add CharSequenceAssert

Author: memoizr

build.gradle

@@ -5,7 +5,7 @@ buildscript {
     ext.kotlin_version = '1.0.3'
 
     repositories {
-        mavenCentral()
+        jcenter()
     }
     dependencies {
         classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
@@ -15,11 +15,13 @@ buildscript {
 apply plugin: 'kotlin'
 
 repositories {
-    mavenCentral()
+    jcenter()
 }
 
 dependencies {
     compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
     compile group: 'org.assertj', name: 'assertj-core', version: '3.5.0'
     testCompile group: 'junit', name: 'junit', version: '4.12'
+    testCompile "org.mockito:mockito-core:1.10.19"
+    testCompile "com.nhaarman:mockito-kotlin:0.2.0"
 }

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

@@ -1,6 +1,7 @@
 package com.memozr.assertk
 
 import com.memozr.assertk.ObjectStuff.notNull
+import org.assertj.core.api.AbstractAssert
 import org.assertj.core.api.Assertions
 
 enum class ObjectStuff {
@@ -9,10 +10,10 @@ enum class ObjectStuff {
 
 inline fun <reified R : Any> of() = AbstractAssertBuilder.InstanceMatcher<R>()
 
-class AbstractAssertBuilder<T : Any>(other: T?) {
+open class AbstractAssertBuilder<T : Any>(other: T?) {
     class InstanceMatcher<R>
 
-    val assertion = Assertions.assertThat(other)
+    open protected val assertion: AbstractAssert<*, T?> = Assertions.assertThat(other)
 
     infix fun isEqualTo(other: T): AbstractAssertBuilder<T> {
         assertion.isEqualTo(other)

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

@@ -0,0 +1,147 @@
+package com.memozr.assertk
+
+import com.memozr.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: String?,
+        override protected val assertion: AbstractCharSequenceAssert<*, String> = assertThat(subject))
+: AbstractAssertBuilder<String>(subject) {
+
+    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: String): CharSequenceAssert {
+        assertion.isEqualToIgnoringCase(expected)
+        return this
+    }
+
+    infix fun isNotEqualToIgnoringCase(expected: String): 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: String): 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: String): CharSequenceAssert {
+        assertion.containsIgnoringCase(expected)
+        return this
+    }
+
+    infix fun doesNotContain(expected: CharSequence): CharSequenceAssert {
+        assertion.doesNotContain(expected)
+        return this
+    }
+
+    infix fun startsWith(expected: String): 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: String): CharSequenceAssert {
+        assertion.containsPattern(pattern)
+        return this
+    }
+
+    infix fun containsPattern(pattern: Pattern): CharSequenceAssert {
+        assertion.containsPattern(pattern)
+        return this
+    }
+}

src/main/kotlin/com/memozr/assertk/General.kt

@@ -1,11 +1,14 @@
 package com.memozr.assertk
 
-val assert: AssertionHook get() = AssertionHook()
-val expect: AssertionHook get() = AssertionHook()
+val assert: AssertionHook get() = RealAssertionHook()
+val expect: AssertionHook get() = RealAssertionHook()
 
-class AssertionHook {
+interface AssertionHook {
     infix fun <T : Any> that(subjectUnderTest: T?) = AbstractAssertBuilder(subjectUnderTest)
+    infix fun that(subjectUnderTest: String?) = CharSequenceAssert(subjectUnderTest)
     infix fun thatThrownBy(expressionUnderTest: () -> Unit) = ThrowableAssertionBuilder(expressionUnderTest)
 }
 
+class RealAssertionHook : AssertionHook
+