How to use lines class of io.kotest.matchers.string package

Best Kotest code snippet using io.kotest.matchers.string.lines

S3FileLineRewriterTest.kt

Source:S3FileLineRewriterTest.kt

...38            }39            getFile().contentString shouldBe "abc\nYYY\n123"40        }41        42        test("Rewriting multiple lines with intended modification") {43            createFile("abc\nXXX\nXXX\n123")44            45            rewriteLines { seq ->46                seq.map { it.replace("XXX", "YYY") }47            }48            49            getFile().contentString shouldBe "abc\nYYY\nYYY\n123"50        }51        52        test("Rewriting should preserve metadata") {53           createFile("A", ObjectMetadata().also { it.addUserMetadata("a", "b") })54            rewriteLines { it }55            56            getFile().objectMetadata.getUserMetaDataOf("a") shouldBe "b"...

SudokuSpec.kt

Source:SudokuSpec.kt

...26        shouldThrow<SudokuException> {27            SudokuSolutionExtractor.getSolutionFromFile(filepath)28        } shouldHaveMessage "File abc.xyz doesn't exist or it's a directory"29    }30    "SudokuSolutionExtractor should throw exception when file contains invalid number of lines" {31        val filepath = this::class.java.classLoader.getResource("invalid_number_of_lines.txt")?.path ?: ""32        shouldThrow<SudokuException> {33            SudokuSolutionExtractor.getSolutionFromFile(filepath)34        } shouldHaveMessage "Input data has invalid number of lines: 8 (should be 9)"35    }36    "SudokuSolutionExtractor should throw exception when file contains invalid data" {37        val filepath = this::class.java.classLoader.getResource("contains_letter.txt")?.path ?: ""38        shouldThrow<SudokuException> {39            SudokuSolutionExtractor.getSolutionFromFile(filepath)40        } shouldHaveMessage "Line 6 should match the regex \"([1-9],){8}[1-9]\", but it didn't: 9,5,1,7,X,3,6,2,8"41    }42    "SudokuValidator should validate solution" {43        val solution = listOf(44            listOf(4, 3, 5, 2, 6, 9, 7, 8, 1),45            listOf(6, 8, 2, 5, 7, 1, 4, 9, 3),46            listOf(1, 9, 7, 8, 3, 4, 5, 6, 2),47            listOf(8, 2, 6, 1, 9, 5, 3, 4, 7),48            listOf(3, 7, 4, 6, 8, 2, 9, 1, 5),...

PasswordPhilosophyTest.kt

Source:PasswordPhilosophyTest.kt

...44            }45        }46        context("All passports valid") {47            it("Returns size of input") {48                checkAll(Arb.list(Arb.stringPattern("[a-z]{0,100}"))) { lines ->49                    p.passwordPhilosophy(lines.map { code -> "1-${code.length} ${code[0]}: " + code }) shouldBe lines.size50                }51            }52        }53        context("Any number of passports") {54            it("Number of valid passports less than total number of passports") {55                checkAll(Arb.list(Arb.stringPattern("[1-9]-[1-9][1-9] [a-z]: ([a-z]{1,50})"))) { l ->56                    p.passwordPhilosophy(l) shouldBeLessThanOrEqual l.size57                }58            }59        }60        context("Incorrect format") {61            it("throws IllegalArgumentException") {62                checkAll(Arb.list(Arb.string()).filter { it.isNotEmpty() }) { s ->63                    shouldThrow<IllegalArgumentException> {64                        p.passwordPhilosophy(s)65                    }66                }67            }68        }69    }70    describe("passwordPhilosophy2") {71        context("Sample test") {72            val ans = 72973            it("returns $ans") {74                val actual = p.passwordPhilosophy2(inputFile)75                actual shouldBe ans76            }77        }78        context("Zero, one, and two occurrences of the character") {79            it("Returns 1 valid passports") {80                val actual = p.passwordPhilosophy2(81                    listOf(82                        "1-3 c: abc",83                        "1-3 c: cbc",84                        "1-3 c: aba"85                    )86                )87                actual shouldBe 188            }89        }90        context("Occurrences at all indices except the specified") {91            it("Returns 0") {92                val actual = p.passwordPhilosophy2(93                    listOf(94                        "3-10 i: iiziiiiiiz",95                        "1-1 j: x",96                        "1-10 k: mkkkkkkkkm"97                    )98                )99                actual shouldBe 0100            }101        }102        context("Character count over limit") {103            it("Returns 0") {104                checkAll(Arb.list(Arb.stringPattern("1-[1-9] a: ([a]{10,20})"))) { s ->105                    p.passwordPhilosophy2(s) shouldBe 0106                }107            }108        }109        context("All passports valid") {110            it("Returns size of input") {111                checkAll(Arb.list(Arb.stringPattern("[a-z]{26}").map { it.toSet().fold("") { acc, element -> acc + element } })) { lines ->112                    p.passwordPhilosophy2(lines.map { code -> "1-${code.length} ${code[0]}: " + code }) shouldBe lines.size113                }114            }115        }116    }117})...

