A modern programming language that makes developers happier.

kotlinlang

Is there any reason why `asClue` doesn't print the clue in this example?
```test("foo") {
  "some clue".asClue {
    emptyList&lt;Unit&gt;().single()
  }
}```
stacktrace:
```List is empty.
java.util.NoSuchElementException: List is empty.
	at kotlin.collections.CollectionsKt___CollectionsKt.single(_Collections.kt:616)```


I think it's because you don't have an assertion that fails but an exception.
```emptyList&lt;Unit&gt;().shouldNotBeEmpty()```
should display the clue

that was my hunch... so because `single()` throws NPE or `IllegalArgumentException` and not the `AssertionFailedError`? Might explain why half of our test failures do not include clues - quite a lot of our testing infrastructure code and logic doesn't use kotest assertions because it doesn't need to and it's easier that way. Unfortunately that clue doesn't get printed in these cases.

We use `single { someCondition }` quite frequently instead of `shouldHaveSingleElement { }` in our tests. `single` returns the item and that's what we need in most of our tests. Whereas `shouldHaveSingleElement` returns the subjected list...

Filed feature request <https://github.com/kotest/kotest/issues/4346>

Perhaps I could wrap `asClue`/`withClue` into my own extension and wrap thrown exceptions into `AssertionFailedError` in meantime :thinking_face:

It's a bit different and can be overcome. Answer in the issue above. However, I'd advise to stick with using only Assertion-type exceptions for test failures, as that's part of the informal protocol. Test frameworks usually differentiate between "this test failed" and "the testing machinery failed".

&gt; However, I'd advise to stick with using only Assertion-type exceptions for test failures, as that's part of the informal protocol.
I think from our experience using assertion APIs only is limiting and creates very verbose code - often it's a lot easier to just call `single { someCondition }`  like in this example instead of calling an extra `shouldHaveSingleElement` beforehand. Maybe I'm missing some special way on how to write this code differently?
```rows // List&lt;RowModel&gt;
  .single { it.title = "Row 1" }
  .onClick()```


the best I can come up with is:
```rows // List&lt;RowModel&gt;
  .shouldHaveSingleElement { it.title == "Row 1" }
  .single { it.title = "Row 1" } // should never throw at this point but we just the matched row
  .onClick()```
maybe I could reuse the predicate, but this is quite verbose, given the simplicity of the example. :thinking_face:

```rows // List<RowModel>
  .forSingle { it.title == "Row 1" }
  .onClick()```
should work, `forSingle` tests for the lambda and then (if a single match is found) returns the result

`forSingle` expects a Kotest assertion inside its lambda, right? So it would be
```rows // List&lt;RowModel&gt;
  .forSingle { it.title shouldBe "Row 1" }
  .onClick()```

True, thanks for the correction :slightly_smiling_face: