integTestImplementation(libs.commonsCompress)
    integTestImplementation(libs.slf4jApi)
    integTestImplementation(libs.jetty)
    integTestImplementation(libs.assertj) {
        because("Kotlin soak tests use AssertJ")
    }

    integTestDistributionRuntimeOnly(project(":distributions-full"))
}

tasks.register("soakTest") {
    description = "Run all soak tests defined in the :soak subproject"

            <artifactId>junit-jupiter</artifactId>
            <version>5.10.2</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.assertj</groupId>
            <artifactId>assertj-core</artifactId>
            <version>3.25.3</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
    <profiles>
        <profile>
            <id>release</id>

      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter</artifactId>
      <version>5.10.2</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.assertj</groupId>
      <artifactId>assertj-core</artifactId>
      <version>3.25.3</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

import org.gradle.api.tasks.testing.TestFailure;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * Maps {@code org.assertj.core.error.MultipleAssertionsError} to {@link TestFailure}.
 * <p>
 * See {@link TestFailureMapper} for more details about failure mapping.
 */
public class AssertjMultipleAssertionsErrorMapper extends TestFailureMapper {

    implementation(libs.slf4jApi)

    testImplementation(testFixtures(project(":core")))
    testImplementation(testFixtures(project(":messaging")))
    testImplementation(libs.assertj) {
        because("We test assertion errors coming from AssertJ")
    }
    testImplementation("org.opentest4j:opentest4j") {
        version {
            // MultipleFailuresError appears only since 1.3.0-RC2
            require("1.3.0")
        }

            package org.gradle;

            import org.assertj.core.error.MultipleAssertionsError;
            import org.junit.jupiter.api.Test;

            import java.util.ArrayList;
            import java.util.List;

            import static org.assertj.core.api.Assertions.assertThat;
            import static org.junit.jupiter.api.Assertions.assertAll;

        file("intermediate/src/main/java/org/gradle/intermediate/IntermediateClass.java") << """
        package org.gradle.intermediate;

        public class IntermediateClass {
            private static org.assertj.core.api.Condition<Object> condition = null;
        }
        """.stripIndent()
    }

    def "auxclasspath configured for rule-using project"() {

        then:
        assert mappedFailure.causes.size() == 3
        assert mappedFailure.rawFailure instanceof MultipleAssertionsError
    }

    def "maps inner assertion failures correctly"() {
        when:
        def innerErrors = mapper.mapInnerFailures(error, rootMapper)

        then:
        innerErrors.eachWithIndex { tf, i ->
            assert tf.causes.size() == 0

import org.eclipse.aether.RepositorySystemSession;
import org.eclipse.aether.SessionData;
import org.junit.jupiter.api.Test;
import org.mockito.Mockito;
import org.xmlunit.assertj.XmlAssert;

import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.when;

class ConsumerPomArtifactTransformerTest {

    @Test

    testImplementation(libs.inject)

    testImplementation(libs.archunitJunit5)
    testImplementation(libs.guava)
    testImplementation("org.junit.jupiter:junit-jupiter")
    testImplementation(libs.assertj)

    testRuntimeOnly(project(":distributions-full"))
}

val acceptedApiChangesDirectory = layout.projectDirectory.dir("src/changes/accepted-changes")