TestParallelism.kt

Source:TestParallelism.kt

1package edu.illinois.cs.cs125.jeed.core.sandbox2import edu.illinois.cs.cs125.jeed.core.Sandbox3import edu.illinois.cs.cs125.jeed.core.Source4import edu.illinois.cs.cs125.jeed.core.SourceExecutionArguments5import edu.illinois.cs.cs125.jeed.core.compile6import edu.illinois.cs.cs125.jeed.core.execute7import edu.illinois.cs.cs125.jeed.core.fromSnippet8import edu.illinois.cs.cs125.jeed.core.haveCompleted9import edu.illinois.cs.cs125.jeed.core.haveTimedOut10import io.kotest.core.spec.style.StringSpec11import io.kotest.matchers.collections.shouldHaveSize12import io.kotest.matchers.doubles.shouldBeLessThan13import io.kotest.matchers.should14import io.kotest.matchers.shouldBe15import io.kotest.matchers.shouldNot16import kotlinx.coroutines.async17import kotlinx.coroutines.runBlocking18import java.util.stream.Collectors19import kotlin.system.measureTimeMillis20class TestParallelism : StringSpec({21    "should execute correctly in parallel using streams" {22        (0..8).toList().parallelStream().map { value ->23            val result = runBlocking {24                Source.fromSnippet(25                    """26for (int i = 0; i < 32; i++) {27    for (long j = 0; j < 1024 * 1024; j++);28    System.out.println($value);29}30                    """.trim()31                ).compile().execute(SourceExecutionArguments(timeout = 1000L))32            }33            result should haveCompleted()34            result.stdoutLines shouldHaveSize 3235            result.stdoutLines.all { it.line.trim() == value.toString() } shouldBe true36        }37    }38    "should execute correctly in parallel using coroutines" {39        (0..8).toList().map { value ->40            async {41                Pair(42                    Source.fromSnippet(43                        """44for (int i = 0; i < 32; i++) {45    for (long j = 0; j < 1024 * 1024; j++);46    System.out.println($value);47}48                    """.trim()49                    ).compile().execute(SourceExecutionArguments(timeout = 1000L)),50                    value51                )52            }53        }.map { it ->54            val (result, value) = it.await()55            result should haveCompleted()56            result.stdoutLines shouldHaveSize 3257            result.stdoutLines.all { it.line.trim() == value.toString() } shouldBe true58        }59    }60    "should execute efficiently in parallel using streams" {61        val compiledSources = (0..8).toList().map {62            async {63                Source.fromSnippet(64                    """65for (int i = 0; i < 32; i++) {66    for (long j = 0; j < 1024 * 1024 * 1024; j++);67}68                    """.trim()69                ).compile()70            }71        }.map { it.await() }72        lateinit var results: List<Sandbox.TaskResults<out Any?>>73        val totalTime = measureTimeMillis {74            results = compiledSources.parallelStream().map {75                runBlocking {76                    it.execute(SourceExecutionArguments(timeout = 1000L))77                }78            }.collect(Collectors.toList()).toList()79        }80        val individualTimeSum = results.map { result ->81            result shouldNot haveCompleted()82            result should haveTimedOut()83            result.totalDuration.toMillis()84        }.sum()85        totalTime.toDouble() shouldBeLessThan individualTimeSum * 0.886    }87    "should execute efficiently in parallel using coroutines" {88        val compiledSources = (0..8).toList().map {89            async {90                Source.fromSnippet(91                    """92for (int i = 0; i < 32; i++) {93    for (long j = 0; j < 1024 * 1024 * 1024; j++);94}95                    """.trim()96                ).compile()97            }98        }.map { it.await() }99        lateinit var results: List<Sandbox.TaskResults<out Any?>>100        val totalTime = measureTimeMillis {101            results = compiledSources.map {102                async {103                    it.execute(SourceExecutionArguments(timeout = 1000L))104                }105            }.map { it.await() }106        }107        val individualTimeSum = results.map { result ->108            result shouldNot haveCompleted()109            result should haveTimedOut()110            result.totalDuration.toMillis()111        }.sum()112        totalTime.toDouble() shouldBeLessThan individualTimeSum * 0.8113    }114})...

