succeeds "components"
        then:
        output.contains("""
SampleLibrary 'sampleLib'
-------------------------

Source sets
    Library source 'sampleLib:librarySource'
        srcDir: src${File.separator}sampleLib${File.separator}librarySource

Binaries
    SampleBinary 'sampleLib:binary'
        build using task: :sampleLibBinary
    OtherSampleBinary 'sampleLib:otherBinary'

        kotlinDslPluginsVersion = publishedKotlinDslPluginVersion
    }

    val apiExtensionsFileCollection = files(apiExtensionsOutputDir).builtBy(generateKotlinDependencyExtensions)

    kotlinMainSourceSet.srcDir(apiExtensionsFileCollection)

    // Workaround for https://github.com/gradle/gradle/issues/24131
    // See gradlebuild.unittest-and-compile.gradle.kts

  expand("projectVersion" to "${project.version}")
  filteringCharset = Charsets.UTF_8.toString()
}

kotlin {
  sourceSets {
    val main by getting {
      resources.srcDir(copyResourcesTemplates.get().outputs)
    }
  }
}

dependencies {
  api(libs.kotlin.stdlib)
  api(projects.okhttp)
  api(projects.loggingInterceptor)
  api(libs.squareup.okio)
  implementation(libs.clikt)

        def sources = generatedCode.values().collect {
            new TestClassSource(it.className, it.generatedCode)
        }
        def srcDir = tmpDir.createDir("src")
        def dstDir = tmpDir.createDir("dst")
        SimpleGeneratedJavaClassCompiler.compile(srcDir, dstDir, sources, classPath)
        def cl = new URLClassLoader([dstDir.toURI().toURL()] as URL[], this.class.classLoader)

	if str.HasFilePathPrefix(filepath.Clean(srcDir), filepath.Clean(parent)) {
		return nil
	}

	// Look for symlinks before reporting error.
	srcDir = expandPath(srcDir)
	parent = expandPath(parent)
	if str.HasFilePathPrefix(filepath.Clean(srcDir), filepath.Clean(parent)) {
		return nil
	}

	// Vendor is present, and srcDir is outside parent's tree. Not allowed.

                cpp.lib library: 'lib1', linkage: 'api'
            }
            binaries.all {
                sources {
                    other(CppSourceSet) {
                        source.srcDir "src/main/otherCpp"
                        lib library: 'lib2', linkage: 'api'
                    }
                }
            }
        }
    }
}
"""

        when:

		t.Logf("%s", out)
		t.Fatalf("go tool compile %s failed: %s", filename, err)
	}
	return outname
}

func testPath(t *testing.T, path, srcDir string) *types.Package {
	t0 := time.Now()
	fset := token.NewFileSet()
	pkg, err := Import(fset, make(map[string]*types.Package), path, srcDir, nil)
	if err != nil {
		t.Errorf("testPath(%s): %s", path, err)
		return nil
	}
	t.Logf("testPath(%s): %v", path, time.Since(t0))
	return pkg

	}

	tmpPath := t.TempDir()

	dir := filepath.Join(tmpPath, "src", "testpositions")
	if err := os.MkdirAll(dir, 0755); err != nil {
		t.Fatal(err)
	}

	cmd := exec.Command("go", "tool", "cgo",
		"-srcdir", testdata,
		"-objdir", dir,
		"issue42580.go")
	cmd.Stderr = new(bytes.Buffer)

	err = cmd.Run()
	if err != nil {
		t.Fatalf("%s: %v\n%s", cmd, err, cmd.Stderr)
	}

	"go/token"
	"internal/diff"
	"os"
	"path/filepath"
	"runtime"
	"strings"
	"testing"
)

var filesToWrite = flag.String("write", "", `go/types files to generate, or "all" for all files`)

const (
	srcDir = "/src/cmd/compile/internal/types2/"
	dstDir = "/src/go/types/"
)

// TestGenerate verifies that generated files in go/types match their types2
// counterpart. If -write is set, this test actually writes the expected

                }
            }
        }
    }

    private
    fun zip(destZip: File, srcDir: File) {
        val srcPath = srcDir.toPath()
        Files.walk(srcPath).use { paths ->
            zip(destZip,
                paths.filter { Files.isRegularFile(it, LinkOption.NOFOLLOW_LINKS) }