!ModelPath.ROOT.isDirectChild(ModelPath.path("a.b"))

        ModelPath.path("a.b").isDirectChild(ModelPath.path("a.b.c"))
        !ModelPath.path("a.b").isDirectChild(ModelPath.path("a.b.c.d"))
        !ModelPath.path("a.b").isDirectChild(ModelPath.path("a.a.b"))
        !ModelPath.path("a.b").isDirectChild(ModelPath.path("a.b"))
        !ModelPath.path("a.b").isDirectChild(ModelPath.path("a"))

package mult

var sink int

type Multiplier interface {
	Multiply(a, b int) int
}

type Mult struct{}

func (Mult) Multiply(a, b int) int {
	for i := 0; i < 1000; i++ {
		sink++
	}
	return a * b
}

type NegMult struct{}

func (NegMult) Multiply(a, b int) int {
	for i := 0; i < 1000; i++ {
		sink++
	}
	return -1 * a * b
}

	// channel lead to the correct (named) directional
	// channel.
	B = f(a, b)
	B = f(a, B)
	B = f(b, a)
	B = f(B, a)

	B = f(a, b, B)
	B = f(a, B, b)
	B = f(b, B, a)
	B = f(b, a, B)
	B = f(B, a, b)
	B = f(B, b, a)

	// verify type error
	A = f /* ERROR "cannot use f(B, b, a) (value of type namedB) as namedA value in assignment" */ (B, b, a)
}

        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'],

type (
        // 0 and 1-element []-lists are syntactically valid
        _[A, B /* ERROR missing type constraint */ ] int
        _[A, /* ERROR missing type parameter name */ interface{}] int
        _[A, B, C /* ERROR missing type constraint */ ] int
        _[A B, C /* ERROR missing type constraint */ ] int
        _[A B, /* ERROR missing type parameter name */ interface{}] int
        _[A B, /* ERROR missing type parameter name */ interface{}, C D] int

        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"
    }

        new URI("s3://somebucket.au.s3.eu-central-1.amazonaws.com/a/b/file.txt")      | Optional.of(getRegion(Regions.EU_CENTRAL_1))                        | 'somebucket.au' | 'a/b/file.txt'
        new URI("s3://somebucket.au.s3-eu-central-1.amazonaws.com/a/b/file.txt")      | Optional.of(getRegion(Regions.EU_CENTRAL_1))                        | 'somebucket.au' | 'a/b/file.txt'