Generate androidTest file executable by Junit4

kx412764776 · kx412764776 · commit c0af00d3ae32 · 2024-07-15T23:19:11.000+01:00
diff --git a/plugin/main/src/kotlinx/benchmark/gradle/AndroidMultiplatformTasks.kt b/plugin/main/src/kotlinx/benchmark/gradle/AndroidMultiplatformTasks.kt
@@ -18,6 +18,7 @@ fun Project.processAndroidCompilation(target: KotlinJvmAndroidCompilation) {
         it.dependsOn("bundle${target.name.capitalize(Locale.getDefault())}Aar")
         it.doLast {
             unpackAndProcessAar(target)
+            generateAndroidExecFile()
         }
     }
 }
diff --git a/plugin/main/src/kotlinx/benchmark/gradle/AndroidTasks.kt b/plugin/main/src/kotlinx/benchmark/gradle/AndroidTasks.kt
@@ -1,5 +1,6 @@
 package kotlinx.benchmark.gradle
 
+import com.squareup.kotlinpoet.*
 import kotlinx.benchmark.gradle.internal.KotlinxBenchmarkPluginInternalApi
 import org.gradle.api.*
 import org.jetbrains.kotlin.gradle.plugin.mpp.KotlinJvmAndroidCompilation
@@ -31,6 +32,7 @@ fun Project.unpackAndProcessAar(target: KotlinJvmAndroidCompilation) {
             println("Class annotations for ${target.name}:")
 
             classAnnotationsDescriptors.forEach { descriptor ->
+                println("Package: ${descriptor.packageName}")
                 println("Class: ${descriptor.name}")
                 println("  Visibility: ${descriptor.visibility}")
                 descriptor.annotations.forEach { annotation ->
@@ -67,4 +69,144 @@ fun Project.unpackAndProcessAar(target: KotlinJvmAndroidCompilation) {
     } else {
         println("AAR file not found")
     }
+}
+
+@KotlinxBenchmarkPluginInternalApi
+fun Project.generateAndroidExecFile() {
+    // TODO: It should be android template project directory
+    val androidTestDir = File("E:\\Android\\AndroidProjects\\kotlin-qualification-task\\composeApp\\src\\androidTest\\kotlin")
+    if (!androidTestDir.exists()) {
+        androidTestDir.mkdirs()
+    }
+
+    // TODO: It should be android template project build.gradle.kts file
+    val buildGradleFile = File("E:\\Android\\AndroidProjects\\kotlin-qualification-task\\composeApp\\build.gradle.kts")
+    val dependencyPaths = listOf(
+        "${project.projectDir}\\build\\outputs\\unpacked-aar\\release\\classes.jar".replace("\\", "\\\\") to null,
+        "androidx.benchmark:benchmark-junit4" to "1.2.4",
+        "androidx.test.ext:junit-ktx" to "1.2.1",
+        "junit:junit" to "4.13.2"
+    )
+
+    updateAndroidDependencies(buildGradleFile, dependencyPaths)
+
+    val jarFile = JarFile(File("${project.projectDir}\\build\\outputs\\unpacked-aar\\release\\classes.jar"))
+    val annotationProcessor = AnnotationProcessor()
+    annotationProcessor.processJarFile(jarFile)
+    jarFile.close()
+
+    val classDescriptors = annotationProcessor.getClassDescriptors()
+    val fileSpecBuilder = FileSpec.builder("generated", "GeneratedCode")
+        .addImport("androidx.test.ext.junit.runners", "AndroidJUnit4")
+        .addImport("org.junit", "Test")
+        .addImport("org.junit.runner", "RunWith")
+    val typeSpecBuilder = TypeSpec.classBuilder("GeneratedCode")
+        .addAnnotation(
+            AnnotationSpec.builder(ClassName("org.junit.runner", "RunWith"))
+                .addMember("%T::class", ClassName("androidx.test.ext.junit.runners", "AndroidJUnit4"))
+                .build()
+        )
+
+    val uniquePropertyNames = mutableSetOf<String>()
+
+    classDescriptors.forEach { descriptor ->
+        if (descriptor.visibility == Visibility.PUBLIC && !descriptor.isAbstract) {
+            val simpleClassName = descriptor.name
+            val fullyQualifiedName = "${descriptor.packageName}.$simpleClassName"
+
+            var propertyName = "${descriptor.packageName.replace('.', '_')}_$simpleClassName".decapitalize()
+            if (!propertyName.endsWith("Benchmark")) {
+                propertyName += "Benchmark"
+            }
+
+            while (!uniquePropertyNames.add(propertyName)) {
+                propertyName += "_"
+            }
+
+            val propertySpec = PropertySpec.builder(propertyName, ClassName.bestGuess(fullyQualifiedName))
+                .initializer("%T()", ClassName.bestGuess(fullyQualifiedName))
+                .build()
+            typeSpecBuilder.addProperty(propertySpec)
+
+            val methodSpecBuilder = FunSpec.builder("benchmarkExecutor_${descriptor.packageName.replace('.', '_')}_$simpleClassName")
+                .addAnnotation(ClassName("org.junit", "Test"))
+                .addCode(buildBenchmarkTestFunctionCode(propertyName, descriptor.methods))
+
+            typeSpecBuilder.addFunction(methodSpecBuilder.build())
+        }
+    }
+
+    fileSpecBuilder.addType(typeSpecBuilder.build())
+    fileSpecBuilder.build().writeTo(androidTestDir)
+}
+
+private fun buildBenchmarkTestFunctionCode(propertyName: String, methods: List<MethodAnnotationsDescriptor>): CodeBlock {
+    val builder = CodeBlock.builder()
+
+    val setUpMethod = methods.find { it.name == "setUp" }
+    val tearDownMethod = methods.find { it.name == "tearDown" }
+    val benchmarkMethods = methods.filter { it.name != "setUp" && it.name != "tearDown" && it.visibility == Visibility.PUBLIC }
+
+    setUpMethod?.let {
+        builder.addStatement("$propertyName.${it.name}()")
+    }
+
+    benchmarkMethods.forEach { method ->
+        builder.addStatement("$propertyName.${method.name}()")
+    }
+
+    tearDownMethod?.let {
+        builder.addStatement("$propertyName.${it.name}()")
+    }
+
+    return builder.build()
+}
+
+private fun updateAndroidDependencies(buildGradleFile: File, dependencies: List<Pair<String, String?>>) {
+    if (buildGradleFile.exists()) {
+        val buildGradleContent = buildGradleFile.readText()
+
+        // Check if the android block exists
+        if (buildGradleContent.contains("android {")) {
+            // Check if the dependencies block inside android contains the dependencyString
+            val androidBlockStart = buildGradleContent.indexOf("android {")
+            val androidBlockEnd = buildGradleContent.lastIndexOf("}") + 1
+            val androidBlockContent = buildGradleContent.substring(androidBlockStart, androidBlockEnd)
+
+            val newDependencies = dependencies.filterNot { (dependency, version) ->
+                val dependencyString = version?.let { """$dependency:$version""" } ?: dependency
+                androidBlockContent.contains(dependencyString)
+            }
+            if (newDependencies.isNotEmpty()) {
+                // Add the dependencies inside the android { dependencies { ... } } block
+                val updatedAndroidBlockContent = if (androidBlockContent.contains("dependencies {")) {
+                    val dependenciesBlockStart = androidBlockContent.indexOf("dependencies {")
+                    val dependenciesBlockEnd = androidBlockContent.indexOf("}", dependenciesBlockStart) + 1
+                    val dependenciesBlockContent =
+                        androidBlockContent.substring(dependenciesBlockStart, dependenciesBlockEnd)
+
+                    val newDependenciesString = newDependencies.joinToString("\n        ") { (dependency, version) ->
+                        version?.let { """androidTestImplementation("$dependency:$version")""" } ?: """androidTestImplementation(files("$dependency"))"""
+                    }
+                    androidBlockContent.replace(
+                        dependenciesBlockContent,
+                        dependenciesBlockContent.replace(
+                            "dependencies {",
+                            "dependencies {\n        $newDependenciesString"
+                        )
+                    )
+                } else {
+                    val newDependenciesString = newDependencies.joinToString("\n        ") { (dependency, version) ->
+                        version?.let { """androidTestImplementation("$dependency:$version")""" } ?: """androidTestImplementation(files("$dependency"))"""
+                    }
+                    androidBlockContent.replace("{", "{\n    dependencies {\n        $newDependenciesString\n    }\n")
+                }
+
+                // Replace the old android block with the updated one
+                val updatedBuildGradleContent =
+                    buildGradleContent.replace(androidBlockContent, updatedAndroidBlockContent)
+                buildGradleFile.writeText(updatedBuildGradleContent)
+            }
+        }
+    }
 }
diff --git a/plugin/main/src/kotlinx/benchmark/gradle/AnnotationProcessor.kt b/plugin/main/src/kotlinx/benchmark/gradle/AnnotationProcessor.kt
@@ -12,7 +12,7 @@ data class AnnotationData(
 data class ClassAnnotationsDescriptor(
     val packageName: String,
     val name: String,
-    val visibility: String,
+    val visibility: Visibility,
     val isAbstract: Boolean,
     val annotations: List<AnnotationData>,
     val methods: List<MethodAnnotationsDescriptor>,
@@ -21,16 +21,20 @@ data class ClassAnnotationsDescriptor(
 
 data class MethodAnnotationsDescriptor(
     val name: String,
-    val visibility: String,
+    val visibility: Visibility,
     val annotations: List<AnnotationData>
 )
 
 data class FieldAnnotationsDescriptor(
     val name: String,
-    val visibility: String,
+    val visibility: Visibility,
     val annotations: List<AnnotationData>
 )
 
+enum class Visibility {
+    PUBLIC, PROTECTED, PRIVATE, PACKAGE_PRIVATE
+}
+
 class AnnotationProcessor {
 
     private val classAnnotationsDescriptors = mutableListOf<ClassAnnotationsDescriptor>()
@@ -58,13 +62,15 @@ class AnnotationProcessor {
             ?.map { parseAnnotation(it) }
             ?: emptyList()
 
-        val methodDescriptors = classNode.methods.map { methodNode ->
-            val methodAnnotations = methodNode.visibleAnnotations
-                ?.filter { it.desc != "Lkotlin/Metadata;" }
-                ?.map { parseAnnotation(it) }
-                ?: emptyList()
-            MethodAnnotationsDescriptor(methodNode.name, getVisibility(methodNode.access), methodAnnotations)
-        }
+        val methodDescriptors = classNode.methods
+            .filterNot { it.name.startsWith("get") || it.name.startsWith("set") || it.name == "<init>" }
+            .map { methodNode ->
+                val methodAnnotations = methodNode.visibleAnnotations
+                    ?.filter { it.desc != "Lkotlin/Metadata;" }
+                    ?.map { parseAnnotation(it) }
+                    ?: emptyList()
+                MethodAnnotationsDescriptor(methodNode.name, getVisibility(methodNode.access), methodAnnotations)
+            }
 
         val fieldDescriptors = classNode.fields.map { fieldNode ->
             val fieldAnnotations = fieldNode.visibleAnnotations
@@ -75,9 +81,10 @@ class AnnotationProcessor {
         }
 
         val packageName = classNode.name.substringBeforeLast('/', "").replace('/', '.')
+        val className = classNode.name.substringAfterLast('/')
         val classDescriptor = ClassAnnotationsDescriptor(
             packageName,
-            classNode.name.replace('/', '.').substringAfterLast('/'),
+            className,
             getVisibility(classNode.access),
             isAbstract(classNode.access),
             classAnnotations,
@@ -136,28 +143,36 @@ class AnnotationProcessor {
         return sb.toString()
     }
 
-    private fun getVisibility(access: Int): String {
+    private fun getVisibility(access: Int): Visibility {
         return when {
-            (access and Opcodes.ACC_PUBLIC) != 0 -> "public"
-            (access and Opcodes.ACC_PROTECTED) != 0 -> "protected"
-            (access and Opcodes.ACC_PRIVATE) != 0 -> "private"
-            else -> "package-private"
+            (access and Opcodes.ACC_PUBLIC) != 0 -> Visibility.PUBLIC
+            (access and Opcodes.ACC_PROTECTED) != 0 -> Visibility.PROTECTED
+            (access and Opcodes.ACC_PRIVATE) != 0 -> Visibility.PRIVATE
+            else -> Visibility.PACKAGE_PRIVATE
         }
     }
 
-    private fun getFieldVisibility(classNode: ClassNode, fieldNode: FieldNode): String {
+    private fun getFieldVisibility(classNode: ClassNode, fieldNode: FieldNode): Visibility {
         val getterName = "get${fieldNode.name.capitalize()}"
         val setterName = "set${fieldNode.name.capitalize()}"
 
         val getterMethod = classNode.methods.find { it.name == getterName }
         val setterMethod = classNode.methods.find { it.name == setterName }
 
-        return if (getterMethod != null && setterMethod != null) {
-            val getterVisibility = getVisibility(getterMethod.access)
-            val setterVisibility = getVisibility(setterMethod.access)
-            if (getterVisibility == setterVisibility) getterVisibility else "package-private"
-        } else {
-            getVisibility(fieldNode.access)
+        val getterVisibility = getterMethod?.let { getVisibility(it.access) }
+        val setterVisibility = setterMethod?.let { getVisibility(it.access) }
+
+        return when {
+            getterVisibility != null && setterVisibility != null -> {
+                if (getterVisibility == setterVisibility) {
+                    getterVisibility
+                } else {
+                    getVisibility(fieldNode.access)
+                }
+            }
+            getterVisibility != null -> getterVisibility
+            setterVisibility != null -> setterVisibility
+            else -> getVisibility(fieldNode.access)
         }
     }
 
@@ -169,9 +184,11 @@ class AnnotationProcessor {
         return classAnnotationsDescriptors
     }
 
-    fun getPublicClassNames(): List<Pair<String, String>> {
-        return classAnnotationsDescriptors.filter { it.visibility == "public" && !it.isAbstract }
-            .map { it.packageName to it.name }
+    fun getMethodDescriptors(className: String): List<MethodAnnotationsDescriptor> {
+        return classAnnotationsDescriptors.find { it.name == className }?.methods ?: emptyList()
     }
 
+    fun getFieldDescriptors(className: String): List<FieldAnnotationsDescriptor> {
+        return classAnnotationsDescriptors.find { it.name == className }?.fields ?: emptyList()
+    }
 }

Original file line number	Diff line number	Diff line change
`@@ -18,6 +18,7 @@ fun Project.processAndroidCompilation(target: KotlinJvmAndroidCompilation) {`
`18`	`18`	`it.dependsOn("bundle${target.name.capitalize(Locale.getDefault())}Aar")`
`19`	`19`	`it.doLast {`
`20`	`20`	`unpackAndProcessAar(target)`
	`21`	`+ generateAndroidExecFile()`
`21`	`22`	`}`
`22`	`23`	`}`
`23`	`24`	`}`