MavenProject project =
                projectBuilder.build(modelSource, buildingRequest).getProject();
        project.setExecutionRoot(true);
        request.setProjectPresent(false);

        return Arrays.asList(project);
    }

        super(createMetadata(artifact, createVersioning(snapshot)));
        this.artifact = artifact;
    }

    @Override
    public boolean storedInGroupDirectory() {
        return false;
    }

    @Override
    public boolean storedInArtifactVersionDirectory() {
        return true;
    }

    @Override
    public String getGroupId() {
        return artifact.getGroupId();
    }

        exNodes.add(node);
        return this;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == null) {
            return false;
        }

        if (MetadataGraphNode.class.isAssignableFrom(obj.getClass())) {
            MetadataGraphNode node2 = (MetadataGraphNode) obj;

            if (node2.metadata == null) {

        mavenExecutionRequest.setGoals(Arrays.asList("clean"));
        final MavenSession session = new MavenSession(
                null,
                new DefaultRepositorySystemSession(h -> false),
                mavenExecutionRequest,
                defaultMavenExecutionResult);
        final ProjectDependencyGraphStub dependencyGraphStub = new ProjectDependencyGraphStub();

                    "summary": "Read Items",
                    "operationId": "read_items_items__get",
                    "parameters": [
                        {
                            "required": False,
                            "schema": {
                                "title": "X-Token",
                                "anyOf": [
                                    {"type": "array", "items": {"type": "string"}},

	// Filter
	if !o.Recursive {
		entries.o = make(metaCacheEntries, 0, o.Limit)
		pastPrefix := false
		err := r.readFn(func(entry metaCacheEntry) bool {
			if o.Prefix != "" && !strings.HasPrefix(entry.name, o.Prefix) {
				// We are past the prefix, don't continue.
				pastPrefix = true
				return false
			}

            gradleWrapper {
                name = "GRADLE_RUNNER"
                gradleParams =
                    (
                        tasks +
                            buildToolGradleParameters(isContinue = false)
                    ).joinToString(separator = " ")
                skipConditionally()
            }
        }

        fun BuildSteps.adHocPerformanceTest(tests: List<String>) {
            gradleStep(

            param("teamcity.ui.settings.readOnly", "true")
            // Avoid rebuilding same revision if it's already built on another branch
            param("teamcity.vcsTrigger.runBuildOnSameRevisionInEveryBranch", "false")
            param("env.DEVELOCITY_ACCESS_KEY", "%ge.gradle.org.access.key%;%gbt-td.grdev.net.access.key%")
            param("env.CHROME_BIN", "%linux.chrome.bin.path%")

            text(

        }
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        AbstractLanguageElement that = (AbstractLanguageElement) o;
        return Objects.equals(rawCommentText, that.rawCommentText) &&
            Objects.equals(annotationNames, that.annotationNames);
    }

     *
     * @param version the version to test, must not be {@code null}
     * @return {@code true} if this range contains the specified version, {@code false} otherwise
     */
    boolean contains(@Nonnull Version version);

    /**
     * {@return the string representation of this version}
     */
    @Nonnull
    @Override
    String toString();