fixed headers/comments/svn props, made some pro...

fixed headers/comments/svn props, made some progress with serializable
classes

3 files changed, 250 insertions, 131 deletions

diff --git a/test/files/run/sequenceComparisons.scala b/test/files/run/sequenceComparisons.scala
index 340a4fa55f..cc1cf3610c 100644
--- a/test/files/run/sequenceComparisons.scala
+++ b/test/files/run/sequenceComparisons.scala
@@ -113,9 +113,9 @@ object Test {
     }
   }
 
-  def main(args: Array[String]): Unit = {
+  def main(args: Array[String]) {
     runSeqs()
 
     assert(failures.isEmpty, failures mkString "\n")
   }
-}
\ No newline at end of file
+}
diff --git a/test/pending/jvm/serialization.check b/test/pending/jvm/serialization.check
index 144e31603f..397578bcba 100644
--- a/test/pending/jvm/serialization.check
+++ b/test/pending/jvm/serialization.check
@@ -1,10 +1,15 @@
+x0 = List(1, 2, 3)
+y0 = List(1, 2, 3)
+x0 eq y0: false, y0 eq x0: false
+x0 equals y0: true, y0 equals x0: true
+
 x1 = List()
 y1 = List()
-x1 eq y1: true - y1 eq x1: true
+x1 eq y1: true, y1 eq x1: true
 
 x2 = None
 y2 = None
-x2 eq y2: true - y2 eq x2: true
+x2 eq y2: true, y2 eq x2: true
 
 x3 = Array[1,2,3]
 y3 = Array[1,2,3]
@@ -14,73 +19,120 @@ x4 = <na>
 y4 = <na>
 x4(2): 4 - y4(2): 4
 
+x5 = 'hello
+y5 = 'hello
+x5 eq y5: true, y5 eq x5: true
+x5 equals y5: true, y5 equals x5: true
+
+x6 = (BannerLimit,12345)
+y6 = (BannerLimit,12345)
+x6 eq y6: false, y6 eq x6: false
+x6 equals y6: true, y6 equals x6: true
+
+x7 = RoundingMode
+y7 = RoundingMode
+x7 eq y7: true, y7 eq x7: true
+x7 equals y7: true, y7 equals x7: true
+
+x8 = WeekDay
+y8 = WeekDay
+x8 eq y8: true, y8 eq x8: true
+x8 equals y8: true, y8 equals x8: true
+
+x9 = UP
+y9 = UP
+x9 eq y9: true, y9 eq x9: true
+x9 equals y9: true, y9 equals x9: true
+
+x10 = WeekDay(0)
+y10 = WeekDay(0)
+x10 eq y10: true, y10 eq x10: true
+x10 equals y10: true, y10 equals x10: true
+
+x9 eq x10: false, x10 eq x9: false
+x9 equals x10: false, x10 equals x9: false
+x9 eq y10: false, y10 eq x9: false
+x9 equals y10: false, y10 equals x9: false
+
 x = List((buffers,20), (layers,2), (title,3))
 y = List((buffers,20), (layers,2), (title,3))
-x equals y: true - y equals x: true
+x equals y: true, y equals x: true
+
+x = Map(2 -> C, 1 -> B, 0 -> A)
+y = Map(2 -> C, 1 -> B, 0 -> A)
+x equals y: true, y equals x: true
 
 x = Map(buffers -> 20, layers -> 2, title -> 3)
 y = Map(buffers -> 20, layers -> 2, title -> 3)
-x equals y: true - y equals x: true
+x equals y: true, y equals x: true
 
 x = Set(2, 3)
 y = Set(2, 3)
-x equals y: true - y equals x: true
+x equals y: true, y equals x: true
 
 x = Set(5, 3)
 y = Set(5, 3)
-x equals y: true - y equals x: true
+x equals y: true, y equals x: true
 
