// assertThat(actual, `is`(expected))
actual.Is(expected)

// assertThat(actual, `is`(not(expected)))
actual.IsNot(expected)

// assertThat(true, `is`(true))
true.IsTrue(message = "assertion with message!")

actual.IsNotNull()
      .Is(/* ... */)
      .IsNot(/* ... */)

dependencies {
    testCompile "com.github.rabitarochan:kotassert:0.1.0-SNAPSHOT"
}

<dependency>
    <groupId>com.github.rabitarochan</groupId>
    <artifactId>kotassert</artifactId>
    <version>0.1.0-SNAPSHOT</version>
    <scope>test</scope>
</dependency>

import kotassert.* // import extension functions.
import org.junit.Test

class UnitTest() {

    @Test
    fun test() {
        val result = 1 + 1
        result.Is(2)
    }

}

// plain kotlin: assertThat(actual, `is`(expected))
actual.Is(expected)

"foobar".Is { it.startsWith("foo") && it.endsWith("bar") }

"foobar".IsNot { it.length <= 5 }

// assertThat("foobar".startsWith("foo"), `is`(true))
"foobar".startsWith("foo").IsTrue()

// assertThat("foobar".startsWith("FOO"), `is`(false))
"foobar".startsWith("FOO").IsFalse()

var actual: String? = null

// assertThat(actual, `is`(nullValue()))
actual.IsNull()

actual = "Hello kotassert"

// assertThat(actual, `is`(not(nullValue())))
actual.IsNotNull()

val x = SingletonFactory.instance
val y = SingletonFactory.instance
val z = NormalFactory.createInstance()

// assertThat(x, `is`(sameInstance(y))
x.IsSameInstance(y)

// assertThat(x, `is`(not(sameInstance(y)))
x.IsNotSameInstance(z)

interface A {}
interface B {}

class C() : A

val x = C()

// assertThat(x, `is`(instanceOf(A::class.java)))
x.IsInstanceOf(A::class)

// assertThat(x, `is`(not(instanceOf(B::class.java))))
x.IsNotInstanceOf(B::class)

val xs = arrayOf(1, 2, 3, 4, 5) // or listOf(1, 2, 3, 4, 5)

// assertThat(1, isIn(xs))
1.IsIn(xs)

// assertThat(6, not(isIn(xs)))
6.IsNotIn(xs)

// assertThat(1, isOneOf(1, 2, 3, 4, 5))
1.IsOneOf(1, 2, 3, 4, 5)

// assertThat(6, not(isOneOf(1, 2, 3, 4, 5)))
6.IsNotOneOf(1, 2, 3, 4, 5)

val xs = arrayOf(1, 2, 3, 4, 5)

// assertThat(xs, `is`(arrayContaining(1, 2, 3, 4, 5))) or assertThat(xs, `is`(contains(1, 2, 3, 4, 5)))
xs.IsContains(1, 2, 3, 4, 5)

// assertThat(xs, `is`(not(arrayContaining(1, 2, 3, 4)))) or assertThat(xs, `is`(not(contains(1, 2, 3, 4))))
xs.IsNotContains(1, 2, 3, 4)

val xs = arrayOf(1, 2, 3, 4, 5)

// assertThat(xs, `is`(arrayContainingInAnyOrder(4, 3, 5, 1, 2))) or assertThat(xs, `is`(containsInAnyOrder(4, 3, 5, 1, 2)))
xs.IsContainsInAnyOrder(4, 3, 5, 1, 2)

// assertThat(xs, `is`(not(arrayContainingInAnyOrder(1, 2, 4, 5)))) or assertThat(xs, `is`(not(containsInAnyOrder(1, 2, 4, 5))))
xs.IsNotContainsInAnyOrder(1, 2, 4, 5)

val xs = mutableArrayOf<Int>()

// assertThat(xs, `is`(empty<Int>()))
xs.IsEmpty()

xs.add(1)

// assertThat(xs, `is`(not(empty<Int>())))
xs.IsNotEmpty()

val xs = arrayOf(1, 2, 3, 4, 5) // or listOf(1, 2, 3, 4, 5)

// assertThat(xs, hasItem(1))
xs.HasItem(1)

// assertThat(xs, not(hasItem(6)))
xs.HasNotItem(6)

val xs = arrayOf(1, 2, 3, 4, 5) // or listOf(1, 2, 3, 4, 5)

// assertThat(xs, hasItems(1, 3, 5))
xs.HasItems(1, 3, 5)

// assertThat(xs, not(hasItems(0, 6)))
xs.HasNotItems(0, 6)

val map = mapOf(
  1 to "one",
  2 to "two",
  3 to "three",
  4 to "four",
  5 to "five"
)

// assertThat(map, hasEntry(1, "one"))
map.HasEntry(1, "one")

// assertThat(map, not(hasEntry(2, "TWO")))
map.HasEntry(2, "TWO")

val map = mapOf(
  1 to "one",
  2 to "two",
  3 to "three",
  4 to "four",
  5 to "five"
)

// assertThat(map, hasKey(1))
map.HasKey(1)

// assertThat(map, not(hasKey(6)))
map.HasKey(6)

val map = mapOf(
  1 to "one",
  2 to "two",
  3 to "three",
  4 to "four",
  5 to "five"
)

// assertThat(map, hasValue("two"))
map.HasValue("two")

// assertThat(map, not(hasValue("TWO")))
map.HasValue("TWO")

data class Person(val id: Int, val name: String)

val alice = Person(1, "alice")
val bob = Person(2, "bob")

// assertThat(alice, samePropertyValueAs(Person(1, "alice")))
alice.IsSamePropertyValueAs(Person(1, "alice"))

// assertThat(alice, not(samePropertyValueAs(bob)))
alice.IsNotSamePropertyValueAs(bob)

KotAssert.throws<NotImplementedError> {
    TODO()
}

KotAssert.notThrow {
    1 + 1
}