DirectTest checks compiler options

Previously, a bad compiler option was ignored.

Add a common idiom to StreamCapture to set stdout;
the idiom may be suboptimal for testing.

Convert a partest to junit for regex, and eliminate
one check file.

src/partest/scala/tools/partest/DirectTest.scala

@@ -41,7 +41,7 @@ abstract class DirectTest {
   def testPath   = SFile(sys.props("partest.test-path"))
   def testOutput = Directory(sys.props("partest.output"))
 
-  // override to add additional settings with strings
+  // override to add additional settings besides -d testOutput.path
   def extraSettings: String = ""
   // a default Settings object using only extraSettings
   def settings: Settings = newSettings(CommandLineParser.tokenize(extraSettings))
@@ -50,7 +50,8 @@ abstract class DirectTest {
     val s = new Settings
     val allArgs = args ++ CommandLineParser.tokenize(debugSettings)
     log("newSettings: allArgs = " + allArgs)
-    s.processArguments(allArgs, true)
+    val (success, residual) = s.processArguments(allArgs, processAll = false)
+    assert(success && residual.isEmpty, s"Bad settings [${args.mkString(",")}], residual [${residual.mkString(",")}]")
     s
   }
   // new compiler using given ad hoc args, -d and extraSettings

src/partest/scala/tools/partest/nest/StreamCapture.scala

@@ -28,6 +28,12 @@ object StreamCapture {
     }
   }
 
+  /** Set err to out. */
+  def redirErr[A](body: => A): A = savingSystem {
+    System.setOut(System.err)
+    body
+  }
+
   def capturingOutErr[A](output: OutputStream)(body: => A): A = {
     val charset = Charset.defaultCharset()
     Using.resource(new PrintStream(output, /*autoflush=*/true, charset.name())) { printStream =>

test/files/run/t6178.scala

@@ -2,6 +2,6 @@ import scala.reflect.runtime.universe._
 import scala.reflect.runtime.{currentMirror => cm}
 
 object Test extends App {
-  val plus = typeOf[java.lang.String].member(TermName("$plus")).asMethod
-  println(cm.reflect("").reflectMethod(plus).apply("2"))
+  val plusMethod = typeOf[java.lang.String].member(TermName("$plus")).asMethod
+  assert(cm.reflect("").reflectMethod(plusMethod).apply("2") == "2")
 }

test/junit/scala/util/matching/RegexTest.scala

@@ -173,4 +173,35 @@ class RegexTest {
     assertTrue(r.matches("foo2"))
     assertTrue(r.matches("2foo"))
   }
+
+  @Test def replacementMatching(): Unit = {
+    val regex = """\$\{(.+?)\}""".r
+    val replaced = regex.replaceAllIn("Replacing: ${main}. And another method: ${foo}.",
+        (m: util.matching.Regex.Match) => {
+      val identifier = m.group(1)
+      identifier
+    })
+    assertEquals("Replacing: main. And another method: foo.", replaced)
+
+    val regex3 = """\$\{(.+?)\}""".r
+    val replaced3 = regex3.replaceSomeIn("Replacing: ${main}. And another: ${foo}.", (m: util.matching.Regex.Match) => {
+      val id = m.group(1)
+      if (id.startsWith("m")) Some(id) else None
+    })
+    assertEquals("Replacing: main. And another: ${foo}.", replaced3)
+  }
+
+  @Test def groupsMatching(): Unit = {
+    val Date = """(\d+)/(\d+)/(\d+)""".r
+    for (Regex.Groups(a, b, c) <- Date findFirstMatchIn "1/1/2001 marks the start of the millennium. 31/12/2000 doesn't.") {
+      assertEquals("1", a)
+      assertEquals("1", b)
+      assertEquals("2001", c)
+    }
+    for (Regex.Groups(a, b, c) <- Date.findAllIn("1/1/2001 marks the start of the millennium. 31/12/2000 doesn't.").matchData) {
+      assert(a == "1" || a == "31")
+      assert(b == "1" || b == "12")
+      assert(c == "2001" || c == "2000")
+    }
+  }
 }