"HttpErrorStatusCodeException with server error"            | new HttpErrorStatusCodeException("something", "something", 503, "something")
        "HttpErrorStatusCodeException with transient client error"  | new HttpErrorStatusCodeException("something", "something", 429, "something")

            tasks.register("something") {
                doLast {
                    println "configurationCache.requested=" + buildFeatures.configurationCache.requested.getOrNull()
                    println "configurationCache.active=" + buildFeatures.configurationCache.active.get()
                }
            }
        """

        when:
        run "something"
        then:

        assertFalse(result.isFound());

        try {
            object.setProperty("something", "value");
            fail();
        } catch (MissingPropertyException e) {
            assertThat(e.getMessage(), equalTo("Could not set unknown property 'something' for <display-name>."));
        }

        result = object.trySetProperty("something", "value");
        assertFalse(result.isFound());
    }

        """

        when:
        run "something"
        then:
        fixture.assertNoConfigurationCache()
        outputContains("configurationCache.requested=null")
        outputContains("configurationCache.active=false")
        outputContains("isolatedProjects.requested=null")
        outputContains("isolatedProjects.active=false")

        when:
        run "something", "-Dorg.gradle.unsafe.isolated-projects=false"

            class SomeOverriddenPrecompiledScript : Some {
                override fun something() {
                    println("precompiled overridden")
                }
            }

            SomePrecompiledScript().something()
            SomeOverriddenPrecompiledScript().something()
            """
        )
        withBuildScript(
            """
            import some.Some

        @Incubating
        Object doSomething() { null }
    }

    class Child extends Base implements Serializable {
        @Nullable
        Object doSomething() { null }
    }

    def "overridden methods retain annotations"() {
        when:
        def methods = ModelSchemaUtils.getCandidateMethods(Child)

        then:
        methods.methodNames() == (["doSomething"] as Set)

            this.service = service
            this.x = x
        }

        @Override
        void execute(Details details) {
            details.see(service.doSomething(), x)
        }
    }

    static interface SomeService<T> {
        T doSomething()
    }

class Item(BaseModel):
    name: str

    if PYDANTIC_V2:
        model_config = {
            "json_schema_extra": {
                "x-something-internal": {"level": 4},
            }
        }
    else:

        class Config:
            schema_extra = {
                "x-something-internal": {"level": 4},
            }


@app.get("/foo", response_model=Item)
def foo():
    return {"name": "Foo item"}

                new CaseSensitivityTestSpec(children, child, childIndex),
                new CaseSensitivityTestSpec(children, "$child/a/something", childIndex),
                new CaseSensitivityTestSpec(children, "$child/A/something", childIndex),
                new CaseSensitivityTestSpec(children, "$child/e/something", childIndex),
                new CaseSensitivityTestSpec(children, "$child/E/other", childIndex),
            ]
        }
    }

	// Create an unrelated GatewayClass, we should not do anything to it
	createClass("something-else", "different-controller")
	expectClass("something-else", "different-controller")
	deleteClass("something-else")
	expectClass("something-else", "")