add assertions for arrayEquals and iterableEquals

Author: MarkusAmshove

src/main/kotlin/org/amshove/kluent/Assertions.kt

@@ -6,6 +6,9 @@ import kotlin.reflect.KClass
 infix fun Any.shouldEqual(theOther: Any) = this `should equal` theOther
 infix fun Any.shouldNotEqual(theOther: Any) = this `should not equal` theOther
 
+infix fun <T> Array<T>.shouldEqual(theOther: Array<T>) = this `should equal` theOther
+infix fun <T> Iterable<T>.shouldEqual(theOther: Iterable<T>) = this `should equal` theOther
+
 infix fun Any.shouldBe(theOther: Any) = this `should be` theOther
 infix fun Any.shouldNotBe(theOther: Any) = this `should not be` theOther
 

src/main/kotlin/org/amshove/kluent/BacktickAssertions.kt

@@ -3,10 +3,14 @@ package org.amshove.kluent
 import org.junit.ComparisonFailure
 import kotlin.reflect.KClass
 import org.junit.Assert.*
+import java.util.*
 
 infix fun Any.`should equal`(theOther: Any) = assertEquals(theOther, this)
 infix fun Any.`should not equal`(theOther: Any) = assertNotEquals(theOther, this)
 
+infix fun <T> Array<T>.`should equal`(theOther: Array<T>) = assertArrayEquals(theOther, this)
+infix fun <T> Iterable<T>.`should equal`(theOther: Iterable<T>) = assertEquals(theOther, this)
+
 infix fun Any.`should be`(theOther: Any) = assertSame(theOther, this)
 infix fun Any.`should not be`(theOther: Any) = assertNotSame(theOther, this)
 
@@ -56,7 +60,7 @@ infix fun <T : Exception> (() -> Unit).`should not throw`(expectedException: KCl
     }
 }
 
-infix fun <T : Exception> (() -> Unit).`should not throw the Exception`(expectedException: KClass<T>) : NotThrowExceptionResult {
+infix fun <T : Exception> (() -> Unit).`should not throw the Exception`(expectedException: KClass<T>): NotThrowExceptionResult {
     try {
         this.invoke()
         return NotThrowExceptionResult(noException)

src/test/kotlin/org/amshove/kluent/tests/assertions/ShouldEqualTests.kt

@@ -30,6 +30,34 @@ class ShouldEqualTests : Spek() {
                     firstObject shouldEqual secondObject
                 }
             }
+            on("checking two equal arrays") {
+                val firstArray = arrayOf(1, 2, 3)
+                val secondArray = arrayOf(1, 2, 3)
+                it("should pass") {
+                    firstArray shouldEqual secondArray
+                }
+            }
+            on("checking two different arrays") {
+                val firstArray = arrayOf(1, 2, 3)
+                val secondArray = arrayOf(4, 5, 6)
+                it("should fail") {
+                    assertFails({ firstArray shouldEqual secondArray })
+                }
+            }
+            on("checking two equal iterables") {
+                val firstIterable = listOf(Person("Tom", "Guy"), Person("Alice", "Bob"), Person("Jon", "Doe"))
+                val secondIterable = listOf(Person("Tom", "Guy"), Person("Alice", "Bob"), Person("Jon", "Doe"))
+                it("should pass") {
+                    firstIterable shouldEqual secondIterable
+                }
+            }
+            on("checking two different iterables") {
+                val firstIterable = listOf(Person("Tom", "Guy"), Person("Jon", "Doe"), Person("Peter", "Meyer"))
+                val secondIterable = listOf(Person("Tom", "Guy"), Person("Alice", "Bob"), Person("Jon", "Doe"))
+                it("should fail") {
+                    assertFails({ firstIterable shouldEqual secondIterable })
+                }
+            }
         }
     }
 }

src/test/kotlin/org/amshove/kluent/tests/backtickassertions/ShouldEqualTests.kt

@@ -5,7 +5,7 @@ import org.amshove.kluent.tests.helpclasses.Person
 import org.jetbrains.spek.api.Spek
 import kotlin.test.assertFails
 
-class ShouldEqualTests : Spek() {
+class ShouldequalTests : Spek() {
     init {
         given("the should equal method") {
             on("checking equality of two equal strings") {
@@ -30,6 +30,34 @@ class ShouldEqualTests : Spek() {
                     firstObject `should equal` secondObject
                 }
             }
+            on("checking two equal arrays") {
+                val firstArray = arrayOf(1, 2, 3)
+                val secondArray = arrayOf(1, 2, 3)
+                it("should pass") {
+                    firstArray `should equal` secondArray
+                }
+            }
+            on("checking two different arrays") {
+                val firstArray = arrayOf(1, 2, 3)
+                val secondArray = arrayOf(4, 5, 6)
+                it("should fail") {
+                    assertFails({ firstArray `should equal` secondArray })
+                }
+            }
+            on("checking two equal iterables") {
+                val firstIterable = listOf(Person("Tom", "Guy"), Person("Alice", "Bob"), Person("Jon", "Doe"))
+                val secondIterable = listOf(Person("Tom", "Guy"), Person("Alice", "Bob"), Person("Jon", "Doe"))
+                it("should pass") {
+                    firstIterable `should equal` secondIterable
+                }
+            }
+            on("checking two different iterables") {
+                val firstIterable = listOf(Person("Tom", "Guy"), Person("Jon", "Doe"), Person("Peter", "Meyer"))
+                val secondIterable = listOf(Person("Tom", "Guy"), Person("Alice", "Bob"), Person("Jon", "Doe"))
+                it("should fail") {
+                    assertFails({ firstIterable `should equal` secondIterable })
+                }
+            }
         }
     }
 }