t.Fatalf("failure while running executable: %s\n%s", err, out)
	}
	var expectedOutput string
	if runtime.GOARCH == "arm64" || runtime.GOARCH == "arm" {
		// TODO: remove when windows/arm64 and windows/arm support SEH stack unwinding.
		expectedOutput = "exceptionCount: 1\ncontinueCount: 1\nunhandledCount: 0\n"
	} else {
		expectedOutput = "exceptionCount: 1\ncontinueCount: 1\nunhandledCount: 1\n"
	}
	// cleaning output

    def setup() {
        settingsFile << "rootProject.name = 'test'"
    }

    boolean outputMatches(String expectedOutput) {
        def actualOutput = result.groupedOutput.task(":components").output
        assert removeDownloadMessageAndEmptyLines(actualOutput) == expected(expectedOutput)
        return true
    }

    String removeDownloadMessageAndEmptyLines(String output) {

        when:
        run "mainExecutable"

        then:
        def mainExecutable = executable("build/exe/main/main")
        mainExecutable.assertExists()
        mainExecutable.exec().out == helloWorldApp.expectedOutput(toolChain)

        cleanup:
        toolChain.resetEnvironment()
    }

    @ToBeFixedForConfigurationCache
    def "uses correct tool chain when explicitly configured"() {
        given:

  }

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

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

  }

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

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

  }

  private static void testReverse(double[] input, double[] expectedOutput) {
    input = Arrays.copyOf(input, input.length);
    Doubles.reverse(input);
    assertThat(input).isEqualTo(expectedOutput);
  }

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

  }

  private static void testReverse(int[] input, int[] expectedOutput) {
    input = Arrays.copyOf(input, input.length);
    Ints.reverse(input);
    assertThat(input).isEqualTo(expectedOutput);
  }

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

  }

  private static void testReverse(long[] input, long[] expectedOutput) {
    input = Arrays.copyOf(input, input.length);
    Longs.reverse(input);
    assertThat(input).isEqualTo(expectedOutput);
  }

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

  }

  private static void testReverse(short[] input, short[] expectedOutput) {
    input = Arrays.copyOf(input, input.length);
    Shorts.reverse(input);
    assertThat(input).isEqualTo(expectedOutput);
  }

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

        result.assertTasksSkipped(tasks.debug.allToInstall, ":assemble")

        executable("build/exe/main/debug/app").assertExists()
        installation("build/install/main/debug").exec().out == app.expectedOutput

        and:
        succeeds "assembleRelease"
        result.assertTasksExecuted(tasks.release.allToInstall, tasks.release.extract, ":assembleRelease")