check(Directives.WITH_RESOLVE_EXTENSION in moduleStructure.allDirectives) {
                "configureResolveExtensions() was called, but no modules specify WITH_RESOLVE_EXTENSION."
            }

            return TestModuleStructureImpl(
                moduleStructure.modules.map { it.transformAndRegisterResolveExtension() },
                moduleStructure.originalTestDataFiles,
            )
        }

  <version>11-SNAPSHOT</version>

  <name>Model urls inheritance test parent</name>
  <description>Flat directory structure case: module = ../child directory path + child directory path != child-artifact-id</description>

  <modules>
    <module>../inheritance</module><!-- current directory == inheritance -->
  </modules>

  <!-- 5 urls in the pom will be inherited with path added -->
  <url>http://www.apache.org/path/to/parent/</url>
  <scm>

cp go.mod3 go.mod
go list -mod=mod -f '{{with .Module}}{{.Path}} {{.Version}}{{end}}' all
! stderr '^go: dropping requirement'
stdout 'rsc.io/quote v1.5.1'

-- x.go --
package x
import _ "rsc.io/quote"

-- go.mod --
module x

go 1.13

exclude rsc.io/sampler v1.99.99

require rsc.io/sampler v1.99.99
-- vendor/modules.txt --
# rsc.io/sampler v1.99.99
## explicit
-- go.moddrop --

cd subdir

# 'go get' on empty patterns that are necessarily local to the module
# should warn that the patterns are empty, exactly once.

go get ./...
stderr -count=1 'matched no packages'

go get ./...
stderr -count=1 'matched no packages'

# 'go get' on patterns that could conceivably match nested modules
# should report a module resolution error.

go get example.net/emptysubdir/... # control case

#
# Where a/x and a/y are disjoint packages, but both contained in module a.
#
# The module dependency graph initially looks like:
#
# lazy ---- a.1 ---- b.1
#              \
#               c.1


cp go.mod go.mod.old
cp lazy.go lazy.go.old
go mod tidy
cmp go.mod go.mod.old

# Before adding a new import, the go.mod file should
# enumerate modules for all packages already imported.
go list all
cmp go.mod go.mod.old

  </organization>
  <modules>
    <!--

    Until the bug is fixed in Maven which is pulling in the trunk to the
    appserver build.
    <module>plexus-appserver</module>
    -->
    <module>plexus-archetypes</module>
    <module>plexus-examples</module>
    <module>plexus-components</module>
    <module>plexus-component-factories</module>
    <module>plexus-containers</module>

  <name>Maven Integration Test :: MNG-4034</name>
  <description>
    Verify that dependencies defined in profiles are subject to the dependency management of the parent.
  </description>

  <modules>
    <module>sub</module>
  </modules>

  <dependencyManagement>
    <dependencies>
      <dependency>
        <groupId>org.apache.maven.its</groupId>
        <artifactId>maven-core-it-support</artifactId>

}

// findModule searches for the module that contains the package at path.
// If the package was loaded, its containing module and true are returned.
// Otherwise, module.Version{} and false are returned.
func findModule(ld *loader, path string) (module.Version, bool) {
	if pkg, ok := ld.pkgCache.Get(path); ok {
		return pkg.mod, pkg.mod != module.Version{}
	}
	return module.Version{}, false
}

cd subdir
! go list
! stderr 'cannot find module providing package'
stderr '^no Go files in '$WORK'[/\\]gopath[/\\]src[/\\]dir[/\\]subdir$'
cd ..

# golang.org/issue/30590: if a package is found in the filesystem
# but is not in the main module, the error message should not say
# "cannot find module providing package", and we shouldn't try
# to find a module providing the package.
! go list ./othermodule

        return IdeaFixtures.parseIml(imlFile)
    }

    private void iprHasModules(TestFile projectDir = buildA, String... expected) {
        def modules = ipr(projectDir).modules
        assert modules.modules.size() == expected.length
        expected.each {
            modules.assertHasModule(it)
        }
    }

    private void imlHasDependencies(TestFile projectDir = buildA, String... expectedModules) {