foo.setDuplicateHostName("foo.com");
        duplicateHostHelper.duplicateHostList.add(foo);
        DuplicateHost bar = new DuplicateHost();
        bar.setRegularName("www.bar.com");
        bar.setDuplicateHostName("mail.bar.com");
        duplicateHostHelper.duplicateHostList.add(bar);
        DuplicateHost hoge = new DuplicateHost();
        hoge.setRegularName("www.foo.com");

	}{
		{
			name: "matchOneOnly",
			path: "/foo/bar/{*}",
			want: &uri_template.UriTemplateMatchConfig{
				PathTemplate: "/foo/bar/*",
			},
		},
		{
			name: "matchAnyOnly",
			path: "/foo/{**}/bar",
			want: &uri_template.UriTemplateMatchConfig{
				PathTemplate: "/foo/**/bar",
			},
		},
		{
			name: "matchAnyAndOne",
			path: "/{*}/foo/{**}/bar",
			want: &uri_template.UriTemplateMatchConfig{

		{Namespace: "foo", Name: "bar", Username: "system:serviceaccount:bar", Expect: false},
		{Namespace: "foo", Name: "bar", Username: ":bar", Expect: false},
		{Namespace: "foo", Name: "bar", Username: "foo:bar", Expect: false},
		{Namespace: "foo", Name: "bar", Username: "", Expect: false},

		{Namespace: "foo2", Name: "bar", Username: "system:serviceaccount:foo:bar", Expect: false},

    map.put("quux", 3);

    map.remove("bar");
    assertThat(map.entrySet())
        .containsExactly(Maps.immutableEntry("foo", 1), Maps.immutableEntry("quux", 3))
        .inOrder();
  }

  public void testInsertionOrderAfterRemoveLast() {
    BiMap<String, Integer> map = HashBiMap.create();
    map.put("foo", 1);
    map.put("bar", 2);
    map.put("quux", 3);

    map.remove("quux");

        assertFailure(
            parser("bar"),
            "Expecting symbol 'foo', but got 'bar' instead"
        )
    }

    @Test
    fun `can parse sequence of symbols`() {
        val parser = combinator.symbol("foo") * combinator.symbol("bar")
        assertSuccess(parser("foo bar"))
        assertSuccess(parser("foo /*comment*/  bar"))
    }

    @Test

    with pytest.raises(ValidationError):
        ModelWithAlias(foo="Bar")


def test_encode_model_with_alias():
    model = ModelWithAlias(Foo="Bar")
    assert jsonable_encoder(model) == {"Foo": "Bar"}


def test_encode_model_with_default():
    model = ModelWithDefault(foo="foo", bar="bar")
    assert jsonable_encoder(model) == {"foo": "foo", "bar": "bar", "bla": "bla"}

fun test() {
    <expr>Foo</expr>.Bar().bar()
}

class Foo {
    class Bar {
        fun bar() {}
    }

public final class CodeFragment$run$Bar {
    // source: 'fragment.kt'
    enclosing method CodeFragment.run()V
    inner (local) class CodeFragment$run$Bar Bar
    inner (local) class CodeFragment$run$Foo Foo
    public method <init>(): void
}

public class CodeFragment$run$Foo {
    // source: 'fragment.kt'
    enclosing method CodeFragment.run()V
    inner (local) class CodeFragment$run$Foo Foo
    public method <init>(): void

			},
		},
		{
			code: `
package main

func main() {

            bar:
   bar:
bar:
bar            :
}
`,

			errors: []string{
				"^.+:6:13: label bar defined and not used\n",
				".+:7:4: label bar already defined at .+:6:13\n",
				".+:8:1: label bar already defined at .+:6:13\n",
				".+:9:1: label bar already defined at .+:6:13\n$",
			},
		},
	}

	for i, test := range tests {

spec:
  rules:
  - matches:
    - path:
        type: PathPrefix
        value: /bar
    backendRefs:
    - group: multicluster.x-k8s.io
      kind: ServiceImport
      name: bar
      namespace: bar
---
kind: ReferenceGrant
apiVersion: gateway.networking.k8s.io/v1beta1
metadata:
  name: bar
  namespace: bar
spec:
  from:
  - group: gateway.networking.k8s.io
    kind: HTTPRoute
    namespace: foo