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

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

    override val platform: TargetPlatform,
    override val project: Project,
    override val moduleName: String,
    override val languageVersionSettings: LanguageVersionSettings,
    internal val sourceRoots: List<PsiFileSystemItem>,
) : KtSourceModule, KtModuleWithPlatform {
    override val stableModuleName: String? get() = moduleName
    override val transitiveDependsOnDependencies: List<KtModule> by lazy {

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

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

    class IncrementalSwiftAppWithCppDep extends IncrementalSwiftApp {

    public static final MavenMetadataArtifactProvider INSTANCE = new MavenMetadataArtifactProvider();

    @Override
    public IvyArtifactName getMetaDataArtifactName(String moduleName) {
        return new DefaultIvyArtifactName(moduleName, "pom", "pom");
    }

    response = client.get("/models/alexnet")
    assert response.status_code == 200
    assert response.json() == {"model_name": "alexnet", "message": "Deep Learning FTW!"}


def test_get_enums_lenet():
    response = client.get("/models/lenet")
    assert response.status_code == 200
    assert response.json() == {"model_name": "lenet", "message": "LeCNN all the images"}


def test_get_enums_resnet():

                        String moduleName;

                        ComponentIdentifier id = artifact.getId().getComponentIdentifier();
                        if (ModuleComponentIdentifier.class.isAssignableFrom(id.getClass())) {
                            moduleName = ((ModuleComponentIdentifier) id).getModule();

            for (Map.Entry<Path, String> info :
                    cache.getModuleInfo(path).getModuleNames().entrySet()) {
                String moduleName = info.getValue();
                type = JavaPathType.patchModule(moduleName);
                if (!containsModule(moduleName)) {
                    /*
                     * Not patching an existing module. This case should be unusual. If it nevertheless

        succeeds 'xcode'

        then:
        assertHasSwiftVersion(componentSourceCompatibility, rootXcodeProject.projectFile.findTargets(fixture.main.moduleName))
        assertHasSwiftVersion(xctestSourceCompatibility, rootXcodeProject.projectFile.findTargets(fixture.test.moduleName))

        where:
        fixture                                     | componentSourceCompatibility | xctestSourceCompatibility

        return ":compileDebugSwift"
    }

    @Override
    void assertComponentUnderTestWasBuilt() {
        file("build/modules/main/debug/${componentUnderTest.moduleName}.swiftmodule").assertIsFile()
        staticLibrary("build/lib/main/debug/${componentUnderTest.moduleName}").assertExists()
    }

    @Override
    protected String getComponentUnderTestDsl() {
        return "library"
    }

        return lib
    }

    class IncrementalSwiftLib extends IncrementalSwiftElement {
        final greeter = new SwiftGreeter()
        final sum = new SwiftSum()

        final String moduleName = "Greeter"
        final List<IncrementalElement.Transform> incrementalChanges = [preserve(greeter), preserve(sum)]
    }

    class IncrementalSwiftAppWithDep extends IncrementalSwiftElement implements AppElement {