private
    val buildModel = CIBuildModel(
        projectId = "Gradle_Check",
        branch = VersionedSettingsBranch("master"),
        buildScanTags = listOf("Check"),
        subprojects = JsonBasedGradleSubprojectProvider(File("../.teamcity/subprojects.json"))
    )

    @Test
    fun `create correct PerformanceTest build type for Linux`() {
        val performanceTest = PerformanceTest(
            buildModel,
            Stage(

    runs-on: ubuntu-latest
    steps:
      - name: git clone
        uses: actions/checkout@v4
      - id: setup-matrix
        run: echo "matrix=$(jq -c -f .github/workflows/extract-unit-test-split.jq .teamcity/subprojects.json)" >> $GITHUB_OUTPUT
      - name: setup java
        uses: actions/setup-java@v4
        with:
          distribution: temurin
          java-version: 11
      - id: determine-sys-prop-args

 their source trees set up in the same way as their colleagues.

 here's what I do currently in the netbeans part of the mavenide project to
 find the relevant subprojects/sibling projects. I check if the user has
 defined the maven.multiproject.includes property in any of his properties
 files for the current project. if yes. then I'm able to find projects that

        build/report-* => $hiddenArtifactDestination
        build/tmp/teŝt files/** => $hiddenArtifactDestination/teŝt-files
        build/errorLogs/** => $hiddenArtifactDestination/errorLogs
        subprojects/internal-build-reports/build/reports/incubation/all-incubating.html => incubation-reports
        build/reports/dependency-verification/** => dependency-verification-reports
    """.trimIndent()

      </description>
      <fields>
        <field xdoc.separator="blank">
          <name>modules</name>
          <version>4.0.0+</version>
          <description>The modules (sometimes called subprojects) to build as a part of this
            project. Each module listed is a relative path to the directory containing the module.
            To be consistent with the way default urls are calculated from parent, it is recommended

                defaultMavenExecutionResult);
        final ProjectDependencyGraphStub dependencyGraphStub = new ProjectDependencyGraphStub();
        session.setProjectDependencyGraph(dependencyGraphStub);
        session.setProjects(dependencyGraphStub.getSortedProjects());

        LifecycleModuleBuilder moduleBuilder = container.lookup(LifecycleModuleBuilder.class);
        set(moduleBuilder, "mojoExecutor", mojoExecutor);

    private final ConcurrentMap<String, ConcurrentMap<String, ConcurrentMap<String, Object>>>
            pluginContextsByProjectAndPluginKey = new ConcurrentHashMap<>();

    public void setProjects(List<MavenProject> projects) {
        if (!projects.isEmpty()) {
            MavenProject first = projects.get(0);
            this.currentProject = ThreadLocal.withInitial(() -> first);

        MavenSession session = new MavenSession(
                getContainer(), configuration.getRepositorySession(), request, new DefaultMavenExecutionResult());
        session.setProjects(projects);
        session.setAllProjects(session.getProjects());
        session.setSession(defaultSessionFactory.newSession(session));

        SessionScope sessionScope = getContainer().lookup(SessionScope.class);

            project.setPluginArtifactRepositories(request.getPluginArtifactRepositories());
            projects.add(project);
        }

        session.setProjects(projects);
        session.setAllProjects(session.getProjects());

        return session;
    }

    protected void initRepoSession(ProjectBuildingRequest request) throws Exception {

        MavenSession session =
                new MavenSession(container, repositorySession, request, new DefaultMavenExecutionResult());
        session.setProjects(Collections.<MavenProject>emptyList());
        return session;
    }

    @Test
    public void testTwoExpressions() throws Exception {
        MavenProject project = createDefaultProject();