String moduleName = decoder.readString();
        IvyArtifactName artifactName = IvyArtifactNameSerializer.INSTANCE.readNullable(decoder);
        String[] confs = readStringSet(decoder).toArray(new String[0]);
        String matcher = decoder.readNullableString();
        return new DefaultExclude(moduleIdentifierFactory.module(moduleOrg, moduleName), artifactName, confs, matcher);
    }

            val provider = KaResolveExtensionProviderForTest(ktResolveExtensionFiles, packageNames, shadowedScope) {
                it is KtSourceModule && it.moduleName == name
            }
            provider.register(testServices)

            return this.copy(files = regularFiles)
        }

            it.children.each { transitive ->
                assert transitive.moduleGroup == "org.gradle.111"
                assert transitive.moduleName == "module_111"
                assert transitive.moduleVersion == "v_111"
            }
        }
        assert configurations.compile.collect { it.name } == ['test-1.45.jar', 'module_111-v_111.jar']
    }
}
"""

		modulehashes.SetLocal(true)
		modulehashes.SetType(sym.SRODATA)

		for i, shlib := range ctxt.Shlibs {
			// modulehashes[i].modulename
			modulename := filepath.Base(shlib.Path)
			addgostring(ctxt, ldr, modulehashes, fmt.Sprintf("go:link.libname.%d", i), modulename)

			// modulehashes[i].linktimehash
			addgostring(ctxt, ldr, modulehashes, fmt.Sprintf("go:link.linkhash.%d", i), string(shlib.Hash))

    }

    private static class TestResolvedDependency implements ResolvedDependency, DependencyGraphNodeResult {
        String name
        String moduleGroup
        String moduleName
        String moduleVersion
        String configuration
        ResolvedModuleVersion module
        Set<ResolvedDependency> children = []
        Set<ResolvedDependency> parents

     * is {@link JavaPathType#MODULES}, then this method returns {@code "--module-path"}.
     * The option does not include the {@linkplain JavaPathType.Modular#moduleName() module name}
     * on which it applies.
     *
     * @return the name of the tool option for this path type
     */
    @Nonnull
    Optional<String> option();

    /**

        project.application.module = "App"
        project.evaluate()

        then:
        def compileSwift = project.tasks.compileDebugSwift
        compileSwift.moduleName.get() == "App"
        compileSwift.moduleFile.get().asFile == projectDir.file("build/modules/main/debug/App.swiftmodule")

        def link = project.tasks.linkDebug

        succeeds "test"
        result.assertTasksExecuted(tasks.debug.compile, tasks.test.allToInstall, ":xcTest", ":test")

        file("build/obj/test").assertIsDir()
        executable("build/exe/test/${lib.test.moduleName}").assertExists()
        lib.assertTestCasesRan(testExecutionResult)
    }

    @ToBeFixedForConfigurationCache
    def "can specify a test dependency on another library"() {
        def lib = new SwiftLib()

        // aren't automatic.
        return javaModuleGraph.getAllDependencies(javaModuleFinder.computeDefaultRootModules()).flatMap { moduleName ->
            val module = javaModuleFinder.findModule(moduleName) ?: return@flatMap emptyList<JavaRoot>()
            val result = module.getJavaModuleRoots()
            result
        }
    }

    /**

            }
        """.stripIndent()
        file("src/test/java/module-info.java") << """
            module org.gradle.example {
                exports org.gradle.example;
                requires ${moduleName};
                requires org.slf4j;
            }
        """.stripIndent()
        buildFile << """
            dependencies {
                implementation 'org.slf4j:slf4j-api:1.7.30'