TestMu 2025 - The Largest Virtual Software Testing Conference is Back | 50,000+ Attendees

How to use runtime class of io.kotest.engine.tags package

Best Kotest code snippet using io.kotest.engine.tags.runtime

Kotest.kt

...112   override fun executeTests() {113      //val testResultsDir = project.buildDir.resolve("test-results")114      val sourceset = project.javaTestSourceSet() ?: return115      val result = try {116         val exec = exec(sourceset.runtimeClasspath)117         if (isIntellij()) rerouteTeamCityListener(exec)118         exec.execute()119      } catch (e: Exception) {120         println(e)121         e.printStackTrace()122         throw GradleException("Test process failed", e)123      }124      if (result.exitValue != 0) {125         throw GradleException("There were test failures")126      }127   }128}...

build.gradle.kts

Source: build.gradle.kts

...11repositories {12    jcenter()13}14dependencies {15    implementation(gradleApi()) // Implementation: available at compile and runtime, non transitive16    testImplementation(gradleTestKit()) // Test implementation: available for testing compile and runtime17    testImplementation("io.kotest:kotest-runner-junit5:4.2.5") // for kotest framework18    testImplementation("io.kotest:kotest-assertions-core:4.2.5") // for kotest core assertions19    testImplementation("io.kotest:kotest-assertions-core-jvm:4.2.5") // for kotest core jvm assertions20}21tasks.withType<Test> {22    useJUnitPlatform() // Use JUnit 5 engine23    testLogging.showStandardStreams = true24    testLogging {25        showCauses = true26        showStackTraces = true27        showStandardStreams = true28        events(*org.gradle.api.tasks.testing.logging.TestLogEvent.values())29        exceptionFormat = org.gradle.api.tasks.testing.logging.TestExceptionFormat.FULL30    }31}32// This task creates a file with a classpath descriptor, to be used in tests33val createClasspathManifest by tasks.registering {34    val outputDir = file("$buildDir/$name")35    inputs.files(sourceSets.main.get().runtimeClasspath)36    outputs.dir(outputDir)37    doLast {38        outputDir.mkdirs()39        file("$outputDir/plugin-classpath.txt").writeText(sourceSets.main.get().runtimeClasspath.joinToString("\n"))40    }41}42// Add the classpath file to the test runtime classpath43dependencies {44    // This way "createClasspathManifest" is always executed before the tests!45    // Gradle auto-resolves dependencies if there are dependencies on inputs/outputs46    testRuntimeOnly(files(createClasspathManifest))47}48pluginBundle { // These settings are set for the whole plugin bundle49    website = "https://danysk.github.io/Course-Laboratory-of-Software-Systems/"50    vcsUrl = "https://github.com/DanySK/Course-Laboratory-of-Software-Systems"51    tags = listOf("example", "greetings", "lss", "unibo")52}53gradlePlugin {54    plugins {55        create("GradleLatex") { // One entry per plugin56            id = "${project.group}.${project.name}"...

TestEngine.kt

Source: TestEngine.kt

...8import io.kotest.core.project.TestSuite9import io.kotest.engine.interceptors.EngineContext10import io.kotest.engine.interceptors.EngineInterceptor11import io.kotest.engine.listener.TestEngineListener12import io.kotest.engine.tags.runtimeTags13import io.kotest.mpp.Logger14data class EngineResult(val errors: List<Throwable>) {15   companion object {16      val empty = EngineResult(emptyList())17   }18   fun addError(t: Throwable): EngineResult {19      return EngineResult(errors + t)20   }21}22@KotestInternal23data class TestEngineConfig(24   val listener: TestEngineListener,25   val interceptors: List<EngineInterceptor>,26   val configuration: ProjectConfiguration,27   val explicitTags: TagExpression?,28)29/**30 * Multiplatform Kotest Test Engine.31 */32@KotestInternal33class TestEngine(private val config: TestEngineConfig) {34   private val logger = Logger(this::class)35   /**36    * Starts execution of the given [TestSuite], intercepting calls via [EngineInterceptor]s.37    *38    * It is recommended that this method is not invoked, but instead the engine39    * is launched via the [TestEngineLauncher].40    */41   @OptIn(KotestInternal::class, ExperimentalKotest::class)42   internal suspend fun execute(suite: TestSuite): EngineResult {43      logger.log { Pair(null, "Executing test suite with ${suite.specs.size} specs") }44      val innerExecute: suspend (EngineContext) -> EngineResult = { context ->45         val scheduler = when (platform) {46            Platform.JVM -> ConcurrentTestSuiteScheduler(47               config.configuration.concurrentSpecs ?: config.configuration.parallelism,48               context,49            )50            Platform.JS -> SequentialTestSuiteScheduler(context)51            Platform.Native -> SequentialTestSuiteScheduler(context)52         }53         scheduler.schedule(context.suite)54      }55      logger.log { Pair(null, "${config.interceptors.size} engine interceptors") }56      val execute = config.interceptors.foldRight(innerExecute) { extension, next ->57         { context -> extension.intercept(context, next) }58      }59      val tags = config.configuration.runtimeTags()60      logger.log { Pair(null, "TestEngine: Active tags: ${tags.expression}") }61      return execute(EngineContext(suite, config.listener, tags, config.configuration))62   }63}...

RequiresTagSpecInterceptor.kt

Source: RequiresTagSpecInterceptor.kt

...12import io.kotest.engine.listener.TestEngineListener13import io.kotest.engine.spec.SpecExtensions14import io.kotest.engine.tags.isActive15import io.kotest.engine.tags.parse16import io.kotest.engine.tags.runtimeTags17import io.kotest.mpp.annotation18/**19 * A [SpecFilter] which will ignore specs if they are annotated with @[RequiresTag]20 * and those tags are not present in the runtime tags.21 */22internal class RequiresTagSpecInterceptor(23   private val listener: TestEngineListener,24   private val configuration: ProjectConfiguration,25   private val registry: ExtensionRegistry,26) : SpecRefInterceptor {27   override suspend fun intercept(28      ref: SpecRef,29      fn: suspend (SpecRef) -> Result<Map<TestCase, TestResult>>30   ): Result<Map<TestCase, TestResult>> {31      return when (val annotation = ref.kclass.annotation<RequiresTag>()) {32         null -> fn(ref)33         else -> {34            val requiredTags = annotation.wrapper.map { NamedTag(it) }.toSet()35            val expr = configuration.runtimeTags().parse()36            if (requiredTags.isEmpty() || expr.isActive(requiredTags)) {37               fn(ref)38            } else {39               runCatching { listener.specIgnored(ref.kclass, "Disabled by @RequiresTag") }40                  .flatMap { SpecExtensions(registry).ignored(ref.kclass, "Disabled by @RequiresTag") }41                  .map { emptyMap() }42            }43         }44      }45   }46}...

RuntimeTagExtensionTest.kt

Source: RuntimeTagExtensionTest.kt

...33   }34}35private class TestWithTag : FunSpec() {36   init {37      test("Test marked with a runtime excluded tag").config(tags = setOf(MyRuntimeExcludedTag)) {38         fail("boom")39      }40   }41}...

