[1.x] Fix test format (#8969)

main/src/test/scala/sbt/internal/ResolversVcsSecurityTest.scala

@@ -9,17 +9,17 @@
 package sbt
 package internal
 
-import hedgehog.*
-import hedgehog.runner.*
+import hedgehog._
+import hedgehog.runner._
 
 import java.net.URI
-import scala.jdk.CollectionConverters.*
+import scala.jdk.CollectionConverters._
 
 import _root_.sbt.Resolvers
 import _root_.sbt.io.IO
 import _root_.sbt.internal.BuildLoader.ResolveInfo
 
-object ResolversVcsSecurityTest extends Properties:
+object ResolversVcsSecurityTest extends Properties {
 
   override def tests: List[Test] = List(
     example(
@@ -55,31 +55,37 @@ object ResolversVcsSecurityTest extends Properties:
   private def vcsUri(scheme: String, path: String, fragment: String): URI =
     new URI(scheme, null, "example.com", -1, path, null, fragment)
 
-  private def testResolverRejects(resolver: Resolvers.Resolver, uri: URI): Result =
+  private def testResolverRejects(resolver: Resolvers.Resolver, uri: URI): Result = {
     val staging = IO.createTemporaryDirectory
-    try
+    try {
       val info = new ResolveInfo(uri, staging, null, null)
-      try
+      try {
         resolver(info)
         Result.failure.log(s"expected IllegalArgumentException for $uri")
-      catch case _: IllegalArgumentException => Result.success
-    finally IO.delete(staging)
+      } catch {
+        case _: IllegalArgumentException => Result.success
+      }
+    } finally IO.delete(staging)
+  }
 
-  private def testResolverAccepts(resolver: Resolvers.Resolver, uri: URI): Result =
+  private def testResolverAccepts(resolver: Resolvers.Resolver, uri: URI): Result = {
     val staging = IO.createTemporaryDirectory
-    try
+    try {
       val info = new ResolveInfo(uri, staging, null, null)
-      try
-        resolver(info) match
-          case Some(_) => Result.success
-          case None    => Result.failure.log(s"expected Some for $uri")
-      catch
+      try resolver(info) match {
+        case Some(_) => Result.success
+        case None    => Result.failure.log(s"expected Some for $uri")
+      } catch {
         case e: IllegalArgumentException =>
           Result.failure.log(s"unexpected IllegalArgumentException for $uri: ${e.getMessage}")
-    finally IO.delete(staging)
+      }
+    } finally IO.delete(staging)
+  }
 
-  private def testProcessBuilderKeepsMetacharactersInSingleArgument: Result =
-    val argv = new ProcessBuilder("git", "fetch", "origin", "topic&injection").command().asScala.toList
+  private def testProcessBuilderKeepsMetacharactersInSingleArgument: Result = {
+    val argv =
+      new ProcessBuilder("git", "fetch", "origin", "topic&injection").command().asScala.toList
     Result.assert(argv == List("git", "fetch", "origin", "topic&injection"))
+  }
 
-end ResolversVcsSecurityTest
+}

main/src/test/scala/sbt/internal/VcsUriFragmentTest.scala

@@ -9,10 +9,10 @@
 package sbt
 package internal
 
-import hedgehog.*
-import hedgehog.runner.*
+import hedgehog._
+import hedgehog.runner._
 
-object VcsUriFragmentTest extends Properties:
+object VcsUriFragmentTest extends Properties {
   override def tests: List[Test] = List(
     example("accepts typical branch and tag names", testAcceptsSafe),
     example("accepts hex commit id fragment", testAcceptsHexSha),
@@ -27,16 +27,18 @@ object VcsUriFragmentTest extends Properties:
     example("rejects DEL", testRejectsDel),
   )
 
-  def testAcceptsSafe: Result =
+  def testAcceptsSafe: Result = {
     VcsUriFragment.validate("develop")
     VcsUriFragment.validate("v1.2.3")
     VcsUriFragment.validate("feature/foo-bar")
     VcsUriFragment.validate("release/1.0.0+build")
     Result.success
+  }
 
-  def testAcceptsHexSha: Result =
+  def testAcceptsHexSha: Result = {
     VcsUriFragment.validate("abc123def4567890abcdef1234567890abcdef12")
     Result.success
+  }
 
   def testRejectsEmpty: Result =
     interceptIllegal("")
@@ -66,9 +68,11 @@ object VcsUriFragmentTest extends Properties:
     interceptIllegal("a\u007fb")
 
   private def interceptIllegal(s: String): Result =
-    try
+    try {
       VcsUriFragment.validate(s)
       Result.failure.log(s"expected failure for ${s.map(_.toInt).mkString(",")}")
-    catch case _: IllegalArgumentException => Result.success
+    } catch {
+      case _: IllegalArgumentException => Result.success
+    }
 
-end VcsUriFragmentTest
+}