6 files changed, 225 insertions, 0 deletions
diff --git a/test/files/run/enums.check b/test/files/run/enums.check
index f53aba8794..93eadae6e3 100644
--- a/test/files/run/enums.check
+++ b/test/files/run/enums.check
@@ -3,3 +3,13 @@ test Test2 was successful
 test Test3 was successful
 test Test4 was successful
 
+D1.ValueSet(North, East)
+D2.ValueSet(North, East)
+D1.ValueSet(North, East, West)
+D2.ValueSet(North, East, West)
+List(101)
+List(101)
+D1.ValueSet(North, East)
+D2.ValueSet(North, East)
+WeekDays.ValueSet(Tue, Wed, Thu, Fri)
+
diff --git a/test/files/run/enums.scala b/test/files/run/enums.scala
index 6dda8cbc6e..9cdeed2691 100644
--- a/test/files/run/enums.scala
+++ b/test/files/run/enums.scala
@@ -65,6 +65,58 @@ object Test4 {
   }
 }
 
+object Test5 {
+
+  object D1 extends Enumeration(0) {
+    val North, South, East, West = Value;
+  }
+
+  object D2 extends Enumeration(-2) {
+    val North, South, East, West = Value;
+  }
+
+  object WeekDays extends Enumeration  {
+    val Mon, Tue, Wed, Thu, Fri, Sat, Sun = Value
+  }
+
+  def run {
+    val s1 = D1.ValueSet(D1.North, D1.East)
+    val s2 = D2.North + D2.East
+    println(s1)
+    println(s2)
+    println(s1 + D1.West)
+    println(s2 + D2.West)
+    println(s1.toBitMask.map(_.toBinaryString).toList)
+    println(s2.toBitMask.map(_.toBinaryString).toList)
+    println(D1.ValueSet.fromBitMask(s1.toBitMask))
+    println(D2.ValueSet.fromBitMask(s2.toBitMask))
+    println(WeekDays.values.range(WeekDays.Tue, WeekDays.Sat))
+  }
+}
+
+object SerializationTest {
+  object Types extends Enumeration { val X, Y = Value }
+  class A extends java.io.Serializable { val types = Types.values }
+  class B extends java.io.Serializable { val types = Set(Types.X, Types.Y) }
+
+  def serialize(obj: AnyRef) = {
+    val baos = new java.io.ByteArrayOutputStream()
+    val oos = new java.io.ObjectOutputStream(baos)
+    oos.writeObject(obj)
+    oos.close()
+    val bais = new java.io.ByteArrayInputStream(baos.toByteArray)
+    val ois = new java.io.ObjectInputStream(bais)
+    val prime = ois.readObject()
+    ois.close()
+    prime
+  }
+
+  def run {
+    serialize(new B())
+    serialize(new A())
+  }
+}
+
 //############################################################################
 // Test code
 
@@ -94,6 +146,9 @@ object Test {
     check_success("Test3", Test3.run, 1);
     check_success("Test4", Test4.run, 0);
     Console.println;
+    Test5.run;
+    Console.println;
+    SerializationTest.run;
   }
 }
 
