build.gradle

apply plugin: "eclipse"
apply plugin: 'idea'

apply plugin: "war"
// Use a different buildDir for IntelliJ builds so they do not conflict with building with Gradle
// Must be done before applying the appengine plugin as a discovery-docs folder
// is added to WEB-INF which is added to the build
if (System.properties['ide'] == 'idea') {
    buildDir = new File(projectDir, 'buildIdea')
}
apply plugin: "appengine"

apply plugin: "checkstyle"
apply plugin: "pmd"
apply plugin: "findbugs"
apply plugin: "jacoco"

def appengineVersion = "1.9.27"

def jsoupVersion = "1.10.2"

def checkstyleVersion = "6.19"
def pmdVersion = "5.5.4"
def findbugsVersion = "3.0.1"

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath "com.google.appengine:gradle-appengine-plugin:1.9.27"
    }
}

configurations {
    staticAnalysis
    enhancer
    exclude
    testExclude
}

configurations.all {
    resolutionStrategy {
        force "com.google.appengine:appengine-api-1.0-sdk:${appengineVersion}"
        force "org.jsoup:jsoup:${jsoupVersion}"
    }
}

repositories {
    mavenCentral()
}

dependencies {
    staticAnalysis  "com.puppycrawl.tools:checkstyle:${checkstyleVersion}",
                    "net.sourceforge.pmd:pmd-java:${pmdVersion}",
                    "com.google.code.findbugs:findbugs:${findbugsVersion}",
                    "de.andrena.tools.macker:macker:1.0.1"

    appengineSdk    "com.google.appengine:appengine-java-sdk:${appengineVersion}"

    compile         "com.google.appengine.tools:appengine-gcs-client:0.4.4",
                    "com.google.appengine:appengine-api-labs:${appengineVersion}",
                    "com.google.code.gson:gson:2.8.0",
                    "com.googlecode.owasp-java-html-sanitizer:owasp-java-html-sanitizer:20160924.1",
                    "com.mailjet:mailjet-client:4.0.5",
                    "com.sendgrid:sendgrid-java:2.2.2",
                    "com.sun.jersey:jersey-client:1.19.3",
                    "com.sun.jersey:jersey-core:1.19.3",
                    "com.sun.jersey.contribs:jersey-multipart:1.19.3",
                    "joda-time:joda-time:2.9.7",
                    "org.apache.taglibs:taglibs-standard-impl:1.2.5",
                    "org.jsoup:jsoup:${jsoupVersion}"

    exclude         "com.google.appengine:appengine-api-1.0-sdk:${appengineVersion}",
                    "com.google.appengine:appengine-endpoints-deps:${appengineVersion}",
                    "com.google.appengine:appengine-endpoints:${appengineVersion}",
                    "com.google.appengine:appengine-jsr107cache:${appengineVersion}",
                    "com.google.appengine.orm:datanucleus-appengine:1.0.10",
                    "javax.jdo:jdo2-api:2.3-eb",
                    "net.sf.jsr107cache:jsr107cache:1.1",
                    "org.apache.geronimo.specs:geronimo-jpa_3.0_spec:1.1.1",
                    "org.apache.geronimo.specs:geronimo-jta_1.1_spec:1.1.1",
                    "org.datanucleus:datanucleus-core:1.1.5",
                    "org.datanucleus:datanucleus-jpa:1.1.5",
                    "xerces:xercesImpl:2.11.0"

    runtime         configurations.exclude

    enhancer        "javax.jdo:jdo2-api:2.3-eb",
                    "joda-time:joda-time:2.9.7",
                    "com.google.appengine.orm:datanucleus-appengine:1.0.10",
                    "org.datanucleus:datanucleus-core:1.1.5",
                    "org.datanucleus:datanucleus-jpa:1.1.5",
                    "com.google.appengine:appengine-api-1.0-sdk:${appengineVersion}"

    testCompile     "com.google.appengine:appengine-api-stubs:${appengineVersion}",
                    "com.google.appengine:appengine-remote-api:${appengineVersion}",
                    "com.google.appengine:appengine-testing:${appengineVersion}",
                    "httpunit:httpunit:1.7",
                    "javax.mail:mail:1.4.7",
                    "org.seleniumhq.selenium:selenium-java:2.53.1",
                    "org.testng:testng:6.9.4",
                    "org.kohsuke:wordnet-random-name:1.3"

    testExclude     "com.google.appengine:appengine-tools-sdk:${appengineVersion}"

    testRuntime     configurations.testExclude

}

