diff --git a/.editorconfig b/.editorconfig new file mode 100644 index 0000000..ad30374 --- /dev/null +++ b/.editorconfig @@ -0,0 +1,4 @@ +[*.{kt,kts}] +ktlint_standard_no-wildcard-imports = disabled +ktlint_standard_value-argument-comment = disabled +ktlint_standard_value-parameter-comment = disabled \ No newline at end of file diff --git a/.gitignore b/.gitignore index 4a63501..357906b 100644 --- a/.gitignore +++ b/.gitignore @@ -182,3 +182,4 @@ gradle-app.setting # End of https://www.toptal.com/developers/gitignore/api/gradle,kotlin,java,intellij /local.properties +/.kotlin/ \ No newline at end of file diff --git a/.idea/.gitignore b/.idea/.gitignore new file mode 100644 index 0000000..26d3352 --- /dev/null +++ b/.idea/.gitignore @@ -0,0 +1,3 @@ +# Default ignored files +/shelf/ +/workspace.xml diff --git a/LICENSE-2.0.html b/LICENSE-2.0.html index b7c7754..3eb47af 100644 --- a/LICENSE-2.0.html +++ b/LICENSE-2.0.html @@ -31,12 +31,12 @@ diff --git a/README.md b/README.md index bdda5e0..da7f056 100644 --- a/README.md +++ b/README.md @@ -61,28 +61,14 @@ README. ### Adding the dependency: -To add this library as a dependency you need to: - -* Add the github package repo in your `build.gradle`: - -```groovy -repositories { - maven { - url = "https://maven.pkg.github.com/alt236/codeplasterage" - } -} -``` - -* Add the dependency itself: +This library is hosted on Maven Central so just add it: ```groovy dependencies { - testImplementation 'uk.co.alt236:codeplasterage:{latest-version}' + testImplementation 'dev.alt236:codeplasterage:{latest-version}' } ``` -You can find the latest version here: https://github.com/alt236/codeplasterage/packages/ - ## Configuration Tests can be configured on both class and method level via the `@Config` annotation. @@ -107,12 +93,12 @@ There are two parts in the config, the inclusion/exclusion filters and general c There are four different filters you can use to target (and exclude classes). They can be all be used at the same time. -| Field Name | Priority | Input | Example | -|----------------------------|------------|--------------------------------------|--------------------------------------------| -| `forceIncludeClassNames` | 1, Highest | Array of fully qualified class names | `uk.co.alt236.codeplasteragetestapp.FOO$1` | -| `forceExcludeClassNames` | 2 | Array of fully qualified class names | `uk.co.alt236.codeplasteragetestapp.FOO$1` | -| `excludeClassNamePatterns` | 3 | Array of RegEx Pattern | `.*codeplasteragetestapp.*` | -| `includeClassNamePatterns` | 4, Lowest | Array of RegEx Pattern | `.*codeplasteragetestapp.*` | +| Field Name | Priority | Input | Example | +|----------------------------|------------|--------------------------------------|-----------------------------------------| +| `forceIncludeClassNames` | 1, Highest | Array of fully qualified class names | `dev.alt236codeplasteragetestapp.FOO$1` | +| `forceExcludeClassNames` | 2 | Array of fully qualified class names | `dev.alt236codeplasteragetestapp.FOO$1` | +| `excludeClassNamePatterns` | 3 | Array of RegEx Pattern | `.*codeplasteragetestapp.*` | +| `includeClassNamePatterns` | 4, Lowest | Array of RegEx Pattern | `.*codeplasteragetestapp.*` | Note 1: It is always better to add the patterns for your own code in `includeClassNamePatterns` instead of just running everything. Otherwise, any 3rd party libraries included in your project will be instantiated and many of them do no not diff --git a/build.gradle b/build.gradle index 35daeb5..2cf6770 100644 --- a/build.gradle +++ b/build.gradle @@ -1,16 +1,17 @@ plugins { id 'java' - id "org.jetbrains.kotlin.jvm" version "${kotlin_version}" - id "org.jlleitschuh.gradle.ktlint" version "${jlleitschuh_ktlint_version}" - id 'com.adarshr.test-logger' version "${test_logger_version}" - id 'org.jetbrains.kotlinx.kover' version "${kover_version}" + alias(libs.plugins.kotlin.jvm) apply false + alias(libs.plugins.kotlin.kapt) apply false + alias(libs.plugins.gradle.ktlint) + alias(libs.plugins.testlogger) + alias(libs.plugins.kover) } apply from: "$rootDir/buildsystem/kover.gradle" apply from: "$rootDir/buildsystem/printcoverage.gradle" -group = "uk.co.alt236.codeplasterage" -version = "1.0-SNAPSHOT" +group = "dev.alt236" +version = "0.0.1-SNAPSHOT" repositories { mavenCentral() @@ -28,4 +29,7 @@ subprojects { showStandardStreams true } + ktlint { + version.set("1.4.1") + } } \ No newline at end of file diff --git a/codeplasterage/build.gradle b/codeplasterage/build.gradle index 8d05a41..9d557a3 100644 --- a/codeplasterage/build.gradle +++ b/codeplasterage/build.gradle @@ -1,81 +1,87 @@ +import com.vanniktech.maven.publish.SonatypeHost + plugins { - id 'java' - id 'kotlin' - id 'maven-publish' + id 'java-library' + alias(libs.plugins.kotlin.jvm) + alias(libs.plugins.kotlin.kapt) + alias(libs.plugins.vanniktech.maven.publish) } def project_name = "Code Plasterage" def github_owner_and_repo = "alt236/codeplasterage" -def group_id = 'uk.co.alt236' +def group_id = 'dev.alt236' def artifact_id = 'codeplasterage' -def artifact_version = '1.1-SNAPSHOT' +def artifact_version = '2.0.0' group group_id version artifact_version repositories { mavenCentral() + gradlePluginPortal() } -publishing { - publications { - mavenJava(MavenPublication) { - artifactId = artifact_id - groupId = group_id - version = artifact_version +dependencies { + implementation libs.commons.lang3 + implementation libs.kotlin.reflect + implementation libs.guava + implementation libs.kotlin.reflect + implementation libs.junit4 + + testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.1' + testImplementation 'org.junit.jupiter:junit-jupiter-params:5.8.1' + testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.1' +} + +test { + useJUnitPlatform() +} + +ktlint { + disabledRules = ["no-wildcard-imports"] +} - from components.java +mavenPublishing { // This is for the 'vanniktech-maven-publish' plugin + var automaticRelease = false + publishToMavenCentral(SonatypeHost.CENTRAL_PORTAL, automaticRelease) + signAllPublications() - pom { - name = project_name - description = 'A library to artificially inflate code coverage stats via reflection' - url = "https://github.com/$github_owner_and_repo" - licenses { - license { - name = 'The Apache License, Version 2.0' - url = 'http://www.apache.org/licenses/LICENSE-2.0.txt' - } - } - developers { - developer { - id = 'alt236' - name = 'Alexandros Schillings' - } - } - scm { - url = "https://github.com/$github_owner_and_repo" - } + coordinates(group_id, artifact_id, artifact_version) + pom { + name = project_name + description = 'A library to artificially inflate code coverage stats via reflection' + url = "https://github.com/$github_owner_and_repo" + licenses { + license { + name = 'The Apache License, Version 2.0' + url = 'http://www.apache.org/licenses/LICENSE-2.0.txt' + distribution = "http://www.apache.org/licenses/LICENSE-2.0.txt" } } - } - repositories { - maven { - name = project_name.replace(" ", "") - url = uri("https://maven.pkg.github.com/$github_owner_and_repo") - credentials { - username = project.findProperty("gpr.user") - ?: project.findProperty("GITHUB_ALT236_PUBLISH_USERNAME") - ?: System.getenv("GITHUB_ALT236_PUBLISH_USERNAME") - password = project.findProperty("gpr.key") - ?: project.findProperty("GITHUB_ALT236_PUBLISH_KEY") - ?: System.getenv("GITHUB_ALT236_PUBLISH_KEY") + developers { + developer { + id = 'alt236' + name = 'Alexandros Schillings' + url = "https://github.com/alt236/" } } + scm { + url = "https://github.com/$github_owner_and_repo" + } } } -dependencies { - implementation "org.jetbrains.kotlin:kotlin-reflect:${kotlin_version}" - implementation 'org.apache.commons:commons-lang3:3.12.0' - implementation "com.google.guava:guava:31.1-jre" - implementation "junit:junit:4.13.2" - - testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.1' - testImplementation 'org.junit.jupiter:junit-jupiter-params:5.8.1' - testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.1' -} +// Fix for dependency order issue: https://github.com/vanniktech/gradle-maven-publish-plugin/issues/814 +afterEvaluate { + var sigDependentTasks = [ + "publishMavenPublicationToMavenCentralRepository", + ] -test { - useJUnitPlatform() + for (taskName in sigDependentTasks) { + tasks.named(taskName) { + println("Found: " + it.name) + dependsOn("signMavenPublication") + } + } } diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/CodeplasterageTestRunner.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/CodeplasterageTestRunner.kt similarity index 80% rename from codeplasterage/src/main/java/uk/co/alt236/codeplasterage/CodeplasterageTestRunner.kt rename to codeplasterage/src/main/java/dev/alt236/codeplasterage/CodeplasterageTestRunner.kt index 63797ae..e1a6b8f 100644 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/CodeplasterageTestRunner.kt +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/CodeplasterageTestRunner.kt @@ -1,32 +1,32 @@ -package uk.co.alt236.codeplasterage - +package dev.alt236.codeplasterage + +import dev.alt236.codeplasterage.config.ConfigFactory +import dev.alt236.codeplasterage.config.TesterConfig +import dev.alt236.codeplasterage.datafactory.CustomDataFactoryFactory +import dev.alt236.codeplasterage.datafactory.DummyDataFactory +import dev.alt236.codeplasterage.datafactory.stats.DataFactoryRequestRecorder +import dev.alt236.codeplasterage.datafactory.stats.DataFactoryStatsPrinter +import dev.alt236.codeplasterage.reflection.classfinder.ClassFinder +import dev.alt236.codeplasterage.reflection.instantiation.Instantiator +import dev.alt236.codeplasterage.testers.reflection.EqualsTester +import dev.alt236.codeplasterage.testers.reflection.HashCodeTester +import dev.alt236.codeplasterage.testers.reflection.MethodCallingTester +import dev.alt236.codeplasterage.testers.reflection.ToStringTester import org.junit.Ignore import org.junit.Test import org.junit.runner.Description import org.junit.runner.Runner import org.junit.runner.notification.Failure import org.junit.runner.notification.RunNotifier -import uk.co.alt236.codeplasterage.config.ConfigFactory -import uk.co.alt236.codeplasterage.config.TesterConfig -import uk.co.alt236.codeplasterage.datafactory.CustomDataFactoryFactory -import uk.co.alt236.codeplasterage.datafactory.DummyDataFactory -import uk.co.alt236.codeplasterage.datafactory.stats.DataFactoryRequestRecorder -import uk.co.alt236.codeplasterage.datafactory.stats.DataFactoryStatsPrinter -import uk.co.alt236.codeplasterage.reflection.classfinder.ClassFinder -import uk.co.alt236.codeplasterage.reflection.instantiation.Instantiator -import uk.co.alt236.codeplasterage.testers.reflection.EqualsTester -import uk.co.alt236.codeplasterage.testers.reflection.HashCodeTester -import uk.co.alt236.codeplasterage.testers.reflection.MethodCallingTester -import uk.co.alt236.codeplasterage.testers.reflection.ToStringTester import java.lang.reflect.Method -class CodeplasterageTestRunner(private val testClass: Class) : Runner() { +class CodeplasterageTestRunner( + private val testClass: Class, +) : Runner() { private val dataFactoryStatsPrinter = DataFactoryStatsPrinter() private val configFactory = ConfigFactory() - override fun getDescription(): Description { - return Description.createTestDescription(testClass, "***** Code Plasterage Test Runner *****") - } + override fun getDescription(): Description = Description.createTestDescription(testClass, "***** Code Plasterage Test Runner *****") override fun run(notifier: RunNotifier) { println("${CodeplasterageTestRunner::class.java.simpleName}: Running tests on $testClass") @@ -85,7 +85,7 @@ class CodeplasterageTestRunner(private val testClass: Class) : Runner() { private fun createAssembleDummyDataFactory( config: TesterConfig, - requestRecorded: DataFactoryRequestRecorder + requestRecorded: DataFactoryRequestRecorder, ): DummyDataFactory { val extraFactoriesFactory = CustomDataFactoryFactory(config.debug) val extraFactories = extraFactoriesFactory.createSubDataFactories(config.customDummyDataFactories) @@ -96,7 +96,7 @@ class CodeplasterageTestRunner(private val testClass: Class) : Runner() { dummyDataFactory: DummyDataFactory, config: TesterConfig, notifier: RunNotifier, - method: Method + method: Method, ) { val instantiator = Instantiator(dummyDataFactory, config.debug) @@ -111,7 +111,7 @@ class CodeplasterageTestRunner(private val testClass: Class) : Runner() { dummyDataFactory: DummyDataFactory, config: TesterConfig, notifier: RunNotifier, - method: Method + method: Method, ) { val instantiator = Instantiator(dummyDataFactory, config.debug) @@ -126,7 +126,7 @@ class CodeplasterageTestRunner(private val testClass: Class) : Runner() { dummyDataFactory: DummyDataFactory, config: TesterConfig, notifier: RunNotifier, - method: Method + method: Method, ) { val instantiator = Instantiator(dummyDataFactory, config.debug) @@ -141,7 +141,7 @@ class CodeplasterageTestRunner(private val testClass: Class) : Runner() { dummyDataFactory: DummyDataFactory, config: TesterConfig, notifier: RunNotifier, - method: Method + method: Method, ) { val instantiator = Instantiator(dummyDataFactory, config.debug) @@ -152,7 +152,11 @@ class CodeplasterageTestRunner(private val testClass: Class) : Runner() { tester.test(classes, notifier, method) } - private fun runTest(notifier: RunNotifier, classInstance: Any, method: Method) { + private fun runTest( + notifier: RunNotifier, + classInstance: Any, + method: Method, + ) { val description = Description.createTestDescription(testClass, method.name) notifier.fireTestStarted(description) diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/Consts.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/Consts.kt similarity index 72% rename from codeplasterage/src/main/java/uk/co/alt236/codeplasterage/Consts.kt rename to codeplasterage/src/main/java/dev/alt236/codeplasterage/Consts.kt index 16594e3..318b098 100644 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/Consts.kt +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/Consts.kt @@ -1,4 +1,4 @@ -package uk.co.alt236.codeplasterage +package dev.alt236.codeplasterage internal object Consts { val ROOT_PACKAGE: String = Consts::class.java.`package`.name diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/config/Config.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/config/Config.kt similarity index 75% rename from codeplasterage/src/main/java/uk/co/alt236/codeplasterage/config/Config.kt rename to codeplasterage/src/main/java/dev/alt236/codeplasterage/config/Config.kt index 3dd007c..90b8c3d 100644 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/config/Config.kt +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/config/Config.kt @@ -1,10 +1,10 @@ @file:Suppress("unused") -package uk.co.alt236.codeplasterage.config +package dev.alt236.codeplasterage.config -import uk.co.alt236.codeplasterage.config.DefaultConfigValues.DEBUG -import uk.co.alt236.codeplasterage.config.DefaultConfigValues.IGNORE_ERRORS -import uk.co.alt236.codeplasterage.datafactory.SubDataFactory +import dev.alt236.codeplasterage.config.DefaultConfigValues.DEBUG +import dev.alt236.codeplasterage.config.DefaultConfigValues.IGNORE_ERRORS +import dev.alt236.codeplasterage.datafactory.SubDataFactory import kotlin.reflect.KClass @Target(AnnotationTarget.CLASS, AnnotationTarget.FUNCTION) @@ -15,7 +15,7 @@ annotation class Config( val forceExcludeClassNames: Array = [], val customDummyDataFactories: Array> = [], val ignoreErrors: Boolean = IGNORE_ERRORS, - val debug: Boolean = DEBUG + val debug: Boolean = DEBUG, ) internal object DefaultConfigValues { diff --git a/codeplasterage/src/main/java/dev/alt236/codeplasterage/config/ConfigFactory.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/config/ConfigFactory.kt new file mode 100644 index 0000000..e797d6b --- /dev/null +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/config/ConfigFactory.kt @@ -0,0 +1,102 @@ +package dev.alt236.codeplasterage.config + +import java.lang.reflect.Method +import kotlin.reflect.KClass + +internal class ConfigFactory { + fun getConfig(testClass: Class<*>): TesterConfig { + val classAnnotation = testClass.getDeclaredAnnotation(Config::class.java) + return compileConfig(null, classAnnotation) + } + + fun compileConfig( + testClass: Class<*>, + testMethod: Method, + ): TesterConfig { + val classAnnotation = testClass.getDeclaredAnnotation(Config::class.java) + val methodAnnotation = testMethod.getDeclaredAnnotation(Config::class.java) + + return compileConfig(methodAnnotation, classAnnotation) + } + + private fun compileConfig( + methodAnnotation: Config?, + classAnnotation: Config?, + ): TesterConfig = + TesterConfig( + ignoreErrors = getIgnoreErrors(methodAnnotation, classAnnotation), + debug = getDebug(methodAnnotation, classAnnotation), + includeClassNamePatterns = + getPrioritizedSet( + methodAnnotation?.includeClassNamePatterns, + classAnnotation?.includeClassNamePatterns, + DefaultConfigValues.DEFAULT_INCLUDE_CLASS_NAME_PATTERNS, + ), + excludeClassNamePatterns = + getPrioritizedSet( + methodAnnotation?.excludeClassNamePatterns, + classAnnotation?.excludeClassNamePatterns, + DefaultConfigValues.DEFAULT_EXCLUDE_CLASS_NAME_PATTERNS, + ), + forceIncludeClassNames = + getPrioritizedSet( + methodAnnotation?.forceIncludeClassNames, + classAnnotation?.forceIncludeClassNames, + DefaultConfigValues.DEFAULT_FORCE_INCLUDE_CLASS_NAMES, + ), + forceExcludeClassNames = + getPrioritizedSet( + methodAnnotation?.forceExcludeClassNames, + classAnnotation?.forceExcludeClassNames, + DefaultConfigValues.DEFAULT_FORCE_EXCLUDE_CLASS_NAMES, + ), + customDummyDataFactories = + getPrioritizedList( + methodAnnotation?.customDummyDataFactories, + classAnnotation?.customDummyDataFactories, + emptyArray(), + ), + ) + + private fun getPrioritizedList( + methodArray: Array>?, + classArray: Array>?, + fallback: Array>, + ): List> = + when { + methodArray != null -> methodArray + classArray != null -> classArray + else -> fallback + }.toList() + + private fun getPrioritizedSet( + methodArray: Array?, + classArray: Array?, + fallback: Array, + ): Set = + when { + methodArray != null -> methodArray + classArray != null -> classArray + else -> fallback + }.toSet() + + private fun getIgnoreErrors( + methodAnnotation: Config?, + classAnnotation: Config?, + ): Boolean = + when { + methodAnnotation != null -> methodAnnotation.ignoreErrors + classAnnotation != null -> classAnnotation.ignoreErrors + else -> DefaultConfigValues.IGNORE_ERRORS + } + + private fun getDebug( + methodAnnotation: Config?, + classAnnotation: Config?, + ): Boolean = + when { + methodAnnotation != null -> methodAnnotation.debug + classAnnotation != null -> classAnnotation.debug + else -> DefaultConfigValues.DEBUG + } +} diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/config/TesterConfig.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/config/TesterConfig.kt similarity index 72% rename from codeplasterage/src/main/java/uk/co/alt236/codeplasterage/config/TesterConfig.kt rename to codeplasterage/src/main/java/dev/alt236/codeplasterage/config/TesterConfig.kt index c82df17..45c36f8 100644 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/config/TesterConfig.kt +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/config/TesterConfig.kt @@ -1,6 +1,6 @@ -package uk.co.alt236.codeplasterage.config +package dev.alt236.codeplasterage.config -import uk.co.alt236.codeplasterage.datafactory.SubDataFactory +import dev.alt236.codeplasterage.datafactory.SubDataFactory import kotlin.reflect.KClass data class TesterConfig( @@ -10,5 +10,5 @@ data class TesterConfig( val forceExcludeClassNames: Set, val customDummyDataFactories: List>, val ignoreErrors: Boolean, - val debug: Boolean + val debug: Boolean, ) diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/datafactory/CustomDataFactoryFactory.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/datafactory/CustomDataFactoryFactory.kt similarity index 76% rename from codeplasterage/src/main/java/uk/co/alt236/codeplasterage/datafactory/CustomDataFactoryFactory.kt rename to codeplasterage/src/main/java/dev/alt236/codeplasterage/datafactory/CustomDataFactoryFactory.kt index ded7a80..17954be 100644 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/datafactory/CustomDataFactoryFactory.kt +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/datafactory/CustomDataFactoryFactory.kt @@ -1,10 +1,11 @@ -package uk.co.alt236.codeplasterage.datafactory +package dev.alt236.codeplasterage.datafactory -import uk.co.alt236.codeplasterage.log.Log +import dev.alt236.codeplasterage.log.Log import kotlin.reflect.KClass -class CustomDataFactoryFactory(private val debug: Boolean) { - +class CustomDataFactoryFactory( + private val debug: Boolean, +) { fun createSubDataFactories(classes: List>): List { val result = ArrayList() for (clazz in classes) { @@ -21,7 +22,8 @@ class CustomDataFactoryFactory(private val debug: Boolean) { } catch (e: NoSuchMethodException) { val message = "Trying to instantiate custom ${SubDataFactory::class.java.simpleName}. " + - "Please ensure that '${clazz.simpleName}' has a constructor that takes a single boolean (to enable debugging) as a parameter" + "Please ensure that '${clazz.simpleName}' has a constructor that takes a single boolean " + + "(to enable debugging) as a parameter" Log.logE(throwable = e, clazz = clazz, context = message) throw e } diff --git a/codeplasterage/src/main/java/dev/alt236/codeplasterage/datafactory/DataFactoryResult.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/datafactory/DataFactoryResult.kt new file mode 100644 index 0000000..7370c50 --- /dev/null +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/datafactory/DataFactoryResult.kt @@ -0,0 +1,23 @@ +package dev.alt236.codeplasterage.datafactory + +sealed class DataFactoryResult { + data class Valid( + val value: T?, + val inputClass: Class, + ) : DataFactoryResult() + + data class Error( + val t: Throwable, + val clazz: Class, + ) : DataFactoryResult() + + companion object { + fun createUnableToCreateInstanceError( + factory: SubDataFactory, + clazz: Class, + ): Error { + val message = "${factory::class.java.simpleName}: Don't know how to produce dummy data for: '$clazz'" + return Error(IllegalStateException(message), clazz) + } + } +} diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/datafactory/DummyDataFactory.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/datafactory/DummyDataFactory.kt similarity index 66% rename from codeplasterage/src/main/java/uk/co/alt236/codeplasterage/datafactory/DummyDataFactory.kt rename to codeplasterage/src/main/java/dev/alt236/codeplasterage/datafactory/DummyDataFactory.kt index cde0e92..cde0472 100644 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/datafactory/DummyDataFactory.kt +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/datafactory/DummyDataFactory.kt @@ -1,15 +1,14 @@ @file:Suppress("MemberVisibilityCanBePrivate") -package uk.co.alt236.codeplasterage.datafactory +package dev.alt236.codeplasterage.datafactory -import uk.co.alt236.codeplasterage.datafactory.factories.ArrayFactory -import uk.co.alt236.codeplasterage.datafactory.factories.CollectionDataFactory -import uk.co.alt236.codeplasterage.datafactory.factories.ObjectDataFactory -import uk.co.alt236.codeplasterage.datafactory.factories.PrimitiveDataFactory -import uk.co.alt236.codeplasterage.datafactory.factories.TextDataFactory -import uk.co.alt236.codeplasterage.datafactory.factories.ThrowableDataFactory -import uk.co.alt236.codeplasterage.datafactory.stats.DataFactoryRequestRecorder -import uk.co.alt236.codeplasterage.log.Log +import dev.alt236.codeplasterage.datafactory.factories.ArrayFactory +import dev.alt236.codeplasterage.datafactory.factories.CollectionDataFactory +import dev.alt236.codeplasterage.datafactory.factories.PrimitiveDataFactory +import dev.alt236.codeplasterage.datafactory.factories.TextDataFactory +import dev.alt236.codeplasterage.datafactory.factories.ThrowableDataFactory +import dev.alt236.codeplasterage.datafactory.stats.DataFactoryRequestRecorder +import dev.alt236.codeplasterage.log.Log import java.lang.reflect.Executable private const val LOG_TAG = "DummyDataFactory" @@ -17,20 +16,22 @@ private const val LOG_TAG = "DummyDataFactory" internal class DummyDataFactory( private val debug: Boolean, val requestsRecorder: DataFactoryRequestRecorder, - val additionalFactories: List = emptyList() + val additionalFactories: List = emptyList(), ) { - private val factories by lazy { val primitiveFactory = PrimitiveDataFactory(debug) - val finalList = additionalFactories + listOf( - primitiveFactory, - TextDataFactory(debug), - ArrayFactory(debug), - CollectionDataFactory(debug), - ThrowableDataFactory(debug), - ObjectDataFactory(debug, primitiveFactory) - ) + val finalList = + additionalFactories + + listOf( + primitiveFactory, + TextDataFactory(debug), + ArrayFactory(debug), + CollectionDataFactory(debug), + ThrowableDataFactory(debug), + dev.alt236.codeplasterage.datafactory.factories + .ObjectDataFactory(debug, primitiveFactory), + ) finalList } diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/datafactory/SubDataFactory.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/datafactory/SubDataFactory.kt similarity index 65% rename from codeplasterage/src/main/java/uk/co/alt236/codeplasterage/datafactory/SubDataFactory.kt rename to codeplasterage/src/main/java/dev/alt236/codeplasterage/datafactory/SubDataFactory.kt index a3d7f95..73e3ec7 100644 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/datafactory/SubDataFactory.kt +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/datafactory/SubDataFactory.kt @@ -1,11 +1,13 @@ -package uk.co.alt236.codeplasterage.datafactory +package dev.alt236.codeplasterage.datafactory -import uk.co.alt236.codeplasterage.log.Log +import dev.alt236.codeplasterage.log.Log import java.lang.reflect.Modifier -abstract class SubDataFactory(private val debug: Boolean) { - +abstract class SubDataFactory( + private val debug: Boolean, +) { abstract fun canCreateDataFor(clazz: Class<*>): Boolean + abstract fun getDummyData(clazz: Class<*>): DataFactoryResult<*> @Suppress("MemberVisibilityCanBePrivate") @@ -17,14 +19,15 @@ abstract class SubDataFactory(private val debug: Boolean) { protected fun tryToInstantiate(clazz: Class): T? { logDebug("About to try and force instantiate a '$clazz'") - val isPossible = when { - Modifier.isPrivate(clazz.modifiers) -> false - Modifier.isAbstract(clazz.modifiers) -> false - clazz.isInterface -> false - clazz.isSynthetic -> false - clazz.constructors.isEmpty() -> false - else -> true - } + val isPossible = + when { + Modifier.isPrivate(clazz.modifiers) -> false + Modifier.isAbstract(clazz.modifiers) -> false + clazz.isInterface -> false + clazz.isSynthetic -> false + clazz.constructors.isEmpty() -> false + else -> true + } return if (isPossible) { try { diff --git a/codeplasterage/src/main/java/dev/alt236/codeplasterage/datafactory/factories/ArrayFactory.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/datafactory/factories/ArrayFactory.kt new file mode 100644 index 0000000..308b3e0 --- /dev/null +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/datafactory/factories/ArrayFactory.kt @@ -0,0 +1,17 @@ +package dev.alt236.codeplasterage.datafactory.factories + +import dev.alt236.codeplasterage.datafactory.DataFactoryResult +import dev.alt236.codeplasterage.datafactory.DataFactoryResult.Valid +import dev.alt236.codeplasterage.datafactory.SubDataFactory +import java.lang.reflect.Array + +class ArrayFactory( + debug: Boolean, +) : SubDataFactory(debug) { + override fun canCreateDataFor(clazz: Class<*>) = clazz.isArray + + override fun getDummyData(clazz: Class<*>): DataFactoryResult<*> { + val array = Array.newInstance(clazz.componentType, 0) + return Valid(array, clazz) + } +} diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/datafactory/factories/CollectionDataFactory.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/datafactory/factories/CollectionDataFactory.kt similarity index 74% rename from codeplasterage/src/main/java/uk/co/alt236/codeplasterage/datafactory/factories/CollectionDataFactory.kt rename to codeplasterage/src/main/java/dev/alt236/codeplasterage/datafactory/factories/CollectionDataFactory.kt index 0775397..5b873e5 100644 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/datafactory/factories/CollectionDataFactory.kt +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/datafactory/factories/CollectionDataFactory.kt @@ -1,19 +1,20 @@ -package uk.co.alt236.codeplasterage.datafactory.factories +package dev.alt236.codeplasterage.datafactory.factories -import uk.co.alt236.codeplasterage.datafactory.DataFactoryResult -import uk.co.alt236.codeplasterage.datafactory.SubDataFactory -import uk.co.alt236.codeplasterage.ext.ClassExt.implementsOrIsAnyOf +import dev.alt236.codeplasterage.datafactory.DataFactoryResult +import dev.alt236.codeplasterage.datafactory.SubDataFactory +import dev.alt236.codeplasterage.ext.ClassExt.implementsOrIsAnyOf import java.util.* import javax.annotation.Nonnull -class CollectionDataFactory(debug: Boolean) : SubDataFactory(debug) { +class CollectionDataFactory( + debug: Boolean, +) : SubDataFactory(debug) { + override fun canCreateDataFor(clazz: Class<*>): Boolean = clazz.implementsOrIsAnyOf(EXPECTED_INTERFACES) - override fun canCreateDataFor(clazz: Class<*>): Boolean { - return clazz.implementsOrIsAnyOf(EXPECTED_INTERFACES) - } - - override fun getDummyData(@Nonnull clazz: Class<*>): DataFactoryResult<*> { - return when (clazz) { + override fun getDummyData( + @Nonnull clazz: Class<*>, + ): DataFactoryResult<*> = + when (clazz) { Vector::class.java -> DataFactoryResult.Valid(Vector(), clazz) Stack::class.java -> DataFactoryResult.Valid(Stack(), clazz) @@ -47,13 +48,13 @@ class CollectionDataFactory(debug: Boolean) : SubDataFactory(debug) { } } } - } private companion object { - val EXPECTED_INTERFACES = setOf( - Collection::class.java, - Iterable::class.java, - Map::class.java - ) + val EXPECTED_INTERFACES = + setOf( + Collection::class.java, + Iterable::class.java, + Map::class.java, + ) } } diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/datafactory/factories/ObjectDataFactory.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/datafactory/factories/ObjectDataFactory.kt similarity index 52% rename from codeplasterage/src/main/java/uk/co/alt236/codeplasterage/datafactory/factories/ObjectDataFactory.kt rename to codeplasterage/src/main/java/dev/alt236/codeplasterage/datafactory/factories/ObjectDataFactory.kt index 662fe87..bcc4235 100644 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/datafactory/factories/ObjectDataFactory.kt +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/datafactory/factories/ObjectDataFactory.kt @@ -1,7 +1,7 @@ -package uk.co.alt236.codeplasterage.datafactory.factories +package dev.alt236.codeplasterage.datafactory.factories -import uk.co.alt236.codeplasterage.datafactory.DataFactoryResult -import uk.co.alt236.codeplasterage.datafactory.SubDataFactory +import dev.alt236.codeplasterage.datafactory.DataFactoryResult +import dev.alt236.codeplasterage.datafactory.SubDataFactory import java.io.Closeable import java.io.InputStream import java.io.Serializable @@ -15,14 +15,15 @@ import java.util.concurrent.TimeUnit import kotlin.reflect.KClass import kotlin.time.Duration -internal class ObjectDataFactory(boolean: Boolean, private val primitiveFactory: PrimitiveDataFactory) : - SubDataFactory(boolean) { - +internal class ObjectDataFactory( + boolean: Boolean, + private val primitiveFactory: PrimitiveDataFactory, +) : SubDataFactory(boolean) { override fun canCreateDataFor(clazz: Class<*>) = true // This is our fallback @Suppress("RemoveRedundantQualifierName") - override fun getDummyData(clazz: Class<*>): DataFactoryResult<*> { - return when (clazz) { + override fun getDummyData(clazz: Class<*>): DataFactoryResult<*> = + when (clazz) { // // Numbers // @@ -50,21 +51,53 @@ internal class ObjectDataFactory(boolean: Boolean, private val primitiveFactory: java.lang.Short::class.java -> primitiveFactory.getDummyData(Short::class.java) kotlin.Short::class.java -> primitiveFactory.getDummyData(Short::class.java) - BigDecimal::class.java -> DataFactoryResult.Valid(DUMMY_BIGDECIMAL, clazz) - BigInteger::class.java -> DataFactoryResult.Valid(DUMMY_BIGINTEGER, clazz) - - UUID::class.java -> DataFactoryResult.Valid(DUMMY_UUID, clazz) - java.util.UUID::class.java -> DataFactoryResult.Valid(DUMMY_UUID, clazz) - - URL::class.java -> DataFactoryResult.Valid(DUMMY_URL, clazz) + BigDecimal::class.java -> + DataFactoryResult.Valid( + dev.alt236.codeplasterage.datafactory.factories.ObjectDataFactory.Companion.DUMMY_BIGDECIMAL, + clazz, + ) + BigInteger::class.java -> + DataFactoryResult.Valid( + dev.alt236.codeplasterage.datafactory.factories.ObjectDataFactory.Companion.DUMMY_BIGINTEGER, + clazz, + ) + + UUID::class.java -> + DataFactoryResult.Valid( + dev.alt236.codeplasterage.datafactory.factories.ObjectDataFactory.Companion.DUMMY_UUID, + clazz, + ) + java.util.UUID::class.java -> + DataFactoryResult.Valid( + dev.alt236.codeplasterage.datafactory.factories.ObjectDataFactory.Companion.DUMMY_UUID, + clazz, + ) + + URL::class.java -> + DataFactoryResult.Valid( + dev.alt236.codeplasterage.datafactory.factories.ObjectDataFactory.Companion.DUMMY_URL, + clazz, + ) // // Locale/Date/Time // Date::class.java -> DataFactoryResult.Valid(Date(0), clazz) - Locale::class.java -> DataFactoryResult.Valid(DUMMY_LOCALE, clazz) - Calendar::class.java -> DataFactoryResult.Valid(Calendar.getInstance(DUMMY_TIME_ZONE), clazz) - TimeZone::class.java -> DataFactoryResult.Valid(DUMMY_TIME_ZONE, clazz) + Locale::class.java -> + DataFactoryResult.Valid( + dev.alt236.codeplasterage.datafactory.factories.ObjectDataFactory.Companion.DUMMY_LOCALE, + clazz, + ) + Calendar::class.java -> + DataFactoryResult.Valid( + Calendar.getInstance(dev.alt236.codeplasterage.datafactory.factories.ObjectDataFactory.Companion.DUMMY_TIME_ZONE), + clazz, + ) + TimeZone::class.java -> + DataFactoryResult.Valid( + dev.alt236.codeplasterage.datafactory.factories.ObjectDataFactory.Companion.DUMMY_TIME_ZONE, + clazz, + ) DateFormat::class.java -> DataFactoryResult.Valid(DateFormat.getInstance(), clazz) SimpleDateFormat::class.java -> DataFactoryResult.Valid(SimpleDateFormat.getInstance(), clazz) @@ -72,18 +105,29 @@ internal class ObjectDataFactory(boolean: Boolean, private val primitiveFactory: java.time.Duration::class.java -> DataFactoryResult.Valid(java.time.Duration.ZERO, clazz) java.util.concurrent.TimeUnit::class.java -> DataFactoryResult.Valid(TimeUnit.MILLISECONDS, clazz) - java.util.Currency::class.java -> DataFactoryResult.Valid(DUMMY_CURRENCY, clazz) + java.util.Currency::class.java -> + DataFactoryResult.Valid( + dev.alt236.codeplasterage.datafactory.factories.ObjectDataFactory.Companion.DUMMY_CURRENCY, + clazz, + ) Iterator::class.java -> DataFactoryResult.Valid(emptyList().iterator(), clazz) - java.util.Iterator::class.java -> DataFactoryResult.Valid( - java.util.Collections.emptyList().iterator(), - clazz - ) + java.util.Iterator::class.java -> + DataFactoryResult.Valid( + java.util.Collections + .emptyList() + .iterator(), + clazz, + ) // Streams Readable::class.java -> DataFactoryResult.Valid("".reader(), clazz) InputStream::class.java -> DataFactoryResult.Valid("".byteInputStream(), clazz) - Closeable::class.java -> DataFactoryResult.Valid(DUMMY_CLOSABLE, clazz) + Closeable::class.java -> + DataFactoryResult.Valid( + dev.alt236.codeplasterage.datafactory.factories.ObjectDataFactory.Companion.DUMMY_CLOSABLE, + clazz, + ) // // Esoteric @@ -92,14 +136,25 @@ internal class ObjectDataFactory(boolean: Boolean, private val primitiveFactory: Class::class.java -> DataFactoryResult.Valid(Object::class.java, clazz) KClass::class.java -> DataFactoryResult.Valid(Object::class, clazz) - java.lang.Object::class.java -> DataFactoryResult.Valid(DUMMY_OBJECT, clazz) - Any::class.java -> DataFactoryResult.Valid(DUMMY_OBJECT, clazz) - Serializable::class.java -> DataFactoryResult.Valid(DUMMY_SERIALIZABLE, clazz) + java.lang.Object::class.java -> + DataFactoryResult.Valid( + dev.alt236.codeplasterage.datafactory.factories.ObjectDataFactory.Companion.DUMMY_OBJECT, + clazz, + ) + Any::class.java -> + DataFactoryResult.Valid( + dev.alt236.codeplasterage.datafactory.factories.ObjectDataFactory.Companion.DUMMY_OBJECT, + clazz, + ) + Serializable::class.java -> + DataFactoryResult.Valid( + dev.alt236.codeplasterage.datafactory.factories.ObjectDataFactory.Companion.DUMMY_SERIALIZABLE, + clazz, + ) else -> { DataFactoryResult.createUnableToCreateInstanceError(this, clazz) } } - } private companion object { val DUMMY_SERIALIZABLE: Serializable = "FOO_DUMMY_SERIALIZABLE" diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/datafactory/factories/PrimitiveDataFactory.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/datafactory/factories/PrimitiveDataFactory.kt similarity index 75% rename from codeplasterage/src/main/java/uk/co/alt236/codeplasterage/datafactory/factories/PrimitiveDataFactory.kt rename to codeplasterage/src/main/java/dev/alt236/codeplasterage/datafactory/factories/PrimitiveDataFactory.kt index d703fd5..ca6420a 100644 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/datafactory/factories/PrimitiveDataFactory.kt +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/datafactory/factories/PrimitiveDataFactory.kt @@ -1,16 +1,20 @@ -package uk.co.alt236.codeplasterage.datafactory.factories +package dev.alt236.codeplasterage.datafactory.factories -import uk.co.alt236.codeplasterage.datafactory.DataFactoryResult -import uk.co.alt236.codeplasterage.datafactory.DataFactoryResult.Valid -import uk.co.alt236.codeplasterage.datafactory.SubDataFactory +import dev.alt236.codeplasterage.datafactory.DataFactoryResult +import dev.alt236.codeplasterage.datafactory.DataFactoryResult.Valid +import dev.alt236.codeplasterage.datafactory.SubDataFactory import javax.annotation.Nonnull -class PrimitiveDataFactory(debug: Boolean) : SubDataFactory(debug) { +class PrimitiveDataFactory( + debug: Boolean, +) : SubDataFactory(debug) { override fun canCreateDataFor(clazz: Class<*>) = clazz.isPrimitive @Nonnull - override fun getDummyData(@Nonnull clazz: Class<*>): DataFactoryResult<*> { - return when (clazz) { + override fun getDummyData( + @Nonnull clazz: Class<*>, + ): DataFactoryResult<*> = + when (clazz) { Boolean::class.java, Boolean::class.javaPrimitiveType -> Valid(DUMMY_BOOLEAN, clazz) Byte::class.java, Byte::class.javaPrimitiveType -> Valid(DUMMY_BYTE, clazz) Char::class.java, Char::class.javaPrimitiveType -> Valid(DUMMY_CHAR, clazz) @@ -24,7 +28,6 @@ class PrimitiveDataFactory(debug: Boolean) : SubDataFactory(debug) { DataFactoryResult.createUnableToCreateInstanceError(this, clazz) } } - } private companion object { const val DUMMY_BOOLEAN: Boolean = false diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/datafactory/factories/TextDataFactory.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/datafactory/factories/TextDataFactory.kt similarity index 56% rename from codeplasterage/src/main/java/uk/co/alt236/codeplasterage/datafactory/factories/TextDataFactory.kt rename to codeplasterage/src/main/java/dev/alt236/codeplasterage/datafactory/factories/TextDataFactory.kt index a53e012..9f29846 100644 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/datafactory/factories/TextDataFactory.kt +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/datafactory/factories/TextDataFactory.kt @@ -1,18 +1,19 @@ -package uk.co.alt236.codeplasterage.datafactory.factories +package dev.alt236.codeplasterage.datafactory.factories -import uk.co.alt236.codeplasterage.datafactory.DataFactoryResult -import uk.co.alt236.codeplasterage.datafactory.SubDataFactory -import uk.co.alt236.codeplasterage.ext.ClassExt.implementsOrIsAnyOf +import dev.alt236.codeplasterage.datafactory.DataFactoryResult +import dev.alt236.codeplasterage.datafactory.SubDataFactory +import dev.alt236.codeplasterage.ext.ClassExt.implementsOrIsAnyOf import javax.annotation.Nonnull -class TextDataFactory(debug: Boolean) : SubDataFactory(debug) { +class TextDataFactory( + debug: Boolean, +) : SubDataFactory(debug) { + override fun canCreateDataFor(clazz: Class<*>): Boolean = clazz.implementsOrIsAnyOf(EXPECTED_INTERFACES) - override fun canCreateDataFor(clazz: Class<*>): Boolean { - return clazz.implementsOrIsAnyOf(EXPECTED_INTERFACES) - } - - override fun getDummyData(@Nonnull clazz: Class<*>): DataFactoryResult<*> { - return when (clazz) { + override fun getDummyData( + @Nonnull clazz: Class<*>, + ): DataFactoryResult<*> = + when (clazz) { String::class.java -> DataFactoryResult.Valid(DUMMY_STRING, clazz) java.lang.String::class.java -> DataFactoryResult.Valid(DUMMY_STRING, clazz) @@ -26,13 +27,13 @@ class TextDataFactory(debug: Boolean) : SubDataFactory(debug) { else -> DataFactoryResult.createUnableToCreateInstanceError(this, clazz) } - } private companion object { const val DUMMY_STRING = "FOO_DUMMY_TEXT" - val EXPECTED_INTERFACES = setOf( - CharSequence::class.java - ) + val EXPECTED_INTERFACES = + setOf( + CharSequence::class.java, + ) } } diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/datafactory/factories/ThrowableDataFactory.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/datafactory/factories/ThrowableDataFactory.kt similarity index 84% rename from codeplasterage/src/main/java/uk/co/alt236/codeplasterage/datafactory/factories/ThrowableDataFactory.kt rename to codeplasterage/src/main/java/dev/alt236/codeplasterage/datafactory/factories/ThrowableDataFactory.kt index c80436d..2a0a83e 100644 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/datafactory/factories/ThrowableDataFactory.kt +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/datafactory/factories/ThrowableDataFactory.kt @@ -1,19 +1,20 @@ -package uk.co.alt236.codeplasterage.datafactory.factories +package dev.alt236.codeplasterage.datafactory.factories -import uk.co.alt236.codeplasterage.datafactory.DataFactoryResult -import uk.co.alt236.codeplasterage.datafactory.DataFactoryResult.Valid -import uk.co.alt236.codeplasterage.datafactory.SubDataFactory +import dev.alt236.codeplasterage.datafactory.DataFactoryResult +import dev.alt236.codeplasterage.datafactory.DataFactoryResult.Valid +import dev.alt236.codeplasterage.datafactory.SubDataFactory import java.io.IOException import javax.annotation.Nonnull -class ThrowableDataFactory(debug: Boolean) : SubDataFactory(debug) { +class ThrowableDataFactory( + debug: Boolean, +) : SubDataFactory(debug) { + override fun canCreateDataFor(clazz: Class<*>): Boolean = Throwable::class.java.isAssignableFrom(clazz) - override fun canCreateDataFor(clazz: Class<*>): Boolean { - return Throwable::class.java.isAssignableFrom(clazz) - } - - override fun getDummyData(@Nonnull clazz: Class<*>): DataFactoryResult<*> { - return when (clazz) { + override fun getDummyData( + @Nonnull clazz: Class<*>, + ): DataFactoryResult<*> = + when (clazz) { ArithmeticException::class.java -> Valid(DUMMY_ARITHMETIC_E, clazz) AssertionError::class.java -> Valid(DUMMY_ASSERTION_E, clazz) ClassCastException::class.java -> Valid(DUMMY_CLASS_CAST_E, clazz) @@ -42,7 +43,6 @@ class ThrowableDataFactory(debug: Boolean) : SubDataFactory(debug) { } } } - } private companion object { const val MESSAGE_DUMMY_EXCEPTION = "This is a Dummy Exception!" diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/datafactory/stats/DataFactoryRequestRecorder.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/datafactory/stats/DataFactoryRequestRecorder.kt similarity index 91% rename from codeplasterage/src/main/java/uk/co/alt236/codeplasterage/datafactory/stats/DataFactoryRequestRecorder.kt rename to codeplasterage/src/main/java/dev/alt236/codeplasterage/datafactory/stats/DataFactoryRequestRecorder.kt index 591e621..90ea486 100644 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/datafactory/stats/DataFactoryRequestRecorder.kt +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/datafactory/stats/DataFactoryRequestRecorder.kt @@ -1,7 +1,6 @@ -package uk.co.alt236.codeplasterage.datafactory.stats +package dev.alt236.codeplasterage.datafactory.stats class DataFactoryRequestRecorder { - private val failed = HashMap, Long>() private val successful = HashMap, Long>() diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/datafactory/stats/DataFactoryStatsPrinter.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/datafactory/stats/DataFactoryStatsPrinter.kt similarity index 77% rename from codeplasterage/src/main/java/uk/co/alt236/codeplasterage/datafactory/stats/DataFactoryStatsPrinter.kt rename to codeplasterage/src/main/java/dev/alt236/codeplasterage/datafactory/stats/DataFactoryStatsPrinter.kt index 29c1cce..7ff7942 100644 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/datafactory/stats/DataFactoryStatsPrinter.kt +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/datafactory/stats/DataFactoryStatsPrinter.kt @@ -1,10 +1,9 @@ -package uk.co.alt236.codeplasterage.datafactory.stats +package dev.alt236.codeplasterage.datafactory.stats -import uk.co.alt236.codeplasterage.datafactory.DummyDataFactory -import uk.co.alt236.codeplasterage.log.Log +import dev.alt236.codeplasterage.datafactory.DummyDataFactory +import dev.alt236.codeplasterage.log.Log internal class DataFactoryStatsPrinter { - fun print(recorder: DataFactoryRequestRecorder) { val sb = StringBuilder() @@ -16,7 +15,10 @@ internal class DataFactoryStatsPrinter { Log.logE(sb.toString()) } - private fun StringBuilder.addSection(section: String, classes: Map, Long>): StringBuilder { + private fun StringBuilder.addSection( + section: String, + classes: Map, Long>, + ): StringBuilder { if (classes.isNotEmpty()) { val sortedKeys = classes.entries.sortedByDescending { it.value }.map { it.key } this.append("* ${DummyDataFactory::class.java.simpleName} $section: \n") @@ -35,11 +37,10 @@ internal class DataFactoryStatsPrinter { return this } - private fun Class<*>.getType(): String { - return when { + private fun Class<*>.getType(): String = + when { this.isInterface -> "interface" this.isEnum -> "enum" else -> "class" } - } } diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/ext/AnnotationExt.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/ext/AnnotationExt.kt similarity index 96% rename from codeplasterage/src/main/java/uk/co/alt236/codeplasterage/ext/AnnotationExt.kt rename to codeplasterage/src/main/java/dev/alt236/codeplasterage/ext/AnnotationExt.kt index 7a41db9..ddf459b 100644 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/ext/AnnotationExt.kt +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/ext/AnnotationExt.kt @@ -1,9 +1,8 @@ -package uk.co.alt236.codeplasterage.ext +package dev.alt236.codeplasterage.ext import java.lang.reflect.AnnotatedElement object AnnotationExt { - fun Class<*>.methodsAreAnnotatedWithAnyOf(candidates: Set): Boolean { for (method in this.declaredMethods) { if (method.isAnnotatedWithAnyOf(candidates)) { diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/ext/ClassExt.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/ext/ClassExt.kt similarity index 73% rename from codeplasterage/src/main/java/uk/co/alt236/codeplasterage/ext/ClassExt.kt rename to codeplasterage/src/main/java/dev/alt236/codeplasterage/ext/ClassExt.kt index bc2445b..6853a20 100644 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/ext/ClassExt.kt +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/ext/ClassExt.kt @@ -1,10 +1,9 @@ -package uk.co.alt236.codeplasterage.ext +package dev.alt236.codeplasterage.ext +import dev.alt236.codeplasterage.log.Log import org.apache.commons.lang3.ClassUtils -import uk.co.alt236.codeplasterage.log.Log object ClassExt { - fun Class<*>.canLoadMethods(): Boolean { try { this.methods @@ -35,11 +34,7 @@ object ClassExt { return thisSupers.containsAnyOf(candidates) } - fun Class<*>.getAllInterfaces(): Set> { - return ClassUtils.getAllInterfaces(this).toSet() - } + fun Class<*>.getAllInterfaces(): Set> = ClassUtils.getAllInterfaces(this).toSet() - fun Class<*>.getAllSuperClasses(): Set> { - return ClassUtils.getAllSuperclasses(this).toSet() - } + fun Class<*>.getAllSuperClasses(): Set> = ClassUtils.getAllSuperclasses(this).toSet() } diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/ext/NormalisedClassName.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/ext/NormalisedClassName.kt similarity index 63% rename from codeplasterage/src/main/java/uk/co/alt236/codeplasterage/ext/NormalisedClassName.kt rename to codeplasterage/src/main/java/dev/alt236/codeplasterage/ext/NormalisedClassName.kt index 29cd36a..85aedb2 100644 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/ext/NormalisedClassName.kt +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/ext/NormalisedClassName.kt @@ -1,16 +1,14 @@ -package uk.co.alt236.codeplasterage.ext +package dev.alt236.codeplasterage.ext -data class NormalisedClassName(val className: String) { +data class NormalisedClassName( + val className: String, +) { constructor(clazz: Class<*>) : this(clazz.name) } -fun Array>.toNormalisedClassNameSet(): Set { - return this.map { NormalisedClassName(it) }.toSet() -} +fun Array>.toNormalisedClassNameSet(): Set = this.map { NormalisedClassName(it) }.toSet() -fun Collection>.toNormalisedClassNameSet(): Set { - return this.map { NormalisedClassName(it) }.toSet() -} +fun Collection>.toNormalisedClassNameSet(): Set = this.map { NormalisedClassName(it) }.toSet() internal fun Set.containsAnyOf(other: Set): Boolean { for (candidate in other) { diff --git a/codeplasterage/src/main/java/dev/alt236/codeplasterage/log/Log.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/log/Log.kt new file mode 100644 index 0000000..3cb937d --- /dev/null +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/log/Log.kt @@ -0,0 +1,93 @@ +package dev.alt236.codeplasterage.log + +import com.google.common.reflect.ClassPath.ClassInfo +import java.lang.reflect.Executable +import kotlin.reflect.KClass + +@Suppress("unused") +internal object Log { + private const val LABEL_EXCEPTION = "Exception: " + private const val LABEL_CAUSE = " cause: " + private const val LABEL_ON = " on: " + private const val LABEL_WHEN = " while: " + + fun log( + where: String, + what: Any, + ) { + println("[$where] $what") + } + + fun logE( + throwable: Throwable, + executable: Executable, + context: String? = null, + ) { + logError(throwable, executable.toString(), context) + } + + fun logE( + throwable: Throwable, + clazz: KClass<*>, + context: String? = null, + ) { + logError(throwable, clazz.toString(), context) + } + + fun logE( + throwable: Throwable, + clazz: Class<*>, + context: String? = null, + ) { + logError(throwable, clazz.toString(), context) + } + + fun logE( + throwable: Throwable, + classInfo: ClassInfo, + context: String? = null, + ) { + logError(throwable, classInfo.toString(), context) + } + + fun logE( + message: String, + throwable: Throwable, + ) { + logE(message) + throwable.printStackTrace() + } + + fun logE(message: String) { + System.err.println(message) + } + + private fun logError( + throwable: Throwable, + onWhat: String, + context: String?, + ) { + val message = + buildString { + append(LABEL_EXCEPTION) + append("${throwable::class.java.simpleName}(${throwable.message ?: ""})") + if (throwable.cause != null) { + append("\n") + append(LABEL_CAUSE) + append(throwable.cause) + } + + append("\n") + append(LABEL_ON) + append(onWhat) + + if (!context.isNullOrEmpty()) { + append("\n") + append(LABEL_WHEN) + append(context) + } + } + + logE(message) + } +} diff --git a/codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/classfinder/ClassFilterResult.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/classfinder/ClassFilterResult.kt new file mode 100644 index 0000000..9bc0901 --- /dev/null +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/classfinder/ClassFilterResult.kt @@ -0,0 +1,39 @@ +package dev.alt236.codeplasterage.reflection.classfinder + +sealed interface ClassFilterResult { + data object Include : ClassFilterResult + + sealed interface Exclude : ClassFilterResult { + fun getReason(): String = this::class.java.simpleName + + data object IsPrivate : Exclude + + data object IsAbstract : Exclude + + data object IsProxy : Exclude + + data object IsInterface : Exclude + + data object IsAnnotation : Exclude + + data object IsSynthetic : Exclude + + data object CannotLoadMethods : Exclude + + data object ForbiddenClassAncestry : Exclude + + data object ForbiddenClassAnnotation : Exclude + + data object ForbiddenClassName : Exclude + + data object ForbiddenMethodAnnotation : Exclude + + data object PartOfLibraryPackage : Exclude + + data class Custom( + private val reason: String, + ) : Exclude { + override fun getReason(): String = reason + } + } +} diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/classfinder/ClassFinder.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/classfinder/ClassFinder.kt similarity index 70% rename from codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/classfinder/ClassFinder.kt rename to codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/classfinder/ClassFinder.kt index 437bebc..4fdfc5a 100644 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/classfinder/ClassFinder.kt +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/classfinder/ClassFinder.kt @@ -1,16 +1,15 @@ -package uk.co.alt236.codeplasterage.reflection.classfinder +package dev.alt236.codeplasterage.reflection.classfinder import com.google.common.reflect.ClassPath -import uk.co.alt236.codeplasterage.config.TesterConfig -import uk.co.alt236.codeplasterage.log.Log -import uk.co.alt236.codeplasterage.reflection.classfinder.filters.ConfigDrivenClassFilter -import uk.co.alt236.codeplasterage.reflection.classfinder.filters.GlobalClassFilter +import dev.alt236.codeplasterage.config.TesterConfig +import dev.alt236.codeplasterage.log.Log +import dev.alt236.codeplasterage.reflection.classfinder.filters.ConfigDrivenClassFilter +import dev.alt236.codeplasterage.reflection.classfinder.filters.GlobalClassFilter class ClassFinder( private val debug: Boolean = false, - private val systemFilter: ClassFinderFilter = GlobalClassFilter() + private val systemFilter: ClassFinderFilter = GlobalClassFilter(), ) { - @Synchronized fun getClasses(config: TesterConfig): List> { val filter = ConfigDrivenClassFilter(config) @@ -24,10 +23,11 @@ class ClassFinder( val clazz = info.tryToLoad() if (clazz != null) { when (val filterResult = systemFilter.isIncluded(clazz)) { - is ClassFilterResult.Include -> if (filterResult == ClassFilterResult.Include) { - printDebug("Including: $clazz.") - result.add(clazz) - } + is ClassFilterResult.Include -> + if (filterResult == ClassFilterResult.Include) { + printDebug("Including: $clazz.") + result.add(clazz) + } is ClassFilterResult.Exclude -> printDebug("Excluding (${filterResult.getReason()}): $clazz") } diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/classfinder/ClassFinderFilter.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/classfinder/ClassFinderFilter.kt similarity index 59% rename from codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/classfinder/ClassFinderFilter.kt rename to codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/classfinder/ClassFinderFilter.kt index 60410be..48e0d7b 100644 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/classfinder/ClassFinderFilter.kt +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/classfinder/ClassFinderFilter.kt @@ -1,6 +1,5 @@ -package uk.co.alt236.codeplasterage.reflection.classfinder +package dev.alt236.codeplasterage.reflection.classfinder interface ClassFinderFilter { - fun isIncluded(clazz: Class<*>): ClassFilterResult } diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/classfinder/filters/ConfigDrivenClassFilter.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/classfinder/filters/ConfigDrivenClassFilter.kt similarity index 82% rename from codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/classfinder/filters/ConfigDrivenClassFilter.kt rename to codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/classfinder/filters/ConfigDrivenClassFilter.kt index 9ac50b8..4330963 100644 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/classfinder/filters/ConfigDrivenClassFilter.kt +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/classfinder/filters/ConfigDrivenClassFilter.kt @@ -1,9 +1,10 @@ -package uk.co.alt236.codeplasterage.reflection.classfinder.filters +package dev.alt236.codeplasterage.reflection.classfinder.filters -import uk.co.alt236.codeplasterage.config.TesterConfig - -class ConfigDrivenClassFilter(config: TesterConfig) { +import dev.alt236.codeplasterage.config.TesterConfig +class ConfigDrivenClassFilter( + config: TesterConfig, +) { private val includeClassNamePatterns by lazy { val retVal = ArrayList() for (pattern in config.includeClassNamePatterns) { @@ -23,9 +24,7 @@ class ConfigDrivenClassFilter(config: TesterConfig) { private val forceExcludeClassNames = config.forceExcludeClassNames @Suppress("unused") - fun isIncluded(clazz: Class<*>): Boolean { - return isIncluded(clazz.name) - } + fun isIncluded(clazz: Class<*>): Boolean = isIncluded(clazz.name) fun isIncluded(clazzName: String): Boolean { if (forceIncludeClassNames.contains(clazzName)) { diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/classfinder/filters/GlobalClassFilter.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/classfinder/filters/GlobalClassFilter.kt similarity index 65% rename from codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/classfinder/filters/GlobalClassFilter.kt rename to codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/classfinder/filters/GlobalClassFilter.kt index 8de13ed..d4a8887 100644 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/classfinder/filters/GlobalClassFilter.kt +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/classfinder/filters/GlobalClassFilter.kt @@ -1,14 +1,14 @@ -package uk.co.alt236.codeplasterage.reflection.classfinder.filters - -import uk.co.alt236.codeplasterage.Consts -import uk.co.alt236.codeplasterage.ext.ClassExt.canLoadMethods -import uk.co.alt236.codeplasterage.reflection.classfinder.ClassFilterResult -import uk.co.alt236.codeplasterage.reflection.classfinder.ClassFilterResult.Exclude -import uk.co.alt236.codeplasterage.reflection.classfinder.ClassFinderFilter -import uk.co.alt236.codeplasterage.reflection.classfinder.filters.checks.CheckForbiddenAncestry -import uk.co.alt236.codeplasterage.reflection.classfinder.filters.checks.CheckForbiddenClassAnnotations -import uk.co.alt236.codeplasterage.reflection.classfinder.filters.checks.CheckForbiddenMethodAnnotations -import uk.co.alt236.codeplasterage.reflection.classfinder.filters.checks.CheckForbiddenName +package dev.alt236.codeplasterage.reflection.classfinder.filters + +import dev.alt236.codeplasterage.Consts +import dev.alt236.codeplasterage.ext.ClassExt.canLoadMethods +import dev.alt236.codeplasterage.reflection.classfinder.ClassFilterResult +import dev.alt236.codeplasterage.reflection.classfinder.ClassFilterResult.Exclude +import dev.alt236.codeplasterage.reflection.classfinder.ClassFinderFilter +import dev.alt236.codeplasterage.reflection.classfinder.filters.checks.CheckForbiddenAncestry +import dev.alt236.codeplasterage.reflection.classfinder.filters.checks.CheckForbiddenClassAnnotations +import dev.alt236.codeplasterage.reflection.classfinder.filters.checks.CheckForbiddenMethodAnnotations +import dev.alt236.codeplasterage.reflection.classfinder.filters.checks.CheckForbiddenName import java.lang.reflect.Modifier import java.lang.reflect.Proxy diff --git a/codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/classfinder/filters/checks/CheckForbiddenAncestry.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/classfinder/filters/checks/CheckForbiddenAncestry.kt new file mode 100644 index 0000000..8083ad8 --- /dev/null +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/classfinder/filters/checks/CheckForbiddenAncestry.kt @@ -0,0 +1,20 @@ +package dev.alt236.codeplasterage.reflection.classfinder.filters.checks + +import dev.alt236.codeplasterage.ext.ClassExt.isAssignableToAnyOf +import dev.alt236.codeplasterage.ext.NormalisedClassName + +class CheckForbiddenAncestry : ForbiddenCheck { + override fun isForbidden(clazz: Class<*>): Boolean = clazz.isAssignableToAnyOf(FORBIDDEN_SUPERCLASSES_AND_INTERFACES) + + companion object { + private val FORBIDDEN_SUPERCLASSES_AND_INTERFACES = + setOf( + NormalisedClassName("dagger.internal.Factory"), + NormalisedClassName("dagger.MembersInjector"), + NormalisedClassName("org.greenrobot.greendao.AbstractDao"), + NormalisedClassName("dagger.hilt.android.internal.testing.EarlySingletonComponentCreator"), + NormalisedClassName("dagger.hilt.android.internal.testing.TestComponentDataSupplier"), + NormalisedClassName(kotlin.jvm.internal.Lambda::class.java), + ) + } +} diff --git a/codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/classfinder/filters/checks/CheckForbiddenClassAnnotations.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/classfinder/filters/checks/CheckForbiddenClassAnnotations.kt new file mode 100644 index 0000000..ec1fe2d --- /dev/null +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/classfinder/filters/checks/CheckForbiddenClassAnnotations.kt @@ -0,0 +1,28 @@ +package dev.alt236.codeplasterage.reflection.classfinder.filters.checks + +import dev.alt236.codeplasterage.ext.AnnotationExt.isAnnotatedWithAnyOf +import dev.alt236.codeplasterage.ext.NormalisedClassName +import org.junit.runner.RunWith + +class CheckForbiddenClassAnnotations : ForbiddenCheck { + override fun isForbidden(clazz: Class<*>): Boolean = clazz.isAnnotatedWithAnyOf(FORBIDDEN_CLASS_ANNOTATIONS) + + private companion object { + private val FORBIDDEN_CLASS_ANNOTATIONS = + setOf( + NormalisedClassName("dagger.hilt.android.EarlyEntryPoint"), + NormalisedClassName("dagger.hilt.codegen.OriginatingElement"), + NormalisedClassName("dagger.hilt.InstallIn"), + NormalisedClassName("dagger.hilt.internal.aggregatedroot.AggregatedRoot"), + NormalisedClassName("dagger.hilt.internal.GeneratedEntryPoint"), + NormalisedClassName("dagger.hilt.internal.processedrootsentinel.ProcessedRootSentinel"), + NormalisedClassName("dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps"), + NormalisedClassName("dagger.internal.DaggerGenerated"), + NormalisedClassName("dagger.internal.QualifierMetadata"), + NormalisedClassName("dagger.internal.ScopeMetadata"), + NormalisedClassName("dagger.Module"), + NormalisedClassName("javax.annotation.Generated"), + NormalisedClassName(RunWith::class.java), + ) + } +} diff --git a/codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/classfinder/filters/checks/CheckForbiddenMethodAnnotations.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/classfinder/filters/checks/CheckForbiddenMethodAnnotations.kt new file mode 100644 index 0000000..f617271 --- /dev/null +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/classfinder/filters/checks/CheckForbiddenMethodAnnotations.kt @@ -0,0 +1,16 @@ +package dev.alt236.codeplasterage.reflection.classfinder.filters.checks + +import dev.alt236.codeplasterage.ext.AnnotationExt.methodsAreAnnotatedWithAnyOf +import dev.alt236.codeplasterage.ext.NormalisedClassName + +class CheckForbiddenMethodAnnotations : ForbiddenCheck { + override fun isForbidden(clazz: Class<*>): Boolean = clazz.methodsAreAnnotatedWithAnyOf(FORBIDDEN_METHOD_ANNOTATIONS) + + companion object { + private val FORBIDDEN_METHOD_ANNOTATIONS = + setOf( + NormalisedClassName("org.junit.jupiter.api.Test"), + NormalisedClassName(org.junit.Test::class.java), + ) + } +} diff --git a/codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/classfinder/filters/checks/CheckForbiddenName.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/classfinder/filters/checks/CheckForbiddenName.kt new file mode 100644 index 0000000..653727c --- /dev/null +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/classfinder/filters/checks/CheckForbiddenName.kt @@ -0,0 +1,58 @@ +package dev.alt236.codeplasterage.reflection.classfinder.filters.checks + +class CheckForbiddenName : ForbiddenCheck { + override fun isForbidden(clazz: Class<*>): Boolean = + when { + clazz.name.contains("\$\$") -> true + clazz.simpleName.startsWith("_") -> true + EXACT_NAMES.matchesExactly(clazz.simpleName) -> true + REGEX_SIMPLE_NAME.matchesAny(clazz.simpleName) -> true + else -> false + } + + private companion object { + val REGEX_SIMPLE_NAME = + listOf( + Regex(".*_ComponentTreeDeps"), + Regex(".*_GeneratedInjector"), + Regex(".*_HiltComponents"), + Regex(".*_HiltModules"), + Regex(".*_HiltModules_BindsModule"), + Regex(".*_HiltModules_KeyModule"), + Regex(".*_MembersInjector"), + Regex(".*_ProvideFactory"), + Regex(".*_SingletonC"), + Regex(".*_TestComponentDataSupplier"), + Regex("_test_.*"), + Regex("Dagger.*Component"), + Regex("Hilt_.*"), + Regex("Module_.*Factory"), + ) + + val EXACT_NAMES = + listOf( + "BR", + "Builder", // It's tricky to spot builders, so this is a bit naive + "BuildConfig", + "DataBinderMapperImpl", + ) + } + + private fun List.matchesExactly(input: String): Boolean { + for (string in this) { + if (string == input) { + return true + } + } + return false + } + + private fun List.matchesAny(input: String): Boolean { + for (regex in this) { + if (regex.matches(input)) { + return true + } + } + return false + } +} diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/classfinder/filters/checks/ForbiddenCheck.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/classfinder/filters/checks/ForbiddenCheck.kt similarity index 50% rename from codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/classfinder/filters/checks/ForbiddenCheck.kt rename to codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/classfinder/filters/checks/ForbiddenCheck.kt index 6ad1ba9..ff086f9 100644 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/classfinder/filters/checks/ForbiddenCheck.kt +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/classfinder/filters/checks/ForbiddenCheck.kt @@ -1,4 +1,4 @@ -package uk.co.alt236.codeplasterage.reflection.classfinder.filters.checks +package dev.alt236.codeplasterage.reflection.classfinder.filters.checks interface ForbiddenCheck { fun isForbidden(clazz: Class<*>): Boolean diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/instantiation/Instantiator.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/instantiation/Instantiator.kt similarity index 78% rename from codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/instantiation/Instantiator.kt rename to codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/instantiation/Instantiator.kt index fb0a234..6212872 100644 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/instantiation/Instantiator.kt +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/instantiation/Instantiator.kt @@ -1,18 +1,18 @@ -package uk.co.alt236.codeplasterage.reflection.instantiation +package dev.alt236.codeplasterage.reflection.instantiation -import uk.co.alt236.codeplasterage.datafactory.DummyDataFactory -import uk.co.alt236.codeplasterage.log.Log +import dev.alt236.codeplasterage.datafactory.DummyDataFactory +import dev.alt236.codeplasterage.log.Log import java.lang.reflect.Constructor internal class Instantiator( private val dataFactory: DummyDataFactory, - private val debug: Boolean + private val debug: Boolean, ) { private val classFilter = InstantiatorClassFilter() private val kotlinObjectGetter = KotlinObjectGetter(debug) - fun instantiate(clazz: Class): InstantiatorResult { - return when { + fun instantiate(clazz: Class): InstantiatorResult = + when { classFilter.isExcluded(clazz) -> { printDebug("*** EXCLUDING: $clazz") InstantiatorResult.Ignored("Excluded class: $clazz", clazz) @@ -20,7 +20,6 @@ internal class Instantiator( else -> instantiateInternal(clazz) } - } @Suppress("UNCHECKED_CAST") private fun instantiateInternal(clazz: Class): InstantiatorResult { @@ -39,11 +38,12 @@ internal class Instantiator( } for (constr in constructors) { - val instance = if (constr.parameterCount == 0) { - instantiate(constr) - } else { - instantiateWithDummyData(constr) - } + val instance = + if (constr.parameterCount == 0) { + instantiate(constr) + } else { + instantiateWithDummyData(constr) + } if (instance != null) { instances.add(instance as T) @@ -69,14 +69,18 @@ internal class Instantiator( } } - private fun instantiate(constr: Constructor, vararg initArgs: Any?): T? { + private fun instantiate( + constr: Constructor, + vararg initArgs: Any?, + ): T? { return try { printDebug("Using Constructor: $constr") - val instance = if (initArgs.isEmpty()) { - constr.newInstance() - } else { - constr.newInstance(*initArgs) - } + val instance = + if (initArgs.isEmpty()) { + constr.newInstance() + } else { + constr.newInstance(*initArgs) + } printDebug("Instantiation OK!") return instance } catch (e: Throwable) { diff --git a/codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/instantiation/InstantiatorClassFilter.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/instantiation/InstantiatorClassFilter.kt new file mode 100644 index 0000000..17120f7 --- /dev/null +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/instantiation/InstantiatorClassFilter.kt @@ -0,0 +1,23 @@ +package dev.alt236.codeplasterage.reflection.instantiation + +import dev.alt236.codeplasterage.CodeplasterageTestRunner +import dev.alt236.codeplasterage.datafactory.DummyDataFactory +import dev.alt236.codeplasterage.log.Log +import dev.alt236.codeplasterage.reflection.classfinder.ClassFinder +import dev.alt236.codeplasterage.reflection.methodcalling.MethodCaller + +internal class InstantiatorClassFilter { + fun isExcluded(clazz: Class<*>): Boolean = blackList.contains(clazz.name) + + private companion object { + private val blackList = + setOf( + ClassFinder::class.java.name, + Instantiator::class.java.name, + MethodCaller::class.java.name, + Log::class.java.name, + DummyDataFactory::class.java.name, + CodeplasterageTestRunner::class.java.name, + ) + } +} diff --git a/codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/instantiation/InstantiatorResult.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/instantiation/InstantiatorResult.kt new file mode 100644 index 0000000..e985fd6 --- /dev/null +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/instantiation/InstantiatorResult.kt @@ -0,0 +1,18 @@ +package dev.alt236.codeplasterage.reflection.instantiation + +sealed class InstantiatorResult { + data class Success( + val instances: List, + val clazz: Class, + ) : InstantiatorResult() + + data class Error( + val error: Throwable, + val clazz: Class, + ) : InstantiatorResult() + + data class Ignored( + val reason: String, + val clazz: Class, + ) : InstantiatorResult() +} diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/instantiation/KotlinObjectGetter.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/instantiation/KotlinObjectGetter.kt similarity index 87% rename from codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/instantiation/KotlinObjectGetter.kt rename to codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/instantiation/KotlinObjectGetter.kt index e61f91c..3ed8fc3 100644 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/instantiation/KotlinObjectGetter.kt +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/instantiation/KotlinObjectGetter.kt @@ -1,10 +1,11 @@ -package uk.co.alt236.codeplasterage.reflection.instantiation +package dev.alt236.codeplasterage.reflection.instantiation -import uk.co.alt236.codeplasterage.log.Log +import dev.alt236.codeplasterage.log.Log import kotlin.reflect.jvm.internal.KotlinReflectionInternalError -class KotlinObjectGetter(private val debug: Boolean) { - +class KotlinObjectGetter( + private val debug: Boolean, +) { @Suppress("UNCHECKED_CAST") fun getKotlinObject(clazz: Class): InstantiatorResult? { return try { diff --git a/codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/methodcalling/CallResult.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/methodcalling/CallResult.kt new file mode 100644 index 0000000..c91c586 --- /dev/null +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/methodcalling/CallResult.kt @@ -0,0 +1,11 @@ +package dev.alt236.codeplasterage.reflection.methodcalling + +sealed class CallResult { + data class Success( + val result: Any?, + ) : CallResult() + + data class Error( + val error: Throwable, + ) : CallResult() +} diff --git a/codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/methodcalling/CallableMethod.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/methodcalling/CallableMethod.kt new file mode 100644 index 0000000..3972958 --- /dev/null +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/methodcalling/CallableMethod.kt @@ -0,0 +1,18 @@ +package dev.alt236.codeplasterage.reflection.methodcalling + +import java.lang.reflect.Method + +sealed interface CallableMethod { + val clazz: Class + val method: Method + + data class InstanceMethod( + override val clazz: Class, + override val method: Method, + ) : CallableMethod + + data class StaticMethod( + override val clazz: Class, + override val method: Method, + ) : CallableMethod +} diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/methodcalling/MethodCaller.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/methodcalling/MethodCaller.kt similarity index 60% rename from codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/methodcalling/MethodCaller.kt rename to codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/methodcalling/MethodCaller.kt index 4dba802..8292215 100644 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/methodcalling/MethodCaller.kt +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/methodcalling/MethodCaller.kt @@ -1,18 +1,24 @@ -package uk.co.alt236.codeplasterage.reflection.methodcalling +package dev.alt236.codeplasterage.reflection.methodcalling -import uk.co.alt236.codeplasterage.datafactory.DummyDataFactory -import uk.co.alt236.codeplasterage.log.Log +import dev.alt236.codeplasterage.datafactory.DummyDataFactory +import dev.alt236.codeplasterage.log.Log import java.lang.reflect.Method internal class MethodCaller( val dummyDataFactory: DummyDataFactory, - val debug: Boolean + val debug: Boolean, ) { - fun callMethod(callable: CallableMethod.StaticMethod) = callMethodUnsafe(null, callable) - fun callMethod(instance: T, callable: CallableMethod) = callMethodUnsafe(instance, callable) - private fun callMethodUnsafe(instance: T?, callable: CallableMethod): CallResult { + fun callMethod( + instance: T, + callable: CallableMethod, + ) = callMethodUnsafe(instance, callable) + + private fun callMethodUnsafe( + instance: T?, + callable: CallableMethod, + ): CallResult { val method = callable.method printDebug("About to call Method: `$method`. Declared in $callable") return if (method.parameterCount == 0) { @@ -22,7 +28,10 @@ internal class MethodCaller( } } - private fun invokeWithDummyData(instance: T?, method: Method): CallResult { + private fun invokeWithDummyData( + instance: T?, + method: Method, + ): CallResult { val dummyData = dummyDataFactory.getDummyDataToCall(method) return if (dummyData == null) { printDebug("*** FAILED TO GET PARAMS! $method") @@ -33,14 +42,19 @@ internal class MethodCaller( } } - private fun invoke(instance: T?, method: Method, vararg initArgs: Any?): CallResult { + private fun invoke( + instance: T?, + method: Method, + vararg initArgs: Any?, + ): CallResult { return try { printDebug("Calling Method: $method") - val result = if (initArgs.isEmpty()) { - method.invoke(instance) - } else { - method.invoke(instance, *initArgs) - } + val result = + if (initArgs.isEmpty()) { + method.invoke(instance) + } else { + method.invoke(instance, *initArgs) + } printDebug("Method Invocation OK!") return CallResult.Success(result) } catch (e: Throwable) { diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/methodcalling/MethodFinder.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/methodcalling/MethodFinder.kt similarity index 68% rename from codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/methodcalling/MethodFinder.kt rename to codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/methodcalling/MethodFinder.kt index c15a80e..7a99701 100644 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/methodcalling/MethodFinder.kt +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/reflection/methodcalling/MethodFinder.kt @@ -1,28 +1,34 @@ -package uk.co.alt236.codeplasterage.reflection.methodcalling +package dev.alt236.codeplasterage.reflection.methodcalling -import uk.co.alt236.codeplasterage.log.Log +import dev.alt236.codeplasterage.log.Log import java.lang.reflect.Method import java.lang.reflect.Modifier -class MethodFinder(val debug: Boolean) { +class MethodFinder( + val debug: Boolean, +) { fun getCallableMethods(clazz: Class): List> { val methods = clazz.declaredMethods ?: emptyArray() - val filtered = methods.toList() - .filterUnusable() - .map { map(clazz, it) } - .sortedBy { it.method.toString() } + val filtered = + methods + .toList() + .filterUnusable() + .map { map(clazz, it) } + .sortedBy { it.method.toString() } printDebug("Class: $clazz --- Methods: ${filtered.size}/${methods.size}") return filtered } - private fun map(clazz: Class, method: Method): CallableMethod { - return if (Modifier.isStatic(method.modifiers)) { + private fun map( + clazz: Class, + method: Method, + ): CallableMethod = + if (Modifier.isStatic(method.modifiers)) { CallableMethod.StaticMethod(clazz, method) } else { CallableMethod.InstanceMethod(clazz, method) } - } private fun List.filterUnusable(): List { val valid = ArrayList(this.size) diff --git a/codeplasterage/src/main/java/dev/alt236/codeplasterage/testers/common/TestLogger.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/testers/common/TestLogger.kt new file mode 100644 index 0000000..67ec012 --- /dev/null +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/testers/common/TestLogger.kt @@ -0,0 +1,15 @@ +package dev.alt236.codeplasterage.testers.common + +import dev.alt236.codeplasterage.config.TesterConfig +import dev.alt236.codeplasterage.log.Log + +internal class TestLogger( + private val config: TesterConfig, + private val tag: String, +) { + fun log(message: Any) { + if (config.debug) { + Log.log("TESTER-$tag", message) + } + } +} diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/testers/common/TestNotifier.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/testers/common/TestNotifier.kt similarity index 78% rename from codeplasterage/src/main/java/uk/co/alt236/codeplasterage/testers/common/TestNotifier.kt rename to codeplasterage/src/main/java/dev/alt236/codeplasterage/testers/common/TestNotifier.kt index 0c9a133..ff704c1 100644 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/testers/common/TestNotifier.kt +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/testers/common/TestNotifier.kt @@ -1,23 +1,25 @@ -package uk.co.alt236.codeplasterage.testers.common +package dev.alt236.codeplasterage.testers.common +import dev.alt236.codeplasterage.config.TesterConfig +import dev.alt236.codeplasterage.log.Log import org.junit.runner.Description import org.junit.runner.notification.Failure import org.junit.runner.notification.RunNotifier -import uk.co.alt236.codeplasterage.config.TesterConfig -import uk.co.alt236.codeplasterage.log.Log internal class TestNotifier( private val config: TesterConfig, private val logger: TestLogger, - private val notifier: RunNotifier + private val notifier: RunNotifier, ) { - fun fireTestStarted(description: Description) { logger.log("===> Starting test: $description") notifier.fireTestStarted(description) } - fun fireTestFinished(description: Description, result: Throwable?) { + fun fireTestFinished( + description: Description, + result: Throwable?, + ) { if (result == null) { logger.log("=== Test SUCCESS!: $description") notifier.fireTestFinished(description) @@ -27,7 +29,7 @@ internal class TestNotifier( Log.logE( "\n*** There was an exception while executing this test, but errors are ignored! ***\n", - result + result, ) notifier.fireTestFinished(description) } else { diff --git a/codeplasterage/src/main/java/dev/alt236/codeplasterage/testers/common/Tester.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/testers/common/Tester.kt new file mode 100644 index 0000000..9e78de4 --- /dev/null +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/testers/common/Tester.kt @@ -0,0 +1,3 @@ +package dev.alt236.codeplasterage.testers.common + +interface Tester diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/testers/reflection/BaseReflectiveTester.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/testers/reflection/BaseReflectiveTester.kt similarity index 52% rename from codeplasterage/src/main/java/uk/co/alt236/codeplasterage/testers/reflection/BaseReflectiveTester.kt rename to codeplasterage/src/main/java/dev/alt236/codeplasterage/testers/reflection/BaseReflectiveTester.kt index 2e1c920..c962d8a 100644 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/testers/reflection/BaseReflectiveTester.kt +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/testers/reflection/BaseReflectiveTester.kt @@ -1,19 +1,21 @@ -package uk.co.alt236.codeplasterage.testers.reflection +package dev.alt236.codeplasterage.testers.reflection +import dev.alt236.codeplasterage.config.TesterConfig +import dev.alt236.codeplasterage.testers.common.TestLogger +import dev.alt236.codeplasterage.testers.common.TestNotifier +import dev.alt236.codeplasterage.testers.common.Tester import org.junit.runner.notification.RunNotifier -import uk.co.alt236.codeplasterage.config.TesterConfig -import uk.co.alt236.codeplasterage.testers.common.TestLogger -import uk.co.alt236.codeplasterage.testers.common.TestNotifier -import uk.co.alt236.codeplasterage.testers.common.Tester import java.lang.reflect.Method -internal abstract class BaseReflectiveTester(protected val config: TesterConfig) : Tester { +internal abstract class BaseReflectiveTester( + protected val config: TesterConfig, +) : Tester { protected val logger = TestLogger(config, this::class.java.simpleName) fun test( classes: Collection>, notifier: RunNotifier, - method: Method + method: Method, ) { logger.log("####### Starting Tester! #######'") testInternal(classes, TestNotifier(config, logger, notifier), method) @@ -22,7 +24,7 @@ internal abstract class BaseReflectiveTester(protected val config: TesterConfig) protected abstract fun testInternal( classes: Collection>, notifier: TestNotifier, - method: Method + method: Method, ) protected fun getDescriptionText( @@ -30,13 +32,14 @@ internal abstract class BaseReflectiveTester(protected val config: TesterConfig) count: Int, method: Method, currentClass: Class<*>, - additionalData: Any? = null + additionalData: Any? = null, ): String { - val suffix = if (additionalData == null) { - currentClass.name - } else { - "${currentClass.name}$additionalData" - } + val suffix = + if (additionalData == null) { + currentClass.name + } else { + "${currentClass.name}$additionalData" + } return "${method.name} [${index + 1}/$count]: $suffix" } } diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/testers/reflection/EqualsTester.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/testers/reflection/EqualsTester.kt similarity index 76% rename from codeplasterage/src/main/java/uk/co/alt236/codeplasterage/testers/reflection/EqualsTester.kt rename to codeplasterage/src/main/java/dev/alt236/codeplasterage/testers/reflection/EqualsTester.kt index 2bc5e3f..30c1944 100644 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/testers/reflection/EqualsTester.kt +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/testers/reflection/EqualsTester.kt @@ -1,22 +1,21 @@ -package uk.co.alt236.codeplasterage.testers.reflection +package dev.alt236.codeplasterage.testers.reflection +import dev.alt236.codeplasterage.config.TesterConfig +import dev.alt236.codeplasterage.reflection.instantiation.Instantiator +import dev.alt236.codeplasterage.reflection.instantiation.InstantiatorResult +import dev.alt236.codeplasterage.testers.common.TestNotifier import org.junit.runner.Description -import uk.co.alt236.codeplasterage.config.TesterConfig -import uk.co.alt236.codeplasterage.reflection.instantiation.Instantiator -import uk.co.alt236.codeplasterage.reflection.instantiation.InstantiatorResult -import uk.co.alt236.codeplasterage.testers.common.TestNotifier import java.lang.reflect.Method internal class EqualsTester( config: TesterConfig, private val testClass: Class, - private val instantiator: Instantiator + private val instantiator: Instantiator, ) : BaseReflectiveTester(config) { - override fun testInternal( classes: Collection>, notifier: TestNotifier, - method: Method + method: Method, ) { val validClasses = classes.filter { it.constructors.isNotEmpty() } logger.log("Will run on ${validClasses.size}/${classes.size} classes") @@ -31,7 +30,10 @@ internal class EqualsTester( } } - private fun test(instantiator: Instantiator, clazz: Class<*>): Throwable? { + private fun test( + instantiator: Instantiator, + clazz: Class<*>, + ): Throwable? { return when (val result = instantiator.instantiate(clazz)) { is InstantiatorResult.Error -> return result.error is InstantiatorResult.Ignored -> return null diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/testers/reflection/HashCodeTester.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/testers/reflection/HashCodeTester.kt similarity index 74% rename from codeplasterage/src/main/java/uk/co/alt236/codeplasterage/testers/reflection/HashCodeTester.kt rename to codeplasterage/src/main/java/dev/alt236/codeplasterage/testers/reflection/HashCodeTester.kt index 4bf7b5a..410911d 100644 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/testers/reflection/HashCodeTester.kt +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/testers/reflection/HashCodeTester.kt @@ -1,22 +1,21 @@ -package uk.co.alt236.codeplasterage.testers.reflection +package dev.alt236.codeplasterage.testers.reflection +import dev.alt236.codeplasterage.config.TesterConfig +import dev.alt236.codeplasterage.reflection.instantiation.Instantiator +import dev.alt236.codeplasterage.reflection.instantiation.InstantiatorResult +import dev.alt236.codeplasterage.testers.common.TestNotifier import org.junit.runner.Description -import uk.co.alt236.codeplasterage.config.TesterConfig -import uk.co.alt236.codeplasterage.reflection.instantiation.Instantiator -import uk.co.alt236.codeplasterage.reflection.instantiation.InstantiatorResult -import uk.co.alt236.codeplasterage.testers.common.TestNotifier import java.lang.reflect.Method internal class HashCodeTester( config: TesterConfig, private val testClass: Class, - private val instantiator: Instantiator + private val instantiator: Instantiator, ) : BaseReflectiveTester(config) { - override fun testInternal( classes: Collection>, notifier: TestNotifier, - method: Method + method: Method, ) { val validClasses = classes.filter { it.constructors.isNotEmpty() } logger.log("Will run on ${validClasses.size}/${classes.size} classes") @@ -31,7 +30,10 @@ internal class HashCodeTester( } } - private fun test(instantiator: Instantiator, clazz: Class<*>): Throwable? { + private fun test( + instantiator: Instantiator, + clazz: Class<*>, + ): Throwable? { return when (val result = instantiator.instantiate(clazz)) { is InstantiatorResult.Error -> return result.error is InstantiatorResult.Ignored -> return null diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/testers/reflection/MethodCallingTester.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/testers/reflection/MethodCallingTester.kt similarity index 66% rename from codeplasterage/src/main/java/uk/co/alt236/codeplasterage/testers/reflection/MethodCallingTester.kt rename to codeplasterage/src/main/java/dev/alt236/codeplasterage/testers/reflection/MethodCallingTester.kt index aa432a2..4f82fca 100644 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/testers/reflection/MethodCallingTester.kt +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/testers/reflection/MethodCallingTester.kt @@ -1,28 +1,27 @@ -package uk.co.alt236.codeplasterage.testers.reflection +package dev.alt236.codeplasterage.testers.reflection +import dev.alt236.codeplasterage.config.TesterConfig +import dev.alt236.codeplasterage.datafactory.DummyDataFactory +import dev.alt236.codeplasterage.reflection.instantiation.Instantiator +import dev.alt236.codeplasterage.reflection.instantiation.InstantiatorResult +import dev.alt236.codeplasterage.reflection.methodcalling.CallResult +import dev.alt236.codeplasterage.reflection.methodcalling.CallableMethod +import dev.alt236.codeplasterage.reflection.methodcalling.MethodCaller +import dev.alt236.codeplasterage.reflection.methodcalling.MethodFinder +import dev.alt236.codeplasterage.testers.common.TestNotifier import org.junit.runner.Description -import uk.co.alt236.codeplasterage.config.TesterConfig -import uk.co.alt236.codeplasterage.datafactory.DummyDataFactory -import uk.co.alt236.codeplasterage.reflection.instantiation.Instantiator -import uk.co.alt236.codeplasterage.reflection.instantiation.InstantiatorResult -import uk.co.alt236.codeplasterage.reflection.methodcalling.CallResult -import uk.co.alt236.codeplasterage.reflection.methodcalling.CallableMethod -import uk.co.alt236.codeplasterage.reflection.methodcalling.MethodCaller -import uk.co.alt236.codeplasterage.reflection.methodcalling.MethodFinder -import uk.co.alt236.codeplasterage.testers.common.TestNotifier import java.lang.reflect.Method internal class MethodCallingTester( config: TesterConfig, private val testClass: Class, private val dummyDataFactory: DummyDataFactory, - private val instantiator: Instantiator + private val instantiator: Instantiator, ) : BaseReflectiveTester(config) { - override fun testInternal( classes: Collection>, notifier: TestNotifier, - method: Method + method: Method, ) { val methodCaller = MethodCaller(dummyDataFactory, config.debug) val methodFinder = MethodFinder(config.debug) @@ -55,21 +54,22 @@ internal class MethodCallingTester( private fun test( instantiator: Instantiator, methodCaller: MethodCaller, - callableMethod: CallableMethod + callableMethod: CallableMethod, ): Throwable? { return when (callableMethod) { is CallableMethod.StaticMethod -> testStaticMethod(methodCaller, callableMethod) - is CallableMethod.InstanceMethod -> when (val result = instantiator.instantiate(callableMethod.clazz)) { - is InstantiatorResult.Error -> return result.error - is InstantiatorResult.Ignored -> return null - is InstantiatorResult.Success -> testInstanceMethod(methodCaller, result.instances, callableMethod) - } + is CallableMethod.InstanceMethod -> + when (val result = instantiator.instantiate(callableMethod.clazz)) { + is InstantiatorResult.Error -> return result.error + is InstantiatorResult.Ignored -> return null + is InstantiatorResult.Success -> testInstanceMethod(methodCaller, result.instances, callableMethod) + } } } private fun testStaticMethod( methodCaller: MethodCaller, - callableMethod: CallableMethod.StaticMethod + callableMethod: CallableMethod.StaticMethod, ): Throwable? { val result = methodCaller.callMethod(callableMethod) return if (result is CallResult.Error) { @@ -82,7 +82,7 @@ internal class MethodCallingTester( private fun testInstanceMethod( methodCaller: MethodCaller, instances: List, - callableMethod: CallableMethod.InstanceMethod + callableMethod: CallableMethod.InstanceMethod, ): Throwable? { for (instance in instances) { try { diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/testers/reflection/ToStringTester.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/testers/reflection/ToStringTester.kt similarity index 74% rename from codeplasterage/src/main/java/uk/co/alt236/codeplasterage/testers/reflection/ToStringTester.kt rename to codeplasterage/src/main/java/dev/alt236/codeplasterage/testers/reflection/ToStringTester.kt index f5c6460..404baf8 100644 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/testers/reflection/ToStringTester.kt +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/testers/reflection/ToStringTester.kt @@ -1,22 +1,21 @@ -package uk.co.alt236.codeplasterage.testers.reflection +package dev.alt236.codeplasterage.testers.reflection +import dev.alt236.codeplasterage.config.TesterConfig +import dev.alt236.codeplasterage.reflection.instantiation.Instantiator +import dev.alt236.codeplasterage.reflection.instantiation.InstantiatorResult +import dev.alt236.codeplasterage.testers.common.TestNotifier import org.junit.runner.Description -import uk.co.alt236.codeplasterage.config.TesterConfig -import uk.co.alt236.codeplasterage.reflection.instantiation.Instantiator -import uk.co.alt236.codeplasterage.reflection.instantiation.InstantiatorResult -import uk.co.alt236.codeplasterage.testers.common.TestNotifier import java.lang.reflect.Method internal class ToStringTester( config: TesterConfig, private val testClass: Class, - private val instantiator: Instantiator + private val instantiator: Instantiator, ) : BaseReflectiveTester(config) { - override fun testInternal( classes: Collection>, notifier: TestNotifier, - method: Method + method: Method, ) { val validClasses = classes.filter { it.constructors.isNotEmpty() } logger.log("Will run on ${validClasses.size}/${classes.size} classes") @@ -31,7 +30,10 @@ internal class ToStringTester( } } - private fun test(instantiator: Instantiator, clazz: Class<*>): Throwable? { + private fun test( + instantiator: Instantiator, + clazz: Class<*>, + ): Throwable? { return when (val result = instantiator.instantiate(clazz)) { is InstantiatorResult.Error -> return result.error is InstantiatorResult.Ignored -> return null diff --git a/codeplasterage/src/main/java/dev/alt236/codeplasterage/testers/standard/SimpleTester.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/testers/standard/SimpleTester.kt new file mode 100644 index 0000000..4988415 --- /dev/null +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/testers/standard/SimpleTester.kt @@ -0,0 +1,7 @@ +@file:Suppress("unused") + +package dev.alt236.codeplasterage.testers.standard + +import dev.alt236.codeplasterage.testers.common.Tester + +class SimpleTester : Tester diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/tests/PlasterageTestEquals.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/tests/PlasterageTestEquals.kt similarity index 57% rename from codeplasterage/src/main/java/uk/co/alt236/codeplasterage/tests/PlasterageTestEquals.kt rename to codeplasterage/src/main/java/dev/alt236/codeplasterage/tests/PlasterageTestEquals.kt index 8ab9aa6..881bde3 100644 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/tests/PlasterageTestEquals.kt +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/tests/PlasterageTestEquals.kt @@ -1,4 +1,4 @@ -package uk.co.alt236.codeplasterage.tests +package dev.alt236.codeplasterage.tests interface PlasterageTestEquals { fun testEquals() diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/tests/PlasterageTestHashCode.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/tests/PlasterageTestHashCode.kt similarity index 59% rename from codeplasterage/src/main/java/uk/co/alt236/codeplasterage/tests/PlasterageTestHashCode.kt rename to codeplasterage/src/main/java/dev/alt236/codeplasterage/tests/PlasterageTestHashCode.kt index 2b2c6e3..3bf1ed0 100644 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/tests/PlasterageTestHashCode.kt +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/tests/PlasterageTestHashCode.kt @@ -1,4 +1,4 @@ -package uk.co.alt236.codeplasterage.tests +package dev.alt236.codeplasterage.tests interface PlasterageTestHashCode { fun testHashCode() diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/tests/PlasterageTestMethodCalling.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/tests/PlasterageTestMethodCalling.kt similarity index 62% rename from codeplasterage/src/main/java/uk/co/alt236/codeplasterage/tests/PlasterageTestMethodCalling.kt rename to codeplasterage/src/main/java/dev/alt236/codeplasterage/tests/PlasterageTestMethodCalling.kt index 84f3445..a810141 100644 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/tests/PlasterageTestMethodCalling.kt +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/tests/PlasterageTestMethodCalling.kt @@ -1,4 +1,4 @@ -package uk.co.alt236.codeplasterage.tests +package dev.alt236.codeplasterage.tests interface PlasterageTestMethodCalling { fun testMethodCalling() diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/tests/PlasterageTestToString.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/tests/PlasterageTestToString.kt similarity index 59% rename from codeplasterage/src/main/java/uk/co/alt236/codeplasterage/tests/PlasterageTestToString.kt rename to codeplasterage/src/main/java/dev/alt236/codeplasterage/tests/PlasterageTestToString.kt index 82a3326..2155f8b 100644 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/tests/PlasterageTestToString.kt +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/tests/PlasterageTestToString.kt @@ -1,4 +1,4 @@ -package uk.co.alt236.codeplasterage.tests +package dev.alt236.codeplasterage.tests interface PlasterageTestToString { fun testToString() diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/tests/PlasterageTests.kt b/codeplasterage/src/main/java/dev/alt236/codeplasterage/tests/PlasterageTests.kt similarity index 80% rename from codeplasterage/src/main/java/uk/co/alt236/codeplasterage/tests/PlasterageTests.kt rename to codeplasterage/src/main/java/dev/alt236/codeplasterage/tests/PlasterageTests.kt index 97f46ed..d4e2b83 100644 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/tests/PlasterageTests.kt +++ b/codeplasterage/src/main/java/dev/alt236/codeplasterage/tests/PlasterageTests.kt @@ -1,6 +1,6 @@ @file:Suppress("unused") -package uk.co.alt236.codeplasterage.tests +package dev.alt236.codeplasterage.tests interface PlasterageTests : PlasterageTestEquals, diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/config/ConfigFactory.kt b/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/config/ConfigFactory.kt deleted file mode 100644 index c7b88f9..0000000 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/config/ConfigFactory.kt +++ /dev/null @@ -1,97 +0,0 @@ -package uk.co.alt236.codeplasterage.config - -import java.lang.reflect.Method -import kotlin.reflect.KClass - -internal class ConfigFactory { - - fun getConfig(testClass: Class<*>): TesterConfig { - val classAnnotation = testClass.getDeclaredAnnotation(Config::class.java) - return compileConfig(null, classAnnotation) - } - - fun compileConfig(testClass: Class<*>, testMethod: Method): TesterConfig { - val classAnnotation = testClass.getDeclaredAnnotation(Config::class.java) - val methodAnnotation = testMethod.getDeclaredAnnotation(Config::class.java) - - return compileConfig(methodAnnotation, classAnnotation) - } - - private fun compileConfig(methodAnnotation: Config?, classAnnotation: Config?): TesterConfig { - return TesterConfig( - ignoreErrors = getIgnoreErrors(methodAnnotation, classAnnotation), - debug = getDebug(methodAnnotation, classAnnotation), - includeClassNamePatterns = getPrioritizedSet( - methodAnnotation?.includeClassNamePatterns, - classAnnotation?.includeClassNamePatterns, - DefaultConfigValues.DEFAULT_INCLUDE_CLASS_NAME_PATTERNS - ), - excludeClassNamePatterns = getPrioritizedSet( - methodAnnotation?.excludeClassNamePatterns, - classAnnotation?.excludeClassNamePatterns, - DefaultConfigValues.DEFAULT_EXCLUDE_CLASS_NAME_PATTERNS - ), - forceIncludeClassNames = getPrioritizedSet( - methodAnnotation?.forceIncludeClassNames, - classAnnotation?.forceIncludeClassNames, - DefaultConfigValues.DEFAULT_FORCE_INCLUDE_CLASS_NAMES - ), - forceExcludeClassNames = getPrioritizedSet( - methodAnnotation?.forceExcludeClassNames, - classAnnotation?.forceExcludeClassNames, - DefaultConfigValues.DEFAULT_FORCE_EXCLUDE_CLASS_NAMES - ), - customDummyDataFactories = getPrioritizedList( - methodAnnotation?.customDummyDataFactories, - classAnnotation?.customDummyDataFactories, - emptyArray() - ) - ) - } - - private fun getPrioritizedList( - methodArray: Array>?, - classArray: Array>?, - fallback: Array> - ): List> { - return when { - methodArray != null -> methodArray - classArray != null -> classArray - else -> fallback - }.toList() - } - - private fun getPrioritizedSet( - methodArray: Array?, - classArray: Array?, - fallback: Array - ): Set { - return when { - methodArray != null -> methodArray - classArray != null -> classArray - else -> fallback - }.toSet() - } - - private fun getIgnoreErrors( - methodAnnotation: Config?, - classAnnotation: Config? - ): Boolean { - return when { - methodAnnotation != null -> methodAnnotation.ignoreErrors - classAnnotation != null -> classAnnotation.ignoreErrors - else -> DefaultConfigValues.IGNORE_ERRORS - } - } - - private fun getDebug( - methodAnnotation: Config?, - classAnnotation: Config? - ): Boolean { - return when { - methodAnnotation != null -> methodAnnotation.debug - classAnnotation != null -> classAnnotation.debug - else -> DefaultConfigValues.DEBUG - } - } -} diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/datafactory/DataFactoryResult.kt b/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/datafactory/DataFactoryResult.kt deleted file mode 100644 index d8472a9..0000000 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/datafactory/DataFactoryResult.kt +++ /dev/null @@ -1,12 +0,0 @@ -package uk.co.alt236.codeplasterage.datafactory - -sealed class DataFactoryResult { - data class Valid(val value: T?, val inputClass: Class) : DataFactoryResult() - data class Error(val t: Throwable, val clazz: Class) : DataFactoryResult() - companion object { - fun createUnableToCreateInstanceError(factory: SubDataFactory, clazz: Class): Error { - val message = "${factory::class.java.simpleName}: Don't know how to produce dummy data for: '$clazz'" - return Error(IllegalStateException(message), clazz) - } - } -} diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/datafactory/factories/ArrayFactory.kt b/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/datafactory/factories/ArrayFactory.kt deleted file mode 100644 index 97ebcaf..0000000 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/datafactory/factories/ArrayFactory.kt +++ /dev/null @@ -1,15 +0,0 @@ -package uk.co.alt236.codeplasterage.datafactory.factories - -import uk.co.alt236.codeplasterage.datafactory.DataFactoryResult -import uk.co.alt236.codeplasterage.datafactory.DataFactoryResult.Valid -import uk.co.alt236.codeplasterage.datafactory.SubDataFactory -import java.lang.reflect.Array - -class ArrayFactory(debug: Boolean) : SubDataFactory(debug) { - override fun canCreateDataFor(clazz: Class<*>) = clazz.isArray - - override fun getDummyData(clazz: Class<*>): DataFactoryResult<*> { - val array = Array.newInstance(clazz.componentType, 0) - return Valid(array, clazz) - } -} diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/log/Log.kt b/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/log/Log.kt deleted file mode 100644 index f335e74..0000000 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/log/Log.kt +++ /dev/null @@ -1,66 +0,0 @@ -package uk.co.alt236.codeplasterage.log - -import com.google.common.reflect.ClassPath.ClassInfo -import java.lang.reflect.Executable -import kotlin.reflect.KClass - -@Suppress("unused") -internal object Log { - private const val LABEL_EXCEPTION = "Exception: " - private const val LABEL_CAUSE = " cause: " - private const val LABEL_ON = " on: " - private const val LABEL_WHEN = " while: " - - fun log(where: String, what: Any) { - println("[$where] $what") - } - - fun logE(throwable: Throwable, executable: Executable, context: String? = null) { - logError(throwable, executable.toString(), context) - } - - fun logE(throwable: Throwable, clazz: KClass<*>, context: String? = null) { - logError(throwable, clazz.toString(), context) - } - - fun logE(throwable: Throwable, clazz: Class<*>, context: String? = null) { - logError(throwable, clazz.toString(), context) - } - - fun logE(throwable: Throwable, classInfo: ClassInfo, context: String? = null) { - logError(throwable, classInfo.toString(), context) - } - - fun logE(message: String, throwable: Throwable) { - logE(message) - throwable.printStackTrace() - } - - fun logE(message: String) { - System.err.println(message) - } - - private fun logError(throwable: Throwable, onWhat: String, context: String?) { - val message = buildString { - append(LABEL_EXCEPTION) - append("${throwable::class.java.simpleName}(${throwable.message ?: ""})") - if (throwable.cause != null) { - append("\n") - append(LABEL_CAUSE) - append(throwable.cause) - } - - append("\n") - append(LABEL_ON) - append(onWhat) - - if (!context.isNullOrEmpty()) { - append("\n") - append(LABEL_WHEN) - append(context) - } - } - - logE(message) - } -} diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/classfinder/ClassFilterResult.kt b/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/classfinder/ClassFilterResult.kt deleted file mode 100644 index 67e2f9c..0000000 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/classfinder/ClassFilterResult.kt +++ /dev/null @@ -1,28 +0,0 @@ -package uk.co.alt236.codeplasterage.reflection.classfinder - -sealed interface ClassFilterResult { - object Include : ClassFilterResult - - sealed interface Exclude : ClassFilterResult { - fun getReason(): String = this::class.java.simpleName - - object IsPrivate : Exclude - object IsAbstract : Exclude - object IsProxy : Exclude - object IsInterface : Exclude - object IsAnnotation : Exclude - object IsSynthetic : Exclude - object CannotLoadMethods : Exclude - object ForbiddenClassAncestry : Exclude - object ForbiddenClassAnnotation : Exclude - object ForbiddenClassName : Exclude - object ForbiddenMethodAnnotation : Exclude - object PartOfLibraryPackage : Exclude - - data class Custom(private val reason: String) : Exclude { - override fun getReason(): String { - return reason - } - } - } -} diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/classfinder/filters/checks/CheckForbiddenAncestry.kt b/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/classfinder/filters/checks/CheckForbiddenAncestry.kt deleted file mode 100644 index 5c1fcac..0000000 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/classfinder/filters/checks/CheckForbiddenAncestry.kt +++ /dev/null @@ -1,22 +0,0 @@ -package uk.co.alt236.codeplasterage.reflection.classfinder.filters.checks - -import uk.co.alt236.codeplasterage.ext.ClassExt.isAssignableToAnyOf -import uk.co.alt236.codeplasterage.ext.NormalisedClassName - -class CheckForbiddenAncestry : ForbiddenCheck { - - override fun isForbidden(clazz: Class<*>): Boolean { - return clazz.isAssignableToAnyOf(FORBIDDEN_SUPERCLASSES_AND_INTERFACES) - } - - companion object { - private val FORBIDDEN_SUPERCLASSES_AND_INTERFACES = setOf( - NormalisedClassName("dagger.internal.Factory"), - NormalisedClassName("dagger.MembersInjector"), - NormalisedClassName("org.greenrobot.greendao.AbstractDao"), - NormalisedClassName("dagger.hilt.android.internal.testing.EarlySingletonComponentCreator"), - NormalisedClassName("dagger.hilt.android.internal.testing.TestComponentDataSupplier"), - NormalisedClassName(kotlin.jvm.internal.Lambda::class.java) - ) - } -} diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/classfinder/filters/checks/CheckForbiddenClassAnnotations.kt b/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/classfinder/filters/checks/CheckForbiddenClassAnnotations.kt deleted file mode 100644 index c7af7a0..0000000 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/classfinder/filters/checks/CheckForbiddenClassAnnotations.kt +++ /dev/null @@ -1,30 +0,0 @@ -package uk.co.alt236.codeplasterage.reflection.classfinder.filters.checks - -import org.junit.runner.RunWith -import uk.co.alt236.codeplasterage.ext.AnnotationExt.isAnnotatedWithAnyOf -import uk.co.alt236.codeplasterage.ext.NormalisedClassName - -class CheckForbiddenClassAnnotations : ForbiddenCheck { - - override fun isForbidden(clazz: Class<*>): Boolean { - return clazz.isAnnotatedWithAnyOf(FORBIDDEN_CLASS_ANNOTATIONS) - } - - private companion object { - private val FORBIDDEN_CLASS_ANNOTATIONS = setOf( - NormalisedClassName("dagger.hilt.android.EarlyEntryPoint"), - NormalisedClassName("dagger.hilt.codegen.OriginatingElement"), - NormalisedClassName("dagger.hilt.InstallIn"), - NormalisedClassName("dagger.hilt.internal.aggregatedroot.AggregatedRoot"), - NormalisedClassName("dagger.hilt.internal.GeneratedEntryPoint"), - NormalisedClassName("dagger.hilt.internal.processedrootsentinel.ProcessedRootSentinel"), - NormalisedClassName("dagger.hilt.processor.internal.aggregateddeps.AggregatedDeps"), - NormalisedClassName("dagger.internal.DaggerGenerated"), - NormalisedClassName("dagger.internal.QualifierMetadata"), - NormalisedClassName("dagger.internal.ScopeMetadata"), - NormalisedClassName("dagger.Module"), - NormalisedClassName("javax.annotation.Generated"), - NormalisedClassName(RunWith::class.java) - ) - } -} diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/classfinder/filters/checks/CheckForbiddenMethodAnnotations.kt b/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/classfinder/filters/checks/CheckForbiddenMethodAnnotations.kt deleted file mode 100644 index 02a47f3..0000000 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/classfinder/filters/checks/CheckForbiddenMethodAnnotations.kt +++ /dev/null @@ -1,18 +0,0 @@ -package uk.co.alt236.codeplasterage.reflection.classfinder.filters.checks - -import uk.co.alt236.codeplasterage.ext.AnnotationExt.methodsAreAnnotatedWithAnyOf -import uk.co.alt236.codeplasterage.ext.NormalisedClassName - -class CheckForbiddenMethodAnnotations : ForbiddenCheck { - - override fun isForbidden(clazz: Class<*>): Boolean { - return clazz.methodsAreAnnotatedWithAnyOf(FORBIDDEN_METHOD_ANNOTATIONS) - } - - companion object { - private val FORBIDDEN_METHOD_ANNOTATIONS = setOf( - NormalisedClassName("org.junit.jupiter.api.Test"), - NormalisedClassName(org.junit.Test::class.java) - ) - } -} diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/classfinder/filters/checks/CheckForbiddenName.kt b/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/classfinder/filters/checks/CheckForbiddenName.kt deleted file mode 100644 index 333674b..0000000 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/classfinder/filters/checks/CheckForbiddenName.kt +++ /dev/null @@ -1,59 +0,0 @@ -package uk.co.alt236.codeplasterage.reflection.classfinder.filters.checks - -class CheckForbiddenName : ForbiddenCheck { - - override fun isForbidden(clazz: Class<*>): Boolean { - return when { - clazz.name.contains("\$\$") -> true - clazz.simpleName.startsWith("_") -> true - EXACT_NAMES.matchesExactly(clazz.simpleName) -> true - REGEX_SIMPLE_NAME.matchesAny(clazz.simpleName) -> true - else -> false - } - } - - private companion object { - val REGEX_SIMPLE_NAME = listOf( - Regex(".*_ComponentTreeDeps"), - Regex(".*_GeneratedInjector"), - Regex(".*_HiltComponents"), - Regex(".*_HiltModules"), - Regex(".*_HiltModules_BindsModule"), - Regex(".*_HiltModules_KeyModule"), - Regex(".*_MembersInjector"), - Regex(".*_ProvideFactory"), - Regex(".*_SingletonC"), - Regex(".*_SingletonC"), - Regex(".*_TestComponentDataSupplier"), - Regex("_test_.*"), - Regex("Dagger.*Component"), - Regex("Hilt_.*"), - Regex("Module_.*Factory") - ) - - val EXACT_NAMES = listOf( - "BR", - "Builder", // It's tricky to spot builders, so this is a bit naive - "BuildConfig", - "DataBinderMapperImpl" - ) - } - - private fun List.matchesExactly(input: String): Boolean { - for (string in this) { - if (string == input) { - return true - } - } - return false - } - - private fun List.matchesAny(input: String): Boolean { - for (regex in this) { - if (regex.matches(input)) { - return true - } - } - return false - } -} diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/instantiation/InstantiatorClassFilter.kt b/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/instantiation/InstantiatorClassFilter.kt deleted file mode 100644 index ebf9ddc..0000000 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/instantiation/InstantiatorClassFilter.kt +++ /dev/null @@ -1,25 +0,0 @@ -package uk.co.alt236.codeplasterage.reflection.instantiation - -import uk.co.alt236.codeplasterage.CodeplasterageTestRunner -import uk.co.alt236.codeplasterage.datafactory.DummyDataFactory -import uk.co.alt236.codeplasterage.log.Log -import uk.co.alt236.codeplasterage.reflection.classfinder.ClassFinder -import uk.co.alt236.codeplasterage.reflection.methodcalling.MethodCaller - -internal class InstantiatorClassFilter { - - fun isExcluded(clazz: Class<*>): Boolean { - return blackList.contains(clazz.name) - } - - private companion object { - private val blackList = setOf( - ClassFinder::class.java.name, - Instantiator::class.java.name, - MethodCaller::class.java.name, - Log::class.java.name, - DummyDataFactory::class.java.name, - CodeplasterageTestRunner::class.java.name - ) - } -} diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/instantiation/InstantiatorResult.kt b/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/instantiation/InstantiatorResult.kt deleted file mode 100644 index e8947e8..0000000 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/instantiation/InstantiatorResult.kt +++ /dev/null @@ -1,7 +0,0 @@ -package uk.co.alt236.codeplasterage.reflection.instantiation - -sealed class InstantiatorResult { - data class Success(val instances: List, val clazz: Class) : InstantiatorResult() - data class Error(val error: Throwable, val clazz: Class) : InstantiatorResult() - data class Ignored(val reason: String, val clazz: Class) : InstantiatorResult() -} diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/methodcalling/CallResult.kt b/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/methodcalling/CallResult.kt deleted file mode 100644 index ac3f214..0000000 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/methodcalling/CallResult.kt +++ /dev/null @@ -1,6 +0,0 @@ -package uk.co.alt236.codeplasterage.reflection.methodcalling - -sealed class CallResult { - data class Success(val result: Any?) : CallResult() - data class Error(val error: Throwable) : CallResult() -} diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/methodcalling/CallableMethod.kt b/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/methodcalling/CallableMethod.kt deleted file mode 100644 index 6c7c1ae..0000000 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/reflection/methodcalling/CallableMethod.kt +++ /dev/null @@ -1,11 +0,0 @@ -package uk.co.alt236.codeplasterage.reflection.methodcalling - -import java.lang.reflect.Method - -sealed interface CallableMethod { - val clazz: Class - val method: Method - - data class InstanceMethod(override val clazz: Class, override val method: Method) : CallableMethod - data class StaticMethod(override val clazz: Class, override val method: Method) : CallableMethod -} diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/testers/common/TestLogger.kt b/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/testers/common/TestLogger.kt deleted file mode 100644 index bc3e053..0000000 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/testers/common/TestLogger.kt +++ /dev/null @@ -1,13 +0,0 @@ -package uk.co.alt236.codeplasterage.testers.common - -import uk.co.alt236.codeplasterage.config.TesterConfig -import uk.co.alt236.codeplasterage.log.Log - -internal class TestLogger(private val config: TesterConfig, private val tag: String) { - - fun log(message: Any) { - if (config.debug) { - Log.log("TESTER-$tag", message) - } - } -} diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/testers/common/Tester.kt b/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/testers/common/Tester.kt deleted file mode 100644 index 4f09cff..0000000 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/testers/common/Tester.kt +++ /dev/null @@ -1,3 +0,0 @@ -package uk.co.alt236.codeplasterage.testers.common - -interface Tester diff --git a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/testers/standard/SimpleTester.kt b/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/testers/standard/SimpleTester.kt deleted file mode 100644 index 2b2a1bf..0000000 --- a/codeplasterage/src/main/java/uk/co/alt236/codeplasterage/testers/standard/SimpleTester.kt +++ /dev/null @@ -1,7 +0,0 @@ -@file:Suppress("unused") - -package uk.co.alt236.codeplasterage.testers.standard - -import uk.co.alt236.codeplasterage.testers.common.Tester - -class SimpleTester : Tester diff --git a/codeplasterage/src/test/java/uk/co/alt236/codeplasterage/datafactory/CustomDataFactoryFactoryTest.kt b/codeplasterage/src/test/java/dev/alt236/codeplasterage/datafactory/CustomDataFactoryFactoryTest.kt similarity index 75% rename from codeplasterage/src/test/java/uk/co/alt236/codeplasterage/datafactory/CustomDataFactoryFactoryTest.kt rename to codeplasterage/src/test/java/dev/alt236/codeplasterage/datafactory/CustomDataFactoryFactoryTest.kt index f69d0d1..9f9dd6f 100644 --- a/codeplasterage/src/test/java/uk/co/alt236/codeplasterage/datafactory/CustomDataFactoryFactoryTest.kt +++ b/codeplasterage/src/test/java/dev/alt236/codeplasterage/datafactory/CustomDataFactoryFactoryTest.kt @@ -1,4 +1,4 @@ -package uk.co.alt236.codeplasterage.datafactory +package dev.alt236.codeplasterage.datafactory import org.junit.jupiter.api.Assertions.assertEquals import org.junit.jupiter.api.Assertions.assertInstanceOf @@ -7,7 +7,6 @@ import org.junit.jupiter.api.Test import org.junit.jupiter.api.assertThrows internal class CustomDataFactoryFactoryTest { - private lateinit var sut: CustomDataFactoryFactory @BeforeEach @@ -42,49 +41,37 @@ internal class CustomDataFactoryFactoryTest { } @Suppress("unused") - private class FactoryWithCorrectConstructor(val boolean: Boolean) : SubDataFactory(true) { - override fun canCreateDataFor(clazz: Class<*>): Boolean { - return true - } + private class FactoryWithCorrectConstructor( + val boolean: Boolean, + ) : SubDataFactory(true) { + override fun canCreateDataFor(clazz: Class<*>): Boolean = true - override fun getDummyData(clazz: Class<*>): DataFactoryResult<*> { - return DataFactoryResult.Error(IllegalStateException(), clazz) - } + override fun getDummyData(clazz: Class<*>): DataFactoryResult<*> = DataFactoryResult.Error(IllegalStateException(), clazz) } @Suppress("ClassName") private class FactoryWithWrongConstructor_Empty : SubDataFactory(true) { - override fun canCreateDataFor(clazz: Class<*>): Boolean { - return true - } + override fun canCreateDataFor(clazz: Class<*>): Boolean = true - override fun getDummyData(clazz: Class<*>): DataFactoryResult<*> { - return DataFactoryResult.Error(IllegalStateException(), clazz) - } + override fun getDummyData(clazz: Class<*>): DataFactoryResult<*> = DataFactoryResult.Error(IllegalStateException(), clazz) } @Suppress("ClassName", "unused") - private class FactoryWithWrongConstructor_NonBoolean(private val foo: String) : SubDataFactory(true) { - override fun canCreateDataFor(clazz: Class<*>): Boolean { - return true - } + private class FactoryWithWrongConstructor_NonBoolean( + private val foo: String, + ) : SubDataFactory(true) { + override fun canCreateDataFor(clazz: Class<*>): Boolean = true - override fun getDummyData(clazz: Class<*>): DataFactoryResult<*> { - return DataFactoryResult.Error(IllegalStateException(), clazz) - } + override fun getDummyData(clazz: Class<*>): DataFactoryResult<*> = DataFactoryResult.Error(IllegalStateException(), clazz) } @Suppress("ClassName", "unused") private class FactoryWithWrongConstructor_MultipleParams( boolean: Boolean, - private val foo: String + private val foo: String, ) : SubDataFactory(boolean) { - override fun canCreateDataFor(clazz: Class<*>): Boolean { - return true - } + override fun canCreateDataFor(clazz: Class<*>): Boolean = true - override fun getDummyData(clazz: Class<*>): DataFactoryResult<*> { - return DataFactoryResult.Error(IllegalStateException(), clazz) - } + override fun getDummyData(clazz: Class<*>): DataFactoryResult<*> = DataFactoryResult.Error(IllegalStateException(), clazz) } } diff --git a/codeplasterage/src/test/java/uk/co/alt236/codeplasterage/datafactory/CustomDataFactoryTest.kt b/codeplasterage/src/test/java/dev/alt236/codeplasterage/datafactory/CustomDataFactoryTest.kt similarity index 83% rename from codeplasterage/src/test/java/uk/co/alt236/codeplasterage/datafactory/CustomDataFactoryTest.kt rename to codeplasterage/src/test/java/dev/alt236/codeplasterage/datafactory/CustomDataFactoryTest.kt index f009a9f..385a5c0 100644 --- a/codeplasterage/src/test/java/uk/co/alt236/codeplasterage/datafactory/CustomDataFactoryTest.kt +++ b/codeplasterage/src/test/java/dev/alt236/codeplasterage/datafactory/CustomDataFactoryTest.kt @@ -1,12 +1,11 @@ -package uk.co.alt236.codeplasterage.datafactory +package dev.alt236.codeplasterage.datafactory +import dev.alt236.codeplasterage.datafactory.stats.DataFactoryRequestRecorder import org.junit.jupiter.api.Assertions.assertInstanceOf import org.junit.jupiter.api.Assertions.assertNull import org.junit.jupiter.api.Test -import uk.co.alt236.codeplasterage.datafactory.stats.DataFactoryRequestRecorder class CustomDataFactoryTest { - @Test fun `DummyDataFactory does not provide TestClass by default`() { val dataFactory = DummyDataFactory(true, DataFactoryRequestRecorder()) @@ -33,16 +32,15 @@ class CustomDataFactoryTest { private class BrandNewClass - private class BrandNewClassDataFactory(debug: Boolean) : SubDataFactory(debug) { - override fun canCreateDataFor(clazz: Class<*>): Boolean { - return clazz == BrandNewClass::class.java - } + private class BrandNewClassDataFactory( + debug: Boolean, + ) : SubDataFactory(debug) { + override fun canCreateDataFor(clazz: Class<*>): Boolean = clazz == BrandNewClass::class.java - override fun getDummyData(clazz: Class<*>): DataFactoryResult<*> { - return when (clazz) { + override fun getDummyData(clazz: Class<*>): DataFactoryResult<*> = + when (clazz) { BrandNewClass::class.java -> DataFactoryResult.Valid(BrandNewClass(), clazz) else -> DataFactoryResult.createUnableToCreateInstanceError(this, clazz) } - } } } diff --git a/codeplasterage/src/test/java/dev/alt236/codeplasterage/datafactory/classtests/DummyDataFromClassTest.kt b/codeplasterage/src/test/java/dev/alt236/codeplasterage/datafactory/classtests/DummyDataFromClassTest.kt new file mode 100644 index 0000000..dde613d --- /dev/null +++ b/codeplasterage/src/test/java/dev/alt236/codeplasterage/datafactory/classtests/DummyDataFromClassTest.kt @@ -0,0 +1,127 @@ +package dev.alt236.codeplasterage.datafactory.classtests + +import dev.alt236.codeplasterage.datafactory.DataFactoryResult +import dev.alt236.codeplasterage.datafactory.DummyDataFactory +import dev.alt236.codeplasterage.datafactory.classtests.DummyDataFromClassTest.Companion.InputArgs.Complex +import dev.alt236.codeplasterage.datafactory.classtests.DummyDataFromClassTest.Companion.InputArgs.Simple +import dev.alt236.codeplasterage.datafactory.stats.DataFactoryRequestRecorder +import org.junit.jupiter.api.Assertions.assertNotNull +import org.junit.jupiter.api.Assertions.assertTrue +import org.junit.jupiter.api.BeforeEach +import org.junit.jupiter.params.ParameterizedTest +import org.junit.jupiter.params.provider.Arguments +import org.junit.jupiter.params.provider.MethodSource +import java.io.Closeable +import java.io.IOException +import java.io.InputStream +import java.io.Serializable +import java.util.stream.Stream + +class DummyDataFromClassTest { + private lateinit var sut: DummyDataFactory + + @BeforeEach + fun setUp() { + sut = DummyDataFactory(true, DataFactoryRequestRecorder()) + } + + @ParameterizedTest(name = "{index} => input=''{1}'' / expected=''{0}''") + @MethodSource("provide_data") + fun `returns valid output for input class`( + inputClass: Class, + expectedClass: Class, + ) { + val result = sut.getDummyDataForType(inputClass) + + assertTrue(result is DataFactoryResult.Valid, "Result must be valid, but was: $result") + (result as DataFactoryResult.Valid) // Smart cast + + assertNotNull(result.value, "Expected value shoud not be null!") + val actualClass = result.value!!::class.java + + assertAssignable(expectedClass, actualClass) + } + + private fun assertAssignable( + actual: Class<*>, + expected: Class<*>, + ) { + val message = "'$actual' is not a subclass of, or does not implement, '$expected' " + assertTrue(actual.isAssignableFrom(expected), message) + } + + companion object { + @JvmStatic + fun provide_data(): Stream { + @Suppress("RemoveRedundantQualifierName") + val args: List = + listOf( + Simple(java.lang.String::class.java), + Simple(String::class.java), + Simple(java.lang.CharSequence::class.java), + Simple(kotlin.CharSequence::class.java), + Simple(java.lang.StringBuffer::class.java), + Simple(kotlin.text.StringBuilder::class.java), + Simple(java.lang.StringBuilder::class.java), + Simple(java.util.Iterator::class.java), + Simple(kotlin.collections.Iterator::class.java), + Simple(kotlin.collections.Iterable::class.java), + Complex(kotlin.collections.Collection::class.java, ArrayList::class.java), + Complex(java.util.Collection::class.java, ArrayList::class.java), + Simple(java.util.HashMap::class.java), + Simple(kotlin.collections.HashMap::class.java), + Simple(java.util.Map::class.java), + Simple(kotlin.collections.Map::class.java), + Simple(kotlin.collections.MutableMap::class.java), + Simple(java.util.Set::class.java), + Simple(kotlin.collections.Set::class.java), + Simple(kotlin.collections.MutableSet::class.java), + Complex(java.util.List::class.java, java.util.ArrayList::class.java), + Simple(kotlin.collections.List::class.java), + Simple(kotlin.collections.MutableList::class.java), + Simple(java.lang.Object::class.java), + Simple(Any::class.java), + Simple(Serializable::class.java), + Simple(Readable::class.java::class.java), + Simple(InputStream::class.java), + Simple(Closeable::class.java), + Simple(ArithmeticException::class.java), + Simple(AssertionError::class.java), + Simple(ClassCastException::class.java), + Simple(ConcurrentModificationException::class.java), + Simple(IllegalArgumentException::class.java), + Simple(IllegalStateException::class.java), + Simple(IndexOutOfBoundsException::class.java), + Simple(IOException::class.java), + Simple(NoSuchElementException::class.java), + Simple(NullPointerException::class.java), + Simple(NumberFormatException::class.java), + Simple(UnsupportedOperationException::class.java), + Simple(IllegalCallerException::class.java), + Simple(RuntimeException::class.java), + Simple(Exception::class.java), + Simple(Throwable::class.java), + Simple(Error::class.java), + ) + + return args.map { it.toTestArgs() }.stream() + } + + private fun InputArgs.toTestArgs(): Arguments = + when (this) { + is Complex -> Arguments.of(this.input, this.expected) + is Simple -> Arguments.of(this.input, this.input) + } + + sealed interface InputArgs { + data class Simple( + val input: Class<*>, + ) : InputArgs + + data class Complex( + val input: Class<*>, + val expected: Class<*>, + ) : InputArgs + } + } +} diff --git a/codeplasterage/src/test/java/dev/alt236/codeplasterage/datafactory/datatests/ArrayTest.kt b/codeplasterage/src/test/java/dev/alt236/codeplasterage/datafactory/datatests/ArrayTest.kt new file mode 100644 index 0000000..5c3bb69 --- /dev/null +++ b/codeplasterage/src/test/java/dev/alt236/codeplasterage/datafactory/datatests/ArrayTest.kt @@ -0,0 +1,72 @@ +package dev.alt236.codeplasterage.datafactory.datatests + +import dev.alt236.codeplasterage.datafactory.DataFactoryResult +import dev.alt236.codeplasterage.datafactory.DummyDataFactory +import dev.alt236.codeplasterage.datafactory.stats.DataFactoryRequestRecorder +import org.junit.jupiter.api.Assertions.assertEquals +import org.junit.jupiter.api.Assertions.assertTrue +import org.junit.jupiter.api.BeforeEach +import org.junit.jupiter.params.ParameterizedTest +import org.junit.jupiter.params.provider.Arguments +import org.junit.jupiter.params.provider.MethodSource +import java.util.stream.Stream + +internal class ArrayTest { + private lateinit var sut: DummyDataFactory + + @BeforeEach + fun setUp() { + sut = DummyDataFactory(true, DataFactoryRequestRecorder()) + } + + @ParameterizedTest(name = "{index} => type=''{1}'' / value=''{0}''") + @MethodSource("provide_data") + fun `returns valid output for input class`( + input: Any, + clazz: Class, + ) { + val inputClass = input::class.java + val result = sut.getDummyDataForType(inputClass) + + assertTrue(result is DataFactoryResult.Valid, "Result not valid: $result") + assertEquals(inputClass, (result as DataFactoryResult.Valid).value!!::class.java) + } + + companion object { + @JvmStatic + fun provide_data(): Stream { + val args = + listOf( + intArrayOf(1), + arrayOf(1), + longArrayOf(1L), + arrayOf(1L), + doubleArrayOf(1.1), + arrayOf(1.1), + floatArrayOf(1.1F), + arrayOf(1.1F), + booleanArrayOf(false), + arrayOf(false), + charArrayOf(1.toChar()), + arrayOf(1.toChar()), + byteArrayOf(1.toByte()), + arrayOf(1.toByte()), + shortArrayOf(1.toShort()), + arrayOf(1.toShort()), + arrayOf("Foo"), + // Arrays of arrays + arrayOf(arrayOf("Foo")), + arrayOf(intArrayOf(1)), + arrayOf(arrayOf(1)), + // Arrays of arrays of arrays :D + arrayOf(arrayOf(1), arrayOf(arrayOf(1))), + arrayOf(arrayOf(1), arrayOf(arrayOf("Foo"))), + arrayOf(arrayOf(1), arrayOf(arrayOf("Foo")), arrayOf(Object())), + ) + + return args.map { it.toTestArgs() }.stream() + } + + private fun Any.toTestArgs(): Arguments = Arguments.of(this, this::class.java) + } +} diff --git a/codeplasterage/src/test/java/uk/co/alt236/codeplasterage/datafactory/datatests/CollectionsTest.kt b/codeplasterage/src/test/java/dev/alt236/codeplasterage/datafactory/datatests/CollectionsTest.kt similarity index 57% rename from codeplasterage/src/test/java/uk/co/alt236/codeplasterage/datafactory/datatests/CollectionsTest.kt rename to codeplasterage/src/test/java/dev/alt236/codeplasterage/datafactory/datatests/CollectionsTest.kt index 1b8386c..3ad4c84 100644 --- a/codeplasterage/src/test/java/uk/co/alt236/codeplasterage/datafactory/datatests/CollectionsTest.kt +++ b/codeplasterage/src/test/java/dev/alt236/codeplasterage/datafactory/datatests/CollectionsTest.kt @@ -1,14 +1,14 @@ -package uk.co.alt236.codeplasterage.datafactory.datatests +package dev.alt236.codeplasterage.datafactory.datatests +import dev.alt236.codeplasterage.datafactory.DataFactoryResult +import dev.alt236.codeplasterage.datafactory.DummyDataFactory +import dev.alt236.codeplasterage.datafactory.stats.DataFactoryRequestRecorder import org.junit.jupiter.api.Assertions.assertEquals import org.junit.jupiter.api.Assertions.assertTrue import org.junit.jupiter.api.BeforeEach import org.junit.jupiter.params.ParameterizedTest import org.junit.jupiter.params.provider.Arguments import org.junit.jupiter.params.provider.MethodSource -import uk.co.alt236.codeplasterage.datafactory.DataFactoryResult -import uk.co.alt236.codeplasterage.datafactory.DummyDataFactory -import uk.co.alt236.codeplasterage.datafactory.stats.DataFactoryRequestRecorder import java.util.* import java.util.stream.Stream @@ -22,7 +22,10 @@ internal class CollectionsTest { @ParameterizedTest(name = "{index} => type=''{1}'' / value=''{0}''") @MethodSource("provide_data") - fun `returns valid output for input class`(input: Any, clazz: Class) { + fun `returns valid output for input class`( + input: Any, + clazz: Class, + ) { val inputClass = input::class.java val result = sut.getDummyDataForType(inputClass) @@ -33,21 +36,20 @@ internal class CollectionsTest { companion object { @JvmStatic fun provide_data(): Stream { - val args = listOf( - ArrayList(), - HashMap(), - TreeMap(), - HashSet(), - TreeSet(), - Vector(), - Stack() - ) + val args = + listOf( + ArrayList(), + HashMap(), + TreeMap(), + HashSet(), + TreeSet(), + Vector(), + Stack(), + ) return args.map { it.toTestArgs() }.stream() } - private fun Any.toTestArgs(): Arguments { - return Arguments.of(this, this::class.java) - } + private fun Any.toTestArgs(): Arguments = Arguments.of(this, this::class.java) } } diff --git a/codeplasterage/src/test/java/uk/co/alt236/codeplasterage/datafactory/datatests/PrimitiveTest.kt b/codeplasterage/src/test/java/dev/alt236/codeplasterage/datafactory/datatests/PrimitiveTest.kt similarity index 55% rename from codeplasterage/src/test/java/uk/co/alt236/codeplasterage/datafactory/datatests/PrimitiveTest.kt rename to codeplasterage/src/test/java/dev/alt236/codeplasterage/datafactory/datatests/PrimitiveTest.kt index dace3d1..e16d5ba 100644 --- a/codeplasterage/src/test/java/uk/co/alt236/codeplasterage/datafactory/datatests/PrimitiveTest.kt +++ b/codeplasterage/src/test/java/dev/alt236/codeplasterage/datafactory/datatests/PrimitiveTest.kt @@ -1,14 +1,14 @@ -package uk.co.alt236.codeplasterage.datafactory.datatests +package dev.alt236.codeplasterage.datafactory.datatests +import dev.alt236.codeplasterage.datafactory.DataFactoryResult +import dev.alt236.codeplasterage.datafactory.DummyDataFactory +import dev.alt236.codeplasterage.datafactory.stats.DataFactoryRequestRecorder import org.junit.jupiter.api.Assertions.assertEquals import org.junit.jupiter.api.Assertions.assertTrue import org.junit.jupiter.api.BeforeEach import org.junit.jupiter.params.ParameterizedTest import org.junit.jupiter.params.provider.Arguments import org.junit.jupiter.params.provider.MethodSource -import uk.co.alt236.codeplasterage.datafactory.DataFactoryResult -import uk.co.alt236.codeplasterage.datafactory.DummyDataFactory -import uk.co.alt236.codeplasterage.datafactory.stats.DataFactoryRequestRecorder import java.math.BigDecimal import java.math.BigInteger import java.util.* @@ -24,7 +24,10 @@ internal class PrimitiveTest { @ParameterizedTest(name = "{index} => type=''{1}'' / value=''{0}''") @MethodSource("provide_data") - fun `returns valid output for input class`(input: Any, clazz: Class) { + fun `returns valid output for input class`( + input: Any, + clazz: Class, + ) { val inputClass = input::class.java val result = sut.getDummyDataForType(inputClass) @@ -35,27 +38,26 @@ internal class PrimitiveTest { companion object { @JvmStatic fun provide_data(): Stream { - val args = listOf( - 1, - 1L, - 'c', - true, - false, - 1.1, - 1.1F, - Date(), - BigDecimal(1), - BigInteger("2"), - Object::class.java, - Object(), - Locale.CANADA - ) + val args = + listOf( + 1, + 1L, + 'c', + true, + false, + 1.1, + 1.1F, + Date(), + BigDecimal(1), + BigInteger("2"), + Object::class.java, + Object(), + Locale.CANADA, + ) return args.map { it.toTestArgs() }.stream() } - private fun Any.toTestArgs(): Arguments { - return Arguments.of(this, this::class.java) - } + private fun Any.toTestArgs(): Arguments = Arguments.of(this, this::class.java) } } diff --git a/codeplasterage/src/test/java/uk/co/alt236/codeplasterage/datafactory/datatests/TextTest.kt b/codeplasterage/src/test/java/dev/alt236/codeplasterage/datafactory/datatests/TextTest.kt similarity index 61% rename from codeplasterage/src/test/java/uk/co/alt236/codeplasterage/datafactory/datatests/TextTest.kt rename to codeplasterage/src/test/java/dev/alt236/codeplasterage/datafactory/datatests/TextTest.kt index 6b4d631..a42ac13 100644 --- a/codeplasterage/src/test/java/uk/co/alt236/codeplasterage/datafactory/datatests/TextTest.kt +++ b/codeplasterage/src/test/java/dev/alt236/codeplasterage/datafactory/datatests/TextTest.kt @@ -1,15 +1,14 @@ -package uk.co.alt236.codeplasterage.datafactory.datatests +package dev.alt236.codeplasterage.datafactory.datatests +import dev.alt236.codeplasterage.datafactory.DataFactoryResult +import dev.alt236.codeplasterage.datafactory.DummyDataFactory +import dev.alt236.codeplasterage.datafactory.stats.DataFactoryRequestRecorder import org.junit.jupiter.api.Assertions.assertEquals import org.junit.jupiter.api.Assertions.assertTrue import org.junit.jupiter.api.BeforeEach import org.junit.jupiter.params.ParameterizedTest import org.junit.jupiter.params.provider.Arguments import org.junit.jupiter.params.provider.MethodSource -import uk.co.alt236.codeplasterage.datafactory.DataFactoryResult -import uk.co.alt236.codeplasterage.datafactory.DummyDataFactory -import uk.co.alt236.codeplasterage.datafactory.stats.DataFactoryRequestRecorder -import java.util.* import java.util.stream.Stream internal class TextTest { @@ -22,7 +21,10 @@ internal class TextTest { @ParameterizedTest(name = "{index} => type=''{1}'' / value=''{0}''") @MethodSource("provide_data") - fun `returns valid output for input class`(input: Any, clazz: Class) { + fun `returns valid output for input class`( + input: Any, + clazz: Class, + ) { val inputClass = input::class.java val result = sut.getDummyDataForType(inputClass) @@ -33,18 +35,17 @@ internal class TextTest { companion object { @JvmStatic fun provide_data(): Stream { - val args = listOf( - "Foo", - "Foo" as CharSequence, - StringBuffer(), - StringBuilder() - ) + val args = + listOf( + "Foo", + "Foo" as CharSequence, + StringBuffer(), + StringBuilder(), + ) return args.map { it.toTestArgs() }.stream() } - private fun Any.toTestArgs(): Arguments { - return Arguments.of(this, this::class.java) - } + private fun Any.toTestArgs(): Arguments = Arguments.of(this, this::class.java) } } diff --git a/codeplasterage/src/test/java/uk/co/alt236/codeplasterage/datafactory/datatests/ThrowableTest.kt b/codeplasterage/src/test/java/dev/alt236/codeplasterage/datafactory/datatests/ThrowableTest.kt similarity index 57% rename from codeplasterage/src/test/java/uk/co/alt236/codeplasterage/datafactory/datatests/ThrowableTest.kt rename to codeplasterage/src/test/java/dev/alt236/codeplasterage/datafactory/datatests/ThrowableTest.kt index a8b8719..18c83bb 100644 --- a/codeplasterage/src/test/java/uk/co/alt236/codeplasterage/datafactory/datatests/ThrowableTest.kt +++ b/codeplasterage/src/test/java/dev/alt236/codeplasterage/datafactory/datatests/ThrowableTest.kt @@ -1,15 +1,14 @@ -package uk.co.alt236.codeplasterage.datafactory.datatests +package dev.alt236.codeplasterage.datafactory.datatests +import dev.alt236.codeplasterage.datafactory.DataFactoryResult +import dev.alt236.codeplasterage.datafactory.DummyDataFactory +import dev.alt236.codeplasterage.datafactory.stats.DataFactoryRequestRecorder import org.junit.jupiter.api.Assertions.assertEquals import org.junit.jupiter.api.Assertions.assertTrue import org.junit.jupiter.api.BeforeEach import org.junit.jupiter.params.ParameterizedTest import org.junit.jupiter.params.provider.Arguments import org.junit.jupiter.params.provider.MethodSource -import uk.co.alt236.codeplasterage.datafactory.DataFactoryResult -import uk.co.alt236.codeplasterage.datafactory.DummyDataFactory -import uk.co.alt236.codeplasterage.datafactory.stats.DataFactoryRequestRecorder -import java.util.* import java.util.stream.Stream internal class ThrowableTest { @@ -22,7 +21,10 @@ internal class ThrowableTest { @ParameterizedTest(name = "{index} => type=''{1}'' / value=''{0}''") @MethodSource("provide_data") - fun `returns valid output for input class`(input: Any, clazz: Class) { + fun `returns valid output for input class`( + input: Any, + clazz: Class, + ) { val inputClass = input::class.java val result = sut.getDummyDataForType(inputClass) @@ -33,21 +35,20 @@ internal class ThrowableTest { companion object { @JvmStatic fun provide_data(): Stream { - val args = listOf( - Throwable(), - Exception(), - RuntimeException(), - Error(), - IllegalStateException(), - NullPointerException(), - IllegalAccessError() - ) + val args = + listOf( + Throwable(), + Exception(), + RuntimeException(), + Error(), + IllegalStateException(), + NullPointerException(), + IllegalAccessError(), + ) return args.map { it.toTestArgs() }.stream() } - private fun Any.toTestArgs(): Arguments { - return Arguments.of(this, this::class.java) - } + private fun Any.toTestArgs(): Arguments = Arguments.of(this, this::class.java) } } diff --git a/codeplasterage/src/test/java/uk/co/alt236/codeplasterage/ext/AnnotationExtTest.kt b/codeplasterage/src/test/java/dev/alt236/codeplasterage/ext/AnnotationExtTest.kt similarity index 61% rename from codeplasterage/src/test/java/uk/co/alt236/codeplasterage/ext/AnnotationExtTest.kt rename to codeplasterage/src/test/java/dev/alt236/codeplasterage/ext/AnnotationExtTest.kt index 441e235..1246da5 100644 --- a/codeplasterage/src/test/java/uk/co/alt236/codeplasterage/ext/AnnotationExtTest.kt +++ b/codeplasterage/src/test/java/dev/alt236/codeplasterage/ext/AnnotationExtTest.kt @@ -1,10 +1,10 @@ -package uk.co.alt236.codeplasterage.ext +package dev.alt236.codeplasterage.ext +import dev.alt236.codeplasterage.ext.AnnotationExt.methodsAreAnnotatedWithAnyOf +import dev.alt236.codeplasterage.testdata.ClassWithJunitTestMethodAnnotation +import dev.alt236.codeplasterage.testdata.ClassWithJupiterTestMethodAnnotation import org.junit.jupiter.api.Assertions.assertTrue import org.junit.jupiter.api.Test -import uk.co.alt236.codeplasterage.ext.AnnotationExt.methodsAreAnnotatedWithAnyOf -import uk.co.alt236.codeplasterage.testdata.ClassWithJunitTestMethodAnnotation -import uk.co.alt236.codeplasterage.testdata.ClassWithJupiterTestMethodAnnotation class AnnotationExtTest { @Test @@ -22,9 +22,10 @@ class AnnotationExtTest { } private companion object { - val FORBIDDEN_ANNOTATIONS = setOf( - NormalisedClassName(org.junit.Test::class.java), - NormalisedClassName(Test::class.java) - ) + val FORBIDDEN_ANNOTATIONS = + setOf( + NormalisedClassName(org.junit.Test::class.java), + NormalisedClassName(Test::class.java), + ) } } diff --git a/codeplasterage/src/test/java/uk/co/alt236/codeplasterage/testdata/ClassWithJunitTestMethodAnnotation.kt b/codeplasterage/src/test/java/dev/alt236/codeplasterage/testdata/ClassWithJunitTestMethodAnnotation.kt similarity index 83% rename from codeplasterage/src/test/java/uk/co/alt236/codeplasterage/testdata/ClassWithJunitTestMethodAnnotation.kt rename to codeplasterage/src/test/java/dev/alt236/codeplasterage/testdata/ClassWithJunitTestMethodAnnotation.kt index d37c176..a3388c4 100644 --- a/codeplasterage/src/test/java/uk/co/alt236/codeplasterage/testdata/ClassWithJunitTestMethodAnnotation.kt +++ b/codeplasterage/src/test/java/dev/alt236/codeplasterage/testdata/ClassWithJunitTestMethodAnnotation.kt @@ -1,9 +1,8 @@ -package uk.co.alt236.codeplasterage.testdata +package dev.alt236.codeplasterage.testdata import org.junit.Test class ClassWithJunitTestMethodAnnotation { - @Test fun methodWithTestAnnotation() { // Even though this test will be executed, we only need this class to check reflection diff --git a/codeplasterage/src/test/java/uk/co/alt236/codeplasterage/testdata/ClassWithJupiterTestMethodAnnotation.kt b/codeplasterage/src/test/java/dev/alt236/codeplasterage/testdata/ClassWithJupiterTestMethodAnnotation.kt similarity index 84% rename from codeplasterage/src/test/java/uk/co/alt236/codeplasterage/testdata/ClassWithJupiterTestMethodAnnotation.kt rename to codeplasterage/src/test/java/dev/alt236/codeplasterage/testdata/ClassWithJupiterTestMethodAnnotation.kt index b4754da..77b88af 100644 --- a/codeplasterage/src/test/java/uk/co/alt236/codeplasterage/testdata/ClassWithJupiterTestMethodAnnotation.kt +++ b/codeplasterage/src/test/java/dev/alt236/codeplasterage/testdata/ClassWithJupiterTestMethodAnnotation.kt @@ -1,9 +1,8 @@ -package uk.co.alt236.codeplasterage.testdata +package dev.alt236.codeplasterage.testdata import org.junit.jupiter.api.Test class ClassWithJupiterTestMethodAnnotation { - @Test fun methodWithTestAnnotation() { // Even though this test will be executed, we only need this class to check reflection diff --git a/codeplasterage/src/test/java/uk/co/alt236/codeplasterage/datafactory/classtests/DummyDataFromClassTest.kt b/codeplasterage/src/test/java/uk/co/alt236/codeplasterage/datafactory/classtests/DummyDataFromClassTest.kt deleted file mode 100644 index 93582a3..0000000 --- a/codeplasterage/src/test/java/uk/co/alt236/codeplasterage/datafactory/classtests/DummyDataFromClassTest.kt +++ /dev/null @@ -1,132 +0,0 @@ -package uk.co.alt236.codeplasterage.datafactory.classtests - -import org.junit.jupiter.api.Assertions.assertNotNull -import org.junit.jupiter.api.Assertions.assertTrue -import org.junit.jupiter.api.BeforeEach -import org.junit.jupiter.params.ParameterizedTest -import org.junit.jupiter.params.provider.Arguments -import org.junit.jupiter.params.provider.MethodSource -import uk.co.alt236.codeplasterage.datafactory.DataFactoryResult -import uk.co.alt236.codeplasterage.datafactory.DummyDataFactory -import uk.co.alt236.codeplasterage.datafactory.classtests.DummyDataFromClassTest.Companion.InputArgs.Complex -import uk.co.alt236.codeplasterage.datafactory.classtests.DummyDataFromClassTest.Companion.InputArgs.Simple -import uk.co.alt236.codeplasterage.datafactory.stats.DataFactoryRequestRecorder -import java.io.Closeable -import java.io.IOException -import java.io.InputStream -import java.io.Serializable -import java.util.* -import java.util.stream.Stream - -class DummyDataFromClassTest { - private lateinit var sut: DummyDataFactory - - @BeforeEach - fun setUp() { - sut = DummyDataFactory(true, DataFactoryRequestRecorder()) - } - - @ParameterizedTest(name = "{index} => input=''{1}'' / expected=''{0}''") - @MethodSource("provide_data") - fun `returns valid output for input class`(inputClass: Class, expectedClass: Class) { - val result = sut.getDummyDataForType(inputClass) - - assertTrue(result is DataFactoryResult.Valid, "Result must be valid, but was: $result") - (result as DataFactoryResult.Valid) // Smart cast - - assertNotNull(result.value, "Expected value shoud not be null!") - val actualClass = result.value!!::class.java - - assertAssignable(expectedClass, actualClass) - } - - private fun assertAssignable(actual: Class<*>, expected: Class<*>) { - val message = "'$actual' is not a subclass of, or does not implement, '$expected' " - assertTrue(actual.isAssignableFrom(expected), message) - } - - companion object { - @JvmStatic - fun provide_data(): Stream { - @Suppress("RemoveRedundantQualifierName") - val args: List = listOf( - Simple(java.lang.String::class.java), - Simple(String::class.java), - - Simple(java.lang.CharSequence::class.java), - Simple(kotlin.CharSequence::class.java), - - Simple(java.lang.StringBuffer::class.java), - - Simple(kotlin.text.StringBuilder::class.java), - Simple(java.lang.StringBuilder::class.java), - - Simple(java.util.Iterator::class.java), - Simple(kotlin.collections.Iterator::class.java), - - Simple(kotlin.collections.Iterable::class.java), - - Complex(kotlin.collections.Collection::class.java, ArrayList::class.java), - Complex(java.util.Collection::class.java, ArrayList::class.java), - - Simple(java.util.HashMap::class.java), - Simple(kotlin.collections.HashMap::class.java), - - Simple(java.util.Map::class.java), - Simple(kotlin.collections.Map::class.java), - Simple(kotlin.collections.MutableMap::class.java), - - Simple(java.util.Set::class.java), - Simple(kotlin.collections.Set::class.java), - Simple(kotlin.collections.MutableSet::class.java), - - Complex(java.util.List::class.java, java.util.ArrayList::class.java), - Simple(kotlin.collections.List::class.java), - Simple(kotlin.collections.MutableList::class.java), - - Simple(java.lang.Object::class.java), - Simple(Any::class.java), - Simple(Serializable::class.java), - - Simple(Readable::class.java::class.java), - Simple(InputStream::class.java), - Simple(Closeable::class.java), - - Simple(ArithmeticException::class.java), - Simple(AssertionError::class.java), - Simple(ClassCastException::class.java), - Simple(ConcurrentModificationException::class.java), - - Simple(IllegalArgumentException::class.java), - Simple(IllegalStateException::class.java), - Simple(IndexOutOfBoundsException::class.java), - Simple(IOException::class.java), - Simple(NoSuchElementException::class.java), - Simple(NullPointerException::class.java), - Simple(NumberFormatException::class.java), - Simple(UnsupportedOperationException::class.java), - - Simple(IllegalCallerException::class.java), - - Simple(RuntimeException::class.java), - Simple(Exception::class.java), - Simple(Throwable::class.java), - Simple(Error::class.java) - ) - - return args.map { it.toTestArgs() }.stream() - } - - private fun InputArgs.toTestArgs(): Arguments { - return when (this) { - is Complex -> Arguments.of(this.input, this.expected) - is Simple -> Arguments.of(this.input, this.input) - } - } - - sealed interface InputArgs { - data class Simple(val input: Class<*>) : InputArgs - data class Complex(val input: Class<*>, val expected: Class<*>) : InputArgs - } - } -} diff --git a/codeplasterage/src/test/java/uk/co/alt236/codeplasterage/datafactory/datatests/ArrayTest.kt b/codeplasterage/src/test/java/uk/co/alt236/codeplasterage/datafactory/datatests/ArrayTest.kt deleted file mode 100644 index f472dee..0000000 --- a/codeplasterage/src/test/java/uk/co/alt236/codeplasterage/datafactory/datatests/ArrayTest.kt +++ /dev/null @@ -1,81 +0,0 @@ -package uk.co.alt236.codeplasterage.datafactory.datatests - -import org.junit.jupiter.api.Assertions.assertEquals -import org.junit.jupiter.api.Assertions.assertTrue -import org.junit.jupiter.api.BeforeEach -import org.junit.jupiter.params.ParameterizedTest -import org.junit.jupiter.params.provider.Arguments -import org.junit.jupiter.params.provider.MethodSource -import uk.co.alt236.codeplasterage.datafactory.DataFactoryResult -import uk.co.alt236.codeplasterage.datafactory.DummyDataFactory -import uk.co.alt236.codeplasterage.datafactory.stats.DataFactoryRequestRecorder -import java.util.* -import java.util.stream.Stream - -internal class ArrayTest { - private lateinit var sut: DummyDataFactory - - @BeforeEach - fun setUp() { - sut = DummyDataFactory(true, DataFactoryRequestRecorder()) - } - - @ParameterizedTest(name = "{index} => type=''{1}'' / value=''{0}''") - @MethodSource("provide_data") - fun `returns valid output for input class`(input: Any, clazz: Class) { - val inputClass = input::class.java - val result = sut.getDummyDataForType(inputClass) - - assertTrue(result is DataFactoryResult.Valid, "Result not valid: $result") - assertEquals(inputClass, (result as DataFactoryResult.Valid).value!!::class.java) - } - - companion object { - @JvmStatic - fun provide_data(): Stream { - val args = listOf( - intArrayOf(1), - arrayOf(1), - - longArrayOf(1L), - arrayOf(1L), - - doubleArrayOf(1.1), - arrayOf(1.1), - - floatArrayOf(1.1F), - arrayOf(1.1F), - - booleanArrayOf(false), - arrayOf(false), - - charArrayOf(1.toChar()), - arrayOf(1.toChar()), - - byteArrayOf(1.toByte()), - arrayOf(1.toByte()), - - shortArrayOf(1.toShort()), - arrayOf(1.toShort()), - - arrayOf("Foo"), - - // Arrays of arrays - arrayOf(arrayOf("Foo")), - arrayOf(intArrayOf(1)), - arrayOf(arrayOf(1)), - - // Arrays of arrays of arrays :D - arrayOf(arrayOf(1), arrayOf(arrayOf(1))), - arrayOf(arrayOf(1), arrayOf(arrayOf("Foo"))), - arrayOf(arrayOf(1), arrayOf(arrayOf("Foo")), arrayOf(Object())) - ) - - return args.map { it.toTestArgs() }.stream() - } - - private fun Any.toTestArgs(): Arguments { - return Arguments.of(this, this::class.java) - } - } -} diff --git a/gradle.properties b/gradle.properties deleted file mode 100644 index f3934b1..0000000 --- a/gradle.properties +++ /dev/null @@ -1,4 +0,0 @@ -kotlin_version=1.7.21 -jlleitschuh_ktlint_version=11.3.1 -test_logger_version=3.2.0 -kover_version=0.6.1 \ No newline at end of file diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml new file mode 100644 index 0000000..a2e65ff --- /dev/null +++ b/gradle/libs.versions.toml @@ -0,0 +1,30 @@ +[versions] +commons-lang3 = "3.12.0" +dagger = "2.52" +guava = "33.3.1-jre" +junit4 = "4.13.2" +kotlin = "2.0.21" +mockk = "1.13.13" +retrofit = "2.11.0" +vanniktech-maven-publish = "0.30.0" +gradle-ktlint = "12.1.2" +testlogger = "3.2.0" +kover = "0.6.1" + +[libraries] +commons-lang3 = { module = "org.apache.commons:commons-lang3", version.ref = "commons-lang3" } +dagger = { module = "com.google.dagger:dagger", version.ref = "dagger" } +dagger-compiler = { module = "com.google.dagger:dagger-compiler", version.ref = "dagger" } +guava = { module = "com.google.guava:guava", version.ref = "guava" } +junit4 = { module = "junit:junit", version.ref = "junit4" } +kotlin-reflect = { module = "org.jetbrains.kotlin:kotlin-reflect", version.ref = "kotlin" } +mockk = { module = "io.mockk:mockk", version.ref = "mockk" } +retrofit = { module = "com.squareup.retrofit2:retrofit", version.ref = "retrofit" } + +[plugins] +kotlin-jvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" } +kotlin-kapt = { id = "org.jetbrains.kotlin.kapt", version.ref = "kotlin" } +vanniktech-maven-publish = { id = "com.vanniktech.maven.publish", version.ref = "vanniktech-maven-publish" } +gradle-ktlint = { id = "org.jlleitschuh.gradle.ktlint", version.ref = "gradle-ktlint" } +testlogger = { id = "com.adarshr.test-logger", version.ref = "testlogger" } +kover = { id = "org.jetbrains.kotlinx.kover", version.ref = "kover" } diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties index 60c76b3..ab79162 100644 --- a/gradle/wrapper/gradle-wrapper.properties +++ b/gradle/wrapper/gradle-wrapper.properties @@ -1,5 +1,5 @@ distributionBase=GRADLE_USER_HOME distributionPath=wrapper/dists -distributionUrl=https\://services.gradle.org/distributions/gradle-7.4.2-bin.zip +distributionUrl=https\://services.gradle.org/distributions/gradle-8.9-bin.zip zipStoreBase=GRADLE_USER_HOME zipStorePath=wrapper/dists \ No newline at end of file diff --git a/testapp/build.gradle b/testapp/build.gradle index f71a61b..e493257 100644 --- a/testapp/build.gradle +++ b/testapp/build.gradle @@ -1,10 +1,10 @@ plugins { id 'java' - id 'kotlin' - id "org.jetbrains.kotlin.kapt" + alias(libs.plugins.kotlin.jvm) + alias(libs.plugins.kotlin.kapt) } -group 'uk.co.alt236.escamotage' +group 'dev.alt236.codeplasterage' repositories { mavenCentral() @@ -17,14 +17,14 @@ dependencies { // Since this library uses reflection, we are using the "main" code bucket to write the classes that // will be reflected upon. - implementation 'io.mockk:mockk:1.13.4' + implementation libs.mockk + implementation libs.dagger + kapt libs.dagger.compiler - implementation 'com.google.dagger:dagger:2.45' - kapt 'com.google.dagger:dagger-compiler:2.45' - - implementation 'com.squareup.retrofit2:retrofit:2.9.0' + implementation libs.retrofit testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.1' + testImplementation 'org.junit.jupiter:junit-jupiter-params:5.8.1' testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.1' testImplementation "junit:junit:4.13.2" } diff --git a/testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/TestInputLogger.kt b/testapp/src/main/java/dev/alt236/codeplasteragetestapp/TestInputLogger.kt similarity index 68% rename from testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/TestInputLogger.kt rename to testapp/src/main/java/dev/alt236/codeplasteragetestapp/TestInputLogger.kt index 84f5927..5fc2e72 100644 --- a/testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/TestInputLogger.kt +++ b/testapp/src/main/java/dev/alt236/codeplasteragetestapp/TestInputLogger.kt @@ -1,15 +1,14 @@ -package uk.co.alt236.codeplasteragetestapp +package dev.alt236.codeplasteragetestapp private const val CHEVRON = ">>>>" object TestInputLogger { - @JvmStatic fun log(vararg args: Any?) { val sb = StringBuilder() sb.append("$CHEVRON Input [${args.size} arg(s)] for '${getCallingContext()}' was:") for ((index, arg) in args.withIndex()) { - sb.append("\n${CHEVRON}\t[$index] type='${arg.getClassName()}', value='${arg.asString()}'") + sb.append("\n$CHEVRON\t[$index] type='${arg.getClassName()}', value='${arg.asString()}'") } println(sb) } @@ -19,17 +18,15 @@ object TestInputLogger { return element.className + "#" + element.methodName } - private fun Any?.asString(): String { - return when (this) { + private fun Any?.asString(): String = + when (this) { is Array<*> -> this.contentToString() else -> this.toString() } - } - private fun Any?.getClassName(): String { - return when (this) { + private fun Any?.getClassName(): String = + when (this) { null -> "???" else -> this::class.java.simpleName } - } } diff --git a/testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/classparsing/arraytests/CommonArrayTests.kt b/testapp/src/main/java/dev/alt236/codeplasteragetestapp/classparsing/arraytests/CommonArrayTests.kt similarity index 86% rename from testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/classparsing/arraytests/CommonArrayTests.kt rename to testapp/src/main/java/dev/alt236/codeplasteragetestapp/classparsing/arraytests/CommonArrayTests.kt index 544c14f..e91b261 100644 --- a/testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/classparsing/arraytests/CommonArrayTests.kt +++ b/testapp/src/main/java/dev/alt236/codeplasteragetestapp/classparsing/arraytests/CommonArrayTests.kt @@ -1,15 +1,23 @@ -package uk.co.alt236.codeplasteragetestapp.classparsing.arraytests +package dev.alt236.codeplasteragetestapp.classparsing.arraytests import java.io.Serializable interface CommonArrayTests { fun booleanArrayTest(args: Array) + fun byteArrayTest(args: Array) + fun charArrayTest(args: Array) + fun doubleArrayTest(args: Array) + fun intArrayTest(args: Array) + fun longArrayTest(args: Array) + fun shortTest(args: Array) + fun stringArrayTest(args: Array) + fun serializableArray(args: Array) } diff --git a/testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/classparsing/arraytests/JavaClass.java b/testapp/src/main/java/dev/alt236/codeplasteragetestapp/classparsing/arraytests/JavaClass.java similarity index 90% rename from testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/classparsing/arraytests/JavaClass.java rename to testapp/src/main/java/dev/alt236/codeplasteragetestapp/classparsing/arraytests/JavaClass.java index ed60632..8ff2101 100644 --- a/testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/classparsing/arraytests/JavaClass.java +++ b/testapp/src/main/java/dev/alt236/codeplasteragetestapp/classparsing/arraytests/JavaClass.java @@ -1,7 +1,7 @@ -package uk.co.alt236.codeplasteragetestapp.classparsing.arraytests; +package dev.alt236.codeplasteragetestapp.classparsing.arraytests; +import dev.alt236.codeplasteragetestapp.TestInputLogger; import org.jetbrains.annotations.NotNull; -import uk.co.alt236.codeplasteragetestapp.TestInputLogger; import java.io.Serializable; diff --git a/testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/classparsing/arraytests/KotlinClass.kt b/testapp/src/main/java/dev/alt236/codeplasteragetestapp/classparsing/arraytests/KotlinClass.kt similarity index 88% rename from testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/classparsing/arraytests/KotlinClass.kt rename to testapp/src/main/java/dev/alt236/codeplasteragetestapp/classparsing/arraytests/KotlinClass.kt index ddf044e..c76ee40 100644 --- a/testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/classparsing/arraytests/KotlinClass.kt +++ b/testapp/src/main/java/dev/alt236/codeplasteragetestapp/classparsing/arraytests/KotlinClass.kt @@ -1,8 +1,8 @@ @file:Suppress("unused") -package uk.co.alt236.codeplasteragetestapp.classparsing.arraytests +package dev.alt236.codeplasteragetestapp.classparsing.arraytests -import uk.co.alt236.codeplasteragetestapp.TestInputLogger +import dev.alt236.codeplasteragetestapp.TestInputLogger import java.io.Serializable class KotlinClass : CommonArrayTests { diff --git a/testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/classparsing/nested/JavaNested.java b/testapp/src/main/java/dev/alt236/codeplasteragetestapp/classparsing/nested/JavaNested.java similarity index 93% rename from testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/classparsing/nested/JavaNested.java rename to testapp/src/main/java/dev/alt236/codeplasteragetestapp/classparsing/nested/JavaNested.java index b0d7158..a68703d 100644 --- a/testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/classparsing/nested/JavaNested.java +++ b/testapp/src/main/java/dev/alt236/codeplasteragetestapp/classparsing/nested/JavaNested.java @@ -1,8 +1,8 @@ -package uk.co.alt236.codeplasteragetestapp.classparsing.nested; +package dev.alt236.codeplasteragetestapp.classparsing.nested; +import dev.alt236.codeplasteragetestapp.TestInputLogger; +import dev.alt236.codeplasteragetestapp.classparsing.primitivetests.CommonPrimitiveTests; import org.jetbrains.annotations.NotNull; -import uk.co.alt236.codeplasteragetestapp.TestInputLogger; -import uk.co.alt236.codeplasteragetestapp.classparsing.primitivetests.CommonPrimitiveTests; @SuppressWarnings("unused") public class JavaNested implements CommonPrimitiveTests { diff --git a/testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/classparsing/nested/KotlinCompanionObject.kt b/testapp/src/main/java/dev/alt236/codeplasteragetestapp/classparsing/nested/KotlinCompanionObject.kt similarity index 94% rename from testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/classparsing/nested/KotlinCompanionObject.kt rename to testapp/src/main/java/dev/alt236/codeplasteragetestapp/classparsing/nested/KotlinCompanionObject.kt index 9e98fef..851702a 100644 --- a/testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/classparsing/nested/KotlinCompanionObject.kt +++ b/testapp/src/main/java/dev/alt236/codeplasteragetestapp/classparsing/nested/KotlinCompanionObject.kt @@ -1,13 +1,12 @@ @file:Suppress("unused") -package uk.co.alt236.codeplasteragetestapp.classparsing.nested +package dev.alt236.codeplasteragetestapp.classparsing.nested -import uk.co.alt236.codeplasteragetestapp.TestInputLogger -import uk.co.alt236.codeplasteragetestapp.classparsing.arraytests.CommonArrayTests +import dev.alt236.codeplasteragetestapp.TestInputLogger +import dev.alt236.codeplasteragetestapp.classparsing.arraytests.CommonArrayTests import java.io.Serializable class KotlinCompanionObject { - object Foo : CommonArrayTests { override fun stringArrayTest(args: Array) { TestInputLogger.log(args) diff --git a/testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/classparsing/primitivetests/CommonPrimitiveTests.kt b/testapp/src/main/java/dev/alt236/codeplasteragetestapp/classparsing/primitivetests/CommonPrimitiveTests.kt similarity index 81% rename from testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/classparsing/primitivetests/CommonPrimitiveTests.kt rename to testapp/src/main/java/dev/alt236/codeplasteragetestapp/classparsing/primitivetests/CommonPrimitiveTests.kt index f210c32..acc05dd 100644 --- a/testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/classparsing/primitivetests/CommonPrimitiveTests.kt +++ b/testapp/src/main/java/dev/alt236/codeplasteragetestapp/classparsing/primitivetests/CommonPrimitiveTests.kt @@ -1,14 +1,21 @@ -package uk.co.alt236.codeplasteragetestapp.classparsing.primitivetests +package dev.alt236.codeplasteragetestapp.classparsing.primitivetests interface CommonPrimitiveTests { fun stringTest(arg: String) // not a primitive, but hey :D fun booleanTest(arg: Boolean) + fun byteTest(arg: Byte) + fun charTest(arg: Char) + fun doubleTest(arg: Double) + fun floatTest(arg: Float) + fun intTest(arg: Int) + fun longTest(arg: Long) + fun shortTest(arg: Short) } diff --git a/testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/classparsing/primitivetests/JavaClass.java b/testapp/src/main/java/dev/alt236/codeplasteragetestapp/classparsing/primitivetests/JavaClass.java similarity index 88% rename from testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/classparsing/primitivetests/JavaClass.java rename to testapp/src/main/java/dev/alt236/codeplasteragetestapp/classparsing/primitivetests/JavaClass.java index 6cdb32b..3daea4d 100644 --- a/testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/classparsing/primitivetests/JavaClass.java +++ b/testapp/src/main/java/dev/alt236/codeplasteragetestapp/classparsing/primitivetests/JavaClass.java @@ -1,7 +1,7 @@ -package uk.co.alt236.codeplasteragetestapp.classparsing.primitivetests; +package dev.alt236.codeplasteragetestapp.classparsing.primitivetests; +import dev.alt236.codeplasteragetestapp.TestInputLogger; import org.jetbrains.annotations.NotNull; -import uk.co.alt236.codeplasteragetestapp.TestInputLogger; @SuppressWarnings("unused") public class JavaClass implements CommonPrimitiveTests { diff --git a/testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/classparsing/primitivetests/KotlinClass.kt b/testapp/src/main/java/dev/alt236/codeplasteragetestapp/classparsing/primitivetests/KotlinClass.kt similarity index 86% rename from testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/classparsing/primitivetests/KotlinClass.kt rename to testapp/src/main/java/dev/alt236/codeplasteragetestapp/classparsing/primitivetests/KotlinClass.kt index 59b46a9..49f96af 100644 --- a/testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/classparsing/primitivetests/KotlinClass.kt +++ b/testapp/src/main/java/dev/alt236/codeplasteragetestapp/classparsing/primitivetests/KotlinClass.kt @@ -1,8 +1,8 @@ @file:Suppress("unused") -package uk.co.alt236.codeplasteragetestapp.classparsing.primitivetests +package dev.alt236.codeplasteragetestapp.classparsing.primitivetests -import uk.co.alt236.codeplasteragetestapp.TestInputLogger +import dev.alt236.codeplasteragetestapp.TestInputLogger class KotlinClass : CommonPrimitiveTests { override fun stringTest(arg: String) { diff --git a/testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/classparsing/statictests/JavaStatic.java b/testapp/src/main/java/dev/alt236/codeplasteragetestapp/classparsing/statictests/JavaStatic.java similarity index 82% rename from testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/classparsing/statictests/JavaStatic.java rename to testapp/src/main/java/dev/alt236/codeplasteragetestapp/classparsing/statictests/JavaStatic.java index ecaa11b..9b53f02 100644 --- a/testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/classparsing/statictests/JavaStatic.java +++ b/testapp/src/main/java/dev/alt236/codeplasteragetestapp/classparsing/statictests/JavaStatic.java @@ -1,7 +1,7 @@ -package uk.co.alt236.codeplasteragetestapp.classparsing.statictests; +package dev.alt236.codeplasteragetestapp.classparsing.statictests; +import dev.alt236.codeplasteragetestapp.TestInputLogger; import org.jetbrains.annotations.NotNull; -import uk.co.alt236.codeplasteragetestapp.TestInputLogger; @SuppressWarnings("unused") public class JavaStatic { diff --git a/testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/classparsing/statictests/JavaStaticPrivateConstr.java b/testapp/src/main/java/dev/alt236/codeplasteragetestapp/classparsing/statictests/JavaStaticPrivateConstr.java similarity index 84% rename from testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/classparsing/statictests/JavaStaticPrivateConstr.java rename to testapp/src/main/java/dev/alt236/codeplasteragetestapp/classparsing/statictests/JavaStaticPrivateConstr.java index 13f0101..ce5e29b 100644 --- a/testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/classparsing/statictests/JavaStaticPrivateConstr.java +++ b/testapp/src/main/java/dev/alt236/codeplasteragetestapp/classparsing/statictests/JavaStaticPrivateConstr.java @@ -1,7 +1,7 @@ -package uk.co.alt236.codeplasteragetestapp.classparsing.statictests; +package dev.alt236.codeplasteragetestapp.classparsing.statictests; +import dev.alt236.codeplasteragetestapp.TestInputLogger; import org.jetbrains.annotations.NotNull; -import uk.co.alt236.codeplasteragetestapp.TestInputLogger; public class JavaStaticPrivateConstr { diff --git a/testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/classparsing/statictests/KotlinObject.kt b/testapp/src/main/java/dev/alt236/codeplasteragetestapp/classparsing/statictests/KotlinObject.kt similarity index 85% rename from testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/classparsing/statictests/KotlinObject.kt rename to testapp/src/main/java/dev/alt236/codeplasteragetestapp/classparsing/statictests/KotlinObject.kt index 46dede9..73f8f24 100644 --- a/testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/classparsing/statictests/KotlinObject.kt +++ b/testapp/src/main/java/dev/alt236/codeplasteragetestapp/classparsing/statictests/KotlinObject.kt @@ -1,8 +1,8 @@ @file:Suppress("unused") -package uk.co.alt236.codeplasteragetestapp.classparsing.statictests +package dev.alt236.codeplasteragetestapp.classparsing.statictests -import uk.co.alt236.codeplasteragetestapp.TestInputLogger +import dev.alt236.codeplasteragetestapp.TestInputLogger object KotlinObject { fun stringArrayTest(args: Array) { diff --git a/testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/classparsing/statictests/KotlinObjectImplementingInterface.kt b/testapp/src/main/java/dev/alt236/codeplasteragetestapp/classparsing/statictests/KotlinObjectImplementingInterface.kt similarity index 82% rename from testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/classparsing/statictests/KotlinObjectImplementingInterface.kt rename to testapp/src/main/java/dev/alt236/codeplasteragetestapp/classparsing/statictests/KotlinObjectImplementingInterface.kt index d3c940b..abe7f90 100644 --- a/testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/classparsing/statictests/KotlinObjectImplementingInterface.kt +++ b/testapp/src/main/java/dev/alt236/codeplasteragetestapp/classparsing/statictests/KotlinObjectImplementingInterface.kt @@ -1,9 +1,9 @@ @file:Suppress("unused") -package uk.co.alt236.codeplasteragetestapp.classparsing.statictests +package dev.alt236.codeplasteragetestapp.classparsing.statictests -import uk.co.alt236.codeplasteragetestapp.TestInputLogger -import uk.co.alt236.codeplasteragetestapp.classparsing.arraytests.CommonArrayTests +import dev.alt236.codeplasteragetestapp.TestInputLogger +import dev.alt236.codeplasteragetestapp.classparsing.arraytests.CommonArrayTests import java.io.Serializable object KotlinObjectImplementingInterface : CommonArrayTests { diff --git a/testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/classparsing/statictests/KotlinObjectJvmStatic.kt b/testapp/src/main/java/dev/alt236/codeplasteragetestapp/classparsing/statictests/KotlinObjectJvmStatic.kt similarity index 87% rename from testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/classparsing/statictests/KotlinObjectJvmStatic.kt rename to testapp/src/main/java/dev/alt236/codeplasteragetestapp/classparsing/statictests/KotlinObjectJvmStatic.kt index d78356e..d6aefa3 100644 --- a/testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/classparsing/statictests/KotlinObjectJvmStatic.kt +++ b/testapp/src/main/java/dev/alt236/codeplasteragetestapp/classparsing/statictests/KotlinObjectJvmStatic.kt @@ -1,8 +1,8 @@ @file:Suppress("unused") -package uk.co.alt236.codeplasteragetestapp.classparsing.statictests +package dev.alt236.codeplasteragetestapp.classparsing.statictests -import uk.co.alt236.codeplasteragetestapp.TestInputLogger +import dev.alt236.codeplasteragetestapp.TestInputLogger object KotlinObjectJvmStatic { @JvmStatic diff --git a/testapp/src/main/java/dev/alt236/codeplasteragetestapp/dagger/TestDaggerInjectable.kt b/testapp/src/main/java/dev/alt236/codeplasteragetestapp/dagger/TestDaggerInjectable.kt new file mode 100644 index 0000000..8cc87ec --- /dev/null +++ b/testapp/src/main/java/dev/alt236/codeplasteragetestapp/dagger/TestDaggerInjectable.kt @@ -0,0 +1,9 @@ +package dev.alt236.codeplasteragetestapp.dagger + +import javax.inject.Inject + +class TestDaggerInjectable + @Inject + constructor() { + fun test() {} + } diff --git a/testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/dagger/TestDaggerInjectionConsumer.kt b/testapp/src/main/java/dev/alt236/codeplasteragetestapp/dagger/TestDaggerInjectionConsumer.kt similarity index 61% rename from testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/dagger/TestDaggerInjectionConsumer.kt rename to testapp/src/main/java/dev/alt236/codeplasteragetestapp/dagger/TestDaggerInjectionConsumer.kt index 02c5b7b..ea6ce11 100644 --- a/testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/dagger/TestDaggerInjectionConsumer.kt +++ b/testapp/src/main/java/dev/alt236/codeplasteragetestapp/dagger/TestDaggerInjectionConsumer.kt @@ -1,10 +1,9 @@ -package uk.co.alt236.codeplasteragetestapp.dagger +package dev.alt236.codeplasteragetestapp.dagger -import uk.co.alt236.codeplasteragetestapp.dagger.di.DaggerTestDaggerComponent +import dev.alt236.codeplasteragetestapp.dagger.di.DaggerTestDaggerComponent import javax.inject.Inject class TestDaggerInjectionConsumer { - @Inject lateinit var injectable: TestDaggerInjectable diff --git a/testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/dagger/di/TestDaggerComponent.kt b/testapp/src/main/java/dev/alt236/codeplasteragetestapp/dagger/di/TestDaggerComponent.kt similarity index 55% rename from testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/dagger/di/TestDaggerComponent.kt rename to testapp/src/main/java/dev/alt236/codeplasteragetestapp/dagger/di/TestDaggerComponent.kt index aa0cf79..794cf68 100644 --- a/testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/dagger/di/TestDaggerComponent.kt +++ b/testapp/src/main/java/dev/alt236/codeplasteragetestapp/dagger/di/TestDaggerComponent.kt @@ -1,13 +1,14 @@ -package uk.co.alt236.codeplasteragetestapp.dagger.di +package dev.alt236.codeplasteragetestapp.dagger.di import dagger.Component -import uk.co.alt236.codeplasteragetestapp.dagger.TestDaggerInjectable -import uk.co.alt236.codeplasteragetestapp.dagger.TestDaggerInjectionConsumer +import dev.alt236.codeplasteragetestapp.dagger.TestDaggerInjectable +import dev.alt236.codeplasteragetestapp.dagger.TestDaggerInjectionConsumer import javax.inject.Singleton @Component(modules = [TestDaggerModule::class]) @Singleton interface TestDaggerComponent { fun getInjectable(): TestDaggerInjectable + fun inject(consumer: TestDaggerInjectionConsumer) } diff --git a/testapp/src/main/java/dev/alt236/codeplasteragetestapp/dagger/di/TestDaggerModule.kt b/testapp/src/main/java/dev/alt236/codeplasteragetestapp/dagger/di/TestDaggerModule.kt new file mode 100644 index 0000000..0c694ab --- /dev/null +++ b/testapp/src/main/java/dev/alt236/codeplasteragetestapp/dagger/di/TestDaggerModule.kt @@ -0,0 +1,11 @@ +package dev.alt236.codeplasteragetestapp.dagger.di + +import dagger.Module +import dagger.Provides +import dev.alt236.codeplasteragetestapp.dagger.TestDaggerInjectable + +@Module +class TestDaggerModule { + @Provides + fun provideInjectable(): TestDaggerInjectable = TestDaggerInjectable() +} diff --git a/testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/tricky/KotlinWithPrivateCompanionObject.kt b/testapp/src/main/java/dev/alt236/codeplasteragetestapp/tricky/KotlinWithPrivateCompanionObject.kt similarity index 75% rename from testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/tricky/KotlinWithPrivateCompanionObject.kt rename to testapp/src/main/java/dev/alt236/codeplasteragetestapp/tricky/KotlinWithPrivateCompanionObject.kt index 23155a5..1bdc0a5 100644 --- a/testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/tricky/KotlinWithPrivateCompanionObject.kt +++ b/testapp/src/main/java/dev/alt236/codeplasteragetestapp/tricky/KotlinWithPrivateCompanionObject.kt @@ -1,11 +1,10 @@ @file:Suppress("unused") -package uk.co.alt236.codeplasteragetestapp.tricky +package dev.alt236.codeplasteragetestapp.tricky -import uk.co.alt236.codeplasteragetestapp.TestInputLogger +import dev.alt236.codeplasteragetestapp.TestInputLogger class KotlinWithPrivateCompanionObject { - fun test(arg: Int) { // This should be called TestInputLogger.log(arg) diff --git a/testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/tricky/synthetics/Comparator.kt b/testapp/src/main/java/dev/alt236/codeplasteragetestapp/tricky/synthetics/Comparator.kt similarity index 58% rename from testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/tricky/synthetics/Comparator.kt rename to testapp/src/main/java/dev/alt236/codeplasteragetestapp/tricky/synthetics/Comparator.kt index 7a6318a..5b360c1 100644 --- a/testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/tricky/synthetics/Comparator.kt +++ b/testapp/src/main/java/dev/alt236/codeplasteragetestapp/tricky/synthetics/Comparator.kt @@ -1,22 +1,24 @@ @file:Suppress("unused") -package uk.co.alt236.codeplasteragetestapp.tricky.synthetics +package dev.alt236.codeplasteragetestapp.tricky.synthetics class Comparator { - - data class DummyObject(val name: String) + data class DummyObject( + val name: String, + ) /** - * This class is an internal synthetic class generated by the Kotlin compiler, such as an anonymous class for a lambda, a SAM wrapper, a callable reference, etc. It's not a Kotlin class or interface, so the reflection library has no idea what declarations it has. Please use Java reflection to inspect this class: class uk.co.alt236.codeplasteragetestapp.unrunables.KotlinInternalSynthetic$syntheticComparator$$inlined$sortedBy$1 - * java.lang.UnsupportedOperationException: This class is an internal synthetic class generated by the Kotlin compiler, such as an anonymous class for a lambda, a SAM wrapper, a callable reference, etc. It's not a Kotlin class or interface, so the reflection library has no idea what declarations it has. Please use Java reflection to inspect this class: class uk.co.alt236.codeplasteragetestapp.unrunables.KotlinInternalSynthetic$syntheticComparator$$inlined$sortedBy$1 + * This class is an internal synthetic class generated by the Kotlin compiler, such as an anonymous class for a lambda, a SAM wrapper, a callable reference, etc. It's not a Kotlin class or interface, so the reflection library has no idea what declarations it has. Please use Java reflection to inspect this class: class dev.alt236testapp.unrunables.KotlinInternalSynthetic$syntheticComparator$$inlined$sortedBy$1 + * java.lang.UnsupportedOperationException: This class is an internal synthetic class generated by the Kotlin compiler, such as an anonymous class for a lambda, a SAM wrapper, a callable reference, etc. It's not a Kotlin class or interface, so the reflection library has no idea what declarations it has. Please use Java reflection to inspect this class: class dev.alt236testapp.unrunables.KotlinInternalSynthetic$syntheticComparator$$inlined$sortedBy$1 * */ @Suppress("UNUSED_VARIABLE") fun syntheticComparator() { - val list: List = listOf( - DummyObject("Bob"), - DummyObject("Alice"), - DummyObject("Eve") - ).sortedBy { it.name } + val list: List = + listOf( + DummyObject("Bob"), + DummyObject("Alice"), + DummyObject("Eve"), + ).sortedBy { it.name } } } diff --git a/testapp/src/main/java/dev/alt236/codeplasteragetestapp/tricky/synthetics/Inline.kt b/testapp/src/main/java/dev/alt236/codeplasteragetestapp/tricky/synthetics/Inline.kt new file mode 100644 index 0000000..4d98a90 --- /dev/null +++ b/testapp/src/main/java/dev/alt236/codeplasteragetestapp/tricky/synthetics/Inline.kt @@ -0,0 +1,17 @@ +@file:Suppress("unused") + +package dev.alt236.codeplasteragetestapp.tricky.synthetics + +class Inline { + // TODO: Fix this test +// /** +// * This class is an internal synthetic class generated by the Kotlin compiler, such as an anonymous class for a lambda, a SAM wrapper, a callable reference, etc. It's not a Kotlin class or interface, so the reflection library has no idea what declarations it has. Please use Java reflection to inspect this class: class dev.alt236testapp.unrunables.KotlinSynthetics$inlineSynthetic$1$2 +// * java.lang.UnsupportedOperationException: This class is an internal synthetic class generated by the Kotlin compiler, such as an anonymous class for a lambda, a SAM wrapper, a callable reference, etc. It's not a Kotlin class or interface, so the reflection library has no idea what declarations it has. Please use Java reflection to inspect this class: class dev.alt236testapp.unrunables.KotlinSynthetics$inlineSynthetic$1$2 +// */ +// inline fun inlineSynthetic(): Call = +// mockk>().also { call -> +// every { call.enqueue(any()) }.answers { +// (arg(0) as Callback).onResponse(call, mockk()) +// } +// } +} diff --git a/testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/dagger/TestDaggerInjectable.kt b/testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/dagger/TestDaggerInjectable.kt deleted file mode 100644 index a0a44e0..0000000 --- a/testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/dagger/TestDaggerInjectable.kt +++ /dev/null @@ -1,8 +0,0 @@ -package uk.co.alt236.codeplasteragetestapp.dagger - -import javax.inject.Inject - -class TestDaggerInjectable @Inject constructor() { - - fun test() {} -} diff --git a/testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/dagger/di/TestDaggerModule.kt b/testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/dagger/di/TestDaggerModule.kt deleted file mode 100644 index 18e1433..0000000 --- a/testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/dagger/di/TestDaggerModule.kt +++ /dev/null @@ -1,14 +0,0 @@ -package uk.co.alt236.codeplasteragetestapp.dagger.di - -import dagger.Module -import dagger.Provides -import uk.co.alt236.codeplasteragetestapp.dagger.TestDaggerInjectable - -@Module -class TestDaggerModule { - - @Provides - fun provideInjectable(): TestDaggerInjectable { - return TestDaggerInjectable() - } -} diff --git a/testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/tricky/synthetics/Inline.kt b/testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/tricky/synthetics/Inline.kt deleted file mode 100644 index 6ed33be..0000000 --- a/testapp/src/main/java/uk/co/alt236/codeplasteragetestapp/tricky/synthetics/Inline.kt +++ /dev/null @@ -1,22 +0,0 @@ -@file:Suppress("unused") - -package uk.co.alt236.codeplasteragetestapp.tricky.synthetics - -import io.mockk.every -import io.mockk.mockk -import retrofit2.Call -import retrofit2.Callback - -class Inline { - - /** - * This class is an internal synthetic class generated by the Kotlin compiler, such as an anonymous class for a lambda, a SAM wrapper, a callable reference, etc. It's not a Kotlin class or interface, so the reflection library has no idea what declarations it has. Please use Java reflection to inspect this class: class uk.co.alt236.codeplasteragetestapp.unrunables.KotlinSynthetics$inlineSynthetic$1$2 - * java.lang.UnsupportedOperationException: This class is an internal synthetic class generated by the Kotlin compiler, such as an anonymous class for a lambda, a SAM wrapper, a callable reference, etc. It's not a Kotlin class or interface, so the reflection library has no idea what declarations it has. Please use Java reflection to inspect this class: class uk.co.alt236.codeplasteragetestapp.unrunables.KotlinSynthetics$inlineSynthetic$1$2 - */ - inline fun inlineSynthetic(): Call = - mockk>().also { call -> - every { call.enqueue(any()) }.answers { - (arg(0) as Callback).onResponse(call, mockk()) - } - } -} diff --git a/testapp/src/test/java/uk/co/alt236/codeplasteragetestapp/SuperDuperAllTests.kt b/testapp/src/test/java/dev/alt236/codeplasteragetestapp/SuperDuperAllTests.kt similarity index 67% rename from testapp/src/test/java/uk/co/alt236/codeplasteragetestapp/SuperDuperAllTests.kt rename to testapp/src/test/java/dev/alt236/codeplasteragetestapp/SuperDuperAllTests.kt index 26270c2..3a8af08 100644 --- a/testapp/src/test/java/uk/co/alt236/codeplasteragetestapp/SuperDuperAllTests.kt +++ b/testapp/src/test/java/dev/alt236/codeplasteragetestapp/SuperDuperAllTests.kt @@ -1,22 +1,21 @@ -package uk.co.alt236.codeplasteragetestapp +package dev.alt236.codeplasteragetestapp +import dev.alt236.codeplasterage.CodeplasterageTestRunner +import dev.alt236.codeplasterage.config.Config +import dev.alt236.codeplasterage.tests.PlasterageTests +import dev.alt236.codeplasteragetestapp.libcomponents.TestDummyDataFactory import org.junit.Assert.assertTrue import org.junit.Test import org.junit.runner.RunWith -import uk.co.alt236.codeplasterage.CodeplasterageTestRunner -import uk.co.alt236.codeplasterage.config.Config -import uk.co.alt236.codeplasterage.tests.PlasterageTests -import uk.co.alt236.codeplasteragetestapp.libcomponents.TestDummyDataFactory @RunWith(CodeplasterageTestRunner::class) @Config( includeClassNamePatterns = [TestConstants.TEST_INCLUDE_CLASSNAME_PATTERN], ignoreErrors = TestConstants.IGNORE_ERRORS, debug = TestConstants.DEBUG, - customDummyDataFactories = [TestDummyDataFactory::class] + customDummyDataFactories = [TestDummyDataFactory::class], ) class SuperDuperAllTests : PlasterageTests { - @Test override fun testToString() { // Empty by design diff --git a/testapp/src/test/java/uk/co/alt236/codeplasteragetestapp/SuperDuperHashCodeTest.kt b/testapp/src/test/java/dev/alt236/codeplasteragetestapp/SuperDuperHashCodeTest.kt similarity index 60% rename from testapp/src/test/java/uk/co/alt236/codeplasteragetestapp/SuperDuperHashCodeTest.kt rename to testapp/src/test/java/dev/alt236/codeplasteragetestapp/SuperDuperHashCodeTest.kt index ebe406b..b1a5eff 100644 --- a/testapp/src/test/java/uk/co/alt236/codeplasteragetestapp/SuperDuperHashCodeTest.kt +++ b/testapp/src/test/java/dev/alt236/codeplasteragetestapp/SuperDuperHashCodeTest.kt @@ -1,19 +1,18 @@ -package uk.co.alt236.codeplasteragetestapp +package dev.alt236.codeplasteragetestapp +import dev.alt236.codeplasterage.CodeplasterageTestRunner +import dev.alt236.codeplasterage.config.Config +import dev.alt236.codeplasterage.tests.PlasterageTestHashCode import org.junit.Test import org.junit.runner.RunWith -import uk.co.alt236.codeplasterage.CodeplasterageTestRunner -import uk.co.alt236.codeplasterage.config.Config -import uk.co.alt236.codeplasterage.tests.PlasterageTestHashCode @RunWith(CodeplasterageTestRunner::class) class SuperDuperHashCodeTest : PlasterageTestHashCode { - @Test @Config( includeClassNamePatterns = [TestConstants.TEST_INCLUDE_CLASSNAME_PATTERN], ignoreErrors = TestConstants.IGNORE_ERRORS, - debug = TestConstants.DEBUG + debug = TestConstants.DEBUG, ) override fun testHashCode() { // Empty by design diff --git a/testapp/src/test/java/uk/co/alt236/codeplasteragetestapp/SuperDuperMethodCallingTest.kt b/testapp/src/test/java/dev/alt236/codeplasteragetestapp/SuperDuperMethodCallingTest.kt similarity index 62% rename from testapp/src/test/java/uk/co/alt236/codeplasteragetestapp/SuperDuperMethodCallingTest.kt rename to testapp/src/test/java/dev/alt236/codeplasteragetestapp/SuperDuperMethodCallingTest.kt index fc50ecb..658bab9 100644 --- a/testapp/src/test/java/uk/co/alt236/codeplasteragetestapp/SuperDuperMethodCallingTest.kt +++ b/testapp/src/test/java/dev/alt236/codeplasteragetestapp/SuperDuperMethodCallingTest.kt @@ -1,21 +1,20 @@ -package uk.co.alt236.codeplasteragetestapp +package dev.alt236.codeplasteragetestapp +import dev.alt236.codeplasterage.CodeplasterageTestRunner +import dev.alt236.codeplasterage.config.Config +import dev.alt236.codeplasterage.tests.PlasterageTestMethodCalling +import dev.alt236.codeplasteragetestapp.libcomponents.TestDummyDataFactory import org.junit.Test import org.junit.runner.RunWith -import uk.co.alt236.codeplasterage.CodeplasterageTestRunner -import uk.co.alt236.codeplasterage.config.Config -import uk.co.alt236.codeplasterage.tests.PlasterageTestMethodCalling -import uk.co.alt236.codeplasteragetestapp.libcomponents.TestDummyDataFactory @RunWith(CodeplasterageTestRunner::class) class SuperDuperMethodCallingTest : PlasterageTestMethodCalling { - @Test @Config( includeClassNamePatterns = [TestConstants.TEST_INCLUDE_CLASSNAME_PATTERN], ignoreErrors = TestConstants.IGNORE_ERRORS, debug = TestConstants.DEBUG, - customDummyDataFactories = [TestDummyDataFactory::class] + customDummyDataFactories = [TestDummyDataFactory::class], ) override fun testMethodCalling() { // Empty by design diff --git a/testapp/src/test/java/uk/co/alt236/codeplasteragetestapp/SuperDuperToEqualsTest.kt b/testapp/src/test/java/dev/alt236/codeplasteragetestapp/SuperDuperToEqualsTest.kt similarity index 60% rename from testapp/src/test/java/uk/co/alt236/codeplasteragetestapp/SuperDuperToEqualsTest.kt rename to testapp/src/test/java/dev/alt236/codeplasteragetestapp/SuperDuperToEqualsTest.kt index 0619ab5..7e67d15 100644 --- a/testapp/src/test/java/uk/co/alt236/codeplasteragetestapp/SuperDuperToEqualsTest.kt +++ b/testapp/src/test/java/dev/alt236/codeplasteragetestapp/SuperDuperToEqualsTest.kt @@ -1,19 +1,18 @@ -package uk.co.alt236.codeplasteragetestapp +package dev.alt236.codeplasteragetestapp +import dev.alt236.codeplasterage.CodeplasterageTestRunner +import dev.alt236.codeplasterage.config.Config +import dev.alt236.codeplasterage.tests.PlasterageTestEquals import org.junit.Test import org.junit.runner.RunWith -import uk.co.alt236.codeplasterage.CodeplasterageTestRunner -import uk.co.alt236.codeplasterage.config.Config -import uk.co.alt236.codeplasterage.tests.PlasterageTestEquals @RunWith(CodeplasterageTestRunner::class) class SuperDuperToEqualsTest : PlasterageTestEquals { - @Test @Config( includeClassNamePatterns = [TestConstants.TEST_INCLUDE_CLASSNAME_PATTERN], ignoreErrors = TestConstants.IGNORE_ERRORS, - debug = TestConstants.DEBUG + debug = TestConstants.DEBUG, ) override fun testEquals() { // Empty by design diff --git a/testapp/src/test/java/uk/co/alt236/codeplasteragetestapp/SuperDuperToStringTest.kt b/testapp/src/test/java/dev/alt236/codeplasteragetestapp/SuperDuperToStringTest.kt similarity index 60% rename from testapp/src/test/java/uk/co/alt236/codeplasteragetestapp/SuperDuperToStringTest.kt rename to testapp/src/test/java/dev/alt236/codeplasteragetestapp/SuperDuperToStringTest.kt index ab75d96..3eb7334 100644 --- a/testapp/src/test/java/uk/co/alt236/codeplasteragetestapp/SuperDuperToStringTest.kt +++ b/testapp/src/test/java/dev/alt236/codeplasteragetestapp/SuperDuperToStringTest.kt @@ -1,19 +1,18 @@ -package uk.co.alt236.codeplasteragetestapp +package dev.alt236.codeplasteragetestapp +import dev.alt236.codeplasterage.CodeplasterageTestRunner +import dev.alt236.codeplasterage.config.Config +import dev.alt236.codeplasterage.tests.PlasterageTestToString import org.junit.Test import org.junit.runner.RunWith -import uk.co.alt236.codeplasterage.CodeplasterageTestRunner -import uk.co.alt236.codeplasterage.config.Config -import uk.co.alt236.codeplasterage.tests.PlasterageTestToString @RunWith(CodeplasterageTestRunner::class) class SuperDuperToStringTest : PlasterageTestToString { - @Test @Config( includeClassNamePatterns = [TestConstants.TEST_INCLUDE_CLASSNAME_PATTERN], ignoreErrors = TestConstants.IGNORE_ERRORS, - debug = TestConstants.DEBUG + debug = TestConstants.DEBUG, ) override fun testToString() { // Empty by design diff --git a/testapp/src/test/java/uk/co/alt236/codeplasteragetestapp/TestConstants.kt b/testapp/src/test/java/dev/alt236/codeplasteragetestapp/TestConstants.kt similarity index 79% rename from testapp/src/test/java/uk/co/alt236/codeplasteragetestapp/TestConstants.kt rename to testapp/src/test/java/dev/alt236/codeplasteragetestapp/TestConstants.kt index d9eff74..b3ecee9 100644 --- a/testapp/src/test/java/uk/co/alt236/codeplasteragetestapp/TestConstants.kt +++ b/testapp/src/test/java/dev/alt236/codeplasteragetestapp/TestConstants.kt @@ -1,4 +1,4 @@ -package uk.co.alt236.codeplasteragetestapp +package dev.alt236.codeplasteragetestapp object TestConstants { const val TEST_INCLUDE_CLASSNAME_PATTERN = ".*codeplasteragetestapp.*" diff --git a/testapp/src/test/java/dev/alt236/codeplasteragetestapp/libcomponents/CheckForbiddenNameTest.kt b/testapp/src/test/java/dev/alt236/codeplasteragetestapp/libcomponents/CheckForbiddenNameTest.kt new file mode 100644 index 0000000..1f330f8 --- /dev/null +++ b/testapp/src/test/java/dev/alt236/codeplasteragetestapp/libcomponents/CheckForbiddenNameTest.kt @@ -0,0 +1,37 @@ +package dev.alt236.codeplasteragetestapp.libcomponents + +import dev.alt236.codeplasterage.reflection.classfinder.filters.checks.CheckForbiddenName +import dev.alt236.codeplasteragetestapp.dagger.di.DaggerTestDaggerComponent +import org.junit.Assert.assertEquals +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith +import org.junit.runners.Parameterized + +@RunWith(value = Parameterized::class) +class CheckForbiddenNameTest( + private val clazz: Class<*>, + private val expected: Boolean, +) { + private lateinit var sut: CheckForbiddenName + + @Before + fun setUp() { + sut = CheckForbiddenName() + } + + @Test + fun testHasForbiddenName() { + assertEquals(expected, sut.isForbidden(clazz)) + } + + companion object { + @JvmStatic + @Parameterized.Parameters(name = "{index}: isValid({0})={1}") + fun data(): Iterable> = + arrayListOf( + arrayOf(String::class.java, false), + arrayOf(DaggerTestDaggerComponent::class.java, true), + ) + } +} diff --git a/testapp/src/test/java/uk/co/alt236/codeplasteragetestapp/libcomponents/GlobalClassFilterTest.kt b/testapp/src/test/java/dev/alt236/codeplasteragetestapp/libcomponents/GlobalClassFilterTest.kt similarity index 73% rename from testapp/src/test/java/uk/co/alt236/codeplasteragetestapp/libcomponents/GlobalClassFilterTest.kt rename to testapp/src/test/java/dev/alt236/codeplasteragetestapp/libcomponents/GlobalClassFilterTest.kt index bef53fa..69ed69a 100644 --- a/testapp/src/test/java/uk/co/alt236/codeplasteragetestapp/libcomponents/GlobalClassFilterTest.kt +++ b/testapp/src/test/java/dev/alt236/codeplasteragetestapp/libcomponents/GlobalClassFilterTest.kt @@ -1,17 +1,16 @@ -package uk.co.alt236.codeplasteragetestapp.libcomponents - +package dev.alt236.codeplasteragetestapp.libcomponents + +import dev.alt236.codeplasterage.reflection.classfinder.ClassFilterResult +import dev.alt236.codeplasterage.reflection.classfinder.filters.GlobalClassFilter +import dev.alt236.codeplasteragetestapp.dagger.TestDaggerInjectable_Factory +import dev.alt236.codeplasteragetestapp.dagger.TestDaggerInjectionConsumer_MembersInjector +import dev.alt236.codeplasteragetestapp.dagger.di.DaggerTestDaggerComponent +import dev.alt236.codeplasteragetestapp.dagger.di.TestDaggerModule_ProvideInjectableFactory import org.junit.Before import org.junit.Test import org.junit.jupiter.api.Assertions.assertInstanceOf -import uk.co.alt236.codeplasterage.reflection.classfinder.ClassFilterResult -import uk.co.alt236.codeplasterage.reflection.classfinder.filters.GlobalClassFilter -import uk.co.alt236.codeplasteragetestapp.dagger.TestDaggerInjectable_Factory -import uk.co.alt236.codeplasteragetestapp.dagger.TestDaggerInjectionConsumer_MembersInjector -import uk.co.alt236.codeplasteragetestapp.dagger.di.DaggerTestDaggerComponent -import uk.co.alt236.codeplasteragetestapp.dagger.di.TestDaggerModule_ProvideInjectableFactory class GlobalClassFilterTest { - private lateinit var sut: GlobalClassFilter @Before diff --git a/testapp/src/test/java/dev/alt236/codeplasteragetestapp/libcomponents/TestDummyDataFactory.kt b/testapp/src/test/java/dev/alt236/codeplasteragetestapp/libcomponents/TestDummyDataFactory.kt new file mode 100644 index 0000000..b118951 --- /dev/null +++ b/testapp/src/test/java/dev/alt236/codeplasteragetestapp/libcomponents/TestDummyDataFactory.kt @@ -0,0 +1,17 @@ +package dev.alt236.codeplasteragetestapp.libcomponents + +import dev.alt236.codeplasterage.datafactory.DataFactoryResult +import dev.alt236.codeplasterage.datafactory.SubDataFactory +import dev.alt236.codeplasteragetestapp.dagger.TestDaggerInjectable + +class TestDummyDataFactory( + debug: Boolean, +) : SubDataFactory(debug) { + override fun canCreateDataFor(clazz: Class<*>): Boolean = clazz == TestDaggerInjectable::class.java + + override fun getDummyData(clazz: Class<*>): DataFactoryResult<*> = + when (clazz) { + TestDaggerInjectable::class.java -> DataFactoryResult.Valid(TestDaggerInjectable(), clazz) + else -> DataFactoryResult.createUnableToCreateInstanceError(this, clazz) + } +} diff --git a/testapp/src/test/java/uk/co/alt236/codeplasteragetestapp/libcomponents/TestDummyDataFactory.kt b/testapp/src/test/java/uk/co/alt236/codeplasteragetestapp/libcomponents/TestDummyDataFactory.kt deleted file mode 100644 index b7e87c5..0000000 --- a/testapp/src/test/java/uk/co/alt236/codeplasteragetestapp/libcomponents/TestDummyDataFactory.kt +++ /dev/null @@ -1,18 +0,0 @@ -package uk.co.alt236.codeplasteragetestapp.libcomponents - -import uk.co.alt236.codeplasterage.datafactory.DataFactoryResult -import uk.co.alt236.codeplasterage.datafactory.SubDataFactory -import uk.co.alt236.codeplasteragetestapp.dagger.TestDaggerInjectable - -class TestDummyDataFactory(debug: Boolean) : SubDataFactory(debug) { - override fun canCreateDataFor(clazz: Class<*>): Boolean { - return clazz == TestDaggerInjectable::class.java - } - - override fun getDummyData(clazz: Class<*>): DataFactoryResult<*> { - return when (clazz) { - TestDaggerInjectable::class.java -> DataFactoryResult.Valid(TestDaggerInjectable(), clazz) - else -> DataFactoryResult.createUnableToCreateInstanceError(this, clazz) - } - } -}