1 files changed, 397 insertions, 0 deletions
diff --git a/examples/scala-js/test-suite/src/test/scala/scala/scalajs/testsuite/javalib/RegexTest.scala b/examples/scala-js/test-suite/src/test/scala/scala/scalajs/testsuite/javalib/RegexTest.scala
new file mode 100644
index 0000000..a27584a
--- /dev/null
+++ b/examples/scala-js/test-suite/src/test/scala/scala/scalajs/testsuite/javalib/RegexTest.scala
@@ -0,0 +1,397 @@
+/*                     __                                               *\
+**     ________ ___   / /  ___      __ ____  Scala.js Test Suite        **
+**    / __/ __// _ | / /  / _ | __ / // __/  (c) 2013, LAMP/EPFL        **
+**  __\ \/ /__/ __ |/ /__/ __ |/_// /_\ \    http://scala-js.org/       **
+** /____/\___/_/ |_/____/_/ | |__/ /____/                               **
+**                          |/____/                                     **
+\*                                                                      */
+package scala.scalajs.testsuite.javalib
+
+import scala.scalajs.js
+import scala.scalajs.js.JSConverters._
+
+import org.scalajs.jasminetest.JasmineTest
+
+import java.util.regex.Pattern
+
+object RegexTest extends JasmineTest {
+
+  describe("java.util.regex.Pattern") {
+
+    it("should respond to `matches`") {
+      expect(Pattern.matches("[Scal]*\\.js", "Scala.js")).toBeTruthy
+      expect(Pattern.matches(".[cal]*\\.j.", "Scala.js")).toBeTruthy
+      expect(Pattern.matches(".*\\.js", "Scala.js")).toBeTruthy
+      expect(Pattern.matches("S[a-z]*", "Scala.js")).toBeFalsy
+    }
+
+    it("should respond to `matches` with flags") {
+      matches("scala.js", "Scala.js")
+      matches("SCALA.JS", "Scala.js")
+      matches("waz*up", "WAZZZZZZZZZZZUP")
+
+      def matches(regex: String, input: String): Unit = {
+        val result = Pattern.compile(regex, Pattern.CASE_INSENSITIVE).matcher(input)
+        expect(result.matches()).toBeTruthy
+      }
+    }
+
+    it("should respond to `split`") {
+      val result = Pattern.compile("[aj]").split("Scala.js")
+      val expected = js.Array("Sc", "l", ".", "s")
+      expect(result.length).toEqual(4)
+      expect(result.toJSArray).toEqual(expected)
+
+      // Tests from JavaDoc
+      split("boo:and:foo", ":", Array("boo", "and", "foo"))
+      split("boo:and:foo", "o", Array("b", "", ":and:f"))
+
+      // Splitting the empty string must return 1 element - #987
+      split("", "a", Array(""))
+      split("", "\\*", Array(""))
+      split("", "\n", Array(""))
+      split("", "", Array(""))
+
+      // Should remove leading empty match under some conditions - #1171
+      // These tests are "measured" on the JVM since the spec is unclear
+      split("abc", "(?=a)", Array("abc"))
+      split("abc", "(?=b)", Array("a", "bc"))
+      split("abc", "(?=a)|b", Array("", "a", "c"))
+      split("abc", "", Array("", "a", "b", "c"))
+      split("abc", "(?=a)|(?=b)", Array("", "a", "bc"))
+      split("abc", "(?=a)|(?=a)", Array("abc"))
+      split("abc", "(?=a|b)", Array("", "a", "bc"))
+      split("abc", "(?=a|d)", Array("abc"))
+      split("abc", "^d*", Array("abc"))
+      split("abc", "d*", Array("", "a", "b", "c"))
+      split("a", "", Array("", "a"))
+      split("a", "^d*", Array("a"))
+      split("a", "d*", Array("", "a"))
+      split("a", "(?=a)", Array("a"))
+      split("ab", "a", Array("", "b"))
+
+      def split(input: String, regex: String, expected: Array[String]): Unit = {
+        val result = Pattern.compile(regex).split(input)
+        expect(result.toJSArray).toEqual(expected.toJSArray)
+      }
+    }
+
+    it("should respond to `split` with limit") {
+      // Tests from JavaDoc
+      splitWithLimit("boo:and:foo", ":", 2, Array("boo", "and:foo"))
+      splitWithLimit("boo:and:foo", ":", 5, Array("boo", "and", "foo"))
+      splitWithLimit("boo:and:foo", ":", -2, Array("boo", "and", "foo"))
+      splitWithLimit("boo:and:foo", "o", 5, Array("b", "", ":and:f", "", ""))
+      splitWithLimit("boo:and:foo", "o", -2, Array("b", "", ":and:f", "", ""))
+      splitWithLimit("boo:and:foo", "o", 0, Array("b", "", ":and:f"))
+
+      // Splitting the empty string must return 1 element - #987
+      splitWithLimit("", "a", 0, Array(""))
+      splitWithLimit("", "\\*", 5, Array(""))
+      splitWithLimit("", "\n", -2, Array(""))
+      splitWithLimit("", "", 1, Array(""))
+
+      // Should remove leading empty match under some conditions - #1171
+      splitWithLimit("abc", "", 2, Array("", "abc"))
+      splitWithLimit("abc", "(?=a)", 2, Array("abc"))
+      splitWithLimit("ab", "a", 1, Array("ab"))
+
+      def splitWithLimit(input: String, regex: String, limit: Int, expected: Array[String]): Unit = {
+        val result = Pattern.compile(regex).split(input, limit)
+        expect(result.toJSArray).toEqual(expected.toJSArray)
+      }
+    }
+
+    it("should respond to `flags`") {
+      val pattern0 = Pattern.compile("a")
+      val pattern1 = Pattern.compile("a", 0)
+      val flags2 = Pattern.CASE_INSENSITIVE | Pattern.DOTALL
+      val pattern2 = Pattern.compile("a", flags2)
+
+      expect(pattern0.flags).toEqual(0)
+      expect(pattern1.flags).toEqual(0)
+      expect(pattern2.flags).toEqual(flags2)
+    }
+
+    it("should respond to `pattern` and `toString`") {
+      def checkPatternAndToString(regex: String): Unit = {
+        val pattern0 = Pattern.compile(regex)
+        expect(pattern0.pattern).toEqual(regex)
+        expect(pattern0.toString).toEqual(regex)
+
+        val pattern1 = Pattern.compile(regex, Pattern.CASE_INSENSITIVE)
+        expect(pattern1.pattern).toEqual(regex)
+        expect(pattern1.toString).toEqual(regex)
+      }
+
+      checkPatternAndToString("a*b+c")
+      checkPatternAndToString("\\S[(a1]a.js")
+    }
+
+    it("should respond to `quote`") {
+      val splitWithQuote = Pattern.compile(Pattern.quote("$1&$2")).split("Scala$1&$2.js")
+      val splitNoQuote = Pattern.compile("$1&$2").split("Scala$1&$2.js")
+      expect(splitWithQuote.mkString).toEqual("Scala.js")
+      expect(splitNoQuote.mkString).toEqual("Scala$1&$2.js")
+    }
+
+  }
+
+  describe("java.util.regex.Matcher") {
+
+    it("should respond to `find`") {
+      val matcher = Pattern.compile("a").matcher("Scala.js")
+
+      expect(matcher.find()).toBeTruthy
+      expect(matcher.find()).toBeTruthy
+      expect(matcher.find()).toBeFalsy
+      expect(matcher.find(4)).toBeTruthy
+      expect(matcher.find()).toBeFalsy
+    }
+
+    it("should respond to `start`, `end`, `group`, and `toMatchResult`") {
+      val matcher = Pattern.compile("\\s(([A-Za-z]{5}(hum)?).js)\\s").matcher("Write Scala.js everyday!")
+
+      def checkGroup0(start: Int, end: Int, group: String) =
+        checkGroup(start, 5, end, 15, group, " Scala.js ")
+
+      def checkGroup1(start: Int, end: Int, group: String) =
+        checkGroup(start, 6, end, 14, group, "Scala.js")
+
+      def checkGroup2(start: Int, end: Int, group: String) =
+        checkGroup(start, 6, end, 11, group, "Scala")
+
+      def checkGroup3(start: Int, end: Int, group: String) =
+        checkGroup(start, -1, end, -1, group, null)
+
+      def checkGroup(start: Int, startExpected: Int, end: Int, endExpected: Int,
+                     group: String, groupExpected: String): Unit = {
+        expect(start).toEqual(startExpected)
+        expect(end).toEqual(endExpected)
+        expect(group).toEqual(groupExpected)
+      }
+
+      expect(matcher.find()).toBeTruthy
+      expect(matcher.groupCount).toEqual(3)
+      checkGroup0(matcher.start, matcher.end, matcher.group)
+      checkGroup0(matcher.start(0), matcher.end(0), matcher.group(0))
+      checkGroup1(matcher.start(1), matcher.end(1), matcher.group(1))
+      checkGroup2(matcher.start(2), matcher.end(2), matcher.group(2))
+      checkGroup3(matcher.start(3), matcher.end(3), matcher.group(3))
+
+      val matchResult = matcher.toMatchResult
+      expect(matchResult.groupCount).toEqual(3)
+      checkGroup0(matchResult.start, matchResult.end, matchResult.group)
+      checkGroup0(matchResult.start(0), matchResult.end(0), matchResult.group(0))
+      checkGroup1(matchResult.start(1), matchResult.end(1), matchResult.group(1))
+      checkGroup2(matchResult.start(2), matchResult.end(2), matchResult.group(2))
+      checkGroup3(matchResult.start(3), matchResult.end(3), matchResult.group(3))
+    }
+
+    it("should respond to `matches`") {
+      val matcher0 = Pattern.compile("S[a-z]+").matcher("Scala")
+      val matcher1 = Pattern.compile("S[a-z]+").matcher("Scala.js")
+
+      expect(matcher0.matches()).toBeTruthy
+      expect(matcher1.matches()).toBeFalsy
+    }
+
+    it("should respond to `reset`") {
+      val matcher = Pattern.compile("S[a-z]+").matcher("Scalable")
+
+      expect(matcher.find()).toBeTruthy
+      expect(matcher.find()).toBeFalsy
+      matcher.reset()
+      expect(matcher.find()).toBeTruthy
+    }
+
+    it("should respond to `reset(String)`") {
+      val matcher = Pattern.compile("S[a-z]+").matcher("Scalable")
+
+      expect(matcher.matches()).toBeTruthy
+      matcher.reset("Scala.js")
+      expect(matcher.matches()).toBeFalsy
+    }
+
+    it("should respond to `usePattern`") {
+      val patternNoDots = Pattern.compile("S[a-z]+")
+      val patternWithDots = Pattern.compile("S[a-z.]+")
+
+      val matcher0 = patternNoDots.matcher("Scala.js")
+      expect(matcher0.matches()).toBeFalsy
+      matcher0.usePattern(patternWithDots)
+      expect(matcher0.matches()).toBeTruthy
+
+      val matcher1 = patternWithDots.matcher("Scala.js")
+      expect(matcher1.matches()).toBeTruthy
+      matcher1.usePattern(patternNoDots)
+      expect(matcher1.matches()).toBeFalsy
+    }
+
+    it("should respond to `lookingAt`") {
+      val matcher0 = Pattern.compile("S[a-z]+").matcher("Scala")
+      val matcher1 = Pattern.compile("S[a-z]+").matcher("Scala.js")
+      val matcher2 = Pattern.compile("[a-z]+").matcher("Scala.js")
+
+      expect(matcher0.lookingAt()).toBeTruthy
+      expect(matcher1.lookingAt()).toBeTruthy
+      expect(matcher2.lookingAt()).toBeFalsy
+
+      val matcher3 = Pattern.compile("S[a-z]+").matcher("Scala.js")
+      expect(matcher3.find()).toBeTruthy
+      expect(matcher3.lookingAt()).toBeTruthy
+    }
+
+    it("should respond to `hitEnd`") {
+      val matcher0 = Pattern.compile("S[a-z]*").matcher("Scala.js")
+      expect(matcher0.find()).toBeTruthy
+      expect(matcher0.hitEnd).toBeFalsy
+      expect(matcher0.find()).toBeFalsy
+      expect(matcher0.hitEnd).toBeTruthy
+
+      val matcher1 = Pattern.compile("[A-Za-z]+").matcher("Scala.js")
+      expect(matcher1.find()).toBeTruthy
+      expect(matcher1.hitEnd).toBeFalsy
+      expect(matcher1.group).toBe("Scala")
+      expect(matcher1.find()).toBeTruthy
+      expect(matcher1.hitEnd).toBeTruthy
+      expect(matcher1.group).toBe("js")
+      expect(matcher1.lookingAt()).toBeTruthy
+      expect(matcher1.group).toBe("Scala")
+      expect(matcher1.hitEnd).toBeFalsy
+    }
+
+    it("should respond to `region`") {
+      val matcher0 = Pattern.compile("S[a-z]+").matcher("A Scalable Solution")
+
+      val region0to3 = matcher0.region(0, 3)
+      expect(region0to3.regionStart).toBe(0)
+      expect(region0to3.regionEnd).toBe(3)
+      expect(region0to3.find()).toBeFalsy
+
+      val region0to15 = matcher0.region(0, 15)
+      expect(region0to15.regionStart).toBe(0)
+      expect(region0to15.regionEnd).toBe(15)
+      expect(region0to15.find()).toBeTruthy
+      expect(region0to15.group).toEqual("Scalable")
+
+      val region2to7 = region0to15.region(2, 7)
+      expect(region2to7.regionStart).toBe(2)
+      expect(region2to7.regionEnd).toBe(7)
+      expect(region2to7.find()).toBeTruthy
+      expect(region2to7.group).toEqual("Scala")
+
+      val region5toEnd = matcher0.region(5, matcher0.regionEnd)
+      expect(region5toEnd.regionStart).toBe(5)
+      expect(region5toEnd.regionEnd).toBe(19)
+      expect(region5toEnd.find()).toBeTruthy
+      expect(region5toEnd.group).toEqual("Solution")
+
+      val matcher1 = Pattern.compile("0[xX][A-Fa-f0-9]{3}$").matcher("In CSS, 0xc4fe is not a color")
+
+      val region5to13 = matcher1.region(5, 13)
+      expect(region5to13.regionStart).toBe(5)
+      expect(region5to13.regionEnd).toBe(13)
+      expect(region5to13.find()).toBeTruthy
+      expect(region5to13.group).toEqual("0xc4f")
+
+      val region5to20 = matcher1.region(5, 20)
+      expect(region5to20.regionStart).toBe(5)
+      expect(region5to20.regionEnd).toBe(20)
+      expect(region5to20.find()).toBeFalsy
+    }
+
+    it("should respond to `appendReplacement` and `appendTail`") {
+      // From the JavaDoc
+      val matcher = Pattern.compile("cat").matcher("one cat two cats in the yard")
+      val sb = new StringBuffer
+
+      while (matcher.find()) {
+        matcher.appendReplacement(sb, "dog")
+      }
+      matcher.appendTail(sb)
+
+      expect(sb.toString).toBe("one dog two dogs in the yard")
+    }
+
+    it("should respond to `replaceAll`") {
+      // From the JavaDoc
+      val matcher = Pattern.compile("a*b").matcher("aabfooaabfooabfoob")
+      expect(matcher.replaceAll("-")).toBe("-foo-foo-foo-")
+    }
+
+    it("should respond to `replaceFirst`") {
+      // From the JavaDoc
+      val matcher = Pattern.compile("dog").matcher("zzzdogzzzdogzzz")
+      expect(matcher.replaceFirst("cat")).toBe("zzzcatzzzdogzzz")
+    }
+
+    it("should throw exception if match accessors are called before `find`") {
+      def checkInvalidAccess(block: => Unit): Unit = {
+        val exception: Throwable = try {
+          block
+          throw new Error("No exception thrown")
+        } catch {
+          case e: Throwable => e
+        }
+
+        expect(exception.getClass.getName).toBe("java.lang.IllegalStateException")
+        expect(exception.getMessage).toBe("No match available")
+      }
+
+      val matcher = Pattern.compile("(Sc([a-z]*))").matcher("Scala.js")
+
+      checkInvalidAccess { matcher.start }
+      checkInvalidAccess { matcher.end }
+      checkInvalidAccess { matcher.group }
+      checkInvalidAccess { matcher.group(42) }
+
+      val matchResult = matcher.toMatchResult
+
+      checkInvalidAccess { matchResult.start }
+      checkInvalidAccess { matchResult.end }
+      checkInvalidAccess { matchResult.group }
+      checkInvalidAccess { matchResult.group(42) }
+    }
+
+    it("should correctly handle zero-length matches") {
+      val pat = Pattern.compile("a*?")
+      val mat = pat.matcher("aaaaa")
+      for (i <- 0 to 5) {
+        expect(mat.find()).toBeTruthy
+        expect(mat.start).toEqual(i)
+        expect(mat.end).toEqual(i)
+      }
+
+      // Make sure we don't suddenly re-match
+      for (i <- 0 to 5) {
+        expect(mat.find()).toBeFalsy
+      }
+    }
+
+    it("should support in-pattern flags - #997") {
+      val p0 = Pattern.compile("(?i)abc")
+
+      expect(p0.flags() & Pattern.CASE_INSENSITIVE).not.toBe(0)
+
+      val m0 = p0.matcher("abcABC")
+
+      expect(m0.find()).toBeTruthy
+      expect(m0.group()).toEqual("abc")
+      expect(m0.find()).toBeTruthy
+      expect(m0.group()).toEqual("ABC")
+      expect(m0.find()).toBeFalsy
+
+      val p1 = Pattern.compile("(?-i)abc", Pattern.CASE_INSENSITIVE)
+
+      expect(p1.flags() & Pattern.CASE_INSENSITIVE).toBe(0)
+
+      val m1 = p1.matcher("abcABC")
+
+      expect(m1.find()).toBeTruthy
+      expect(m1.group()).toEqual("abc")
+      expect(m1.find()).toBeFalsy
+    }
+
+  }
+}