<mxGeometry relative="1" as="geometry">
                        <mxPoint x="105" y="-280" as="sourcePoint"/>
                        <mxPoint x="390" y="-260" as="targetPoint"/>
                        <Array as="points">
                            <mxPoint x="390" y="-430"/>
                        </Array>
                    </mxGeometry>

    }

    def "addAll from iterable"() {
        expect:
        addAll([], [1, 2, 3] as Iterable) == [1, 2, 3]
        addAll([] as Set, [1, 2, 3, 1] as Iterable) == [1, 2, 3] as Set
    }

    def "addAll from array"() {
        expect:
        addAll([], 1, 2, 3) == [1, 2, 3]
        addAll([] as Set, 1, 2, 3, 1) == [1, 2, 3] as Set
    }

    def "injection"() {
        expect:
        def target = []

    get() = get("projectRoot") as File


/**
 * Path of the local Gradle installation as configured in IntelliJ.
 */
internal
val Environment.gradleHome: File?
    get() = get("gradleHome") as? File


/**
 * URI of the remote Gradle distribution as configured in IntelliJ.
 */
internal
val Environment.gradleUri: URI?
    get() = get("gradleUri") as? URI


/**

                    <mxGeometry relative="1" as="geometry">
                        <mxPoint x="105" y="-280" as="sourcePoint"/>
                        <mxPoint x="390" y="-260" as="targetPoint"/>
                        <Array as="points">
                            <mxPoint x="390" y="-430"/>
                        </Array>
                    </mxGeometry>

        accumulator.addClass("c", hash, null, [], [] as Set, IntSets.EMPTY_SET)

        expect:
        accumulator.dependentsMap.a.privateDependentClasses == [] as Set
        accumulator.dependentsMap.a.accessibleDependentClasses == ['b'] as Set
        accumulator.dependentsMap.b.privateDependentClasses == ['a'] as Set
        accumulator.dependentsMap.b.accessibleDependentClasses == [] as Set

            ConstantValueKind.Boolean -> value as Boolean
            ConstantValueKind.Char -> value as Char
            ConstantValueKind.String -> value as String
            ConstantValueKind.Byte -> (value as Number).toByte()
            ConstantValueKind.Double -> (value as Number).toDouble()
            ConstantValueKind.Float -> (value as Number).toFloat()
            ConstantValueKind.Int -> (value as Number).toInt()

    @Rule
    TestNameTestDirectoryProvider tmp = new TestNameTestDirectoryProvider(getClass())

    def processor = Mock(TestResultProcessor)

    @Subject
    def classProcessor = createProcessor([] as Set, [] as Set, [] as Set, [] as Set, [] as Set)

    JUnitTestClassProcessor createProcessor(Set<String> includeCategories, Set<String> excludeCategories, Set<String> includedTests, Set<String> excludedTests, Set<String> includedTestsCommandLine) {

        store.write({ it.writeInt(10) } as BinaryStore.WriteAction)
        store.write({ it.writeString("x") } as BinaryStore.WriteAction)
        def data1 = store.done()
        store.write({ it.writeString("y") } as BinaryStore.WriteAction)
        def data2 = store.done()

        then:
        data1.read({ it.readInt() } as BinaryStore.ReadAction) == 10
        data1.read({ it.readString() } as BinaryStore.ReadAction) == "x"

        def invocation = new MethodInvocation(method, [[] as Thing[]] as Object[])

        when:
        def serialized = serialize(invocation)
        def result = deserialize(serialized)

        then:
        result.method == method
        result.arguments == [[] as Thing[]] as Object[]
    }

    def "replaces a method that has already been seen with an integer ID"() {

        expect:
        matcher.matches(["a", "c"] as String[], 0)
        matcher.matches(["a", "c", "d"] as String[], 0)
        matcher.matches(["prefix", "a", "c"] as String[], 1)

        and:
        !matcher.matches([] as String[], 0)
        !matcher.matches(["a"] as String[], 0)
        !matcher.matches(["other"] as String[], 0)
        !matcher.matches(["a", "other"] as String[], 0)