diff options
Diffstat (limited to 'test/junit/scala/util')
-rw-r--r-- | test/junit/scala/util/SpecVersionTest.scala | 97 | ||||
-rw-r--r-- | test/junit/scala/util/SystemPropertiesTest.scala | 27 | ||||
-rw-r--r-- | test/junit/scala/util/control/ExceptionTest.scala | 42 | ||||
-rw-r--r-- | test/junit/scala/util/matching/RegexTest.scala | 132 |
4 files changed, 270 insertions, 28 deletions
diff --git a/test/junit/scala/util/SpecVersionTest.scala b/test/junit/scala/util/SpecVersionTest.scala index e3e7a978f2..82fc4fdf7b 100644 --- a/test/junit/scala/util/SpecVersionTest.scala +++ b/test/junit/scala/util/SpecVersionTest.scala @@ -6,13 +6,16 @@ import org.junit.Test import org.junit.runner.RunWith import org.junit.runners.JUnit4 +import scala.tools.testing.AssertUtil._ + /** The java version property uses the spec version - * and must work for all "major.minor" and fail otherwise. + * and must work for legacy "major.minor" and plain version_number, + * and fail otherwise. */ @RunWith(classOf[JUnit4]) class SpecVersionTest { - val sut = new PropertiesTrait { - override def javaSpecVersion = "1.7" + class TestProperties(versionAt: String) extends PropertiesTrait { + override def javaSpecVersion = versionAt override protected def pickJarBasedOn: Class[_] = ??? override protected def propCategory: String = "test" @@ -21,37 +24,75 @@ class SpecVersionTest { override lazy val scalaProps = new java.util.Properties } + @Test + def comparesJDK9Correctly(): Unit = { + val sut9 = new TestProperties("9") + assert(sut9 isJavaAtLeast "1") + assert(sut9 isJavaAtLeast "1.5") + assert(sut9 isJavaAtLeast "5") + assert(sut9 isJavaAtLeast "1.8") + assert(sut9 isJavaAtLeast "8") + assert(sut9 isJavaAtLeast "9") + assertFalse(sut9.isJavaAtLeast("10")) + } + // SI-7265 @Test def comparesCorrectly(): Unit = { - assert(sut isJavaAtLeast "1.5") - assert(sut isJavaAtLeast "1.6") - assert(sut isJavaAtLeast "1.7") - assert(!(sut isJavaAtLeast "1.8")) - assert(!(sut isJavaAtLeast "1.71")) - } - @Test(expected = classOf[NumberFormatException]) - def badVersion(): Unit = { - sut isJavaAtLeast "1.a" + val sut7 = new TestProperties("1.7") + assert(sut7 isJavaAtLeast "1") + assert(sut7 isJavaAtLeast "1.5") + assert(sut7 isJavaAtLeast "5") + assert(sut7 isJavaAtLeast "1.6") + assert(sut7 isJavaAtLeast "1.7") + assert(sut7.isJavaAtLeast("7")) + assertFalse(sut7.isJavaAtLeast("9")) + assertFalse(sut7 isJavaAtLeast "1.8") + assertFalse(sut7 isJavaAtLeast "9") + assertFalse(sut7 isJavaAtLeast "10") } - @Test(expected = classOf[NumberFormatException]) - def missingVersion(): Unit = { - sut isJavaAtLeast "1" - } - @Test(expected = classOf[NumberFormatException]) - def noVersion(): Unit = { - sut isJavaAtLeast "" + + @Test def variousBadVersionStrings(): Unit = { + val sut = new TestProperties("9") + assertThrows[NumberFormatException](sut.isJavaAtLeast("1.9"), _ == "Not a version: 1.9") + assertThrows[NumberFormatException](sut.isJavaAtLeast("1.")) + assertThrows[NumberFormatException](sut.isJavaAtLeast("1.8.")) + assertThrows[NumberFormatException](sut.isJavaAtLeast("1.a")) + assertThrows[NumberFormatException](sut.isJavaAtLeast("")) + assertThrows[NumberFormatException](sut.isJavaAtLeast(".")) + assertThrows[NumberFormatException](sut.isJavaAtLeast("..")) + assertThrows[NumberFormatException](sut.isJavaAtLeast(".5")) + assertThrows[NumberFormatException](sut.isJavaAtLeast("9-ea")) //version number, not version string } - @Test(expected = classOf[NumberFormatException]) - def dotOnly(): Unit = { - sut isJavaAtLeast "." + + @Test def `spec has minor or more`(): Unit = { + val sut = new TestProperties("9.2.5") + assert(sut.isJavaAtLeast("9")) + assert(sut.isJavaAtLeast("9.0.1")) + assert(sut.isJavaAtLeast("9.2.1")) + assert(sut.isJavaAtLeast("8.3.1")) + assert(sut.isJavaAtLeast("8.3.1.1.1")) + assertFalse(sut.isJavaAtLeast("9.3.1")) + assertFalse(sut.isJavaAtLeast("10.3.1")) } - @Test(expected = classOf[NumberFormatException]) - def leadingDot(): Unit = { - sut isJavaAtLeast ".5" + + @Test def `compares only major minor security`(): Unit = { + val sut = new TestProperties("9.2.5.1.2.3") + assert(sut.isJavaAtLeast("9")) + assert(sut.isJavaAtLeast("9.0.1")) + assert(sut.isJavaAtLeast("9.2.5.9.9.9")) + assertFalse(sut.isJavaAtLeast("9.2.6")) } - @Test(expected = classOf[NumberFormatException]) - def notASpec(): Unit = { - sut isJavaAtLeast "1.7.1" + + @Test def `futurely proofed`(): Unit = { + val sut = new TestProperties("10.2.5") + assert(sut.isJavaAtLeast("10")) + assert(sut.isJavaAtLeast("9")) + assert(sut.isJavaAtLeast("9.0.1")) + assert(sut.isJavaAtLeast("9.2.1")) + assert(sut.isJavaAtLeast("8.3.1")) + assert(sut.isJavaAtLeast("8.3.1.1.1")) + assert(sut.isJavaAtLeast("9.3.1")) + assertFalse(sut.isJavaAtLeast("10.3.1")) } } diff --git a/test/junit/scala/util/SystemPropertiesTest.scala b/test/junit/scala/util/SystemPropertiesTest.scala new file mode 100644 index 0000000000..38e830eb88 --- /dev/null +++ b/test/junit/scala/util/SystemPropertiesTest.scala @@ -0,0 +1,27 @@ +package scala.util + +import org.junit.runner.RunWith +import org.junit.runners.JUnit4 +import org.junit.Test +import org.junit.Assert._ + +@RunWith(classOf[JUnit4]) +class SystemPropertiesTest { + @Test + def filterAll(): Unit = { + val isEmpty = sys.props.filter(_ => false).size == 0 + assertTrue("A filter matching nothing should produce an empty result", isEmpty) + } + + @Test + def filterNone(): Unit = { + val isUnchanged = sys.props.filter(_ => true) == sys.props + assertTrue("A filter matching everything should not change the result", isUnchanged) + } + + @Test + def empty(): Unit = { + val hasSize0 = sys.props.empty.size == 0 + assertTrue("SystemProperties.empty should have size of 0", hasSize0) + } +} diff --git a/test/junit/scala/util/control/ExceptionTest.scala b/test/junit/scala/util/control/ExceptionTest.scala new file mode 100644 index 0000000000..5211d31839 --- /dev/null +++ b/test/junit/scala/util/control/ExceptionTest.scala @@ -0,0 +1,42 @@ +/* __ *\ +** ________ ___ / / ___ Scala API ** +** / __/ __// _ | / / / _ | (c) 2016-2016, LAMP/EPFL ** +** __\ \/ /__/ __ |/ /__/ __ | http://scala-lang.org/ ** +** /____/\___/_/ |_/____/_/ | | ** +** |/ ** +\* */ + +package scala.util + +import org.junit.runner.RunWith +import org.junit.runners.JUnit4 +import org.junit.Test +import org.junit.Assert._ + +import scala.collection.mutable.ListBuffer + +import scala.util.control.Exception._ + +@RunWith(classOf[JUnit4]) +class ExceptionTest { + + @Test + def andFinally(): Unit = { + + locally { + val audit = ListBuffer[Int]() + val katch = nonFatalCatch[Unit].andFinally(audit append 1) + val result = katch(10) + assertEquals(result, 10) + assertEquals(audit.toList, 1 :: Nil) + } + + locally { + val audit = ListBuffer[Int]() + val katch = nonFatalCatch[Unit].andFinally(audit append 1).andFinally(audit append 2) + val result = katch(20) + assertEquals(result, 20) + assertEquals(audit.toList, 1 :: 2 :: Nil) + } + } +}
\ No newline at end of file diff --git a/test/junit/scala/util/matching/RegexTest.scala b/test/junit/scala/util/matching/RegexTest.scala index 5b13397d6a..d80e05e512 100644 --- a/test/junit/scala/util/matching/RegexTest.scala +++ b/test/junit/scala/util/matching/RegexTest.scala @@ -6,6 +6,8 @@ import org.junit.Test import org.junit.runner.RunWith import org.junit.runners.JUnit4 +import scala.tools.testing.AssertUtil._ + @RunWith(classOf[JUnit4]) class RegexTest { @Test def t8022CharSequence(): Unit = { @@ -44,4 +46,134 @@ class RegexTest { } assertEquals(List((1,2),(3,4),(5,6)), z) } + + @Test def `SI-9666: use inline group names`(): Unit = { + val r = new Regex("a(?<Bee>b*)c") + val ms = r findAllIn "stuff abbbc more abc and so on" + assertTrue(ms.hasNext) + assertEquals("abbbc", ms.next()) + assertEquals("bbb", ms group "Bee") + assertTrue(ms.hasNext) + assertEquals("abc", ms.next()) + assertEquals("b", ms group "Bee") + assertFalse(ms.hasNext) + } + + @Test def `SI-9666: use explicit group names`(): Unit = { + val r = new Regex("a(b*)c", "Bee") + val ms = r findAllIn "stuff abbbc more abc and so on" + assertTrue(ms.hasNext) + assertEquals("abbbc", ms.next()) + assertEquals("bbb", ms group "Bee") + assertTrue(ms.hasNext) + assertEquals("abc", ms.next()) + assertEquals("b", ms group "Bee") + assertFalse(ms.hasNext) + } + + @Test def `SI-9666: fall back to explicit group names`(): Unit = { + val r = new Regex("a(?<Bar>b*)c", "Bee") + val ms = r findAllIn "stuff abbbc more abc and so on" + assertTrue(ms.hasNext) + assertEquals("abbbc", ms.next()) + assertEquals("bbb", ms group "Bee") + assertEquals("bbb", ms group "Bar") + assertTrue(ms.hasNext) + assertEquals("abc", ms.next()) + assertEquals("b", ms group "Bee") + assertEquals("b", ms group "Bar") + assertFalse(ms.hasNext) + } + + type NoGroup = IllegalArgumentException + type NoMatch = NoSuchElementException + type NoData = IllegalStateException + + @Test def `SI-9666: throw on bad name`(): Unit = { + assertThrows[NoGroup] { + val r = new Regex("a(?<Bar>b*)c") + val ms = r findAllIn "stuff abbbc more abc and so on" + assertTrue(ms.hasNext) + ms group "Bee" + } + assertThrows[NoGroup] { + val r = new Regex("a(?<Bar>b*)c", "Bar") + val ms = r findAllIn "stuff abbbc more abc and so on" + assertTrue(ms.hasNext) + ms group "Bee" + } + assertThrows[NoGroup] { + val r = new Regex("a(b*)c", "Bar") + val ms = r findAllIn "stuff abbbc more abc and so on" + assertTrue(ms.hasNext) + ms group "Bee" + } + } + + @Test def `SI-9827 MatchIterator ergonomics`(): Unit = { + val r = "(ab)(cd)".r + val s = "xxxabcdyyyabcdzzz" + assertEquals(3, r.findAllIn(s).start) + assertEquals(5, r.findAllIn(s).start(2)) + locally { + val mi = r.findAllIn(s) + assertTrue(mi.hasNext) + assertEquals(3, mi.start) + assertEquals("abcd", mi.next()) + assertEquals(3, mi.start) + assertTrue(mi.hasNext) + assertEquals(10, mi.start) + } + locally { + val mi = r.findAllIn(s) + assertEquals("abcd", mi.next()) + assertEquals(3, mi.start) + assertEquals("abcd", mi.next()) + assertEquals(10, mi.start) + assertThrows[NoMatch] { mi.next() } + assertThrows[NoData] { mi.start } + } + locally { + val mi = r.findAllIn("") + assertThrows[NoData] { mi.start } + assertThrows[NoMatch] { mi.next() } + } + locally { + val mi = r.findAllMatchIn(s) + val x = mi.next() + assertEquals("abcd", x.matched) + assertEquals(3, x.start) + val y = mi.next() + assertEquals("abcd", y.matched) + assertEquals(10, y.start) + assertThrows[NoMatch] { mi.next() } + assertEquals(3, x.start) + assertEquals(10, y.start) + } + locally { + val regex = "(foo)-(.*)".r + val s = "foo-abc-def" + val result = regex.findAllIn(s) + //result.toString // comment this line to make it not work + val r = (result.group(1), result.group(2)) + assertEquals(("foo", "abc-def"), r) + } + locally { + val t = "this is a test" + val rx = " ".r + val m = rx.findAllIn(t) + assertEquals(5, rx.findAllIn(t).end) + } + locally { + val data = "<a>aaaaa</a><b>bbbbbb</b><c>ccccccc</c>" + val p = "^<a>(.+)</a><b>(.+)</b><c>(.+)</c>$".r + val parts = p.findAllIn(data) + val aes = parts.group(1) + val bes = parts.group(2) + val ces = parts.group(3) + assertEquals("ccccccc", ces) + assertEquals("bbbbbb", bes) + assertEquals("aaaaa", aes) + } + } } |