sourceSets {
    main {
        java {
            srcDir "src/main/java"
            include "**/*.java"
        }
        resources {
            srcDir "src/main/resources"
            exclude "**/*.java"
        }
    }
    test {
        java {
            srcDir "src/test/java"
            srcDir "src/client/java"
            include "**/*.java"
        }
        resources {
            srcDir "src/test/resources"
            exclude "**/*.java"
        }
    }
}

// SETUP TASKS

import org.gradle.plugins.ide.eclipse.model.SourceFolder

eclipse {
    project {
        natures "org.eclipse.jdt.core.javanature", "com.google.appengine.eclipse.core.gaeNature", "org.eclipse.wst.jsdt.core.jsNature"
        buildCommand "org.eclipse.jdt.core.javabuilder"
        buildCommand "com.google.gdt.eclipse.core.webAppProjectValidator"
        buildCommand "com.google.appengine.eclipse.core.enhancerbuilder"
        buildCommand "com.google.appengine.eclipse.core.projectValidator"
        buildCommand "org.eclipse.wst.validation.validationbuilder"
    }
    classpath {
        containers "com.google.appengine.eclipse.core.GAE_CONTAINER/appengine-java-sdk-1.9.27"
        defaultOutputDir = file("src/main/webapp/WEB-INF/classes")
        sourceSets = [sourceSets.main, sourceSets.test]
        minusConfigurations = [configurations.exclude, configurations.testExclude]
        file {
            whenMerged { cp ->
                cp.entries.findAll {
                    it instanceof SourceFolder && !it.path.startsWith("src/main/")
                }*.output = "target/test-classes"

                // Method to put mail.jar on top of the classpath
                // This is necessary because placing it in its default place causes unintended name clash
                def nonMailEntries = cp.entries.findAll{ entry ->
                    !entry.path.contains("mail-1.4.7")
                }
                cp.entries.removeAll(nonMailEntries)
                cp.entries.addAll(nonMailEntries)
            }
        }
    }
}

idea {
    module {
        // Removes the source directories added by the appengine plugin
        testSourceDirs -= sourceSets.functionalTest.allSource.srcDirs
    }
}

// removes unused sourceSets from the appengine plugin
// the appengine plugin also adds source directories to the IDEA plugin, which are removed from the idea block above
sourceSets.remove(sourceSets.functionalTest)
sourceSets.remove(sourceSets.endpointsSrc)

eclipseProject {
    onlyIf {
        !(new File(".project")).exists()
    }
}

eclipseClasspath {
    onlyIf {
        !(new File(".classpath")).exists()
    }
}

task createConfigs {
    description "Sets up the project by obtaining necessary files and configurations points."
    group "Setup"
    def templatesToCopy = [
        "gradle.template.properties",
        "src/main/resources/build.template.properties",
        "src/test/resources/test.template.properties",
        "src/main/webapp/WEB-INF/appengine-web.template.xml"
    ]
    templatesToCopy.findAll {
        !(new File(it.replace(".template", ""))).exists()
    }.each {
        filename -> copy {
            from filename
            into filename.startsWith("src/") ? new File(filename).getParent() : "${projectDir}"
            rename '(.*).template(.*)', '$1$2'
        }
    }
}

task createEclipseLaunches {
    doLast {
        def templatesToCopy = [
                ".templates/eclipseLaunches/All tests.launch.xml",
                ".templates/eclipseLaunches/CI tests.launch.xml",
                ".templates/eclipseLaunches/Failed tests.launch.xml",
                ".templates/eclipseLaunches/Local tests.launch.xml"
        ]
        templatesToCopy.findAll {
            !(new File(it.replace(".templates/eclipseLaunches", ".launches").replace(".xml", ""))).exists()
        }.each { filename ->
            copy {
                from filename
                into ".launches"
                rename '(.*).xml', '$1'
            }
            filename = filename.replace(".templates/eclipseLaunches", ".launches").replace(".xml", "")
            def fileContents = new File(filename).getText("UTF-8")
            def projectName = "${projectDir}".replaceAll(/.*(\/|\\)/, "")
            new File(filename).text = new File(filename).getText("UTF-8").replaceAll(/\$\{project\.name\}/, projectName)
        }
    }
}

