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

Copied to Clipboard!

How to use counter class of io.kotest.assertions package

Best Kotest code snippet using io.kotest.assertions.counter

ClaimantTransformerTest.kt

Source:ClaimantTransformerTest.kt

...15import java.lang.RuntimeException16class ClaimantTransformerTest: StringSpec() {17    init {18        "Transforms valid json" {19            val counter = mock<Counter>()20            transformer(counter).transform(jsonObject(validJson)) shouldBeRight {21                it shouldMatchJson expectedOutput22                verifyZeroInteractions(counter)23            }24        }25        "Returns right if nino missing" {26            val counter = mock<Counter>()27            transformer(counter).transform(jsonObject(invalidJsonMissingNino)) shouldBeRight {28                it shouldMatchJson noNinoOutput29                verifyZeroInteractions(counter)30            }31        }32        "Returns right if nino empty" {33            val counter = mock<Counter>()34            transformer(counter).transform(jsonObject(invalidJsonEmptyNino)) shouldBeRight {35                it shouldMatchJson noNinoOutput36                verifyZeroInteractions(counter)37            }38        }39        "Returns right if nino blank" {40            val counter = mock<Counter>()41            transformer(counter).transform(jsonObject(invalidJsonBlankNino)) shouldBeRight {42                it shouldMatchJson noNinoOutput43                verifyZeroInteractions(counter)44            }45        }46        "Returns right if nino null" {47            val counter = mock<Counter>()48            transformer(counter).transform(jsonObject(invalidJsonNullNino)) shouldBeRight {49                it shouldMatchJson noNinoOutput50                verifyZeroInteractions(counter)51            }52        }53        "Returns left if _id missing" {54            val counter = mock<Counter>()55            transformer(counter).transform(jsonObject(invalidJsonMissingId)) shouldBeLeft {56                it.shouldBeTypeOf<Pair<JsonObject, String>>()57                it.first.json() shouldMatchJson invalidJsonMissingId58                it.second shouldBe "_id"59                verifyZeroInteractions(counter)60            }61        }62        "Returns left if everything missing" {63            val counter = mock<Counter>()64            transformer(counter).transform(jsonObject(invalidJsonMissingEverything)) shouldBeLeft {65                it.shouldBeTypeOf<Pair<JsonObject, String>>()66                it.first.json() shouldMatchJson invalidJsonMissingEverything67                it.second shouldBe "_id"68                verifyZeroInteractions(counter)69            }70        }71        "Records failure" {72            val counter = mock<Counter>()73            val saltProvider = mock<SaltRepository> {74                on { salt() } doThrow RuntimeException("ERROR")75            }76            val transformer = ClaimantTransformer(saltProvider, counter)77            shouldThrow<RuntimeException> {78                transformer.transform(jsonObject(validJson))79            }80            verify(counter, times(1)).inc()81            verifyNoMoreInteractions(counter)82        }83    }84    companion object {85        private const val validJson =86            """{87                "_id": {88                    "citizenId": "2bee0d32-4e18-477c-b5b1-b46d7952a927"89                },90                "nino": "AA123456A"91            }"""92        private const val invalidJsonMissingId =93            """{94                "nino": "AA123456A"95            }"""96        private const val invalidJsonMissingNino =97            """{98                "_id": {99                    "citizenId": "2bee0d32-4e18-477c-b5b1-b46d7952a927"100                }101            }"""102        private const val invalidJsonEmptyNino =103            """{104                "_id": {105                    "citizenId": "2bee0d32-4e18-477c-b5b1-b46d7952a927"106                },107                "nino": ""108            }"""109        private const val invalidJsonBlankNino =110            """{111                "_id": {112                    "citizenId": "2bee0d32-4e18-477c-b5b1-b46d7952a927"113                },114                "nino": "    "115            }"""116        private const val invalidJsonNullNino =117            """{118                "_id": {119                    "citizenId": "2bee0d32-4e18-477c-b5b1-b46d7952a927"120                },121                "nino": null122            }"""123        private const val invalidJsonMissingEverything = "{}"124        private const val expectedOutput =125            """{126                "_id": {127                    "citizenId": "2bee0d32-4e18-477c-b5b1-b46d7952a927"128                },129                "nino": "xFJrf8lbU4G-LB3gx6uF0z531bs0DIVYQ5o5514Y5OrrlxEriQ_W-jEum6bgveIL9gFwwRswDXz8lgqmTQCgFg=="130            }"""131        private const val noNinoOutput =132            """{133                "_id": {134                    "citizenId": "2bee0d32-4e18-477c-b5b1-b46d7952a927"135                },136                "nino": ""137            }"""138        private fun transformer(counter: Counter) = ClaimantTransformer(saltProvider(), counter)139        private fun saltProvider() = mock<SaltRepository> { on { salt() } doReturn "SALT" }140    }141}...