TagsExcludedDiscoveryExtension.kt

Source: TagsExcludedDiscoveryExtension.kt

...9import io.kotest.engine.listener.TestEngineListener10import io.kotest.engine.spec.SpecExtensions11import io.kotest.engine.tags.isPotentiallyActive12import io.kotest.engine.tags.parse13import io.kotest.engine.tags.runtimeTags14/**15 * Filters any [Spec] that can be eagerly excluded based on the @[TagExpression] annotation at the class level.16 */17class TagsExcludedSpecInterceptor(18   private val listener: TestEngineListener,19   private val conf: ProjectConfiguration,20) : SpecRefInterceptor {21   private val extensions = SpecExtensions(conf.registry)22   override suspend fun intercept(23      ref: SpecRef,24      fn: suspend (SpecRef) -> Result<Map<TestCase, TestResult>>25   ): Result<Map<TestCase, TestResult>> {26      val potentiallyActive = conf.runtimeTags().parse().isPotentiallyActive(ref.kclass)27      return if (potentiallyActive) {28         fn(ref)29      } else {30         runCatching { listener.specIgnored(ref.kclass, null) }31            .flatMap { extensions.ignored(ref.kclass, "Skipped by tags") }32            .map { emptyMap() }33      }34   }35}

runtime

Using AI Code Generation

