},
						},
					},
				},
			},
			expect: sets.String{}.InsertAll("ingress/bar", "ingress/mock"),
		},
	}

	for _, testCase := range testCases {
		t.Run(testCase.name, func(t *testing.T) {
			if !testCase.expect.Equals(extractServicesByPortNameType(&testCase.input)) {
				t.Fatal("should be equal.")
			}
		})
	}
}

func TestExtractPorts(t *testing.T) {
	ports := []corev1.ServicePort{

	var usecases = []struct {
		name      string
		runner    Runner
		testCases map[string]argTest
		cmd       *cobra.Command
	}{
		{
			name: "leaf command, no defined args, follow parent",
			runner: Runner{
				Phases: []Phase{phaseBuilder("foo")},
			},
			testCases: map[string]argTest{
				"phase foo": {
					pass: []string{"one", "two", "three"},

	if err != nil {
		t.Fatal(err)
	}

	testCases := []sets.String{
		sets.NewString(),
		sets.NewString("192.168.1.1"),
		sets.NewString("192.168.1.1", "192.168.1.254"),
		sets.NewString("192.168.1.1", "192.168.1.128", "192.168.1.254"),
	}

	for i, tc := range testCases {
		r, err := NewInMemory(cidr)
		if err != nil {
			t.Fatal(err)
		}

    private void runMultiTestCase ( List<? extends MultiTestCase> testcases, int timeoutSecs ) throws InterruptedException {
        for ( Runnable r : testcases ) {
            this.executor.submit(r);
        }
        this.executor.shutdown();
        this.executor.awaitTermination(timeoutSecs, TimeUnit.SECONDS);
        for ( MultiTestCase r : testcases ) {
            assertTrue("Have not completed", r.completed);
        }

	_, cidr, err := netutils.ParseCIDRSloppy("192.168.1.0/24")
	if err != nil {
		t.Fatal(err)
	}
	testCases := []sets.String{
		sets.NewString(),
		sets.NewString("192.168.1.1"),
		sets.NewString("192.168.1.1", "192.168.1.254"),
		sets.NewString("192.168.1.1", "192.168.1.128", "192.168.1.254"),
	}

	for i, tc := range testCases {
		r, err := newTestAllocator(cidr)
		if err != nil {
			t.Fatal(err)
		}

			ingressutil.CreateIngressKubeSecret(t, fakeCredName, ingressutil.TLS, CredentialB, false)

			// Set up Host Namespace
			host := apps.External.All.Config().ClusterLocalFQDN()

			testCases := []struct {
				name            string
				statusCode      int
				credentialToUse string
				useGateway      bool
			}{
				// Use CA certificate stored as k8s secret with the same issuing CA as server's CA.

	// Subsequently deleting fileInfos[6].versionID should return fileInfos[6].dataDir since there are no other object versions sharing this data dir.
	count := len(testCases)
	for i := 4; i < len(testCases); i++ {
		tc := testCases[i]
		dataDir, err := xl.DeleteVersion(fileInfos[i])
		failOnErr(count+1, err)
		if dataDir != tc.expectedDataDir {
			t.Fatalf("Expected %s but got %s", tc.expectedDataDir, dataDir)
		}

	podapi "k8s.io/kubernetes/pkg/api/pod"
	api "k8s.io/kubernetes/pkg/apis/core"
	"k8s.io/kubernetes/pkg/apis/policy"
	"k8s.io/kubernetes/pkg/features"
)

func TestEviction(t *testing.T) {
	testcases := []struct {
		name     string
		pdbs     []runtime.Object
		policies []*policyv1.UnhealthyPodEvictionPolicyType
		eviction *policy.Eviction

		badNameInURL bool

		expectError   string
		expectDeleted bool

		var saDeletedErr, deletedErr string
		if deletionTestCase.expectErr {
			saDeletedErr = "service account ns/saname has been deleted"
			deletedErr = "service account token has been invalidated"
		}

		testcases = append(testcases,
			claimTestCase{
				name:      deletionTestCase.name + " serviceaccount",
				getter:    fakeGetter{deletedServiceAccount, nil, nil, nil},

	defer cleanup(t, m)
	featuregatetesting.SetFeatureGateDuringTest(t, utilfeature.DefaultFeatureGate, features.SidecarContainers, true)
	if err := expectProbes(m, nil); err != nil {
		t.Error(err)
	}

	testCases := []struct {
		desc                    string
		probePaths              []probeKey
		enableSidecarContainers bool
	}{
		{
			desc:                    "pod with sidecar (no sidecar containers feature enabled)",