DatakeyProcessorImplTest.kt

Source:DatakeyProcessorImplTest.kt

...21        "Returns right if datakey call successful" {22            val datakeyRepository = mock<DecryptingDataKeyRepository> {23                on { decryptDataKey(encryptingKeyId, encryptedKey) } doReturn decryptedKey.right()24            }25            val counter = mock<Counter>()26            val processor = DataKeyProcessorImpl(datakeyRepository, counter)27            verifyZeroInteractions(counter)28            val input = encryptionExtractionResult()29            val queueRecord = mock<SourceRecord>()30            val result = processor.process(Pair(queueRecord, input))31            result shouldBeRight { (record, result) ->32                record shouldBeSameInstanceAs queueRecord33                result shouldBe DataKeyResult(jsonProcessingExtract(), initialisationVector, decryptedKey)34            }35        }36        "Returns left if can't decrypt datakey" {37            val datakeyRepository = mock<DecryptingDataKeyRepository> {38                on {39                    decryptDataKey(encryptingKeyId, encryptedKey)40                } doReturn Pair(returnCode, Pair(encryptingKeyId, encryptedKey)).left()41            }42            val counter = mock<Counter>()43            val processor = DataKeyProcessorImpl(datakeyRepository, counter)44            val input = encryptionExtractionResult()45            val queueRecord = mock<SourceRecord> {46                on { key() } doReturn "key".toByteArray()47            }48            val result = processor.process(Pair(queueRecord, input))49            result shouldBeLeft queueRecord50            verify(counter, times(1)).inc()51            verifyNoMoreInteractions(counter)52        }53        "Throws exception if service unavailable" {54            val thrown = DataKeyServiceUnavailableException("Service Unavailable")55            val datakeyRepository = mock<DecryptingDataKeyRepository> {56                on { decryptDataKey(encryptingKeyId, encryptedKey) } doThrow thrown57            }58            val counter = mock<Counter>()59            val processor = DataKeyProcessorImpl(datakeyRepository, counter)60            val input = encryptionExtractionResult()61            val error = shouldThrow<DataKeyServiceUnavailableException> {62                processor.process(Pair(mock(), input))63            }64            error shouldBeSameInstanceAs thrown65            verify(counter, times(1)).inc()66            verifyNoMoreInteractions(counter)67        }68    }69    private fun encryptionExtractionResult(): EncryptionExtractionResult =70            EncryptionExtractionResult(jsonProcessingExtract(), EncryptionMetadata(encryptingKeyId, encryptedKey, initialisationVector))71    private val encryptingKeyId = "encryptingKeyId"72    private val encryptedKey = "encryptedKey"73    private val initialisationVector = "initialisationVector"74    private val decryptedKey = "decryptedKey"75    private val returnCode = 40076}...

build.gradle.kts

Source:build.gradle.kts

