Best Kotest code snippet using io.kotest.matchers.short.ushort
KotlinMetadataAnnotationUnsignedTest.kt
Source:KotlinMetadataAnnotationUnsignedTest.kt
1/*2 * ProGuardCORE -- library to process Java bytecode.3 *4 * Copyright (c) 2002-2020 Guardsquare NV5 *6 * Licensed under the Apache License, Version 2.0 (the "License");7 * you may not use this file except in compliance with the License.8 * You may obtain a copy of the License at9 *10 * http://www.apache.org/licenses/LICENSE-2.011 *12 * Unless required by applicable law or agreed to in writing, software13 * distributed under the License is distributed on an "AS IS" BASIS,14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.15 * See the License for the specific language governing permissions and16 * limitations under the License.17 */18package proguard.classfile.kotlin19import io.kotest.common.ExperimentalKotest20import io.kotest.core.spec.style.FreeSpec21import io.kotest.datatest.withData22import io.kotest.matchers.shouldBe23import io.mockk.spyk24import io.mockk.verify25import proguard.classfile.kotlin.visitor.AllKotlinAnnotationArgumentVisitor26import proguard.classfile.kotlin.visitor.AllKotlinAnnotationVisitor27import proguard.classfile.kotlin.visitor.AllTypeAliasVisitor28import proguard.classfile.kotlin.visitor.KotlinAnnotationArgumentVisitor29import testutils.ClassPoolBuilder30import testutils.KotlinSource31import testutils.ReWritingMetadataVisitor32@OptIn(ExperimentalKotest::class)33class KotlinMetadataAnnotationUnsignedTest : FreeSpec({34 withData(35 UnsignedTestValues(36 name = "Unsigned zero should be converted to signed 0",37 uByte = "0u" expect 0,38 uShort = "0u" expect 0,39 uInt = "0u" expect 0,40 uLong = "0u" expect 0L41 ),42 UnsignedTestValues(43 name = "Unsigned MAX_VALUE should be converted to signed -1",44 uByte = "UByte.MAX_VALUE" expect -1,45 uShort = "UShort.MAX_VALUE" expect -1,46 uInt = "UInt.MAX_VALUE" expect -1,47 uLong = "ULong.MAX_VALUE" expect -1L48 ),49 UnsignedTestValues(50 name = "Unsigned MIN_VALUE should be converted to signed 0",51 uByte = "UByte.MIN_VALUE" expect 0,52 uShort = "UShort.MIN_VALUE" expect 0,53 uInt = "UInt.MIN_VALUE" expect 0,54 uLong = "ULong.MIN_VALUE" expect 0L55 ),56 UnsignedTestValues(57 name = "Unsigned (MAX_VALUE - 1) should be converted to signed -2",58 uByte = "${UByte.MAX_VALUE - 1u}u" expect -2,59 uShort = "${UShort.MAX_VALUE - 1u}u" expect -2,60 uInt = "${UInt.MAX_VALUE - 1u}u" expect -2,61 uLong = "${ULong.MAX_VALUE - 1u}u" expect -2,62 ),63 UnsignedTestValues(64 name = "Unsigned (MIN_VALUE + 1) should be converted to signed 1",65 uByte = "${UByte.MIN_VALUE + 1u}u" expect 1,66 uShort = "${UShort.MIN_VALUE + 1u}u" expect 1,67 uInt = "${UInt.MIN_VALUE + 1u}u" expect 1,68 uLong = "${ULong.MIN_VALUE + 1u}u" expect 1,69 ),70 ) { (_, uByte, uShort, uInt, uLong) ->71 val (programClassPool, _) = ClassPoolBuilder.fromSource(72 KotlinSource(73 "TestUnsigned.kt",74 """75 @Target(AnnotationTarget.TYPEALIAS)76 annotation class MyTypeAliasAnnotationWithUnsigned(77 val uByte: UByte,78 val uShort: UShort,79 val uInt: UInt,80 val uLong: ULong,81 )82 @MyTypeAliasAnnotationWithUnsigned(83 uByte = ${uByte.first},84 uShort = ${uShort.first},85 uInt = ${uInt.first},86 uLong = ${uLong.first}87 )88 typealias myAliasWithUnsigned = String89 """.trimIndent()90 ),91 kotlincArguments = listOf("-Xuse-experimental=kotlin.ExperimentalUnsignedTypes")92 )93 val annotationArgVisitor = spyk<KotlinAnnotationArgumentVisitor>()94 val clazz = programClassPool.getClass("TestUnsignedKt")95 programClassPool.classesAccept(96 clazz.name,97 ReWritingMetadataVisitor(98 AllTypeAliasVisitor(99 AllKotlinAnnotationVisitor(100 AllKotlinAnnotationArgumentVisitor(annotationArgVisitor)101 )102 )103 )104 )105 verify(exactly = 1) {106 annotationArgVisitor.visitUByteArgument(107 clazz,108 ofType<KotlinAnnotatable>(),109 ofType<KotlinAnnotation>(),110 withArg { it.name shouldBe "uByte" },111 KotlinAnnotationArgument.UByteValue(uByte.second)112 )113 annotationArgVisitor.visitUShortArgument(114 clazz,115 ofType<KotlinAnnotatable>(),116 ofType<KotlinAnnotation>(),117 withArg { it.name shouldBe "uShort" },118 KotlinAnnotationArgument.UShortValue(uShort.second)119 )120 annotationArgVisitor.visitUIntArgument(121 clazz,122 ofType<KotlinAnnotatable>(),123 ofType<KotlinAnnotation>(),124 withArg { it.name shouldBe "uInt" },125 KotlinAnnotationArgument.UIntValue(uInt.second)126 )127 annotationArgVisitor.visitULongArgument(128 clazz,129 ofType<KotlinAnnotatable>(),130 ofType<KotlinAnnotation>(),131 withArg { it.name shouldBe "uLong" },132 KotlinAnnotationArgument.ULongValue(uLong.second)133 )134 }135 }136})137private data class UnsignedTestValues(138 val name: String,139 val uByte: Pair<String, Byte>,140 val uShort: Pair<String, Short>,141 val uInt: Pair<String, Int>,142 val uLong: Pair<String, Long>143) {144 override fun toString(): String = name145}146private inline infix fun <reified T : Number> String.expect(value: T) = Pair(this, value)...
ByteBufShortTest.kt
Source:ByteBufShortTest.kt
1/*2 * Copyright 2018-2021 Guthix3 *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 */16package io.guthix.buffer.bytebuf17import io.guthix.buffer.*18import io.kotest.core.spec.style.StringSpec19import io.kotest.matchers.ints.shouldBeNonNegative20import io.kotest.matchers.shouldBe21import io.kotest.property.Arb22import io.kotest.property.arbitrary.*23import io.kotest.property.checkAll24import io.netty.buffer.ByteBuf25import io.netty.buffer.ByteBufAllocator26private suspend fun doShortGSTest(27 setter: ByteBuf.(Int, Int) -> ByteBuf,28 getter: ByteBuf.(Int) -> Short29) = checkAll(Arb.shortArray(collectionSizeArb, Arb.short())) { testData ->30 val buf = ByteBufAllocator.DEFAULT.buffer(testData.size * Short.SIZE_BYTES)31 try {32 testData.forEachIndexed { i, expected -> buf.setter(i * Short.SIZE_BYTES, expected.toInt()) }33 testData.forEachIndexed { i, expected ->34 val get = buf.getter(i * Short.SIZE_BYTES)35 get shouldBe expected36 }37 } finally {38 buf.release()39 }40}41private suspend fun doShortRWTest(42 writer: ByteBuf.(Int) -> ByteBuf,43 reader: ByteBuf.() -> Short44) = checkAll(Arb.shortArray(collectionSizeArb, Arb.short())) { testData ->45 val buf = ByteBufAllocator.DEFAULT.buffer(testData.size * Short.SIZE_BYTES)46 try {47 testData.forEach { expected -> buf.writer(expected.toInt()) }48 testData.forEach { expected ->49 val read = buf.reader()50 read shouldBe expected51 }52 } finally {53 buf.release()54 }55}56@ExperimentalUnsignedTypes57private suspend fun doUShortGSTest(58 setter: ByteBuf.(Int, Int) -> ByteBuf,59 getter: ByteBuf.(Int) -> Int60) = checkAll(Arb.uShortArray(collectionSizeArb, Arb.uShort())) { testData ->61 val buf = ByteBufAllocator.DEFAULT.buffer(testData.size * UShort.SIZE_BYTES)62 try {63 testData.forEachIndexed { i, expected -> buf.setter(i * UShort.SIZE_BYTES, expected.toInt()) }64 testData.forEachIndexed { i, expected ->65 val get = buf.getter(i * UShort.SIZE_BYTES)66 get.shouldBeNonNegative()67 get shouldBe expected.toInt()68 }69 } finally {70 buf.release()71 }72}73@ExperimentalUnsignedTypes74private suspend fun doUShortRWTest(75 writer: ByteBuf.(Int) -> ByteBuf,76 reader: ByteBuf.() -> Int77) = checkAll(Arb.uShortArray(collectionSizeArb, Arb.uShort())) { testData ->78 val buf = ByteBufAllocator.DEFAULT.buffer(testData.size * UShort.SIZE_BYTES)79 try {80 testData.forEach { expected -> buf.writer(expected.toInt()) }81 testData.forEach { expected ->82 val read = buf.reader()83 read.shouldBeNonNegative()84 read shouldBe expected.toInt()85 }86 } finally {87 buf.release()88 }89}90@ExperimentalUnsignedTypes91class ByteBufShortTest : StringSpec({92 "Get/Set Short add" { doShortGSTest(ByteBuf::setShortAdd, ByteBuf::getShortAdd) }93 "Read/Write Short add" { doShortRWTest(ByteBuf::writeShortAdd, ByteBuf::readShortAdd) }94 "Unsigned Get/Set Short add" { doUShortGSTest(ByteBuf::setShortAdd, ByteBuf::getUnsignedShortAdd) }95 "Unsigned Read/Write Short add" { doUShortRWTest(ByteBuf::writeShortAdd, ByteBuf::readUnsignedShortAdd) }96 "Get/Set Short LE add" { doShortGSTest(ByteBuf::setShortLEAdd, ByteBuf::getShortLEAdd) }97 "Read/Write Short LE add" { doShortRWTest(ByteBuf::writeShortLEAdd, ByteBuf::readShortLEAdd) }98 "Unsigned Get/Set Short LE add" { doUShortGSTest(ByteBuf::setShortLEAdd, ByteBuf::getUnsignedShortLEAdd) }99 "Unsigned Read/Write Short LE add" { doUShortRWTest(ByteBuf::writeShortLEAdd, ByteBuf::readUnsignedShortLEAdd) }100})...
JagMessageSerializationShortTest.kt
Source:JagMessageSerializationShortTest.kt
1/*2 * Copyright 2018-2021 Guthix3 *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 */16package io.guthix.buffer17import io.kotest.core.spec.style.StringSpec18import io.kotest.matchers.shouldBe19import io.kotest.property.checkAll20import io.netty.buffer.ByteBufAllocator21import kotlinx.serialization.ExperimentalSerializationApi22import kotlinx.serialization.Serializable23@ExperimentalSerializationApi24@Serializable25private data class ShortTest(26 @JShort(JShortType.DEFAULT) val default: Short,27 @JShort(JShortType.LE) val le: Short,28 @JShort(JShortType.ADD) val add: Short,29 @JShort(JShortType.LE_ADD) val leAdd: Short30)31@ExperimentalSerializationApi32@Serializable33private data class UShortTest(34 @JShort(JShortType.DEFAULT) val default: UShort,35 @JShort(JShortType.LE) val le: UShort,36 @JShort(JShortType.ADD) val add: UShort,37 @JShort(JShortType.LE_ADD) val leAdd: UShort38)39@ExperimentalUnsignedTypes40@ExperimentalSerializationApi41class JagMessageSerializationShortTest : StringSpec({42 "Encode/Decode Test" {43 checkAll<Short, Short, Short, Short> { default, le, add, leAdd ->44 val expectedByteBuf = ByteBufAllocator.DEFAULT.jBuffer(Short.SIZE_BYTES * 4).apply {45 writeShort(default.toInt())46 writeShortLE(le.toInt())47 writeShortAdd(add.toInt())48 writeShortLEAdd(leAdd.toInt())49 }50 try {51 val expectedTest = ShortTest(default, le, add, leAdd)52 val actualByteBuf = JagMessage.encodeToByteBuf(ShortTest.serializer(), expectedTest)53 try {54 actualByteBuf shouldBe expectedByteBuf55 val actualTest = JagMessage.decodeFromByteBuf(ShortTest.serializer(), expectedByteBuf)56 actualTest shouldBe expectedTest57 } finally {58 actualByteBuf.release()59 }60 } finally {61 expectedByteBuf.release()62 }63 }64 }65 "Unsigned Encode/Decode Test" {66 checkAll<UShort, UShort, UShort, UShort> { default, le, add, leAdd ->67 val expectedByteBuf = ByteBufAllocator.DEFAULT.jBuffer(UShort.SIZE_BYTES * 4).apply {68 writeShort(default.toInt())69 writeShortLE(le.toInt())70 writeShortAdd(add.toInt())71 writeShortLEAdd(leAdd.toInt())72 }73 try {74 val expectedTest = UShortTest(default, le, add, leAdd)75 val actualByteBuf = JagMessage.encodeToByteBuf(UShortTest.serializer(), expectedTest)76 try {77 actualByteBuf shouldBe expectedByteBuf78 val actualTest = JagMessage.decodeFromByteBuf(UShortTest.serializer(), expectedByteBuf)79 actualTest shouldBe expectedTest80 } finally {81 actualByteBuf.release()82 }83 } finally {84 expectedByteBuf.release()85 }86 }87 }88})...
ByteBufShortSmart.kt
Source:ByteBufShortSmart.kt
1/*2 * Copyright 2018-2021 Guthix3 *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 */16package io.guthix.buffer.bytebuf17import io.guthix.buffer.*18import io.kotest.core.spec.style.StringSpec19import io.kotest.matchers.ints.shouldBeNonNegative20import io.kotest.matchers.shouldBe21import io.kotest.property.Arb22import io.kotest.property.arbitrary.*23import io.kotest.property.checkAll24import io.netty.buffer.ByteBuf25import io.netty.buffer.ByteBufAllocator26private suspend fun doShortSmartRWTest(27 writer: ByteBuf.(Int) -> ByteBuf,28 reader: ByteBuf.() -> Short29) = checkAll(30 Arb.shortArray(collectionSizeArb, Arb.short(Smart.MIN_SHORT_VALUE.toShort(), Smart.MAX_SHORT_VALUE.toShort()))31) { testData ->32 val buf = ByteBufAllocator.DEFAULT.buffer(testData.size * Short.SIZE_BYTES)33 try {34 testData.forEach { expected -> buf.writer(expected.toInt()) }35 testData.forEach { expected ->36 val read = buf.reader()37 read shouldBe expected38 }39 } finally {40 buf.release()41 }42}43@ExperimentalUnsignedTypes44private suspend fun doUShortSmartRWTest(45 writer: ByteBuf.(Int) -> ByteBuf,46 reader: ByteBuf.() -> Short47) = checkAll(48 Arb.uShortArray(collectionSizeArb, Arb.uShort(USmart.MIN_SHORT_VALUE.toUShort(), USmart.MAX_SHORT_VALUE.toUShort()))49) { testData ->50 val buf = ByteBufAllocator.DEFAULT.buffer(testData.size * Short.SIZE_BYTES)51 try {52 testData.forEach { expected -> buf.writer(expected.toInt()) }53 testData.forEach { expected ->54 val read = buf.reader()55 read.toInt().shouldBeNonNegative()56 read shouldBe expected.toInt()57 }58 } finally {59 buf.release()60 }61}62@ExperimentalUnsignedTypes63private suspend fun doIncrShortSmartRWTest(64 writer: ByteBuf.(Int) -> ByteBuf,65 reader: ByteBuf.() -> Int66) = checkAll(Arb.intArray(collectionSizeArb, Arb.int(0, 100_000))) { testData ->67 val buf = ByteBufAllocator.DEFAULT.buffer()68 try {69 testData.forEach { expected -> buf.writer(expected) }70 testData.forEach { expected ->71 val read = buf.reader()72 read.shouldBeNonNegative()73 read shouldBe expected74 }75 } finally {76 buf.release()77 }78}79@ExperimentalUnsignedTypes80class ByteBufShortSmartTest : StringSpec({81 "Read/Write Short Smart" { doShortSmartRWTest(ByteBuf::writeShortSmart, ByteBuf::readShortSmart) }82 "Unsigned Read/Write Short Smart" {83 doUShortSmartRWTest(ByteBuf::writeUnsignedShortSmart, ByteBuf::readUnsignedShortSmart)84 }85 "Unsigned Read/Write Incr Short Smart" {86 doIncrShortSmartRWTest(ByteBuf::writeIncrShortSmart, ByteBuf::readIncrShortSmart)87 }88})...
JagMessageSerializationShortSmartTest.kt
Source:JagMessageSerializationShortSmartTest.kt
1/*2 * Copyright 2018-2021 Guthix3 *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 */16package io.guthix.buffer17import io.kotest.core.spec.style.StringSpec18import io.kotest.matchers.shouldBe19import io.kotest.property.Arb20import io.kotest.property.arbitrary.short21import io.kotest.property.arbitrary.uShort22import io.kotest.property.checkAll23import io.netty.buffer.ByteBufAllocator24import kotlinx.serialization.ExperimentalSerializationApi25import kotlinx.serialization.Serializable26@ExperimentalSerializationApi27@Serializable28private data class ShortSmartTest(29 @JShortSmart val default: Short30)31@ExperimentalSerializationApi32@Serializable33private data class UShortSmartTest(34 @JShortSmart val default: UShort35)36@ExperimentalUnsignedTypes37@ExperimentalSerializationApi38class JagMessageSerializationShortSmartTest : StringSpec({39 "Encode/Decode Test" {40 checkAll(Arb.short(Smart.MIN_SHORT_VALUE.toShort(), Smart.MAX_SHORT_VALUE.toShort())) { default ->41 val expectedByteBuf = ByteBufAllocator.DEFAULT.jBuffer(Short.SIZE_BYTES).apply {42 writeShortSmart(default.toInt())43 }44 try {45 val expectedTest = ShortSmartTest(default)46 val actualByteBuf = JagMessage.encodeToByteBuf(ShortSmartTest.serializer(), expectedTest)47 try {48 actualByteBuf shouldBe expectedByteBuf49 val actualTest = JagMessage.decodeFromByteBuf(ShortSmartTest.serializer(), expectedByteBuf)50 actualTest shouldBe expectedTest51 } finally {52 actualByteBuf.release()53 }54 } finally {55 expectedByteBuf.release()56 }57 }58 }59 "Unsigned Encode/Decode Test" {60 checkAll(Arb.uShort(USmart.MIN_SHORT_VALUE.toUShort(), USmart.MAX_SHORT_VALUE.toUShort())) { default ->61 val expectedByteBuf = ByteBufAllocator.DEFAULT.jBuffer(UShort.SIZE_BYTES).apply {62 writeUShortSmart(default.toInt())63 }64 try {65 val expectedTest = UShortSmartTest(default)66 val actualByteBuf = JagMessage.encodeToByteBuf(UShortSmartTest.serializer(), expectedTest)67 try {68 actualByteBuf shouldBe expectedByteBuf69 val actualTest = JagMessage.decodeFromByteBuf(UShortSmartTest.serializer(), expectedByteBuf)70 actualTest shouldBe expectedTest71 } finally {72 actualByteBuf.release()73 }74 } finally {75 expectedByteBuf.release()76 }77 }78 }79})...
test.kt
Source:test.kt
1package unsigned2import io.kotest.core.spec.style.StringSpec3import io.kotest.matchers.ints.shouldBeLessThan4import io.kotest.matchers.shouldBe5import java.math.BigInteger6/**7 * Created by elect on 15/10/16.8 */9val Int.b10 get() = toByte()11val Int.s12 get() = toShort()13val Long.b14 get() = toByte()15val Long.s16 get() = toShort()17val Long.i18 get() = toInt()19val BigInteger.L20 get() = toLong()21/**22 * BUG, 0xffffffffffffffff is outside Long range23 * https://youtrack.jetbrains.com/issue/KT-474924 */25val String.hL: Long26 get() = java.lang.Long.parseUnsignedLong(filter { it != '_' && it != '\'' }, 16)27val String.L: Long28 get() = java.lang.Long.parseUnsignedLong(filter { it != '_' && it != '\'' })29val String.bL: Long30 get() = java.lang.Long.parseUnsignedLong(filter { it != '_' && it != '\'' }, 2)31class Unsigned : StringSpec() {32 init {33 "primitive" {34 250.b udiv 50.b shouldBe 5.b35 250.b urem 200.b shouldBe 50.b36 250.b ucmp 251.b shouldBeLessThan 137 250.b ucmp 250.b shouldBe 038 0b1010_1010.b ushr 4 shouldBe 0b1010.b39 65500.s udiv 500.s shouldBe 131.s40 65500.s urem 65000.s shouldBe 500.s41 65500.s ucmp 65501.s shouldBeLessThan 142 65500.s ucmp 65500.s shouldBe 043 0b0100_1100_0011_1101.s ushr 8 shouldBe 0b100_1100.s44 4_000_000_000.i udiv 2 shouldBe 2_000_000_00045 2_750_000_000.i urem 2_000_000_000 shouldBe 750_000_00046 4_000_000_000.i ucmp 4_000_000_001.i shouldBeLessThan 147 4_000_000_000.i ucmp 4_000_000_000.i shouldBe 048 "18_000_000_000_000_000_000".L udiv 2L shouldBe "9'000'000'000'000'000'000".L49 "17'000'000'000'000'000'000".L urem "9'000'000'000'000'000'000".L shouldBe "8'000'000'000'000'000'000".L50 "18'000'000'000'000'000'000".L ucmp "18'000'000'000'000'000'001".L shouldBeLessThan 151 "18'000'000'000'000'000'001".L ucmp "18'000'000'000'000'000'001".L shouldBe 052 }53 "string format" {54 Ubyte(0xff).v.toString() shouldBe "-1"55 Ubyte(0xff).toString() shouldBe "255"56 Ushort(0xffff).v.toString() shouldBe "-1"57 Ushort(0xffff).toString() shouldBe "65535"58 Uint(0xffff_ffff).v.toString() shouldBe "-1"59 Uint(0xffff_ffff).toString() shouldBe "4294967295"60 Ulong(Ulong.MAX_VALUE).v.toString() shouldBe "-1"61 Ulong(Ulong.MAX_VALUE).toString() shouldBe "18446744073709551615"62 Ubyte.MIN.toString(16) shouldBe "0"63 Ubyte.MAX.toString(16) shouldBe "ff"64 Ushort.MIN.toString(16) shouldBe "0"65 Ushort.MAX.toString(16) shouldBe "ffff"66 Uint.MIN.toString(16) shouldBe "0"67 Uint.MAX.toString(16) shouldBe "ffffffff"68 Ulong.MIN.toString(16) shouldBe "0"69 Ulong.MAX.toString(16) shouldBe "ffffffffffffffff"70 Ubyte.MAX.toString("%08x") shouldBe "000000ff"71// (-71777214294589696L).toBinaryString() shouldBe "1111111100000000111111110000000011111111000000001111111100000000"72 }73 }74}...
ShortTest.kt
Source:ShortTest.kt
1package com.sksamuel.kotest.property.arbitrary2import io.kotest.core.spec.style.FunSpec3import io.kotest.data.blocking.forAll4import io.kotest.data.row5import io.kotest.inspectors.forAll6import io.kotest.matchers.short.shouldBeBetween7import io.kotest.matchers.shouldBe8import io.kotest.property.Arb9import io.kotest.property.PropTest10import io.kotest.property.arbitrary.*11import io.kotest.property.checkAll12import io.kotest.property.checkCoverage13class ShortTest : FunSpec({14 test("<Short, Short> should give values between min and max inclusive") {15 // Test parameters include the test for negative bounds16 forAll(17 row(-10, -1),18 row(1, 3),19 row(-100, 100),20 row((Short.MAX_VALUE - 10).toShort(), Short.MAX_VALUE),21 row(Short.MIN_VALUE, (Short.MIN_VALUE + 10).toShort())22 ) { vMin, vMax ->23 val expectedValues = (vMin..vMax).map { it.toShort() }.toSet()24 val actualValues = (1..100_000).map { Arb.short(vMin, vMax).single() }.toSet()25 actualValues shouldBe expectedValues26 }27 }28 test("Arb.short edge cases should respect min and max bounds") {29 checkCoverage("run", 25.0) {30 PropTest(iterations = 1000).checkAll<Short, Short> { min, max ->31 if (min < max) {32 classify("run")33 Arb.short(min, max).edgecases().forAll {34 it.shouldBeBetween(min, max)35 }36 }37 }38 }39 }40})41class UShortTest : FunSpec({42 test("<UShort, UShort> should give values between min and max inclusive") {43 forAll(44 row(1u, 3u),45 row(0u, 100u),46 row((UShort.MAX_VALUE - 10u).toUShort(), UShort.MAX_VALUE),47 row(UShort.MIN_VALUE, (UShort.MIN_VALUE + 10u).toUShort())48 ) { vMin, vMax ->49 val expectedValues = (vMin..vMax).map { it.toUShort() }.toSet()50 val actualValues = (1..100_000).map { Arb.uShort(vMin, vMax).single() }.toSet()51 actualValues shouldBe expectedValues52 }53 }54 test("Arb.uShort edge cases should respect min and max bounds") {55 checkCoverage("run", 25.0) {56 PropTest(iterations = 1000).checkAll<UShort, UShort> { min, max ->57 if (min < max) {58 classify("run")59 Arb.uShort(min, max).edgecases().forAll {60 it.shouldBeBetween(min, max)61 }62 }63 }64 }65 }66})...
ushort.kt
Source:ushort.kt
1package io.kotest.matchers.short2import io.kotest.matchers.Matcher3import io.kotest.matchers.MatcherResult4import io.kotest.matchers.shouldBe5fun UShort.shouldBeBetween(lower: UShort, upper: UShort): UShort {6 this shouldBe between(lower, upper)7 return this8}9fun between(lower: UShort, upper: UShort) = object : Matcher<UShort> {10 override fun test(value: UShort) = MatcherResult(11 value in lower..upper,12 { "$value should be between ($lower, $upper) inclusive" },13 {14 "$value should not be between ($lower, $upper) inclusive"15 })16}...
ushort
Using AI Code Generation
1import io.kotest.matchers.short.shouldBeLessThan2import io.kotest.matchers.int.shouldBeGreaterThan3import io.kotest.matchers.long.shouldBeLessThanOrEqual4import io.kotest.matchers.float.shouldBeGreaterThanOrEqual5import io.kotest.matchers.double.shouldBeBetween6import io.kotest.matchers.string.shouldContain7import io.kotest.matchers.char.shouldBeLowerCase8import io.kotest.matchers.boolean.shouldBeTrue9import io.kotest.matchers.array.shouldContain10import io.kotest.matchers.collection.shouldContain11import io.kotest.matchers.map.shouldContain12import io.kotest.matchers.iterable.shouldContain13import io.kotest.matchers.any.shouldBeInstance14import io.kotest.matchers.function.shouldThrow15import io.kotest.matchers.result.shouldBeFailure16import io.kotest.matchers.option.shouldBeDefined17import io.kotest.matchers.try.shouldBeFailure18import io.kotest.matchers.io.shouldBeEmpty
ushort
Using AI Code Generation
1 import io.kotest.matchers . short . shouldBeLessThan 2 import io.kotest.matchers . int . shouldBeGreaterThan 3 import io.kotest.matchers . long . shouldBeLessThan 4 import io.kotest.matchers . float . shouldBeGreaterThan 5 import io.kotest.matchers . double . shouldBeLessThan6 import io.kotest.matchers . byte . shouldNotBeLessThan 7 import io.kotest.matchers . short . shouldNotBeLessThan 8 import io.kotest.matchers . int . shouldNotBeGreaterThan 9 import io.kotest.matchers . long . shouldNotBeLessThan 10 import io.kotest.matchers . float . shouldNotBeGreaterThan 11 import io.kotest.matchers . double . shouldNotBeLessThan12 import io.kotest.matchers . byte . shouldBeLessThanOrEqualTo 13 import io.kotest.matchers . short . shouldBeLessThanOrEqualTo 14 import io.kotest.matchers . int . shouldBeGreaterThanOrEqualTo 15 import io
ushort
Using AI Code Generation
1 import io.kotest.matchers.shouldBe2 import io.kotest.matchers.shouldNotBe3 import io.kotest.matchers.types.shouldBeSameInstanceAs4 import io.kotest.matchers.shouldBe5 import io.kotest.matchers.shouldNotBe6 import io.kotest.matchers.types.shouldBeSameInstanceAs7 import io.kotest.matchers.shouldBe8 import io.kotest.matchers.shouldNotBe9 import io.kotest.matchers.types.shouldBeSameInstanceAs10 import io.kotest.matchers.shouldBe11 import io.kotest.matchers.shouldNotBe12 import io.kotest.matchers.types.shouldBeSameInstanceAs13 import io.kotest.matchers.shouldBe14 import io.kotest.matchers.shouldNotBe15 import io.kotest.matchers.types.shouldBeSameInstanceAs16 import io.kotest.matchers.shouldBe17 import io.kotest.matchers.shouldNotBe18 import io.kotest.matchers.types.shouldBeSameInstanceAs19 import io.kotest.matchers.shouldBe20 import io.kotest.matchers.shouldNotBe21 import io.kotest.matchers.types.shouldBeSameInstanceAs22 import io.kotest.matchers.shouldBe23 import io.kotest.matchers.shouldNotBe24 import io.kotest.matchers.types.shouldBeSameInstanceAs25 import io.kotest.matchers.shouldBe26 import io.kotest.matchers.shouldNotBe27 import io.kotest.matchers.types.shouldBeSameInstanceAs28 import io
ushort
Using AI Code Generation
1val expected : List<Int> = listOf(1,2,3)2val actual : List<Int> = listOf(1,2,3,4)3val expected : Map<String,Int> = mapOf("one" to 1,"two" to 2,"three" to 3)4val actual : Map<String,Int> = mapOf("one" to 1,"two" to 2,"three" to 3,"four" to 4)5val expected : Array<Int> = arrayOf(1,2,3)6val actual : Array<Int> = arrayOf(1,2,3,4)7val expected : Throwable = RuntimeException()8val actual : Throwable = RuntimeException()9val expected : Result<Int> = Result.success(10)10val actual : Result<Int> = Result.success(20)11val expected : Option<Int> = Option.Some(10)12val actual : Option<Int> = Option.Some(20)
ushort
Using AI Code Generation
1 import io.kotest.matchers.shouldBe2 import io.kotest.matchers.shouldNotBe3 class ShortTest : WordSpec({4 "Short" Should {5 "have the correct value" {6 a shouldBe 1.toShort()7 }8 }9 })
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.
You could also refer to video tutorials over LambdaTest YouTube channel to get step by step demonstration from industry experts.
Get 100 minutes of automation test minutes FREE!!