String intellijSetupGroup = 'IntelliJ IDEA Setup'

// IntelliJ Project Setup
import groovy.xml.StreamingMarkupBuilder

task addAppEngineSdkHomePath(dependsOn: appengineDownloadSdk) {
    group intellijSetupGroup
    doLast {
        String moduleXmlFilePath = '.idea/modules/teammates.iml'
        Node moduleXml = new XmlParser().parse(moduleXmlFilePath)
        Node facetComponent = (Node) (moduleXml.component.find { it.@name == 'FacetManager' })
        Node googleAppEngineFacet = (Node) (facetComponent.find { it.@type == 'google-app-engine' })
        Node configuration = googleAppEngineFacet.configuration[0]

        NodeList sdkHomePathList = configuration.'sdk-home-path'
        if (sdkHomePathList.size() > 1) {
            throw new GradleException('More than one sdk-home-path found in Google App Engine Facet')
        } else if (sdkHomePathList.size() == 1) {
            configuration.'sdk-home-path'[0].value = System.properties['appengine.sdk.root']
        } else {
            List configurationChildren = configuration.children()
            configurationChildren.add(0, new Node(null, 'sdk-home-path', null, System.properties['appengine.sdk.root']))
        }

        new File(moduleXmlFilePath).withWriter('UTF-8') { out ->
            out << new StreamingMarkupBuilder().bind { mkp.xmlDeclaration() }
            def xmlNodePrinter = new XmlNodePrinter(new PrintWriter(out))
            xmlNodePrinter.preserveWhitespace = true
            xmlNodePrinter.print(moduleXml)
        }
    }
}

task deleteIdeaFolder(type: Delete) {
    delete '.idea'
}

task copyIntelliJProjectSettings(type: Copy) {
    group intellijSetupGroup
    if (file('.idea').exists()) {
        if (!file('.idea').isDirectory()) {
            throw new GradleException('Found file with name .idea where it should be a folder.' +
                    'Please rename or delete it otherwise setup cannot proceed.')
        }

        if (project.hasProperty('delete_previous_idea')) {
            println 'Your previous project will be overwritten.'
            dependsOn deleteIdeaFolder
        } else {
            doLast {
                throw new GradleException('A project folder is found, you can delete it manually or ' +
                        'call the setup again with the property -Pdelete_previous_idea')
            }
        }
    }
    from '.templates/.idea'
    into '.idea'
}

task setupIntellijRunConfigs(type: Copy) {
    group intellijSetupGroup
    from '.templates/.idea/runConfigurations'
    into '.idea/runConfigurations'
}

task setupIntellijProject {
    description 'Sets up an IntelliJ project'
    group intellijSetupGroup

    dependsOn copyIntelliJProjectSettings
    finalizedBy addAppEngineSdkHomePath
}

// IntelliJ project settings setup
static void throwUnexpectedNodeListSizeException(String taskName, String currentNode, String parentNode, int size) {
    throw new GradleException('[' + taskName +  '] ' + currentNode + ' size in ' + parentNode +
            ' node not expected to be' + size)
}

static Node findOrCreateExternalProjectsManagerComponent(Node xml, String parentTaskName) {
    String componentName = 'ExternalProjectsManager'
    Node componentNode = (Node)(xml.component.find { it.@name == componentName })

    if (componentNode == null) {
        xml.appendNode('component', [name: componentName])
        componentNode = (Node) (xml.component.find { it.@name == componentName })

        componentNode.appendNode('system', [id: 'GRADLE'])

        Node systemNode = (Node)(componentNode.system[0])
        Node stateNode = systemNode.appendNode('state')
        Node projectsViewNode = stateNode.appendNode('projects_view')
        Node treeStateNode = projectsViewNode.appendNode('tree_state')
        Node pathNode = treeStateNode.appendNode('PATH')

        Node firstPathElementNode = pathNode.appendNode('PATH_ELEMENT')
        firstPathElementNode.appendNode('option', [name: 'myItemId', value: ''])
        firstPathElementNode.appendNode('option', [name: 'myItemType', value: 'com.intellij.openapi.externalSystem.view.ExternalProjectsStructure$RootNode'])

        Node secondPathElementNode = pathNode.appendNode('PATH_ELEMENT')
        secondPathElementNode.appendNode('option', [name: 'myItemId', value: 'teammates'])
        secondPathElementNode.appendNode('option', [name: 'myItemType', value: 'com.intellij.openapi.externalSystem.view.ProjectNode'])
    }

    return componentNode
}

