Project project = mock(Project.class);
        when(project.getBuild()).thenReturn(build);
        when(project.getBasedir()).thenReturn(Path.of("myproject"));
        when(project.getOutputDirectory(any(ProjectScope.class))).thenCallRealMethod();

        assertEquals(Path.of("myproject", "target", "classes"), targetPath(project));

        scope = ProjectScope.TEST;

    buildScanAction: (gradleRootProject: Project, infoCollectedInBuildLogic: Any, infoCollectedInMainBuild: Any) -> Unit
) {
    val gradleRootProject = when {
        project.name == "gradle" -> project.rootProject
        project.rootProject.name == "build-logic" -> rootProject.gradle.parent?.rootProject
        else -> project.gradle.parent?.rootProject
    }

    def convertsMethodSignatureToLink() {
        MethodMetaData method = method('someName', signature: 'someName(org.gradle.SomeClass, java.lang.Object)')
        _ * nameResolver.resolve('SomeClass', classMetaData) >>'org.gradle.SomeClass'
        _ * nameResolver.resolve('Object', classMetaData) >>'java.lang.Object'
        _ * classMetaData.declaredMethods >> ([method] as Set)
        _ * linkRenderer.link(method, listener) >> parse('<someLinkElement/>')

    // -----------/
    // - Methods -/
    // -----------/

    /**
     * Method checkFieldWithDuplicate.
     *
     * @param parser a parser object.
     * @param parsed a parsed object.
     * @param alias a alias object.
     * @param tagName a tagName object.
     * @throws XmlPullParserException XmlPullParserException if
     * any.
     * @return boolean
     */
    private boolean checkFieldWithDuplicate(

    default DependencyResolverResult resolve(@Nonnull Session session, @Nonnull Project project) {
        return resolve(
                DependencyResolverRequest.build(session, DependencyResolverRequest.RequestType.RESOLVE, project));
    }

    @Nonnull
    default DependencyResolverResult resolve(
            @Nonnull Session session, @Nonnull Project project, @Nonnull PathScope scope) {

     * @param time The build time of the project in milliseconds.
     * @param cause The cause of the build failure, may be {@code null}.
     */
    public BuildFailure(MavenProject project, long time, Throwable cause) {
        this(project, Duration.ofMillis(time), cause);
    }

    /**
     * Creates a new build summary for the specified project.
     *
     * @param project The project being summarized, must not be {@code null}.

    /**
     * Builds a project descriptor from the specified POM file.
     *
     * @param projectFile The POM file to build the project from, must not be {@code null}.
     * @param request The project building request that holds further parameters, must not be {@code null}.
     * @return The result of the project building, never {@code null}.
     * @throws ProjectBuildingException If the project descriptor could not be successfully built.

 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.extension.internal;

import javax.inject.Inject;
import javax.inject.Named;
import javax.inject.Provider;
import javax.inject.Singleton;

import java.util.Objects;

import org.apache.maven.internal.CoreRealm;

/**
 * CoreExportsProvider
 */
@Named
@Singleton

     * </ul>
     *
     * <p>The implementation must ensure that the returned object is functionally
     * equivalent to the input object from the perspective of the Maven model.</p>
     *
     * @param <T> the type of the model object
     * @param object the model object to process
     * @return the processed object (may be the same instance, a pooled instance, or a modified instance)

		t.Errorf("buf = %q; want foo", buf)
	}

	r.Reset(strings.NewReader("bar bar"))
	checkAll(r, "bar bar")

	*r = Reader{} // zero out the Reader
	r.Reset(strings.NewReader("bar bar"))
	checkAll(r, "bar bar")

	// Wrap a reader and then Reset to that reader.
	r.Reset(strings.NewReader("recur"))
	r2 := NewReader(r)
	checkAll(r2, "recur")
	r.Reset(strings.NewReader("recur2"))
	r2.Reset(r)