stage('Build / Unit Test') {
            String jdkName = jenkinsEnv.jdkFromVersion(buildOs, buildJdk)
            String mvnName = jenkinsEnv.mvnFromVersion(buildOs, buildMvn)
            try {
                withEnv(["JAVA_HOME=${ tool "$jdkName" }",
                         "PATH+MAVEN=${ tool "$jdkName" }/bin:${tool "$mvnName"}/bin",
                         "MAVEN_OPTS=-Xms2g -Xmx4g -Djava.awt.headless=true"]) {                   

 * A stateful “backing” for a compilation operation.
 * <p>
 * The compilation may extract data from the source under compilation, made available after compilation by {@link #getExtractedData()}.
 * The exposed transformer typically gathers the data while transforming.
 * <p>
 * As these objects are stateful, they can only be used for a single compile operation.
 *
 * @param <T> the type of data extracted by this operation
 */

import javax.annotation.CheckReturnValue;
import java.io.File;
import java.util.Collection;
import java.util.List;

/**
 * <p>
 * Responsible for updating the file watchers based on changes to the contents of the virtual file system,
 * and changes to the file system hierarchies we are allowed to watch.</p>
 *
 * <p>
 * The following terms are worth distinguishing between:
 * </p>
 *

	return &cbc{
		b:         b,
		blockSize: b.BlockSize(),
		iv:        bytes.Clone(iv),
		tmp:       make([]byte, b.BlockSize()),
	}
}

type cbcEncrypter cbc

// cbcEncAble is an interface implemented by ciphers that have a specific
// optimized implementation of CBC encryption, like crypto/aes.
// NewCBCEncrypter will check for this interface and return the specific
// BlockMode if found.
type cbcEncAble interface {

        }
        result
    }

    @CompileDynamic
    private OutputScrapingExecutionResult executeInContainer() {
        def invocation = buildInvocation()
        container.withEnv(invocation.environmentVars.collectEntries { k, v -> [k, v]})
        def containerResult = container.execute(["/gradle-under-test/bin/gradle", *invocation.args] as String[])
        def result

// Option is a functional option for remote operations.
type Option func(*options) error

type options struct {
	args       map[string]string
	ignoreRuns bool
	baseDir    string
}

// WithArgs sets the input args to the dockerfile
func WithArgs(a map[string]string) Option {
	return func(o *options) error {
		o.args = a
		return nil
	}
}

// IgnoreRuns tells the parser to ignore RUN statements rather than failing

  // TODO: Test blocking to re-enter monitor after being signaled.
  // TODO: Test interrupts with both interruptible and uninterruptible monitor.
  // TODO: Test multiple waiters: If guard is still satisfied, signal next waiter.
  // TODO: Test multiple waiters: If guard is no longer satisfied, do not signal next waiter.

  // TODO: Test blocking to re-enter monitor after being signaled.
  // TODO: Test interrupts with both interruptible and uninterruptible monitor.
  // TODO: Test multiple waiters: If guard is still satisfied, signal next waiter.
  // TODO: Test multiple waiters: If guard is no longer satisfied, do not signal next waiter.

        buildTriggeredAndFailed()
        executedAndNotSkipped ":compileJava"
    }

    @Requires(UnitTestPreconditions.NotLinux)
    def "creation of initial source file triggers build for hierarchical watchers"() {
        expect:
        succeeds("build")
        skipped(":compileJava")
        executed(":build")

        when:
        file("src/main/java/Thing.java") << "class Thing {}"

        then:

    }

    interface IVCollector {
        void collect(byte[] toCollect) throws IOException;
    }

    /**
     * Combines an algorithm and a key, and allows obtaining encryption/decryption ciphers according to those.
     */
    interface Session {
        SecretKey getKey();
        EncryptionAlgorithm getAlgorithm();
        Cipher encryptingCipher(IVCollector collector);