func NewMockPodManager(ctrl *gomock.Controller) *MockPodManager {
	mock := &MockPodManager{ctrl: ctrl}
	mock.recorder = &MockPodManagerMockRecorder{mock}
	return mock
}

// EXPECT returns an object that allows the caller to indicate expected use.
func (m *MockPodManager) EXPECT() *MockPodManagerMockRecorder {
	return m.recorder
}

// GetMirrorPodByPod mocks base method.

    }
}

@RequiresOptIn("Analysis should not be allowed to be run from the EDT, as otherwise it may cause IDE freezes.")
public annotation class KaAllowAnalysisOnEdt

/**
 * Allows [analyze][org.jetbrains.kotlin.analysis.api.analyze] to be called on the EDT in the given [action], which is normally not allowed.
 *
 * Analysis is not supposed to be invoked from the EDT, as it may cause freezes. Use at your own risk!

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.test.fixtures;

/**
 * Allows {@link org.gradle.integtests.fixtures.ToBeFixedForConfigurationCacheExtension} to verify
 * test expectations before cleanup so they can be silenced if necessary.
 */
public interface ResettableExpectations {
    /**

 the project level, and the user level. On the site level you can configure maven for all users
 utilizing the local installation, the group level allows configuration management for all the projects
 that belong to the same group, the project level allows configuration management at
 the project level, and the user level allows users to override settings on
 the site level, group level and project level.

* Site configuration

/**
 * A service that provides the plugin service for the current build invocation.
 *
 * The plugin uses this to encapsulate its service in user facing code that may be cached.
 * This allows such cached code to use the plugin service for the current build when used from-cache.
 */
@ServiceScope(Scope.BuildTree.class)
public interface GradleEnterprisePluginServiceRef {

    GradleEnterprisePluginService get();

    update-alternatives --set iptables /usr/sbin/iptables-legacy && \
    update-alternatives --set ip6tables /usr/sbin/ip6tables-legacy; fi

# Add a user that will run the application. This allows running as this user and capture iptables
RUN useradd -m --uid 1338 application && \

package pgo

import (
	"bufio"
	"fmt"
	"io"
)

// Serialization of a Profile allows go tool preprofile to construct the edge
// map only once (rather than once per compile process). The compiler processes
// then parse the pre-processed data directly from the serialized format.
//
// The format of the serialized output is as follows.
//
//      GO PREPROFILE V1
//      caller_name
//      callee_name

import org.gradle.internal.properties.InputBehavior;
import org.gradle.internal.service.scopes.Scope.Global;
import org.gradle.internal.service.scopes.ServiceScope;

import java.util.EnumSet;

/**
 * Allows the registration of {@link WorkInputListener work input listeners}.
 */
@ServiceScope(Global.class)
public interface WorkInputListeners {
    /**

  // (and cluster policy otherwise allows the traffic), OR if the traffic source is
  // the pod's local node, OR if the traffic matches at least one ingress rule
  // across all of the NetworkPolicy objects whose podSelector matches the pod. If
  // this field is empty then this NetworkPolicy does not allow any traffic (and serves
  // solely to ensure that the pods it selects are isolated by default)

import java.io.Closeable;
import java.io.File;
import java.util.function.Consumer;

/**
 * A build cache service that is capable of handling local files directly. The direct access
 * allows more optimized implementations than the more general {@link org.gradle.caching.BuildCacheService}
 * interface.
 */
public interface LocalBuildCacheService extends BuildCacheTempFileStore, Closeable {

    /**