var candidate = PsiTreeUtil.findElementOfClassAtOffset(mainFile, textRange.startOffset, KtExpression::class.java, true)
            ?: error("Cannot find a starting element in range $textRange")

        while (true) {
            val parent = candidate.parent
            if (parent is KtExpression && parent.textRange in textRange && parent.startOffset == candidate.startOffset) {

        if(parentFolder == null || !parentFolder.exists()) {
            Exception cause = new NoSuchFileException(javaCommand);
            throw new ExecException("A problem occurred starting process 'command '" + javaCommand + "''", cause);
        }
        return getVersionFromJavaHome(parentFolder.getParentFile());
    }

    private int getVersionFromJavaHome(File javaHome) {

        return new DeprecationTimeline("This will change in %s.", version);
    }

    static DeprecationTimeline startingWithVersion(GradleVersion version, String message) {
        return new DeprecationTimeline("Starting with %s, %s.", version, message);
    }

    @Override
    public String toString() {
        return message == null ? String.format(messagePattern, targetVersion) : String.format(messagePattern, targetVersion, message);

    }

    def "connecting streams is required initially"() {
        expect:
        illegalStateReportedWhen { consumer.start() }
        illegalStateReportedWhen { consumer.processOutput }
    }

    def "starting is required"() {
        when:
        consumer.connectStreams(process(""), "cool process", executor)

        then:
        illegalStateReportedWhen { consumer.processOutput }
    }

    /**
     * Common interface for tracked access to system properties and environment variables.
     */
    interface Properties {
        /**
         * Selects the properties that have a name longer than and starting with the given prefix.
         *
         * The returned map keys still contain the prefix.
         *
         * @return a map containing only the properties whose name start with the given prefix.
         */

  queue: TaskQueue,
  block: () -> T,
): T {
  var startNs = -1L
  val loggingEnabled = isLoggable(Level.FINE)
  if (loggingEnabled) {
    startNs = queue.taskRunner.backend.nanoTime()
    log(task, queue, "starting")
  }

  var completedNormally = false
  try {
    val result = block()
    completedNormally = true
    return result
  } finally {
    if (loggingEnabled) {

	rm -rf /tmp/siteb
	echo "done"
}

cleanup

export MINIO_CI_CD=1
export MINIO_BROWSER=off
export MINIO_ROOT_USER="minio"
export MINIO_ROOT_PASSWORD="minio123"

# Start MinIO instances
echo -n "Starting MinIO instances ..."
minio server --address ":9001" --console-address ":10000" /tmp/sitea/{1...4}/disk{1...4} /tmp/sitea/{5...8}/disk{1...4} >/tmp/sitea_1.log 2>&1 &

// respective 64 bit atomic instructions are not available
// on all platforms.
var lastID atomic.Uint32

// nextID returns a value increasing monotonically by 1 with
// each call, starting with 1. It may be called concurrently.
func nextID() uint64 { return uint64(lastID.Add(1)) }

// A TypeParam represents a type parameter type.
type TypeParam struct {
	check *Checker  // for lazy type bound completion

	if re.prog.Inst[pc].Op != syntax.InstFail && (arg || b.shouldVisit(pc, pos)) {
		b.jobs = append(b.jobs, job{pc: pc, arg: arg, pos: pos})
	}
}

// tryBacktrack runs a backtracking search starting at pos.
func (re *Regexp) tryBacktrack(b *bitState, i input, pc uint32, pos int) bool {
	longest := re.longest

	b.push(re, pc, pos, false)
	for len(b.jobs) > 0 {
		l := len(b.jobs) - 1

        this.mvn = findMvnExecutable(home)
    }

    static File findMvnExecutable(File home) {
        def bin = new File(home, "bin")
        if (IS_WINDOWS) {
            // Maven moved from .bat to .cmd starting with 3.3.1 (3.3.0 was canceled)
            def bat = new File(bin, "mvn.bat")
            return bat.isFile() ? bat : new File(bin, "mvn.cmd")
        }
        return new File(bin, "mvn")
    }