Merge pull request #5266 from dotty-staging/tuple-tests

Add tuple >22 test cases from #2199

Author: nicolasstucki

tests/pending/tuple-cons.scala

@@ -0,0 +1,182 @@
+import dotty._
+
+object Test {
+  def main(args: Array[String]) = {
+    val t1: *:[Int, *:[Int, Unit]] = (1, 2)
+
+    val t2: *:[Int, *:[Int, *:[Int, Unit]]] = 0 *: t1
+
+    assert(t2.head == 0)
+    assert(t2.tail.head == 1)
+    assert(t2.tail.tail.head == 2)
+
+    t2 match {
+      case e1 *: e2 *: e3 *: () =>
+        assert(e1 == 0)
+        assert(e2 == 1)
+        assert(e3 == 2)
+    }
+
+    val t3: *:[Int, *:[Int, *:[Int, *:[Int, Unit]]]] = -1 *: t2
+
+    assert(t3.head == -1)
+    assert(t3.tail.head == 0)
+    assert(t3.tail.tail.head == 1)
+    assert(t3.tail.tail.tail.head == 2)
+
+    t3 match {
+      case e1 *: e2 *: e3 *: e4 *: () =>
+        assert(e1 == -1)
+        assert(e2 == 0)
+        assert(e3 == 1)
+        assert(e4 == 2)
+    }
+
+    type I = Int
+
+    //       1   2   3   4   5   6   7   8   9   10  11  12  13  14  15  16  17  18  19  20
+    val t20: *:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,Unit]]]]]]]]]]]]]]]]]]]] = 1 *: 2 *: 3 *: 4 *: 5 *: 6 *: 7 *: 8 *: 9 *: 10 *: 11 *: 12 *: 13 *: 14 *: 15 *: 16 *: 17 *: 18 *: 19 *: 20 *: ()
+
+    t20 match {
+      case e1 *: e2 *: e3 *: e4 *: e5 *: e6 *: e7 *: e8 *: e9 *: e10 *: e11 *: e12 *: e13 *: e14 *: e15 *: e16 *: e17 *: e18 *: e19 *: e20 *: () =>
+      assert(e1 == 1)
+      assert(e2 == 2)
+      assert(e3 == 3)
+      assert(e4 == 4)
+      assert(e5 == 5)
+      assert(e6 == 6)
+      assert(e7 == 7)
+      assert(e8 == 8)
+      assert(e9 == 9)
+      assert(e10 == 10)
+      assert(e11 == 11)
+      assert(e12 == 12)
+      assert(e13 == 13)
+      assert(e14 == 14)
+      assert(e15 == 15)
+      assert(e16 == 16)
+      assert(e17 == 17)
+      assert(e18 == 18)
+      assert(e19 == 19)
+      assert(e20 == 20)
+    }
+
+    //       1   2   3   4   5   6   7   8   9   10  11  12  13  14  15  16  17  18  19  20  21
+    val t21: *:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,Unit]]]]]]]]]]]]]]]]]]]]] = 21 *: t20
+
+    t21 match {
+      case e21 *: e1 *: e2 *: e3 *: e4 *: e5 *: e6 *: e7 *: e8 *: e9 *: e10 *: e11 *: e12 *: e13 *: e14 *: e15 *: e16 *: e17 *: e18 *: e19 *: e20 *: () =>
+      assert(e1 == 1)
+      assert(e2 == 2)
+      assert(e3 == 3)
+      assert(e4 == 4)
+      assert(e5 == 5)
+      assert(e6 == 6)
+      assert(e7 == 7)
+      assert(e8 == 8)
+      assert(e9 == 9)
+      assert(e10 == 10)
+      assert(e11 == 11)
+      assert(e12 == 12)
+      assert(e13 == 13)
+      assert(e14 == 14)
+      assert(e15 == 15)
+      assert(e16 == 16)
+      assert(e17 == 17)
+      assert(e18 == 18)
+      assert(e19 == 19)
+      assert(e20 == 20)
+      assert(e21 == 21)
+    }
+
+    //       1   2   3   4   5   6   7   8   9   10  11  12  13  14  15  16  17  18  19  20  21  22
+    val t22: *:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,Unit]]]]]]]]]]]]]]]]]]]]]] = 22 *: t21
+
+    t22 match {
+      case e22 *: e21 *: e1 *: e2 *: e3 *: e4 *: e5 *: e6 *: e7 *: e8 *: e9 *: e10 *: e11 *: e12 *: e13 *: e14 *: e15 *: e16 *: e17 *: e18 *: e19 *: e20 *: () =>
+      assert(e1 == 1)
+      assert(e2 == 2)
+      assert(e3 == 3)
+      assert(e4 == 4)
+      assert(e5 == 5)
+      assert(e6 == 6)
+      assert(e7 == 7)
+      assert(e8 == 8)
+      assert(e9 == 9)
+      assert(e10 == 10)
+      assert(e11 == 11)
+      assert(e12 == 12)
+      assert(e13 == 13)
+      assert(e14 == 14)
+      assert(e15 == 15)
+      assert(e16 == 16)
+      assert(e17 == 17)
+      assert(e18 == 18)
+      assert(e19 == 19)
+      assert(e20 == 20)
+      assert(e21 == 21)
+      assert(e22 == 22)
+    }
+
+    //       1   2   3   4   5   6   7   8   9   10  11  12  13  14  15  16  17  18  19  20  21  22  23
+    val t23: *:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,Unit]]]]]]]]]]]]]]]]]]]]]]] = 23 *: t22
+
+    t23 match {
+      case e23 *: e22 *: e21 *: e1 *: e2 *: e3 *: e4 *: e5 *: e6 *: e7 *: e8 *: e9 *: e10 *: e11 *: e12 *: e13 *: e14 *: e15 *: e16 *: e17 *: e18 *: e19 *: e20 *: () =>
+      assert(e1 == 1)
+      assert(e2 == 2)
+      assert(e3 == 3)
+      assert(e4 == 4)
+      assert(e5 == 5)
+      assert(e6 == 6)
+      assert(e7 == 7)
+      assert(e8 == 8)
+      assert(e9 == 9)
+      assert(e10 == 10)
+      assert(e11 == 11)
+      assert(e12 == 12)
+      assert(e13 == 13)
+      assert(e14 == 14)
+      assert(e15 == 15)
+      assert(e16 == 16)
+      assert(e17 == 17)
+      assert(e18 == 18)
+      assert(e19 == 19)
+      assert(e20 == 20)
+      assert(e21 == 21)
+      assert(e22 == 22)
+      assert(e23 == 23)
+    }
+
+    //       1   2   3   4   5   6   7   8   9   10  11  12  13  14  15  16  17  18  19  20  21  22  23  24
+    val t24: *:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,*:[I,Unit]]]]]]]]]]]]]]]]]]]]]]]] = 24 *: t23
+
+    t24 match {
+      case e24 *: e23 *: e22 *: e21 *: e1 *: e2 *: e3 *: e4 *: e5 *: e6 *: e7 *: e8 *: e9 *: e10 *: e11 *: e12 *: e13 *: e14 *: e15 *: e16 *: e17 *: e18 *: e19 *: e20 *: () =>
+      assert(e1 == 1)
+      assert(e2 == 2)
+      assert(e3 == 3)
+      assert(e4 == 4)
+      assert(e5 == 5)
+      assert(e6 == 6)
+      assert(e7 == 7)
+      assert(e8 == 8)
+      assert(e9 == 9)
+      assert(e10 == 10)
+      assert(e11 == 11)
+      assert(e12 == 12)
+      assert(e13 == 13)
+      assert(e14 == 14)
+      assert(e15 == 15)
+      assert(e16 == 16)
+      assert(e17 == 17)
+      assert(e18 == 18)
+      assert(e19 == 19)
+      assert(e20 == 20)
+      assert(e21 == 21)
+      assert(e22 == 22)
+      assert(e23 == 23)
+      assert(e24 == 24)
+    }
+  }
+}

