collisionCount     *int32
		expectedErr        bool
	}{{
		name:            "valid status",
		replicas:        3,
		readyReplicas:   3,
		currentReplicas: 2,
		updatedReplicas: 1,
		expectedErr:     false,
	}, {
		name:            "invalid replicas",
		replicas:        -1,
		readyReplicas:   3,
		currentReplicas: 2,
		updatedReplicas: 1,
		expectedErr:     true,
	}, {

						},
					},
				},
				expectedErr: true,
			},
			{
				pod: &v1.Pod{
					ObjectMeta: metav1.ObjectMeta{
						Name:      "pod4",
						Namespace: "default",
					},
					Spec: v1.PodSpec{},
				},
				expectedErr: true,
			},
		}

		for _, test := range tests {
			got, err := GetTargetNodeName(test.pod)
			if test.expectedErr != (err != nil) {

		skipKubeConfig       string
		expectedErr          bool
		manifestShouldChange bool
	}{
		{
			description: "error-free case should succeed",
			waitErrsToReturn: map[string]error{
				waitForHashes:        nil,
				waitForHashChange:    nil,
				waitForPodsWithLabel: nil,
			},
			moveFileFunc:         os.Rename,
			expectedErr:          false,
			manifestShouldChange: true,
		},
		{

		// regular errors return errors but do not retry
		{name: "404 doesnt retry", attr: aliceAttr, allow: false, statusCode: 404, expectedErr: true, expectedAuthorized: false, expectedCalls: 1},
		{name: "403 doesnt retry", attr: aliceAttr, allow: false, statusCode: 403, expectedErr: true, expectedAuthorized: false, expectedCalls: 1},

		allowDeprecated   bool
		allowExperimental bool
		expectedErr       bool
	}{
		{
			gv: schema.GroupVersion{
				Group:   KubeadmGroupName,
				Version: "v1alpha1",
			},
			expectedErr: true,
		},
		{
			gv: schema.GroupVersion{
				Group:   KubeadmGroupName,
				Version: "v1alpha2",
			},
			expectedErr: true,
		},
		{
			gv: schema.GroupVersion{
				Group:   KubeadmGroupName,

			err := EnhanceListError(tt.err, tt.opts, tt.subj)
			if err == nil {
				t.Errorf("EnhanceListError did not return an error")
			}
			if err.Error() != tt.expectedErr {
				t.Errorf("EnhanceListError() error = %q, expectedErr %q", err, tt.expectedErr)
			}
			if tt.expectStatusErr {
				if _, ok := err.(*apierrors.StatusError); !ok {
					t.Errorf("EnhanceListError incorrectly returned a non-StatusError: %v", err)
				}

		token, rest := consumeToken(test[0])
		expectedToken := test[1]
		expectedRest := test[2]
		if token != expectedToken {
			t.Errorf("expected to consume token '%s', not '%s' from '%s'",
				expectedToken, token, test[0])
		} else if rest != expectedRest {
			t.Errorf("expected to have left '%s', not '%s' after reading token '%s' from '%s'",
				expectedRest, rest, token, test[0])
		}
	}
}

func TestConsumeValue(t *testing.T) {

        outputs.stdOut.contains('USAGE: gradle-app [option...] [task...]')
    }

    def "displays version message"() {
        def version = DefaultGradleVersion.current()
        def expectedText = [
                "",
                "------------------------------------------------------------",
                "Gradle ${version.version}",

		},
	}
	for testName, testCase := range testCases {
		actualSet := ToSet(ResourceNames(testCase.a))
		expectedSet := ToSet(testCase.expected)
		if !actualSet.Equal(expectedSet) {
			t.Errorf("%s expected: %v, actual: %v", testName, expectedSet, actualSet)
		}
	}
}

func TestContains(t *testing.T) {
	testCases := map[string]struct {
		a        []corev1.ResourceName

				}
			}
			if err == nil || tc.expectedErr == nil {
				if err != nil || tc.expectedErr != nil {
					t.Fatalf("expected err: %v, got err: %v", tc.expectedErr, err)
				}
			} else if err.Error() != tc.expectedErr.Error() {
				t.Fatalf("expected err: \n%v\n got err: \n%v\n", tc.expectedErr, err)
			}
		})
	}

}

type dummyAdmissionImpl struct{}