Property-Based Testing

import io.kotest.property.Arb
import io.kotest.property.arbitrary.string
import io.kotest.property.arbitrary.int
import io.kotest.property.checkAll
import io.kotest.core.spec.style.StringSpec

class StringPropertyTest : StringSpec({
    "reverse of reverse equals original" {
        checkAll(Arb.string()) { s ->
            s.reversed().reversed() shouldBe s
        }
    }

    "string length after reverse is preserved" {
        checkAll(Arb.string()) { s ->
            s.reversed().length shouldBe s.length
        }
    }
})

// property_based.kt
// Mendemonstrasikan property-based testing ala kotest-property / jqwik.
// Strategi: dengan seed tertentu, generator menghasilkan input acak
// yang deterministik; untuk setiap input, sifat (property) yang
// seharusnya selalu benar diperiksa.

import kotlin.random.Random

// SUT: fungsi yang ingin kita uji propertinya.
class StringOps {
    fun balik(s: String): String = s.reversed()
    fun panjang(s: String): Int = s.length
    fun gabung(a: String, b: String): String = a + b
}

// Generator input yang deterministic dengan seed.
class GenInput(private val rng: Random) {
    fun stringAcak(maxLen: Int = 10): String {
        val n = rng.nextInt(0, maxLen + 1)
        val sb = StringBuilder()
        repeat(n) {
            val c = ('a'..'z').random(rng)
            sb.append(c)
        }
        return sb.toString()
    }

    fun <T> daftar(size: Int, generator: (Random) -> T): List<T> =
        List(size) { generator(rng) }
}

object PropertyRunner {
    var pass = 0
    var fail = 0

    fun <T> forAll(label: String, samples: List<T>, property: (T) -> Boolean) {
        var gagalInput: T? = null
        for (input in samples) {
            if (!property(input)) { gagalInput = input; break }
        }
        if (gagalInput == null) {
            pass++
            println("[LULUS] $label: ${samples.size} sampel lolos")
        } else {
            fail++
            println("[GAGAL]  $label: gagal pada input=$gagalInput")
        }
    }
}

fun main() {
    val rng = Random(42) // seed deterministik
    val gen = GenInput(rng)
    val ops = StringOps()

    // Property 1: balik(balik(s)) == s
    val sampel1 = gen.daftar(50) { gen.stringAcah(15) }
    PropertyRunner.forAll("balik(balik(s)) == s", sampel1) { s ->
        ops.balik(ops.balik(s)) == s
    }

    // Property 2: panjang(balik(s)) == panjang(s)
    val sampel2 = gen.daftar(50) { gen.stringAcah(20) }
    PropertyRunner.forAll("panjang(balik(s)) == panjang(s)", sampel2) { s ->
        ops.panjang(ops.balik(s)) == ops.panjang(s)
    }

    // Property 3: gabung(a, b).length == a.length + b.length
    val sampel3 = gen.daftar(30) { gen.stringAcah(10) }
    PropertyRunner.forAll("gabung(a, b).length == a.length + b.length", sampel3) { a ->
        val b = gen.stringAcah(10)
        ops.gabung(a, b).length == a.length + b.length
    }

    println()
    println("Total: pass=${PropertyRunner.pass} fail=${PropertyRunner.fail}")
    println("Seed 42 dipakai agar input dapat direproduksi jika ada kegagalan.")
}

// Helper agar stringAcah konsisten
fun GenInput.stringAcah(maxLen: Int = 10): String = stringAcak(maxLen)

[LULUS] balik(balik(s)) == s: 50 sampel lolos
[LULUS] panjang(balik(s)) == panjang(s): 50 sampel lolos
[LULUS] gabung(a, b).length == a.length + b.length: 30 sampel lolos

Total: pass=3 fail=0
Seed 42 dipakai agar input dapat direproduksi jika ada kegagalan.

// Property: panjang string tidak boleh negatif
// Failing input: "abcdef"
// Shrunk ke: "" (panjang 0, tetap gagal) — bug ada pada method panjang()