A modern programming language that makes developers happier.

kotlinlang

image.png

for the first, the tests aren't nested and so when they start to repeat through the inner loop on the second outer loop, I get 'duplicate' test name errors.

but if I create that test internally, now there are two tests with that name. Here is a demonstration of the issue by just adding a prefix to the test

Can you paste up the code for the first example

```class PrintDrlTest : FreeSpec({

    "test" - {
        forAll("a", "b", "c") { outer -&gt;
            forAll("1", "2", "3") { inner -&gt;
                println("$outer$inner")
            }
        }
    }

    "test 2" - {
        forAll("a", "b", "c") { outer -&gt;
            "prefix: $outer" - {
                forAll("1", "2", "3") { inner -&gt;
                    println("$outer$inner")
                }
            }
        }
    }
})```

```    "test" - {
        forAll("a", "b", "c") { outer -&gt;
            forAll("1", "2", "3") { inner -&gt;
                println("$outer$inner")
            }
        }
    }```


that's just two nested loops, and the outer loop won't be joined with the inner loop for a test name

like it looks like the tests will be nested but they won't be because you're not creating inner tests

It's no difference to going

```test("a") { }
test("1") { }
test("2") { }
test("b") { }
test("1") { }
test("2") { }```

for either of those they're not really nested? How do I get them to nest then? I tried `test 2` without the prefix and have the issue of the duplicate top level tests

see my most recent pictures in the main channel

If you want to nest tests, then just roll your own loop

```    "test" - {
        listOf("a", "b", "c").forEach { outer -&gt;
           "$outer" - {
                 listOf("1", "2", "3").forEach { inner -&gt;
                        "$inner" - {
                              println("$outer$inner")
                        }
                  }
               }
        }
    }```


what does the forAll accomplish then? If it needs to be nested in a test to begin with, and you can't nest them without this issue.

forAll is special syntax that will create tests for you (basically doing what I pasted above)

just seems like it should work to nest as well. I'll just roll my own loop.

nested tests are created at runtime, because it's just nested lambdas right. So when the code is compiled with forAll it binds to the closest statically created test loop. so in your example, the closest loop is the top level "test"- block. The inner block doesn't exist until runtime.

I can see why it's not intuitive. Let me make a ticket to see if we can make the whole thing defer until runtime.

<https://github.com/kotest/kotest/issues/2078>

thanks for the feedback, always good to keep improving things

welcome! I was just really confused by it all. couldn't understand why it was making the top ones twice.