JUnit migration

build.sbt

@@ -76,6 +76,8 @@ pomExtra := (
   </developers>
 )
 
+libraryDependencies ++= Seq("junit" % "junit" % "4.11" % "test", "com.novocode" % "junit-interface" % "0.10" % "test")
+
 // default value must be set here
 TestKeys.includeTestDependencies := true
 

src/test/scala/scala/util/parsing/combinator/JavaTokenParsersTest.scala

@@ -0,0 +1,58 @@
+package scala.util.parsing.combinator
+
+import scala.util.parsing.input.CharArrayReader
+
+import org.junit.Test
+import org.junit.Assert.assertEquals
+
+class JavaTokenParsersTest {
+
+  @Test
+  def parseDecimalNumber: Unit = {
+    object TestJavaTokenParsers extends JavaTokenParsers
+    import TestJavaTokenParsers._
+    assertEquals("1.1", decimalNumber(new CharArrayReader("1.1".toCharArray)).get)
+    assertEquals("1.", decimalNumber(new CharArrayReader("1.".toCharArray)).get)
+    assertEquals(".1", decimalNumber(new CharArrayReader(".1".toCharArray)).get)
+    // should fail to parse and we should get Failure as ParseResult
+    val failure = decimalNumber(new CharArrayReader("!1".toCharArray)).asInstanceOf[Failure]
+    assertEquals("""string matching regex `(\d+(\.\d*)?|\d*\.\d+)' expected but `!' found""", failure.msg)
+  }
+
+  @Test
+  def parseJavaIdent: Unit = {
+    object javaTokenParser extends JavaTokenParsers
+    import javaTokenParser._
+    def parseSuccess(s: String): Unit = {
+      val parseResult = parseAll(ident, s)
+      parseResult match {
+        case Success(r, _) => assertEquals(s, r)
+        case _ => sys.error(parseResult.toString)
+      }
+    }
+    def parseFailure(s: String, errorColPos: Int): Unit = {
+      val parseResult = parseAll(ident, s)
+      parseResult match {
+        case Failure(_, next) =>
+          val pos = next.pos
+          assertEquals(1, pos.line)
+          assertEquals(errorColPos, pos.column)
+        case _ => sys.error(parseResult.toString)
+      }
+    }
+    parseSuccess("simple")
+    parseSuccess("with123")
+    parseSuccess("with$")
+    parseSuccess("with\u00f8\u00df\u00f6\u00e8\u00e6")
+    parseSuccess("with_")
+    parseSuccess("_with")
+
+    parseFailure("3start", 1)
+    parseFailure("-start", 1)
+    parseFailure("with-s", 5)
+    // we♥scala
+    parseFailure("we\u2665scala", 3)
+    parseFailure("with space", 6)
+  }
+
+}

src/test/scala/scala/util/parsing/combinator/PackratParsersTest.scala

