isolated1 instanceof IsolatedArray
        def copy1 = isolated1.isolate()
        copy1 == [] as String[]
        copy1.class == String[].class
        !copy1.is(original1)

        def original2 = ["123"] as String[]
        def isolated2 = isolatableFactory.isolate(original2)
        isolated2 instanceof IsolatedArray
        def copy2 = isolated2.isolate()

        expect:
        def schema = store.getSchema(ModelTypes.set(ModelType.of(String)))
        schema instanceof ScalarCollectionSchema
        schema instanceof ManagedImplSchema
        !(schema instanceof CompositeSchema)
        !(schema instanceof StructSchema)
        schema.elementType == ModelType.of(String)
        schema.elementTypeSchema == store.getSchema(ModelType.of(String))
    }

        }
        if (value instanceof String) {
            return visitor.stringValue((String) value);
        }
        if (value instanceof Boolean) {
            return visitor.booleanValue((Boolean) value);
        }
        if (value instanceof List) {
            return processList((List<?>) value, visitor);
        }
        if (value instanceof Enum) {
            return visitor.enumValue((Enum<?>) value);

        binaries.findAll { it.debuggable && it.optimized && it instanceof CppSharedLibrary }.size() == 1
        binaries.findAll { it.debuggable && !it.optimized && it instanceof CppSharedLibrary }.size() == 1
        binaries.findAll { it.debuggable && it.optimized && it instanceof CppStaticLibrary }.size() == 1
        binaries.findAll { it.debuggable && !it.optimized && it instanceof CppStaticLibrary }.size() == 1

        and:

        if (snapshot == NullValueSnapshot.INSTANCE) {
            encoder.writeSmallInt(NULL_SNAPSHOT);
        } else if (snapshot instanceof StringValueSnapshot) {
            StringValueSnapshot stringSnapshot = (StringValueSnapshot) snapshot;
            encoder.writeSmallInt(STRING_SNAPSHOT);
            encoder.writeString(stringSnapshot.getValue());
        } else if (snapshot instanceof ListValueSnapshot) {

    final DirectInstantiator instantiator = DirectInstantiator.INSTANCE

    def "creates instance with constructor parameters"() {
        CharSequence param = Mock()

        expect:
        def result = instantiator.newInstance(SomeType, param)
        result instanceof SomeType
        result.result == param
    }

    def "creates instance with subtypes of constructor parameters"() {
        expect:

        binaries.findAll { it.debuggable && it.optimized && it instanceof SwiftSharedLibrary }.size() == 1
        binaries.findAll { it.debuggable && !it.optimized && it instanceof SwiftSharedLibrary }.size() == 1
        binaries.findAll { it.debuggable && it.optimized && it instanceof SwiftStaticLibrary }.size() == 1
        binaries.findAll { it.debuggable && !it.optimized && it instanceof SwiftStaticLibrary }.size() == 1

        and:

    def "can retrieve property value"() {
        def instance = new SimpleUnmanagedType(prop: "12")

        when:
        def schema = extract(SimpleUnmanagedType)

        then:
        assert schema instanceof UnmanagedImplStructSchema
        schema.getProperty("prop").getPropertyValue(instance) == "12"
        schema.getProperty("calculatedProp").getPropertyValue(instance) == "calc"
    }

        if (o == null) {
            return null;
        } else if (o instanceof Byte) {
            return (Byte) o;
        } else if (o instanceof Number) {
            return ((Number) o).byteValue();
        } else if (o instanceof String) {
            return toByte((String) o);
        } else if (o instanceof java.util.Date) {
            if (pattern != null) {

        if (o == null) {
            return null;
        } else if (o instanceof Integer) {
            return (Integer) o;
        } else if (o instanceof Number) {
            return ((Number) o).intValue();
        } else if (o instanceof String) {
            return toInteger((String) o);
        } else if (o instanceof java.util.Date) {
            if (pattern != null) {