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

Copied to Clipboard!

How to use RootScope.addTest method of io.kotest.core.spec.style.scopes.RootScope class

Best Kotest code snippet using io.kotest.core.spec.style.scopes.RootScope.RootScope.addTest

ParserTestSpec.kt

Source:ParserTestSpec.kt

1/*2 * BSD-style license; for more info see http://pmd.sourceforge.net/license.html3 */4package net.sourceforge.pmd.lang.java.ast5import io.kotest.core.config.configuration6import io.kotest.core.spec.DslDrivenSpec7import io.kotest.core.spec.style.scopes.Lifecycle8import io.kotest.core.spec.style.scopes.RootScope9import io.kotest.core.spec.style.scopes.RootTestRegistration10import io.kotest.core.test.TestCaseConfig11import io.kotest.core.test.TestContext12import io.kotest.core.test.TestType13import io.kotest.core.test.createTestName14import net.sourceforge.pmd.lang.ast.test.Assertions15import net.sourceforge.pmd.lang.ast.test.IntelliMarker16import io.kotest.matchers.should as kotlintestShould17/**18 * Base class for grammar tests that use the DSL. Tests are layered into19 * containers that make it easier to browse in the IDE. Layout is group name,20 * then java version, then test case. Test cases are "should" assertions matching21 * a string against a matcher defined in [ParserTestCtx], e.g. [ParserTestCtx.matchExpr].22 *23 * @author ClÃ©ment Fournier24 */25abstract class ParserTestSpec(body: ParserTestSpec.() -> Unit) : DslDrivenSpec(), RootScope, IntelliMarker {26    init {27        body()28    }29    override fun lifecycle(): Lifecycle = Lifecycle.from(this)30    override fun defaultConfig(): TestCaseConfig = actualDefaultConfig()31    override fun defaultTestCaseConfig(): TestCaseConfig? = defaultTestConfig32    override fun registration(): RootTestRegistration = RootTestRegistration.from(this)33    private fun actualDefaultConfig() =34            defaultTestConfig ?: defaultTestCaseConfig() ?: configuration.defaultTestConfig35    fun test(name: String, disabled: Boolean = false, test: suspend TestContext.() -> Unit) =36            registration().addTest(37                    name = createTestName(name),38                    xdisabled = disabled,39                    test = test,40                    config = actualDefaultConfig()41            )42    /**43     * Defines a group of tests that should be named similarly,44     * with separate tests for separate versions.45     *46     * Calls to "should" in the block are intercepted to create47     * a new test.48     *49     * This is useful to make a batch of grammar specs for grammar50     * regression tests without bothering to find a name.51     *52     * @param name Name of the container test53     * @param spec Assertions. Each call to [io.kotest.matchers.should] on a string54     *             receiver is replaced by a [GroupTestCtx.should], which creates a55     *             new parser test.56     *57     */58    fun parserTestGroup(name: String,59                        disabled: Boolean = false,60                        spec: suspend GroupTestCtx.() -> Unit) =61            registration().addContainerTest(62                    name = createTestName(name),63                    test = { GroupTestCtx(this).spec() },64                    xdisabled = disabled65            )66    /**67     * Defines a group of tests that should be named similarly.68     * Calls to "should" in the block are intercepted to create69     * a new test, with the given [name] as a common prefix.70     *71     * This is useful to make a batch of grammar specs for grammar72     * regression tests without bothering to find a name.73     *74     * @param name Name of the container test75     * @param javaVersion Language versions to use when parsing76     * @param spec Assertions. Each call to [io.kotest.matchers.should] on a string77     *             receiver is replaced by a [GroupTestCtx.should], which creates a78     *             new parser test.79     *80     */81    fun parserTest(name: String,82                   javaVersion: JavaVersion = JavaVersion.Latest,83                   spec: suspend GroupTestCtx.VersionedTestCtx.() -> Unit) =84            parserTest(name, listOf(javaVersion), spec)85    /**86     * Defines a group of tests that should be named similarly,87     * executed on several java versions. Calls to "should" in88     * the block are intercepted to create a new test, with the89     * given [name] as a common prefix.90     *91     * This is useful to make a batch of grammar specs for grammar92     * regression tests without bothering to find a name.93     *94     * @param name Name of the container test95     * @param javaVersions Language versions for which to generate tests96     * @param spec Assertions. Each call to [io.kotest.matchers.should] on a string97     *             receiver is replaced by a [GroupTestCtx.should], which creates a98     *             new parser test.99     */100    fun parserTest(name: String,101                   javaVersions: List<JavaVersion>,102                   spec: suspend GroupTestCtx.VersionedTestCtx.() -> Unit) =103            parserTestGroup(name) {104                onVersions(javaVersions) {105                    spec()106                }107            }108    private suspend fun containedParserTestImpl(109            context: TestContext,110            name: String,111            javaVersion: JavaVersion,112            assertions: ParserTestCtx.() -> Unit) {113        context.registerTestCase(114                name = createTestName(name),115                test = { ParserTestCtx(javaVersion).assertions() },116                config = actualDefaultConfig(),117                type = TestType.Test118        )119    }120    inner class GroupTestCtx(private val context: TestContext) {121        suspend fun onVersions(javaVersions: List<JavaVersion>, spec: suspend VersionedTestCtx.() -> Unit) {122            javaVersions.forEach { javaVersion ->123                context.registerTestCase(124                        name = createTestName("Java ${javaVersion.pmdName}"),125                        test = { VersionedTestCtx(this, javaVersion).spec() },126                        config = actualDefaultConfig(),127                        type = TestType.Container128                )129            }130        }131        inner class VersionedTestCtx(private val context: TestContext, javaVersion: JavaVersion) : ParserTestCtx(javaVersion) {132            suspend infix fun String.should(matcher: Assertions<String>) {133                containedParserTestImpl(context, "'$this'", javaVersion = javaVersion) {134                    this@should kotlintestShould matcher135                }136            }137        }138    }139}...