static NodeList getSystemNodeList(Node externalProjectsComponentNode, String parentTaskName) {
    NodeList systemNodeList = externalProjectsComponentNode.system
    if (systemNodeList.size() == 0) {
        throw new GradleException('[' + parentTaskName + '] Cannot find system node in ExternalProjectsManager')
    }

    return systemNodeList
}

static Node findGradleSystemNode(NodeList systemNodeList, String parentTaskName) {
    Node gradleSystemNode = (Node)(systemNodeList.find { it.@id == 'GRADLE' })
    if (gradleSystemNode == null) {
        throw new GradleException('[' + parentTaskName + '] Cannot find GRADLE from system node(s)')
    }

    return gradleSystemNode
}

static Node getStateNode(Node gradleSystemNode, String parentTaskName) {
    NodeList stateNodeList = gradleSystemNode.state
    if (stateNodeList.size() != 1) {
        throwUnexpectedNodeListSizeException(parentTaskName, 'state', 'system', stateNodeList.size())
    }
    Node stateNode = (Node)(stateNodeList[0])

    return stateNode
}

static NodeList getTaskPathNodeList(Node stateNode, String parentTaskName) {
    NodeList taskPathNodeList = stateNode.task

    if (taskPathNodeList.size() > 1) {
        throwUnexpectedNodeListSizeException(parentTaskName, 'task', 'state', taskPathNodeList.size())
    }

    return taskPathNodeList
}

static Node getOrCreateTaskPathNode(NodeList taskPathNodeList, Node stateNode) {
    if (taskPathNodeList.size() == 0) {
        List stateNodeChildren = stateNode.children()
        stateNodeChildren.add(0, new Node(null, 'task', [path: '$PROJECT_DIR$']))

        NodeList newTaskPathNodeList = stateNode.task
        Node taskPathNode = (Node)newTaskPathNodeList[0]

        taskPathNode.appendNode('activation')

        return taskPathNode
    }

    NodeList newTaskPathNodeList = taskPathNodeList
    Node taskPathNode = (Node)newTaskPathNodeList[0]
    return taskPathNode
}

static Node getActivationNode(Node taskPathNode, String parentTaskName) {
    NodeList activationNodeList = taskPathNode.activation
    if (activationNodeList.size() != 1) {
        throwUnexpectedNodeListSizeException(parentTaskName, 'activation', 'state', activationNodeList.size())
    }

    return (Node)(activationNodeList[0])
}

static NodeList getAfterCompileNodeList(Node activationNode, String parentTaskName) {
    NodeList afterCompileNodeList = activationNode.after_compile
    if (afterCompileNodeList.size() > 1) {
        throwUnexpectedNodeListSizeException(parentTaskName, 'after_compile', 'activation', afterCompileNodeList.size())
    }

    return afterCompileNodeList
}

