@Override
            public void execute(CustomParameter customParameter) {
                customParameter.setValue(model1.getParameterValue() + ":parameter2");
            }
        });
        result.add(model0);
        result.add(model1);
        result.add(model2);
        return result;
    }

        server.expectConcurrent("model-a", "model-b")

        executer.withArguments(ENABLE_CLI)
        def model3 = runBuildAction(new FetchCustomModelForEachProjectInParallel())

        then:
        model3.size() == 3
        model3[0].message == "It works from project :"
        model3[1].message == "this is project a"
        model3[2].message == "this is project b"

        and:

            modelsCreated(":", ":a")
        }

        when:
        executer.withArguments(ENABLE_CLI)
        def model2 = runBuildAction(new FetchCustomModelForEachProjectInTree())

        then:
        model2.size() == 2
        model2[0].message == "It works from project :"
        model2[1].message == "It works from project :a"

        and:
        fixture.assertStateLoaded()

        when:

        model2.values().every { it.size() == 2 }

        model2[":"][0].message == "fetch2 It works from project :"
        model2[":"][1].message == "fetch1 It works from project :"
        model2[":a"][0].message == "fetch2 It works from project :a"
        model2[":a"][1].message == "fetch1 It works from project :a"
    }

    def "no parameterized models are reused when settings change"() {
        when:

from fastapi import FastAPI
from fastapi.testclient import TestClient
from pydantic import BaseModel

app = FastAPI()


class Model(BaseModel):
    pass


class Model2(BaseModel):
    a: Model


class Model3(BaseModel):
    c: Model
    d: Model2


@app.get("/", response_model=Model3)
def f():
    return {"c": {}, "d": {"a": {}}}


client = TestClient(app)


def test_get_api_route():

        expect:
        def model = builder.create(rootBuildState)
        model.includedBuilds.size() == 1

        def model1 = model.includedBuilds[0]
        model1.rootDir == dir1
        model1.includedBuilds.size() == 1

        def model2 = model1.includedBuilds[0]
        model2.rootDir == dir2
        model2.includedBuilds.empty

        model.editableBuilds.size() == 2

    @Override
    public CustomModel execute(BuildController controller) {
        CustomModel model1 = controller.getModel(CustomModel.class);
        CustomModel model2 = controller.getModel(CustomModel.class);
        assert model1.getThing() == model2.getThing();
        return model1;
    }

        def model2 = models2.right
        model2.size() == 2
        model2[0].message == "It works from project :"
        model2[1].message == "It works from project :a"

        and:
        fixture.assertStateLoaded()
        outputDoesNotContain("creating model")
    }

    def "caches execution of phased BuildAction that queries custom tooling model and that runs tasks"() {
        given:

                    },
                }
            },
            "/response_model_model1-annotation_model2-return_same_model": {
                "get": {
                    "summary": "Response Model Model1 Annotation Model2 Return Same Model",
                    "operationId": "response_model_model1_annotation_model2_return_same_model_response_model_model1_annotation_model2_return_same_model_get",
                    "responses": {

                void apply(Project project) {
                    registry.register(new SomeModelBuilder())
                    project.tasks.register("model1", SomeTask)
                    project.tasks.register("model2", SomeTask)
                    project.configurations.create("classpath")
                }
            }

            class SomeModelBuilder implements ToolingModelBuilder {