Merge pull request #3 from memoizr/iterables

Iterables, integer, long, double, float assertions, Kotlin 1.1

Author: memoizr

build.gradle

@@ -1,11 +1,13 @@
 buildscript {
+    ext.KOTLIN_VERSION="1.1-M01"
     ext.kotlin_version = '1.0.3'
 
     repositories {
         jcenter()
+        maven { url "https://dl.bintray.com/kotlin/kotlin-eap-1.1" }
     }
     dependencies {
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$KOTLIN_VERSION"
     }
 }
 
@@ -23,11 +25,12 @@ version '0.1'
 apply plugin: 'kotlin'
 
 repositories {
+    maven { url "https://dl.bintray.com/kotlin/kotlin-eap-1.1" }
     jcenter()
 }
 
 dependencies {
-    compile "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+    compile "org.jetbrains.kotlin:kotlin-stdlib:$KOTLIN_VERSION"
     compile group: 'org.assertj', name: 'assertj-core', version: '2.5.0'
     testCompile group: 'junit', name: 'junit', version: '4.12'
     testCompile "org.mockito:mockito-core:1.10.19"

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

@@ -1,16 +1,9 @@
 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<*>) {
+abstract class AbstractAssertBuilder<S : AbstractAssertBuilder<S, A>, A : Any>(actual: A?, selfType: Class<*>) {
     class InstanceMatcher<R>
 
     @Suppress("UNCHECKED_CAST", "LeakingThis")
@@ -34,13 +27,13 @@ abstract class AbstractAssertBuilder<S : AbstractAssertBuilder<S, A>, A : Any> i
         return myself
     }
 
-    infix fun _is(objectStuff: ObjectStuff?): S {
-        return when (objectStuff) {
+    infix fun _is(objectSelector: ObjectSelector?): S {
+        return when (objectSelector) {
             notNull -> {
                 assertion.isNotNull()
                 myself
             }
-            else -> {
+            null -> {
                 assertion.isNull()
                 myself
             }

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

@@ -1,12 +1,18 @@
 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)
+    infix fun <ELEMENT : Any?> that(subjectUnderTest: Iterable<ELEMENT>?): IterableAssert<ELEMENT, Iterable<ELEMENT>> = IterableAssert(subjectUnderTest)
+    infix fun that(subjectUnderTest: Int?) = IntegerAssert(subjectUnderTest)
+    infix fun that(subjectUnderTest: Float?) = FloatAssert(subjectUnderTest)
+    infix fun that(subjectUnderTest: Double?) = DoubleAssert(subjectUnderTest)
+    infix fun that(subjectUnderTest: Long?) = LongAssert(subjectUnderTest)
 }
 
 class RealAssertionHook : AssertionHook

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

@@ -1,22 +1,15 @@
 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 {
+    infix fun _is(assertionTest: SequenceSelector): CharSequenceAssert {
         when (assertionTest) {
             empty -> assertion.isEmpty()
             notEmpty -> assertion.isNotEmpty()

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

@@ -0,0 +1,68 @@
+package com.memoizr.assertk
+
+import org.assertj.core.api.AbstractDoubleAssert
+import org.assertj.core.api.Assertions
+
+class DoubleAssert internal constructor(
+        subjectUnderTest: Double?,
+        override val assertion: AbstractDoubleAssert<*> = Assertions.assertThat(subjectUnderTest)) :
+        AbstractAssertBuilder<DoubleAssert, Double>(subjectUnderTest, DoubleAssert::class.java) {
+
+    infix fun isLessThan(expected: Double): DoubleAssert {
+        assertion.isLessThan(expected)
+        return this
+    }
+
+    infix fun isLessThanOrEqualTo(expected: Double): DoubleAssert {
+        assertion.isLessThanOrEqualTo(expected)
+        return this
+    }
+
+    infix fun isGreaterThan(expected: Double): DoubleAssert {
+        assertion.isGreaterThan(expected)
+        return this
+    }
+
+    infix fun isGreaterThanOrEqualTo(expected: Double): DoubleAssert {
+        assertion.isGreaterThanOrEqualTo(expected)
+        return this
+    }
+
+    infix fun isBetween(expected: ClosedRange<Double>): DoubleAssert {
+        assertion.isBetween(expected.start, expected.endInclusive)
+        return this
+    }
+
+    infix fun isStrictlyBetween(expected: ClosedRange<Double>): DoubleAssert {
+        assertion.isStrictlyBetween(expected.start, expected.endInclusive)
+        return this
+    }
+
+    infix fun isCloseTo(expected: Double): Close {
+        return Close(expected, assertion, this)
+    }
+
+    infix fun _is(expected: NumberSelector): DoubleAssert {
+        when (expected) {
+            zero -> assertion.isZero()
+            notZero -> assertion.isNotZero()
+            positive -> assertion.isPositive()
+            notPositive -> assertion.isNotPositive()
+            negative -> assertion.isNegative()
+            notNegative -> assertion.isNotNegative()
+        }
+        return this
+    }
+
+    class Close(private val actual: Double, private val assertion: AbstractDoubleAssert<*>, private val assert: DoubleAssert) {
+        infix fun withinOffset(expected: Double): DoubleAssert {
+            assertion.isCloseTo(actual, Assertions.within(expected))
+            return assert
+        }
+
+        infix fun withinPercentage(expected: Number): DoubleAssert {
+            assertion.isCloseTo(actual, Assertions.withinPercentage(expected.toDouble()))
+            return assert
+        }
+    }
+}

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

@@ -0,0 +1,68 @@
+package com.memoizr.assertk
+
+import org.assertj.core.api.AbstractFloatAssert
+import org.assertj.core.api.Assertions
+
+class FloatAssert internal constructor(
+        subjectUnderTest: Float?,
+        override val assertion: AbstractFloatAssert<*> = Assertions.assertThat(subjectUnderTest)) :
+        AbstractAssertBuilder<FloatAssert, Float>(subjectUnderTest, FloatAssert::class.java) {
+
+    infix fun isLessThan(expected: Float): FloatAssert {
+        assertion.isLessThan(expected)
+        return this
+    }
+
+    infix fun isLessThanOrEqualTo(expected: Float): FloatAssert {
+        assertion.isLessThanOrEqualTo(expected)
+        return this
+    }
+
+    infix fun isGreaterThan(expected: Float): FloatAssert {
+        assertion.isGreaterThan(expected)
+        return this
+    }
+
+    infix fun isGreaterThanOrEqualTo(expected: Float): FloatAssert {
+        assertion.isGreaterThanOrEqualTo(expected)
+        return this
+    }
+
+    infix fun isBetween(expected: ClosedRange<Float>): FloatAssert {
+        assertion.isBetween(expected.start, expected.endInclusive)
+        return this
+    }
+
+    infix fun isStrictlyBetween(expected: ClosedRange<Float>): FloatAssert {
+        assertion.isStrictlyBetween(expected.start, expected.endInclusive)
+        return this
+    }
+
+    infix fun isCloseTo(expected: Float): Close {
+        return Close(expected, assertion, this)
+    }
+
+    infix fun _is(expected: NumberSelector): FloatAssert {
+        when (expected) {
+            zero -> assertion.isZero()
+            notZero -> assertion.isNotZero()
+            positive -> assertion.isPositive()
+            notPositive -> assertion.isNotPositive()
+            negative -> assertion.isNegative()
+            notNegative -> assertion.isNotNegative()
+        }
+        return this
+    }
+
+    class Close(private val actual: Float, private val assertion: AbstractFloatAssert<*>, private val assert: FloatAssert) {
+        infix fun withinOffset(expected: Float): FloatAssert {
+            assertion.isCloseTo(actual, Assertions.within(expected))
+            return assert
+        }
+
+        infix fun withinPercentage(expected: Number): FloatAssert {
+            assertion.isCloseTo(actual, Assertions.withinPercentage(expected.toDouble()))
+            return assert
+        }
+    }
+}

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

@@ -0,0 +1,68 @@
+package com.memoizr.assertk
+
+import org.assertj.core.api.AbstractIntegerAssert
+import org.assertj.core.api.Assertions
+
+class IntegerAssert internal constructor(
+        subjectUnderTest: Int?,
+        override val assertion: AbstractIntegerAssert<*> = Assertions.assertThat(subjectUnderTest)) :
+        AbstractAssertBuilder<IntegerAssert, Int>(subjectUnderTest, IntegerAssert::class.java) {
+
+    infix fun isLessThan(expected: Int): IntegerAssert {
+        assertion.isLessThan(expected)
+        return this
+    }
+
+    infix fun isLessThanOrEqualTo(expected: Int): IntegerAssert {
+        assertion.isLessThanOrEqualTo(expected)
+        return this
+    }
+
+    infix fun isGreaterThan(expected: Int): IntegerAssert {
+        assertion.isGreaterThan(expected)
+        return this
+    }
+
+    infix fun isGreaterThanOrEqualTo(expected: Int): IntegerAssert {
+        assertion.isGreaterThanOrEqualTo(expected)
+        return this
+    }
+
+    infix fun isBetween(expected: IntRange): IntegerAssert {
+        assertion.isBetween(expected.start, expected.endInclusive)
+        return this
+    }
+
+    infix fun isStrictlyBetween(expected: IntRange): IntegerAssert {
+        assertion.isStrictlyBetween(expected.start, expected.endInclusive)
+        return this
+    }
+
+    infix fun isCloseTo(expected: Int): Close {
+        return Close(expected, assertion, this)
+    }
+
+    infix fun _is(expected: NumberSelector): IntegerAssert {
+        when (expected) {
+            zero -> assertion.isZero()
+            notZero -> assertion.isNotZero()
+            positive -> assertion.isPositive()
+            notPositive -> assertion.isNotPositive()
+            negative -> assertion.isNegative()
+            notNegative -> assertion.isNotNegative()
+        }
+        return this
+    }
+
+    class Close(private val actual: Int, private val assertion: AbstractIntegerAssert<*>, private val assert: IntegerAssert) {
+        infix fun withinOffset(expected: Int): IntegerAssert {
+            assertion.isCloseTo(actual, Assertions.within(expected))
+            return assert
+        }
+
+        infix fun withinPercentage(expected: Number): IntegerAssert {
+            assertion.isCloseTo(actual, Assertions.withinPercentage(expected.toDouble()))
+            return assert
+        }
+    }
+}