}

                PotentialPlugin<?> potentialPlugin = pluginInspector.inspect(implClass);
                PluginImplementation<Object> withId = new RegistryAwarePluginImplementation(classLoader, pluginId, potentialPlugin);
                return Optional.of(withId);
            }
        });
    }

    @Override
    public PluginRegistry createChild(final ClassLoaderScope lookupScope) {

            allprojects {
                tasks.withType(AbstractScalaCompile) {
                    options.fork = true
                }
                ${mavenCentralRepository()}
                plugins.withId("scala") {
                    dependencies {
                        implementation 'org.scala-lang:scala-library:${ScalaCoverage.SCALA_2.last()}'

                        testImplementation 'junit:junit:4.12'

			[]string{"ht&p"},
		},
	}

	s := xds.NewFakeDiscoveryServer(t, xds.FakeOptions{})
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			ads := s.ConnectADS().WithType(v3.RouteType).WithID(tt.node)
			ads.RequestResponseAck(t, &discovery.DiscoveryRequest{ResourceNames: tt.routes})
		})
	}
}

const (
	app3Ip    = "10.2.0.1"
	gatewayIP = "10.3.0.1"
)

// Common code for the xds testing.

        if (OperatingSystem.current().isLinux() && swiftToolChain.version.compareTo(VersionNumber.parse("4.1")) >= 0) {
            initScript << """
                allprojects { p ->
                    p.plugins.withId("cpp-library") {
                        p.library.binaries.configureEach(CppStaticLibrary) {
                            compileTask.get().configure {
                                compilerArgs.add("-fPIC")

}

configureJavadocVariant()

publishing {
    publications {
        create<MavenPublication>("gradleDistribution") {
            configureGradleModulePublication()
        }
    }

    plugins.withId("gradlebuild.shaded-jar") {
        publishNormalizedToLocalRepository()
    }
}

val pgpSigningKey: Provider<String> = providers.environmentVariable("PGP_SIGNING_KEY")

                    }
                }

                subprojects {
                    repositories {
                        ${mavenCentralRepository()}
                    }

                    plugins.withId('java') {
                        testing {
                            suites {
                                test {
                                    useJUnit()
                                }

        // For the configuration cache module
        "it.unimi.dsi.fastutil.objects.ReferenceArrayList",
        "it.unimi.dsi.fastutil.objects.ReferenceOpenHashSet",
    )
)
plugins.withId("java-base") {
    dependencies {
        attributesSchema {
            attribute(minified)
        }
        // It would be nice if we could be more selective about which variants to apply this to.

    /**
     * Returns a plugin with the specified id if this plugin has been used in the project.
     *
     * @param id The id of the plugin
     * @throws UnknownPluginException When there is no plugin with the given id.
     */
    Plugin getPlugin(String id) throws UnknownPluginException;

    /**
     * Returns a plugin with the specified type if this plugin has been used in the project.
     *

                allprojects {
                    repositories {
                        ${mavenCentralRepository()}
                    }
                }
                subprojects {
                    plugins.withId('java') {
                        testing {
                            suites {
                                test {
                                    useJUnit()
                                }

                    options.fork = true
                }
                ${mavenCentralRepository()}
                plugins.withId("scala") {
                    dependencies {
                        implementation("${scalaDependency(version.toString())}")
                    }
                }
            }
        """
        ['a', 'b', 'c', 'd'].each { project ->
            file("${project}/build.gradle") << """