Fix uTest test task creation for multi-test-class test modules (com-lihaoyi#4811)

Seems to be caused by the `def getTestTasks` changes in
com-lihaoyi#4737. The problem appears to be
in uTest, which is strict about ensuring the `TaskDef`s passed to
`.tasks` must cover all tasks selected by the `args` selector, which
fails when we make multiple separate calls to `.tasks` each with the
tasks related to an individual test class:


https://github.com/com-lihaoyi/utest/blob/76e7fe5a72464ab44df3f829bd2b3e7699d522bf/utest/src/utest/runner/BaseRunner.scala#L67-L75

Arguably this is an issue in uTest for being too strict, but for now a
workaround is to do all the work in a single call to `.tasks` with all
test classes involved, and break it up into the per-test-class sublists
after the fact

Adjusted `example.scalalib.testing[1-test-suite]` to cover this case by
having two test classes in the `foo` test suite

Author: lihaoyi

example/javalib/testing/1-test-suite/build.mill

@@ -27,3 +27,5 @@ object bar extends JavaModule {
     )
   }
 }
+
+//// SNIPPET:RUNSINGLE

example/javalib/testing/1-test-suite/foo/test/src/foo/FooMoreTests.java

@@ -0,0 +1,33 @@
+package foo;
+
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.*;
+
+import org.junit.Test;
+
+public class FooMoreTests {
+
+  @Test
+  public void hello() {
+    String result = new Foo().hello();
+    assertTrue(result.startsWith("Hello"));
+  }
+
+  @Test
+  public void world() {
+    String result = new Foo().hello();
+    assertTrue(result.endsWith("World"));
+  }
+
+  @Test
+  public void testMockito() {
+    Foo mockFoo = mock(Foo.class);
+
+    when(mockFoo.hello()).thenReturn("Hello Mockito World");
+
+    String result = mockFoo.hello();
+
+    assertTrue(result.equals("Hello Mockito World"));
+    verify(mockFoo).hello();
+  }
+}

example/kotlinlib/testing/1-test-suite/build.mill

@@ -43,3 +43,5 @@ object bar extends KotlinModule {
     def kotlincOptions = super.kotlincOptions() ++ Seq("-jvm-target", "11")
   }
 }
+
+//// SNIPPET:RUNSINGLE

example/kotlinlib/testing/1-test-suite/foo/test/src/foo/FooMoreTests.kt

@@ -0,0 +1,35 @@
+package foo
+
+import io.kotest.core.spec.style.FunSpec
+import io.kotest.matchers.shouldBe
+import io.kotest.matchers.string.shouldEndWith
+import io.kotest.matchers.string.shouldStartWith
+import org.mockito.kotlin.doReturn
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.verify
+import org.mockito.kotlin.whenever
+
+class FooMoreTests :
+    FunSpec({
+
+        test("hello") {
+            val result = Foo().hello()
+            result shouldStartWith "Hello"
+        }
+
+        test("world") {
+            val result = Foo().hello()
+            result shouldEndWith "World"
+        }
+
+        test("mockito") {
+            val mockFoo = mock<Foo>()
+
+            whenever(mockFoo.hello()) doReturn "Hello Mockito World"
+
+            val result = mockFoo.hello()
+
+            result shouldBe "Hello Mockito World"
+            verify(mockFoo).hello()
+        }
+    })

example/package.mill

@@ -134,6 +134,7 @@ object `package` extends RootModule with Module {
             "kotest_filter_tests='hello' kotest_filter_specs='bar.BarTests' ./mill bar.test"
           )
           .replace("compiling 1 ... source...", "Compiling 1 ... source...")
+          .replace("compiling 2 ... source...", "Compiling 2 ... source...")
       case _ => line
     }
   }

example/scalalib/testing/1-test-suite/build.mill

