env.pollForPathExists("/apis/stable.example.com/v1/coolfoos")
	env.pollForPathExists("/apis/stable.example.com/v1/coolbars")
	s := env.fetchOpenAPIOrDie()
	env.expectPath(s, "/apis/stable.example.com/v1/coolfoos")
	env.expectPath(s, "/apis/stable.example.com/v1/coolbars")
	env.expectPath(s, "/apis/apiextensions.k8s.io/v1")
}

func TestCRDMultiVersion(t *testing.T) {
	env, ctx := setup(t)
	env.runFunc()
	defer env.cleanFunc()

        def artifact = artifact(group, module, version)

        expect:
        pattern.getLocation(artifact).path == expectPath

        where:
        group       | module     | version | expectPath
        "group"     | "projectA" | "1.2"   | 'prefix/group/projectA/1.2/ivys/1.2/ivy.xml'
        "org.group" | "projectA" | "1.2"   | 'prefix/org/group/projectA/1.2/ivys/1.2/ivy.xml'

		HTTPClient      *http.Client
		HttpErr         error
		Overwrite       bool
		Object          runtime.Object
		Namespace       string
		NamespaceScoped bool
		Subresource     string

		ExpectPath   string
		ExpectObject runtime.Object
		Err          bool
		Req          func(string, *http.Request) bool
	}{
		{
			Name:            "test1",
			Namespace:       "bar",
			NamespaceScoped: true,

				podDeleted = true
			}
		}
		return podPatched == expectPatch && podDeleted == expectDelete, nil
	})
	if err != nil {
		t.Errorf("Failed waiting for the expected actions: %q", err)
	}
	if podPatched != expectPatch {
		t.Errorf("[%v]Unexpected test result. Expected patch %v, got %v", description, expectPatch, podPatched)
	}
	if podDeleted != expectDelete {

		if test.expectErr && err == nil {
			t.Error("unexpected non-error")
		}
		if !test.expectErr && err != nil {
			t.Errorf("unexpected error: %v", err)
		}
		if data != test.expectData {
			t.Errorf("expected %s, got %s", test.expectData, data)
		}
		if result != test.expectResult {
			t.Errorf("expected %s, got %s", test.expectResult, result)
		}
	}

		fieldSelector fields.Selector
		expectMatch   bool
	}{
		{
			name: "match on name",
			in: &api.Service{
				ObjectMeta: metav1.ObjectMeta{
					Name:      "test",
					Namespace: "testns",
				},
				Spec: api.ServiceSpec{ClusterIP: api.ClusterIPNone},
			},
			fieldSelector: fields.ParseSelectorOrDie("metadata.name=test"),
			expectMatch:   true,
		},
		{
			name: "match on namespace",

		taint        *Taint
		taintToMatch Taint
		expectMatch  bool
	}{
		{
			description: "two taints with the same key,value,effect should match",
			taint: &Taint{
				Key:    "foo",
				Value:  "bar",
				Effect: TaintEffectNoSchedule,
			},
			taintToMatch: Taint{
				Key:    "foo",
				Value:  "bar",
				Effect: TaintEffectNoSchedule,
			},
			expectMatch: true,
		},
		{

		},
		{
			name:        "Nil",
			expectMatch: false,
		},
	}

	for _, tc := range testCases {
		if result := IsRequestEntityTooLargeError(tc.err); result != tc.expectMatch {
			t.Errorf("Expect match %t, got match %t", tc.expectMatch, result)
		}
	}
}

func TestIsUnexpectedServerError(t *testing.T) {
	unexpectedServerErr := func() error {
		return &StatusError{

				TolerationSeconds: &tolerationToMatchSeconds,
			},
			expectMatch: true,
		},
	}

	for _, tc := range testCases {
		if actual := tc.toleration.MatchToleration(tc.tolerationToMatch); actual != tc.expectMatch {
			t.Errorf("[%s] expect: %v , got:  %v", tc.description, tc.expectMatch, !tc.expectMatch)
		}
	}

    equivalenceMock.expectDistinct(group2Item2, group1Item2);
    equivalenceMock.expectEquivalent(group2Item2, group2Item1);

    equivalenceMock.expectHash(group1Item1, 1);
    equivalenceMock.expectHash(group1Item2, 1);
    equivalenceMock.expectHash(group2Item1, 2);
    equivalenceMock.expectHash(group2Item2, 2);

    equivalenceMock.replay();

    tester
        .addEquivalenceGroup(group1Item1, group1Item2)