if (t instanceof TaskExecutionException) {
            TaskExecutionException taskExecutionException = (TaskExecutionException) t;
            String taskPath = ((TaskInternal) taskExecutionException.getTask()).getIdentityPath().getPath();
            metadata.put(METADATA_KEY_TASK_PATH, taskPath);
        }

        if (t instanceof ScriptCompilationException) {

        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

    def "creates sub version selector"() {
        expect:
        matcher.parseSelector(selector) instanceof SubVersionSelector

        where:
        selector << [
            "1+",
            "1.2.3+"
        ]
    }

    def "creates latest version selector"() {
        expect:
        matcher.parseSelector(selector) instanceof LatestVersionSelector

        where:
        selector << [

        if (annotation instanceof CallableKind.StaticMethod) {
            return STATIC_METHOD;
        }
        if (annotation instanceof CallableKind.InstanceMethod) {
            return INSTANCE_METHOD;
        }
        if (annotation instanceof CallableKind.AfterConstructor) {
            return AFTER_CONSTRUCTOR;
        }
        if (annotation instanceof CallableKind.GroovyPropertyGetter) {

        assertNotNull(client);
        assertTrue(client instanceof FaultTolerantClient);
        assertTrue(((FaultTolerantClient) client).getCrawlerClient() instanceof HcHttpClient);

        url = "https://hoge.com/";
        client = clientFactory.getClient(url);
        assertNotNull(client);
        assertTrue(client instanceof FaultTolerantClient);

            }

            task verify {
                assert components.java instanceof DefaultJvmSoftwareComponent
                assert components.comp instanceof DefaultJvmSoftwareComponent
            }
        """

        expect:
        succeeds "verify"
    }

    def "can instantiate component instances adjacent to java component with java-library plugin applied in Kotlin DSL"() {
        given:

        }
        if (clazz.isAssignableFrom(Date.class)) {
            if (value instanceof Date) {
                return (T) value;
            }
            return (T) FessFunctions.parseDate(value.toString());
        }
        if (clazz.isAssignableFrom(Long.class)) {
            if (value instanceof Long) {
                return (T) value;
            }

        loggingSystem.setLevel(LogLevel.INFO)
        loggingSystem.startCapture()
        stream.println('info')

        then:
        1 * listener.onOutput({ it instanceof LogLevelChangeEvent && it.newLogLevel == LogLevel.INFO })
        1 * listener.onOutput({ it instanceof StyledTextOutputEvent && it.spans[0].text == withEOL('info') })
        original.toString() == ''
        0 * listener._
    }

    def fillsInEventDetails() {