How to use Equality class of io.kotest.equals package

Best Kotest code snippet using io.kotest.equals.Equality

CallUrlInfoTest.kt

Source:CallUrlInfoTest.kt

1/*2 * Copyright @ 2018 Atlassian Pty Ltd3 *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 */17package org.jitsi.jibri18import io.kotest.core.spec.IsolationMode19import io.kotest.core.spec.style.ShouldSpec20import io.kotest.data.forAll21import io.kotest.data.headers22import io.kotest.data.row23import io.kotest.data.table24import io.kotest.matchers.shouldBe25import io.kotest.matchers.shouldNotBe26class CallUrlInfoTest : ShouldSpec() {27    override fun isolationMode(): IsolationMode? = IsolationMode.InstancePerLeaf28    init {29        context("creating a CallUrlInfo") {30            context("without url params") {31                val info = CallUrlInfo("baseUrl", "callName")32                should("assign the fields correctly") {33                    info.baseUrl shouldBe "baseUrl"34                    info.callName shouldBe "callName"35                    info.callUrl shouldBe "baseUrl/callName"36                }37            }38            context("with url params") {39                val info = CallUrlInfo("baseUrl", "callName", listOf("one", "two", "three"))40                should("assign the fields correctly") {41                    info.baseUrl shouldBe "baseUrl"42                    info.callName shouldBe "callName"43                    info.callUrl shouldBe "baseUrl/callName#one&two&three"44                }45            }46        }47        context("a nullable CallUrlInfo instance") {48            should("not equal null") {49                val nullableInfo: CallUrlInfo? = CallUrlInfo("baseUrl", "callName")50                nullableInfo shouldNotBe null51            }52        }53        context("equality and hashcode") {54            val info = CallUrlInfo("baseUrl", "callName")55            context("a CallUrlInfo instance") {56                should("not equal another type") {57                    @Suppress("ReplaceCallWithBinaryOperator")58                    info.equals("string") shouldBe false59                }60                context("when compared to other variations") {61                    should("be equal/not equal where appropriate") {62                        val duplicateInfo = CallUrlInfo("baseUrl", "callName")63                        val differentBaseUrl = CallUrlInfo("differentBaseUrl", "callName")64                        val differentCallName = CallUrlInfo("differentUrl", "differentCallName")65                        val differentBaseUrlCase = CallUrlInfo("BASEURL", "callName")66                        val differentCallNameCase = CallUrlInfo("baseUrl", "CALLNAME")67                        val withUrlParams = CallUrlInfo("baseUrl", "callName", listOf("one", "two", "three"))68                        val t = table(69                            headers("left", "right", "shouldEqual"),70                            row(info, info, true),71                            row(info, duplicateInfo, true),72                            row(info, differentBaseUrl, false),73                            row(info, differentCallName, false),74                            row(info, differentBaseUrlCase, true),75                            row(info, differentCallNameCase, true),76                            row(info, withUrlParams, true)77                        )78                        forAll(t) { left, right, shouldEqual ->79                            if (shouldEqual) {80                                left shouldBe right81                                left.hashCode() shouldBe right.hashCode()82                            } else {83                                left shouldNotBe right84                                left.hashCode() shouldNotBe right.hashCode()85                            }86                        }87                    }88                }89            }90        }91    }92}...

TestUtils.kt

Source:TestUtils.kt

