Add support for CharRange

('a'..'c').should() startWith('1')
('a'..'c').should() endWith('c')
('a'..'c').should() contain('b')
('a'..'c').should() beNotEmpty()
('a'..'c').should() overlap(('b'..'z'))

Add support for IntRange

(1..10).should() startWith(1)
(1..10).should() endWith(10)
(1..10).should() contain(5)
(1..10).should() beNotEmpty()
(1..10).should() overlap((9..10))

It is possible to avoid using () when we call should.

Why? instead of myString.should() be "Hello we can use myString.should be "Hello I think it is a little bit closer to natural language,

How to implement it?

instead of adding external function fun String.should() = StringShould(this)

we can add

val String.should: AnyShould
 get() = AnyShould(this)

The question us

• do you like new staff?
• if yes, should we remove shuold() staff?

Allows to assert a boolean value against another Boolean Allows to assert boolean against isTrue() or isFalse() Allows to assert boolean against another boolean with infix notation

In order to maintain fluent DSL, I suggest adding be function to BeEqual interface.

true.should() be true
"Hello".should() be "Hello"

interface BeEqual<T, R : BeEqual<T, R>> {

infix fun be(expected: T): R = beEqual()

}

As a counterpart we may add notBe

"Hello".should() notBe "World"

In order to compile it, we should use the argument -Xuse-experimental=kotlin.ExperimentalStdlibApi or mark usage or declaration as @ExperimentalStdlibApi

> Task :kiwi-json:compileKotlinMetadata FAILED
e: /Users/sgsergey.bukharov/IdeaProjects/kiwi/kiwi-json/src/commonMain/kotlin/io/from/source/kiwi/json/Extension.kt: (19, 53): This declaration is experimental and its usage must be marked with '@kotlin.ExperimentalStdlibApi' or '@UseExperimental(kotlin.ExperimentalStdlibApi::class)'
e: /Users/sgsergey.bukharov/IdeaProjects/kiwi/kiwi-json/src/commonMain/kotlin/io/from/source/kiwi/json/JsonParser.kt: (5, 27): This declaration is experimental and its usage must be marked with '@kotlin.ExperimentalStdlibApi' or '@UseExperimental(kotlin.ExperimentalStdlibApi::class)'

Add support for Triple similar as for Pair

Triple(1,2,3).should haveFirstEqualTo(1)
Triple(1,2,3).should haveSecondEqualTo(2)
Triple(1,2,3).should haveThirdEqualTo(3)

Add support for java.math.BigInteger, java.math.BigDecimal

class BigDecimalShould(private val actual: BigDecimal) : NumberShould<BigDecimal> {
...
}

Add support for UByte, UShort, UInt and ULong

interface UNumberShould<T : Comparable<T>> : BeEqual<T, UNumberShould<T>>, BeComparable<T, UNumberShould<T>> {

    fun bePositive(): UNumberShould<T>
    fun beZero(): UNumberShould<T>
}

Sample implementation for UByteShould might look like

class UByteShould(private val actual: UByte) : UNumberShould<UByte> {
    ...
}

Add support for Boolean type in commonMain

class BooleanShould(private val actual: Boolean) : BeEqual<Boolean, BooleanShould> {
    fun beTrue(): BooleanShould = .. 
    fun beFalse(): BooleanShould = ..
}

Subsequent to validating Maps, it'll be good if we could enhance the library to support validation of JSON strings.

 """{
            "name": "hedgehog",
            "weight": 1,
            "mammal": false,
            "habitats": ["Europe", "Asia", "North America"]
            "eats": {
                "fish": ["dory", "salmon"]
            }
        }""".should()
                .beJson()
                .haveProperty("name", "kiwi")
                .haveValueOnPath("$.eats.fish[1]", "dory")

As a reference take a loo at the CollectionShould<T> proposed api

   arrayOf(1,2,3,4,5).should
                   .sumTo(13)
                   .beSorted()

Introduce JsonPath evaluation for json object

sample usage

json.evaluatePath("$.store.details.name").should be listOf(JsonString("Books & Books"))

json.evaluatePath("$..author").should be listOf(
                JsonString("Douglas Hofstadter"),
                JsonString("Christophe Galfard"),
                JsonString("Nassim Nicholas Taleb"),
                JsonString("Stanislaw Lem"),
                JsonString(("J. R. R. Tolkien")))

follow the https://goessner.net/articles/JsonPath/index.html#e2

Add support for LongRange

(1L..10L).should() startWith(1)
(1L..10L).should() endWith(10)
(1L..10L).should() contain(5)
(1L..10L).should() beNotEmpty()
(1L..10L).should() overlap((9L..11L))

Add support for java.nio.file.Path as a first iteration use existing methods

val path = File("/home/arek/.ssh").toPath()

path.should()
       .exist()
       .haveRoot("name of the root")
       .haveParent("parent")
       ...
       .startsWith("somethind")