MavenProject project = mock(MavenProject.class);
        when(project.getGroupId()).thenReturn("org.apache.maven.plugins.overflow");
        when(project.getArtifactId()).thenReturn("maven-project-info-reports-plugin");
        when(project.getPackaging()).thenReturn("maven-plugin");
        when(project.getName()).thenReturn("Apache Maven Project Info Reports Plugin");

        MavenProject project2 = ex2.getResults().get(0).getProject();
        assertNotNull(project2);
        assertEquals("testArtifactMissingVersion", project2.getArtifactId());
        assertEquals(pomFile, project2.getFile());
    }

    @Test
    void testReadInvalidPom() throws Exception {
        File pomFile = new File("src/test/resources/projects/badPom.xml").getAbsoluteFile();

    def "workspace id of project transforms is unique per build with included builds"() {
        // The setup here is in a way that the project path of the project dependency in the same build
        // is the same as the buildTreePath of the substituted project dependency in the included build.

                        "projecta",
                        "projectb"
                    ]
                }
            }
        }
    ]
}`

	policyProjectsMap = map[string]string{
		// grants access to bucket `projecta` if user is in group `projecta`
		"projecta": policyProjectA,

		// grants access to bucket `projectb` if user is in group `projectb`

dependencies {
    implementation(projects.buildCache)
    implementation(projects.buildCacheBase)
    implementation(projects.buildCacheLocal)
    implementation(projects.buildCachePackaging)
    implementation(projects.buildCacheSpi)
    implementation(projects.buildOperations)
    implementation(projects.concurrent)
    implementation(projects.fileTemp)
    implementation(projects.files)
    implementation(projects.functional)

dependencies {
    api(projects.configurationProblemsBase)
    api(projects.core)
    api(projects.coreApi)
    api(projects.graphSerialization)
    api(projects.stdlibJavaExtensions)
    api(projects.loggingApi)

    api(libs.kotlinStdlib)

    implementation(projects.baseServices)

    }

    private
    fun applyProjectStates(projects: List<CachedProjectState>, gradle: GradleInternal) {
        for (project in projects) {
            if (project is ProjectWithWork && project.normalizationState != null) {
                val projectState = gradle.owner.projects.getProject(project.path)
                projectState.mutableModel.normalization.configureFromCachedState(project.normalizationState)
            }
        }

    api(project(":jvm-services"))
    api(project(":language-java"))
    api(project(":language-jvm"))
    api(project(":problems-api"))
    api(project(":platform-base"))
    api(project(":toolchains-jvm"))
    api(project(":toolchains-jvm-shared"))
    api(project(":workers"))
    api(project(":worker-main"))
    api(project(":build-process-services"))

    api(libs.inject)
    api(libs.jsr305)

    )
}

dependencies {
    api(projects.serviceProvider)
    api(project(":base-services"))
    api(project(":core-api"))
    api(project(":core"))
    api(project(":dependency-management"))
    api(project(":file-collections"))
    api(project(":stdlib-java-extensions"))
    api(project(":logging"))
    api(project(":messaging"))
    api(project(":model-core"))

    api(libs.guava)
    api(libs.jsr305)

    implementation(project(":maven"))
    implementation(project(":platform-base"))
    implementation(project(":platform-jvm"))
    implementation(project(":publish"))

    runtimeOnly(libs.groovy)

    integTestImplementation(testFixtures(project(":dependency-management")))
    integTestImplementation(testFixtures(project(":resources-http")))

    testImplementation(project(":language-java")) {