DescribeSpecRootScope.kt

Source:DescribeSpecRootScope.kt

1package io.kotest.core.spec.style.scopes2import io.kotest.common.ExperimentalKotest3import io.kotest.core.names.TestName4import io.kotest.core.test.TestScope5@Deprecated("Renamed to DescribeSpecRootScope. Deprecated since 5.0")6typealias DescribeSpecRootContext = DescribeSpecRootScope7/**8 * A context that allows root tests to be registered using the syntax:9 *10 * describe("some test")11 *12 * or13 *14 * xdescribe("some disabled test")15 */16interface DescribeSpecRootScope : RootScope {17   fun context(name: String, test: suspend DescribeSpecContainerScope.() -> Unit) {18      addContainer(TestName("Context: ", name, false), false, null) { DescribeSpecContainerScope(this).test() }19   }20   fun xcontext(name: String, test: suspend DescribeSpecContainerScope.() -> Unit) {21      addContainer(TestName("Context: ", name, false), true, null) { DescribeSpecContainerScope(this).test() }22   }23   @ExperimentalKotest24   fun context(name: String): RootContainerWithConfigBuilder<DescribeSpecContainerScope> =25      RootContainerWithConfigBuilder(TestName(name), xdisabled = false, this) { DescribeSpecContainerScope(it) }26   @ExperimentalKotest27   fun xcontext(name: String): RootContainerWithConfigBuilder<DescribeSpecContainerScope> =28      RootContainerWithConfigBuilder(TestName(name), xdisabled = true, this) { DescribeSpecContainerScope(it) }29   fun describe(name: String, test: suspend DescribeSpecContainerScope.() -> Unit) {30      addContainer(31         TestName("Describe: ", name, false),32         disabled = false,33         null34      ) { DescribeSpecContainerScope(this).test() }35   }36   fun xdescribe(name: String, test: suspend DescribeSpecContainerScope.() -> Unit) {37      addContainer(38         TestName("Describe: ", name, false),39         disabled = true,40         null41      ) { DescribeSpecContainerScope(this).test() }42   }43   @ExperimentalKotest44   fun describe(name: String): RootContainerWithConfigBuilder<DescribeSpecContainerScope> =45      RootContainerWithConfigBuilder(46         TestName("Describe: ", name, false),47         xdisabled = false,48         this49      ) { DescribeSpecContainerScope(it) }50   @ExperimentalKotest51   fun xdescribe(name: String): RootContainerWithConfigBuilder<DescribeSpecContainerScope> =52      RootContainerWithConfigBuilder(53         TestName("Describe: ", name, false),54         xdisabled = true,55         this56      ) { DescribeSpecContainerScope(it) }57   fun it(name: String, test: suspend TestScope.() -> Unit) {58      addTest(TestName(name), false, null, test)59   }60   fun xit(name: String, test: suspend TestScope.() -> Unit) {61      addTest(TestName(name), true, null, test)62   }63}...

