From f4267ccd96a9143c910c66a5b0436aaa64b7c9dc Mon Sep 17 00:00:00 2001
From: Paul Phillips <paulp@improving.org>
Date: Wed, 18 Sep 2013 00:09:46 -0700
Subject: Cull extraneous whitespace.

One last flurry with the broom before I leave you slobs to code
in your own filth. Eliminated all the trailing whitespace I
could manage, with special prejudice reserved for the test cases
which depended on the preservation of trailing whitespace.

Was reminded I cannot figure out how to eliminate the trailing
space on the "scala> " prompt in repl transcripts. At least
reduced the number of such empty prompts by trimming transcript
code on the way in.

Routed ConsoleReporter's "printMessage" through a trailing
whitespace stripping method which might help futureproof
against the future of whitespace diseases. Deleted the up-to-40
lines of trailing whitespace found in various library files.

It seems like only yesterday we performed whitespace surgery
on the whole repo. Clearly it doesn't stick very well. I suggest
it would work better to enforce a few requirements on the way in.
---
 test/files/jvm/t1600.scala | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

(limited to 'test/files/jvm/t1600.scala')

diff --git a/test/files/jvm/t1600.scala b/test/files/jvm/t1600.scala
index 69179c1ba4..5a1b2900c5 100644
--- a/test/files/jvm/t1600.scala
+++ b/test/files/jvm/t1600.scala
@@ -4,23 +4,23 @@
  * changes on deserialization.
  */
 object Test {
-  
+
   import collection._
   def main(args: Array[String]) {
     for (i <- Seq(0, 1, 2, 10, 100)) {
       def entries = (0 until i).map(i => (new Foo, i)).toList
       def elements = entries.map(_._1)
-      
+
       val maps = Seq[Map[Foo, Int]](new mutable.HashMap, new mutable.LinkedHashMap,
           immutable.HashMap.empty).map(_ ++ entries)
       test[Map[Foo, Int]](maps, entries.size, assertMap _)
-      
+
       val sets = Seq[Set[Foo]](new mutable.HashSet, new mutable.LinkedHashSet,
           immutable.HashSet.empty).map(_ ++ elements)
       test[Set[Foo]](sets, entries.size, assertSet _)
     }
   }
-  
+
   private def test[A <: AnyRef](collections: Seq[A], expectedSize: Int, assertFunction: (A, Int) => Unit) {
     for (collection <- collections) {
       assertFunction(collection, expectedSize)
@@ -28,19 +28,19 @@ object Test {
       val bytes = toBytes(collection)
       Foo.hashCodeModifier = 1
       val deserializedCollection = toObject[A](bytes)
-      
+
       assertFunction(deserializedCollection, expectedSize)
       assert(deserializedCollection.getClass == collection.getClass,
           "collection class should remain the same after deserialization ("+deserializedCollection.getClass+" != "+collection.getClass+")")
       Foo.hashCodeModifier = 0
     }
   }
-  
+
   private def toObject[A](bytes: Array[Byte]): A = {
     val in = new java.io.ObjectInputStream(new java.io.ByteArrayInputStream(bytes))
     in.readObject.asInstanceOf[A]
   }
-  
+
   private def toBytes(o: AnyRef): Array[Byte] = {
     val bos = new java.io.ByteArrayOutputStream
     val out = new java.io.ObjectOutputStream(bos)
@@ -48,7 +48,7 @@ object Test {
     out.close
     bos.toByteArray
   }
-  
+
   private def assertMap[A, B](map: Map[A, B], expectedSize: Int) {
     assert(expectedSize == map.size, "expected map size: " + expectedSize + ", actual size: " + map.size)
     map.foreach { case (k, v) =>
@@ -56,19 +56,19 @@ object Test {
       assert(map(k) == v)
     }
   }
-  
+
   private def assertSet[A](set: Set[A], expectedSize: Int) {
     assert(expectedSize == set.size, "expected set size: " + expectedSize + ", actual size: " + set.size)
     set.foreach { e => assert(set.contains(e), "contains should return true for element in the set, element: " + e) }
   }
-  
+
   object Foo {
-    /* Used to simulate a hashCode change caused by deserializing an instance with an 
+    /* Used to simulate a hashCode change caused by deserializing an instance with an
      * identity-based hashCode in another JVM.
      */
     var hashCodeModifier = 0
   }
-  
+
   class Foo extends Serializable {
     override def hashCode = System.identityHashCode(this) + Foo.hashCodeModifier
   }
-- 
cgit v1.2.3