assertionFailures[1].description.length() > 100
        assertionFailures[1].description.contains('org.opentest4j.AssertionFailedError: JUnit 5 assertion failure ==> expected: <myExpectedValue> but was: <myActualValue>')
        assertionFailures[1].causes.empty
        assertionFailures[1].className == 'org.opentest4j.AssertionFailedError'
        assertionFailures[1].stacktrace == assertionFailures[1].description

    }

    def "Different expected and actual OpenTest4j types are mapped correctly using JUnit4"() {
        given:
        setupJUnit4()
        file('src/test/java/org/gradle/JUnitTest.java') << '''
            package org.gradle;

            import org.junit.Test;
            import org.opentest4j.AssertionFailedError;
            import org.opentest4j.FileInfo;

            public class JUnitTest {

                "junit-platform-engine-${JUNIT_PLATFORM_VERSION}.jar",
                "junit-platform-commons-${JUNIT_PLATFORM_VERSION}.jar",
                "junit-jupiter-${JUNIT_JUPITER_VERSION}.jar",
                "opentest4j-${OPENTEST4J_VERSION}.jar",
                "apiguardian-api-${API_GUARDIAN_VERSION}.jar"
            ));
            assertTrue(jars.containsAll(jarSet));
            jars.removeAll(jarSet);

        'junit-platform-engine-1.8.3'   | 'junit-platform-engine-1.9.9'
        'junit-platform-launcher-1.8.3' | 'junit-platform-launcher-1.9.9'
        'opentest4j-1.2.27'             | 'opentest4j-1.3.38'
    }

    def "does not locate dependency replaced by Develocity plugin in classpath when installation is present"() {
        given:

import org.junit.jupiter.api.extension.ExtensionContext
import org.junit.jupiter.api.extension.InvocationInterceptor
import org.junit.jupiter.api.extension.ReflectiveInvocationContext
import org.openjsse.net.ssl.OpenJSSE
import org.opentest4j.TestAbortedException

/**
 * Marks a test as Platform aware, before the test runs a consistent Platform will be
 * established e.g. SecurityProvider for Conscrypt installed.
 *

import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
import org.junit.jupiter.api.Timeout
import org.junit.jupiter.api.extension.RegisterExtension
import org.junitpioneer.jupiter.RetryingTest
import org.opentest4j.TestAbortedException

/**
 * This test binds two different web servers (IPv4 and IPv6) to the same port, but on different
 * local IP addresses. Requests made to `127.0.0.1` will reach the IPv4 server, and requests made to

        api(libs.mySqlConnector)        { version { strictly("8.0.17") }}
        api(libs.netty)                 { version { strictly("4.1.63.Final") }}
        api(libs.opentest4j)            { version { strictly("1.3.0") }}
        api(libs.samplesCheck)          { version { strictly("1.0.0") }}
        api(libs.samplesDiscovery)      { version { strictly("1.0.0") }}

     * for an exception. This is for classes of external projects which actually do
     * something similar to what we do in Gradle with {@link DefaultMultiCauseException}.
     * It is, in particular, the case for opentest4j.
     */
    private static List<? extends Throwable> tryExtractMultiCauses(Throwable throwable) {
        Method causesMethod = findCandidateGetCausesMethod(throwable);
        if (causesMethod != null) {

        jarsReplacedByTdPlugin.add("junit-platform-commons-");
        jarsReplacedByTdPlugin.add("junit-platform-engine-");
        jarsReplacedByTdPlugin.add("junit-platform-launcher-");
        jarsReplacedByTdPlugin.add("opentest4j-");
        return jarsReplacedByTdPlugin;
    }

    @Nullable
    private final GradleInstallation gradleInstallation;
    private final Map<String, Module> modules = new HashMap<>();

    val mockwebserver = "com.squareup.okhttp3:mockwebserver"
    val mySqlConnector = "mysql:mysql-connector-java"
    val netty = "io.netty:netty-all"
    val opentest4j = "org.opentest4j:opentest4j"
    val samplesCheck = "org.gradle.exemplar:samples-check"
    val samplesDiscovery = "org.gradle.exemplar:samples-discovery"
    val snappy = "org.iq80.snappy:snappy"