import java.io.File

import kotlin.reflect.KClass


open class TestWithClassPath : TestWithTempFiles() {

    protected
    fun jarClassPathWith(vararg classes: KClass<*>): ClassPath =
        jarClassPathWith("cp.jar", *classes)

    protected
    fun jarClassPathWith(path: String, vararg classes: KClass<*>): ClassPath = classPathOf(
        file(path).also { jar ->
            zipTo(jar, classEntriesFor(classes))
        }

        val genericTypeWithPrimitiveComponent = SchemaType.of<PublicGenericType<String>>()
        assertThat(
            accessibilityFor(
                genericTypeWithPrimitiveComponent,
                classPath = jarClassPathWith(PublicGenericType::class)
            ),
            equalTo(accessible(genericTypeWithPrimitiveComponent))
        )
    }

    @Test
    fun `internal Kotlin type is inaccessible because NonPublic`() {

        val genericType = SchemaType.of<PublicGenericType<PublicComponentType>>()

        val projectSchema = availableProjectSchemaFor(
            schemaWithExtensions("generic" to genericType),
            jarClassPathWith(PublicGenericType::class, PublicComponentType::class)
        )

        assertThat(
            projectSchema.extension("generic").type,
            equalTo(accessible(genericType))
        )
    }

        verify(logger, atMost(1)).isDebugEnabled
        verifyNoMoreInteractions(logger)
    }

    private
    fun apiJarsWith(vararg classes: KClass<*>): List<File> =
        jarClassPathWith("gradle-api.jar", *classes, org.gradle.api.Generated::class).asFiles

    private
    fun fixturesApiMetadataJar(): File =
        file("gradle-api-metadata.jar").also { file ->
            JarOutputStream(