connection?.stop()
        acceptor?.stop()
    }

    @Issue("GRADLE-2316")
    @Requires(UnitTestPreconditions.NotMacOs) // https://github.com/gradle/gradle-private/issues/2832
    def "detects self connect when outgoing connection binds to same port"() {
        given:
        def socketChannel = SocketChannel.open()
        def communicationAddress = addressFactory.getLocalBindingAddress()

	return cmd, nil
}

type version struct {
	name         string
	major, minor int
}

var compiler struct {
	sync.Once
	version
	err error
}

// compilerVersion detects the version of $(go env CC).
//
// It returns a non-nil error if the compiler matches a known version schema but
// the version could not be parsed, or if $(go env CC) could not be determined.

	println("OK")
}

func LockOSThreadAvoidsStatePropagation() {
	// This test is similar to LockOSThreadAlt in that it will detect if a thread
	// which should have died is still running. However, rather than do this with
	// thread IDs, it does this by unsharing state on that thread. This way, it
	// also detects whether new threads were cloned from the dead thread, and not
	// from a clean thread. Cloning from a locked thread is undesirable since

	call := obj.Call(systemdInterface+".KillUnit", 0, unit, who, signal)
	if call.Err != nil {
		return fmt.Errorf("unable to reload logind conf: %w", call.Err)
	}

	return nil
}

// MonitorShutdown detects the node shutdown by watching for "PrepareForShutdown" logind events.
// see https://www.freedesktop.org/wiki/Software/systemd/inhibit/ for more details.
func (bus *DBusCon) MonitorShutdown() (<-chan bool, error) {

        def key = resourceHashesCache.keySet().iterator().next()
        resourceHashesCache.getIfPresent(key).toString() == 'e3f8c5a79d138a40570261fa7de40642'
    }

    def "detects moving of files in jars and directories"() {
        def zipFile = file('library.jar')
        file('zipContents').create {
            file('firstFile.txt').text = "Some text"
            subdir {}

	}
}

// Implementation note: Print is written for AST nodes but could be
// used to print arbitrary data structures; such a version should
// probably be in a different package.
//
// Note: This code detects (some) cycles created via pointers but
// not cycles that are created via slices or maps containing the
// same slice or map. Code for general data structures probably
// should catch those as well.

            }
        """

        expect:
        2.times {
            succeeds "custom", "--rerun-tasks"
        }
    }

    @Issue("https://github.com/gradle/gradle/issues/2293")
    def "detects a cycle with a task that mustRunAfter itself as finalizer of another task"() {
        buildFile << """
            def finalizer = tasks.register("finalizer")
            tasks.named("finalizer").configure {

        clangOnLinux | clangOnLinuxVerboseOutput | '3.6.0' | 'Ubuntu clang version 3.6.0-2ubuntu1~trusty1 (tags/RELEASE_360/final) (based on LLVM 3.6.0)'
    }

    def "detects clang pretending to be gcc"() {
        def visitor = Mock(DiagnosticsVisitor)

        expect:
        def result = output clang
        !result.available

        when:
        result.explain(visitor)

        executedAndNotSkipped ":c:${language.compileTaskName}"
        executedAndNotSkipped ":d:${language.compileTaskName}"
    }

    @Issue("gradle/gradle#1913")
    def "detects changes in compile classpath"() {
        given:
        buildFile << """
            ${mavenCentralRepository()}

            dependencies {
               if (providers.gradleProperty('useCommons').present) {

    }

    @Requires(UnitTestPreconditions.Jdk9OrLater)
    def "incremental compilation detects if some exported package for compiled module was deleted #description"() {
        file("impl/build.gradle") << """
            def layout = project.layout
            tasks.compileJava {