Update function names

Author: jzbrooks

assertk/src/commonMain/kotlin/assertk/assertions/array.kt

@@ -182,13 +182,13 @@ fun Assert<Array<*>>.containsExactly(vararg elements: Any?) = given { actual ->
  * Asserts the collection contains at least one instance of a given type.
  *
  * ```
- * assertThat(arrayOf<Any>("one", "two", 1)).containsInstanceOf<String>().each {
+ * assertThat(arrayOf<Any>("one", "two", 1)).havingInstanceOf<String>().each {
  *   it.hasLength(3)
  * }
  * ```
  */
-inline fun <reified T> Assert<Array<*>>.containsInstanceOf(): Assert<List<T>> {
-    return transform("contains subtype of ${T::class}") { actual ->
+inline fun <reified T> Assert<Array<*>>.havingInstancesOf(): Assert<List<T>> {
+    return transform("contains instances of ${T::class}") { actual ->
         actual.filterIsInstance<T>().also {
             if (it.isEmpty()) expected("to contain at least one instance of ${T::class} but was ${actual.asList()}")
         }
@@ -199,10 +199,10 @@ inline fun <reified T> Assert<Array<*>>.containsInstanceOf(): Assert<List<T>> {
  * Asserts the collection does not contain an instance of a given type.
  *
  * ```
- * assertThat(arrayOf<Any>("one", "two", 1)).doesNotContainInstanceOf<Double>()
+ * assertThat(arrayOf<Any>("one", "two", 1)).havingInstancesOf<Double>()
  * ```
  */
-inline fun <reified T> Assert<Array<*>>.doesNotContainInstanceOf() = given { actual ->
+inline fun <reified T> Assert<Array<*>>.notHavingInstancesOf() = given { actual ->
     if (actual.any { it is T }) expected("to not contain instances of ${T::class} but was ${actual.asList()}")
 }
 

assertk/src/commonMain/kotlin/assertk/assertions/iterable.kt

@@ -2,12 +2,10 @@ package assertk.assertions
 
 import assertk.Assert
 import assertk.all
-import assertk.assertThat
 import assertk.collection
 import assertk.assertions.support.appendName
 import assertk.assertions.support.expected
 import assertk.assertions.support.show
-import assertk.fail
 
 /**
  * Asserts the iterable contains the expected element, using `in`.
@@ -137,13 +135,13 @@ internal fun MutableList<*>.removeFirst(value: Any?) {
  * Asserts the collection contains at least one instance of a given type.
  *
  * ```
- * assertThat(listOf<Any>("one", "two", 1)).containsInstanceOf<String>().each {
+ * assertThat(listOf<Any>("one", "two", 1)).havingInstanceOf<String>().each {
  *   it.hasLength(3)
  * }
  * ```
  */
-inline fun <reified T> Assert<Iterable<*>>.containsInstanceOf(): Assert<List<T>> {
-    return transform("contains subtype of ${T::class}") { actual ->
+inline fun <reified T> Assert<Iterable<*>>.havingInstancesOf(): Assert<List<T>> {
+    return transform("contains instance of ${T::class}") { actual ->
         actual.filterIsInstance<T>().also {
             if (it.isEmpty()) expected("to contain at least one instance of ${T::class} but was $actual")
         }
@@ -157,7 +155,7 @@ inline fun <reified T> Assert<Iterable<*>>.containsInstanceOf(): Assert<List<T>>
  * assertThat(listOf<Any>("one", "two", 1)).doesNotContainInstanceOf<Double>()
  * ```
  */
-inline fun <reified T> Assert<Iterable<*>>.doesNotContainInstanceOf() = given { actual ->
+inline fun <reified T> Assert<Iterable<*>>.notHavingInstancesOf() = given { actual ->
     if (actual.any { it is T }) expected("to not contain instances of ${T::class} but was $actual")
 }
 

assertk/src/commonTest/kotlin/test/assertk/assertions/ArrayTest.kt

@@ -324,12 +324,12 @@ class ArrayTest {
 
     //region containsInstanceOf
     @Test fun containsInstanceOf_element_present_passes() {
-        assertThat(arrayOf<Any>(1, "two")).containsInstanceOf<String>().single().isEqualTo("two")
+        assertThat(arrayOf<Any>(1, "two")).havingInstancesOf<String>().single().isEqualTo("two")
     }
 
     @Test fun containsInstanceOf_element_missing_fails() {
         val error = assertFailsWith<AssertionError> {
-            assertThat(arrayOf<Any>(1, "two")).containsInstanceOf<Double>()
+            assertThat(arrayOf<Any>(1, "two")).havingInstancesOf<Double>()
         }
         assertEquals("expected to contain at least one instance of class kotlin.Double but was [1, two]", error.message)
     }
@@ -338,13 +338,13 @@ class ArrayTest {
     //region doesNotContainInstanceOf
     @Test fun doesNotContainInstanceOf_element_present_fails() {
         val error = assertFailsWith<AssertionError>() {
-            assertThat(arrayOf<Any>(1, "two")).doesNotContainInstanceOf<String>()
+            assertThat(arrayOf<Any>(1, "two")).notHavingInstancesOf<String>()
         }
         assertEquals("expected to not contain instances of class kotlin.String but was [1, two]", error.message)
     }
 
     @Test fun doesNotContainInstanceOf_element_missing_passes() {
-        assertThat(arrayOf<Any>(1, "two")).doesNotContainInstanceOf<Double>()
+        assertThat(arrayOf<Any>(1, "two")).notHavingInstancesOf<Double>()
     }
     //endregion
 

assertk/src/commonTest/kotlin/test/assertk/assertions/IterableTest.kt

@@ -1,7 +1,6 @@
 package test.assertk.assertions
 
 import assertk.all
-import assertk.assertFailure
 import assertk.assertThat
 import assertk.assertions.any
 import assertk.assertions.atLeast
@@ -10,11 +9,11 @@ import assertk.assertions.contains
 import assertk.assertions.containsAtLeast
 import assertk.assertions.containsExactly
 import assertk.assertions.containsExactlyInAnyOrder
-import assertk.assertions.containsInstanceOf
+import assertk.assertions.havingInstancesOf
 import assertk.assertions.containsNone
 import assertk.assertions.containsOnly
 import assertk.assertions.doesNotContain
-import assertk.assertions.doesNotContainInstanceOf
+import assertk.assertions.notHavingInstancesOf
 import assertk.assertions.each
 import assertk.assertions.exactly
 import assertk.assertions.extracting
@@ -234,12 +233,12 @@ class IterableTest {
 
     //region containsInstanceOf
     @Test fun containsInstanceOf_element_present_passes() {
-        assertThat(iterableOf(1, "two")).containsInstanceOf<String>().single().isEqualTo("two")
+        assertThat(iterableOf(1, "two")).havingInstancesOf<String>().single().isEqualTo("two")
     }
 
     @Test fun containsInstanceOf_element_missing_fails() {
         val error = assertFailsWith<AssertionError> {
-            assertThat(iterableOf(1, "two")).containsInstanceOf<Double>()
+            assertThat(iterableOf(1, "two")).havingInstancesOf<Double>()
         }
         assertEquals("expected to contain at least one instance of class kotlin.Double but was [1, two]", error.message)
     }
@@ -248,13 +247,13 @@ class IterableTest {
     //region doesNotContainInstanceOf
     @Test fun doesNotContainInstanceOf_element_present_fails() {
         val error = assertFailsWith<AssertionError>() {
-            assertThat(iterableOf(1, "two")).doesNotContainInstanceOf<String>()
+            assertThat(iterableOf(1, "two")).notHavingInstancesOf<String>()
         }
         assertEquals("expected to not contain instances of class kotlin.String but was [1, two]", error.message)
     }
 
     @Test fun doesNotContainInstanceOf_element_missing_passes() {
-        assertThat(iterableOf(1, "two")).doesNotContainInstanceOf<Double>()
+        assertThat(iterableOf(1, "two")).notHavingInstancesOf<Double>()
     }
     //endregion