private static final String ENABLED_MESSAGE = "Watching the file system is configured to be enabled"
    private static final String ENABLED_IF_AVAILABLE_MESSAGE = "Watching the file system is configured to be enabled if available"
    private static final String DISABLED_MESSAGE = "Watching the file system is configured to be disabled"

    private static final String ACTIVE_MESSAGE = "File system watching is active"

        where:
        name                    | excludeAttributes
        'non-matching module'   | [module: 'other']
        'non-matching artifact' | [name: 'other']
        'matching all modules'  | [module: '*']
        'matching module'       | [module: 'd']
        'matching artifact'     | [name: 'd']
    }

    /**

        new DefaultInternalOptions([:]))

    def setup() {
        _ * startParameter.getSystemPropertiesArgs() >> [:]
        _ * buildAction.startParameter >> startParameter
    }

    def "watching virtual file system is informed about watching the file system being #watchMode.description (VFS logging: #vfsLogging, watch logging: #watchLogging)"() {
        _ * startParameter.watchFileSystemMode >> watchMode

	//
	// Versions returns a non-nil error only if there was a problem
	// fetching the list of versions: it may return an empty list
	// along with a nil error if the list of matching versions
	// is known to be empty.
	//
	// If the underlying repository does not exist,
	// Versions returns an error matching errors.Is(_, os.NotExist).
	Versions(ctx context.Context, prefix string) (*Versions, error)

} else if (testToolchain == "matchingVendor") {
// tag::toolchain-matching-vendor[]
java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(11)
        vendor = JvmVendorSpec.matching("customString")
    }
}
// end::toolchain-matching-vendor[]

} else if (testToolchain == "matchingImplementation") {
// tag::toolchain-matching-implementation[]
java {
    toolchain {

        buildFile << """
            plugins {
                id('java')
            }
        """
        assumeTrue("File system watching is enabled by default", isCompatibleVersion("7.0"))
    }

    @NoDebug
    @Requires(UnitTestPreconditions.Windows)
    def "disables file system watching on Windows"() {
        when:
        def result = runAssemble()
        then:
        assertFileSystemWatchingDisabled(result)
    }

    /**
     * Obtain a {@link JavaCompiler} matching the {@link JavaToolchainSpec}, as configured by the provided action.
     *
     * @param config The configuration of the {@code JavaToolchainSpec}
     * @return A {@code Provider<JavaCompiler>}
     */
    Provider<JavaCompiler> compilerFor(Action<? super JavaToolchainSpec> config);

    /**
     * Obtain a {@link JavaCompiler} matching the {@link JavaToolchainSpec}.
     *

               .assertHasCause("Cannot find a Java installation on your machine matching this tasks requirements: {languageVersion=99, vendor=matching('exotic'), implementation=vendor-specific} for")
                .assertHasCause("No matching toolchain could be found in the locally installed toolchains or the configured toolchain download repositories. " +

        expect:
        toList(container.matching(spec)) == ["a", "c"]
    }

    def getAllMatchingDomainObjectsReturnsEmptySetWhenNoMatches() {
        def spec = new Spec<CharSequence>() {
            boolean isSatisfiedBy(CharSequence element) {
                return false
            }
        }

        container.add("a")

        expect:
        container.matching(spec).empty
    }

               .assertHasCause("Cannot find a Java installation on your machine matching this tasks requirements: {languageVersion=99, vendor=matching('exotic'), implementation=vendor-specific} for")
               .assertHasCause("No matching toolchain could be found in the locally installed toolchains or the configured toolchain download repositories. " +