when:
        withIsolatedProjects()
        runBuildActionFails(new FailingBuildAction())

        then:
        fixture.assertNoConfigurationCache()
        failureDescriptionContains("Build action expectedly failed")

        // TODO:isolated should not contain this output https://github.com/gradle/gradle/issues/27476
        failure.assertOutputContains("Configuration cache entry stored.")
    }

    GraphDef expected_graph_def;
    Scope expected_scope = Scope::NewRootScope();
    Output expected_a = ops::Const(expected_scope.WithOpName("a"), 10.0f, {});
    Output expected_b = ops::Const(expected_scope.WithOpName("b"), 10.0f, {});
    Output expected_c =
        ops::Mul(expected_scope.WithOpName("c"), expected_a, expected_b);
    TF_ASSERT_OK(expected_scope.ToGraphDef(&expected_graph_def));

				}
			}

			val, err := test.externalCAFunc(&cfg.ClusterConfiguration)
			if val != test.expected {
				t.Errorf("UsingExternalCA did not match expected: %v", test.expected)
			}

			if (err != nil) != test.expectedErr {
				t.Errorf("UsingExternalCA returned un expected err: %v", err)
			}
		})
	}
}

func TestValidateMethods(t *testing.T) {

        }
        def expectedGradleOps = [
            expectedOp('Gradle.afterProject', 'gradle.afterProject(Action)'),
            expectedOp('Gradle.afterProject', 'gradle.afterProject(Closure(0))'),
            expectedOp('Gradle.afterProject', 'gradle.afterProject(Closure(1))'),
            expectedOp('Gradle.afterProject', 'gradle.afterProject(Closure(2))'),
            expectedOp('Gradle.addListener', 'gradle.addListener(ProjectEvaluationListener)'),

			expectedOK: false,
		},
		{
			fieldPath:  "metadata.labels['key']foo",
			expectedOK: false,
		},
		{
			fieldPath:  "['key']",
			expectedOK: false,
		},
		{
			fieldPath:  "metadata.labels",
			expectedOK: false,
		},
	}
	for _, tc := range cases {
		path, subscript, ok := SplitMaybeSubscriptedPath(tc.fieldPath)
		if !ok {
			if tc.expectedOK {

			expectedKey:       "/cluster-signing-key",
		},
		{
			name:              "specifiedOnly-KubeletServingSignerFilesSpecified",
			config:            specifiedOnly,
			specifiedFn:       areKubeletServingSignerFilesSpecified,
			expectedSpecified: true,
			filesFn:           getKubeletServingSignerFiles,
			expectedCert:      "/cluster-signing-kubelet-serving/cert-file",

			manifestsDir:  "/etc/bar/",
			expected:      "/etc/bar/foo.yaml",
		},
	}
	for _, rt := range tests {
		t.Run(rt.componentName, func(t *testing.T) {
			actual := GetStaticPodFilepath(rt.componentName, rt.manifestsDir)
			expected := filepath.FromSlash(rt.expected)
			if actual != expected {
				t.Errorf(
					"failed GetStaticPodFilepath:\n\texpected: %s\n\t  actual: %s",
					rt.expected,
					actual,
				)
			}
		})

			Namespace: namespace,
		},
		Data: data,
	}
}

func checkActions(actual, expected []ktesting.Action) error {
	if len(actual) != len(expected) {
		return fmt.Errorf("unexpected number of actions, want %d but got %d, %v", len(expected), len(actual), actual)
	}

	for i, action := range actual {
		expectedAction := expected[i]
		verb := expectedAction.GetVerb()
		resource := expectedAction.GetResource().Resource

			},
		},
	}

	for _, podIn := range podsIn {
		expected := podStart
		expected.ResourceVersion = "2"
		grace := int64(30)
		enableServiceLinks := v1.DefaultEnableServiceLinks
		expected.Spec.TerminationGracePeriodSeconds = &grace
		expected.Spec.RestartPolicy = api.RestartPolicyAlways
		expected.Spec.DNSPolicy = api.DNSClusterFirst
		expected.Spec.EnableServiceLinks = &enableServiceLinks

	} else if expectedKey, _ := controller.KeyFunc(set1); expectedKey != key {
		t.Errorf("expected StatefulSet key %s found %s", expectedKey, key)
	}
	ssc.queue.Done(key)

	ssc.addPod(logger, pod2)
	key, done = ssc.queue.Get()
	if key == "" || done {
		t.Error("failed to enqueue StatefulSet")
	} else if expectedKey, _ := controller.KeyFunc(set2); expectedKey != key {