-x = Queue(a,b,c)
-y = Queue(a,b,c)
-x equals y: true - y equals x: true
+x = Queue(a, b, c)
+y = Queue(a, b, c)
+x equals y: true, y equals x: true
 
-x = Stack(c, b, a)
-y = Stack(c, b, a)
-x equals y: true - y equals x: true
+x = Stack(a, b, c)
+y = Stack(a, b, c)
+x equals y: true, y equals x: true
 
 x = Map(42 -> FortyTwo)
 y = Map(42 -> FortyTwo)
-x equals y: true - y equals x: true
+x equals y: true, y equals x: true
 
-x = Set(0, 2)
-y = Set(0, 2)
-x equals y: true - y equals x: true
+x = TreeSet(0, 2)
+y = TreeSet(0, 2)
+x equals y: true, y equals x: true
+
+x = Vector(1, 2, 3)
+y = Vector(1, 2, 3)
+x equals y: true, y equals x: true
 
 x = ArrayBuffer(one, two)
 y = ArrayBuffer(one, two)
-x equals y: true - y equals x: true
+x equals y: true, y equals x: true
 
 x = Map(title -> 3, buffers -> 20, layers -> 2)
 y = Map(title -> 3, buffers -> 20, layers -> 2)
-x equals y: true - y equals x: true
+x equals y: true, y equals x: true
 
 x = Set(0, 8, 9)
 y = Set(0, 8, 9)
-x equals y: true - y equals x: true
+x equals y: true, y equals x: true
 
 x = Set(layers, buffers, title)
 y = Set(layers, buffers, title)
-x equals y: true - y equals x: true
+x equals y: true, y equals x: true
 
 x = LinkedList(2, 3)
 y = LinkedList(2, 3)
-x equals y: true - y equals x: true
+x equals y: true, y equals x: true
 
 x = Queue(20, 2, 3)
 y = Queue(20, 2, 3)
-x equals y: true - y equals x: true
+x equals y: true, y equals x: true
 
-x = Stack(20, 2, 3)
-y = Stack(20, 2, 3)
-x equals y: true - y equals x: true
+x = Stack(3, 2, 20)
+y = Stack(3, 2, 20)
+x equals y: true, y equals x: true
 
 x = ListBuffer(white, black)
 y = ListBuffer(white, black)
-x equals y: true - y equals x: true
+x equals y: true, y equals x: true
+
+x = History((Feed,hello))
+y = History((Feed,hello))
+x equals y: true, y equals x: true
 
 x = <html><title>title</title><body></body></html>
 y = <html><title>title</title><body></body></html>
-x equals y: true - y equals x: true
+x equals y: true, y equals x: true
 
 x = <html>
       <body>
@@ -122,25 +174,25 @@ y = <html>
       </table>
       </body>
     </html>
-x equals y: true - y equals x: true
+x equals y: true, y equals x: true
 
 x = Tim
 y = Tim
-x equals y: true - y equals x: true
+x equals y: true, y equals x: true
 
 x = Bob
 y = Bob
-x equals y: true - y equals x: true
+x equals y: true, y equals x: true
 
 x = John
 y = John
-x equals y: true - y equals x: true
+x equals y: true, y equals x: true
 
 x = Bill
 y = Bill
-x equals y: true - y equals x: true
+x equals y: true, y equals x: true
 
 x = Paul
 y = Paul
-x equals y: true - y equals x: true
+x equals y: true, y equals x: true
 
diff --git a/test/pending/jvm/serialization.scala b/test/pending/jvm/serialization.scala
index 2c46ee0b7b..d2c2cc5e7d 100644
--- a/test/pending/jvm/serialization.scala
+++ b/test/pending/jvm/serialization.scala
@@ -5,15 +5,6 @@
 
 import java.lang.System
 
