def iae = new IllegalArgumentException("badness", npe)
        def re = new RuntimeException("sadness")
        def mbf = new MultipleBuildFailures([re, iae])

        expect:
        with(ExceptionMetadataHelper.extractCauses(mbf)) {
            size() == 2
            get(0).message == "sadness"
            with(get(1)) {
                message == "badness"

            assert t.name == "thingName"
"""

        expect:
        succeeds()
    }

    def "plugin can create instance of interface that extends Named"() {
        buildFile """
            interface Thing extends Named { }

            def t = objects.newInstance(Thing, "thingName")
            assert t.name == "thingName"
"""

        expect:
        succeeds()
    }

    }

    def "has display name"() {
        expect:
        library.displayName.displayName == "C++ library 'main'"
        library.toString() == "C++ library 'main'"
    }

    def "has implementation configuration"() {
        expect:
        library.implementationDependencies == project.configurations.implementation
    }

    def "has api configuration"() {
        expect:

                    }
                }
            }
        """)

        when:
        blockingServer.expect("before-resolve")
        blockingServer.expect("after-resolve")
        blockingServer.expect("other")
        run("undeclared", "other")

        then:
        noExceptionThrown()
    }

        expect:
        succeeds()
    }

    def canAddExtensionsToProject() {

        buildFile '''
extensions.test = new ExtensionBean()

assert test instanceof ExtensionBean
test { it ->
    assert it instanceof ExtensionBean
    assert it == project.test
}
class ExtensionBean {
}
'''

        expect:
        succeeds()
    }

        expect:
        id.getNamespace() == "some-namespace"
        id.getName() == "some-name"
    }

    def "hashCode and equals determine equality" () {
        given:
        NamespaceId id1 = new NamespaceId("some-namespace", "some-name")
        NamespaceId id2 = new NamespaceId("some-namespace", "some-name")

        expect:
        id1 Matchers.strictlyEqual(id2)
    }

		// Won't currently get an error as MarshalTo can't return one
		result, _ := q.Marshal()
		q.MarshalTo(result)
		if q.Cmp(testCase.expect) != 0 {
			t.Errorf("Expected: %v, Actual: %v", testCase.expect, q)
		}
	}
	// Test when i is {0,0}
	table2 := []struct {
		dec    *inf.Dec
		expect Quantity
	}{
		{dec(0, 0).Dec, Quantity{i: int64Amount{value: 0, scale: 0}, d: infDecAmount{dec(0, 0).Dec}, s: "0", Format: DecimalSI}},

        conversionFails('09')
        conversionFails(TOO_BIG_STR)
    }

    def convertsVersionToVersion() {
        expect:
        JavaVersion.toVersion(JavaVersion.VERSION_1_4) == JavaVersion.VERSION_1_4
    }

    def convertsNumberToVersion() {
        expect:
        JavaVersion.toVersion(1.3) == JavaVersion.VERSION_1_3
        JavaVersion.toVersion(1.5) == JavaVersion.VERSION_1_5

            assert taskProvider.get().prop == "value 4"
        '''

        expect:
        succeeds 'help'
    }

    def "throws exception when replacing non-existent task when #description"() {
        buildFile << """
            tasks.${api}
        """

        expect:
        fails 'help'

        parser.option('a')
        parser.option('long-value')

        expect:
        def result = parser.parse([])
        !result.hasOption('a')
        !result.hasOption('long-value')
        result.extraArguments == []
    }

    def parsesShortOption() {
        parser.option('a')
        parser.option('b')

        expect:
        def result = parser.parse(['-a'])
        result.hasOption('a')