task addIntelliJAfterBuildTask {
    description 'Adds enhanceIntellijOutputClasses task to execute after build'
    group intellijSetupGroup
    doLast {
        String workspaceXmlFilePath = '.idea/workspace.xml'
        Node workspaceXml = new XmlParser().parse(workspaceXmlFilePath)

        Node externalProjectsComponentNode = findOrCreateExternalProjectsManagerComponent(workspaceXml, name)
        NodeList systemNodeList = getSystemNodeList(externalProjectsComponentNode, name)
        Node gradleSystemNode = findGradleSystemNode(systemNodeList, name)
        Node stateNode = getStateNode(gradleSystemNode, name)

        // if the user somehow messed with the gradle tool window, the task path node may exist
        // otherwise we create it
        NodeList taskPathNodeList = getTaskPathNodeList(stateNode, name)
        Node taskPathNode = getOrCreateTaskPathNode(taskPathNodeList, stateNode)

        Node activationNode = getActivationNode(taskPathNode, name)

        NodeList afterCompileNodeList = getAfterCompileNodeList(activationNode, name)

        // activation node may exist but there is no after_compile node, for example if they have a after_sync node
        String afterBuildTask = 'enhanceIntellijOutputClasses'
        if (afterCompileNodeList.size() == 0) {
            activationNode.appendNode('after_compile')
            activationNode.after_compile[0].appendNode('task', [name: afterBuildTask])
        } else {
            Node afterCompileNode = (Node)(afterCompileNodeList[0])
            Node taskNode = (Node)(afterCompileNode.task.find {it.@name == afterBuildTask})
            if (taskNode == null) {
                afterCompileNode.appendNode('task', [name: afterBuildTask])
            }
        }

        new File(workspaceXmlFilePath).withWriter('UTF-8') { out ->
            out << new StreamingMarkupBuilder().bind { mkp.xmlDeclaration() }
            def xmlNodePrinter = new XmlNodePrinter(new PrintWriter(out))
            xmlNodePrinter.preserveWhitespace = true
            xmlNodePrinter.print(workspaceXml)
        }
    }
}

task setupIntellijProjectSettings {
    description 'Sets up settings in the IntelliJ project'
    group intellijSetupGroup

    dependsOn addIntelliJAfterBuildTask
}

// IntelliJ project static analysis plugins setup

task copyIntelliJProjectPluginsSettings(type: Copy) {
    group intellijSetupGroup
    from '.templates/ideaPlugins'
    into '.idea'
}

task copyStylelintConfiguration(type: Copy) {
    group intellijSetupGroup
    from 'static-analysis/teammates-stylelint.yml'
    into projectDir
    rename {
        '.stylelintrc.yml'
    }
}

task setupIntellijStaticAnalysis {
    description 'Sets up the static analysis plugins in the IntelliJ project'
    dependsOn copyIntelliJProjectPluginsSettings
    finalizedBy copyStylelintConfiguration
}

task copyDepsToWebInfLib(type: Copy) {
    from configurations.runtime
    into "src/main/webapp/WEB-INF/lib/"
    rename("datanucleus-appengine-1.0.10.jar", "datanucleus-appengine-1.0.10.final.jar")
    rename("appengine-endpoints-deps-1.9.27.jar", "appengine-endpoints-deps.jar")
    rename("appengine-endpoints-1.9.27.jar", "appengine-endpoints.jar")
    rename("appengine-api-labs-1.9.27.jar", "appengine-api-labs.jar")
}

task resetEclipseDeps {
    description "Updates the project's dependencies to be used by Eclipse configurations"
    group "Setup"
    doFirst {
        delete  ".classpath",
                "src/main/webapp/WEB-INF/lib"
    }
    finalizedBy eclipseClasspath, copyDepsToWebInfLib
}

task printUserHomeDir {
    doLast {
        println "Your Gradle user directory is: ${gradle.gradleUserHomeDir}"
    }
}

task setupEclipse {
    description "Sets up the Eclipse-specific configurations for the project."
    group "Setup"
    dependsOn eclipseProject, createEclipseLaunches, resetEclipseDeps
}

// RUN SERVER TASKS

compileJava.options.encoding = "UTF-8"
compileTestJava.options.encoding = "UTF-8"

appengine {
    httpPort = 8888
    downloadSdk = true
    jvmFlags = ["-Xss2m", "-Dfile.encoding=UTF-8",
                // absolute paths are not supported, the following is relative to the exploded war directory
                // this only specifies the datastore path, but the indexes are still generated in
                // WEB-INF/appengine-generated.
                "-Ddatastore.backing_store=../../local_db.bin"]
    appcfg {
        oauth2 = true
    }
}

appengineRun {
    if (project.hasProperty("disable_daemon")) {
        daemon = false
    } else {
        daemon = true
    }
}

task removeDuplicateLibs(type: Delete) {
    delete  "${buildDir}/exploded-app/WEB-INF/lib/datanucleus-appengine-1.0.10.final.jar",
            "${buildDir}/exploded-app/WEB-INF/lib/appengine-endpoints-deps.jar",
            "${buildDir}/exploded-app/WEB-INF/lib/appengine-endpoints.jar",
            "${buildDir}/exploded-app/WEB-INF/lib/appengine-api-labs.jar"
}

appengineExplodeApp.finalizedBy removeDuplicateLibs

task enhancerRun {
    doLast {
        def path = System.getProperty("java.class.path") + ":" + project.gradle.gradleUserHomeDir + "/appengine-sdk/appengine-java-sdk-${appengineVersion}/lib/appengine-tools-api.jar"
        ant.taskdef(name: "enhance", classpath: path, classname: "com.google.appengine.tools.enhancer.EnhancerTask")
        ant.enhance(failonerror: true, verbose: true) {
            classpath {
                pathelement(path: path)
                pathelement(path: sourceSets.main.output.classesDir.canonicalPath)
                pathelement(path: project.configurations.enhancer.asPath)
            }
            fileset(dir: sourceSets.main.output.classesDir.canonicalPath, includes: "teammates/storage/entity/*.class")
            arg(value: "-enhancerVersion"); arg(value: "v1")
            arg(value: "-api"); arg(value: "JPA")
        }
    }
}

enhancerRun.dependsOn appengineDownloadSdk
enhancerRun.dependsOn project.classes
enhancerRun.shouldRunAfter project.testClasses
war.dependsOn enhancerRun

task copyEnhancedClassesToExplodedWar(type: Copy) {
    description 'Copy the enhanced classes to the exploded war'
    group intellijSetupGroup

    from sourceSets.main.output.classesDir.canonicalPath + '/teammates/storage/entity'
    into war.destinationDir.canonicalPath + '/exploded/' + war.archiveName + '/WEB-INF/classes/teammates/storage/entity'
}

task enhanceIntellijOutputClasses(dependsOn: enhancerRun) {
    description 'Enhance IntelliJ IDEA build output classes'
    group intellijSetupGroup
    finalizedBy copyEnhancedClassesToExplodedWar
}

// STATIC ANALYSIS TASKS

def isWindows = System.getProperty("os.name").toLowerCase().contains("windows")

checkstyle {
    toolVersion = checkstyleVersion
    configFile = file("static-analysis/teammates-checkstyle.xml")
}

pmd {
    toolVersion = pmdVersion
    consoleOutput = true
    ruleSetFiles = files("static-analysis/teammates-pmd.xml", "static-analysis/teammates-pmdMain.xml")
    ruleSets = []
}

findbugs {
    toolVersion = findbugsVersion
    visitors = [
        "FindDeadLocalStores"
    ]
}

tasks.withType(FindBugs) {
    reports {
        xml.enabled = false
        html.enabled = true
    }
}

task downloadStaticAnalysisTools {
    description "Downloads all static analysis tools."
    group "Static analysis"
    doFirst {
        configurations.staticAnalysis.resolve()
    }
}

task lintMain {
    dependsOn checkstyleMain, pmdMain, findbugsMain
}

task lintTest {
    dependsOn checkstyleTest, pmdTest, findbugsTest
}

task macker {
    doLast {
        logging.setLevel(LogLevel.INFO)
        ant.taskdef(name: "macker", classpath: configurations.staticAnalysis.asPath, classname: "de.andrena.tools.macker.ant.MackerAntTask")
        ant.macker(failonerror: true, verbose: false) {
            rules(dir: "${projectDir}/static-analysis", includes: "teammates-macker.xml")
            classes(dir: "${buildDir}/classes") {
                include(name: "**/*.class")
            }
        }
    }
}

macker.dependsOn testClasses
macker.shouldRunAfter lintMain, lintTest

task lint {
    description "Runs the entire static analysis tasks for back-end."
    group "Static analysis"
    dependsOn lintMain, lintTest, macker
}

// TEST TASKS

def numOfTestRetries = 3
def isTravis = System.getenv("TRAVIS") != null
def isAppVeyor = System.getenv("APPVEYOR") != null
def failedXmlPath = "test-output/testng-failed.xml"
def failedXmlUrl = "https://gist.githubusercontent.com/anonymous/gist_id/raw/"

