* limitations under the License.
 */
package org.gradle.api.internal;

import org.gradle.internal.reflect.Instantiator;

public class TestContainer extends AbstractNamedDomainObjectContainer<TestObject> {

    public TestContainer(org.gradle.internal.reflect.Instantiator instantiator) {
        super(TestObject.class, instantiator, new DynamicPropertyNamer(), CollectionCallbackActionDecorator.NOOP);
    }

    }

    def "chained lookup of testContainer.withType.matching"() {
        buildFile << """
            testContainer.withType(testContainer.type).matching({ it.name.endsWith("foo") }).all { element ->
                assert element.name in ['foo', 'barfoo']
            }

            testContainer.register("foo")
            testContainer.register("bar")
            testContainer.register("foobar")

                testContainer.create("afterEvaluate")
            }

            project(':nested').beforeEvaluate {
                testContainer.create("beforeEvaluate")
            }

            task verify {
                doLast {
                    assert testContainer.findByName("afterEvaluate") != null
                    assert testContainer.findByName("beforeEvaluate") != null
                }

            def factory = { name -> new Impl(name) }
            def testContainer = project.container(PubType, factory)

            testContainer.create("foo")
            testContainer.register("bar")
            testContainer.register("baz").get()

            task assertSchema {
                doLast {
                    assertSchemaIs(testContainer,
                        "foo": "PubType",

		fakeSandBoxConfig, _ := m.generatePodSandboxConfig(testPod, 0)
		testContainer.Lifecycle = cmdPostStart
		fakePodStatus := &kubecontainer.PodStatus{
			ContainerStatuses: []*kubecontainer.Status{
				{
					ID: kubecontainer.ContainerID{
						Type: "docker",
						ID:   testContainer.Name,
					},
					Name:      testContainer.Name,
					State:     kubecontainer.ContainerStateCreated,

	for desc, tc := range map[string]struct {
		testContainer        v1.Container
		expectedResizePolicy []v1.ContainerResizePolicy
	}{
		"CPU and memory limits are specified": {
			testContainer: v1.Container{
				Resources: v1.ResourceRequirements{
					Limits: v1.ResourceList{
						v1.ResourceCPU:    resource.MustParse("100m"),

func TestEvictonMessageWithResourceResize(t *testing.T) {
	testpod := newPod("testpod", 1, []v1.Container{
		newContainer("testcontainer", newResourceList("", "200Mi", ""), newResourceList("", "", "")),
	}, nil)
	testpod.Status = v1.PodStatus{
		ContainerStatuses: []v1.ContainerStatus{
			{
				Name:               "testcontainer",
				AllocatedResources: newResourceList("", "100Mi", ""),
			},
		},
	}

	testPod1 := makePod("fakePod", "fakeContainer", "2", "2")
	testContainer1 := &testPod1.Spec.Containers[0]
	testPod2 := makePod("fakePod", "fakeContainer", "5", "5")
	testContainer2 := &testPod2.Spec.Containers[0]
	testPod3 := makePod("fakePod", "fakeContainer", "7", "7")
	testContainer3 := &testPod3.Spec.Containers[0]
	testPod4 := makePod("fakePod", "fakeContainer", "11", "11")
	testContainer4 := &testPod4.Spec.Containers[0]

	featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.InPlacePodVerticalScaling, true)
	nowTime := time.Now()
	testContainerName := "ctr0"
	testContainerID := kubecontainer.ContainerID{Type: "test", ID: testContainerName}
	testContainer := v1.Container{
		Name:  testContainerName,
		Image: "img",
	}
	testContainerStatus := v1.ContainerStatus{
		Name: testContainerName,
	}

import org.mockserver.model.HttpResponse.response
import org.testcontainers.containers.GenericContainer
import org.testcontainers.containers.MockServerContainer
import org.testcontainers.containers.Network
import org.testcontainers.junit.jupiter.Container
import org.testcontainers.junit.jupiter.Testcontainers
import org.testcontainers.utility.DockerImageName

@Testcontainers
class SocksProxyTest {
  val network: Network = Network.newNetwork()