Adding new assertFailureWith

assertk/src/commonMain/kotlin/assertk/assert.kt

@@ -190,3 +190,17 @@ inline fun assertFailure(f: () -> Unit): Assert<Throwable> {
     }
     fail("expected failure but lambda completed successfully")
 }
+
+/**
+ * Asserts that the given block will throw an exception with expected type rather than complete successfully.
+ */
+inline fun <reified T: Throwable> assertFailureWith(f: () -> Unit): Assert<T> {
+    @Suppress("TooGenericExceptionCaught", "InstanceOfCheckForException") // Intentionally capturing all exceptions.
+    try {
+        f()
+    } catch (t: Throwable) {
+        if (t !is T) fail("expected failure to be type of ${T::class}")
+        return assertThat(t)
+    }
+    fail("expected failure but lambda completed successfully")
+}

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

@@ -1,8 +1,8 @@
 package assertk.assertions
 
 import assertk.Assert
-import assertk.ValueAssert
 import assertk.all
+import kotlin.reflect.KProperty1
 
 /**
  * Returns an assert on the throwable's message.
@@ -62,5 +62,16 @@ fun Assert<Throwable>.hasRootCause(cause: Throwable) {
     }
 }
 
+/**
+ * Asserts the throwable with a specific type have the expected properties for it.
+ */
+fun <T: Throwable> Assert<T>.hasProperties(vararg pairs: Pair<KProperty1<T, Any>, Any>) {
+    all {
+        pairs.forEach {
+            prop(it.first).isEqualTo(it.second)
+        }
+    }
+}
+
 private fun Throwable.rootCause(): Throwable = this.cause?.rootCause() ?: this
 

assertk/src/commonTest/kotlin/test/assertk/AssertFailureTest.kt

@@ -1,6 +1,8 @@
 package test.assertk
 
 import assertk.assertFailure
+import assertk.assertFailureWith
+import assertk.assertions.hasProperties
 import assertk.assertions.isEqualTo
 import assertk.assertions.isInstanceOf
 import assertk.assertions.message
@@ -9,12 +11,7 @@ import test.assertk.assertions.valueOrFail
 import kotlin.coroutines.resume
 import kotlin.coroutines.resumeWithException
 import kotlin.coroutines.suspendCoroutine
-import kotlin.test.Test
-import kotlin.test.assertEquals
-import kotlin.test.assertFailsWith
-import kotlin.test.assertFalse
-import kotlin.test.assertSame
-import kotlin.test.assertTrue
+import kotlin.test.*
 
 class AssertFailureTest {
 
@@ -24,6 +21,30 @@ class AssertFailureTest {
         assertSame(expected, assertFailure { throw expected }.valueOrFail)
     }
 
+    @Test
+    fun failure_with_expected_type_and_additional_properties() {
+        assertFailureWith<DummyException> {
+            throw DummyException(12, "night")
+        }.hasProperties(
+            DummyException::value to 12,
+            DummyException::tag to "night"
+        )
+    }
+
+    @Test
+    fun failure_with_wrong_type() {
+        val t = assertFailsWith<AssertionFailedError> {
+            assertFailureWith<DummyException> {
+                throw RuntimeException()
+            }
+        }
+
+        val message = t.message ?: fail("should have a message")
+
+        assertTrue("expected failure to be type of class" in message)
+        assertTrue("DummyException" in message)
+    }
+
     @Test
     fun failure_originating_subject_not_wrapped_in_result() {
         val t = assertFailsWith<AssertionFailedError> {
@@ -60,4 +81,6 @@ class AssertFailureTest {
         }
         t.isInstanceOf<IllegalArgumentException>()
     }
+
+    class DummyException(val value: Int, val tag: String) : Exception("My value broken is $value")
 }