if (o == null) {
            return null;
        } else if (o instanceof Double) {
            return (Double) o;
        } else if (o instanceof Number) {
            return new Double(((Number) o).doubleValue());
        } else if (o instanceof String) {
            return toDouble((String) o);
        } else if (o instanceof java.util.Date) {
            if (pattern != null) {

    def "assembles schema for RuleSource type"() {
        expect:
        def schema = store.getSchema(ModelType.of(RuleSource))
        schema instanceof RuleSourceSchema
        !(schema instanceof ManagedImplSchema)
        !(schema instanceof CompositeSchema)
        schema instanceof StructSchema
        schema.propertyNames.empty
        schema.properties.isEmpty()
    }

    static abstract class SomeRules extends RuleSource {

        if (o == null) {
            return null;
        } else if (o instanceof Short) {
            return (Short) o;
        } else if (o instanceof Number) {
            return ((Number) o).shortValue();
        } else if (o instanceof String) {
            return toShort((String) o);
        } else if (o instanceof java.util.Date) {
            if (pattern != null) {

    public static <E extends Throwable> boolean isLikelyTransientNetworkingIssue(E failure) {
        if (failure instanceof SocketException || failure instanceof SocketTimeoutException || failure instanceof NoHttpResponseException || failure instanceof ConnectionClosedException) {
            return true;
        }
        if (failure instanceof DefaultMultiCauseException) {

        assert expected instanceof KotlinDslScriptsModel
        assert actual instanceof KotlinDslScriptsModel

        checkModel(actual, expected, [
            [{ it.scriptModels }, { a, e -> checkKotlinDslScriptModel(a, e) }]
        ])
    }

    static void checkKotlinDslScriptModel(actual, expected) {
        assert expected instanceof KotlinDslScriptModel

        expect:
        with(factory.createCoordinateResolvers(variant, versionMappingStrategy).get()) {
            variantResolver instanceof ResolutionBackedVariantDependencyResolver
            componentResolver instanceof ResolutionBackedComponentDependencyResolver
        }
    }

    Configuration conf() {
        ResolvedVariantResult rootVariant = Mock(ResolvedVariantResult) {

                }
                assert delegate instanceof ExtensionAware
            }

            task javaexecProjectMethod() {
                def testFile = file("${'$'}buildDir/${'$'}name")
                dependsOn(sourceSets.main.output)
                doFirst {
                    project.javaexec {
                        assert !(delegate instanceof ExtensionAware)

        then:
        def clean = project.tasks[CLEAN_TASK_NAME]
        clean instanceOf(Delete)
        clean dependsOn()
        clean.group == BUILD_GROUP
        clean.targetFiles.files == [project.buildDir] as Set

        and:
        def assemble = project.tasks[ASSEMBLE_TASK_NAME]
        assemble.group == BUILD_GROUP
        assemble instanceOf(DefaultTask)

        and:
        def check = project.tasks[CHECK_TASK_NAME]

        // key = "application/vnd.ms-publisher";
        // assertTrue(extractorFactory.getExtractor(key) instanceof
        // TikaExtractor);

        key = "application/pdf";
        assertTrue(extractorFactory.getExtractor(key) instanceof PdfExtractor);

        key = "application/x-lha";
        assertTrue(extractorFactory.getExtractor(key) instanceof LhaExtractor);

        then:
        result.size() == 2

        def transformed1 = result[0]
        transformed1 instanceof LocationAwareException
        transformed1.cause.is(scriptFailure)

        def transformed2 = result[1]
        transformed2 instanceof LocationAwareException
        transformed2.cause.is(failure)

        failure.causes == [otherFailure1, otherFailure2]
    }