withConnection { ProjectConnection connection ->
            connection.action(action).run()
        }

        then:
        notThrown Exception

        cleanup:
        classloader?.close()
    }

        e.message == "Failed to cast object $arg of type ${arg.class.name} to target type ${Integer.name}"

        when:
        def result = cast(CharSequence).transform(arg)

        then:
        notThrown(ClassCastException)
        result.is arg
    }

    def "as string"() {
        expect:
        asString().transform(1) == "1"
        asString().transform(null) == null
    }

    def "to URL"() {

        then:
        c != DefaultClassLoaderFactoryTestHelper

        when:
        Thread.currentThread().contextClassLoader = cl
        c.getConstructor().newInstance().doStuff()

        then:
        notThrown()
    }

    def getClasspath() {
        return DefaultClassPath.of(ClasspathUtil.getClasspathForClass(DefaultClassLoaderFactoryTestHelper))
    }

}
'''

        buildFile << 'task doStuff'

        when:
        executer.usingInitScript(initScript1).usingInitScript(initScript2).withTasks('doStuff').run()

        then:
        notThrown(Throwable)
    }

    def "each Kotlin init script has independent ClassLoader"() {
        given:
        createExternalJar()

        and:
        TestFile initScript1 = file('init1.init.gradle.kts')

            newBuild().forLaunchables(task).run()
            newBuild().forLaunchables(selector).run()
        }

        then:
        notThrown(Throwable)
    }

        when:
        withConnection { connection ->
            fetchCustomModelsWithRestrictedMemoryAction(connection)
        }

        then:
        notThrown(GradleConnectionException)
        assertHasConfigureSuccessfulLogging()
    }

    private fetchCustomModelsWithRestrictedMemoryAction(ProjectConnection connection) {

            createReport("c")
        }
    }

    def "reports given at construction are available"() {
        when:
        container.configure { a {} }

        then:
        notThrown(MissingPropertyException)
    }

    def "container is immutable"() {
        when:
        container.add(Stub(Report))

        then:
        thrown(ReportContainer.ImmutableViolationException)

        connection.disconnect()
        daemonConnection.stop()

        then:
        notThrown()
    }

    def "handles case where cannot receive from connection"() {
        when:
        connection.queueBroken()
        daemonConnection.stop()

        then:
        notThrown()
    }

    def "handles failure to notify stdin handler"() {
        StdinHandler handler = Mock()

            connector.useBuildDistribution()
        }
        toolingApi.withConnection { connection -> connection.newBuild().forTasks('check').run() }

        then:
        notThrown(Throwable)
    }

    def "tooling api searches up from the project directory to find the wrapper properties"() {
        settingsFile << "include 'child'"
        buildFile << """

        when:
        project.custom {
            dynamic {
                doLast { // should resolve to task.doLast

                }
            }
        }

        then:
        notThrown(Exception)
    }
    
    def "can use [] notation to get and set"() {
        when:
        extension["foo"]
        
        then:
        thrown(MissingPropertyException)

        when: