buildKtSourceModule {
        configLanguageVersionSettings?.let { this.languageVersionSettings = it }
        this.platform = platform
        this.moduleName = compilerConfig.get(CommonConfigurationKeys.MODULE_NAME) ?: "<no module name provided>"

        addModuleDependencies(moduleName)

        addSourceRoots(compilerConfig.javaSourceRoots.map { Paths.get(it) })
    }.apply(::addModule)


    this.platform = platform

        if (JavaVersion.current().isJava9Compatible()) {
            classLoaderName = ste.getClassLoaderName();
            moduleName = ste.getModuleName();
            moduleVersion = ste.getModuleVersion();
        } else {
            classLoaderName = null;
            moduleName = null;
            moduleVersion = null;
        }
        declaringClass = ste.getClassName();
        methodName = ste.getMethodName();

    /**
     * Declares that an entire module shouldn't be searched for in this repository.
     *
     * @param group the group name
     * @param moduleName the module name
     */
    void excludeModule(String group, String moduleName);

    /**
     * Declares that an entire module shouldn't be searched for in this repository, using regular expressions.
     *

plugins {
    id 'java-library'
}
repositories {
    mavenCentral()
}

tasks.named('test') {
    useJUnitPlatform()
}

// tag::patchArgs[]
def moduleName = "org.gradle.sample"
def patchArgs = ["--patch-module", "$moduleName=${tasks.compileJava.destinationDirectory.asFile.get().path}"]
tasks.named('compileTestJava') {
    options.compilerArgs += patchArgs
}
tasks.named('test') {
    jvmArgs += patchArgs
}

    }

    @Override
    String declareDependency(String moduleName, String moduleVersion) {
        "project(':$moduleName')"
    }

    @Override
    String declaredDependencyId(String moduleName, String moduleVersion) {
        "projectId('$moduleName')"
    }

    @Override
    void moduleDefinition(String name, String definition) {

        def branch = identifier.safeForBranch().decorate("branch")
        def status = identifier.safeForFileName().decorate("status")
        def module = ivyRepo.module(organisation, moduleName, version)

        settingsFile << "rootProject.name = '${sq(moduleName)}'"
        buildFile.text = """
            apply plugin: 'ivy-publish'
            apply plugin: 'java'

            group = '${sq(organisation)}'

    class IncrementalCppGreeter extends IncrementalCppElement {
        final greeter = new CppGreeterFunction().asLib()
        final alternateGreeter = new CppAlternateHeaderGreeterFunction().asLib()

        final String moduleName = "cppGreeter"
        final List<IncrementalElement.Transform> incrementalChanges = [modify(greeter, alternateGreeter)]
    }

    class IncrementalSwiftAppWithCppDep extends IncrementalSwiftApp {

        when:
        select('one.dot', 'has.two.dots', 'ModuleName')

        then:
        noExceptionThrown()
    }

    def "converts second dot into slash"() {
        expect:
        select('one.dot', 'has.two.dots').includedTests == ['one.dot', 'has.two/dots']
    }

    def "ignores wildcard to select all tests from module"() {
        expect:
        select('ModuleName.*').includedTests == ['ModuleName.*']
    }

        super(tested.projectName)
        greeterTest = new SwiftGreeterTest(greeter).withImport(tested.moduleName)
        sumTest = new SwiftSumTest(sum).withImport(tested.moduleName)
        multiplyTest = new SwiftMultiplyTest(multiply).withTestableImport(tested.moduleName)
    }

    final List<XCTestSourceFileElement> getTestSuites() {
        [greeterTest, sumTest, multiplyTest]
    }

        super(tested.projectName)
        sumTest = new SwiftSumTest(sum).withImport(tested.moduleName)
        greeterTest = new SwiftGreeterTest(greeter).withImport(tested.moduleName)
        multiplyTest = new SwiftMultiplyTest(multiply).withTestableImport(tested.moduleName)
    }

    List<XCTestSourceFileElement> getTestSuites() {
        return [sumTest, greeterTest, multiplyTest]
    }