} else {
            executable = "${workingDir}/${executable}"
        }
        builder.environment("JAVA_HOME", System.getProperty("java.home"))
        // // https://github.com/gradle/dotcom/issues/6071
        builder.environment("JAVA_OPTS", "")
        return builder.build()
    }

    ExecResult run() {
        return build().start().waitForFinish()
    }

import org.jetbrains.kotlin.types.Variance
import kotlin.collections.single

abstract class AbstractCreateInheritanceTypeSubstitutorTest : AbstractAnalysisApiBasedTest() {
    override fun doTest(testServices: TestServices) {
        val baseClass = testServices.expressionMarkerProvider
            .getElementsOfTypeAtCarets<KtClassOrObject>(testServices, "base")
            .single().first

import org.jetbrains.kotlin.test.services.TestServices
import org.jetbrains.kotlin.test.services.assertions

abstract class AbstractMultiModuleSymbolByPsiTest : AbstractAnalysisApiBasedTest() {
    override fun doTest(testServices: TestServices) {
        val files = testServices.ktTestModuleStructure.allMainKtFiles
        val debugRenderer = DebugSymbolRenderer()

        val debugPrinter = PrettyPrinter()

abstract class AbstractSymbolRestoreFromDifferentModuleTest : AbstractAnalysisApiBasedTest() {
    private val defaultRenderer = KaDeclarationRendererForDebug.WITH_QUALIFIED_NAMES

    override fun doTest(testServices: TestServices) {
        val declaration =
            testServices.expressionMarkerProvider.getElementsOfTypeAtCarets<KtDeclaration>(testServices).single().first

        val restoreAt =

/**
 * Reads through the declarations provided in the .klib and renders their `klibSourceFile`
 */
abstract class AbstractGetKlibSourceFileNameTest : AbstractAnalysisApiBasedTest() {
    override fun doTest(testServices: TestServices) {
        val mainModule = testServices.ktTestModuleStructure.mainModules
            .let { modules -> if (modules.size == 1) modules.first() else fail("Expected single main module. Found $modules") }

  // Converted MHLO ops should be marked illegal here.
  // TODO: b/304003568 - Add TF_TransposeOp folding logic to tflite.
  target.addIllegalOp<mhlo::DotGeneralOp, mhlo::DotOp, mhlo::TransposeOp>();
  if (failed(applyPartialConversion(getOperation(), target,
                                    std::move(patterns)))) {
    getOperation().emitError("mhlo to TFLite legalization failed.");

     * check (see [checkSessionsMarkedInvalid]) and should be skipped.
     */
    protected open fun shouldSkipValidityCheck(session: SESSION): Boolean = false

    override fun doTest(testServices: TestServices) {
        val ktModules = testServices.ktTestModuleStructure.mainModules.map { it.ktModule }

        val sessionsBeforeModification = getSessions(ktModules)

}

// IsAbs returns whether the given path is absolute or not.
// On Windows, filepath.IsAbs will not return True for paths prefixed with a slash, even
// though they can be used as absolute paths (https://docs.microsoft.com/en-us/dotnet/standard/io/file-path-formats).
//
// WARN: It isn't safe to use this for API values which will propagate across systems (e.g. REST API values
// that get validated on Unix, persisted, then consumed by Windows, etc).

		return false
	}
	return IsPathSeparator(path[0])
}

// volumeNameLen returns length of the leading volume name on Windows.
// It returns 0 elsewhere.
//
// See:
// https://learn.microsoft.com/en-us/dotnet/standard/io/file-path-formats
// https://googleprojectzero.blogspot.com/2016/02/the-definitive-guide-on-win32-to-nt.html
func volumeNameLen(path string) int {
	switch {
	case len(path) >= 2 && path[1] == ':':

	ErrRangeLoopReentry

	// ErrSlashAmbig: '/' could start a division or regexp.
	// Example:
	//   <script>
	//     {{if .C}}var x = 1{{end}}
	//     /-{{.N}}/i.test(x) ? doThis : doThat();
	//   </script>
	// Discussion:
	//   The example above could produce `var x = 1/-2/i.test(s)...`
	//   in which the first '/' is a mathematical division operator or it