if (o == null) {
            return null;
        } else if (o instanceof Long) {
            return (Long) o;
        } else if (o instanceof Number) {
            return ((Number) o).longValue();
        } else if (o instanceof String) {
            return toLong((String) o);
        } else if (o instanceof java.util.Date) {
            if (pattern != null) {

        repo instanceof DefaultMavenArtifactRepository
        repo.url == centralUrl
    }

    def createIvyRepository() {
        expect:
        def repo = factory.createIvyRepository()
        repo instanceof DefaultIvyArtifactRepository
    }

    def createMavenRepository() {
        expect:
        def repo = factory.createMavenRepository()
        repo instanceof DefaultMavenArtifactRepository
    }

            visitor.accept(new BuildableElementFileCollection(element, resolver, taskDependencyFactory, patternSetFactory));
            return;
        }

        if (element instanceof Task) {
            visitor.accept((FileCollectionInternal) ((Task) element).getOutputs().getFiles());
        } else if (element instanceof TaskOutputs) {

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

        and:
        project.application.developmentBinary.get() == binaries.find { it.debuggable && !it.optimized && it instanceof CppExecutable }
    }

    def "adds compile, link and install tasks"() {

                if (expectation.spec) {
                    if (expectation.spec instanceof VariantArtifacts) {
                        artifacts.addAll(expectation.spec.toArtifacts(module))
                    } else if (module instanceof MavenModule) {
                        artifacts << module.getArtifact(expectation.spec)
                    } else if (module instanceof IvyModule) {

        if (o == null) {
            return null;
        } else if (o instanceof Float) {
            return (Float) o;
        } else if (o instanceof Number) {
            return new Float(((Number) o).floatValue());
        } else if (o instanceof String) {
            return toFloat((String) o);
        } else if (o instanceof java.util.Date) {
            if (pattern != null) {

    def "assembles schema for model set"() {
        expect:
        def schema = store.getSchema(ModelTypes.modelSet(ModelType.of(String)))
        schema instanceof ModelSetSchema
        schema instanceof ManagedImplSchema
        schema instanceof CompositeSchema
        !(schema instanceof StructSchema)
        schema.elementType == ModelType.of(String)
        schema.elementTypeSchema == store.getSchema(ModelType.of(String))
    }

        assert executor instanceof SingleUseDaemonClient
    }

    private Runnable unwrapAction(Action<?> action) {
        assert action instanceof Actions.RunnableActionAdapter
        return action.runnable
    }

    private BuildActionExecutor unwrapExecutor(Runnable runnable) {
        assert runnable instanceof RunBuildAction
        return runnable.executor
    }

        if (annotation instanceof ParameterKind.Receiver) {
            return RECEIVER;
        }
        if (annotation instanceof ParameterKind.CallerClassName) {
            return CALLER_CLASS_NAME;
        }
        if (annotation instanceof ParameterKind.KotlinDefaultMask) {
            return KOTLIN_DEFAULT_MASK;
        }
        if (annotation instanceof ParameterKind.VarargParameter) {

        if (value instanceof Provider) {
            return providerResolutionStrategy.resolve((Provider<?>) value);
        }
        if (value instanceof Factory) {
            return ((Factory<?>) value).create();
        }
        return value;
    }

    public static boolean isDeferred(Object value) {
        return value instanceof Provider
            || value instanceof Factory