[autofix.ci] apply automated fixes

autofix-ci[bot] · web-flow · commit 645dd3587337 · 2025-03-22T10:42:04.000Z
diff --git a/main/util/src/mill/util/Util.scala b/main/util/src/mill/util/Util.scala
@@ -106,7 +106,7 @@ object Util {
     char.toString * (targetLength - s.length) + s
   }
 
-  def renderSecondsSuffix(millis: Long) = (millis / 1000).toInt match {
+  def renderSecondsSuffix(millis: Long): String = (millis / 1000).toInt match {
     case 0 => ""
     case n => s" ${n}s"
   }
diff --git a/scalalib/src/mill/scalalib/TestModuleUtil.scala b/scalalib/src/mill/scalalib/TestModuleUtil.scala
@@ -175,52 +175,66 @@ private final class TestModuleUtil(
   private def runTestDefault(
       filteredClassLists: Seq[Seq[String]]
   )(implicit ctx: mill.api.Ctx) = {
-    TestModuleUtil.withTestProgressTickerThread(filteredClassLists.map(_.size).sum)(body = workerResultSet => {
-      filteredClassLists match {
-        // When no tests at all are discovered, run at least one test JVM
-        // process to go through the test framework setup/teardown logic
-        case Nil => callTestRunnerSubprocess(Task.dest, Left(Nil), workerResultSet)
-        case Seq(singleTestClassList) =>
-          callTestRunnerSubprocess(Task.dest, Left(singleTestClassList), workerResultSet)
-        case multipleTestClassLists =>
-          val maxLength = multipleTestClassLists.length.toString.length
-          val futures = multipleTestClassLists.zipWithIndex.map { case (testClassList, i) =>
-            val groupPromptMessage = testClassList match {
-              case Seq(single) => single
-              case multiple =>
-                TestModuleUtil.collapseTestClassNames(
-                  multiple
-                ).mkString(", ") + s", ${multiple.length} suites"
-            }
+    TestModuleUtil.withTestProgressTickerThread(filteredClassLists.map(_.size).sum)(body =
+      workerResultSet => {
+        filteredClassLists match {
+          // When no tests at all are discovered, run at least one test JVM
+          // process to go through the test framework setup/teardown logic
+          case Nil => callTestRunnerSubprocess(Task.dest, Left(Nil), workerResultSet)
+          case Seq(singleTestClassList) =>
+            callTestRunnerSubprocess(Task.dest, Left(singleTestClassList), workerResultSet)
+          case multipleTestClassLists =>
+            val maxLength = multipleTestClassLists.length.toString.length
+            val futures = multipleTestClassLists.zipWithIndex.map { case (testClassList, i) =>
+              val groupPromptMessage = testClassList match {
+                case Seq(single) => single
+                case multiple =>
+                  TestModuleUtil.collapseTestClassNames(
+                    multiple
+                  ).mkString(", ") + s", ${multiple.length} suites"
+              }
 
-            val paddedIndex = mill.util.Util.leftPad(i.toString, maxLength, '0')
-            val folderName = testClassList match {
-              case Seq(single) => single
-              case multiple =>
-                s"group-$paddedIndex-${multiple.head}"
-            }
+              val paddedIndex = mill.util.Util.leftPad(i.toString, maxLength, '0')
+              val folderName = testClassList match {
+                case Seq(single) => single
+                case multiple =>
+                  s"group-$paddedIndex-${multiple.head}"
+              }
 
-            // set priority = -1 to always prioritize test subprocesses over normal Mill
-            // tasks. This minimizes the number of blocked tasks since Mill tasks can be
-            // blocked on test subprocesses, but not vice versa, so better to schedule
-            // the test subprocesses first
-            Task.fork.async(Task.dest / folderName, paddedIndex, groupPromptMessage, priority = -1) {
-              logger =>
-                (folderName, callTestRunnerSubprocess(Task.dest / folderName, Left(testClassList), workerResultSet))
+              // set priority = -1 to always prioritize test subprocesses over normal Mill
+              // tasks. This minimizes the number of blocked tasks since Mill tasks can be
+              // blocked on test subprocesses, but not vice versa, so better to schedule
+              // the test subprocesses first
+              Task.fork.async(
+                Task.dest / folderName,
+                paddedIndex,
+                groupPromptMessage,
+                priority = -1
+              ) {
+                logger =>
+                  (
+                    folderName,
+                    callTestRunnerSubprocess(
+                      Task.dest / folderName,
+                      Left(testClassList),
+                      workerResultSet
+                    )
+                  )
+              }
             }
-          }
 
-          val outputs = Task.fork.awaitAll(futures)
+            val outputs = Task.fork.awaitAll(futures)
 
-          val (lefts, rights) = outputs.partitionMap {
-            case (name, Left(v)) => Left(name + " " + v)
-            case (name, Right((msg, results))) => Right((name + " " + msg, results))
-          }
+            val (lefts, rights) = outputs.partitionMap {
+              case (name, Left(v)) => Left(name + " " + v)
+              case (name, Right((msg, results))) => Right((name + " " + msg, results))
+            }
 
-          if (lefts.nonEmpty) Left(lefts.mkString("\n"))
-          else Right((rights.map(_._1).mkString("\n"), rights.flatMap(_._2)))
+            if (lefts.nonEmpty) Left(lefts.mkString("\n"))
+            else Right((rights.map(_._1).mkString("\n"), rights.flatMap(_._2)))
+        }
       }
-    })
+    )
   }
 
   private def runTestQueueScheduler(
@@ -427,8 +441,8 @@ private final class TestModuleUtil(
 private[scalalib] object TestModuleUtil {
 
   private def withTestProgressTickerThread[T](totalClassCount: Long)(
-    tickerThreadBlock: () => Unit = () => (),
-    body: java.util.concurrent.ConcurrentMap[os.Path, Unit] => T
+      tickerThreadBlock: () => Unit = () => (),
+      body: java.util.concurrent.ConcurrentMap[os.Path, Unit] => T
   )(implicit ctx: mill.api.Ctx): T = {
     val workerResultSet = new java.util.concurrent.ConcurrentHashMap[os.Path, Unit]()
     val executor = Executors.newScheduledThreadPool(1)
@@ -437,14 +451,18 @@ private[scalalib] object TestModuleUtil {
       executor.scheduleWithFixedDelay(
         () => {
           tickerThreadBlock()
-          var totalSuccess = 0L 
+          var totalSuccess = 0L
           var totalFailure = 0L
           workerResultSet.forEach { (resultLog, _) =>
             val (success, failure) = upickle.default.read[(Long, Long)](os.read.stream(resultLog))
             totalSuccess += success
             totalFailure += failure
           }
-          ctx.log.ticker(s"${totalSuccess + totalFailure}/${totalClassCount} completed${ if (totalFailure > 0) { s", ${totalFailure} failures." } else { "." } }")
+          ctx.log.ticker(
+            s"${totalSuccess + totalFailure}/${totalClassCount} completed${if (totalFailure > 0) {
+                s", ${totalFailure} failures."
+              } else { "." }}"
+          )
         },
         0,
         20,
diff --git a/scalalib/test/src/mill/scalalib/TestRunnerScalatestTests.scala b/scalalib/test/src/mill/scalalib/TestRunnerScalatestTests.scala
@@ -32,8 +32,20 @@ object TestRunnerScalatestTests extends TestSuite {
         3,
         Map(
           // No test grouping is triggered because we only run one test class
-          testrunner.scalatest -> Set("out.json", "result.log", "sandbox", "test-report.xml", "testargs"),
-          testrunnerGrouping.scalatest -> Set("out.json", "result.log", "sandbox", "test-report.xml", "testargs"),
+          testrunner.scalatest -> Set(
+            "out.json",
+            "result.log",
+            "sandbox",
+            "test-report.xml",
+            "testargs"
+          ),
+          testrunnerGrouping.scalatest -> Set(
+            "out.json",
+            "result.log",
+            "sandbox",
+            "test-report.xml",
+            "testargs"
+          ),
           testrunnerParallel.scalatest -> Set("worker-0", "test-classes", "test-report.xml")
         )
       )
@@ -43,7 +55,13 @@ object TestRunnerScalatestTests extends TestSuite {
         Seq("*"),
         9,
         Map(
-          testrunner.scalatest -> Set("out.json", "result.log", "sandbox", "test-report.xml", "testargs"),
+          testrunner.scalatest -> Set(
+            "out.json",
+            "result.log",
+            "sandbox",
+            "test-report.xml",
+            "testargs"
+          ),
           testrunnerGrouping.scalatest -> Set(
             "group-0-mill.scalalib.ScalaTestSpec",
             "mill.scalalib.ScalaTestSpec3",
@@ -76,7 +94,13 @@ object TestRunnerScalatestTests extends TestSuite {
         Seq("*", "--", "-z", "A Set 2"),
         3,
         Map(
-          testrunner.scalatest -> Set("out.json", "result.log", "sandbox", "test-report.xml", "testargs"),
+          testrunner.scalatest -> Set(
+            "out.json",
+            "result.log",
+            "sandbox",
+            "test-report.xml",
+            "testargs"
+          ),
           testrunnerGrouping.scalatest -> Set(
             "group-0-mill.scalalib.ScalaTestSpec",
             "mill.scalalib.ScalaTestSpec3",
diff --git a/scalalib/test/src/mill/scalalib/TestRunnerUtestTests.scala b/scalalib/test/src/mill/scalalib/TestRunnerUtestTests.scala
@@ -36,17 +36,35 @@ object TestRunnerUtestTests extends TestSuite {
         Seq("mill.scalalib.FooTests"),
         1,
         Map(
-          testrunner.utest -> Set("out.json", "result.log", "sandbox", "test-report.xml", "testargs"),
+          testrunner.utest -> Set(
+            "out.json",
+            "result.log",
+            "sandbox",
+            "test-report.xml",
+            "testargs"
+          ),
           // When there is only one test group with test classes, we do not put it in a subfolder
-          testrunnerGrouping.utest -> Set("out.json", "result.log", "sandbox", "test-report.xml", "testargs"),
+          testrunnerGrouping.utest -> Set(
+            "out.json",
+            "result.log",
+            "sandbox",
+            "test-report.xml",
+            "testargs"
+          ),
           testrunnerParallel.utest -> Set("worker-0", "test-classes", "test-report.xml")
         )
       )
       test("multi") - tester.testOnly(
         Seq("*Bar*", "*bar*"),
         2,
         Map(
-          testrunner.utest -> Set("out.json", "result.log", "sandbox", "test-report.xml", "testargs"),
+          testrunner.utest -> Set(
+            "out.json",
+            "result.log",
+            "sandbox",
+            "test-report.xml",
+            "testargs"
+          ),
           // When there are multiple test groups with one test class each, we
           // put each test group in a subfolder with the number of the class
           testrunnerGrouping.utest -> Set(
@@ -61,7 +79,13 @@ object TestRunnerUtestTests extends TestSuite {
         Seq("*"),
         3,
         Map(
-          testrunner.utest -> Set("out.json", "result.log", "sandbox", "test-report.xml", "testargs"),
+          testrunner.utest -> Set(
+            "out.json",
+            "result.log",
+            "sandbox",
+            "test-report.xml",
+            "testargs"
+          ),
           // When there are multiple test groups some with multiple test classes, we put each
           // test group in a subfolder with the index of the group, and for any test groups
           // with only one test class we append the name of the class
diff --git a/testrunner/src/mill/testrunner/TestRunnerUtils.scala b/testrunner/src/mill/testrunner/TestRunnerUtils.scala
@@ -119,7 +119,9 @@ 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 filteredTestClasses = testClasses.iterator.filter { case (cls, _) =>
+      classFilter(cls)
+    }.toArray
 
     val tasksArr: Array[Array[Task]] = // each test class can have multiple test tasks ==> array of test classes will have this signature
       if (filteredTestClasses.isEmpty) {
@@ -216,7 +218,12 @@ import java.util.concurrent.atomic.AtomicBoolean
     (doneMessage, results)
   }
 
-  def runTasks(tasksSeq: Seq[Seq[Task]], testReporter: TestReporter, runner: Runner, resultPathOpt: Option[os.Path])(implicit
+  def runTasks(
+      tasksSeq: Seq[Seq[Task]],
+      testReporter: TestReporter,
+      runner: Runner,
+      resultPathOpt: Option[os.Path]
+  )(implicit
       ctx: Ctx.Log with Ctx.Home
   ): (String, Iterator[TestResult]) = {
     // Capture this value outside of the task event handler so it
@@ -227,13 +234,20 @@ import java.util.concurrent.atomic.AtomicBoolean
     var failureCounter = 0L
 
     val resultLog: () => Unit = resultPathOpt match {
-      case Some(resultPath) => () => os.write.over(resultPath, upickle.default.write((successCounter, failureCounter)))
-      case None => () => ctx.log.outputStream.println(s"Test result: ${successCounter + failureCounter} completed${ if (failureCounter > 0) { s", ${failureCounter} failures." } else { "." } }")
+      case Some(resultPath) =>
+        () => os.write.over(resultPath, upickle.default.write((successCounter, failureCounter)))
+      case None => () =>
+          ctx.log.outputStream.println(
+            s"Test result: ${successCounter + failureCounter} completed${if (failureCounter > 0) {
+                s", ${failureCounter} failures."
+              } else { "." }}"
+          )
     }
 
     tasksSeq.foreach { tasks =>
       val taskResult = executeTasks(tasks, testReporter, events)
-      if (taskResult) { successCounter += 1 } else { failureCounter += 1 }
+      if (taskResult) { successCounter += 1 }
+      else { failureCounter += 1 }
       resultLog()
     }
 
@@ -254,7 +268,8 @@ import java.util.concurrent.atomic.AtomicBoolean
 
     val (runner, tasksArr) = getTestTasks(framework, args, classFilter, cl, testClassfilePath)
 
-    val (doneMessage, results) = runTasks(tasksArr.view.map(_.toSeq).toSeq, testReporter, runner, resultPathOpt)
+    val (doneMessage, results) =
+      runTasks(tasksArr.view.map(_.toSeq).toSeq, testReporter, runner, resultPathOpt)
 
     (doneMessage, results.toSeq)
   }
@@ -289,7 +304,8 @@ import java.util.concurrent.atomic.AtomicBoolean
 
       val tasks = runner.tasks(taskDefs.toArray)
       val taskResult = executeTasks(tasks, testReporter, events)
-      if (taskResult) { successCounter += 1 } else { failureCounter += 1 }
+      if (taskResult) { successCounter += 1 }
+      else { failureCounter += 1 }
       os.write.over(resultPath, upickle.default.write((successCounter, failureCounter)))
     }
 

Original file line number	Diff line number	Diff line change
`@@ -106,7 +106,7 @@ object Util {`
`106`	`106`	`char.toString * (targetLength - s.length) + s`
`107`	`107`	`}`
`108`	`108`
`109`		`- def renderSecondsSuffix(millis: Long) = (millis / 1000).toInt match {`
	`109`	`+ def renderSecondsSuffix(millis: Long): String = (millis / 1000).toInt match {`
`110`	`110`	`case 0 => ""`
`111`	`111`	`case n => s" ${n}s"`
`112`	`112`	`}`