@@ -28,11 +28,13 @@ object foo extends ScalaModule {
 compiling 1 ... source...
 
 > mill foo.test.compile
-compiling 1 ... source...
+compiling 2 ... source...
 
 > mill foo.test.testForked
 ...foo.FooTests...hello ...
 ...foo.FooTests...world ...
+...foo.FooMoreTests...hello ...
+...foo.FooMoreTests...world ...
 
 > mill foo.test # same as above, `.test` is the default task for the `test` module
 ...foo.FooTests...hello ...
@@ -131,6 +133,16 @@ object bar extends ScalaModule {
 // `foo.test` in the command line. e.g. {utest-github-url}[uTest]
 // lets you pass in a selector to decide which test to run, which in Mill would be:
 
+//// SNIPPET:RUNSINGLE
+/** Usage
+
+> mill foo.test foo.FooMoreTests
+...foo.FooMoreTests...hello ...
+
+*/
+
+//// SNIPPET:END
+
 /** Usage
 
 > mill bar.test bar.BarTests.hello

example/scalalib/testing/1-test-suite/foo/test/src/FooMoreTests.scala

@@ -0,0 +1,16 @@
+package foo
+import utest._
+object FooMoreTests extends TestSuite {
+  def tests = Tests {
+    test("hello") {
+      val result = Foo.hello()
+      assert(result.startsWith("Hello"))
+      result
+    }
+    test("world") {
+      val result = Foo.hello()
+      assert(result.endsWith("World"))
+      result
+    }
+  }
+}

scalalib/test/resources/testrunner/doneMessageFailure/src/DoneMessageFailureFramework.scala

@@ -14,25 +14,18 @@ class DoneMessageFailureFramework extends Framework {
     def done() = "test failure done message"
     def remoteArgs() = Array.empty
     def tasks(taskDefs: Array[TaskDef]) = Array(new Task {
-      def taskDef(): TaskDef = taskDefs.head
+      def taskDef(): TaskDef = taskDefs.headOption.getOrElse(null)
       def execute(
           eventHandler: EventHandler,
           loggers: Array[Logger]
       ): Array[Task] = {
         eventHandler.handle(new Event {
-
           override def fullyQualifiedName(): String = "foo.bar"
-
           override def fingerprint(): Fingerprint = new Fingerprint {}
-
           override def selector(): Selector = new TestSelector("foo.bar")
-
           override def status(): Status = Status.Failure
-
           override def throwable(): OptionalThrowable = new OptionalThrowable()
-
           override def duration(): Long = 0L
-
         })
         Array.empty
       }

testrunner/src/mill/testrunner/TestRunnerUtils.scala

@@ -120,28 +120,24 @@ import java.util.concurrent.atomic.AtomicBoolean
     val runner = framework.runner(args.toArray, Array[String](), cl)
     val testClasses = discoverTests(cl, framework, testClassfilePath)
 
-    val filteredTestClasses = testClasses.iterator.filter { case (cls, _) =>
-      classFilter(cls)
-    }.toArray
-
-    val tasksArr = // each test class can have multiple test tasks ==> array of test classes will have this signature
-      if (filteredTestClasses.isEmpty) {
-        // We still need to run runner's tasks on empty array
-        Array(runner.tasks(Array.empty))
-      } else {
-        filteredTestClasses.map { case (cls, fingerprint) =>
-          runner.tasks(
-            Array(new TaskDef(
-              cls.getName.stripSuffix("$"),
-              fingerprint,
-              false,
-              Array(new SuiteSelector)
-            ))
-          )
-        }
-      }
+    val tasks = runner.tasks(
+      for ((cls, fingerprint) <- testClasses.iterator.toArray if classFilter(cls))
+        yield new TaskDef(
+          cls.getName.stripSuffix("$"),
+          fingerprint,
+          false,
+          Array(new SuiteSelector)
+        )
+    )
+
+    def nameOpt(t: Task) = Option(t.taskDef()).map(_.fullyQualifiedName())
+    val groupedTasks = tasks
+      .groupBy(nameOpt)
+      .values
+      .toArray
+      .sortBy(_.headOption.map(nameOpt))
 
-    (runner, tasksArr)
+    (runner, groupedTasks)
   }
 
   private def executeTasks(