Hello, I'm encountering this issue " Task :app:connectedDebugAndroidTest FAILED", when running test ...

# gradle

[Deepak Gahlot]

Hello,
I'm encountering this issue " Task appconnectedDebugAndroidTest FAILED", when running test cases via Gradle command. This is when i'm trying to generate the coverage report from Jacoco using command "createDebugCoverageReport"

[Deepak Gahlot]

I'm just trying to run Unit Test cases

[Deepak Gahlot]

here is my build.gradle(app) and jacoco.gradle files

[Deepak Gahlot]

Build.gradle

plugins {
    id 'com.android.application'
    id 'kotlin-android'
    id 'com.google.gms.google-services'
    id 'org.jetbrains.kotlin.android'
    id 'kotlin-android-extensions'
}
apply from: "$project.rootDir/jacoco.gradle"
android {
    signingConfigs {
        release {
            keyAlias 'ariba'
            keyPassword 'aribakey'
            storeFile file('ariba.jks')
            storePassword 'aribakey'
        }
    }
    compileSdkVersion 30
    buildToolsVersion '30.0.3'
    def jenkinsBuild = System.getenv("BUILD_NUMBER") ?: "1"
    defaultConfig {
        applicationId "com.sap.ariba.mint"
        minSdkVersion 28
        targetSdkVersion 30
        versionCode jenkinsBuild.toInteger()
        versionName "6.5.1"
        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
    }
    buildTypes {
        debug {
            testCoverageEnabled true
        }
        release {
            minifyEnabled true
            shrinkResources true
            proguardFiles getDefaultProguardFile('proguard-android.txt'), '<http://proguard-rules.pro|proguard-rules.pro>'
            signingConfig signingConfigs.release
        }
    }
    lintOptions {
        abortOnError false
    }
    dexOptions {
        javaMaxHeapSize "4g"
        jumboMode true
    }
    packagingOptions {
        exclude 'META-INF/DEPENDENCIES'
        exclude 'build-data.properties'
    }
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
    buildFeatures {
        compose true
    }
    kotlinOptions {
        jvmTarget = "1.8"
        useIR = true
    }
    composeOptions {
        kotlinCompilerVersion "1.5.21"
        kotlinCompilerExtensionVersion = "1.0.1"
    }
    testOptions {
        unitTests.returnDefaultValues = true
    }
}
tasks.withType(Test) {
    useJUnitPlatform()
    testLogging {
        exceptionFormat "full"
        events "started", "skipped", "passed", "failed"
        showStandardStreams true
    }
}
tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).configureEach {
    kotlinOptions {
        jvmTarget = "1.8"
        freeCompilerArgs += ["-Xallow-jvm-ir-dependencies", "-Xskip-prerelease-check", "-Xallow-unstable-dependencies", "-Xopt-in=org.mylibrary.OptInAnnotation"]
    }
}

allprojects {
    repositories {
        mavenCentral()
        jcenter()
        maven { url "<https://jitpack.io>" }
        maven { url "<https://clojars.org/repo/>" }
        maven { url "<https://repo.fenixedu.org/fenixedu-maven-repository/>" }
    }
    tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).all {
        kotlinOptions {
            allWarningsAsErrors = false
        }
    }
}
configurations {
    implementation.exclude module: 'proto-google-common-protos'
    implementation.exclude module: 'protolite-well-known-types'
    implementation.exclude module: 'protobuf-lite'
}

[Deepak Gahlot]

project.afterEvaluate { project ->
    setupAndroidReporting()
}

def setupAndroidReporting() {
    tasks.withType(Test) {
        // Whether or not classes without source location should be instrumented
        jacoco.includeNoLocationClasses = true
        jacoco.excludes = ['jdk.internal.*']
    }

    // Grab all build types and product flavors
    def buildTypes = android.buildTypes.collect { type ->
        type.name
    }
    def productFlavors = android.productFlavors.collect { flavor ->
        flavor.name
    }
    // When no product flavors defined, use empty
    if (!productFlavors) productFlavors.add('')
    productFlavors.each { productFlavorName ->
        buildTypes.each { buildTypeName ->
            def sourceName, sourcePath
            if (!productFlavorName) {
                sourceName = sourcePath = "${buildTypeName}"
            } else {
                sourceName = "${productFlavorName}${buildTypeName.capitalize()}"
                sourcePath = "${productFlavorName}/${buildTypeName}"
            }
            def testTaskName = "test${sourceName.capitalize()}UnitTest"
            System.out.println("Task -> $testTaskName")

            // Create coverage task of form 'testFlavorTypeCoverage' depending on 'testFlavorTypeUnitTest'
            task "${testTaskName}Coverage"(type: JacocoReport, dependsOn: "$testTaskName") {
                group = "Reporting"
                description = "Generate Jacoco coverage reports on the ${sourceName.capitalize()} build."

                def fileFilter = [
                        // data binding
                        'android/databinding/**/*.class',
                        '**/android/databinding/*Binding.class',
                        '**/android/databinding/*',
                        '**/androidx/databinding/*',
                        '**/BR.*',
                        // android
                        '**/R.class',
                        '**/R$*.class',
                        '**/BuildConfig.*',
                        '**/Manifest*.*',
                        '**/*Test*.*',
                        'android/**/*.*',
                        // kotlin
                        '**/*MapperImpl*.*',
                        '**/*$ViewInjector*.*',
                        '**/*$ViewBinder*.*',
                        '**/BuildConfig.*',
                        '**/*Component*.*',
                        '**/*BR*.*',
                        '**/Manifest*.*',
                        '**/*$Lambda$*.*',
                        '**/*Companion*.*',
                        '**/*Module*.*',
                        '**/*Dagger*.*',
                        '**/*Hilt*.*',
                        '**/*MembersInjector*.*',
                        '**/*_MembersInjector.class',
                        '**/*_Factory*.*',
                        '**/*_Provide*Factory*.*',
                        '**/*Extensions*.*',
                        // sealed and data classes
                        '**/*$Result.*',
                        '**/*$Result$*.*',
                        // adapters generated by moshi
                        '**/*JsonAdapter.*',
                ]

                def javaTree = fileTree(dir: "${project.buildDir}/intermediates/javac/$sourceName/classes", excludes: fileFilter)
                def kotlinTree = fileTree(dir: "${project.buildDir}/tmp/kotlin-classes/$sourceName", excludes: fileFilter)
                classDirectories.from = files([javaTree], [kotlinTree])
                executionData.from = files("${project.buildDir}/jacoco/${testTaskName}.exec")
                def coverageSourceDirs = ["src/main/java",
                                          "src/$productFlavorName/java",
                                          "src/$buildTypeName/java"]

                sourceDirectories.setFrom(files(coverageSourceDirs))
                additionalSourceDirs.setFrom(files(coverageSourceDirs))

                reports {
                    csv.enabled false // change if needed
                    xml.enabled false // change if needed
                    html {
                        enabled true
                        destination file("${buildDir}/coverage-report")
                    }
                }
            }
        }
    }
}

android {
    buildTypes {
        debug {
            testCoverageEnabled true
        }
    }
}

[Deepak Gahlot]

Jacoco.gradle

[no]

What's the reason the task failed? Is there a stacktrace?