1 * connection.dispatch({it instanceof Stop})
        1 * connection.receive() >> new Success(null)
        1 * connection.dispatch({it instanceof Finished})
        1 * connection.stop()
        1 * connection2.dispatch({it instanceof Stop})
        1 * connection2.receive() >> new Success(null)
        1 * connection2.dispatch({it instanceof Finished})
        1 * connection2.stop()
        0 * _
    }

    def "assembles schema for unmanaged type"() {
        expect:
        def schema = store.getSchema(ModelType.of(SomeType))
        schema instanceof UnmanagedImplStructSchema
        !(schema instanceof ManagedImplSchema)
        !(schema instanceof CompositeSchema)
        schema instanceof StructSchema
        !schema.annotated
        schema.propertyNames == ['readOnlyString', 'strings'] as SortedSet

                return definitions.any { it instanceof IncludedBuild }
            }

            @Override
            TestFile getAccessLocation(List<BuildWithSystemPropertyDefined> definitions, AbstractIntegrationSpec test) {
                IncludedBuild includedBuild = definitions.find { it instanceof IncludedBuild }
                return test.file("${includedBuild.name}/build.gradle")

        } else if (failure instanceof GradleConnectionException) {
            return (GradleConnectionException) failure;
        } else if (failure instanceof InternalBuildCancelledException) {
            return new BuildCancelledException(connectionFailureMessage(failure), failure.getCause());
        } else if (failure instanceof InternalTestExecutionException) {

    }

    public MetaClassAdapter determineDelegate(Object bean) {
        if (bean instanceof Class) {
            return new ClassAdapter((Class<?>) bean);
        } else if (bean instanceof Map) {
            return new MapAdapter();
        } else {
            if (bean instanceof DynamicObject || bean instanceof DynamicObjectAware || !(bean instanceof GroovyObject)) {
                return new MetaClassAdapter();
            }

    def "getFactory() returns a factory which creates instances of implementation class"() {
        given:
        implementationDeclared(CharSequence, String)

        when:
        def factory = serviceLocator.getFactory(CharSequence)
        def obj1 = factory.create()
        def obj2 = factory.create()

        then:
        obj1 instanceof String
        obj2 instanceof String
        !obj1.is(obj2)
    }

        return wrapper instanceof ClassTypeWrapper;
    }

    public Class<? super T> getRawClass() {
        return Cast.uncheckedCast(wrapper.getRawClass());
    }

    public Class<T> getConcreteClass() {
        return Cast.uncheckedCast(wrapper.getRawClass());
    }

    public boolean isRawClassOfParameterizedType() {

        1 * resultProcessor.failure('id', !null) >> { args ->
            def e = args[1]
            assert e instanceof DefaultTestFailure
            assert !e.details.assertionFailure
            assert e.rawFailure instanceof TestSuiteExecutionException
            assert e.rawFailure.message == 'Could not start <suite>.'
            assert e.rawFailure.cause == failure
        }
    }

            return 0L;
        }
        if (obj instanceof String) {
            return ((String) obj).length() + 56L;
        }
        if (obj instanceof Number) {
            return 24L;
        }
        if (obj instanceof Date) {
            return 32L;
        }
        if (obj instanceof LocalDateTime) {
            return 80L;
        }
        if (obj instanceof ZonedDateTime) {
            return 2128L;
        }

            return componentSelector instanceof ProjectComponentSelector || componentSelector instanceof ModuleComponentSelector;
        }

        private boolean isLeftProjectButRightIsModuleComponentSelector(DependencyEdge left, DependencyEdge right) {
            return left.getRequested() instanceof ProjectComponentSelector && right.getRequested() instanceof ModuleComponentSelector;
        }