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

Copied to Clipboard!

How to use sample method of io.kotest.property.arbitrary.edgecases class

Best Kotest code snippet using io.kotest.property.arbitrary.edgecases.sample

BuilderTest.kt

Source:BuilderTest.kt

...119            val shrinker = IntShrinker(1..5)120            val edges = setOf(1, 2)121            val arb = arbitrary(edges.toList(), shrinker) { 5 }122            arb.edgecases() shouldContainExactlyInAnyOrder edges123            arb.sample(RandomSource.seeded(1234L)).shrinks.children.value.map { it.value() } shouldBe shrinker.shrink(5)124         }125         test("should use shrinker when provided") {126            val shrinker = IntShrinker(1..5)127            val arb = arbitrary(shrinker) { 5 }128            arb.classifier.shouldBeNull()129            val shrinks = arb.sample(RandomSource.seeded(1234L)).shrinks130            shrinks.children.value.map { it.value() } shouldContainExactly shrinker.shrink(5)131         }132         test("should use classifier when provided") {133            val classifier = IntClassifier(1..5)134            val arb = arbitrary(classifier) { 5 }135            arb.classifier shouldBeSameInstanceAs classifier136         }137         test("should use classifier and shrinker when provided") {138            val shrinker = IntShrinker(1..5)139            val classifier = IntClassifier(1..5)140            val arb = arbitrary(shrinker, classifier) { 5 }141            arb.classifier shouldBeSameInstanceAs classifier142            val shrinks = arb.sample(RandomSource.seeded(1234L)).shrinks143            shrinks.children.value.map { it.value() } shouldContainExactly shrinker.shrink(5)144         }145         test("should use edgecase function when provided") {146            val arb = arbitrary({ 5 }) { 10 }147            arb.edgecases() shouldContainExactlyInAnyOrder setOf(5)148         }149         test("should use edgecase function and shrinker when provided") {150            val shrinker = IntShrinker(1..5)151            val arb = arbitrary({ 5 }, shrinker) { 10 }152            arb.edgecases() shouldContainExactlyInAnyOrder setOf(5)153            val shrinks = arb.sample(RandomSource.seeded(1234L)).shrinks154            shrinks.children.value.map { it.value() } shouldContainExactly shrinker.shrink(10)155         }156         test("should support .bind() syntax") {157            val arb = Arb.constant(5)158            val shrinker = IntShrinker(1..5)159            val classifier = IntClassifier(1..5)160            arbitrary { arb.bind() }.single() shouldBe 5161            arbitrary(shrinker) { arb.bind() }.single() shouldBe 5162            arbitrary(classifier) { arb.bind() }.single() shouldBe 5163            arbitrary(shrinker, classifier) { arb.bind() }.single() shouldBe 5164            arbitrary(listOf(5)) { arb.bind() }.single() shouldBe 5165            arbitrary({ 5 }) { arb.bind() }.single() shouldBe 5166            arbitrary({ 5 }, shrinker) { arb.bind() }.single() shouldBe 5167         }168      }169      context("suspend arbitrary builder with unrestricted continuation") {170         suspend fun combineAsString(vararg values: Any?): String = values.joinToString(" ")171         test("should build arb on the parent coroutine context") {172            val arb = withContext(Foo("hello")) {173               generateArbitrary {174                  val hello = coroutineContext[Foo]?.value175                  val world = arbitrary { "world" }.bind()176                  val first = Arb.int(1..10).bind()177                  val second = Arb.int(11..20).bind()178                  combineAsString(hello, world, first, second)179               }180            }181            arb.generate(RandomSource.seeded(1234L)).take(4).toList().map { it.value } shouldContainExactly listOf(182               "hello world 2 20",183               "hello world 6 12",184               "hello world 7 19",185               "hello world 9 13"186            )187         }188         test("should bind edgecases") {189            val arb: Arb<String> = generateArbitrary {190               val first = Arb.string(5, Codepoint.alphanumeric()).withEdgecases("edge1", "edge2").bind()191               val second = Arb.int(1..9).withEdgecases(5).bind()192               val third = Arb.int(101..109).withEdgecases(100 + second, 109).bind()193               combineAsString(first, second, third)194            }195            arb.edgecases() shouldContainExactlyInAnyOrder setOf(196               "edge1 5 105",197               "edge2 5 105",198               "edge1 5 109",199               "edge2 5 109",200            )201         }202         test("should preserve edgecases of dependent arbs, even when intermideary arb(s) have no edgecases") {203            val arb: Arb<String> = generateArbitrary {204               val first = Arb.string(5, Codepoint.alphanumeric()).withEdgecases("edge1", "edge2").bind()205               val second = Arb.int(1..4).withEdgecases(emptyList()).bind()206               val third = Arb.int(101..109).withEdgecases(100 + second).bind()207               combineAsString(first, second, third)208            }209            arb.edgecases() shouldContainExactlyInAnyOrder setOf(210               "edge1 1 101",211               "edge1 2 102",212               "edge1 3 103",213               "edge1 4 104",214               "edge2 1 101",215               "edge2 2 102",216               "edge2 3 103",217               "edge2 4 104"218            )219         }220         test("should propagate exception") {221            val throwingArb = generateArbitrary {222               val number = Arb.int(1..4).withEdgecases(emptyList()).bind()223               // try to throw something inside the arb224               number shouldBeGreaterThan 5225            }226            val assertionError = shouldThrow<AssertionError> { execute(RandomSource.seeded(1234L), throwingArb) }227            assertionError.message shouldBe "4 should be > 5"228         }229         test("should assign edgecases") {230            val edges = setOf("edge1", "edge2")231            val arb = generateArbitrary(edges.toList()) { "abcd" }232            arb.edgecases() shouldContainExactlyInAnyOrder edges233         }234         test("should assign edgecases and shrinker") {235            val shrinker = IntShrinker(1..5)236            val edges = setOf(1, 2)237            val arb = generateArbitrary(edges.toList(), shrinker) { 5 }238            arb.edgecases() shouldContainExactlyInAnyOrder edges239            arb.sample(RandomSource.seeded(1234L)).shrinks.children.value.map { it.value() } shouldBe shrinker.shrink(5)240         }241         test("should use shrinker when provided") {242            val shrinker = IntShrinker(1..5)243            val arb = generateArbitrary(shrinker) { 5 }244            arb.classifier.shouldBeNull()245            val shrinks = arb.sample(RandomSource.seeded(1234L)).shrinks246            shrinks.children.value.map { it.value() } shouldContainExactly shrinker.shrink(5)247         }248         test("should use classifier when provided") {249            val classifier = IntClassifier(1..5)250            val arb = generateArbitrary(classifier) { 5 }251            arb.classifier shouldBeSameInstanceAs classifier252         }253         test("should use classifier and shrinker when provided") {254            val shrinker = IntShrinker(1..5)255            val classifier = IntClassifier(1..5)256            val arb = generateArbitrary(shrinker, classifier) { 5 }257            arb.classifier shouldBeSameInstanceAs classifier258            val shrinks = arb.sample(RandomSource.seeded(1234L)).shrinks259            shrinks.children.value.map { it.value() } shouldContainExactly shrinker.shrink(5)260         }261         test("should use edgecase function when provided") {262            val arb = generateArbitrary({ 5 }) { 10 }263            arb.edgecases() shouldContainExactlyInAnyOrder setOf(5)264         }265         test("should use edgecase function and shrinker when provided") {266            val shrinker = IntShrinker(1..5)267            val arb = generateArbitrary({ 5 }, shrinker) { 10 }268            arb.edgecases() shouldContainExactlyInAnyOrder setOf(5)269            val shrinks = arb.sample(RandomSource.seeded(1234L)).shrinks270            shrinks.children.value.map { it.value() } shouldContainExactly shrinker.shrink(10)271         }272         test("should support .bind() syntax") {273            val arb = Arb.constant(5)274            val shrinker = IntShrinker(1..5)275            val classifier = IntClassifier(1..5)276            generateArbitrary { arb.bind() }.single() shouldBe 5277            generateArbitrary(shrinker) { arb.bind() }.single() shouldBe 5278            generateArbitrary(classifier) { arb.bind() }.single() shouldBe 5279            generateArbitrary(shrinker, classifier) { arb.bind() }.single() shouldBe 5280            generateArbitrary(listOf(5)) { arb.bind() }.single() shouldBe 5281            generateArbitrary({ 5 }) { arb.bind() }.single() shouldBe 5282            generateArbitrary({ 5 }, shrinker) { arb.bind() }.single() shouldBe 5283         }...

Arb.kt

Source:Arb.kt

1package arrow.fx.coroutines.stream2import io.kotest.property.Arb3import io.kotest.property.RandomSource4import io.kotest.property.Sample5import io.kotest.property.Shrinker6import io.kotest.property.arbitrary.arb7import io.kotest.property.arbitrary.bool8import io.kotest.property.arbitrary.byte9import io.kotest.property.arbitrary.choice10import io.kotest.property.arbitrary.choose11import io.kotest.property.arbitrary.double12import io.kotest.property.arbitrary.float13import io.kotest.property.arbitrary.int14import io.kotest.property.arbitrary.list15import io.kotest.property.arbitrary.long16import io.kotest.property.arbitrary.map17import io.kotest.property.arbitrary.set18import io.kotest.property.arbitrary.short19import kotlin.random.nextInt20@JvmOverloads21inline fun <reified A> Arb.Companion.array(22  gen: Arb<A>,23  range: IntRange = 0..10024): Arb<Array<A>> {25  check(!range.isEmpty())26  check(range.first >= 0)27  return arb(edgecases = listOf(emptyArray<A>()) + gen.edgecases().map { arrayOf(it) }) {28    sequence {29      val genIter = gen.generate(it).iterator()30      while (true) {31        val targetSize = it.random.nextInt(range)32        val list = ArrayList<A>(targetSize)33        while (list.size < targetSize && genIter.hasNext()) {34          list.add(genIter.next().value)35        }36        check(list.size == targetSize)37        yield(list.toArray() as Array<A>)38      }39    }40  }41}42@PublishedApi43internal fun <A, B> arrayChunkGenerator(44  arb: Arb<A>,45  shrinker: Shrinker<B>,46  range: IntRange = 0..10,47  build: (values: List<A>, offset: Int, length: Int) -> B48): Arb<B> {49  check(!range.isEmpty())50  check(range.first >= 0)51  val edgecases =52    arb.edgecases().map { a -> build(listOf(a), 0, 1) } + build(emptyList(), 0, 0)53  return arb(edgecases, shrinker) {54    val genIter = arb.generate(it).iterator()55    sequence {56      while (true) {57        val targetSize = it.random.nextInt(range)58        val list = ArrayList<A>(targetSize)59        while (list.size < targetSize && genIter.hasNext()) {60          list.add(genIter.next().value)61        }62        val offset = (0..list.size).random(it.random)63        val length = (0..(list.size - offset)).random(it.random)64        yield(build(list, offset, length))65      }66    }67  }68}69class ChunkShrinker<A> : Shrinker<Chunk<A>> {70  override fun shrink(value: Chunk<A>): List<Chunk<A>> =71    if (value.isEmpty()) emptyList()72    else listOf(73      Chunk.empty(),74      value.takeLast(1),75      value.take(value.size() / 3),76      value.take(value.size() / 2),77      value.take(value.size() * 2 / 3),78      value.dropLast(1)79    )80}81inline fun <reified A> Arb.Companion.chunk(arb: Arb<A>): Arb<Chunk<A>> =82  object : Arb<Chunk<A>>() {83    override fun edgecases(): List<Chunk<A>> =84      listOf(Chunk.empty<A>()) + arb.edgecases().map { Chunk(it) }85    override fun values(rs: RandomSource): Sequence<Sample<Chunk<A>>> =86      Arb.choose(87        5 to arb.map { Chunk.just(it) },88        10 to Arb.list(arb, 0..20).map { Chunk.iterable(it) },89        10 to Arb.set(arb, 0..20).map { Chunk.iterable(it) },90        10 to Arb.array(arb, 0..20).map { Chunk.array(it) },91        10 to Arb.boxedChunk(arb)92      ).values(rs)93  }94inline fun <reified A> Arb.Companion.boxedChunk(arb: Arb<A>): Arb<Chunk<A>> =95  object : Arb<Chunk<A>>() {96    override fun edgecases(): List<Chunk<A>> =97      listOf(Chunk.empty<A>()) + arb.edgecases().map { Chunk(it) }98    override fun values(rs: RandomSource): Sequence<Sample<Chunk<A>>> =99      arrayChunkGenerator(arb, ChunkShrinker()) { values, offset, length ->100        Chunk.boxed(values.toTypedArray(), offset, length)101      }.values(rs)102  }103fun Arb.Companion.booleanChunk(): Arb<Chunk<Boolean>> =104  object : Arb<Chunk<Boolean>>() {105    override fun edgecases(): List<Chunk<Boolean>> =106      listOf(Chunk.empty<Boolean>()) + Arb.bool().edgecases().map { Chunk(it) }107    override fun values(rs: RandomSource): Sequence<Sample<Chunk<Boolean>>> =108      Arb.choice(109        arrayChunkGenerator(Arb.bool(), ChunkShrinker()) { values, offset, length ->110          Chunk.booleans(values.toBooleanArray(), offset, length)111        },112        arrayChunkGenerator(Arb.bool(), ChunkShrinker()) { values, _, _ ->113          Chunk.array(values.toTypedArray())114        }115      ).values(rs)116  }117fun Arb.Companion.byteChunk(): Arb<Chunk<Byte>> =118  object : Arb<Chunk<Byte>>() {119    override fun edgecases(): List<Chunk<Byte>> =120      listOf(Chunk.empty<Byte>()) + Arb.byte().edgecases().map { Chunk(it) }121    override fun values(rs: RandomSource): Sequence<Sample<Chunk<Byte>>> =122      Arb.choice(123        arrayChunkGenerator(Arb.byte(), ChunkShrinker()) { values, offset, length ->124          Chunk.bytes(values.toByteArray(), offset, length)125        },126        arrayChunkGenerator(Arb.byte(), ChunkShrinker()) { values, _, _ ->127          Chunk.array(values.toTypedArray())128        }129      ).values(rs)130  }131fun Arb.Companion.intChunk(): Arb<Chunk<Int>> =132  object : Arb<Chunk<Int>>() {133    override fun edgecases(): List<Chunk<Int>> =134      listOf(Chunk.empty<Int>()) + Arb.int().edgecases().map { Chunk(it) }135    override fun values(rs: RandomSource): Sequence<Sample<Chunk<Int>>> =136      Arb.choice(137        arrayChunkGenerator(Arb.int(), ChunkShrinker()) { values, offset, length ->138          Chunk.ints(values.toIntArray(), offset, length)139        },140        arrayChunkGenerator(Arb.int(), ChunkShrinker()) { values, _, _ ->141          Chunk.array(values.toTypedArray())142        }143      ).values(rs)144  }145fun Arb.Companion.longChunk(): Arb<Chunk<Long>> =146  object : Arb<Chunk<Long>>() {147    override fun edgecases(): List<Chunk<Long>> =148      listOf(Chunk.empty<Long>()) + Arb.long().edgecases().map { Chunk(it) }149    override fun values(rs: RandomSource): Sequence<Sample<Chunk<Long>>> =150      Arb.choice(151        arrayChunkGenerator(Arb.long(), ChunkShrinker()) { values, offset, length ->152          Chunk.longs(values.toLongArray(), offset, length)153        },154        arrayChunkGenerator(Arb.long(), ChunkShrinker()) { values, _, _ ->155          Chunk.array(values.toTypedArray())156        }157      ).values(rs)158  }159fun Arb.Companion.doubleChunk(): Arb<Chunk<Double>> =160  object : Arb<Chunk<Double>>() {161    override fun edgecases(): List<Chunk<Double>> =162      listOf(Chunk.empty<Double>()) + Arb.double().edgecases().map { Chunk(it) }163    override fun values(rs: RandomSource): Sequence<Sample<Chunk<Double>>> =164      Arb.choice(165        arrayChunkGenerator(Arb.double(), ChunkShrinker()) { values, offset, length ->166          Chunk.doubles(values.toDoubleArray(), offset, length)167        },168        arrayChunkGenerator(Arb.double(), ChunkShrinker()) { values, _, _ ->169          Chunk.array(values.toTypedArray())170        }171      ).values(rs)172  }173fun Arb.Companion.floatChunk(): Arb<Chunk<Float>> =174  object : Arb<Chunk<Float>>() {175    override fun edgecases(): List<Chunk<Float>> =176      listOf(Chunk.empty<Float>()) + Arb.float().edgecases().map { Chunk(it) }177    override fun values(rs: RandomSource): Sequence<Sample<Chunk<Float>>> =178      Arb.choice(179        arrayChunkGenerator(Arb.float(), ChunkShrinker()) { values, offset, length ->180          Chunk.floats(values.toFloatArray(), offset, length)181        },182        arrayChunkGenerator(Arb.float(), ChunkShrinker()) { values, _, _ ->183          Chunk.array(values.toTypedArray())184        }185      ).values(rs)186  }187fun Arb.Companion.shortChunk(): Arb<Chunk<Short>> =188  object : Arb<Chunk<Short>>() {189    override fun edgecases(): List<Chunk<Short>> =190      listOf(Chunk.empty<Short>()) + Arb.short().edgecases().map { Chunk(it) }191    override fun values(rs: RandomSource): Sequence<Sample<Chunk<Short>>> =192      Arb.choice(193        arrayChunkGenerator(Arb.short(), ChunkShrinker()) { values, offset, length ->194          Chunk.shorts(values.toShortArray(), offset, length)195        },196        arrayChunkGenerator(Arb.short(), ChunkShrinker()) { values, _, _ ->197          Chunk.array(values.toTypedArray())198        }199      ).values(rs)200  }...

CollectionsTest.kt

Source:CollectionsTest.kt

...21import io.kotest.property.exhaustive.constant22import io.kotest.property.forAll23class CollectionsTest : DescribeSpec({24   describe("Arb.list should") {25      it("not include empty edge cases as first sample") {26         val numGen = Arb.list(Arb.int(), 1..10)27         forAll(1, numGen) { it.isNotEmpty() }28      }29      it("return lists of underlying generators") {30         val gen = Arb.list(Exhaustive.constant(1), 2..10)31         checkAll(gen) {32            it.shouldHaveAtLeastSize(2)33            it.shouldHaveAtMostSize(10)34            it.toSet() shouldBe setOf(1)35         }36      }37      it("include repeated elements in edge cases") {38         val edgeCase = Arb.positiveInt().edgecases().firstOrNull()39         Arb.list(Arb.positiveInt()).edgecases() shouldContain listOf(edgeCase, edgeCase)40         Arb.list(Arb.positiveInt(), 4..6).edgecases() shouldContain listOf(edgeCase, edgeCase, edgeCase, edgeCase)41      }42      it("include empty list in edge cases") {43         Arb.list(Arb.positiveInt()).edgecases() shouldContain emptyList()44      }45      it("respect bounds in edge cases") {46         val edges = Arb.list(Arb.positiveInt(), 2..10).edgecases().toSet()47         edges.forAll { it.shouldNotBeEmpty() }48      }49      it("generate lists of length up to 100 by default") {50         checkAll(10_000, Arb.list(Arb.double())) {51            it.shouldHaveAtMostSize(100)52         }53      }54      it("generate lists in the given range") {55         checkAll(1000, Arb.list(Arb.double(), 250..500)) {56            it.shouldHaveAtLeastSize(250)57            it.shouldHaveAtMostSize(500)58         }59      }60   }61   describe("Arb.set should") {62      it("not include empty edge cases as first sample") {63         val numGen = Arb.set(Arb.int(), 1..10)64         forAll(1, numGen) { it.isNotEmpty() }65      }66      it("throw when underlying arb cardinality is lower than expected set cardinality") {67         val arbUnderlying = Arb.of("foo", "bar", "baz")68         shouldThrowAny {69            Arb.set(arbUnderlying, 5..100).single()70         }71      }72      it("generate when sufficient cardinality is available, even if dups are periodically generated") {73         // this arb will generate 100 ints, but the first 1000 we take are almost certain to not be unique,74         // so this test will ensure, as long as the arb can still complete, it does.75         val arbUnderlying = Arb.int(0..1000)76         Arb.set(arbUnderlying, 1000).single()...

OsmTypesTest.kt

Source:OsmTypesTest.kt

...18          Point(-90.0, -180.0),19          Point(90.0, 180.0)20        )21        val pointArb: Arb<Point> = arbitrary(edgeCases) { rs ->22          val latitude = Arb.numericDoubles(-90.0, 90.0).sample(rs)23          val longitude = Arb.numericDoubles(-180.0, 180.0).sample(rs)24          Point(latitude.value, longitude.value)25        }26        forAll(pointArb) { p: Point -> LAT_RANGE.contains(p.lat) && LON_RANGE.contains(p.lon) }27      }28      test("should accept lat value of -90") {29        Point(-90.0, 0.0)30      }31      test("should accept lat value of 90") {32        Point(90.0, 0.0)33      }34      test("should accept long value of -180") {35        Point(0.0, -180.0)36      }37      test("should accept long value of 180") {...

PropertySpec.kt

Source:PropertySpec.kt

1package ru.iopump.qa.sample.property2import com.github.f4b6a3.uuid.UuidCreator3import io.kotest.core.spec.style.FreeSpec4import io.kotest.matchers.booleans.shouldBeTrue5import io.kotest.matchers.shouldBe6import io.kotest.matchers.string.UUIDVersion7import io.kotest.matchers.string.shouldBeUUID8import io.kotest.property.Arb9import io.kotest.property.Exhaustive10import io.kotest.property.arbitrary.int11import io.kotest.property.arbitrary.withEdgecases12import io.kotest.property.checkAll13import io.kotest.property.exhaustive.andNull14import io.kotest.property.exhaustive.enum15import io.kotest.property.forAll...

FilterTest.kt

Source:FilterTest.kt

...34   }35   test("should be stack safe") {36      val arb = object : Arb<Int>() {37         override fun edgecase(rs: RandomSource): Int? = null38         override fun sample(rs: RandomSource): Sample<Int> = Sample(rs.random.nextInt())39      }40      shouldNotThrow<StackOverflowError> {41         arb.filter { it % 2 == 0 }.take(1000000).toList()42      }43   }44   test("should apply filter to shrinks") {45      val arbEvenInts = Arb.int(-100..100).filter { it % 2 == 0 }46      val oddNumbers = (-100..100).filter { it % 2 != 0 }47      arbEvenInts.samples().take(100).forAll { sample ->48         sample.shrinks.value() shouldNotBeIn oddNumbers49         sample.shrinks.children.value.forAll {50            it.value() shouldNotBeIn oddNumbers51         }52      }53   }54   test("Arb.filter composition should not exhaust call stack") {55      var arb: Arb<Int> = Arb.of(0, 1)56      repeat(10000) {57         arb = arb.filter { it == 0 }58      }59      val result = shouldNotThrowAny { arb.single(RandomSource.seeded(1234L)) }60      result shouldBe 061   }62})...

MapTest.kt

Source:MapTest.kt

...19      val counter = AtomicInteger(0)20      val intArb = Arb.int(1, 10).map {21         counter.getAndIncrement()22      }23      intArb.samples(RandomSource.default()).take(1).toList()24      counter.get().shouldBe(1)25   }26   test("should transform edge cases") {27      val arb = Arb.int(1, 10).withEdgecases(1).map { "$it" }28      arb.generate(RandomSource.default(), EdgeConfig(edgecasesGenerationProbability = 1.0)).first().value shouldBe "1"29   }30   test("should preserve shrinking") {31      val arb = arbitrary(IntShrinker(1..1000)) { rs -> Arb.int(1..1000).single(rs) }32      val sample = arb.map { it.toString() }.sample(RandomSource.seeded(1234L))33      val shrinks = sample.shrinks.children.value.map { it.value() } + sample.shrinks.value()34      sample.value shouldBe "120"35      shrinks shouldContainExactly listOf(36         "1",37         "40",38         "60",39         "80",40         "115",41         "116",42         "117",43         "118",44         "119",45         "120"46      )47   }48   test("Arb.map composition should not exhaust call stack") {...

edgecases.kt

Source:edgecases.kt

...39 * Returns a new [Arb] with the edge cases from this arb transformed by the given function [f].40 */41fun <A> Arb<A>.modifyEdgecases(f: (A) -> A?): Arb<A> = object : Arb<A>() {42   override fun edgecase(rs: RandomSource): A? = this@modifyEdgecases.edgecase(rs)?.let(f)43   override fun sample(rs: RandomSource): Sample<A> = this@modifyEdgecases.sample(rs)44}...

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.