StringSpecRootScope.kt

Source:StringSpecRootScope.kt

1package io.kotest.core.spec.style.scopes2import io.kotest.core.Tag3import io.kotest.core.extensions.TestCaseExtension4import io.kotest.core.names.TestName5import io.kotest.core.spec.KotestTestScope6import io.kotest.core.test.EnabledIf7import io.kotest.core.test.EnabledOrReasonIf8import io.kotest.core.test.NestedTest9import io.kotest.core.test.TestCase10import io.kotest.core.test.TestCaseSeverityLevel11import io.kotest.core.test.TestScope12import kotlin.coroutines.CoroutineContext13import kotlin.time.Duration14@Deprecated("Renamed to StringSpecRootScope. Deprecated since 5.0")15typealias StringSpecRootContext = StringSpecRootScope16/**17 * Defines the DSL for creating tests in the 'StringSpec' style.18 *19 * Example:20 *21 * "my test" {22 *   1 + 1 shouldBe 223 * }24 *25 */26interface StringSpecRootScope : RootScope {27   fun String.config(28      enabled: Boolean? = null,29      invocations: Int? = null,30      threads: Int? = null,31      tags: Set<Tag>? = null,32      timeout: Duration? = null,33      extensions: List<TestCaseExtension>? = null,34      enabledIf: EnabledIf? = null,35      invocationTimeout: Duration? = null,36      severity: TestCaseSeverityLevel? = null,37      enabledOrReasonIf: EnabledOrReasonIf? = null,38      coroutineDebugProbes: Boolean? = null,39      blockingTest: Boolean? = null,40      test: suspend TestScope.() -> Unit,41   ) {42      RootTestWithConfigBuilder(43         this@StringSpecRootScope,44         TestName(null, this, false),45         false46      ).config(47         enabled = enabled,48         invocations = invocations,49         threads = threads,50         tags = tags,51         timeout = timeout,52         extensions = extensions,53         enabledIf = enabledIf,54         invocationTimeout = invocationTimeout,55         severity = severity,56         enabledOrReasonIf = enabledOrReasonIf,57         coroutineDebugProbes = coroutineDebugProbes,58         blockingTest = blockingTest,59         test = test60      )61   }62   /**63    * Adds a String Spec test using the default test case config.64    */65   operator fun String.invoke(test: suspend StringSpecScope.() -> Unit) {66      addTest(TestName(null, this, false), false, null) {67         StringSpecScope(this.coroutineContext, testCase).test()68      }69   }70}71/**72 * This scope exists purely to stop nested string scopes.73 */74@KotestTestScope75class StringSpecScope(76   override val coroutineContext: CoroutineContext,77   override val testCase: TestCase78) : TestScope {79   override suspend fun registerTestCase(nested: NestedTest) {80      error("Cannot add nested tests using StringSpec")81   }82}...

root.kt

Source:root.kt

