"/a/b/c"                 | "/z"           | "/z"
        "a/b/c"                  | "/z"           | "/z"
        "a/b/c"                  | "/"            | "/"
        "/"                      | "/a/b/c"       | "/a/b/c"
        ""                       | "/a/b/c"       | "/a/b/c"
        "//host"                 | "/a/b//c"      | "//host/a/b/c"
        "//host/a/b/c"           | "/z"           | "//host/z"

	19: {"/", "/../a/b/c", "/a/b/c"},
	20: {"/", "./hello/world", "/hello/world"},
	21: {"/a", "../", "/"},
	22: {"/a/b/c", "..", "/a/b"},
	23: {"/a/b/c", "..///..///", "/a/"},
	24: {"/a/b/c", "..///..///..", "/"},
	25: {"/a/b/c", "..///..///..///..", "/"},
	26: {"/a/b/c", "..///..///..///..///..", "/"},
	27: {"/a/b/c/", "/d/e/f/", "/a/b/c/d/e/f/"},
	28: {"a/b/c/", ".", "a/b/c"},
	29: {"a/b/c/", "./d", "a/b/c/d"},

        !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"))

        val a = listOf("a", "b", "c")
        val b = listOf("a", "b", "c")

        assertThat(
            commonPrefixOf(listOf(a, b)),
            equalTo(listOf("a", "b", "c"))
        )
    }

    @Test
    fun `common is empty for different prefix`() {

        val a = listOf("0", "a", "b", "c")
        val b = listOf("1", "a", "b", "c")

        assertThat(
            commonPrefixOf(listOf(a, b)),

        assertThat(matcher, matchesDir());
        assertThat(matcher, matchesDir("a", "b"));
        assertThat(matcher, matchesDir("c", "a", "b"));
        assertThat(matcher, matchesDir("a", "b", "c"));
        assertThat(matcher, matchesDir("c", "a", "b", "d"));
        assertThat(matcher, matchesDir("a", "b", "a", "b"));
        assertThat(matcher, matchesDir("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)
}

        declaredReplacements 'a->b'
        expect:
        resolvedModules 'b'
    }

    def "uses highest when it is last"() {
        declaredDependencies 'b', 'a', 'b:2'
        declaredReplacements 'a->b'
        expect:
        resolvedModules 'b:2'
    }

    def "uses highest when it is last following replacedBy"() {
        declaredDependencies 'a', 'b', 'b:2'
        declaredReplacements 'a->b'

    assertEquals(c, ImmutableMultiset.of("a", "b", "a"));
    assertEquals(c, ImmutableMultiset.of("a", "a", "b"));
    assertThat(c).isNotEqualTo(ImmutableMultiset.of("a", "b"));
    assertThat(c).isNotEqualTo(ImmutableMultiset.of("a", "b", "c", "d"));
  }

  public void testIterationOrder() {
    Collection<String> c = ImmutableMultiset.of("a", "b", "a");
    assertThat(c).containsExactly("a", "a", "b").inOrder();

  }

  @Test fun emptySameSite() {
    assertThat(parse(url, "a=b; SameSite=")!!.sameSite).isEqualTo("")
    assertThat(parse(url, "a=b; SameSite= ")!!.sameSite).isEqualTo("")
    assertThat(parse(url, "a=b; SameSite=\r\t \n")!!.sameSite).isEqualTo("")
  }

  @Test fun spaceInSameSite() {
    assertThat(parse(url, "a=b; SameSite=a b")!!.sameSite).isEqualTo("a b")
  }

  @Test fun trimLeadingAndTrailingWhitespaceFromSameSite() {