withBuildScript(
            """
            tasks {
                register<Task>("broken") {
                    val prop = objects.property(String::class.java)
                    // broken by https://youtrack.jetbrains.com/issue/KT-36297
                    prop.set(provider { "abc" })
                    doLast { println("$S{name} -> value = $S{prop.get()}") }

            class MyPlugin {
                static class Rules extends RuleSource {
                    @Model
                    String string() { "foo" }

                    @Mutate
                    void broken(String s) {
                        throw new RuntimeException("oh no!")
                    }
                }
            }

            apply type: MyPlugin

            model {

    }

    def "ignores invalid toolchains when finding a matching one"() {
        given:
        def queryService = createQueryServiceWithInstallations(["8.0", "8.0.242.hs-adpt", "8.0.broken"])

        when:
        def filter = createSpec(JavaLanguageVersion.of(8))
        def toolchain = queryService.findMatchingToolchain(filter)

        then:

            @Override
            String toString() {
                return "broken"
            }
        }

        when:
        publishArtifact.file

        then:
        def e = thrown(UnsupportedNotationException)
        e.message.startsWith("Cannot convert the provided notation to a File or URI: broken.")
    }

    def createArtifactFromFileInMap() {
        Task task = Mock()

    def "recovers from failed download"() {
        given:
        server.expect(server.head("/$TEST_DISTRIBUTION_URL"))
        prepareWrapper(getDefaultBaseUrl())
        server.expect(server.get("/$TEST_DISTRIBUTION_URL").broken())

        when:
        wrapperExecuter.withStackTraceChecksDisabled()
        def failure = wrapperExecuter.runWithFailure()

        then:
        failure.error.contains('Server returned HTTP response code: 500')

            classes.doLast {
                throw new RuntimeException("broken")
            }
        """

        when:
        fails(buildA, ":assemble")

        then:
        failure.assertHasDescription("Execution failed for task ':${buildName}:classes'.")
        failure.assertHasCause("broken")

        where:
        settings                     | buildName | dependencyName | display

			},
			allowed: false,
		},
		{
			description:                      "should always allow no-op update",
			clusterTrustBundleFeatureEnabled: true,
			authzErr:                         errors.New("broken"),
			attributes: &testAttributes{
				resource: certificatesapi.Resource("clustertrustbundles"),
				oldObj: &certificatesapi.ClusterTrustBundle{
					Spec: certificatesapi.ClusterTrustBundleSpec{

</suite>"""

        when: succeeds "test"

        then:
        if (VersionNumber.parse(version.toString()) > VersionNumber.parse('5.12.1')) {
            // Broken in 5.12.1, fixed in 5.13
            assert containsLinesThatMatch(result.output,
                "Gradle Test Executor \\d+ -> static out",
                "Gradle Test Executor \\d+ -> static err",

        }
    )


def test_post_broken_body(client: TestClient):
    response = client.post(
        "/items/",
        headers={"content-type": "application/json"},
        content="{some broken json}",
    )
    assert response.status_code == 422, response.text
    assert response.json() == IsDict(
        {
            "detail": [
                {
                    "type": "json_invalid",

        }
    )


@needs_py310
def test_post_broken_body(client: TestClient):
    response = client.post(
        "/items/",
        headers={"content-type": "application/json"},
        content="{some broken json}",
    )
    assert response.status_code == 422, response.text
    assert response.json() == IsDict(
        {
            "detail": [
                {
                    "type": "json_invalid",