1package io.kotest.datatest2import io.kotest.core.names.TestName3import io.kotest.core.spec.style.scopes.ContainerScope4import io.kotest.core.spec.style.scopes.RootScope5import io.kotest.core.spec.style.scopes.addTest6import io.kotest.core.test.Identifiers7import io.kotest.core.test.TestType8import kotlin.jvm.JvmName9/**10 * Registers tests at the root level for each element.11 *12 * The test name will be generated from the stable properties of the elements. See [Identifiers].13 */14fun <T> RootScope.withData(first: T, second: T, vararg rest: T, test: suspend ContainerScope.(T) -> Unit) {15   withData(listOf(first, second) + rest, test)16}17fun <T> RootScope.withData(18   nameFn: (T) -> String,19   first: T,20   second: T,21   vararg rest: T,22   test: suspend ContainerScope.(T) -> Unit23) = withData(nameFn, listOf(first, second) + rest, test)24/**25 * Registers tests at the root level for each element of [ts].26 *27 * The test name will be generated from the stable properties of the elements. See [Identifiers].28 */29fun <T> RootScope.withData(ts: Sequence<T>, test: suspend ContainerScope.(T) -> Unit) {30   withData(ts.toList(), test)31}32/**33 * Registers tests at the root level for each element of [ts].34 *35 * The test name will be generated from the stable properties of the elements. See [Identifiers].36 */37fun <T> RootScope.withData(nameFn: (T) -> String, ts: Sequence<T>, test: suspend ContainerScope.(T) -> Unit) {38   withData(nameFn, ts.toList(), test)39}40/**41 * Registers tests at the root level for each element of [ts].42 *43 * The test name will be generated from the stable properties of the elements. See [Identifiers].44 */45fun <T> RootScope.withData(ts: Collection<T>, test: suspend ContainerScope.(T) -> Unit) {46   withData({ getStableIdentifier(it) }, ts, test)47}48/**49 * Registers tests at the root level for each element of [ts].50 *51 * The test name will be generated from the given [nameFn] function.52 */53fun <T> RootScope.withData(54   nameFn: (T) -> String,55   ts: Collection<T>,56   test: suspend ContainerScope.(T) -> Unit57) {58   ts.forEach { t ->59      addTest(TestName(nameFn(t)), false, null, TestType.Dynamic) { test(t) }60   }61}62/**63 * Registers tests at the root level for each tuple of [data], with the first value of the tuple64 * used as the test name, and the second value passed to the test.65 */66@JvmName("withDataMap")67fun <T> RootScope.withData(data: Map<String, T>, test: suspend ContainerScope.(T) -> Unit) {68   data.forEach { (name, t) ->69      addTest(TestName(name), false, null, TestType.Dynamic) { test(t) }70   }71}...

FunSpecRootScope.kt

Source:FunSpecRootScope.kt

1package io.kotest.core.spec.style.scopes2import io.kotest.common.ExperimentalKotest3import io.kotest.core.names.TestName4import io.kotest.core.spec.RootTest5import io.kotest.core.test.TestScope6@Deprecated("Renamed to FunSpecRootContext. Deprecated since 5.0")7typealias FunSpecRootContext = FunSpecRootScope8/**9 * Extends [RootScope] with dsl-methods for the 'fun spec' style.10 */11interface FunSpecRootScope : RootScope {12   /**13    * Adds a container [RootTest] that uses a [FunSpecContainerScope] as the test context.14    */15   fun context(name: String, test: suspend FunSpecContainerScope.() -> Unit) {16      addContainer(TestName("context ", name, false), false, null) { FunSpecContainerScope(this).test() }17   }18   /**19    * Adds a disabled container [RootTest] that uses a [FunSpecContainerScope] as the test context.20    */21   fun xcontext(name: String, test: suspend FunSpecContainerScope.() -> Unit) =22      addContainer(TestName("context ", name, false), true, null) { FunSpecContainerScope(this).test() }23   @ExperimentalKotest24   fun context(name: String): RootContainerWithConfigBuilder<FunSpecContainerScope> =25      RootContainerWithConfigBuilder(TestName("context ", name, false), false, this) { FunSpecContainerScope(it) }26   @ExperimentalKotest27   fun xcontext(name: String): RootContainerWithConfigBuilder<FunSpecContainerScope> =28      RootContainerWithConfigBuilder(TestName("context ", name, false), true, this) { FunSpecContainerScope(it) }29   /**30    * Adds a [RootTest], with the given name and config taken from the config builder.31    */32   fun test(name: String): RootTestWithConfigBuilder =33      RootTestWithConfigBuilder(this, TestName(name), xdisabled = false)34   /**35    * Adds a [RootTest], with the given name and default config.36    */37   fun test(name: String, test: suspend TestScope.() -> Unit) = addTest(TestName(name), false, null, test)38   /**39    * Adds a disabled [RootTest], with the given name and default config.40    */41   fun xtest(name: String, test: suspend TestScope.() -> Unit) = addTest(TestName(name), true, null, test)42   /**43    * Adds a disabled [RootTest], with the given name and with config taken from the config builder.44    */45   fun xtest(name: String): RootTestWithConfigBuilder =46      RootTestWithConfigBuilder(this, TestName(name), xdisabled = true)47}...

ExpectSpecRootScope.kt

Source:ExpectSpecRootScope.kt

