conversions[diagnostic] = creator
    }

    fun <A, B> add(diagnostic: KtDiagnosticFactory2<A, B>, creator: KaFirDiagnostic2Creator<A, B>) {
        conversions[diagnostic] = creator
    }

    fun <A, B, C> add(diagnostic: KtDiagnosticFactory3<A, B, C>, creator: KaFirDiagnostic3Creator<A, B, C>) {
        conversions[diagnostic] = creator
    }

		d = a + bits.RotateLeft32((a^b^c)+d+x4+0x4bdecfa9, 11)
		c = d + bits.RotateLeft32((d^a^b)+c+x7+0xf6bb4b60, 16)
		b = c + bits.RotateLeft32((c^d^a)+b+xa+0xbebfbc70, 23)
		a = b + bits.RotateLeft32((b^c^d)+a+xd+0x289b7ec6, 4)
		d = a + bits.RotateLeft32((a^b^c)+d+x0+0xeaa127fa, 11)
		c = d + bits.RotateLeft32((d^a^b)+c+x3+0xd4ef3085, 16)
		b = c + bits.RotateLeft32((c^d^a)+b+x6+0x04881d05, 23)

        where:
        expectedLines           | actualLines
        ["a", "b", "c"]         | ["a", "b", "c"]
        ["a"]                   | ["a", "b"]
        ["a"]                   | ["b", "a"]
        ["a"]                   | ["b", "a", "c"]
        ["b", "c"]              | ["a", "b", "c", "d"]
        ["b", "c"]              | ["a", "b", "c", "d", "b", "c", "e"]
    }

    def "can match order exactly (#executedTasks)"() {
        def spec = exact(':a', ':b', ':c')

        when:
        spec.assertMatches(-1, executedTasks)

        then:
        noExceptionThrown()

        where:
        executedTasks << [
            [':a', ':b', ':c'],
            [':a', ':b', ':c', ':d'],
            [':z', ':a', ':b', ':c'],
            [':a', ':z', ':b', ':c'],

        where:
        elements << [["a"], ["a", "b"]]
    }

    def "has a nice toString method"() {
        expect:
        PersistentList.of().toString() == "Nil"
        PersistentList.of("a").toString() == "a"
        PersistentList.of("a", "b").toString() == "a : b"
        PersistentList.of("a", "b", "c").toString() == "a : b : c"
        PersistentList.of("a", "b", "c", "d").toString() == "a : b : c : d"
    }

	}

	test(getTestTree(), []testCase{
		{"GET", "", "/a", "/a", nil},
		{"Get", "", "/b", "", nil},
		{"Get", "", "/a/b", "/a/b", nil},
		{"Get", "", "/a/c", "/a/{x}", []string{"c"}},
		{"Get", "", "/a/b/", "/a/b/{$}", nil},
		{"Get", "", "/a/b/c", "/a/b/{y}", []string{"c"}},
		{"Get", "", "/a/b/c/d", "/a/b/{x...}", []string{"c/d"}},
		{"Get", "", "/g/h/i", "/g/h/i", nil},
		{"Get", "", "/g/h/j", "/g/{x}/j", []string{"h"}},
	})

    @Rule
    public final BlockingHttpServer blockingServer = new BlockingHttpServer()

    def setup() {
        blockingServer.start()

        createDirs("a", "b", "c")
        settingsFile << """
            include 'a', 'b', 'c'
        """
        buildFile << """
            allprojects {
                task ping {
                    def projectName = project.name
                    doLast {

}
"""
        executer.withArgument('--info')
    }

    def "project dependency c->[a,b]"() {
        projectDependency from: 'c', to: ['a', 'b']
        when:
        run ':c:build'

        then:
        jarsBuilt 'a', 'b', 'c'
        depsCopied 'a', []
        depsCopied 'b', []
        depsCopied 'c', ['a', 'b']
    }

    def "project dependency c->b->a"() {

	LEAL	const(e)(SI*1), e

#define ROUND1(a, b, c, d, e, index) \
	LOAD(index, e); \
	FUNC1(a, b, c, d, e); \
	MIX(a, b, c, d, e, 0x5A827999)

#define ROUND1x(a, b, c, d, e, index) \
	SHUFFLE(index, e); \
	FUNC1(a, b, c, d, e); \
	MIX(a, b, c, d, e, 0x5A827999)

#define ROUND2(a, b, c, d, e, index) \
	SHUFFLE(index, e); \
	FUNC2(a, b, c, d, e); \
	MIX(a, b, c, d, e, 0x6ED9EBA1)

fun foo(a: Int): Int {
    val b: Int = 1
    for (n in 1..a) {
        <expr>if (a + b > 0) break
        consume(a - b)
        if (a - b > 0) break
        consume(a + b)</expr>
    }
    return 1
}