static void beforeBuild(File workingDir) {
        workingDir.listFiles().findAll { new File(it, "settings.gradle").exists() }.forEach { projectDir ->
            // Workaround for Android Gradle plugin checking for the presence of these directories at configuration time,
            // which invalidates configuration cache if their presence changes. Create these directories before the first build.

// errorcheck

// Copyright 2020 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Basic type parameter list type-checking (not syntax) errors.

package tparam1

// The predeclared identifier "any" may be used in place of interface{}.
var _ any

func _(_ any)

type _[_ any] struct{}

const N = 10

type (

// license that can be found in the LICENSE file.

// Issue 20298: "imported and not used" error report order was non-deterministic.
// This test works by limiting the number of errors (-e=0)
// and checking that the errors are all at the beginning.

package p

import (
	"bufio"       // ERROR "imported and not used"
	"bytes"       // ERROR "imported and not used"
	"crypto/x509" // ERROR "imported and not used"

	Col1  uint16 // Column number for block end.
	Stmts uint16 // Number of statements included in this block.
}

var cover Cover

// Cover records information about test coverage checking.
// NOTE: This struct is internal to the testing infrastructure and may change.
// It is not covered (yet) by the Go 1 compatibility guidelines.
type Cover struct {
	Mode            string

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package p

// The parser no longer parses type parameters for methods.
// In the past, type checking the code below led to a crash (#50427).

type T interface{ m[ /* ERROR "must have no type parameters" */ P any]() }

func _(t T) {

WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

// Package healthz implements basic http server health checking.
// Usage:
//
//	import "k8s.io/apiserver/pkg/server/healthz"
//	healthz.InstallHandler(mux)

*/
import "C"

import (
	"testing"
	"unsafe"
)

func test42018(t *testing.T) {
	// Test that Windows handles are marked go:notinheap, by growing the
	// stack and checking for pointer adjustments. Trick from
	// test/fixedbugs/issue40954.go.
	var i int
	handle := C.HANDLE(unsafe.Pointer(uintptr(unsafe.Pointer(&i))))
	recurseHANDLE(100, handle, uintptr(unsafe.Pointer(&i)))

	"runtime"
	"testing"

	. "cmd/compile/internal/types2"
)

// BenchmarkLookupFieldOrMethod measures types.LookupFieldOrMethod performance.
// LookupFieldOrMethod is a performance hotspot for both type-checking and
// external API calls.
func BenchmarkLookupFieldOrMethod(b *testing.B) {
	// Choose an arbitrary, large package.
	path := filepath.Join(runtime.GOROOT(), "src", "net", "http")

	files, err := pkgFiles(path)

import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.ElementType.TYPE;

import java.lang.annotation.Target;

/**
 * Disables Animal Sniffer's checking of compatibility with older versions of Java/Android.
 *
 * <p>Each package's copy of this annotation needs to be listed in our {@code pom.xml}.
 */
@Target({METHOD, CONSTRUCTOR, TYPE})
@ElementTypesAreNonnullByDefault

 * limitations under the License.
 */

package gradlebuild.integrationtests.tasks

import org.gradle.api.tasks.CacheableTask


/**
 * A test that provides an IDE as environment for checking IDE and Gradle behavior during synchronization process.
 * These tests are running using `forking` executor, since current Gradle distribution has to be used as a Gradle version for IDE.
 */
@CacheableTask