def rootMapper = new ThrowableToTestFailureMapper() {
        @Override
        TestFailure createFailure(Throwable throwable) {
            TestFailure.fromTestAssertionFailure(throwable, null, null, null)
        }
    }

    def "maps assertion failure correctly"() {
        when:
        def mappedFailure = mapper.map(error, rootMapper)

        then:

    }

    @Override
    public TestFailure map(Throwable throwable, ThrowableToTestFailureMapper rootMapper) throws Exception {
        List<TestFailure> innerFailures = mapInnerFailures(throwable, rootMapper);
        // As there is no expected or actual value, we pass null as their value
        return TestFailure.fromTestAssertionFailure(throwable, null, null, innerFailures);
    }

        );
    }

    @Override
    public TestFailure map(Throwable throwable, ThrowableToTestFailureMapper rootMapper) throws Exception {
        Throwable cause = throwable.getCause();
        List<TestFailure> causeFailure = null;
        if (cause != null) {
            causeFailure = Collections.singletonList(rootMapper.createFailure(cause));
        }

        );
    }

    @Override
    public TestFailure map(Throwable throwable, ThrowableToTestFailureMapper rootMapper) throws Exception {
        return TestFailure.fromTestAssertionFailure(throwable, null, null, mapInnerFailures(throwable, rootMapper));
    }

    @SuppressWarnings("unchecked")

        return state == State.Redirect;
    }

    public <S> void applyTo(BuildableModuleComponentMetaDataResolveResult<S> target, Function<T, S> resultMapper) {
        if (state == State.Resolved) {
            target.resolved(resultMapper.apply(metaData));
        } else if (state == State.Failed) {
            target.failed(failure);
        } else if (state == State.Redirect) {

     * <p>
     * If needed, {@code rootMapper} can be used to recursively map inner failures by platform-specific means.
     *
     * @param throwable the {@link Throwable} to be mapped
     * @param rootMapper the {@link ThrowableToTestFailureMapper} to be used to recursively map inner failures.

            ClassWriter classWriter = new ClassWriter(0);
            ClassVisitor remappingVisitor = new ClassRemapper(classWriter, remapper);
            classReader.accept(remappingVisitor, ClassReader.EXPAND_FRAMES);
            byte[] remappedClass = classWriter.toByteArray();
            String remappedClassName = remapper.map(internalName).concat(".class");
            jar.putNextEntry(new ZipEntry(remappedClassName));

import org.gradle.internal.util.Trie;
import org.objectweb.asm.commons.Remapper;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.nio.charset.Charset;
import java.util.Arrays;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

class ImplementationDependencyRelocator extends Remapper {

            "junit.framework.ComparisonFailure",
            "org.junit.ComparisonFailure"
        );
    }

    @Override
    public TestFailure map(Throwable throwable, ThrowableToTestFailureMapper rootMapper) throws Exception {
        String expectedValue = invokeMethod(throwable, "getExpected", String.class);
        String actualValue = invokeMethod(throwable, "getActual", String.class);

import org.objectweb.asm.ClassReader
import org.objectweb.asm.ClassWriter
import org.objectweb.asm.commons.ClassRemapper
import org.objectweb.asm.commons.Remapper
import java.io.BufferedInputStream
import java.io.File
import java.io.FileInputStream
import java.io.IOException
import java.net.URI
import java.nio.file.FileSystems
import java.nio.file.FileVisitResult