plugins {
    id("org.gradle.toolchains.foojay-resolver-convention").version("1.0.0")
}

includeBuild("../build-logic-settings")

// Shared basics for all
include("basics")

// Platform: defines shared dependency versions
include("build-platform")

// Compute the identity/version we are building and related details (like current git commit)
include("module-identity")

    /**
     * Transform Graph into a Collection of metadata objects that
     * could serve as a classpath for a particular scope
     *
     * @param dirtyGraph - dependency graph
     * @param scope - which classpath to extract
     * @param resolve - whether to resolve artifacts.
     * @return Collection of metadata objects in the linked subgraph of the graph which

def test_broken_raise():
    with pytest.raises(ValueError, match="Broken after yield"):
        client.get("/broken")


def test_broken_no_raise():
    """
    When a dependency with yield raises after the yield (not in an except), the
    response is already "successfully" sent back to the client, but there's still
    an error in the server afterwards, an exception is raised and captured or shown

        with(details) {
            when {
                // Nullaway-enabled targets must not depend on nullaway-disabled ones.
                // They can depend on nullaway-undefined, which any external dependency is going to be.
                producerValue == NullawayState.DISABLED && consumerValue == NullawayState.ENABLED -> incompatible()
                else -> compatible()
            }
        }
    }

import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.assertTrue;

/**
 * A test which demonstrates maven's dependency management
 *
 */
@Deprecated
class ProjectInheritanceTest extends AbstractProjectInheritanceTestCase {
    // ----------------------------------------------------------------------
    //
    // p1 inherits from p0

                event.getException().getMessage());
    }

    @Override
    public void artifactDescriptorMissing(RepositoryEvent event) {
        logger.warn("The POM for {} is missing, no dependency information available", event.getArtifact());
    }

import java.util.Map;

/**
 * A core extension to monitor Maven's execution. Typically, such an extension gets loaded into Maven by specifying the
 * property {@code maven.ext.class.path} on the command line. As soon as dependency injection is set up, Maven
 * looks up all implementers of this interface and calls their {@link #init(Context)} method. Note:

/**
 * A factory to create model builder instances when no dependency injection is available. Note: This class is
 * only meant as a utility for developers that want to employ the model builder outside of the Maven build system, Maven
 * plugins should always acquire model builder instances via dependency injection. Developers might want to subclass

 * under the License.
 */
package org.apache.maven.repository.metadata;

import org.apache.maven.artifact.ArtifactScopeEnum;

/**
 * Resolves conflicts in the supplied dependency graph.
 * Different implementations will implement different conflict resolution policies.
 *
 */
@Deprecated
public interface GraphConflictResolver {
    String ROLE = GraphConflictResolver.class.getName();

 */

import com.gradle.develocity.agent.gradle.test.DevelocityTestConfiguration
import gradlebuild.archtest.PackageCyclesExtension

plugins {
    `jvm-test-suite`
    id("gradlebuild.dependency-modules")
    id("gradlebuild.code-quality")
    id("gradlebuild.jvm-compile")
}

val packageCyclesExtension = extensions.create<PackageCyclesExtension>("packageCycles").apply {