...56        violationRules {57            rule {58                enabled = true59                limit {60                    counter = "LINE"61                    value = "TOTALCOUNT"62                    minimum = "1.0".toBigDecimal()63                }64            }65        }66    }67}68tasks.withType<DependencyUpdatesTask> {69    rejectVersionIf {70        this.candidate.version.contains("alpha", ignoreCase = true) ||71                this.candidate.version.contains("beta", ignoreCase = true) ||72                this.candidate.version.contains("rc", ignoreCase = true) ||73                this.candidate.version.contains("m", ignoreCase = true)74    }...

TreeTest.kt

Source:TreeTest.kt

1/*2 * Copyright (c) 2021. Herman Cheung3 *4 * Licensed under the Apache License, Version 2.0 (the "License");5 * you may not use this file except in compliance with the License.6 * You may obtain a copy of the License at7 *8 * http://www.apache.org/licenses/LICENSE-2.09 *10 * Unless required by applicable law or agreed to in writing, software11 * distributed under the License is distributed on an "AS IS" BASIS,12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.13 * See the License for the specific language governing permissions and14 * limitations under the License.15 *16 *17 */18package io.hkhc.gradle.test19import io.hkhc.utils.tree.Node20import io.hkhc.utils.tree.TreePrinter21import io.hkhc.utils.tree.toStringTree22import io.kotest.assertions.Actual23import io.kotest.assertions.Expected24import io.kotest.assertions.assertionCounter25import io.kotest.assertions.collectOrThrow26import io.kotest.assertions.eq.Eq27import io.kotest.assertions.eq.actualIsNull28import io.kotest.assertions.eq.expectedIsNull29import io.kotest.assertions.errorCollector30import io.kotest.assertions.failure31import io.kotest.assertions.show.Printed32import io.kotest.assertions.show.Show33import io.kotest.assertions.show.show34import io.kotest.matchers.Matcher35import io.kotest.matchers.should36class NodeEq<T> : Eq<Node<T>> {37    override fun equals(actual: Node<T>, expected: Node<T>): Throwable? {38        return when {39            actual === expected -> null40            actual == expected -> null41            else ->42                failure(Expected(expected.show()), Actual(actual.show()))43        }44    }45}46fun <T : Any?> eq(actual: Node<T>?, expected: Node<T>?): Throwable? {47    // if we have null and non null, usually that's a failure, but people can override equals to allow it48    println("Node<T> eq match")49    return when {50        actual === expected -> null51        actual == null && expected == null -> null52        actual == null && expected != null && actual != expected -> actualIsNull(expected)53        actual != null && expected == null && actual != expected -> expectedIsNull(actual)54        actual != null && expected != null -> NodeEq<T>().equals(actual, expected)55        else -> null56    }57}58@Suppress("UNCHECKED_CAST")59infix fun <T> Node<T>.shouldBe(expected: Node<T>) {60    println("Node shouldBe")61    when (expected) {62        is Matcher<*> -> should(expected as Matcher<Node<T>>)63        else -> {64            val actual = this65            assertionCounter.inc()66            eq(actual, expected)?.let(errorCollector::collectOrThrow)67        }68    }69}70class StringTreeShow<T> : Show<T> {71    init {72        println("Create new StringTreeShow()")73    }74    override fun show(a: T): Printed {75        println("show()")76        if (a is Node<*>) {77            return TreePrinter().dumpToString(a.toStringTree()).show()78        } else {79            return "Not a tree".show()80        }81    }82}...

TaskSchedulerTests.kt

Source:TaskSchedulerTests.kt

...10import kotlin.time.ExperimentalTime11@OptIn(ExperimentalTime::class)12class TaskSchedulerTests : FunSpec({13    isolationMode = IsolationMode.InstancePerTest14    var counter = 015    val taskScheduler = TaskScheduler()16    afterEach {17        if (taskScheduler.running) {18            taskScheduler.stop()19        }20    }21    context("Scheduler stopped") {22        test("Start scheduler") {23            taskScheduler.running shouldBe false24            taskScheduler.start()25            taskScheduler.running shouldBe true26        }27        test("Start scheduler multiple times") {28            taskScheduler.start()29            shouldThrow<LifecycleException> { taskScheduler.start() }30        }31        test("Stop scheduler") {32            shouldThrow<LifecycleException> { taskScheduler.stop() }33        }34        test("Add task and start scheduler") {35            taskScheduler.add(TaskDefinition(0, 10_000) { counter++ })36            taskScheduler.start()37            eventually(100.milliseconds) { counter shouldBe 1 }38        }39        test("Start scheduler and add task") {40            taskScheduler.start()41            taskScheduler.add(TaskDefinition(0, 10_000) { counter++ })42            eventually(100.milliseconds) { counter shouldBe 1 }43        }44    }45    context("Scheduler started") {46        taskScheduler.start()47        test("Stop scheduler") {48            taskScheduler.stop()49            taskScheduler.running shouldBe false50        }51        test("Add task") {52            taskScheduler.add(TaskDefinition(0, 10_000) { counter++ })53            eventually(100.milliseconds) { counter shouldBe 1 }54        }55        test("Add delayed task") {56            taskScheduler.add(TaskDefinition(100, 10_000) { counter++ })57            continually(90.milliseconds) { counter shouldBe 0 }58            eventually(100.milliseconds) { counter shouldBe 1 }59        }60        test("Run task multiple times") {61            taskScheduler.add(TaskDefinition(0, 100) { counter++ })62            eventually(50.milliseconds) { counter shouldBe 1 }63            eventually(150.milliseconds) { counter shouldBe 2 }64            eventually(250.milliseconds) { counter shouldBe 3 }65        }66        test("Run task and stop") {67            taskScheduler.add(TaskDefinition(0, 100) { counter++ })68            eventually(50.milliseconds) { counter shouldBe 1 }69            taskScheduler.stop()70            continually(150.milliseconds) { counter shouldBe 1 }71        }72    }73})...

WaitSpec.kt

Source:WaitSpec.kt

...14        private val log = LoggerFactory.getLogger(WaitSpec::class.java)15    }16    /*1*/17    private lateinit var tries: Iterator<Boolean>18    private lateinit var counter: AtomicInteger19    private val num: Int get() = counter.incrementAndGet()20    init {21        /*2*/22        beforeTest {23            tries = listOf(true, true, false).iterator()24            counter = AtomicInteger()25        }26        "eventually waiting should be success" {27            /*3*/eventually(200.milliseconds, 50.milliseconds.fixed(), exceptionClass = RuntimeException::class) {28            log.info("Try #$num")29            if (tries.next()) /*4*/ throw IllegalStateException("Try #$counter")30        }31        }32        "eventually waiting should be failed on second try" {33            /*5*/shouldThrow<AssertionError> {34            eventually(/*6*/100.milliseconds, 50.milliseconds.fixed(), exceptionClass = IllegalStateException::class) {35                log.info("Try #$num")36                if (tries.next()) throw IllegalStateException("Try #$counter")37            }38        }.toString().also(log::error)39        }40        "continually waiting should be success" - {41            /*7*/continually(200.milliseconds, 50.milliseconds.fixed()) {42            log.info("Try #$num")43        }44        }45        "continually waiting should be failed on third try" {46            /*8*/shouldThrow<IllegalStateException> {47            continually(200.milliseconds, 50.milliseconds.fixed()) {48                log.info("Try #$num")49                if (tries.next()) throw IllegalStateException("Try #$counter")50            }51        }.toString().also(log::error)52        }53    }54}...

