when:
        def output1 = runTestClass.apply('TestClass1')

        then:
        notThrown(Exception)

        and:
        onlyTestClass1In(output1)

        when:
        def output2 = runTestClass.apply('TestClass2')

        then:
        notThrown(Exception)

        then:
        onlyTestClass2In(output2)

        where:
        api << LauncherApi.values()
    }

        new DefaultOsMemoryInfo().getOsSnapshot().getPhysicalMemory().getTotal()

        then:
        notThrown UnsupportedOperationException
    }

    def "gets OS free memory on any system"() {
        when:
        new DefaultOsMemoryInfo().getOsSnapshot().getPhysicalMemory().getFree()

        then:
        notThrown UnsupportedOperationException
    }

    @Requires(UnitTestPreconditions.Windows)

        then:
        notThrown(Exception)

        when:
        dsl.asDynamicObject

        then:
        thrown(IllegalStateException)
    }

    static class Thing {}

    def "works for dsl object"() {
        when:
        new DslObject(TestUtil.instantiatorFactory().decorateLenient().newInstance(Thing))

        then:
        notThrown(Exception)
    }

        then:
        notThrown(NullPointerException)
        status.pid == null
    }

    def "PID unboxing should not happen in DaemonStopEvent"() {
        given:
        Long unknownPID = null;

        when:
        def daemonStopEvent = new DaemonStopEvent(null, unknownPID, null, null);

        then:
        notThrown(NullPointerException)
        daemonStopEvent.pid == null
    }

        doNothing().execute(thing)

        then:
        0 * thing._(*_)
    }

    def "can do nothing on null"() {
        when:
        doNothing().execute(null)

        then:
        notThrown(Throwable)
    }

    def "composite actions"() {
        def actions = [Mock(Action), Mock(Action)]

        when:
        composite(actions).execute("foo")

        then:

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

        when:
        def result = cast(CharSequence, arg)

        then:
        notThrown(ClassCastException)
        result.is arg
    }

    def setup() {
        applyPlugin()
    }

    def "signing block"() {
        when:
        signing {
            signatories {

            }
        }

        then:
        notThrown Exception
    }

    def "signatories"() {
        expect:
        signing.signatories != null
        signing.signatories instanceof SignatoryProvider
    }

    def "signing configuration"() {

        poll {
            assert signalCount.get() == 2
        }
    }

    def "can trigger signal without anyone waiting"() {
        when:
        signal.trigger()

        then:
        notThrown(Exception)
    }

        given:
        unlockUncleanly()

        when:
        createLock(Exclusive).writeFile {}

        then:
        notThrown FileIntegrityViolationException
    }

    def "can lock a file"() {
        when:
        def lock = createLock(lockMode)

        then:

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

        then:
        notThrown Exception

        cleanup:
        classloader?.close()
    }