tests/pending/tuple-erased.scala

@@ -0,0 +1,59 @@
+object Test {
+  def main(args: Array[String]): Unit = {
+    val t02: Any = (1, 2)
+    val t05: Any = (1, 2, 4, 5, 6)
+    val t21: Any = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21)
+    val t22: Any = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22)
+    val t23: Any = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23)
+    val t24: Any = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24)
+
+    assert(t02.asInstanceOf[Tuple] == t02)
+    assert(t05.asInstanceOf[Tuple] == t05)
+    assert(t21.asInstanceOf[Tuple] == t21)
+    assert(t22.asInstanceOf[Tuple] == t22)
+    assert(t23.asInstanceOf[Tuple] == t23)
+    assert(t24.asInstanceOf[Tuple] == t24)
+
+    assert(t02.isInstanceOf[Tuple])
+    assert(t05.isInstanceOf[Tuple])
+    assert(t21.isInstanceOf[Tuple])
+    assert(t22.isInstanceOf[Tuple])
+    assert(t23.isInstanceOf[Tuple])
+    assert(t24.isInstanceOf[Tuple])
+
+    assert(t02.asInstanceOf[Product] == t02)
+    assert(t05.asInstanceOf[Product] == t05)
+    assert(t21.asInstanceOf[Product] == t21)
+    assert(t22.asInstanceOf[Product] == t22)
+    assert(t23.asInstanceOf[Product] == t23)
+    assert(t24.asInstanceOf[Product] == t24)
+
+    assert(t02.isInstanceOf[Product])
+    assert(t05.isInstanceOf[Product])
+    assert(t21.isInstanceOf[Product])
+    assert(t22.isInstanceOf[Product])
+    assert(t23.isInstanceOf[Product])
+    assert(t24.isInstanceOf[Product])
+
+    assert(t02.asInstanceOf[*:[_, _]] == t02)
+    assert(t05.asInstanceOf[*:[_, _]] == t05)
+    assert(t21.asInstanceOf[*:[_, _]] == t21)
+    assert(t22.asInstanceOf[*:[_, _]] == t22)
+    assert(t23.asInstanceOf[*:[_, _]] == t23)
+    assert(t24.asInstanceOf[*:[_, _]] == t24)
+
+    assert(t02.isInstanceOf[*:[_, _]])
+    assert(t05.isInstanceOf[*:[_, _]])
+    assert(t21.isInstanceOf[*:[_, _]])
+    assert(t22.isInstanceOf[*:[_, _]])
+    assert(t23.isInstanceOf[*:[_, _]])
+    assert(t24.isInstanceOf[*:[_, _]])
+
+    val x = ()
+    assert(x.asInstanceOf[Tuple] == x)
+    assert(x.asInstanceOf[Any] == x)
+
+    val y: *:[Int, *:[String, Unit]] = (1, "s")
+    y: Tuple
+  }
+}

