library {
                    module.set('Hello')
                }
                dependencies {
                    implementation project(':lib2')
                }
            }
            project(':lib2') {
                apply plugin: 'swift-library'
                library {
                    module.set('Log')
                }
            }
"""

  </developers>
  <ciManagement>
    <system>GitHub Actions</system>
    <url>https://github.com/google/guava/actions</url>
  </ciManagement>
  <modules>
    <module>guava</module>
    <module>guava-bom</module>
    <module>guava-testlib</module>
    <module>guava-tests</module>
  </modules>
  <build>
    <!-- Handle where Guava deviates from Maven defaults -->
    <sourceDirectory>src</sourceDirectory>

        def pattern = Pattern.compile(Pattern.quote(homeDir) + "/caches/${CacheLayout.MODULES.getKey()}/${CacheLayout.FILE_STORE.getKey()}/([^/]+/[^/]+/[^/]+)/[a-z0-9]+/")
        def text = file.text.replaceAll(pattern, '@CACHE_DIR@/$1/@SHA1@/')
        pattern = Pattern.compile("GRADLE_USER_HOME/${CacheLayout.MODULES.getKey()}/${CacheLayout.FILE_STORE.getKey()}/([^/]+/[^/]+/[^/]+)/[a-z0-9]+/")

	} else {
		return "", false, nil
	}

	// Check that there aren't other modules in the way.
	// This check is unnecessary inside the module cache
	// and important to skip in the vendor directory,
	// where all the module trees have been overlaid.
	// So we only check local module trees
	// (the main module, and any directory trees pointed at by replace directives).
	if isLocal {

			// Right now we return "missing go.mod", which is a little confusing.
			return nil, &module.ModuleError{
				Path: r.modPath,
				Err: &module.InvalidVersionError{
					Version: v,
					Err:     notExistError{err: err},
				},
			}
		}

		invalidf := func(format string, args ...any) error {
			return &module.ModuleError{
				Path: r.modPath,
				Err: &module.InvalidVersionError{

        def a1 = mavenHttpRepo.module('org.foo', 'a')
        def b1 = mavenHttpRepo.module('org.foo', 'b')
        def b2 = mavenHttpRepo.module('org.foo', 'b', '2.0')
        def c1 = mavenHttpRepo.module('org.foo', 'c')
        def d1 = mavenHttpRepo.module('org.foo', 'd')
        def e1 = mavenHttpRepo.module('org.foo', 'e')
        def f1 = mavenHttpRepo.module('org.foo', 'f')

        a1.dependsOn(c1).publish()

                // This is a performance optimization. Most modules do not declare capabilities. So, instead of systematically registering
                // an implicit capability for each module that we see, we only consider modules which _declare_ capabilities. If they do,
                // then we try to find a module which provides the same capability. It that module has been found, then we register it.

  }

 protected:
  MLIRContext context_;
  OwningOpRef<ModuleOp> module_;
  llvm::SourceMgr source_manager_;
};

TEST_F(Tf2XlaRewriterTest, LegalizesOpWithTf2xlaHloImporter) {
  TF_EXPECT_OK(LegalizeModule());

  int num_tuple_ops = 0;
  module_->walk([&num_tuple_ops](TupleOp tuple_op) { num_tuple_ops += 1; });

  EXPECT_EQ(num_tuple_ops, 0);
}

            }
        }
        javaModulesMultiProject {
            sampleDirectory = samplesRoot.dir("java/modules-multi-project")
            displayName = "Building Java Modules"
            description = "Build Java Modules and a modular Java application."
            category = "Java Modules"
            common {
                from(templates.javaApplicationAsSubproject)

    }

    def "configures changing modules cache with jdk5+ units"() {
        when:
        strategy.cacheChangingModulesFor(30000, "milliseconds")

        then:
        1 * cachePolicy.cacheChangingModulesFor(30000, TimeUnit.MILLISECONDS)
    }

    def "configures changing modules cache with jdk6+ units"() {
        when: