third_party/allwpilib/wpilibjExamples/build.gradle

import edu.wpi.first.toolchain.NativePlatforms

apply plugin: 'java'
apply plugin: 'jacoco'

ext {
    useJava = true
    useCpp = false
    skipDev = true
}

apply from: "${rootDir}/shared/opencv.gradle"

test {
    useJUnitPlatform()
    systemProperty 'junit.jupiter.extensions.autodetection.enabled', 'true'
    testLogging {
        events "failed"
        exceptionFormat "full"
    }
    finalizedBy jacocoTestReport
}

if (project.hasProperty('onlylinuxathena') || project.hasProperty('onlylinuxarm32') || project.hasProperty('onlylinuxarm64')) {
    test.enabled = false
}

dependencies {
    implementation project(':wpilibj')
    implementation project(':apriltag')
    implementation project(':wpimath')
    implementation project(':hal')
    implementation project(':wpiutil')
    implementation project(':wpinet')
    implementation project(':ntcore')
    implementation project(':cscore')
    implementation project(':cameraserver')
    implementation project(':wpilibNewCommands')

    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.2'
    testImplementation 'org.junit.jupiter:junit-jupiter-params:5.8.2'
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.2'
}

jacoco {
    toolVersion = "0.8.8"
}

jacocoTestReport {
    reports {
        xml.required = true
        html.required = true
    }
}

if (!project.hasProperty('skipJavaFormat')) {
    apply plugin: 'pmd'

    pmd {
        consoleOutput = true
        reportsDir = file("$project.buildDir/reports/pmd")
        ruleSetFiles = files(new File(rootDir, "styleguide/pmd-ruleset.xml"))
        ruleSets = []
    }
}

gradle.projectsEvaluated {
    tasks.withType(JavaCompile) {
        options.compilerArgs << "-Xlint:unchecked" << "-Xlint:deprecation" << "-Werror"
    }
}

tasks.register('buildDesktopJava') {
    it.dependsOn tasks.withType(JavaCompile)
}

apply from: 'publish.gradle'

ext {
    templateDirectory = new File("$projectDir/src/main/java/edu/wpi/first/wpilibj/templates/")
    templateFile = new File("$projectDir/src/main/java/edu/wpi/first/wpilibj/templates/templates.json")
    exampleDirectory = new File("$projectDir/src/main/java/edu/wpi/first/wpilibj/examples/")
    exampleFile = new File("$projectDir/src/main/java/edu/wpi/first/wpilibj/examples/examples.json")
    commandDirectory = new File("$projectDir/src/main/java/edu/wpi/first/wpilibj/commands/")
    commandFile = new File("$projectDir/src/main/java/edu/wpi/first/wpilibj/commands/commands.json")
}

apply plugin: 'cpp'
apply plugin: 'edu.wpi.first.NativeUtils'

apply from: '../shared/config.gradle'