1    val runtimeClass = Class.forName("io.kotest.engine.tags.TagExpression")2    val instance = runtimeClass.getConstructor(String::class.java).newInstance("abc")3    println(instance)4    val runtimeClass = Class.forName("io.kotest.core.spec.style.scopes.RootContext")5    val instance = runtimeClass.getConstructor().newInstance()6    println(instance)7    val runtimeClass = Class.forName("io.kotest.core.spec.style.scopes.RootContext")8    val instance = runtimeClass.getConstructor().newInstance()9    println(instance)10}11    at java.net.URLClassLoader.findClass(URLClassLoader.java:382)12    at java.lang.ClassLoader.loadClass(ClassLoader.java:418)13    at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:355)14    at java.lang.ClassLoader.loadClass(ClassLoader.java:351)15    at java.lang.Class.forName0(Native Method)16    at java.lang.Class.forName(Class.java:348)17    at com.example.MainKt.main(Main.kt:9)18    at com.example.MainKt.main(Main.kt)

runtime

Using AI Code Generation

1    val tags = TestTag::class.sealedSubclasses.map { it.objectInstance as TestTag }2    val styles = SpecStyle::class.sealedSubclasses.map { it.objectInstance as SpecStyle }3    val configs = TestCaseConfig::class.sealedSubclasses.map { it.objectInstance as TestCaseConfig }4    val levels = TestCaseSeverityLevel::class.sealedSubclasses.map { it.objectInstance as TestCaseSeverityLevel }5    val orders = TestCaseOrder::class.sealedSubclasses.map { it.objectInstance as TestCaseOrder }6    val configs = TestCaseConfig::class.sealedSubclasses.map { it.objectInstance as TestCaseConfig }7    val levels = TestCaseSeverityLevel::class.sealedSubclasses.map { it.objectInstance as TestCaseSeverityLevel }8    val orders = TestCaseOrder::class.sealedSubclasses.map { it.objectInstance as TestCaseOrder }9    val configs = TestCaseConfig::class.sealedSubclasses.map { it.objectInstance as TestCaseConfig }10    val levels = TestCaseSeverityLevel::class.sealedSubclasses.map { it.objectInstance as TestCaseSeverityLevel }11    val orders = TestCaseOrder::class.sealedSubclasses.map { it.objectInstance as TestCaseOrder }12    val configs = TestCaseConfig::class.sealedSubclasses.map { it.objectInstance as TestCaseConfig }13    val levels = TestCaseSeverityLevel::class.sealedSubclasses.map { it.objectInstance as TestCase

Blogs

Check out the latest blogs from LambdaTest on this topic:

What is coaching leadership

Coaching is a term that is now being mentioned a lot more in the leadership space. Having grown successful teams I thought that I was well acquainted with this subject.

Assessing Risks in the Scrum Framework

Software Risk Management (SRM) combines a set of tools, processes, and methods for managing risks in the software development lifecycle. In SRM, we want to make informed decisions about what can go wrong at various levels within a company (e.g., business, project, and software related).

Testing in Production: A Detailed Guide

When most firms employed a waterfall development model, it was widely joked about in the industry that Google kept its products in beta forever. Google has been a pioneer in making the case for in-production testing. Traditionally, before a build could go live, a tester was responsible for testing all scenarios, both defined and extempore, in a testing environment. However, this concept is evolving on multiple fronts today. For example, the tester is no longer testing alone. Developers, designers, build engineers, other stakeholders, and end users, both inside and outside the product team, are testing the product and providing feedback.

Using ChatGPT for Test Automation

ChatGPT broke all Internet records by going viral in the first week of its launch. A million users in 5 days are unprecedented. A conversational AI that can answer natural language-based questions and create poems, write movie scripts, write social media posts, write descriptive essays, and do tons of amazing things. Our first thought when we got access to the platform was how to use this amazing platform to make the lives of web and mobile app testers easier. And most importantly, how we can use ChatGPT for automated testing.

What exactly do Scrum Masters perform throughout the course of a typical day

Many theoretical descriptions explain the role of the Scrum Master as a vital member of the Scrum team. However, these descriptions do not provide an honest answer to the fundamental question: “What are the day-to-day activities of a Scrum Master?”

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.