equalTo(inaccessible(type, nonAvailable(type.kotlinString)))
        )
    }

    @Test
    fun `public type is represented as Accessible`() {

        val typeString = "existing.Type"

        val classPath = classPathWithPublicType(typeString)
        classLoaderFor(classPath).useToRun {
            val type = schemaTypeFor(typeString)
            val projectSchema = availableProjectSchemaFor(

                domainObject,
                typeOf<NamedDomainObjectProvider<DomainObject>>()
            )
        }
    }

    @Test
    fun `val domainObject by registering(type)`() {

        val domainObjectProvider = mockDomainObjectProviderFor(DomainObject())
        val container = mock<PolymorphicDomainObjectContainer<Any>> {

import org.junit.Test


@Suppress("deprecation")
class ProjectExtensionsTest {

    abstract class CustomConvention

    @Test
    fun `can get generic project extension by type`() {

        val project = mock<Project>()
        val convention = mock<org.gradle.api.plugins.Convention>()
        val extension = mock<NamedDomainObjectContainer<List<String>>>()

            verify(extensionContainer).configure(eq(extensionType), any<Action<JacocoTaskExtension>>())
            verifyNoMoreInteractions()
        }
    }

    @Test
    fun `can get generic extension by type`() {

        val extensionAware = mock<ExtensionAware>()
        val extensions = mock<ExtensionContainer>()
        val extension = mock<NamedDomainObjectContainer<List<String>>>()

    @Test
    fun `type-checks assignment of subtype to superclass type`() {
        val result = schema.resolve(
            """
            superClassProp = sub()
            """.trimIndent()
        )

        assertEquals(1, result.assignments.size)
    }

    @Test
    fun `type-checks assignment of subtype to super interface type`() {
        val result = schema.resolve(
            """

            optional(
                expression * zeroOrMore(token(COMMA) * expression) * optional(token(COMMA))
            )
        )

    val parenthesizedType by debug {
        paren(type)
    }

    val parenthesizedExpression by debug {
        paren(expression)
    }

    val valueArgument by debug {
        optional(annotation) * optional(simpleIdentifier * token(EQ)) * optional(token(MUL)) * expression

            when (val typeArgument = it.type) {
                null -> "*"
                else -> typeConversion(typeArgument)
            } + nullableSuffix
        }
    }
    print(typeConversion(type))
}

val KType.simpleName: String
    get() = (classifier as KClass<*>).simpleName!!

val KType.qualifiedName: String

        writeEnum(value.type)
        writeInt(value.ordinalGroup.ordinal)
    }

    override suspend fun ReadContext.decode(): OrdinalNode {
        val ordinalType = readEnum<OrdinalNode.Type>()
        val ordinal = readInt()
        return ordinalGroups.group(ordinal).locationsNode(ordinalType)
    }

        get() = analysisSession.token

    private val typeMapper by lazy { KaFe10JvmTypeMapperContext(analysisContext.resolveSession) }

    override fun mapTypeToJvmType(type: KaType, mode: TypeMappingMode): Type {
        val kotlinType = (type as KaFe10Type).fe10Type
        return typeMapper.mapType(kotlinType, mode)
    }

    override fun isPrimitiveBacked(type: KaType): Boolean {
        val kotlinType = (type as KaFe10Type).fe10Type

            assertInferredTypeOf(
                clean,
                typeOf<TaskProvider<Task>>()
            )
        }
    }

    @Test
    fun `val task by registering(type)`() {

        val taskProvider = mockTaskProviderFor(mock<Delete>())
        val tasks = mock<TaskContainer> {
            on { register("clean", Delete::class.java) } doReturn taskProvider
        }

        tasks {