rename package

Author: memoizr

src/main/kotlin/com/memoizr/assertk/AbstractAssertBuilder.kt

@@ -0,0 +1,60 @@
+package com.memoizr.assertk
+
+import com.memoizr.assertk.ObjectStuff.notNull
+import org.assertj.core.api.AbstractAssert
+import org.assertj.core.api.Assertions
+
+enum class ObjectStuff {
+    notNull
+}
+
+inline fun <reified R : Any> of() = AbstractAssertBuilder.InstanceMatcher<R>()
+
+abstract class AbstractAssertBuilder<S : AbstractAssertBuilder<S, A>, A : Any> internal constructor(actual: A?, selfType: Class<*>) {
+    class InstanceMatcher<R>
+
+    @Suppress("UNCHECKED_CAST", "LeakingThis")
+    protected val myself: S = selfType.cast(this) as S
+
+    open protected val assertion: AbstractAssert<*, out A?> = Assertions.assertThat(actual)
+
+    infix fun isEqualTo(other: A): S {
+        assertion.isEqualTo(other)
+        return myself
+    }
+
+    infix fun isNotEqualTo(other: A): S {
+        assertion.isNotEqualTo(other)
+        return myself
+    }
+
+    @Suppress("UNUSED_PARAMETER")
+    inline infix fun <reified R : Any> isInstance(bar: InstanceMatcher<R>): S {
+        assertion.isInstanceOf(R::class.java)
+        return myself
+    }
+
+    infix fun _is(objectStuff: ObjectStuff?): S {
+        return when (objectStuff) {
+            notNull -> {
+                assertion.isNotNull()
+                myself
+            }
+            else -> {
+                assertion.isNull()
+                myself
+            }
+        }
+    }
+
+    infix fun describedAs(description: String): S {
+        assertion.`as`(description)
+        return myself
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    infix fun isSuchThat(assertionBlock: S.(S) -> Unit): S {
+        (this as S).assertionBlock(this)
+        return myself
+    }
+}

src/main/kotlin/com/memoizr/assertk/AssertionHooks.kt

@@ -0,0 +1,14 @@
+package com.memoizr.assertk
+
+val assert: AssertionHook get() = RealAssertionHook()
+val expect: AssertionHook get() = RealAssertionHook()
+
+interface AssertionHook {
+    infix fun <T : Any> that(subjectUnderTest: T?) = ObjectAssert(subjectUnderTest)
+    infix fun that(subjectUnderTest: CharSequence?) = CharSequenceAssert(subjectUnderTest)
+    infix fun thatThrownBy(expressionUnderTest: () -> Unit) = ThrowableAssertion(expressionUnderTest)
+}
+
+class RealAssertionHook : AssertionHook
+
+

src/main/kotlin/com/memoizr/assertk/CharSequenceAssert.kt

@@ -0,0 +1,147 @@
+package com.memoizr.assertk
+
+import com.memoizr.assertk.CharSequenceAssertTest.*
+import org.assertj.core.api.AbstractCharSequenceAssert
+import org.assertj.core.api.Assertions.assertThat
+import java.util.regex.Pattern
+
+enum class CharSequenceAssertTest {
+    nullOrEmpty, empty, notEmpty
+}
+
+class CharSequenceAssert internal constructor(
+        private val subject: CharSequence?,
+        override val assertion: AbstractCharSequenceAssert<*, out CharSequence> = assertThat(subject)) :
+        AbstractAssertBuilder<CharSequenceAssert, CharSequence>(subject, CharSequenceAssert::class.java) {
+
+    object onlyDigits
+
+    infix fun _is(assertionTest: CharSequenceAssertTest): CharSequenceAssert {
+        when (assertionTest) {
+            empty -> assertion.isEmpty()
+            notEmpty -> assertion.isNotEmpty()
+            nullOrEmpty -> assertion.isNullOrEmpty()
+        }
+        return this
+    }
+
+    infix fun hasSize(expectedSize: Int): CharSequenceAssert {
+        assertion.hasSize(expectedSize)
+        return this
+    }
+
+    infix fun hasLineCount(expectedLineCount: Int): CharSequenceAssert {
+        assertion.hasLineCount(expectedLineCount)
+        return this
+    }
+
+    infix fun isEqualToIgnoringCase(expected: CharSequence): CharSequenceAssert {
+        assertion.isEqualToIgnoringCase(expected)
+        return this
+    }
+
+    infix fun isNotEqualToIgnoringCase(expected: CharSequence): CharSequenceAssert {
+        assertion.isNotEqualToIgnoringCase(expected)
+        return this
+    }
+
+    infix fun contains(onlyDigits: onlyDigits): CharSequenceAssert {
+        assertion.containsOnlyDigits()
+        return this
+    }
+
+    infix fun contains(expected: CharSequence): CharSequenceAssert {
+        assertion.contains(expected)
+        return this
+    }
+
+    infix fun containsOnlyOnce(expected: CharSequence): CharSequenceAssert {
+        assertion.containsOnlyOnce(expected)
+        return this
+    }
+
+    infix fun contains(expected: Iterable<CharSequence>): CharSequenceAssert {
+        assertion.contains(expected)
+        return this
+    }
+
+    infix fun containsSequence(expected: Iterable<CharSequence>): CharSequenceAssert {
+        assertion.containsSequence(expected)
+        return this
+    }
+
+    infix fun containsIgnoringCase(expected: CharSequence): CharSequenceAssert {
+        assertion.containsIgnoringCase(expected)
+        return this
+    }
+
+    infix fun doesNotContain(expected: CharSequence): CharSequenceAssert {
+        assertion.doesNotContain(expected)
+        return this
+    }
+
+    infix fun startsWith(expected: CharSequence): CharSequenceAssert {
+        assertion.startsWith(expected)
+        return this
+    }
+
+    infix fun doesNotStartWith(expected: CharSequence): CharSequenceAssert {
+        assertion.doesNotStartWith(expected)
+        return this
+    }
+
+    infix fun endsWith(expected: CharSequence): CharSequenceAssert {
+        assertion.endsWith(expected)
+        return this
+    }
+
+    infix fun doesNotEndWith(expected: CharSequence): CharSequenceAssert {
+        assertion.doesNotEndWith(expected)
+        return this
+    }
+
+    infix fun matches(expected: Pattern): CharSequenceAssert {
+        assertion.matches(expected)
+        return this
+    }
+
+    infix fun doesNotMatch(expected: Pattern): CharSequenceAssert {
+        assertion.doesNotMatch(expected)
+        return this
+    }
+
+    infix fun matches(expected: CharSequence): CharSequenceAssert {
+        assertion.matches(expected)
+        return this
+    }
+
+    infix fun doesNotMatch(expected: CharSequence): CharSequenceAssert {
+        assertion.doesNotMatch(expected)
+        return this
+    }
+
+    infix fun isEqualToIgnoringWhitespace(expected: CharSequence): CharSequenceAssert {
+        assertion.isEqualToIgnoringWhitespace(expected)
+        return this
+    }
+
+    infix fun isNotEqualToIgnoringWhitespace(expected: CharSequence): CharSequenceAssert {
+        assertion.isNotEqualToIgnoringWhitespace(expected)
+        return this
+    }
+
+    infix fun isSubstringOf(expected: CharSequence): CharSequenceAssert {
+        assertion.isSubstringOf(expected)
+        return this
+    }
+
+    infix fun containsPattern(pattern: CharSequence): CharSequenceAssert {
+        assertion.containsPattern(pattern)
+        return this
+    }
+
+    infix fun containsPattern(pattern: Pattern): CharSequenceAssert {
+        assertion.containsPattern(pattern)
+        return this
+    }
+}

src/main/kotlin/com/memoizr/assertk/ObjectAssert.kt

@@ -0,0 +1,9 @@
+package com.memoizr.assertk
+
+import org.assertj.core.api.AbstractObjectAssert
+import org.assertj.core.api.Assertions
+
+class ObjectAssert<A : Any> internal constructor(
+        actual: A?,
+        override val assertion: AbstractObjectAssert<*, A> = Assertions.assertThat(actual)) :
+        AbstractAssertBuilder<ObjectAssert<A>, A>(actual, ObjectAssert::class.java)

src/main/kotlin/com/memoizr/assertk/ThrowableAssertion.kt

@@ -0,0 +1,55 @@
+package com.memoizr.assertk
+
+import org.assertj.core.api.AbstractThrowableAssert
+import org.assertj.core.api.Assertions
+
+class ThrowableAssertion(
+        func: () -> Unit,
+        private val assertion: AbstractThrowableAssert<*, out Throwable> = Assertions.assertThatThrownBy(func)) {
+
+    infix fun hasMessage(message: String): ThrowableAssertion {
+        assertion.hasMessage(message)
+        return this
+    }
+
+    infix fun hasCause(throwable: Throwable): ThrowableAssertion {
+        assertion.hasCause(throwable)
+        return this
+    }
+
+    infix fun has(noCause: noCause): ThrowableAssertion {
+        assertion.hasNoCause()
+        return this
+    }
+
+    infix fun hasMessageStartingWith(message: String): ThrowableAssertion {
+        assertion.hasMessageStartingWith(message)
+        return this
+    }
+
+    infix fun hasMessageEndingWith(message: String): ThrowableAssertion {
+        assertion.hasMessageEndingWith(message)
+        return this
+    }
+
+    infix fun hasMessageContaining(message: String): ThrowableAssertion {
+        assertion.hasMessageContaining(message)
+        return this
+    }
+
+    infix fun hasStackTraceContaining(message: String): ThrowableAssertion {
+        assertion.hasStackTraceContaining(message)
+        return this
+    }
+
+    infix fun hasCauseExactlyInstanceOf(throwable: Class<out Throwable>): ThrowableAssertion {
+        assertion.hasCauseExactlyInstanceOf(throwable)
+        return this
+    }
+
+    infix fun and(assertions: ThrowableAssertion.(ThrowableAssertion) -> Unit) {
+        assertions(this)
+    }
+
+    object noCause
+}