1/*2 * BSD-style license; for more info see http://pmd.sourceforge.net/license.html3 */4package net.sourceforge.pmd.lang.ast.test5import io.kotest.matchers.Matcher6import io.kotest.matchers.equalityMatcher7import io.kotest.matchers.should8import net.sourceforge.pmd.Report9import net.sourceforge.pmd.RuleViolation10import net.sourceforge.pmd.lang.ast.Node11import kotlin.reflect.KCallable12import kotlin.reflect.jvm.isAccessible13import kotlin.test.assertEquals14/**15 * Extension to add the name of a property to error messages.16 *17 * @see [shouldBe].18 */19infix fun <N, V : N> KCallable<N>.shouldEqual(expected: V?) =20        assertWrapper(this, expected) { n, v ->21            // using shouldBe would perform numeric conversion22            // eg (3.0 shouldBe 3L) passes, even though (3.0 != 3L)23            // equalityMatcher doesn't do this conversion24            n.should(equalityMatcher(v) as Matcher<N>)25        }26private fun <N, V> assertWrapper(callable: KCallable<N>, right: V, asserter: (N, V) -> Unit) {27    fun formatName() = "::" + callable.name.removePrefix("get").decapitalize()28    val value: N = try {29        callable.isAccessible = true30        callable.call()31    } catch (e: Exception) {32        throw RuntimeException("Couldn't fetch value for property ${formatName()}", e)33    }34    try {35        asserter(value, right)36    } catch (e: AssertionError) {37        if (e.message?.contains("expected:") == true) {38            // the exception has no path, let's add one39            throw AssertionError(e.message!!.replace("expected:", "expected property ${formatName()} to be"))40        }41        throw e42    }43}44/**45 * Extension to add the name of the property to error messages.46 * Use with double colon syntax, eg `it::isIntegerLiteral shouldBe true`.47 * For properties synthesized from Java getters starting with "get", you48 * have to use the name of the getter instead of that of the generated49 * property (with the get prefix).50 *51 * If this conflicts with [io.kotest.matchers.shouldBe], use the equivalent [shouldEqual]52 *53 */54infix fun <N, V : N> KCallable<N>.shouldBe(expected: V?) = this.shouldEqual(expected)55infix fun <T> KCallable<T>.shouldMatch(expected: T.() -> Unit) = assertWrapper(this, expected) { n, v -> n should v }56inline fun <reified T> Any?.shouldBeA(f: (T) -> Unit = {}): T {57    if (this is T) {58        f(this)59        return this60    } else throw AssertionError("Expected an instance of ${T::class.java}, got $this")61}62operator fun <T> List<T>.component6() = get(5)63operator fun <T> List<T>.component7() = get(6)64operator fun <T> List<T>.component8() = get(7)65operator fun <T> List<T>.component9() = get(8)66operator fun <T> List<T>.component10() = get(9)67operator fun <T> List<T>.component11() = get(10)68/** Assert number of violations. */69fun assertSize(report: Report, size: Int): List<RuleViolation> {70    assertEquals(size, report.violations.size, message = "Wrong number of violations!")71    return report.violations72}73/** Assert number of suppressed violations. */74fun assertSuppressed(report: Report, size: Int): List<Report.SuppressedViolation> {75    assertEquals(size, report.suppressedViolations.size, message = "Wrong number of suppressed violations!")76    return report.suppressedViolations77}78/** Checks the coordinates of this node. */79fun Node.assertPosition(bline: Int, bcol: Int, eline: Int, ecol: Int) {80    this::getBeginLine shouldBe bline81    this::getBeginColumn shouldBe bcol82    this::getEndLine shouldBe eline83    this::getEndColumn shouldBe ecol84}...

UUIDValueObjectSpec.kt

Source:UUIDValueObjectSpec.kt

1package com.musinsa.shared.domain.valueobject2import io.kotest.assertions.throwables.shouldThrow3import io.kotest.core.spec.style.DescribeSpec4import io.kotest.matchers.shouldBe5import io.kotest.matchers.shouldNotBe6import io.kotest.property.checkAll7import io.kotest.property.exhaustive.exhaustive8private class TestUUIDValueObject(value: String) : UUIDValueObject(value)9private fun createUUIDValueObject(10    value: String = java.util.UUID.randomUUID().toString()11): UUIDValueObject {12    return TestUUIDValueObject(value)13}14class UUIDSpec : DescribeSpec(15    {16        val uuids = List(100) {17            createUUIDValueObject()18        }.exhaustive()19        describe("init") {20            it("should throw an exception when an invalid UUID string") {21                checkAll<String>(100) {22                    shouldThrow<IllegalArgumentException> {23                        TestUUIDValueObject(it)24                    }25                }26            }27        }28        describe("equals()") {29            it("should be able equivalence comparisons") {30                uuids.checkAll { uuid ->31                    val nullObject = null32                    (uuid == uuid) shouldBe true33                    (uuid == nullObject) shouldBe false34                    (uuid.equals(object {})) shouldBe false35                    val clone = createUUIDValueObject(uuid.value)36                    (uuid == clone) shouldBe true37                    val other = createUUIDValueObject()38                    (uuid == other) shouldBe false39                }40            }41        }42        describe("hashCode()") {43            it("should return same value if some objects are checked for equality") {44                uuids.checkAll { uuid ->45                    val clone = createUUIDValueObject(uuid.value)46                    (uuid == clone) shouldBe true47                    uuid.hashCode() shouldBe clone.hashCode()48                    val other = createUUIDValueObject()49                    uuid.hashCode() shouldNotBe other.hashCode()50                }51            }52        }53        describe("toString()") {54            it("should return string of properties") {55                uuids.checkAll { uuid ->56                    with(uuid) {57                        val expected = "TestUUIDValueObject(value=$value)"58                        toString() shouldBe expected59                    }60                }61            }62        }63    }64)...

CodiSpec.kt

Source:CodiSpec.kt

1package com.musinsa.codi.domain.entity2import com.musinsa.codi.faker.clone3import com.musinsa.codi.faker.codi4import io.kotest.core.spec.style.DescribeSpec5import io.kotest.matchers.shouldBe6import io.kotest.matchers.shouldNotBe7import io.kotest.property.arbitrary.arbitrary8import io.kotest.property.checkAll9class CodiSpec : DescribeSpec(10    {11        val codiArb = arbitrary { codi() }12        describe("equals()") {13            it("should be able equivalence comparisons") {14                codiArb.checkAll(100) { codi ->15                    val nullObject = null16                    (codi == codi) shouldBe true17                    (codi == nullObject) shouldBe false18                    (codi.equals(object {})) shouldBe false19                    val clone = codi.clone()20                    (codi === clone) shouldBe false21                    (codi == clone) shouldBe true22                    val other = codi()23                    (codi == other) shouldBe false24                }25            }26        }27        describe("hashCode()") {28            it("should return same value if some objects are checked for equality") {29                codiArb.checkAll(100) { codi ->30                    val clone = codi.clone()31                    (codi == clone) shouldBe true32                    codi.hashCode() shouldBe clone.hashCode()33                    val other = codi()34                    codi.hashCode() shouldNotBe other.hashCode()35                }36            }37        }38        describe("toString()") {39            it("should return string of properties") {40                codiArb.checkAll(100) { codi ->41                    with(codi) {42                        val expected = "Codi(id=$id, type=$type, sourceId=$sourceId, thumbnail=$thumbnail, " +43                            "viewCount=$viewCount, commentCount=$commentCount, relatedGoods=$relatedGoods, " +44                            "labels=$labels, siteKind=$siteKind, sex=$sex, useYn=$useYn, createdAt=$createdAt, " +45                            "updatedAt=$updatedAt, lastCommentAddedAt=$lastCommentAddedAt)"46                        toString() shouldBe expected47                    }48                }49            }50        }51    }52)...

GoodsSpec.kt

Source:GoodsSpec.kt

1package com.musinsa.codi.domain.entity2import com.musinsa.codi.faker.clone3import com.musinsa.codi.faker.goods4import io.kotest.core.spec.style.DescribeSpec5import io.kotest.matchers.shouldBe6import io.kotest.matchers.shouldNotBe7import io.kotest.property.arbitrary.arbitrary8import io.kotest.property.checkAll9class GoodsSpec : DescribeSpec(10    {11        val goodsArb = arbitrary { goods() }12        describe("equals()") {13            it("should be able equivalence comparisons") {14                goodsArb.checkAll(100) { goods ->15                    val nullObject = null16                    (goods == goods) shouldBe true17                    (goods == nullObject) shouldBe false18                    (goods.equals(object {})) shouldBe false19                    val clone = goods.clone()20                    (goods === clone) shouldBe false21                    (goods == clone) shouldBe true22                    val other = goods()23                    (goods == other) shouldBe false24                }25            }26        }27        describe("hashCode()") {28            it("should return same value if some objects are checked for equality") {29                goodsArb.checkAll(100) { goods ->30                    val clone = goods.clone()31                    (goods == clone) shouldBe true32                    goods.hashCode() shouldBe clone.hashCode()33                    val other = goods()34                    goods.hashCode() shouldNotBe other.hashCode()35                }36            }37        }38        describe("toString()") {39            it("should return string of properties") {40                goodsArb.checkAll(100) { goods ->41                    with(goods) {42                        val expected =43                            "Goods(no=$no, seqNo=$seqNo, name=$name, brand=$brand, itemCategory=$itemCategory, " +44                                "image=$image, status=$status, price=$price, netPrice=$netPrice, " +45                                "discountRate=$discountRate, color=$color, createdAt=$createdAt)"46                        toString() shouldBe expected47                    }48                }49            }50        }51    }52)...

EntitySpec.kt

Source:EntitySpec.kt

1package com.musinsa.shared.domain.entity2import io.kotest.core.spec.style.DescribeSpec3import io.kotest.matchers.shouldBe4import io.kotest.matchers.shouldNotBe5import io.kotest.property.checkAll6import io.kotest.property.exhaustive.exhaustive7import java.util.UUID8private class TestEntity(value: String) : Entity<String>(value) {9    fun clone(): TestEntity {10        val idField = javaClass.superclass.getDeclaredField("id")11        idField.isAccessible = true12        return TestEntity(idField.get(this) as String)13    }14}15private fun createEntity(value: String = UUID.randomUUID().toString()): TestEntity {16    return TestEntity(value)17}18class EntitySpec : DescribeSpec(19    {20        val entities = List(100) {21            createEntity()22        }.exhaustive()23        describe("equals()") {24            it("should be able equivalence comparisons") {25                entities.checkAll { entity ->26                    val nullObject = null27                    (entity == entity) shouldBe true28                    (entity == nullObject) shouldBe false29                    (entity.equals(object {})) shouldBe false30                    val clone = entity.clone()31                    (entity == clone) shouldBe true32                    val other = createEntity()33                    (entity == other) shouldBe false34                }35            }36        }37        describe("hashCode()") {38            it("should return same value if some objects are checked for equality") {39                entities.checkAll { entity ->40                    val clone = entity.clone()41                    (entity == clone) shouldBe true42                    entity.hashCode() shouldBe clone.hashCode()43                    val other = createEntity()44                    entity.hashCode() shouldNotBe other.hashCode()45                }46            }47        }48    }49)...

BrandSpec.kt

Source:BrandSpec.kt

1package com.musinsa.codi.domain.entity2import com.musinsa.codi.faker.brand3import com.musinsa.codi.faker.clone4import io.kotest.core.spec.style.DescribeSpec5import io.kotest.matchers.shouldBe6import io.kotest.matchers.shouldNotBe7import io.kotest.property.arbitrary.arbitrary8import io.kotest.property.checkAll9class BrandSpec : DescribeSpec(10    {11        val brandArb = arbitrary { brand() }12        describe("equals()") {13            it("should be able equivalence comparisons") {14                brandArb.checkAll(100) { brand ->15                    val nullObject = null16                    (brand == brand) shouldBe true17                    (brand == nullObject) shouldBe false18                    (brand.equals(object {})) shouldBe false19                    val clone = brand.clone()20                    (brand === clone) shouldBe false21                    (brand == clone) shouldBe true22                    val other = brand()23                    (brand == other) shouldBe false24                }25            }26        }27        describe("hashCode()") {28            it("should return same value if some objects are checked for equality") {29                brandArb.checkAll(100) { brand ->30                    val clone = brand.clone()31                    (brand == clone) shouldBe true32                    brand.hashCode() shouldBe clone.hashCode()33                    val other = brand()34                    brand.hashCode() shouldNotBe other.hashCode()35                }36            }37        }38        describe("toString()") {39            it("should return string of properties") {40                brandArb.checkAll(100) { brand ->41                    with(brand) {42                        toString() shouldBe "Brand(code=$code, name=$name)"43                    }44                }45            }46        }47    }48)...

IdentityValidatorTest.kt

Source:IdentityValidatorTest.kt

1package ru.fix.distributed.job.manager2import io.kotest.assertions.throwables.shouldThrow3import io.kotest.matchers.booleans.shouldBeFalse4import io.kotest.matchers.booleans.shouldBeTrue5import org.junit.jupiter.api.Test6import ru.fix.distributed.job.manager.IdentityValidator.IdentityType.JobId7import ru.fix.distributed.job.manager.IdentityValidator.validate8class IdentityValidatorTest {9    @Test10    fun `Identity with correct symbols can be created`() {11        validate(JobId, "foo-is_a5.6")12    }13    @Test14    fun `Identity with incorrect symbols can not be created`() {15        shouldThrow<Exception> { validate(JobId, "withCyrillicSymbol-Ñ") }16        shouldThrow<Exception> { validate(JobId, "with:colon") }17        shouldThrow<Exception> { validate(JobId, "with/slash") }18        shouldThrow<Exception> { validate(JobId, "with\\backslash") }19        shouldThrow<Exception> { validate(JobId, " withSpacePrefix") }20        shouldThrow<Exception> { validate(JobId, "with space") }21    }22    @Test23    fun `JobId equality based on String id equality`() {24        JobId("foo").equals(JobId("foo")).shouldBeTrue()25        JobId("foo").equals(JobId("bar")).shouldBeFalse()26    }27}...

Equality

Using AI Code Generation

1    import io.kotest.matchers.shouldBe2    import io.kotest.matchers.shouldNotBe3    import io.kotest.matchers.shouldThrow4    import io.kotest.assertions.throwables.shouldThrowAny5    import io.kotest.assertions.throwables.shouldThrowExactly6    import io.kotest.assertions.throwables.shouldThrowExactlyWithMessage7    import io.kotest.assertions.throwables.shouldThrowWithMessage8    import io.kotest.assertions.throwables.shouldThrowWithMessageContaining9    import io.kotest.matchers.shouldBe10    import io.kotest.matchers.shouldNotBe11    import io.kotest.matchers.shouldBeInstanceOf12    import io.kotest.matchers.shouldNotBeInstanceOf13    import io.kotest.matchers.shouldBeOneOf14    import io.kotest.matchers.shouldNotBeOneOf15    import io.kotest.matchers.shouldBeInRange16    import io.kotest.matchers.shouldNotBeInRange17    import io.kotest.matchers.shouldBeGreaterThan18    import io.kotest.matchers.shouldBeGreaterThanOrEqual19    import io.kotest.matchers.shouldBeLessThan20    import io.kotest.matchers.shouldBeLessThanOrEqual21    import io.kotest.matchers.shouldBePositive22    import io.kotest.matchers.shouldBeNegative23    import io.kotest.matchers.shouldBeZero24    import io.kotest.matchers.shouldBeTrue25    import io.kotest.matchers.shouldBeFalse26    import io.kotest.matchers.shouldBeBlank27    import io.kotest.matchers.shouldNotBeBlank28    import io.kotest.matchers.shouldBeEmpty29    import io.kotest.matchers.shouldNotBeEmpty30    import io.kotest.matchers.shouldBeNullOrEmpty31    import io.kotest.matchers.shouldBeNullOrBlank32    import io.kotest.matchers.shouldBeSingle33    import io.kotest.matchers.shouldBeFinite34    import io.kotest.matchers.shouldBeInfinite35    import io.kotest.matchers.shouldBeNaN36    import io.kotest.matchers.shouldBeNaNOrInfinite37    import io.kotest.matchers.shouldBeSimilar38    import io.kotest.matchers.should

Equality

Using AI Code Generation

1    import io.kotest.matchers.shouldBe2    import io.kotest.matchers.shouldNotBe3    data class Person(val name: String, val age: Int)4    fun main() {5      val p1 = Person("John", 20)6      val p2 = Person("John", 20)7    }8    import io.kotest.matchers.shouldBe9    import io.kotest.matchers.shouldNotBe10    fun main() {11    }

Equality

Using AI Code Generation

1class Person(val name: String, val age: Int) {2override fun equals(other: Any?): Boolean = this.equality(other) { Person(it.name, it.age) }3override fun hashCode(): Int = this.hashcode(Person::name, Person::age)4}5val p1 = Person("john", 30)6val p2 = Person("john", 30)7class Person(val name: String, val age: Int) {8override fun equals(other: Any?): Boolean = this.equality(other) { Person(it.name, it.age) }9override fun hashCode(): Int = this.hashcode(Person::name, Person::age)10}11val p1 = Person("john", 30)12val p2 = Person("john", 30)13class Person(val name: String, val age: Int) {14override fun equals(other: Any?): Boolean = this.equality(other) { Person(it.name, it.age) }15override fun hashCode(): Int = this.hashcode(Person::name, Person::age)16}17val p1 = Person("john", 30)18val p2 = Person("john", 30)19class Person(val name: String, val age: Int) {20override fun equals(other: Any?): Boolean = this.equality(other) { Person(it.name, it.age) }21override fun hashCode(): Int = this.hashcode(Person::name, Person::age)22}23val p1 = Person("john", 30)24val p2 = Person("john", 30)25class Person(val name: String, val age: Int) {26override fun equals(other: Any

Equality

Using AI Code Generation

1data class Person(val name: String, val age: Int)2val p1 = Person("John", 20)3val p2 = Person("John", 20)4data class Person(val name: String, val age: Int)5val p1 = Person("John", 20)6val p2 = Person("John", 20)7data class Person(val name: String, val age: Int)8val p1 = Person("John", 20)9val p2 = Person("John", 20)10data class Person(val name: String, val age: Int)11val p1 = Person("John", 20)12val p2 = Person("John", 20)13data class Person(val name: String, val age: Int)14val p1 = Person("John", 20)15val p2 = Person("John", 20)16data class Person(val name: String, val age: Int)17val p1 = Person("John", 20)18val p2 = Person("John", 20)19data class Person(val name: String, val age: Int)20val p1 = Person("John", 20)21val p2 = Person("John", 20)22data class Person(val name: String, val age: Int)

Equality

Using AI Code Generation

1val person = Person("John", "Doe")2person.shouldBe(Person("John", "Doe"))3val person = Person("John", "Doe")4person.shouldBe(Person("John", "Doe"))5val person = Person("John", "Doe")6person.shouldBe(Person("John", "Doe"))7val person = Person("John", "Doe")8person.shouldBe(Person("John", "Doe"))9val person = Person("John", "Doe")10person.shouldBe(Person("John", "Doe"))11val person = Person("John", "Doe")12person.shouldBe(Person("John", "Doe"))13val person = Person("John", "Doe")14person.shouldBe(Person("John", "Doe"))15val person = Person("John", "Doe")16person.shouldBe(Person("John", "Doe"))17val person = Person("John", "Doe")18person.shouldBe(Person("John", "Doe"))19val person = Person("John", "Doe")20person.shouldBe(Person("John", "Doe"))21val person = Person("John", "Doe")22person.shouldBe(Person("John", "Doe"))23val person = Person("John", "Doe")24person.shouldBe(Person("John", "Doe"))25val person = Person("John", "Doe")26person.shouldBe(Person("John", "Doe"))27val person = Person("John", "Doe")28person.shouldBe(Person("John",

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.