diff --git a/test/files/run/parserNoSuccessMessage.check b/test/files/run/parserNoSuccessMessage.check
new file mode 100644
index 0000000000..fe00d2fd3a
--- /dev/null
+++ b/test/files/run/parserNoSuccessMessage.check
@@ -0,0 +1,20 @@
+[1.2] failure: string matching regex `\d+' expected but `x' found
+
+-x
+ ^
+[1.1] failure: string matching regex `\d+' expected but `x' found
+
+x
+^
+[1.3] parsed: (Some(-)~5)
+[1.2] parsed: (None~5)
+[1.2] error: Number expected!
+
+-x
+ ^
+[1.1] error: Number expected!
+
+x
+^
+[1.3] parsed: (Some(-)~5)
+[1.2] parsed: (None~5)
diff --git a/test/files/run/parserNoSuccessMessage.scala b/test/files/run/parserNoSuccessMessage.scala
new file mode 100644
index 0000000000..93aa252db0
--- /dev/null
+++ b/test/files/run/parserNoSuccessMessage.scala
@@ -0,0 +1,19 @@
+object Test extends scala.util.parsing.combinator.RegexParsers {
+  def sign = "-"
+  def number = "\\d+".r
+  def p = sign.? ~ number withErrorMessage  "Number expected!"
+  def q = sign.? ~! number withErrorMessage  "Number expected!"
+
+  def main(args: Array[String]) {
+    println(parseAll(p, "-x"))
+    println(parseAll(p, "x"))
+    println(parseAll(p, "-5"))
+    println(parseAll(p, "5"))
+    println(parseAll(q, "-x"))
+    println(parseAll(q, "x"))
+    println(parseAll(q, "-5"))
+    println(parseAll(q, "5"))
+  }
+}
+
+
diff --git a/test/files/run/t4658.check b/test/files/run/t4658.check
new file mode 100644
index 0000000000..743b0faee3
--- /dev/null
+++ b/test/files/run/t4658.check
@@ -0,0 +1,80 @@
+Ranges:
+1073741824
+1073741824
+0
+0
+55
+25
+1
+-45
+-55
+0
+-24
+-30
+0
+-40
+-55
+-10
+-24
+-30
+-10
+IntRanges:
+Disabled #1
+Disabled #2
+0
+0
+55
+25
+1
+-45
+-55
+0
+-24
+-30
+0
+-40
+-55
+-10
+-24
+-30
+-10
+LongRanges:
+Disabled #1
+Disabled #2
+0
+0
+55
+25
+1
+-45
+-55
+0
+-24
+-30
+0
+-40
+-55
+-10
+-24
+-30
+-10
+BigIntRanges:
+Disabled #1
+Disabled #2
+0
+0
+55
+25
+1
+-45
+-55
+0
+-24
+-30
+0
+-40
+-55
+-10
+-24
+-30
+-10
diff --git a/test/files/run/t4658.scala b/test/files/run/t4658.scala
new file mode 100644
index 0000000000..e1799fae9b
--- /dev/null
+++ b/test/files/run/t4658.scala
@@ -0,0 +1,41 @@
+import scala.collection.immutable.NumericRange
+//#4658
+object Test {
+
+  case class R(start: Int, end: Int, step: Int = 1, inclusive: Boolean = true)
+
+  val rangeData = Array(
+    R(1, Int.MaxValue), R(-Int.MaxValue, -1), R(0, 0), R(0,0, inclusive = false), R(1,10),
+    R(1,10,2), R(1,10,11), R(-10, -5), R(-10, 0), R(-10, 10), R(-10, -5, 2), R(-10, 0, 2), R(-10, 10, 2),
+    R(-10, -5, inclusive = false), R(-10, 0, inclusive = false), R(-10, 10, inclusive = false),
+    R(-10, -5, 2, inclusive = false), R(-10, 0, 2, inclusive = false), R(-10, 10, 2, inclusive = false)
+  )
+
+  def ranges = rangeData.map(r => if (r.inclusive) r.start to r.end by r.step else r.start until r.end by r.step)
+
+  def numericIntRanges = rangeData.map(r => if (r.inclusive) NumericRange.inclusive(r.start, r.end, r.step) else NumericRange(r.start, r.end, r.step))
+
+  def numericLongRanges = rangeData.map(r => if (r.inclusive) NumericRange.inclusive(r.start.toLong, r.end, r.step) else NumericRange(r.start.toLong, r.end, r.step))
+
+  def numericBigIntRanges = rangeData.map(r => if (r.inclusive) NumericRange.inclusive(BigInt(r.start), BigInt(r.end), BigInt(r.step)) else NumericRange(BigInt(r.start), BigInt(r.end), BigInt(r.step)))
+
+  def main(args: Array[String]) {
+    // We drop the first two tests for all ranges which don't have a decent sum implementation,
+    // because it is just too slow.
+    println("Ranges:")
+    ranges.foreach{range => println(range.sum)}
+    println("IntRanges:")
+    println("Disabled #1")
+    println("Disabled #2")
+    numericIntRanges.drop(2).foreach{range => println(range.sum)}
+    println("LongRanges:")
+    println("Disabled #1")
+    println("Disabled #2")
+    numericLongRanges.drop(2).foreach{range => println(range.sum)}
+    println("BigIntRanges:")
+    println("Disabled #1")
+    println("Disabled #2")
+    numericBigIntRanges.drop(2).foreach{range => println(range.sum)}
+  }
+
+}
+\ No newline at end of file