tests/pending/tuple-for-comprehension.scala

@@ -0,0 +1,140 @@
+object Test {
+  def main(args: Array[String]) = {
+    assert(Some(2) == (for {
+      x1 <- Some(1)
+      x2 = x1
+    } yield x1 + x2))
+
+    assert(Some(3) == (for {
+      x1 <- Some(1)
+      x2 = x1
+      x3 = x1
+    } yield x1 + x2 + x3))
+
+    assert(Some(4) == (for {
+      x1 <- Some(1)
+      x2 = x1
+      x3 = x1
+      x4 = x1
+    } yield x1 + x2 + x3 + x4))
+
+    assert(Some(5) == (for {
+      x1 <- Some(1)
+      x2 = x1
+      x3 = x1
+      x4 = x1
+      x5 = x1
+    } yield x1 + x2 + x3 + x4 + x5))
+
+    assert(Some(6) == (for {
+      x1 <- Some(1)
+      x2 = x1
+      x3 = x1
+      x4 = x1
+      x5 = x1
+      x6 = x1
+    } yield x1 + x2 + x3 + x4 + x5 + x6))
+
+    assert(Some(21) == (for {
+      x1 <- Some(1)
+      x2 = x1
+      x3 = x1
+      x4 = x1
+      x5 = x1
+      x6 = x1
+      x7 = x1
+      x8 = x1
+      x9 = x1
+      x10 = x1
+      x11 = x1
+      x12 = x1
+      x13 = x1
+      x14 = x1
+      x15 = x1
+      x16 = x1
+      x17 = x1
+      x18 = x1
+      x19 = x1
+      x20 = x1
+      x21 = x1
+    } yield x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 + x11 + x12 + x13 + x14 + x15 + x16 + x17 + x18 + x19 + x20 + x21))
+
+    assert(Some(22) == (for {
+      x1 <- Some(1)
+      x2 = x1
+      x3 = x1
+      x4 = x1
+      x5 = x1
+      x6 = x1
+      x7 = x1
+      x8 = x1
+      x9 = x1
+      x10 = x1
+      x11 = x1
+      x12 = x1
+      x13 = x1
+      x14 = x1
+      x15 = x1
+      x16 = x1
+      x17 = x1
+      x18 = x1
+      x19 = x1
+      x20 = x1
+      x21 = x1
+      x22 = x1
+    } yield x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 + x11 + x12 + x13 + x14 + x15 + x16 + x17 + x18 + x19 + x20 + x21 + x22))
+
+    assert(Some(23) == (for {
+      x1 <- Some(1)
+      x2 = x1
+      x3 = x1
+      x4 = x1
+      x5 = x1
+      x6 = x1
+      x7 = x1
+      x8 = x1
+      x9 = x1
+      x10 = x1
+      x11 = x1
+      x12 = x1
+      x13 = x1
+      x14 = x1
+      x15 = x1
+      x16 = x1
+      x17 = x1
+      x18 = x1
+      x19 = x1
+      x20 = x1
+      x21 = x1
+      x22 = x1
+      x23 = x1
+    } yield x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 + x11 + x12 + x13 + x14 + x15 + x16 + x17 + x18 + x19 + x20 + x21 + x22 + x23))
+
+    assert(Some(24) == (for {
+      x1 <- Some(1)
+      x2 = x1
+      x3 = x1
+      x4 = x1
+      x5 = x1
+      x6 = x1
+      x7 = x1
+      x8 = x1
+      x9 = x1
+      x10 = x1
+      x11 = x1
+      x12 = x1
+      x13 = x1
+      x14 = x1
+      x15 = x1
+      x16 = x1
+      x17 = x1
+      x18 = x1
+      x19 = x1
+      x20 = x1
+      x21 = x1
+      x22 = x1
+      x23 = x1
+      x24 = x1
+    } yield x1 + x2 + x3 + x4 + x5 + x6 + x7 + x8 + x9 + x10 + x11 + x12 + x13 + x14 + x15 + x16 + x17 + x18 + x19 + x20 + x21 + x22 + x23 + x24))
+  }
+}