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.

1 files changed, 17 insertions, 17 deletions

diff --git a/test/files/run/pc-conversions.scala b/test/files/run/pc-conversions.scala
index b1ef3d963e..19fef355c8 100644
--- a/test/files/run/pc-conversions.scala
+++ b/test/files/run/pc-conversions.scala
@@ -7,11 +7,11 @@ import collection._
 
 // test conversions between collections
 object Test {
-  
+
   def main(args: Array[String]) {
     testConversions
   }
-  
+
   def testConversions {
     // seq conversions
     assertSeq(parallel.mutable.ParArray(1, 2, 3))
@@ -20,7 +20,7 @@ object Test {
     assertSeq(parallel.immutable.ParRange(1, 50, 1, false))
     assertSeq(parallel.immutable.ParHashMap(1 -> 2, 2 -> 4))
     assertSeq(parallel.immutable.ParHashSet(1, 2, 3))
-    
+
     // par conversions
     assertPar(Array(1, 2, 3))
     assertPar(mutable.ArrayBuffer(1, 2, 3))
@@ -31,7 +31,7 @@ object Test {
     assertPar(immutable.Range(1, 50, 1))
     assertPar(immutable.HashMap(1 -> 1, 2 -> 2))
     assertPar(immutable.HashSet(1, 2, 3))
-    
+
     // par.to* and to*.par tests
     assertToPar(List(1 -> 1, 2 -> 2, 3 -> 3))
     assertToPar(Stream(1 -> 1, 2 -> 2))
@@ -49,19 +49,19 @@ object Test {
     assertToPar(parallel.mutable.ParHashSet(1 -> 2))
     assertToPar(parallel.immutable.ParHashMap(1 -> 2))
     assertToPar(parallel.immutable.ParHashSet(1 -> 3))
-    
+
     assertToParWoMap(immutable.Range(1, 10, 2))
-    
+
     // seq and par again conversions)
     assertSeqPar(parallel.mutable.ParArray(1, 2, 3))
   }
-  
+
   def assertSeqPar[T](pc: parallel.ParIterable[T]) = pc.seq.par == pc
-  
+
   def assertSeq[T](pc: parallel.ParIterable[T]) = assert(pc.seq == pc)
-  
+
   def assertPar[T, P <: Parallel](xs: GenIterable[T]) = assert(xs == xs.par)
-  
+
   def assertToPar[K, V](xs: GenTraversable[(K, V)]) {
     xs match {
       case _: Seq[_] =>
@@ -69,26 +69,26 @@ object Test {
         assert(xs.par.toIterable == xs)
       case _ =>
     }
-    
+
     assert(xs.toSeq.par == xs.toSeq)
     assert(xs.par.toSeq == xs.toSeq)
-    
+
     assert(xs.toSet.par == xs.toSet)
     assert(xs.par.toSet == xs.toSet)
-    
+
     assert(xs.toMap.par == xs.toMap)
     assert(xs.par.toMap == xs.toMap)
   }
-  
+
   def assertToParWoMap[T](xs: GenSeq[T]) {
     assert(xs.toIterable.par == xs.toIterable)
     assert(xs.par.toIterable == xs.toIterable)
-    
+
     assert(xs.toSeq.par == xs.toSeq)
     assert(xs.par.toSeq == xs.toSeq)
-    
+
     assert(xs.toSet.par == xs.toSet)
     assert(xs.par.toSet == xs.toSet)
   }
-  
+
 }