runtimeElements.exclude(group: "runtimeElements-group", module: "runtimeElements-module")
                implementation.exclude(group: "implementation-group", module: "implementation-module")
                runtimeOnly.exclude(group: "runtimeOnly-group", module: "runtimeOnly-module")
            }

            $dependencies

            publishing {

        and:
        parseContext.getMetaDataArtifact({ it.selector.module == 'parent' }, _, MAVEN_POM) >> asResource(parent)
        parseContext.getMetaDataArtifact({ it.selector.module == 'grandparent' }, _, MAVEN_POM) >> asResource(grandParent)

        when:
        parsePom()

        then:
        def dep = single(metadata.dependencies)
        dep.selector == moduleId('group-two', 'artifact-two', 'version-two')

This pass collects StableHLO functions referenced from `tf.XlaCallModule`'s
`_entry_function` attribute into a module, serializes the module into MLIR
bytecode, and embed the bytecode to `tf.XlaCallModule`'s `module` attribute.

After serialization, this pass removes the `_entry_function` attribute from
`tf.XlaCallModule`, and removes all the serialized stablehlo functions

</project>
"""
        and:
        parseContext.getMetaDataArtifact({ it.selector.module == 'parent' }, _, MAVEN_POM) >> asResource(parent)
        parseContext.getMetaDataArtifact({ it.selector.module == 'grandparent' }, _, MAVEN_POM) >> asResource(grandParent)
        parseContext.getMetaDataArtifact({ it.selector.module == 'imported' }, _, MAVEN_POM) >> asResource(imported)

        when:
        parsePom()

        assertEquals("module-2", pom.getValue("modules[1]"));
        assertEquals("module-1", pom.getValue("modules[2]"));
        assertEquals("module-3", pom.getValue("modules[3]"));
        assertEquals("module-4", pom.getValue("modules[4]"));
    }

    /**
     * Will throw an exception if it doesn't find parent(s) in build
     *
     * @throws Exception in case of issue

// RUN:     -stablehlo-quantize-composite-functions=enable-per-channel-quantized-weight=false | FileCheck --check-prefix=CHECK-PER-TENSOR %s

// Tests that basic dot_general is properly quantized.

module attributes {tf_saved_model.semantics} {
  func.func private @quantize_dot_general_fn(%arg0: tensor<1x2xf32>) -> tensor<1x3xf32> attributes {tf._original_func_name = "main_0"} {

        httpServer.start()
        def dep1 = withColorVariants(remoteRepo.module("group", "thing1", "1.2")).publish().allowAll()
        def dep2 = withColorVariants(remoteRepo.module("group", "thing2", "1.2")).publish().allowAll()
        withColorVariants(remoteRepo.module("group", "thing3", "1.2")).dependsOn(dep1).dependsOn(dep2).publish().allowAll()

	}

	n := &Name{Name: id}
	return n
}

// moduleName parses:
//
//	<module-name> ::= <module-subname>
//	 	      ::= <module-name> <module-subname>
//		      ::= <substitution>  # passed in by caller
//	<module-subname> ::= W <source-name>
//			 ::= W P <source-name>
//
// The module name is optional. If it is not present, this returns the parent.
func (st *state) moduleName(parent AST) AST {

}

var errNoModules = errors.New("not using modules")

// importGo checks whether it can use the go command to find the directory for path.
// If using the go command is not appropriate, importGo returns errNoModules.
// Otherwise, importGo tries using the go command and reports whether that succeeded.
// Using the go command lets build.Import and build.Context.Import find code

                for (String module : model.getModules()) {
                    if (module == null || module.isEmpty()) {
                        continue;
                    }

                    module = module.replace('\\', File.separatorChar).replace('/', File.separatorChar);

                    Path modulePath = modelProcessor.locateExistingPom(new File(basedir, module).toPath());