//   to be observable from other eager configuration blocks (e.g., `subprojects { ... }`).
        // - `lifecycle.beforeProject` executes just before each project is evaluated. Therefore, its effects
        //   are not observable from eager configuration blocks, which would anyway be incompatible with
        //   Isolated Projects.
        if (isIsolatedProjects()) {

    }

    def 'supports correct order of blocks in setttings file if there is #order'() {
        given:
        file("settings.gradle.dcl") << content

        expect:
        succeeds(":projects")
        outputContains("Root project 'test-project'")

        where:
        order                                     | content

        file.text =="""plugins {
            |    id("com.gradle.develocity") version("${VERSION}")
            |}
            |
            |includeBuild '../lib'""".stripMargin()
    }

    def "plugin management block blocks"() {
        given:
        File file = File.createTempFile("test_script", ".tmp")
        file.write("""pluginManagement {
            |    repositories {
            |        gradlePluginPortal()
            |    }

public interface ManagedExecutor extends AsyncStoppable, ExecutorService {
    /**
     * Stops accepting new jobs and blocks until all currently executing jobs have been completed.
     */
    @Override
    void stop();

    /**
     * Stops accepting new jobs and blocks until all currently executing jobs have been completed. Once the given

	exit := gp.coroexit
	gp.coroexit = false
	mp := gp.m

	// Track and validate thread-lock interactions.
	//
	// The rules with thread-lock interactions are simple. When a coro goroutine is switched to,
	// the same thread must be used, and the locked state must match with the thread-lock state of
	// the goroutine which called newcoro. Thread-lock state consists of the thread and the number

	return atomic.Loaduintptr(&l.key) > locked
}

func lock(l *mutex) {
	lockWithRank(l, getLockRank(l))
}

func lock2(l *mutex) {
	gp := getg()
	if gp.m.locks < 0 {
		throw("runtime·lock: lock count")
	}
	gp.m.locks++

	// Speculative grab for lock.
	if atomic.Casuintptr(&l.key, 0, locked) {
		return
	}
	semacreate(gp.m)

	timer := &lockTimer{lock: l}
	timer.begin()

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.function.Supplier;

// TODO Replace the use of this with synchronized caches from Guava
@NonNullApi
public class Synchronizer {

    private final Lock lock = new ReentrantLock();

    public <T> T synchronize(Supplier<T> factory) {
        lock.lock();
        try {
            return factory.get();

// document to standard output.
// It is intended for debugging.
func DumpMarkdown(d *md.Document) {
	dumpBlocks(d.Blocks, 0)
}

func dumpBlocks(bs []md.Block, depth int) {
	for _, b := range bs {
		dumpBlock(b, depth)
	}
}

func dumpBlock(b md.Block, depth int) {
	typeName := strings.TrimPrefix(fmt.Sprintf("%T", b), "*markdown.")
	dprintf(depth, "%s\n", typeName)
	switch b := b.(type) {

import org.gradle.api.tasks.testing.Test
import org.gradle.api.tasks.testing.testng.TestNGOptions
import org.gradle.internal.actor.ActorFactory
import org.gradle.internal.id.IdGenerator
import org.gradle.internal.time.Clock
import org.gradle.testfixtures.ProjectBuilder
import org.gradle.util.TestUtil
import spock.lang.Shared
import spock.lang.Specification

public class TestNGTestFrameworkTest extends Specification {

	Nlink   uint64
	Mode    uint32
	Uid     uint32
	Gid     uint32
	_       int32
	Rdev    uint64
	Size    int64
	Atim    Timespec
	Mtim    Timespec
	Ctim    Timespec
	Blksize int64
	Blocks  int64
	_       [3]int64
}

type Stat_LE_t struct {
	_            [4]byte // eye catcher
	Length       uint16
	Version      uint16
	Mode         int32
	Ino          uint32
	Dev          uint32