RetrySpec.kt

Source:RetrySpec.kt

...12    private companion object {13        private val log = LoggerFactory.getLogger(RetrySpec::class.java)14    }15    private lateinit var tries: Iterator<Boolean>16    private lateinit var counter: AtomicInteger17    private val num: Int get() = counter.incrementAndGet()18    init {19        beforeTest {20            tries = listOf(false, false, true).iterator()21            counter = AtomicInteger()22        }23        "retry should be failed after 10 tries" {24            shouldThrow<AssertionError> {25                retry(10, 1.seconds, 50.milliseconds, 2, IllegalStateException::class) {26                    log.info("Try $num")27                    throw IllegalStateException()28                }29            }.toString().also(log::error)30        }31    }32}...

AssertionExtension.kt

Source:AssertionExtension.kt

1package com.example.realworld.util.extension2import com.fasterxml.jackson.databind.ObjectMapper3import io.kotest.assertions.assertionCounter4import io.kotest.assertions.collectOrThrow5import io.kotest.assertions.eq.eq6import io.kotest.assertions.errorCollector7infix fun <T> String.shouldBeEqualJson(expected: T) {8    val actual = this9    assertionCounter.inc()10    val expectedJson = ObjectMapper().writeValueAsString(expected)11    eq(actual, expectedJson)?.let(errorCollector::collectOrThrow)12}...

counter

Using AI Code Generation

1    import io.kotest.assertions.counter2    import io.kotest.core.spec.style.StringSpec3    import io.kotest.matchers.shouldBe4    class CounterTest : StringSpec({5      "counter should work" {6        val c = counter()7        c.inc()8        c.inc()9        c.value() shouldBe 210      }11    })

counter

Using AI Code Generation