1package io.kotest.core.spec.style.scopes2import io.kotest.common.ExperimentalKotest3import io.kotest.core.names.TestName4import io.kotest.core.test.TestScope5@Deprecated("Renamed to ExpectSpecRootScope. Deprecated since 5.0")6typealias ExpectSpecRootContext = ExpectSpecRootScope7/**8 * Top level registration methods for ExpectSpec methods.9 */10interface ExpectSpecRootScope : RootScope {11   fun context(name: String, test: suspend ExpectSpecContainerScope.() -> Unit) {12      addContainer(TestName("Context: ", name, false), false, null) { ExpectSpecContainerScope(this).test() }13   }14   /**15    * Adds a container test to this spec expecting config.16    */17   @ExperimentalKotest18   fun context(name: String): RootContainerWithConfigBuilder<ExpectSpecContainerScope> =19      RootContainerWithConfigBuilder(TestName("Context: ", name, false), false, this) { ExpectSpecContainerScope(it) }20   fun xcontext(name: String, test: suspend ExpectSpecContainerScope.() -> Unit) {21      addContainer(TestName("Context: ", name, false), true, null) { ExpectSpecContainerScope(this).test() }22   }23   fun expect(name: String, test: suspend TestScope.() -> Unit) {24      addTest(TestName("Expect: ", name, false), false, null) { ExpectSpecContainerScope(this).test() }25   }26   fun xexpect(name: String, test: suspend TestScope.() -> Unit) {27      addTest(TestName("Expect: ", name, false), true, null) { ExpectSpecContainerScope(this).test() }28   }29   fun expect(name: String): RootTestWithConfigBuilder {30      return RootTestWithConfigBuilder(this, TestName("Expect: ", name, null, false), false)31   }32   fun xexpect(name: String): RootTestWithConfigBuilder {33      return RootTestWithConfigBuilder(this, TestName("Expect: ", name, null, false), true)34   }35}...

RootScope.kt

Source:RootScope.kt

1package io.kotest.core.spec.style.scopes2import io.kotest.core.names.TestName3import io.kotest.core.source.sourceRef4import io.kotest.core.spec.RootTest5import io.kotest.core.test.TestScope6import io.kotest.core.test.TestType7import io.kotest.core.test.config.UnresolvedTestConfig8@Deprecated("Renamed to RootContext. Deprecated since 5.0")9typealias RootContext = RootScope10/**11 * A [RootScope] allows for [RootTest]s to be registered via a DSL.12 */13interface RootScope {14   /**15    * Register a new [RootTest].16    */17   fun add(test: RootTest)18}19/**20 * Convenience method to add a test of type [type] to this [RootScope].21 */22fun RootScope.addTest(23   testName: TestName,24   disabled: Boolean,25   config: UnresolvedTestConfig?,26   type: TestType,27   test: suspend ContainerScope.() -> Unit28) {29   add(30      RootTest(31         name = testName,32         test = { AbstractContainerScope(this).test() },33         type = type,34         source = sourceRef(),35         disabled = disabled,36         config = config,37         factoryId = null,38      )39   )40}41/**42 * Convenience method to add a [TestType.Test] test to this [RootScope].43 */44fun RootScope.addTest(45   testName: TestName,46   disabled: Boolean,47   config: UnresolvedTestConfig?,48   test: suspend TestScope.() -> Unit49) {50   addTest(testName, disabled, config, TestType.Test, test)51}52/**53 * Convenience method to add a [TestType.Container] test to this [RootScope].54 */55fun RootScope.addContainer(56   testName: TestName,57   disabled: Boolean,58   config: UnresolvedTestConfig?,59   test: suspend ContainerScope.() -> Unit60) {61   addTest(testName, disabled, config, TestType.Container, test)62}...

Law.kt

Source:Law.kt

