build.gradle

plugins {
  id 'cpp-application'
}

// this feels weird but it is the only way invoking `./gradlew :ddprof-lib:*` tasks will work
if (rootDir.toString().endsWith("ddprof-lib/gradle")) {
  apply from: rootProject.file('../../common.gradle')
}


// disable the default compile and link tasks not to interfere with our custom ones
tasks.withType(CppCompile).configureEach { task ->
  if (task.name.startsWith('compileRelease') || task.name.startsWith('compileDebug')) {
    task.onlyIf {
      false
    }
  }
}

tasks.withType(LinkExecutable).configureEach { task ->
  if (task.name.startsWith('linkRelease') || task.name.startsWith('linkDebug')) {
    task.onlyIf {
      false
    }
  }
}

tasks.withType(ExtractSymbols).configureEach { task ->
  task.onlyIf {
    false
  }
}

tasks.withType(StripSymbols).configureEach { task ->
  task.onlyIf {
    false
  }
}

def buildNativeLibsTask = tasks.register("buildNativeLibs") {
  group = 'build'
  description = "Build the native libs for the Google Tests"

  onlyIf {
    hasGtest && !project.hasProperty('skip-native') && !project.hasProperty('skip-gtest') && os().isLinux()
  }

  def srcDir = project(':ddprof-lib').file('src/test/resources/native-libs')
  def targetDir = project(':ddprof-lib').file('build/test/resources/native-libs/')

  // Move the exec calls to the execution phase
  doLast {
    srcDir.eachDir { dir ->
      def libName = dir.name
      def libDir = file("${targetDir}/${libName}")
      def libSrcDir = file("${srcDir}/${libName}")

      exec {
        commandLine "sh", "-c", """
          echo "Processing library: ${libName} @ ${libSrcDir}"
          mkdir -p ${libDir}
          cd ${libSrcDir}
          make TARGET_DIR=${libDir}
        """
      }
    }
  }

  inputs.files project(':ddprof-lib').files('src/test/resources/native-libs/**/*')
  outputs.dir "${targetDir}"
}

def gtestAll = tasks.register("gtest") {
  onlyIf {
    hasGtest && !project.hasProperty('skip-tests') && !project.hasProperty('skip-native') && !project.hasProperty('skip-gtest')
  }
  group = 'verification'
  description = "Run all Google Tests for all build configurations of the library"

  if (!hasGtest) {
    logger.warn("WARNING: Google Test not found - skipping native tests")
  }
}