-object EqualityTest {
-  def check[A, B](x: A, y: B) {
-    println("x = " + x)
-    println("y = " + y)
-    println("x equals y: " + (x equals y) + " - y equals x: " + (y equals x))
-    println()
-  }
-}
-
 object Serialize {
   @throws(classOf[java.io.IOException])
   def write[A](o: A): Array[Byte] = {
@@ -30,48 +21,115 @@ object Serialize {
       new java.io.ObjectInputStream(new java.io.ByteArrayInputStream(buffer))
     in.readObject().asInstanceOf[A]
   }
+  def check[A, B](x: A, y: B) {
+    println("x = " + x)
+    println("y = " + y)
+    println("x equals y: " + (x equals y) + ", y equals x: " + (y equals x))
+    println()
+  }
 }
+import Serialize._
 
 //############################################################################
 // Test classes in package "scala"
 
-@serializable
 object Test1_scala {
 
   private def arrayToString[A](arr: Array[A]): String =
     arr.mkString("Array[",",","]")
 
-  private def arrayEquals[A, B](a1: Array[A], a2: Array[B]) =
-     (a1.length == a2.length) &&
-     (Iterator.range(0, a1.length) forall { i => a1(i) == a2(i) })
+  private def arrayEquals[A, B](a1: Array[A], a2: Array[B]): Boolean =
+    (a1.length == a2.length) &&
+    (Iterator.range(0, a1.length) forall { i => a1(i) == a2(i) })
+
+  @serializable
+  object WeekDay extends Enumeration {
+    type WeekDay = Value
+    val Monday, Tuesday, Wednesday, Thusday, Friday, Saturday, Sunday = Value
+  }
+  import WeekDay._, BigDecimal._, RoundingMode._
 
+  val x0 = List(1, 2, 3)
   val x1 = Nil
   val x2 = None
   val x3 = Array(1, 2, 3)
   val x4 = { x: Int => 2 * x }
+  val x5 = 'hello
+  val x6 = ("BannerLimit", 12345)
+  val x7 = BigDecimal.RoundingMode
+  val x8 = WeekDay
+  val x9 = UP      // named element
+  val x10 = Monday // unamed element
 
   try {
-    val y1: List[Nothing]      = Serialize.read(Serialize.write(x1))
-    val y2: Option[Nothing]    = Serialize.read(Serialize.write(x2))
-    val y3: Array[Int]         = Serialize.read(Serialize.write(x3))
-    val y4: Function[Int, Int] = Serialize.read(Serialize.write(x4))
-
+    val y0: List[Int]          = read(write(x0))
+    val y1: List[Nothing]      = read(write(x1))
+    val y2: Option[Nothing]    = read(write(x2))
+    val y3: Array[Int]         = read(write(x3))
+    val y4: Function[Int, Int] = read(write(x4))
+    val y5: Symbol             = read(write(x5))
+    val y6: (String, Int)      = read(write(x6))
+    val y7: RoundingMode.type  = read(write(x7))
+    val y8: WeekDay.type       = read(write(x8))
+    val y9: RoundingMode       = read(write(x9))
+    val y10: WeekDay           = read(write(x10))
+
+    println("x0 = " + x0)
+    println("y0 = " + y0)
+    println("x0 eq y0: " + (x0 eq y0) + ", y0 eq x0: " + (y0 eq x0))
+    println("x0 equals y0: " + (x0 equals y0) + ", y0 equals x0: " + (y0 equals x0))
+    println()
     println("x1 = " + x1)
     println("y1 = " + y1)
-    println("x1 eq y1: " + (x1 eq y1) + " - y1 eq x1: " + (y1 eq x1))
-    println
+    println("x1 eq y1: " + (x1 eq y1) + ", y1 eq x1: " + (y1 eq x1))
+    println()
     println("x2 = " + x2)
     println("y2 = " + y2)
-    println("x2 eq y2: " + (x2 eq y2) + " - y2 eq x2: " + (y2 eq x2))
-    println
+    println("x2 eq y2: " + (x2 eq y2) + ", y2 eq x2: " + (y2 eq x2))
+    println()
     println("x3 = " + arrayToString(x3))
     println("y3 = " + arrayToString(y3))
     println("arrayEquals(x3, y3): " + arrayEquals(x3, y3))
-    println
+    println()
     println("x4 = <na>")
     println("y4 = <na>")
     println("x4(2): " + x4(2) + " - y4(2): " + y4(2))
-    println
+    println()
+    println("x5 = " + x5)
+    println("y5 = " + y5)
+    println("x5 eq y5: " + (x5 eq y5) + ", y5 eq x5: " + (y5 eq x5))
+    println("x5 equals y5: " + (x5 equals y5) + ", y5 equals x5: " + (y5 equals x5))
+    println()
+    println("x6 = " + x6)
+    println("y6 = " + y6)
+    println("x6 eq y6: " + (x6 eq y6) + ", y6 eq x6: " + (y6 eq x6))
+    println("x6 equals y6: " + (x6 equals y6) + ", y6 equals x6: " + (y6 equals x6))
+    println()
+    println("x7 = " + x7)
+    println("y7 = " + y7)
+    println("x7 eq y7: " + (x7 eq y7) + ", y7 eq x7: " + (y7 eq x7))
+    println("x7 equals y7: " + (x7 equals y7) + ", y7 equals x7: " + (y7 equals x7))
+    println()
+    println("x8 = " + x8)
+    println("y8 = " + y8)
+    println("x8 eq y8: " + (x8 eq y8) + ", y8 eq x8: " + (y8 eq x8))
+    println("x8 equals y8: " + (x8 equals y8) + ", y8 equals x8: " + (y8 equals x8))
+    println()
+    println("x9 = " + x9)
+    println("y9 = " + y9)
+    println("x9 eq y9: " + (x9 eq y9) + ", y9 eq x9: " + (y9 eq x9))
+    println("x9 equals y9: " + (x9 equals y9) + ", y9 equals x9: " + (y9 equals x9))
+    println()
+    println("x10 = " + x10)
+    println("y10 = " + y10)
+    println("x10 eq y10: " + (x10 eq y10) + ", y10 eq x10: " + (y10 eq x10))
+    println("x10 equals y10: " + (x10 equals y10) + ", y10 equals x10: " + (y10 equals x10))
+    println()
+    println("x9 eq x10: " + (x9 eq x10) + ", x10 eq x9: " + (x10 eq x9))
+    println("x9 equals x10: " + (x9 equals x10) + ", x10 equals x9: " + (x10 equals x9))
+    println("x9 eq y10: " + (x9 eq y10) + ", y10 eq x9: " + (y10 eq x9))
+    println("x9 equals y10: " + (x9 equals y10) + ", y10 equals x9: " + (y10 equals x9))
+    println()
   }
   catch {
     case e: Exception =>
@@ -86,18 +144,17 @@ object Test1_scala {
 @serializable
 object Test2_immutable {
   import scala.collection.immutable.{
-    BitSet, ListMap, ListSet, Queue, Stack, TreeSet, TreeMap}
+    BitSet, HashMap, ListMap, ListSet, Queue, Stack, TreeSet, TreeMap, Vector}
 
   val x1 = List(
-    Pair("buffers", 20),
-    Pair("layers", 2),
-    Pair("title", 3)
+    ("buffers", 20),
+    ("layers", 2),
+    ("title", 3)
   )
 
-  val x2 = new ListMap[String, Int]
-    .incl(Pair("buffers", 20))
-    .incl(Pair("layers", 2))
-    .incl(Pair("title", 3))
+  val m1 = new HashMap[Int, String] + (0 -> "A", 1 -> "B", 2 -> "C")
+
+  val x2 = new ListMap[String, Int] + ("buffers" -> 20, "layers" -> 2, "title" -> 3)
 
   val x3 = {
     val bs = new collection.mutable.BitSet()
@@ -105,34 +162,40 @@ object Test2_immutable {
     bs.toImmutable
   }
 
-  val x4 = new ListSet[Int]().incl(3).incl(5)
+  val x4 = new ListSet[Int]() + 3 + 5
+
+  val x5 = Queue("a", "b", "c")
 
-  val x5 = new Queue("a", "b", "c")
+  val x6 = Stack("a", "b", "c")
 
-  val x6 = new Stack().push("a", "b", "c")
+  val x7 = new TreeMap[Int, String] + (42 -> "FortyTwo")
 
-  val x7 = new TreeMap[Int, String] + 42 -> "FortyTwo"
+  val x8 = new TreeSet[Int]() + 2 + 0
 
-  val x8 = new TreeSet[Int]().incl(2).incl(0)
+  val x9 = Vector(1, 2, 3)
 
   try {
-    val y1: List[Pair[String, Int]] = Serialize.read(Serialize.write(x1))
-    val y2: ListMap[String, Int]    = Serialize.read(Serialize.write(x2))
-    val y3: BitSet                  = Serialize.read(Serialize.write(x3))
-    val y4: ListSet[Int]            = Serialize.read(Serialize.write(x4))
-    val y5: Queue[String]           = Serialize.read(Serialize.write(x5))
-    val y6: Stack[String]           = Serialize.read(Serialize.write(x6))
-    val y7: TreeMap[Int, String]    = Serialize.read(Serialize.write(x7))
-    val y8: TreeSet[Int]            = Serialize.read(Serialize.write(x8))
-
-    EqualityTest.check(x1, y1)
-    EqualityTest.check(x2, y2)
-    EqualityTest.check(x3, y3)
-    EqualityTest.check(x4, y4)
-    EqualityTest.check(x5, y5)
-    EqualityTest.check(x6, y6)
-    EqualityTest.check(x7, y7)
-    EqualityTest.check(x8, y8)
+    val y1: List[Pair[String, Int]] = read(write(x1))
+    val n1: HashMap[Int, String]    = read(write(m1))
+    val y2: ListMap[String, Int]    = read(write(x2))
+    val y3: BitSet                  = read(write(x3))
+    val y4: ListSet[Int]            = read(write(x4))
+    val y5: Queue[String]           = read(write(x5))
+    val y6: Stack[String]           = read(write(x6))
+    val y7: TreeMap[Int, String]    = read(write(x7))
+    val y8: TreeSet[Int]            = read(write(x8))
+    val y9: Vector[Int]             = read(write(x9))
+
+    check(x1, y1)
+    check(m1, n1)
+    check(x2, y2)
+    check(x3, y3)
+    check(x4, y4)
+    check(x5, y5)
+    check(x6, y6)
+    check(x7, y7)
+    check(x8, y8)
+    check(x9, y9)
   }
   catch {
     case e: Exception =>
@@ -163,43 +226,47 @@ object Test3_mutable {
   val x3 = new HashSet[String]
   x3 ++= Test2_immutable.x1.map(p => p._1)
 
-  @serializable
-  class Feed extends Publisher[String, Feed]
-
-  val x8 = new History[String, Feed]
-
   val x4 = new LinkedList[Int](2, null)
   x4.append(new LinkedList(3, null))
 
-  val x7 = new ListBuffer[String]
-  x7 ++= List("white", "black")
-
   val x5 = new Queue[Int]
   x5 ++= Test2_immutable.x1.map(p => p._2)
 
   val x6 = new Stack[Int]
-  x6 ++= x5
+  x6 pushAll x5
+
+  val x7 = new ListBuffer[String]
+  x7 ++= List("white", "black")
+
+  @serializable
+  class Feed extends Publisher[String, Feed] {
+    override def toString() = "Feed"
+  }
+  val feed = new Feed
+
+  val x8 = new History[String, Feed]
+  x8.notify(feed, "hello")
 
   try {
-    val y0: ArrayBuffer[String]   = Serialize.read(Serialize.write(x0))
-    val y1: HashMap[String, Int]  = Serialize.read(Serialize.write(x1))
-    val y2: BitSet                = Serialize.read(Serialize.write(x2))
-    val y3: HashSet[String]       = Serialize.read(Serialize.write(x3))
-    val y4: LinkedList[Int]       = Serialize.read(Serialize.write(x4))
-    val y5: Queue[Int]            = Serialize.read(Serialize.write(x5))
-    val y6: Stack[Int]            = Serialize.read(Serialize.write(x6))
-    val y7: ListBuffer[String]    = Serialize.read(Serialize.write(x7))
-    val y8: History[String, Feed] = Serialize.read(Serialize.write(x8))
-
-    EqualityTest.check(x0, y0)
-    EqualityTest.check(x1, y1)
-    EqualityTest.check(x2, y2)
-    EqualityTest.check(x3, y3)
-    EqualityTest.check(x4, y4)
-    EqualityTest.check(x5, y5)
-    EqualityTest.check(x6, y6)
-    EqualityTest.check(x7, y7)
-    //EqualityTest.check(x8, y8) //todo
+    val y0: ArrayBuffer[String]   = read(write(x0))
+    val y1: HashMap[String, Int]  = read(write(x1))
+    val y2: BitSet                = read(write(x2))
+    val y3: HashSet[String]       = read(write(x3))
+    val y4: LinkedList[Int]       = read(write(x4))
+    val y5: Queue[Int]            = read(write(x5))
+    val y6: Stack[Int]            = read(write(x6))
+    val y7: ListBuffer[String]    = read(write(x7))
+    val y8: History[String, Feed] = read(write(x8))
+
+    check(x0, y0)
+    check(x1, y1)
+    check(x2, y2)
+    check(x3, y3)
+    check(x4, y4)
+    check(x5, y5)
+    check(x6, y6)
+    check(x7, y7)
+    check(x8, y8)
   }
   catch {
     case e: Exception =>
@@ -246,11 +313,11 @@ object Test4_xml {
     </html>;
 
   try {
-    val y1: scala.xml.Elem = Serialize.read(Serialize.write(x1))
-    val y2: scala.xml.Elem = Serialize.read(Serialize.write(x2))
+    val y1: scala.xml.Elem = read(write(x1))
+    val y2: scala.xml.Elem = read(write(x2))
 
-    EqualityTest.check(x1, y1)
-    EqualityTest.check(x2, y2)
+    check(x1, y1)
+    check(x2, y2)
   }
   catch {
     case e: Exception =>
@@ -283,11 +350,11 @@ object Test5 {
   val x2 = bob
 
   try {
-    val y1: Person   = Serialize.read(Serialize.write(x1))
-    val y2: Employee = Serialize.read(Serialize.write(x2))
+    val y1: Person   = read(write(x1))
+    val y2: Employee = read(write(x2))
 
-    EqualityTest.check(x1, y1)
-    EqualityTest.check(x2, y2)
+    check(x1, y1)
+    check(x2, y2)
   }
   catch {
     case e: Exception =>
@@ -313,13 +380,13 @@ object Test6 {
   val x3 = paul
 
   try {
-    val y1: Person   = Serialize.read(Serialize.write(x1))
-    val y2: Employee = Serialize.read(Serialize.write(x2))
-    val y3: Person   = Serialize.read(Serialize.write(x3))
+    val y1: Person   = read(write(x1))
+    val y2: Employee = read(write(x2))
+    val y3: Person   = read(write(x3))
 
-    EqualityTest.check(x1, y1)
-    EqualityTest.check(x2, y2)
-    EqualityTest.check(x3, y3)
+    check(x1, y1)
+    check(x2, y2)
+    check(x3, y3)
   }
   catch {
     case e: Exception =>