Unlock 30% off on Manual Testing Annual Plans this Holiday Season.

Copied to Clipboard!

How to use Expression.isPotentiallyActive method of io.kotest.engine.tags.active class

Best Kotest code snippet using io.kotest.engine.tags.active.Expression.isPotentiallyActive

active.kt

Source:active.kt

1package io.kotest.engine.tags2import io.kotest.core.Tag3import io.kotest.core.spec.Spec4import kotlin.reflect.KClass5/**6 * Returns true if the given [Spec] class could contain an active test based on further tags.7 * Returns false if the spec has been explicitly excluded and should not be instantiated.8 */9fun Expression?.isPotentiallyActive(kclass: KClass<out Spec>): Boolean {10   // nothing is excluded if the expression is null11   if (this == null) return true12   // if the class is not tagged then it is not excluded13   val tags = kclass.tags()14   if (tags.isEmpty()) return true15   return isPotentiallyActive(tags.toSet()) ?: true16}17internal fun Expression.isPotentiallyActive(tags: Set<Tag>): Boolean? {18   return when (this) {19      is Expression.Or -> left.isPotentiallyActive(tags) ?: true || right.isPotentiallyActive(tags) ?: true20      is Expression.And -> left.isPotentiallyActive(tags) ?: true && right.isPotentiallyActive(tags) ?: true21      is Expression.Not -> expr.isPotentiallyActive(tags)?.not()22      is Expression.Identifier -> if (tags.map { it.name }.contains(ident)) true else null23   }24}25/**26 * Returns true if the the given tag should be considered active based27 * on the current tag expression.28 */29fun Expression?.isActive(tag: Tag): Boolean = isActive(setOf(tag))30/**31 * Returns true if the the given set of tags should be considered active based32 * on the current tag expression.33 */34fun Expression?.isActive(tags: Set<Tag>): Boolean {35   // everything is always active when no tag expression is provided36   if (this == null) return true37   return evaluate(tags, this)38}39private fun evaluate(tags: Set<Tag>, expression: Expression): Boolean {40   return when (expression) {41      is Expression.Or -> evaluate(tags, expression.left) || evaluate(tags, expression.right)42      is Expression.And -> evaluate(tags, expression.left) && evaluate(tags, expression.right)43      is Expression.Not -> !evaluate(tags, expression.expr)44      is Expression.Identifier -> tags.map { it.name }.contains(expression.ident)45   }46}...

TagsExcludedDiscoveryExtension.kt

Source:TagsExcludedDiscoveryExtension.kt

1package io.kotest.engine.spec.interceptor2import io.kotest.common.flatMap3import io.kotest.core.TagExpression4import io.kotest.core.config.ProjectConfiguration5import io.kotest.core.spec.Spec6import io.kotest.core.spec.SpecRef7import io.kotest.core.test.TestCase8import io.kotest.core.test.TestResult9import 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}...

Expression.isPotentiallyActive

Using AI Code Generation

1+private fun isTagActive(tag: String): Boolean {2+   return Expression.isPotentiallyActive(tag)3+}4+private fun isTagActive(tag: Tag): Boolean {5+   return Expression.isPotentiallyActive(tag.name)6+}7+private fun isTagActive(tag: String, tags: Tags): Boolean {8+   return Expression.isPotentiallyActive(tag, tags)9+}10+private fun isTagActive(tag: Tag, tags: Tags): Boolean {11+   return Expression.isPotentiallyActive(tag.name, tags)12+}13+private fun isTagActive(tag: String, tags: Set<Tag>): Boolean {14+   return Expression.isPotentiallyActive(tag, tags)15+}16+private fun isTagActive(tag: Tag, tags: Set<Tag>): Boolean {17+   return Expression.isPotentiallyActive(tag.name, tags)18+}19+private fun isTagActive(tag: String, tags: Array<Tag>): Boolean {20+   return Expression.isPotentiallyActive(tag, tags)21+}22+private fun isTagActive(tag: Tag, tags: Array<Tag>): Boolean {23+   return Expression.isPotentiallyActive(tag.name,

Expression.isPotentiallyActive

Using AI Code Generation

1@ActiveIf(ActiveIfTest::class)2class ActiveIfTest {3    companion object : Expression {4        override fun isPotentiallyActive(): Boolean = true5    }6    fun test1() {7        println("test1")8    }9    fun test2() {10        println("test2")11    }12}

Expression.isPotentiallyActive

Using AI Code Generation

1class ActiveTagTest : FreeSpec({2    "isPotentiallyActive" - {3        "should return true if no tags are active" - {4            isPotentiallyActive(listOf(), listOf()) shouldBe true5            isPotentiallyActive(listOf(), listOf("foo")) shouldBe true6            isPotentiallyActive(listOf(), listOf("!foo")) shouldBe true7        }8        "should return true if active tags are empty and the expression is empty" - {9            isPotentiallyActive(listOf(), listOf()) shouldBe true10        }11        "should return false if active tags are empty and the expression is not empty" - {12            isPotentiallyActive(listOf(), listOf("foo")) shouldBe false13            isPotentiallyActive(listOf(), listOf("!foo")) shouldBe false14        }15        "should return true if active tags are not empty and the expression is empty" - {16            isPotentiallyActive(listOf("foo"), listOf()) shouldBe true17            isPotentiallyActive(listOf("!foo"), listOf()) shouldBe true18        }19        "should return true if active tags contains the expression" - {20            isPotentiallyActive(listOf("foo"), listOf("foo")) shouldBe true21            isPotentiallyActive(listOf("foo", "bar"), listOf("foo")) shouldBe true22            isPotentiallyActive(listOf("foo", "bar"), listOf("bar")) shouldBe true23            isPotentiallyActive(listOf("foo", "bar"), listOf("!foo")) shouldBe true24            isPotentiallyActive(listOf("foo", "bar"), listOf("!bar")) shouldBe true25        }26        "should return false if active tags does not contain the expression" - {27            isPotentiallyActive(listOf("foo"), listOf("bar")) shouldBe false28            isPotentiallyActive(listOf("foo"), listOf("!foo")) shouldBe false29            isPotentiallyActive(listOf("foo", "bar"), listOf("foo", "bar")) shouldBe false30            isPotentiallyActive(listOf("foo", "bar"), listOf("!foo", "!bar")) shouldBe false31        }32        "should return true if active tags contains any of the expressions" - {33            isPotentiallyActive(listOf("foo"), listOf("foo", "bar")) shouldBe true34            isPotentiallyActive(listOf("foo"), listOf("bar", "foo")) shouldBe true35            isPotentiallyActive(listOf("foo"), listOf("!

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.