// we need this trickery to reuse the toolchain and system config from tasks created by the cpp-application plugin
tasks.whenTaskAdded { task ->
  if (task instanceof CppCompile) {
    if (!task.name.startsWith('compileGtest') && task.name.contains('Release')) {
      buildConfigurations.each { config ->
        if (config.os == osIdentifier() && config.arch == archIdentifier()) {
          project(':ddprof-lib').file("src/test/cpp/").eachFile {
            def testFile = it
            def testName = it.name.substring(0, it.name.lastIndexOf('.'))
            def gtestCompileTask = tasks.register("compileGtest${config.name.capitalize()}_${testName}", CppCompile) {
              onlyIf {
                config.active && hasGtest && !project.hasProperty('skip-tests') && !project.hasProperty('skip-native')
                && !project.hasProperty('skip-gtest')
              }
              group = 'build'
              description = "Compile the Google Test ${testName} for the ${config.name} build of the library"
              objectFileDir = file("$buildDir/obj/gtest/${config.name}/${testName}")
              compilerArgs.addAll(config.compilerArgs.findAll {
                // need to drop the -std and -DNDEBUG flags because we need a different standard and assertions enabled
                it != '-std=c++17' && it != '-DNDEBUG'
              })
              if (os().isLinux() && isMusl()) {
                compilerArgs.add('-D__musl__')
              }
              compilerArgs.add('-std=c++17')
              toolChain = task.toolChain
              targetPlatform = task.targetPlatform
              includes task.includes
              includes project(':ddprof-lib').file('src/main/cpp-external').toString()
              includes project(':ddprof-lib').file('src/main/cpp').toString()
              includes "${javaHome()}/include"
              includes project(':malloc-shim').file('src/main/public').toString()
              if (os().isMacOsX()) {
                includes "${javaHome()}/include/darwin"
                includes "/opt/homebrew/opt/googletest/include/"
              } else if (os().isLinux()) {
                includes "${javaHome()}/include/linux"
              }
              includes task.systemIncludes
              source project(':ddprof-lib').fileTree('src/main/cpp') {
                include '**/*'
              }
              source project(':ddprof-lib').fileTree('src/main/cpp-external') {
                include '**/*'
              }
              source testFile

              inputs.files source
              outputs.dir objectFileDir
            }
            def linkTask = tasks.named("linkGtest${config.name.capitalize()}_${testName}")
            if (linkTask != null) {
              linkTask.get().dependsOn gtestCompileTask
            }
            def subrepoInitTask = project(':ddprof-lib').tasks.named("initSubrepo")
            if (subrepoInitTask != null) {
              gtestCompileTask.configure {
                dependsOn subrepoInitTask
              }
            }
          }
        }
      }
    }
  } else if (task instanceof LinkExecutable) {
    if (!task.name.startsWith('linkGtest') && task.name.contains('Release')) {
      buildConfigurations.each { config ->
        if (config.os == osIdentifier() && config.arch == archIdentifier()) {
          def gtestTask = tasks.register("gtest${config.name.capitalize()}") {
            group = 'verification'
            description = "Run all Google Tests for the ${config.name} build of the library"
          }
          project(':ddprof-lib').file("src/test/cpp/").eachFile {

            def testFile = it
            def testName = it.name.substring(0, it.name.lastIndexOf('.'))
            def binary = file("$buildDir/bin/gtest/${config.name}_${testName}/${testName}")
            def gtestLinkTask = tasks.register("linkGtest${config.name.capitalize()}_${testName}", LinkExecutable) {
              onlyIf {
                config.active && hasGtest && !project.hasProperty('skip-tests') && !project.hasProperty('skip-native')
                && !project.hasProperty('skip-gtest')
              }
              group = 'build'
              description = "Link the Google Test for the ${config.name} build of the library"
              source = fileTree("$buildDir/obj/gtest/${config.name}/${testName}")
              linkedFile = binary
              if (config.name != 'release') {
                // linking the gtests using the minimizing release flags is making gtest unhappy
                linkerArgs.addAll(config.linkerArgs)
              }
              linkerArgs.addAll("-lgtest", "-lgtest_main", "-lgmock", "-lgmock_main", "-ldl", "-lpthread", "-lm")
              if (os().isMacOsX()) {
                linkerArgs.addAll("-L/opt/homebrew/opt/googletest/lib")
              } else {
                linkerArgs.add("-lrt")
              }
              toolChain = task.toolChain
              targetPlatform = task.targetPlatform
              libs = task.libs
              inputs.files source
              outputs.file linkedFile
            }
            def gtestExecuteTask = tasks.register("gtest${config.name.capitalize()}_${testName}", Exec) {
              onlyIf {
                config.active && hasGtest && !project.hasProperty('skip-tests') && !project.hasProperty('skip-native')
                && !project.hasProperty('skip-gtest')
              }
              group = 'verification'
              description = "Run the Google Test ${testName} for the ${config.name} build of the library"
              dependsOn gtestLinkTask
              executable binary

              config.testEnv.each { key, value ->
                environment key, value
              }

              inputs.files binary
              // Test tasks should run every time the test command is run
              outputs.upToDateWhen { false }
            }

            def compileTask = tasks.findByName("compileGtest${config.name.capitalize()}_${testName}")
            if (compileTask != null) {
              gtestLinkTask.dependsOn compileTask
            }
            gtestTask.get().dependsOn gtestExecuteTask.get()
            if (os().isLinux()) {
              // custom binaries for tests are built only on linux
              gtestExecuteTask.get().dependsOn(buildNativeLibs)
            }
            gtestAll.get().dependsOn gtestExecuteTask.get()
          }
        }
      }
    }
  }
}