assertIncludes(settingsClassPath, spec.jars.settings)
        assertExcludes(settingsClassPath, spec.jars.root, spec.jars.a, spec.jars.b)

        def rootClassPath = canonicalClasspathOf(model, spec.scripts.root)
        assertContainsBuildSrc(rootClassPath)
        assertIncludes(rootClassPath, spec.jars.root)
        assertExcludes(rootClassPath, spec.jars.a, spec.jars.b)

        }
    }
}


private
fun pluginIdExtensionDeclarationsFor(
    jars: Iterable<File>,
    pluginDependenciesSpecQualifiedName: String,
    pluginDependencySpecQualifiedName: String,
): Sequence<String> {
    return pluginExtensionsFrom(jars)
        .map { (memberName, pluginId, implementationClass) ->
            """
            /**

    fun `provides a source code generation oriented model over a classpath`() {

        val jars = listOf(
            withClassJar(
                "some.jar",
                Plugin::class.java,
                PluginCollection::class.java,
                ObjectFactory::class.java
            )
        )

        apiTypeProviderFor(jars).use { api ->

            assertThat(api.typeOrNull<Test>(), nullValue())

This directory is intended to contain Hazelcast [1] JARs for Maven Resolver Named Locks using Hazelcast.

See here [2] on how to add necessary JARs.

[1] https://github.com/hazelcast/hazelcast

        assertContainsGradleKotlinDslJars(initClassPath)
        assertIncludes(initClassPath, spec.jars.init)

        def someInitClassPath = canonicalClasspathOf(model, spec.scripts.someInit)
        assertNotContainsBuildSrc(someInitClassPath)
        assertContainsGradleKotlinDslJars(someInitClassPath)
        assertIncludes(someInitClassPath, spec.jars.someInit)
    }

This directory is intended to contain Redisson [1] JARs for Maven Resolver Named Locks using Redisson.

See here [2] on how to add necessary JARs.

[1] https://github.com/redisson/redisson

    }

    @Test
    fun `ignores package-info and compiler generated classes`() {
        val jars = EffectiveClassPath(javaClass.classLoader).asFiles.filter { it.name.startsWith("gradle-core-api-") }

        ClassBytesRepository(
            platformClassLoader = ClassLoaderUtils.getPlatformClassLoader(),
            classPathFiles = jars
        ).use { repository ->
            repository.allSourceNames.apply {

        enc = "Shift_JIS";
        assertEquals("Shift_JIS", encodingHelper.normalize(enc));

        enc = "S-JIS";
        assertEquals("S-JIS", encodingHelper.normalize(enc));
    }

    public void test_normalize_map() {
        String enc;

        encodingHelper.addEncodingMapping("S-JIS", "Shift_JIS");

        enc = "UTF-8";
        assertEquals("UTF-8", encodingHelper.normalize(enc));

        final StringBuilder buf = new StringBuilder(1000);

        ArchiveInputStream ais = null;

        try {
            ais = archiveStreamFactory.createArchiveInputStream("tar", in);
            TarArchiveEntry entry = null;
            long contentSize = 0;
            while ((entry = (TarArchiveEntry) ais.getNextEntry()) != null) {
                contentSize += entry.getSize();

        try (ObjectOutputStream oos = new ObjectOutputStream(baos)) {
            oos.writeObject(build);
        }

        Build build2;
        ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
        try (ObjectInputStream ois = new ObjectInputStream(bais)) {
            build2 = (Build) ois.readObject();
        }

        assertNotNull(build2);
    }

    @Test