Scala example source code file (ParallelArrayTest.scala)

This example Scala source code file (ParallelArrayTest.scala) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Java - Scala tags/keywords

The Scala ParallelArrayTest.scala source code

// package test.scala.collection.parallel.mutable

// import org.scalatest.FunSuite
// import collection.parallel.mutable.ParallelArray

// /**
//  * Notes:
//  */
// class ParallelArrayTest extends FunSuite {

//   test("create new parallel array with a bad initial capacity"){
//     intercept[IllegalArgumentException]{
//       new ParallelArray(-5)
//     }

//     /**
//      * this currently passes, but do we want it to?
//      * does it have meaning to have an empty parallel array? 
//      */
//     new ParallelArray(0)
//     ()
//   }

//   test("compare identical ParallelArrays"){
//     assert(new ParallelArray(5) === new ParallelArray(5))
//     assert(ParallelArray(1,2,3,4,5) === ParallelArray(1,2,3,4,5))
//   }

//   /**
//    * this test needs attention. how is equality defined on ParallelArrays?
//    * Well, the same way it is for normal collections, I guess. For normal arrays its reference equality.
//    * I do not think it should be that way in the case of ParallelArray-s. I'll check this with Martin.
//    */
//   test("compare non-identical ParallelArrays"){
//     assert(ParallelArray(1,2,3,4,5) != ParallelArray(1,2,3,4),
//       "compared PA's that I expect to not be identical, but they were!")
//   }

//   test("creation via PA object [String]"){
//     val paFromApply: ParallelArray[String] = ParallelArray("x", "1", "true", "etrijwejiorwer")
//     val paFromHandoff: ParallelArray[String] = ParallelArray.handoff(Array("x", "1", "true", "etrijwejiorwer"))
//     val paFromCopy: ParallelArray[String] = ParallelArray.createFromCopy(Array("x", "1", "true", "etrijwejiorwer"))
//     assert( paFromApply === paFromCopy )
//     assert( paFromApply === paFromCopy )
//   }

// //  // handoffs dont work for primitive types...
// //  test("creation via PA object [Boolean]"){
// //    val paFromApply: ParallelArray[Boolean] = ParallelArray(true, false, true, false)
// //    val paFromCopy: ParallelArray[Boolean] = ParallelArray.createFromCopy(Array(true, false, true, false))
// //    assert( paFromApply === paFromCopy )
// //  }
// //
// //  // handoffs dont work for primitive types...
// //  test("creation via PA object [Int]"){
// //    val paFromApply: ParallelArray[Int] = ParallelArray(1, 2, 4, 3)
// //    val paFromCopy: ParallelArray[Int] = ParallelArray.createFromCopy(Array(1, 2, 4, 3))
// //    assert( paFromApply === paFromCopy )
// //  }

//   /**
//    * This fails because handoff is really doing a copy.
//    * TODO: look at handoff
//    */
//   test("Handoff Is Really A Handoff"){
//     val arrayToHandOff = Array("a", "x", "y", "z")
//     val paFromHandoff: ParallelArray[String] = ParallelArray.handoff(arrayToHandOff)
//     arrayToHandOff(0) = "w"
//     assert(paFromHandoff(0) === "w")
//   }

//   test("simple reduce"){
//     assert( ParallelArray(1,2,3,4,5).reduce(_+_) === 15 )
//   }

//   test("simple count"){
//     assert( ParallelArray[Int]().count(_ > 7) === 0 )
//     assert( ParallelArray(1,2,3).count(_ > 7) === 0 )
//     assert( ParallelArray(1,2,3).count(_ <= 3) === 3 )
//     assert( ParallelArray(1,2,3,4,5,6,7,8,9,10).count(_ > 7 ) === 3 )
//   }

//   test("simple forall"){
//     assert( ParallelArray[Int]().forall(_ > 7) === true )
//     assert( ParallelArray(1,2,3).forall(_ > 3) === false )
//     assert( ParallelArray(1,2,3).forall(_ <= 3) === true )
//     assert( ParallelArray(1,2,3,4,5,6,7,8,9,10).forall(_ > 0) === true )
//     assert( ParallelArray(1,2,3,4,5,6,7,8,9,10).forall(_ < 5) === false )
//   }

//   /**
//    */
//   test("simple foreach"){
//     val buf = new java.util.concurrent.ArrayBlockingQueue[Int](10000)
//     ParallelArray((1 to 10000):_*).foreach(buf add _)
//     (1 to 10000).foreach(i => assert( buf contains i, "buf should have contained:" + i ))
//   }

//   test("simple exists"){
//     assert( ParallelArray[Int]().exists(_ => true) === false )
//     assert( ParallelArray(1,2,3).forall(_ > 3) === false )
//     assert( ParallelArray(1,2,3,4,5,6,7,8,9,10).exists(_ > 7) === true )
//   }

//   test("simple filter"){
//     assert(ParallelArray(1,2,3,4,5).filter( _ < 4 ) === ParallelArray(1,2,3))
//   }

//   test("simple map test"){
//     assert(ParallelArray(1,2,3,4,5).map( (_:Int) * 10 ) === ParallelArray(10,20,30,40,50))
//   }
// }