// misspelled     x.foo   ==    FoO    type X has no field or method foo, but does have field FoO
	// ok             x.foo   ==    foo
	// misspelled     x.foo   ==    foO    type X has no field or method foo, but does have field foO
	//
	// ok             x.Foo   !=    Foo
	// misspelled     x.Foo   !=    FoO    type X has no field or method Foo, but does have field FoO

			initialState: []runtime.Object{
				makeEndpoints("foo", []string{"1.2.3.4"}, []corev1.EndpointPort{{Name: "foo", Port: 8080, Protocol: "TCP"}}),
				makeEndpointSlice("foo", []string{"4.3.2.1"}, []corev1.EndpointPort{{Name: "foo", Port: 8080, Protocol: "TCP"}}),
			},
			expectUpdate: []runtime.Object{

    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
    assertEquals("[(bar,1)=b, (foo,1)=a, (foo,3)=c]", table.cellSet().toString());
  }

  public void testRowKeySetToString_ordered() {
    table = create("foo", 1, 'a', "bar", 1, 'b', "foo", 3, 'c');
    assertEquals("[bar, foo]", table.rowKeySet().toString());
  }

  public void testValuesToString_ordered() {

		{"/", "", "/"},
		{"/", "/", ""},
		{"/foo", "", "/foo"},
		{"/foo", "/", "foo"},
		{"/foo", "/foo", ""},
		{"/foo/bar", "/foo", "bar"},
		{"/foo/bar", "/foo/", "bar"},
		{"/foo/", "/", "foo/"},
		{"/foo/", "/foo", ""},
		{"/foo/", "/foo/", ""},

		// if prefix is not s's prefix, return s
		{"", "/", ""},
		{"/foo", "/bar", "/foo"},
		{"/foo", "/foo/bar", "/foo"},
		{"foo", "/foo", "foo"},
		{"/foo", "foo", "/foo"},

app = FastAPI()


@app.get("/default")
async def default(foo: Annotated[str, Query()] = "foo"):
    return {"foo": foo}


@app.get("/required")
async def required(foo: Annotated[str, Query(min_length=1)]):
    return {"foo": foo}


@app.get("/multiple")
async def multiple(foo: Annotated[str, object(), Query(min_length=1)]):
    return {"foo": foo}


@app.get("/unrelated")

        manager.apply("foo")

        then:
        1 * target.applyImperative("foo", { imperativeClass.isInstance(it) })

        and:
        manager.pluginContainer.size() == 1
        manager.hasPlugin("foo")
        def called = false
        manager.withPlugin("foo") {
            assert it.id == "foo"
            assert it.namespace == null
            assert it.name == "foo"
            called = true
        }

//line foo/bar.y:204
//line foo/bar.y:208
//line foo/bar.y:211
//line foo/bar.y:213
//line foo/bar.y:215
//line foo/bar.y:217
//line foo/bar.y:221
//line foo/bar.y:229
//line foo/bar.y:236
//line foo/bar.y:238
//line foo/bar.y:240
//line foo/bar.y:244
//line foo/bar.y:249
//line foo/bar.y:253
//line foo/bar.y:257
//line foo/bar.y:262
//line foo/bar.y:267
//line foo/bar.y:272
	if l == f {
//line foo/bar.y:277

        then:
        isCached(":foo")
    }

    def "uses cached subproject classloader when parent changes"() {
        settingsFile << "include 'foo'"
        addIsCachedCheck()
        addIsCachedCheck "foo"

        when:
        run()
        buildFile << "task foo"
        run()

        then:
        isNotCached()
        isCached(":foo")
    }

	{[]string{"/* Foo   */"}, " Foo\n"},
	{[]string{"/* Foo  Bar  */"}, " Foo  Bar\n"},
	{[]string{"/* Foo*/", "/* Bar*/"}, " Foo\n Bar\n"},
	{[]string{"/* Foo*/", "/**/", "/**/", "/**/", "// Bar"}, " Foo\n\nBar\n"},
	{[]string{"/* Foo*/", "/*\n*/", "//", "/*\n*/", "// Bar"}, " Foo\n\nBar\n"},
	{[]string{"/* Foo*/", "// Bar"}, " Foo\nBar\n"},
	{[]string{"/* Foo\n Bar*/"}, " Foo\n Bar\n"},

// misspelled     x.foo   ==    FoO    type X has no field or method foo, but does have field FoO
// ok             x.foo   ==    foo
// misspelled     x.foo   ==    foO    type X has no field or method foo, but does have field foO
//
// ok             x.Foo   !=    Foo
// misspelled     x.Foo   !=    FoO    type X has no field or method Foo, but does have field FoO