runAndFail("classes").assertHasDescription("Execution failed for task ':compileScala'.")
    }

    @Issue("gradle/gradle#8421")
    def "incremental compiler detects change in package"() {
        settingsFile << """
            include 'lib'
        """
        [buildFile, file('lib/build.gradle')].each {
            it << """
                plugins {

	// If there is more than one line (table headers) in /proc/swaps then swap is enabled
	klog.InfoS("Swap is on", "/proc/swaps contents", procSwapsStr)
	return len(procSwapsLines) > 1
}

// IsSwapOn detects whether swap in enabled on the system by inspecting
// /proc/swaps. If the file does not exist, an os.NotFound error will be returned.
// If running on windows, swap is assumed to always be false.
func IsSwapOn() (bool, error) {

import org.junit.jupiter.api.Test


class AlphabeticalAcceptedApiChangesTaskIntegrationTest : AbstractAcceptedApiChangesMaintenanceTaskIntegrationTest() {
    @Test
    fun `verify AlphabeticalAcceptedApiChangesTask detects misordered changes`() {
        //language=JSON
        firstAcceptedApiChangesFile.writeText(
            """
                {
                    "acceptedApiChanges": [
                        {

            task t
        """

        when:
        succeeds "t", "--scan"

        then:
        scanPlugin.issuedNoPluginWarningCount(output, 1)
    }

    def "detects that the build scan plugin has been #description"() {
        given:
        scanPlugin.collectConfig = applied

        when:
        succeeds "t"

        then:

    }

    private void exitsContinuousBuildSinceNotWatchingAnyLocationsExceptForConfigCache() {
        if (GradleContextualExecuter.configCache) {
            // When using the configuration cache, the build files are stored in the VFS, so we start watching.
            // That means for hierarchical watchers, we'll also detect the change above.

                constraint("org:fooA:{strictly 1.0}", "org:fooA:1.0")
                constraint("org:transitive:{strictly 1.0}", "org:transitive:1.0")
            }
        }
    }

    def "detects cycles in consistency"() {
        repository {
            'org:foo:1.0'()
            'org:foo:1.1'()
        }
        buildFile << """
            configurations {

            task t
            task f { doLast { throw new RuntimeException("failed") } }
        """
    }

    void applyPlugin() {
        settingsFile << plugin.plugins()
    }

    def "detects that the build scan plugin has been [applied=#applied]"() {
        given:
        if (applied) {
            applyPlugin()
        }

        settingsFile << """

        then:
        builder.getAllArguments().findAll { !it.startsWith('-Duser.') } == ['-Dfile.encoding=UTF-8', '-cp', libJar.name, '--module-path', moduleJar.name, '--module', 'mainModule/mainClass']
    }

    def "detects null entries early"() {
        when:
        builder.args(1, null)
        then:
        thrown(IllegalArgumentException)
    }

Note that, by default, link:{groovyDslPath}/org.gradle.nativeplatform.test.tasks.RunTestExecutable.html[RunTestExecutable] task type always executes every test that it detects, irrespective of this setting.

  static Status New(const QueueRunnerDef& queue_runner_def, Coordinator* coord,
                    std::unique_ptr<QueueRunner>* result);

  /// Adds a callback that the queue runner will call when it detects an error.
  void AddErrorCallback(const std::function<void(Status)>& cb);

  /// Delete the previously registered callbacks.
  void ClearErrorCallbacks();

  /// The destructor would join all the threads.