appObjects.recompiledFiles(appOtherSourceFile, sourceFile)
        libObjects.noneRecompiled()

        and:
        install.exec().out == "Hi world"

        when:
        unused << "broken again"

        then:
        succeeds installApp
        install.exec().out == "Hi world"

        and:
        allSkipped()
    }

    @ToBeFixedForConfigurationCache

	argv0 := argv[0]
	if filepath.Base(argv0) == argv0 {
		argv0, err = exec.LookPath(argv0)
		if err != nil {
			Exitf("cannot find %s: %v", argv[0], err)
		}
	}
	if ctxt.Debugvlog != 0 {
		ctxt.Logf("invoking archiver with syscall.Exec()\n")
	}
	err = syscall.Exec(argv0, argv, os.Environ())
	if err != nil {
		Exitf("running %s failed: %v", argv[0], err)
	}

import org.gradle.internal.invocation.BuildAction;
import org.gradle.internal.logging.LoggingManagerInternal;
import org.gradle.launcher.exec.BuildActionExecutor;
import org.gradle.launcher.exec.BuildActionParameters;
import org.gradle.launcher.exec.BuildActionResult;
import org.gradle.launcher.exec.BuildExecutor;

/**
 * Sets up logging around a session.
 */
public class SetupLoggingActionExecutor implements BuildExecutor {

        new Thread(() -> latch.countDown()).start();
      }

      future.addListener(listenerLatch::countDown, exec);
    }

    assertSame(Boolean.TRUE, future.get());
    // Wait for the listener latch to complete.
    listenerLatch.await(500, MILLISECONDS);

    exec.shutdown();
    exec.awaitTermination(500, MILLISECONDS);
  }

	if err != nil {
		t.Fatal(err)
	}

	// Check that it works as expected.
	_, err = exec.LookPath(path)
	if err != nil {
		t.Fatalf("LookPath: got %v, want nil", err)
	}

	for {
		err = exec.Command(path).Run()
		if err == nil {
			break
		}
		if errors.Is(err, syscall.ETXTBSY) {
			// A fork+exec in another process may be holding open the FD that we used

# run on Unix platforms.

go test -c -o $WORK/some/nonexisting/directory/ ./pkg/...
exists -exec $WORK/some/nonexisting/directory/pkg1.test$GOEXE
exists -exec $WORK/some/nonexisting/directory/pkg2.test$GOEXE

go test -c ./pkg/...
exists -exec pkg1.test$GOEXE
exists -exec pkg2.test$GOEXE

! go test -c -o $WORK/bin/test/bin.test.exe ./pkg/...

}

func parseMobileProvision(fname string) *exec.Cmd {
	return exec.Command("security", "cms", "-D", "-i", string(fname))
}

func plistExtract(fname string, path string) ([]byte, error) {
	out, err := exec.Command("/usr/libexec/PlistBuddy", "-c", "Print "+path, fname).CombinedOutput()
	if err != nil {
		return nil, err
	}
	return bytes.TrimSpace(out), nil
}

func getLines(cmd *exec.Cmd) [][]byte {
	out := output(cmd)

    super.setUp();

    exec = Executors.newCachedThreadPool();

    task.addListener(
        new Runnable() {
          @Override
          public void run() {
            listenerLatch.countDown();
          }
        },
        directExecutor());
  }

  @Override
  protected void tearDown() throws Exception {
    if (exec != null) {
      exec.shutdown();
    }

    super.tearDown();

        if (cur != null) {
            Map<String, PluginExecution> execs = new LinkedHashMap<>();
            cur.getExecutions().forEach(e -> execs.put(e.getId(), e));
            plugin.getExecutions().forEach(e -> {
                int i = 0;
                String id = e.getId();
                while (execs.putIfAbsent(id, e.withId(id)) != null) {
                    id = e.getId() + "-" + (++i);

}

// WithExec sets the Exec field in the declarative configuration to the given value
// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the Exec field is set to the value of the last call.
func (b *LifecycleHandlerApplyConfiguration) WithExec(value *ExecActionApplyConfiguration) *LifecycleHandlerApplyConfiguration {
	b.Exec = value
	return b
}