}

  private static void testSortDescending(long[] input, long[] expectedOutput) {
    input = Arrays.copyOf(input, input.length);
    UnsignedLongs.sortDescending(input);
    assertThat(input).isEqualTo(expectedOutput);
  }

  private static void testSortDescending(
      long[] input, int fromIndex, int toIndex, long[] expectedOutput) {
    input = Arrays.copyOf(input, input.length);

  }

  private static void testSortDescending(byte[] input, byte[] expectedOutput) {
    input = Arrays.copyOf(input, input.length);
    UnsignedBytes.sortDescending(input);
    assertThat(input).isEqualTo(expectedOutput);
  }

  private static void testSortDescending(
      byte[] input, int fromIndex, int toIndex, byte[] expectedOutput) {
    input = Arrays.copyOf(input, input.length);

	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()),

                "Gradle Test Executor \\d+ -> constructor out",
                "Gradle Test Executor \\d+ -> constructor err"
            )
        }

        outputContains expectedOutput('The Foo Test')

        /**
         * This test documents the current behavior. It's not right, we're missing a lot of output in the report.
         */

	}
	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 {

        then:
        installation(consumer.file("build/install/main/release")).exec().out == app.withFeatureEnabled().expectedOutput
        def releaseInstall = installation(consumer.file("build/install/main/release"))
        releaseInstall.exec().out == app.withFeatureEnabled().expectedOutput
        releaseInstall.assertIncludesLibraries("greeting")

        resultDebug.assertTasksNotSkipped(':compileDebugSwift', ':linkDebug', ':installDebug', ':_xcode___App_Debug')
        debugBinary.exec().out == app.expectedOutput
        fixture(debugBinary).assertHasDebugSymbolsFor(app.sourceFileNames)

        when:
        releaseBinary.assertDoesNotExist()
        def resultRelease = xcodebuild

        succeeds "assemble"

        then:
        result.assertTasksExecuted(assembleAppTasks)
        result.assertTasksNotSkipped(assembleAppTasks)
        executable("build/exe/main/debug/App").exec().out == app.expectedOutput

        when:
        app.applyChangesToProject(testDirectory)
        succeeds "assemble"

        then:
        result.assertTasksExecuted(assembleAppTasks)

        run("installDebug")

        then:
        def debugInstall = installation(consumer.file("build/install/main/debug"))
        debugInstall.exec().out == app.withFeatureDisabled().expectedOutput
        debugInstall.assertIncludesLibraries("greeting")
        def debugLib = sharedLibrary(producer.file("build/lib/main/debug/shared/greeting"))

                }
            }
        """

        when:
        configurationCacheRun "reader"

        then:
        outputContains expectedOutput

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