BinaryBoardingTest.kt

Source:BinaryBoardingTest.kt

1import io.kotest.assertions.throwables.shouldThrow2import io.kotest.core.spec.style.DescribeSpec3import io.kotest.inspectors.forAll4import io.kotest.matchers.ints.shouldBeGreaterThan5import io.kotest.matchers.ints.shouldBeInRange6import io.kotest.matchers.shouldBe7import io.kotest.property.Arb8import io.kotest.property.arbitrary.*9import io.kotest.property.checkAll10import java.io.File11import java.lang.IllegalArgumentException12class BinaryBoardingTest : DescribeSpec({13    val b = BinaryBoarding()14    val input = File("input.txt").readLines()15    describe("Test binaryBoarding") {16        context("Sample test") {17            val expected = 92618            it("Returns $expected") {19                b.binaryBoarding(input) shouldBe expected20            }21        }22        context("Bounds of seat ID") {23            checkAll(Arb.list(Arb.stringPattern("[BF]{7}[RL]{3}"), 1..100)) { l ->24                b.binaryBoarding(l) shouldBeInRange 0..(8 * BinaryBoarding.R_HIGH + BinaryBoarding.C_HIGH)25            }26        }27        context("Leading B yields larger seat ID") {28            checkAll(29                Arb.bind(30                    Arb.list(Arb.stringPattern("B[BF]{6}[LR]{3}"), 1..100),31                    Arb.list(Arb.stringPattern("F[BF]{6}[LR]{3}"), 1..100)32                ) { low, high -> Pair(low, high) }33            ) { p ->34                b.binaryBoarding(p.first) shouldBeGreaterThan b.binaryBoarding(p.second)35            }36        }37        context("Invalid input") {38            checkAll(Arb.list(Arb.string()).filter { it.size != 10 }) { l ->39                shouldThrow<IllegalArgumentException> {40                    b.binaryBoarding(l)41                }42            }43        }44    }45    describe("Test binaryBoarding2") {46        context("Sample test") {47            val expected = 65748            it("Returns $expected") {49                val actual = b.binaryBoarding2(input)50                actual shouldBe expected51            }52        }53        context("Only one seat taken") {54            it("Returns NoSuchElementException") {55                shouldThrow<NoSuchElementException> {56                    // Was guaranteed -1 and +1 are in the input57                    b.binaryBoarding2(listOf("BBBBBBBRRR"))58                }59            }60        }61    }62    describe("Test getSeatID helper") {63        context("Sample code to Seat ID mapping") {64            listOf(65                "BFFFBBFRRR" to 567,66                "FFFBBBFRRR" to 119,67                "BBFFBBFRLL" to 82068            ).forAll { (code, seatID) ->69                b.getSeatID(code) shouldBe seatID70            }71        }72    }73})...

FormatFileTest.kt

Source:FormatFileTest.kt

1package io.github.divinespear.plugin2import com.github.difflib.DiffUtils3import io.kotest.core.spec.style.WordSpec4import io.kotest.core.spec.tempfile5import io.kotest.matchers.and6import io.kotest.matchers.collections.beEmpty7import io.kotest.matchers.nulls.beNull8import io.kotest.matchers.paths.aFile9import io.kotest.matchers.paths.beReadable10import io.kotest.matchers.paths.exist11import io.kotest.matchers.should12import io.kotest.matchers.shouldNot13import java.io.File14import java.nio.file.Files15import java.nio.file.Path16import java.nio.file.Paths17import java.nio.file.StandardCopyOption18class FormatFileTest : WordSpec() {19  companion object {20    val LINE_SEPARATOR = System.getProperty("line.separator") ?: "\n";21  }22  private lateinit var actual: File23  private fun resourcePath(name: String): Path {24    val path = this.javaClass.getResource(name)?.let {25      Paths.get(it.file)26    }27    path shouldNot beNull()28    path!! should (exist() and aFile() and beReadable())29    return path.normalize()30  }31  init {32    beforeTest {33      actual = tempfile("format-test")34    }35    "eclipselink result file" should {36      "be formatted" {37        val source = resourcePath("/eclipselink-normal-result.txt")38        val expected = resourcePath("/eclipselink-format-result.txt")39        val actualPath = actual.toPath()40        Files.copy(source, actualPath, StandardCopyOption.REPLACE_EXISTING)41        formatFile(actualPath, true, LINE_SEPARATOR)42        val diff = DiffUtils.diff(Files.readAllLines(expected), Files.readAllLines(actualPath))43        diff.deltas should beEmpty()44      }45    }46    "hibernate result file" should {47      "be formatted" {48        val source = resourcePath("/hibernate-normal-result.txt")49        val expected = resourcePath("/hibernate-format-result.txt")50        val actualPath = actual.toPath()51        Files.copy(source, actualPath, StandardCopyOption.REPLACE_EXISTING)52        formatFile(actualPath, true, LINE_SEPARATOR)53        val diff = DiffUtils.diff(Files.readAllLines(expected), Files.readAllLines(actualPath))54        diff.deltas should beEmpty()55      }56    }57  }58}...

example-readme-10.kt

Source:example-readme-10.kt

...24fun readFile(path: String?): Cont<FileError, Content> = cont {25  ensureNotNull(path) { EmptyPath }26  ensure(path.isNotEmpty()) { EmptyPath }27  try {28    val lines = File(path).readLines()29    Content(lines)30  } catch (e: FileNotFoundException) {31    shift(FileNotFound(path))32  } catch (e: SecurityException) {33    shift(SecurityError(e.message))34  }35}36suspend fun <A> awaitExitCase(exit: CompletableDeferred<ExitCase>): A =37  guaranteeCase(::awaitCancellation) { exitCase -> exit.complete(exitCase) }38suspend fun test() {39  val exit = CompletableDeferred<ExitCase>()40  cont<FileError, Int> {41    withContext(Dispatchers.IO) {42      val job = launch { awaitExitCase(exit) }43      val content = readFile("failure").bind()...

example-readme-02.kt

Source:example-readme-02.kt

...24fun readFile(path: String?): Cont<FileError, Content> = cont {25  ensureNotNull(path) { EmptyPath }26  ensure(path.isNotEmpty()) { EmptyPath }27  try {28    val lines = File(path).readLines()29    Content(lines)30  } catch (e: FileNotFoundException) {31    shift(FileNotFound(path))32  } catch (e: SecurityException) {33    shift(SecurityError(e.message))34  }35}36suspend fun test() {37  readFile("").toEither() shouldBe Either.Left(EmptyPath)38  readFile("knit.properties").toValidated() shouldBe  Validated.Invalid(FileNotFound("knit.properties"))39  readFile("gradle.properties").toIor() shouldBe Ior.Left(FileNotFound("gradle.properties"))40  readFile("README.MD").toOption { None } shouldBe None41  readFile("build.gradle.kts").fold({ _: FileError -> null }, { it })42    .shouldBeInstanceOf<Content>()43    .body.shouldNotBeEmpty()...

lines

Using AI Code Generation

1    import io.kotest.matchers.string.lines2    import io.kotest.matchers.string.shouldHaveLineCount3    import io.kotest.matchers.string.shouldHaveLines4    fun testLines() {5        """.trimMargin()6        str shouldHaveLines listOf("line 1", "line 2", "line 3", "line 4")7        str shouldHaveLines lines {8            line("line 1")9            line("line 2")10            line("line 3")11            line("line 4")12        }13    }14    import io.kotest.matchers.string.shouldMatch15    import io.kotest.matchers.string.shouldNotMatch16    fun testRegex() {17        "foo" shouldMatch "foo".toRegex()18        "foo" shouldNotMatch "bar".toRegex()19    }20    import io.kotest.matchers.string.shouldMatch21    import io.kotest.matchers.string.shouldNotMatch22    fun testRegex() {23        "foo" shouldMatch "foo".toRegex()24        "foo" shouldNotMatch "bar".toRegex()25    }26    import io.kotest.matchers.string.shouldStartWith27    fun testShouldStartWith() {28    }29    import io.kotest.matchers.string.shouldStartWithIgnoringCase30    fun testShouldStartWithIgnoringCase() {31    }32    import io.kotest.matchers.string.shouldEndWith

lines

Using AI Code Generation

1lines should haveLines(3)2lines should haveLines(4)3lines should haveLines(2)4lines should haveLines(1)5lines should haveLines(0)6lines should haveLines(5)7lines should haveLines(-1)8lines should haveLines(-2)9lines should haveLines(-3)10lines should haveLines(-4)11lines should haveLines(-5)12lines should haveLines(-6)13lines should haveLines(-7)14lines should haveLines(-8)15lines should haveLines(-9)16lines should haveLines(-10)17lines should haveLines(-11)18lines should haveLines(-12)19lines should haveLines(-13)20lines should haveLines(-14)21lines should haveLines(-15)22lines should haveLines(-16)23lines should haveLines(-17)24lines should haveLines(-18)25lines should haveLines(-19)26lines should haveLines(-20)27lines should haveLines(-21)28lines should haveLines(-22)29lines should haveLines(-23)30lines should haveLines(-24)31lines should haveLines(-25)32lines should haveLines(-26)33lines should haveLines(-27)34lines should haveLines(-28)35lines should haveLines(-29)36lines should haveLines(-30)37lines should haveLines(-31)38lines should haveLines(-32)39lines should haveLines(-33)40lines should haveLines(-34)41lines should haveLines(-35)42lines should haveLines(-36)43lines should haveLines(-37)44lines should haveLines(-38)45lines should haveLines(-39)46lines should haveLines(-40)47lines should haveLines(-41)48lines should haveLines(-42)49lines should haveLines(-43)50lines should haveLines(-44)51lines should haveLines(-45)52lines should haveLines(-46)53lines should haveLines(-47)54lines should haveLines(-48)55lines should haveLines(-49)56lines should haveLines(-50)57lines should haveLines(-51)58lines should haveLines(-52)59lines should haveLines(-53)60lines should haveLines(-54)61lines should haveLines(-55)62lines should haveLines(-56)63lines should haveLines(-57)64lines should haveLines(-58)65lines should haveLines(-59)66lines should haveLines(-60)67lines should haveLines(-61)68lines should haveLines(-62)69lines should haveLines(-63)

lines

Using AI Code Generation

1text.lines() shouldBe listOf("Hello", "World!")2val list = listOf(1, 2, 3)3val map = mapOf("a" to 1, "b" to 2)4val set = setOf(1, 2, 3)5val array = arrayOf(1, 2, 3)6val sequence = sequenceOf(1, 2, 3)7val iterable = listOf(1, 2, 3)

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.