// Displays full exception; to be run after the test fails after the last retry
// For HTML tests, the exception is displayed in diff form instead of the extremely verbose full exception message
def afterTestClosure = { descriptor, result ->
    if (result.resultType == TestResult.ResultType.FAILURE && result.exception != null && result.exception.getMessage() != null) {
        println ""

        def msg = result.exception.getMessage()
        def shouldDisplayAsDiff = msg.indexOf("<<expected>") != -1
        if (shouldDisplayAsDiff) {
            def expectedFileName = "expected-${descriptor.getClassName()}"
            def actualFileName = "actual-${descriptor.getClassName()}"
            file("${expectedFileName}").text = msg[(msg.indexOf("<<expected>") + 11)..(msg.indexOf("</expected>>") - 1)]
            file("${actualFileName}").text = msg[(msg.indexOf("<<actual>") + 9)..(msg.indexOf("</actual>>") - 1)]
            def diffCommand = isWindows ? "FC" : "diff"
            def process = "${diffCommand} ${expectedFileName} ${actualFileName}".execute()
            println process.getText()
            process.waitFor()
            if (!isAppVeyor && !isTravis) { // CI does not allow deleting files
                def deleteCommand = isWindows ? "del" : "rm"
                "${deleteCommand} ${expectedFileName}".execute()
                "${deleteCommand} ${actualFileName}".execute()
            }
        } else {
            println "${result.exception.getClass().getName()}: ${result.exception.getMessage()}"
        }

        for (StackTraceElement ste : result.exception.getStackTrace()) {
            if (ste.getClassName().contains("NativeMethodAccessorImpl")) {
                // Everything after this line is the internal workings of TestNG, not important for us
                println "\t..."
                break
            }
            println "\tat ${ste.getClassName()}.${ste.getMethodName()}(${ste.getFileName()}:${ste.getLineNumber()})"
        }
    }
}

import org.gradle.internal.serialize.PlaceholderException

def checkConfigFailureClosure = { descriptor, result ->
    if (result.exception instanceof PlaceholderException
            && result.exception.toString().startsWith("org.gradle.api.internal.tasks.testing.TestSuiteExecutionException")) {
        throw new GradleException('Detected TestNG configuration failure - check src/test/testng-ci.xml')
    }
}

test {
    useTestNG()
    options.useDefaultListeners = true
    ignoreFailures false
    maxHeapSize = "1g"
    reports.html.enabled = false
    reports.junitXml.enabled = false
    jvmArgs "-Xss2m", "-Dfile.encoding=UTF-8"
    afterTest afterTestClosure
    testLogging {
        events "passed"
    }
    dependsOn enhancerRun
}

task localTests(type: Test) {
    useTestNG()
    options.suites "src/test/testng-local.xml"
    options.outputDirectory = file("build/reports/test-local")
    options.useDefaultListeners = true
    ignoreFailures false
    maxHeapSize = "1g"
    reports.html.enabled = false
    reports.junitXml.enabled = false
    jvmArgs "-Xss2m", "-Dfile.encoding=UTF-8"
    afterTest afterTestClosure
    testLogging {
        events "passed"
    }
    dependsOn enhancerRun
}

task failedTests(type: Test) {
    useTestNG()
    options.suites "test-output/testng-failed.xml"
    options.outputDirectory = file("build/reports/test-failed")
    options.useDefaultListeners = true
    ignoreFailures false
    maxHeapSize = "1g"
    reports.html.enabled = false
    reports.junitXml.enabled = false
    jvmArgs "-Xss2m", "-Dfile.encoding=UTF-8"
    afterTest afterTestClosure
    testLogging {
        events "passed"
    }
    dependsOn enhancerRun
}

task ciTests {
    description "Runs the full test suite and retries failed test up to ${numOfTestRetries} times."
    group "Test"
}