1package io.kotest.property.arrow.laws2import io.kotest.assertions.fail3import io.kotest.core.names.TestName4import io.kotest.core.spec.style.scopes.RootScope5import io.kotest.core.spec.style.scopes.addTest6import io.kotest.core.test.TestScope7public data class Law(val name: String, val test: suspend TestScope.() -> Unit)8public fun <A> A.equalUnderTheLaw(other: A, f: (A, A) -> Boolean = { a, b -> a == b }): Boolean =9  if (f(this, other)) true else fail("Found $this but expected: $other")10public fun RootScope.testLaws(vararg laws: List<Law>): Unit =11  laws12    .flatMap { list: List<Law> -> list.asIterable() }13    .distinctBy { law: Law -> law.name }14    .forEach { law ->15      addTest(TestName(law.name), disabled = false, config = null) { law.test(this) }16    }17public fun RootScope.testLaws(prefix: String, vararg laws: List<Law>): Unit =18  laws19    .flatMap { list: List<Law> -> list.asIterable() }20    .distinctBy { law: Law -> law.name }21    .forEach { law: Law ->22      addTest(TestName(prefix, law.name, true), disabled = false, config = null) { law.test(this) }23    }...

RootScope.addTest

Using AI Code Generation

1RootScope.addTest("test name", test = { /* test body */ })2FeatureScope.addTest("test name", test = { /* test body */ })3ScenarioScope.addTest("test name", test = { /* test body */ })4ExpectScope.addTest("test name", test = { /* test body */ })5WhenScope.addTest("test name", test = { /* test body */ })6ThenScope.addTest("test name", test = { /* test body */ })7AndScope.addTest("test name", test = { /* test body */ })8DescribeScope.addTest("test name", test = { /* test body */ })9ContextScope.addTest("test name", test = { /* test body */ })10ItScope.addTest("test name", test = { /* test body */ })11GivenScope.addTest("test name", test = { /* test body */ })12WhenScope.addTest("test name", test = { /* test body */ })13ThenScope.addTest("test name", test = { /* test body */ })

RootScope.addTest

Using AI Code Generation

1RootScope.addTest(name = "test 1", xdisabled = false, test = {2})3RootScope.addTest(name = "test 2", xdisabled = false, test = {4})5RootScope.addTest(name = "test 3", xdisabled = false, test = {6})7}8}9RootScope.addTest(name = "test 4", xdisabled = false, test = {10})11RootScope.addTest(name = "test 5", xdisabled = false, test = {12})13}14}

RootScope.addTest

Using AI Code Generation

1@DisplayName("My First Test")2class MyFirstTest : FunSpec({3    test("My First Test") {4        println("Hello World")5    }6})7@DisplayName("My First Test")8class MyFirstTest : FunSpec({9    addTest("My First Test") {10        println("Hello World")11    }12})13@DisplayName("My First Test")14class MyFirstTest : FunSpec({15    addTest(Description.spec("My First Test"), {16        println("Hello World")17    })18})19@DisplayName("My First Test")20class MyFirstTest : FunSpec({21    addTest(Description.spec("My First Test"), {22        println("Hello World")23    }, null)24})25@DisplayName("My First Test")26class MyFirstTest : FunSpec({27    addTest(Description.spec("My First Test"), {28        println("Hello World")29    }, null, null)30})31@DisplayName("My First Test")32class MyFirstTest : FunSpec({33    addTest(Description.spec("My First Test"), {34        println("Hello World")35    }, null, null, null)36})37@DisplayName("My First Test")38class MyFirstTest : FunSpec({39    addTest(Description.spec("My First Test"), {40        println("Hello World")41    }, null, null, null, null)42})43@DisplayName("My First Test")44class MyFirstTest : FunSpec({45    addTest(Description.spec("My First Test"), {46        println("Hello World")47    }, null, null, null, null, null)48})49@DisplayName("

RootScope.addTest

Using AI Code Generation

1@DisplayName("My Test")2class MyTest : FunSpec({3    test("test1") {4    }5})6@DisplayName("My Test")7class MyTest : FunSpec({8    test("test1") {9    }10})11@DisplayName("My Test")12class MyTest : FunSpec({13    test("test1") {14    }15})16@DisplayName("My Test")17class MyTest : FunSpec({18    test("test1") {19    }20})21@DisplayName("My Test")22class MyTest : FunSpec({23    test("test1") {24    }25})26@DisplayName("My Test")27class MyTest : FunSpec({28    test("test1") {29    }30})31@DisplayName("My Test")32class MyTest : FunSpec({33    test("test1") {34    }35})36@DisplayName("My Test")37class MyTest : FunSpec({38    test("test1") {39    }40})41@DisplayName("My Test")42class MyTest : FunSpec({43    test("test1") {44    }45})46@DisplayName("My Test")47class MyTest : FunSpec({48    test("test1") {49    }50})

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.