diff options
-rw-r--r-- | src/compiler/scala/tools/nsc/util/StackTracing.scala | 44 | ||||
-rw-r--r-- | src/library/scala/util/Properties.scala | 66 | ||||
-rw-r--r-- | test/junit/scala/util/SpecVersionTest.scala | 102 |
3 files changed, 140 insertions, 72 deletions
diff --git a/src/compiler/scala/tools/nsc/util/StackTracing.scala b/src/compiler/scala/tools/nsc/util/StackTracing.scala index 0765bb923f..c6749a13f3 100644 --- a/src/compiler/scala/tools/nsc/util/StackTracing.scala +++ b/src/compiler/scala/tools/nsc/util/StackTracing.scala @@ -8,7 +8,7 @@ private[util] trait StackTracing extends Any { /** Format a stack trace, returning the prefix consisting of frames that satisfy * a given predicate. - * The format is similar to the typical case described in the JavaDoc + * The format is similar to the typical case described in the Javadoc * for [[java.lang.Throwable#printStackTrace]]. * If a stack trace is truncated, it will be followed by a line of the form * `... 3 elided`, by analogy to the lines `... 3 more` which indicate @@ -19,25 +19,18 @@ private[util] trait StackTracing extends Any { def stackTracePrefixString(e: Throwable)(p: StackTraceElement => Boolean): String = { import collection.mutable.{ ArrayBuffer, ListBuffer } import compat.Platform.EOL - import scala.util.Properties.isJavaAtLeast - - val sb = ListBuffer.empty[String] type TraceRelation = String val Self = new TraceRelation("") val CausedBy = new TraceRelation("Caused by: ") val Suppressed = new TraceRelation("Suppressed: ") - val suppressable = isJavaAtLeast("1.7") - - def clazz(e: Throwable) = e.getClass.getName + def clazz(e: Throwable): String = e.getClass.getName def because(e: Throwable): String = e.getCause match { case null => null ; case c => header(c) } def msg(e: Throwable): String = e.getMessage match { case null => because(e) ; case s => s } def txt(e: Throwable): String = msg(e) match { case null => "" ; case s => s": $s" } def header(e: Throwable): String = s"${clazz(e)}${txt(e)}" - val indent = "\u0020\u0020" - val seen = new ArrayBuffer[Throwable](16) def unseen(t: Throwable) = { def inSeen = seen exists (_ eq t) @@ -46,28 +39,25 @@ private[util] trait StackTracing extends Any { interesting } + val sb = ListBuffer.empty[String] + + // format the stack trace, skipping the shared trace def print(e: Throwable, r: TraceRelation, share: Array[StackTraceElement], indents: Int): Unit = if (unseen(e)) { val trace = e.getStackTrace - val frames = ( - if (share.nonEmpty) { - val spare = share.reverseIterator - val trimmed = trace.reverse dropWhile (spare.hasNext && spare.next == _) - trimmed.reverse - } else trace - ) - val prefix = frames takeWhile p - val margin = indent * indents - val indented = margin + indent + val frames = if (share.isEmpty) trace else { + val spare = share.reverseIterator + val trimmed = trace.reverse dropWhile (spare.hasNext && spare.next == _) + trimmed.reverse + } + val prefix = frames takeWhile p + val margin = " " * indents + val indent = margin + " " sb append s"${margin}${r}${header(e)}" - prefix foreach (f => sb append s"${indented}at $f") - if (frames.size < trace.size) sb append s"$indented... ${trace.size - frames.size} more" - if (r == Self && prefix.size < frames.size) sb append s"$indented... ${frames.size - prefix.size} elided" + prefix foreach (f => sb append s"${margin} at $f") + if (frames.size < trace.size) sb append s"${margin} ... ${trace.size - frames.size} more" + if (r == Self && prefix.size < frames.size) sb append s"${margin} ... ${frames.size - prefix.size} elided" print(e.getCause, CausedBy, trace, indents) - if (suppressable) { - import scala.language.reflectiveCalls - type Suppressing = { def getSuppressed(): Array[Throwable] } - for (s <- e.asInstanceOf[Suppressing].getSuppressed) print(s, Suppressed, frames, indents + 1) - } + e.getSuppressed foreach (t => print(t, Suppressed, frames, indents + 1)) } print(e, Self, share = Array.empty, indents = 0) diff --git a/src/library/scala/util/Properties.scala b/src/library/scala/util/Properties.scala index fc2302d148..9d62bfe6ef 100644 --- a/src/library/scala/util/Properties.scala +++ b/src/library/scala/util/Properties.scala @@ -168,29 +168,61 @@ private[scala] trait PropertiesTrait { /** Compares the given specification version to the specification version of the platform. * - * @param version a specification version of the form "major.minor" - * @return `true` iff the specification version of the current runtime - * is equal to or higher than the version denoted by the given string. - * @throws NumberFormatException if the given string is not a version string + * @param version a specification version number (legacy forms acceptable) + * @return `true` if the specification version of the current runtime + * is equal to or higher than the version denoted by the given string. + * @throws NumberFormatException if the given string is not a version string * - * @example {{{ - * // In this example, the runtime's Java specification is assumed to be at version 1.7. - * isJavaAtLeast("1.6") // true - * isJavaAtLeast("1.7") // true - * isJavaAtLeast("1.8") // false - * }}} + * @example {{{ + * // In this example, the runtime's Java specification is assumed to be at version 8. + * isJavaAtLeast("1.8") // true + * isJavaAtLeast("8") // true + * isJavaAtLeast("9") // false + * isJavaAtLeast("9.1") // false + * isJavaAtLeast("1.9") // throws + * }}} */ def isJavaAtLeast(version: String): Boolean = { - def parts(x: String) = { - val i = x.indexOf('.') - if (i < 0) throw new NumberFormatException("Not a version: " + x) - (x.substring(0, i), x.substring(i+1, x.length)) + def versionOf(s: String, depth: Int): (Int, String) = + s.indexOf('.') match { + case 0 => + (-2, s.substring(1)) + case 1 if depth == 0 && s.charAt(0) == '1' => + val r0 = s.substring(2) + val (v, r) = versionOf(r0, 1) + val n = if (v > 8 || r0.isEmpty) -2 else v // accept 1.8, not 1.9 or 1. + (n, r) + case -1 => + val n = if (!s.isEmpty) s.toInt else if (depth == 0) -2 else 0 + (n, "") + case i => + val r = s.substring(i + 1) + val n = if (depth < 2 && r.isEmpty) -2 else s.substring(0, i).toInt + (n, r) + } + def compareVersions(s: String, v: String, depth: Int): Int = { + if (depth >= 3) 0 + else { + val (sn, srest) = versionOf(s, depth) + val (vn, vrest) = versionOf(v, depth) + if (vn < 0) -2 + else if (sn < vn) -1 + else if (sn > vn) 1 + else compareVersions(srest, vrest, depth + 1) + } + } + compareVersions(javaSpecVersion, version, 0) match { + case -2 => throw new NumberFormatException(s"Not a version: $version") + case i => i >= 0 } - val (v, _v) = parts(version) - val (s, _s) = parts(javaSpecVersion) - s.toInt >= v.toInt && _s.toInt >= _v.toInt } + /** Tests whether the major version of the platform specification is at least the given value. + * + * @param version a major version number + */ + def isJavaAtLeast(version: Int): Boolean = isJavaAtLeast(version.toString) + // provide a main method so version info can be obtained by running this def main(args: Array[String]) { val writer = new PrintWriter(Console.err, true) diff --git a/test/junit/scala/util/SpecVersionTest.scala b/test/junit/scala/util/SpecVersionTest.scala index e3e7a978f2..4639389dd9 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,80 @@ 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") + assert(sut9.isJavaAtLeast(9)) + assertFalse(sut9.isJavaAtLeast(10)) + 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")) + 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")) + 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(9)) + 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")) } } |