(1..numOfTestRetries + 1).each { id ->
    def isFirstTry = id == 1
    def isLastRetry = id == numOfTestRetries + 1
    task "testTry${id}"(type: Test) {
        useTestNG()
        options.suites isFirstTry ? "src/test/testng-ci.xml" : "build/reports/test-try-${id - 1}/testng-failed.xml"
        options.outputDirectory = file("build/reports/test-try-${id}")
        options.useDefaultListeners = true
        ignoreFailures = !isLastRetry
        maxHeapSize = "1g"
        reports.html.enabled = false
        reports.junitXml.enabled = false
        if (isTravis) {
            jvmArgs "-Xss2m", "-Dfile.encoding=UTF-8", "-Djava.io.tmpdir=" + System.getenv("TRAVIS_BUILD_DIR")
        } else {
            jvmArgs "-Xss2m", "-Dfile.encoding=UTF-8"
        }
        testLogging {
            events "passed"
        }
        if (isLastRetry) {
            afterTest afterTestClosure
        } else if (isFirstTry) {
            afterSuite checkConfigFailureClosure
        }
        finalizedBy "killFirefox${id}"
        dependsOn enhancerRun
        onlyIf {
            isFirstTry || file("build/reports/test-try-${id - 1}/testng-failed.xml").exists()
        }
    }
    ciTests.dependsOn "testTry${id}"

    task "killFirefox${id}"(type: Exec) {
        doFirst {
            if (isWindows) {
                commandLine "taskkill", "/f", "/im", "firefox.exe"
            } else {
                commandLine "pkill", "firefox"
            }
            // Silence output for this task
            standardOutput = new ByteArrayOutputStream()
            errorOutput = standardOutput
        }
        ignoreExitValue = true
        outputs.upToDateWhen { false }
    }
}

task generateFailedCmd(type: Exec) {
    def os = new ByteArrayOutputStream()
    doFirst {
        commandLine "gist", "-p", "build/reports/test-try-${numOfTestRetries + 1}/testng-failed.xml"
        standardOutput = os
    }
    doLast {
        def gistUrl = os.toString()
        def gistHash = gistUrl.substring(gistUrl.lastIndexOf("/") + 1).replaceAll("\\s", "")
        println "Run failed tests locally by downloading the XML file containing the failed tests using the command:"
        println "Windows: gradlew.bat -Pgist=${gistHash} downloadFailedXml"
        println "Linux/OS X: ./gradlew -Pgist=${gistHash} downloadFailedXml"
        println "followed by running \"Failed tests\" in Eclipse/IntelliJ or using the following command:"
        println "Windows: gradlew.bat failedTests"
        println "Linux/OS X: ./gradlew failedTests"
    }
}

task cleanTestOutputDir {
    doLast {
        def testOutputDir = new File("test-output")
        testOutputDir.deleteDir()
    }
}

task downloadFailedXml {
    description "Downloads testng-failed.xml from a failed run in Travis/AppVeyor."
    group "Test"
    onlyIf {
        project.hasProperty("gist")
    }
    doFirst {
        def failedXml = new File(failedXmlPath)
        failedXml.getParentFile().mkdirs()
        def downloadUrl = failedXmlUrl.replace(/gist_id/, project.getProperty("gist"))
        new URL(downloadUrl).withInputStream{i -> failedXml.withOutputStream{ it << i }}
    }
    doLast {
        println "The XML file containing the failed tests has been downloaded successfully."
        println "You can now run the failed tests locally."
    }
    dependsOn cleanTestOutputDir
}

// COVERAGE TASKS

jacoco {
    toolVersion = "0.7.8"
}

task jacocoMerge(type: JacocoMerge) {
    destinationFile = file("${buildDir}/jacocoMerge/jacocoMerge.exec")
    executionData fileTree("${buildDir}/jacoco").files
}

task jacocoReport(type: JacocoReport) {
    description "Runs coverage session from available test run data."
    group "Test"
    sourceDirectories = files(sourceSets.main.java.srcDirs, sourceSets.test.java.srcDirs)
    classDirectories = files(sourceSets.main.output, sourceSets.test.output)
    executionData jacocoMerge.destinationFile
    reports {
        xml.enabled true
        html.enabled true
    }
    afterEvaluate {
        classDirectories = files(classDirectories.files.collect {
            fileTree(dir: it, exclude: ["**/*.jar", "teammates/client/**/*", "**/*Filter.class", "**/*Servlet.class"])
        })
    }
    dependsOn jacocoMerge
}