1    import io.kotest.assertions.counter2    import io.kotest.assertions.counter.forAll3    import io.kotest.assertions.counter.forNone4    import io.kotest.assertions.counter.forSome5    import io.kotest.assertions.counter.forExactly6    import io.kotest.assertions.counter.forAtLeast7    import io.kotest.assertions.counter.forAtMost8    import io.kotest.matchers.collections.counter9    import io.kotest.matchers.collections.counter.forAll10    import io.kotest.matchers.collections.counter.forNone11    import io.kotest.matchers.collections.counter.forSome12    import io.kotest.matchers.collections.counter.forExactly13    import io.kotest.matchers.collections.counter.forAtLeast14    import io.kotest.matchers.collections.counter.forAtMost15    import io.kotest.matchers.longs.counter16    import io.kotest.matchers.longs.counter.forAll17    import io.kotest.matchers.longs.counter.forNone18    import io.kotest.matchers.longs.counter.forSome19    import io.kotest.matchers.longs.counter.forExactly20    import io.kotest.matchers.longs.counter.forAtLeast21    import io.kotest.matchers.longs.counter.forAtMost22    import io.kotest.matchers.ints.counter23    import io.kotest.matchers.ints.counter.forAll24    import io.kotest.matchers.ints.counter.forNone25    import io.kotest.matchers.ints.counter.forSome26    import io.kotest.matchers.ints.counter.forExactly27    import io.kotest.matchers.ints.counter.forAtLeast28    import io.kotest.matchers.ints.counter.forAtMost29    import io.kotest.matchers.booleans.counter30    import io.kotest.matchers.booleans.counter.forAll31    import io.kotest.matchers.booleans.counter.forNone32    import io.kotest.matchers.booleans.counter.for

counter

Using AI Code Generation

1    import io.kotest.assertions.counter2    import io.kotest.core.spec.style.StringSpec3    import io.kotest.matchers.shouldBe4    class CounterTest : StringSpec({5       "counter should count" {6          val c = counter()7       }8    })9Kotest provides a powerful property testing framework that allows you to generate random data, and test your code against it. It is based on the [kotest-property](

counter

Using AI Code Generation

1import io.kotest.assertions.counter2fun main() {3val counter = counter()4counter.inc()5counter.inc()6}7import io.kotest.assertions.counter8fun main() {9val counter = counter()10counter.inc()11counter.inc()12}13import io.kotest.assertions.counter14fun main() {15val counter = counter()16counter.inc()17counter.inc()18}19import io.kotest.assertions.counter20fun main() {21val counter = counter()22counter.inc()23counter.inc()24}25import io.kotest.assertions.counter26fun main() {27val counter = counter()28counter.inc()29counter.inc()30}31import io.kotest.assertions.counter32fun main() {33val counter = counter()34counter.inc()35counter.inc()36}37import io.kotest.assertions.counter38fun main() {39val counter = counter()40counter.inc()41counter.inc()42}43import io.kotest.assertions.counter44fun main() {45val counter = counter()46counter.inc()47counter.inc()48}

counter

Using AI Code Generation

1    import io.kotest.assertions.counter.*2    import io.kotest.assertions.counter.Counter3    import io.kotest.assertions.counter.CounterMode.*4    class CounterSpec : WordSpec({5      "counter" should {6        "increment and decrement" {7          val counter = Counter()8          counter.increment()9          counter.decrement()10        }11        "increment and decrement in parallel" {12          val counter = Counter()13          counter.increment()14          counter.decrement()15        }16      }17    })18I have tried to use `counter.increment()` and `counter.decrement()` in a loop, but it doesn’t work, because the `decrement` method is called before the `increment` method.  19So I tried to use `counter.increment()` and `counter.decrement()` in two different threads, but it doesn’t work too, because the `decrement` method is called before the `increment` method.  20I also tried to use `counter.increment()` and `counter.decrement()` in a loop, but it doesn’t work, because the `decrement` method is called before the `increment` method.  21So I tried to use `counter.increment()` and `counter.decrement()` in two different threads, but it doesn’t work too, because the `decrement` method is called before the `increment` method.  22I also tried to use `counter.increment()` and `counter.decrement()` in a loop, but it doesn’t work, because the `decrement` method is called before the `increment` method.  23So I tried to use `counter.increment()` and `counter.decrement()` in two different threads, but it doesn’t work too, because the `decrement` method is called before the `increment` method.  24I also tried to use `counter.increment()` and `counter.decrement()` in a loop, but it doesn’t work, because the `decrement` method is called before the `increment` method.  25So I tried to use `counter.increment()` and `counter.decrement()` in two different threads, but

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.