want    string
	}{
		{"", New("#"), ""},
		{"", foo, ""},
		{"foo=bar", foo, "bar"},
		{"foo=bar,after=x", foo, "bar"},
		{"before=x,foo=bar,after=x", foo, "bar"},
		{"before=x,foo=bar", foo, "bar"},
		{",,,foo=bar,,,", foo, "bar"},
		{"foodecoy=wrong,foo=bar", foo, "bar"},
		{"foo=", foo, ""},
		{"foo", foo, ""},
		{",foo", foo, ""},
		{"foo=bar,baz", New("#loooooooong"), ""},
	}
	for _, tt := range tests {

        ("/default?foo=bar", 200, {"foo": "bar"}),
        ("/required?foo=bar", 200, {"foo": "bar"}),
        ("/required", 422, foo_is_missing),
        ("/required?foo=", 422, foo_is_short),
        ("/multiple?foo=bar", 200, {"foo": "bar"}),
        ("/multiple", 422, foo_is_missing),
        ("/multiple?foo=", 422, foo_is_short),
        ("/unrelated?foo=bar", 200, {"foo": "bar"}),
        ("/unrelated", 422, foo_is_missing),

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

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

		{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");

        options.environment = ["FOO": "bar"]
        other.environment = ["FOO": "bar", "BAR": "foo"]

        then:
        !options.isCompatibleWith(other)
    }

    def "is compatible with the same system properties"() {
        def other = new DefaultJavaForkOptions(resolver, fileCollectionFactory, new DefaultJavaDebugOptions())

        when:
        options.systemProperties = ["foo": "bar", "bar": "foo"]

        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

			ingressClass: makeValidIngressClass("test123", "foo.co/bar",
				setParams(makeIngressClassParams(nil, "foo", "bar", utilpointer.String("Cluster"), nil)),
			),
			expectedErrs: field.ErrorList{},
		},
		"valid name, valid controller, invalid scope": {
			ingressClass: makeValidIngressClass("test123", "foo.co/bar",
				setParams(makeIngressClassParams(nil, "foo", "bar", nil, utilpointer.String("foo_ns"))),
			),

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

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