model {
    components {
        wpilibjExamplesDev(NativeExecutableSpec) {
            targetBuildTypes 'debug'
            sources {
                cpp {
                    source {
                        srcDirs 'src/dev/native/cpp'
                        include '**/*.cpp'
                    }
                    exportedHeaders {
                        srcDirs 'src/dev/native/include'
                    }
                }
            }
            binaries.all { binary ->
                lib project: ':wpilibNewCommands', library: 'wpilibNewCommands', linkage: 'shared'
                lib project: ':apriltag', library: 'apriltag', linkage: 'shared'
                lib project: ':wpilibc', library: 'wpilibc', linkage: 'shared'
                lib project: ':wpimath', library: 'wpimath', linkage: 'shared'
                lib project: ':wpimath', library: 'wpimathJNIShared', linkage: 'shared'
                project(':ntcore').addNtcoreDependency(binary, 'shared')
                project(':ntcore').addNtcoreJniDependency(binary)
                lib project: ':cscore', library: 'cscore', linkage: 'shared'
                lib project: ':cscore', library: 'cscoreJNIShared', linkage: 'shared'
                project(':hal').addHalDependency(binary, 'shared')
                project(':hal').addHalJniDependency(binary)
                lib project: ':wpiutil', library: 'wpiutil', linkage: 'shared'
                lib project: ':wpiutil', library: 'wpiutilJNIShared', linkage: 'shared'
                lib project: ':wpinet', library: 'wpinet', linkage: 'shared'
                lib project: ':wpinet', library: 'wpinetJNIShared', linkage: 'shared'
                lib project: ':cameraserver', library: 'cameraserver', linkage: 'shared'
                if (binary.targetPlatform.name == nativeUtils.wpi.platforms.roborio) {
                    nativeUtils.useRequiredLibrary(binary, 'ni_link_libraries', 'ni_runtime_libraries')
                } else {
                    def systemArch = getCurrentArch()
                    if (binary.targetPlatform.name == systemArch) {
                        lib project: ":simulation:halsim_gui", library: 'halsim_gui', linkage: 'shared'
                    }
                }
                nativeUtils.useRequiredLibrary(binary, 'opencv_shared')
            }
        }
    }
    tasks {
        def c = $.components
        def found = false
        c.each {
            if (it in NativeExecutableSpec && it.name == "wpilibjExamplesDev") {
                it.binaries.each {
                    if (!found) {
                        def arch = it.targetPlatform.name
                        if (arch == NativePlatforms.desktop) {
                            found = true
                            def filePath = it.tasks.install.installDirectory.get().toString() + File.separatorChar + 'lib'

                            def doFirstTask = { task ->
                                def extensions = ''
                                it.tasks.install.installDirectory.get().getAsFile().eachFileRecurse {
                                    def name = it.name
                                    if (!(name.endsWith('.dll') || name.endsWith('.so') || name.endsWith('.dylib'))) {
                                        return
                                    }
                                    def file = it
                                    if (name.startsWith("halsim_gui") || name.startsWith("libhalsim_gui".toString())) {
                                        extensions += file.absolutePath + File.pathSeparator
                                    }
                                }
                                if (extensions != '') {
                                    task.environment 'HALSIM_EXTENSIONS', extensions
                                }
                            }

                            project.tasks.create("runCpp", Exec) { task ->
                                dependsOn it.tasks.install
                                commandLine it.tasks.install.runScriptFile.get().asFile.toString()
                                test.dependsOn it.tasks.install
                                test.systemProperty 'java.library.path', filePath
                                test.environment 'LD_LIBRARY_PATH', filePath
                                test.workingDir filePath
                            }

                            new groovy.json.JsonSlurper().parseText(exampleFile.text).each { entry ->
                                project.tasks.create("run${entry.foldername}", JavaExec) { run ->
                                    run.group "run examples"
                                    run.mainClass = "edu.wpi.first.wpilibj.examples." + entry.foldername + "." + entry.mainclass
                                    run.classpath = sourceSets.main.runtimeClasspath
                                    run.dependsOn it.tasks.install
                                    run.systemProperty 'java.library.path', filePath
                                    run.environment 'LD_LIBRARY_PATH', filePath
                                    run.workingDir filePath
                                    doFirst { doFirstTask(run) }

                                    if (org.gradle.internal.os.OperatingSystem.current().isMacOsX()) {
                                        run.jvmArgs = ['-XstartOnFirstThread']
                                    }
                                }
                                project.tasks.create("test${entry.foldername}", Test) { testTask ->
                                    testTask.group "verification"
                                    testTask.useJUnitPlatform()
                                    testTask.filter {
                                        includeTestsMatching("edu.wpi.first.wpilibj.examples.${entry.foldername}.*")
                                        setFailOnNoMatchingTests(false)
                                    }
                                    testTask.classpath = sourceSets.test.runtimeClasspath
                                    testTask.dependsOn it.tasks.install

                                    testTask.systemProperty 'junit.jupiter.extensions.autodetection.enabled', 'true'
                                    testTask.testLogging {
                                        events "failed"
                                        exceptionFormat "full"
                                    }
                                    testTask.systemProperty 'java.library.path', filePath
                                    testTask.environment 'LD_LIBRARY_PATH', filePath
                                    testTask.workingDir filePath
                                }
                            }

                            found = true
                        }
                    }
                }
            }
        }
    }
}

ext {
    isCppCommands = false
}
apply from: "${rootDir}/shared/examplecheck.gradle"