@@ -0,0 +1,159 @@
+package scala.util.parsing.combinator
+
+import org.junit.Test
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+
+import scala.util.parsing.combinator.syntactical.StandardTokenParsers
+
+class PackratParsersTest {
+
+  @Test
+  def test1: Unit = {
+    import grammars1._
+    val head = phrase(term)
+
+    def extractResult(r : ParseResult[Int]): Int = r match {
+      case Success(a,_) => a
+      case NoSuccess(a,_) => sys.error(a)
+    }
+    def check(expected: Int, expr: String): Unit = {
+      val parseResult = head(new lexical.Scanner(expr))
+      val result = extractResult(parseResult)
+      assertEquals(expected, result)
+    }
+
+    check(1, "1")
+    check(3, "1+2")
+    check(5, "9-4")
+    check(81, "9*9")
+    check(4, "8/2")
+    check(37, "4*9-0/7+9-8*1")
+    check(9, "(1+2)*3")
+  }
+
+  @Test
+  def test2: Unit = {
+    import grammars2._
+    val head = phrase(exp)
+
+    def extractResult(r : ParseResult[Int]): Int = r match {
+      case Success(a,_) => a
+      case NoSuccess(a,_) => sys.error(a)
+    }
+    def check(expected: Int, expr: String): Unit = {
+      val parseResult = head(new lexical.Scanner(expr))
+      val result = extractResult(parseResult)
+      assertEquals(expected, result)
+    }
+
+    check(1, "1")
+    check(3, "1+2")
+    check(81, "9*9")
+    check(43, "4*9+7")
+    check(59, "4*9+7*2+3*3")
+    check(188, "4*9+7*2+3*3+9*5+7*6*2")
+    check(960, "4*(9+7)*(2+3)*3")
+  }
+
+  @Test
+  def test3: Unit = {
+    import grammars3._
+    val head = phrase(AnBnCn)
+    def extractResult(r: ParseResult[AnBnCnResult]): AnBnCnResult = r match {
+      case Success(a,_) => a
+      case NoSuccess(a,_) => sys.error(a)
+    }
+    def threeLists(as: List[Symbol], bs: List[Symbol], cs: List[Symbol]): AnBnCnResult = {
+      val as1 = as.map(_.name)
+      val bs1 = bs.map(_.name)
+      val cs1 = cs.map(_.name)
+      new ~(new ~(as1, bs1), cs1)
+    }
+    def assertSuccess(expected1: List[Symbol], expected2: List[Symbol], expected3: List[Symbol],
+        input: String): Unit = {
+      val expected = threeLists(expected1, expected2, expected3)
+      val parseResult = head(new lexical.Scanner(input))
+      val result = extractResult(parseResult)
+      assertEquals(expected, result)
+    }
+
+    assertSuccess(List('a, 'b), List('a), List('b, 'c), "a b c")
+    assertSuccess(List('a, 'a, 'b, 'b), List('a, 'a), List('b, 'b, 'c, 'c), "a a b b c c")
+    assertSuccess(List('a, 'a, 'a, 'b, 'b, 'b), List('a, 'a, 'a), List('b, 'b, 'b, 'c, 'c, 'c),
+      "a a a b b b c c c")
+    assertSuccess(List('a, 'a, 'a, 'a, 'b, 'b, 'b, 'b), List('a, 'a, 'a, 'a), List('b, 'b, 'b, 'b, 'c, 'c, 'c, 'c),
+      "a a a a b b b b c c c c")
+
+    def assertFailure(expectedFailureMsg: String, input: String): Unit = {
+      val packratReader = new PackratReader(new lexical.Scanner(input))
+      val parseResult = AnBnCn(packratReader)
+      assertTrue(s"Not an instance of Failure: ${parseResult.toString()}", parseResult.isInstanceOf[Failure])
+      val failure = parseResult.asInstanceOf[Failure]
+      assertEquals(expectedFailureMsg, failure.msg)
+    }
+    assertFailure("``b'' expected but `c' found", "a a a a b b b c c c c")
+    assertFailure("end of input", "a a a a b b b b c c c")
+  }
+
+}
+
+private object grammars1 extends StandardTokenParsers with PackratParsers {
+
+  lexical.delimiters ++= List("+","-","*","/","(",")")
+  lexical.reserved ++= List("Hello","World")
+
+  /****
+   * term = term + fact | term - fact | fact
+   * fact = fact * num  | fact / num  | num
+   */
+
+
+ val term: PackratParser[Int] = (term~("+"~>fact) ^^ {case x~y => x+y}
+           |term~("-"~>fact) ^^ {case x~y => x-y}
+           |fact)
+
+ val fact: PackratParser[Int] = (fact~("*"~>numericLit) ^^ {case x~y => x*y.toInt}
+           |fact~("/"~>numericLit) ^^ {case x~y => x/y.toInt}
+           |"("~>term<~")"
+           |numericLit ^^ {_.toInt})
+}
+
+private object grammars2 extends StandardTokenParsers with PackratParsers {
+
+  lexical.delimiters ++= List("+","-","*","/","(",")")
+  lexical.reserved ++= List("Hello","World")
+
+  /*
+   * exp = sum | prod | num
+   * sum = exp ~ "+" ~ num
+   * prod = exp ~ "*" ~ num
+   */
+
+  val exp : PackratParser[Int] = sum | prod | numericLit ^^{_.toInt} | "("~>exp<~")"
+  val sum : PackratParser[Int] = exp~("+"~>exp) ^^ {case x~y => x+y}
+  val prod: PackratParser[Int] = exp~("*"~>(numericLit ^^{_.toInt} | exp)) ^^ {case x~y => x*y}
+
+}
+
+private object grammars3 extends StandardTokenParsers with PackratParsers {
+  lexical.reserved ++= List("a","b", "c")
+  val a: PackratParser[String] = memo("a")
+  val b: PackratParser[String] = memo("b")
+  val c: PackratParser[String] = memo("c")
+
+  type AnBnCnResult = List[String] ~ List[String] ~ List[String]
+
+  val AnBnCn: PackratParser[AnBnCnResult] =
+    guard(repMany1(a,b) <~ not(b)) ~ rep1(a) ~ repMany1(b,c)// ^^{case x~y => x:::y}
+
+
+  private def repMany[T](p: => Parser[T], q: => Parser[T]): Parser[List[T]] =
+  ( p~repMany(p,q)~q ^^ {case x~xs~y => x::xs:::(y::Nil)}
+   | success(Nil)
+  )
+
+  def repMany1[T](p: => Parser[T], q: => Parser[T]): Parser[List[T]] =
+   p~opt(repMany(p,q))~q ^^ {case x~Some(xs)~y => x::xs:::(y::Nil)}
+
+}

src/test/scala/scala/util/parsing/combinator/RegexParsersTest.scala

@@ -0,0 +1,76 @@
+package scala.util.parsing.combinator
+
+import org.junit.Test
+import org.junit.Assert.assertEquals
+
+class RegexParsersTest {
+  @Test
+  def parserNoSuccessMessage: Unit = {
+    object parser extends RegexParsers {
+      def sign = "-"
+      def number = "\\d+".r
+      type ResultType = Option[String] ~ String
+      def p: Parser[ResultType] = sign.? ~ number withErrorMessage  "Number expected!"
+      def q: Parser[ResultType] = sign.? ~! number withErrorMessage  "Number expected!"
+    }
+    import parser._
+    def extractResult(r: ParseResult[ResultType]): ResultType = r match {
+      case Success(r, _) => r
+      case r => sys.error(r.toString)
+    }
+    def result(num: Int): ResultType = {
+      val minusSign = if (num < 0) Some("-") else None
+      val absNumStr = Math.abs(num).toString
+      new ~(minusSign, absNumStr)
+    }
+
+    val failure1 = parseAll(p, "-x").asInstanceOf[Failure]
+    assertEquals("string matching regex `\\d+' expected but `x' found", failure1.msg)
+    val failure2 = parseAll(p, "x").asInstanceOf[Failure]
+    assertEquals("string matching regex `\\d+' expected but `x' found", failure2.msg)
+    assertEquals(result(-5), extractResult(parseAll(p, "-5")))
+    assertEquals(result(5), extractResult(parseAll(p, "5")))
+    val error1 = parseAll(q, "-x").asInstanceOf[Error]
+    assertEquals("Number expected!", error1.msg)
+    val error2 = parseAll(q, "x").asInstanceOf[Error]
+    assertEquals("Number expected!", error2.msg)
+    assertEquals(result(-5), extractResult(parseAll(q, "-5")))
+    assertEquals(result(5), extractResult(parseAll(q, "5")))
+  }
+
+  @Test
+  def parserFilter: Unit = {
+    object parser extends RegexParsers {
+      val keywords = Set("if", "false")
+      def word: Parser[String] = "\\w+".r
+
+      def keyword: Parser[String] = word filter (keywords.contains)
+      def ident: Parser[String] = word filter(!keywords.contains(_))
+
+      def test: Parser[String ~ String] = keyword ~ ident
+    }
+    import parser._
+
+    val failure1 = parseAll(test, "if false").asInstanceOf[Failure]
+    assertEquals("Input doesn't match filter: false", failure1.msg)
+    val failure2 = parseAll(test, "not true").asInstanceOf[Failure]
+    assertEquals("Input doesn't match filter: not", failure2.msg)
+    val success = parseAll(test, "if true").asInstanceOf[Success[String ~ String]]
+    assertEquals(new ~("if", "true"), success.get)
+  }
+
+  @Test
+  def parserForFilter: Unit = {
+    object parser extends RegexParsers {
+      def word: Parser[String] = "\\w+".r
+
+      def twoWords = for {
+        (a ~ b) <- word ~ word
+      } yield (b, a)
+    }
+    import parser._
+
+    val success = parseAll(twoWords, "first second").asInstanceOf[Success[(String, String)]]
+    assertEquals(("second", "first"), success.get)
+  }
+}