private Class<?> plugin1Class = classLoader.parseClass("""
        import org.gradle.api.Plugin
        import org.gradle.api.Project
        class TestPlugin1 implements Plugin<Project> {
          void apply(Project project) {}
        }
    """)

    private Class<?> plugin2Class = classLoader.parseClass("""
        import org.gradle.api.Plugin
        import org.gradle.api.Project

        String typeName = type.getSimpleName()
        return classLoader.parseClass("""
import org.gradle.model.Managed

@Managed
interface Managed${typeName} {
    ${typeName} get${typeName}()
}
""")
    }

    Class<?> managedClass(Class<?> type) {
        String typeName = type.getSimpleName()
        return classLoader.parseClass("""
import org.gradle.model.Managed

@Managed

        def parentTask = groovyClassLoader.parseClass """
            class ParentTask extends org.gradle.api.DefaultTask {
                @$parentAnnotation.name Object getValue() { null }
            }
        """

        def childTask = groovyClassLoader.parseClass """
            class ChildTask extends ParentTask {

    def classLoader = new GroovyClassLoader(this.class.classLoader)

    def "cannot have read only property of scalar type #someType.simpleName"() {

        when:
        def clazz = classLoader.parseClass """
            import org.gradle.api.artifacts.Configuration.State
            import org.gradle.model.Managed

            @Managed
            interface ManagedType {

        GroovyClassLoader classLoader = new GroovyClassLoader(getClass().classLoader)
        DefaultSerializer serializer = new DefaultSerializer(classLoader)

        Class cl = classLoader.parseClass('package org.gradle.cache; class TestObj implements Serializable { }')
        Object o = cl.newInstance(new Object[0])

        when:
        def r = serialize(o, serializer)

        then:
        cl.isInstance(r)

        schema.getProperty("name") == null
    }

    def "primitive types are supported - #primitiveType"() {
        when:
        def interfaceWithPrimitiveProperty = new GroovyClassLoader(getClass().classLoader).parseClass """
            import org.gradle.model.Managed

            @Managed
            interface PrimitiveProperty {
                $primitiveType.name getPrimitiveProperty()

        def cause = new RuntimeException("nested")
        def sourceExceptionType = source.parseClass(
                "package org.gradle; public class TestException extends RuntimeException { public TestException(String msg, Throwable cause) { super(msg, cause); } }")
        def destExceptionType = dest.parseClass(

class ClassLoaderObjectInputStreamTest extends Specification {

    def "should handle array types"() {
        setup:
        GroovyClassLoader gcl = new GroovyClassLoader()
        def myClass = gcl.parseClass("class MyClass {}")
        def arrayObject = Array.newInstance(myClass, 10)
        def output = new ByteArrayOutputStream()
        def oos = new ObjectOutputStream(output)
        oos.writeObject(arrayObject)

    def setup() {
        rulesClass = classLoader.parseClass("""
            class Rules extends org.gradle.model.RuleSource {

            }
        """)

        hybridClass = classLoader.parseClass("""
            import org.gradle.api.Plugin
            import org.gradle.api.Project

            class Hybrid implements Plugin<Project> {

    }

    private void addClass(GroovyClassLoader cl, String impl) {
        def type = cl.parseClass(impl)
        detector.getDeclaredSources(type)
        type = null
    }