New tests are added (multidimensional arrays, array builder, wrapper, arrayOps)

Author: VladimirNik

test/dotc/tests.scala

@@ -113,6 +113,10 @@ class tests extends CompilerTest {
   @Test def pos_vc_array_object = compileFile(runDir, "valueclasses-array-object", args = "-Ycheck:all" :: Nil)
   @Test def pos_vc_array_newarray = compileFile(runDir, "valueclasses-array-newarray", args = "-Ycheck:all" :: Nil)
   @Test def pos_vc_underlying_null = compileFile(runDir, "valueclasses-underlying-null", args = "-Ycheck:all" :: Nil)
+  @Test def pos_vc_array_creation = compileFile(runDir, "valueclasses-array-creation", args = "-Ycheck:all" :: Nil)
+  @Test def pos_vc_array_caseclasses = compileFile(runDir, "valueclasses-array-caseclasses", args = "-Ycheck:all" :: Nil)
+  @Test def pos_vc_array_arrayops = compileFile(runDir, "valueclasses-array-arrayops", args = "-Ycheck:all" :: Nil)
+  @Test def pos_vc_array_array = compileFile(runDir, "valueclasses-array-array", args = "-Ycheck:all" :: Nil)
 
   @Test def pos_all = compileFiles(posDir) // twice omitted to make tests run faster
 

tests/run/valueclasses-array-array.check

@@ -0,0 +1,9 @@
+List(X@0, X@0, X@0, X@0)
+List([X, [X, [X, [X)
+List(X@1, X@2, X@3, X@4)
+List(X@1, X@1, X@1, X@1, X@1)
+List([X, [X, [X, [X, [X)
+List(X@0, X@1, X@2, X@3, X@4)
+List([X, [X, [X, [X)
+List(X@5, X@a, X@14)
+Some(Vector(X@1, X@2, X@3))

tests/run/valueclasses-array-array.scala

@@ -0,0 +1,32 @@
+class X[T](val x: T) extends AnyVal
+object Test {
+  def main(args: Array[String]) = {
+    def pl(xs: Array[_]) = println(xs.toList)
+    pl(Array.ofDim[X](4))
+    pl(Array.ofDim[X](4,3))
+    Array.ofDim[X](4,3,2)
+    Array.ofDim[X](4,3,2,5)
+    Array.ofDim[X](4,3,2,5,6)
+    pl(Array.concat(Array[X](new X(1), new X(2)), Array[X](new X(3), new X(4))))
+    import scala.collection.mutable.{ WrappedArray, ArrayBuilder }
+    val ar: WrappedArray[X] = Array[X](new X(1), new X(2))
+    ar.toArray
+    val ar0: WrappedArray[X] = Array[X](new X(1), new X(2))
+    val ar1: ArrayBuilder[X] = ArrayBuilder.make[X]()
+    val ar2 = ar1.++=(ar0)
+    pl(Array.fill(5)(new X(1)))
+    pl(Array.fill(5,6)(new X(1)))
+    Array.fill(5,6,7)(new X(1))
+    Array.fill(5,6,7,8)(new X(1))
+    Array.fill(5,6,7,8,9)(new X(1))
+
+    pl(Array.tabulate(5)(x => new X(x)))
+    pl(Array.tabulate(4,5)((x,y) => new X(x + y)))
+    Array.tabulate(4,5,6)((x,y,z) => new X(x + y + z))
+    Array.tabulate(4,5,6,7)((x,y,z,q) => new X(x + y + z + q))
+    Array.tabulate(4,5,6,7,8)((x,y,z,q,w) => new X(x + y + z + q + w))
+
+    pl(Array.iterate(new X(5), 3)(xx => new X(2*xx.x)))
+    println(Array.unapplySeq(Array[X](new X(1), new X(2), new X(3))))
+  }
+}

tests/run/valueclasses-array-arrayops.check

@@ -0,0 +1,14 @@
+Array(X@1, X@2)
+SeqView(...)
+SeqViewS(...)
+List(X@1, X@2)
+List()
+non-empty iterator
+ArrayBuffer(X@1, X@2)
+X@1
+WrappedArray(X@1, X@2)
+List(X@1, X@2)
+Set(X@1, X@2)
+Set(ArrayBuffer(X@1, X@4), ArrayBuffer(X@2, X@5), ArrayBuffer(X@3, X@6))
+t4.transpose: List([X, [X, [X)
+t21.transpose: List()

tests/run/valueclasses-array-arrayops.scala

@@ -0,0 +1,33 @@
+import scala.collection.mutable._
+class X(val x: Int) extends AnyVal
+object Test {
+  def main(args: Array[String]) = {
+    val ar3 = Array(Array(new X(1)), Array(new X(2)))
+    val ar = Array(new X(1), new X(2))
+    println(ar.deep) //ArrayLike
+    println(ar.view) //IndexedSeqLike
+    println(ar.view(0,1))
+    println(ar.drop(0).toList)
+    println(ar.take(0).toList)
+    println(ar.iterator)
+    println(ar.toBuffer)
+    println(ar.head)
+    println(ar.seq)
+    println(ar3.flatten.toList)
+
+    val ar2: WrappedArray[X] = ar
+    println(ar2.toArray.toSet)
+    ar2.companion
+
+    val t = Array((1, new X(3)), (2, new X(4)))
+    t.unzip
+
+    val t2: Array[Array[X]] = Array(Array(new X(1), new X(2), new X(3)), Array(new X(4), new X(5), new X(6)))
+    val t3: WrappedArray[Array[X]] = t2
+    println(t3.transpose.toSet)
+    val t4: ArrayOps[Array[X]] = t2
+    println(s"t4.transpose: ${t4.transpose.toList}")
+    val t21: Array[Array[X]] = Array(Array[X](), Array[X]())
+    println(s"t21.transpose: ${t21.transpose.toList}")
+  }
+}

tests/run/valueclasses-array-caseclasses.check

@@ -0,0 +1,6 @@
+List([Y)
+List(Y(null), Y(null))
+List(Y(null), Y(null), Y(null), Y(null), Y(null))
+List(Y(Z()), Y(Z()), Y(Z()))
+List(Y(Z()), Y(Z()), Y(Z()))
+List(Y(Z()), Y(Z()), Y(Z()))

tests/run/valueclasses-array-caseclasses.scala

@@ -0,0 +1,18 @@
+case class Y[T](val y: T) extends AnyVal
+case class Z()
+
+object Test {
+  def main(args: Array[String]) = {
+    val a1 = Array(Array[Y[Z]]())
+    val a2 = Array.ofDim[Y[Z]](2)
+    val a3 = new Array[Y[Z]](5)
+    val a4: Array[Y[Z]] = Array(Y[Z](Z()), Y[Z](Z()), Y[Z](Z()))
+
+    println(a1.toList)
+    println(a2.toList)
+    println(a3.toList)
+    println(a4.toArray.toList)
+    println(a4.par.toList)
+    println(a4.map(x => a4(0)).toList)
+  }
+}

tests/run/valueclasses-array-creation.check

@@ -0,0 +1,12 @@
+List(X@b, X@16)
+List([X, [X)
+List(X@7, X@2)
+X@1
+X@1
+List([X, [X)
+List(X@7, X@2)
+List(X@0, X@0, X@0)
+List(null, null, null)
+List(null, null, null)
+List(X@6, X@6)
+List(X@e)

tests/run/valueclasses-array-creation.scala

@@ -0,0 +1,52 @@
+class X(val x: Int) extends AnyVal
+object Test {
+  def main(args: Array[String]) = {
+    val simple = Array(new X(11), new X(22))
+    val a = Array(Array(new X(1), new X(2)), Array(new X(3)))
+    val b = a(0)
+    val c = b(0)
+    val d = a(0)(0)
+    a(0)(0) = new X(7)
+    def test(x: Array[Array[X]]) = {
+      x(0) = Array(new X(5));
+      x
+    }
+    def test2(x: Array[X]) = x
+    def test3[T](y: Array[T]) = {
+      val a = y(0);
+      y(0) = y(1);
+      y(1) = a;
+      y match {
+        case ar@Array(el1: X, el2: X) => (ar.asInstanceOf[Array[X]]) filter (_.x > 1) map { t => new X(el2.x * 2) }
+        case _ => y
+      }
+    }
+    def test4(y: Array[X]) = {
+      y match {
+        case ar@Array(el1, el2) => ar filter (_.x > 1) map { t => new X(el2.x * 2) }
+        case _ => y
+      }
+    }
+
+
+    val x = new Array[X](3)
+    val y = new Array[Array[X]](3)
+    val z = new Array[Array[Array[X]]](3)
+
+    println(simple.toList)
+
+    println(a.toList)
+    println(b.toList)
+    println(c)
+    println(d)
+    println(test(a).toList)
+    println(test2(b).toList)
+
+    println(x.toList)
+    println(y.toList)
+    println(z.toList)
+
+    println(test3(Array(new X(3), new X(5))).toList)
+    println(test4(Array(new X(0), new X(7))).toList)
+  }
+}