releaseBinary.assertExists()
        releaseBinary.exec().out == app.withFeatureEnabled().expectedOutput
        installation("build/install/main/release").exec().out == app.withFeatureEnabled().expectedOutput
        releaseBinary.assertHasStrippedDebugSymbolsFor(['main.o', 'greeter.o'])

        succeeds "assembleDebug"

			}

			var output, expectedOutput bytes.Buffer

			if err = i.Run(&output, printer); err != nil {
				t.Fatalf("did not expect an error running the Images command: %v", err)
			}

			tmpl, err := template.New("test").Parse(tc.expectedOutput)
			if err != nil {
				t.Fatalf("could not create template: %v", err)
			}
			if err = tmpl.Execute(&expectedOutput, versionMapping); err != nil {

        public ExecutionResult assertOutputEquals(String expectedOutput, boolean ignoreExtraLines, boolean ignoreLineOrder) {
            outputResult.assertOutputEquals(expectedOutput, ignoreExtraLines, ignoreLineOrder);
            return this;
        }

        @Override
        public ExecutionResult assertNotOutput(String expectedOutput) {
            outputResult.assertNotOutput(expectedOutput);
            return this;
        }

	tests := []struct {
		name           string
		input          string
		expectedOutput string
		expectedError  bool
	}{
		{
			name:           "empty input",
			input:          "",
			expectedOutput: "",
			expectedError:  true,
		},
		{
			name:           "label as input",
			input:          "stable",
			expectedOutput: normalizedBuildVersion(constants.DefaultKubernetesPlaceholderVersion.String()),

	}
	if fs.Output() != expectedOutput {
		t.Errorf("unexpected output: got %#v, expected %#v", fs.Output(), expectedOutput)
	}

	expectedName = "gopher"
	expectedErrorHandling = ExitOnError
	expectedOutput = os.Stdout
	fs.Init(expectedName, expectedErrorHandling)
	fs.SetOutput(expectedOutput)

	if fs.Name() != expectedName {

                }
            }
        """

        when:
        configurationCacheRun "reader"

        then:
        outputContains expectedOutput

        where:
        type                             | tasksInput             | expectedOutput
        "Task"                           | "copy1.get()"          | "[copy1]"
        "TaskProvider"                   | "copy1"                | "[copy1]"

            collectOutputs(build)
            build.forLaunchables(tasks[0]).run()
        }
    }

    private boolean outputContains(String expectedOutput) {
        return stdout.toString().contains(expectedOutput)
    }

    class TestOperationCollector implements ProgressListener {

        List<TestOperationDescriptor> descriptors = []

        @Override

        when:
        withBuildCache().run "weirdOutput"
        then:
        executedAndNotSkipped ":weirdOutput"
        expectedOutput.file

        when:
        cleanBuildDir()
        withBuildCache().run "weirdOutput"
        then:
        skipped ":weirdOutput"
        expectedOutput.file
    }

    def "local state declared via #api API is destroyed when task is loaded from cache"() {