import org.gradle.api.tasks.testing.logging.TestLogging
import org.gradle.api.tasks.testing.logging.TestStackTraceFilter
import org.gradle.internal.serialize.PlaceholderException
import spock.lang.Specification

class FullExceptionFormatterTest extends Specification {
    def testDescriptor = new SimpleTestDescriptor()
    def testLogging = Mock(TestLogging)
    def formatter = new FullExceptionFormatter(testLogging)

        then:
        textOutputFactory.toString().count("PASSED") == 0
    }

    def "logs event if granularity matches"() {
        testLogging.events(TestLogEvent.PASSED)
        testLogging.minGranularity = 2
        testLogging.maxGranularity = 4

        when:
        eventLogger.afterSuite(outerSuiteDescriptor, result)
        eventLogger.afterSuite(innerSuiteDescriptor, result)

    }

    private TestExceptionFormatter getExceptionFormatter(TestLogging testLogging) {
        switch (testLogging.getExceptionFormat()) {
            case SHORT:
                return new ShortExceptionFormatter(testLogging);
            case FULL:
                return new FullExceptionFormatter(testLogging);
            default:
                throw new AssertionError();
        }
    }

import org.gradle.api.tasks.testing.logging.TestLogging;
import org.gradle.api.tasks.testing.logging.TestStackTraceFilter;

import java.util.EnumSet;
import java.util.Set;

import static org.gradle.util.internal.GUtil.toEnum;
import static org.gradle.util.internal.GUtil.toEnumSet;

public class DefaultTestLogging implements TestLogging {
    private Set<TestLogEvent> events = EnumSet.noneOf(TestLogEvent.class);

        """
            test {
                testLogging {
                    events(${events.collect { "'$it'" }.join(', ')})
                }
            }
        """
    }

    private static String testLoggingStandardStream() {
        """
            test {
                testLogging {
                    showStandardStreams = true
                }
            }

            ${mavenCentralRepository()}

            dependencies {
                ${testFrameworkDependencies}
            }

            test {
                ${configureTestFramework}
                testLogging {
                    quiet {
                        events "skipped", "failed"
                        minGranularity 2
                        maxGranularity -1
                        displayGranularity 3

                        dependencies {
                            implementation localGroovy()
                        }
                    }
                }
            }

            test {
                testLogging.exceptionFormat = 'full'
            }
        """
    }

    @NoDebug
    def "fails appropriately if runner is loaded from a JAR that is not part of the distribution and no explicit version set"() {
        when:

                ${testFrameworkDependencies}
            }

            test {
                ${configureTestFramework} {
                    includeEngines 'does-not-exist'
                }
                testLogging {
                    minGranularity = 1
                    exceptionFormat = "FULL"
                }
            }
        """

        when:
        executer.withStackTraceChecksDisabled()

test {
    if (!JavaVersion.current().java8Compatible) {
        jvmArgs '-XX:MaxPermSize=512m'
    }
    jvmArgs '-XX:+HeapDumpOnOutOfMemoryError'
    <% if (binding.hasVariable("fullTestLogging")) { %>
        testLogging {
            events "started", "skipped", "failed", "passed", "standard_out", "standard_error"
        }
    <% } %>
}

String compilerMemory = getProperty('compilerMemory')

        ${mavenCentralRepository()}

        testing {
            suites {
                test {
                    useSpock()
                }
            }
        }
        test {
            testLogging.exceptionFormat = 'full'
        }

        // Needed when using ProjectBuilder
        class AddOpensArgProvider implements CommandLineArgumentProvider {
            private final Test test;