Add subject for CharSequence

Author: bitspittle

src/commonMain/kotlin/com/varabyte/truthish/Truth.kt

@@ -14,6 +14,7 @@ fun assertThat(actual: Long) = LongSubject(actual)
 fun assertThat(actual: Float) = FloatSubject(actual)
 fun assertThat(actual: Double) = DoubleSubject(actual)
 fun assertThat(actual: String) = StringSubject(actual)
+fun assertThat(actual: CharSequence) = CharSequenceSubject(actual)
 fun <T, I: Iterable<T>> assertThat(actual: I) = IterableSubject(actual)
 fun <K, V, T: Map<K, V>> assertThat(actual: T) = MapSubject(actual)
 fun <T, S: Sequence<T>> assertThat(actual: S) = IterableSubject(actual.asIterable())
@@ -83,6 +84,7 @@ class AssertAllScope(summary: String?) {
     fun that(actual: Float) = FloatSubject(actual).withStrategy(deferredStrategy)
     fun that(actual: Double) = DoubleSubject(actual).withStrategy(deferredStrategy)
     fun that(actual: String) = StringSubject(actual).withStrategy(deferredStrategy)
+    fun that(actual: CharSequence) = CharSequenceSubject(actual).withStrategy(deferredStrategy)
     fun <T, I: Iterable<T>> that(actual: I) = IterableSubject(actual).withStrategy(deferredStrategy)
     fun <K, V, T: Map<K, V>> that(actual: T) = MapSubject(actual).withStrategy(deferredStrategy)
     fun <T, S: Sequence<T>> that(actual: S) = IterableSubject(actual.asIterable()).withStrategy(deferredStrategy)
@@ -146,6 +148,7 @@ class SummarizedSubjectBuilder(private val message: String, private val strategy
     fun that(actual: Float) = FloatSubject(actual).withMessage(message).withStrategyOverride()
     fun that(actual: Double) = DoubleSubject(actual).withMessage(message).withStrategyOverride()
     fun that(actual: String) = StringSubject(actual).withMessage(message).withStrategyOverride()
+    fun that(actual: CharSequence) = CharSequenceSubject(actual).withMessage(message).withStrategyOverride()
     fun <T, I: Iterable<T>> that(actual: I) = IterableSubject(actual).withMessage(message).withStrategyOverride()
     fun <K, V, T: Map<K, V>> that(actual: T) = MapSubject(actual).withMessage(message).withStrategyOverride()
     fun <T, S: Sequence<T>> that(actual: S) = IterableSubject(actual.asIterable()).withMessage(message).withStrategyOverride()

src/commonMain/kotlin/com/varabyte/truthish/failure/Reportable.kt

@@ -67,3 +67,11 @@ inline fun <reified R : Reportable> R.withStrategy(strategy: FailureStrategy): R
     this.strategy = strategy
     return this
 }
+
+// Useful for delegating one reportable to another
+internal inline fun <reified R1 : Reportable, reified R2 : Reportable> R1.copyValuesFrom(other: R2): R1 {
+    this.name = other.name
+    this.strategy = other.strategy
+    this.message = other.message
+    return this
+}

src/commonMain/kotlin/com/varabyte/truthish/subjects/StringSubject.kt renamed to src/commonMain/kotlin/com/varabyte/truthish/subjects/TextSubjects.kt

@@ -3,11 +3,12 @@ package com.varabyte.truthish.subjects
 import com.varabyte.truthish.failure.DetailsFor
 import com.varabyte.truthish.failure.Report
 import com.varabyte.truthish.failure.Summaries
+import com.varabyte.truthish.failure.copyValuesFrom
 
-class StringSubject(private val actual: String) : ComparableSubject<String>(actual) {
+class CharSequenceSubject(private val actual: CharSequence) : NotNullSubject<CharSequence>(actual) {
 
     fun isEmpty() {
-        if (!actual.isEmpty()) {
+        if (actual.isNotEmpty()) {
             report(Report(Summaries.EXPECTED_EMPTY, DetailsFor.actual(actual)))
         }
     }
@@ -19,7 +20,7 @@ class StringSubject(private val actual: String) : ComparableSubject<String>(actu
     }
 
     fun isBlank() {
-        if (!actual.isBlank()) {
+        if (actual.isNotBlank()) {
             report(Report(Summaries.EXPECTED_BLANK, DetailsFor.actual(actual)))
         }
     }
@@ -148,4 +149,29 @@ class StringSubject(private val actual: String) : ComparableSubject<String>(actu
     fun doesNotContainMatch(regex: String) {
         doesNotContainMatch(Regex(regex))
     }
-}
+}
+
+class StringSubject(private val actual: String) : ComparableSubject<String>(actual) {
+    private val delegateSubject
+        get() = CharSequenceSubject(actual).copyValuesFrom(this)
+
+    fun isEmpty() { delegateSubject.isEmpty() }
+    fun isNotEmpty() { delegateSubject.isNotEmpty() }
+    fun isBlank() { delegateSubject.isBlank() }
+    fun isNotBlank() { delegateSubject.isNotBlank() }
+    fun hasLength(expectedLength: Int) { delegateSubject.hasLength(expectedLength) }
+    fun startsWith(expected: CharSequence) { delegateSubject.startsWith(expected) }
+    fun doesNotStartWith(expected: CharSequence) { delegateSubject.doesNotStartWith(expected) }
+    fun endsWith(expected: CharSequence) { delegateSubject.endsWith(expected) }
+    fun doesNotEndWith(expected: CharSequence) { delegateSubject.doesNotEndWith(expected) }
+    fun matches(regex: Regex) { delegateSubject.matches(regex) }
+    fun matches(regex: String) { delegateSubject.matches(regex) }
+    fun doesNotMatch(regex: Regex) { delegateSubject.doesNotMatch(regex) }
+    fun doesNotMatch(regex: String) { delegateSubject.doesNotMatch(regex) }
+    fun contains(expected: CharSequence) { delegateSubject.contains(expected) }
+    fun containsMatch(regex: Regex) { delegateSubject.containsMatch(regex) }
+    fun containsMatch(regex: String) { delegateSubject.containsMatch(regex) }
+    fun doesNotContain(expected: CharSequence) { delegateSubject.doesNotContain(expected) }
+    fun doesNotContainMatch(regex: Regex) { delegateSubject.doesNotContainMatch(regex) }
+    fun doesNotContainMatch(regex: String) { delegateSubject.doesNotContainMatch(regex) }
+}

src/commonTest/kotlin/com/varabyte/truthish/MessageAsserts.kt

@@ -19,6 +19,7 @@ class MessageAsserts {
 
     @Test
     fun messageChecks() {
+        @Suppress("RedundantNullableReturnType") // Force nullable to test nullable subject
         val stub: Stub? = Stub()
 
         assertThrows<ReportError> {
@@ -65,6 +66,10 @@ class MessageAsserts {
             assertWithMessage(TEST_MESSAGE).that("XYZ").isEmpty()
         }.assertSubstrings(TEST_MESSAGE)
 
+        assertThrows<ReportError> {
+            assertWithMessage(TEST_MESSAGE).that(StringBuilder("XYZ")).isEmpty()
+        }.assertSubstrings(TEST_MESSAGE)
+
         assertThrows<ReportError> {
             assertWithMessage(TEST_MESSAGE).that(listOf(1, 2, 3)).containsAnyIn(listOf(4, 5, 6))
         }.assertSubstrings(TEST_MESSAGE)