import org.gradle.testing.junit.AbstractJUnitTestFailureIntegrationTest
import org.hamcrest.Matcher

import static org.gradle.testing.fixture.JUnitCoverage.JUNIT_JUPITER
import static org.hamcrest.CoreMatchers.equalTo

@TargetCoverage({ JUNIT_JUPITER })
class JUnitJupiterJUnitTestFailureIntegrationTest extends AbstractJUnitTestFailureIntegrationTest implements JUnitJupiterMultiVersionTest {
    @Override

import org.gradle.api.internal.file.collections.FileTreeAdapter
import org.gradle.api.internal.file.collections.MinimalFileTree
import org.gradle.api.internal.project.DefaultAntBuilder

import static org.hamcrest.CoreMatchers.equalTo
import static org.hamcrest.MatcherAssert.assertThat
import static org.junit.Assert.assertTrue

class AntBuilderAwareUtil {

    static def assertSetContains(FileCollection set, Set<String> filenames) {

import org.apache.commons.compress.archivers.zip.ZipFile
import org.gradle.test.fixtures.file.TestFile

import java.nio.charset.Charset

import static org.hamcrest.CoreMatchers.equalTo
import static org.hamcrest.MatcherAssert.assertThat

class ZipTestFixture extends ArchiveTestFixture {
    protected final String metadataCharset
    protected final String contentCharset

        def windowsLineEndings = scriptText.split(TextUtil.windowsLineSeparator).length

        // Windows line endings are made up of two characters,
        // we should see an equal number of lines unless
        // the generator is using the wrong line ending entirely
        // or has generated some lines with one or the other character
        carriageLineEndings == newlineEndings

        "ext" | "classifier" | "name-classifier.ext"
        "ext" | null         | "name.ext"
        null  | "classifier" | "name-classifier"
        null  | null         | "name"
    }

    def "is equal when all fields are equal"() {
        def name = new DefaultIvyArtifactName("name", "type", "ext", 'classifier')
        def same = new DefaultIvyArtifactName("name", "type", "ext", 'classifier')

        and:
        files == conf.allArtifacts.files as Set
    }

    void "knows when content is equal"() {
        def d1 = createProjectDependency()
        def d2 = createProjectDependency()

        expect:
        d1.contentEquals(d2)
    }

    void "knows when content is not equal"() {
        def d1 = createProjectDependency()
        def d2 = createProjectDependency()

        1 * client2.stop()
        0 * client3.stop()

        and:
        reserveIdleClient(oneGbOptions) == client3
    }

    def "expires all idle daemons when requested memory is equal than what all daemons consume"() {
        given:
        def client1 = reserveNewClient(oneGbOptions)
        def client2 = reserveNewClient(threeGbOptions)

        and:
        clientsManager.release(client1)

                }

                static void mirror(IvyArtifactRepository repo) {
                    ${mirrorConditions}
                }

                // We see them as equal:
                // https://repo.maven.apache.org/maven2/ and http://repo.maven.apache.org/maven2
                static String normalizeUrl(Object url) {

        where:
        path1              | offset | path2         | result
        "/var/hello/world" | 5      | "hello-other" | -1
    }

    def "equal chars are equal"() {
        expect:
        (Character.MIN_VALUE..Character.MAX_VALUE).each { currentChar ->
            assert compareCharsIgnoringCase(currentChar as char, currentChar as char) == 0

    def "empties"() {
        expect:
        changes(
            FileSystemSnapshot.EMPTY,
            FileSystemSnapshot.EMPTY
        ) == []
    }

    def "equal hash for #current.type"() {
        expect:
        changes(previous, current) == []

        where:
        previous                        | current
        regularFile("one", 0x1234)      | regularFile("one", 0x1234)