Add some tests to all current tuple operations

Author: Antoine Brunner

tests/run/tuple-tests.check

@@ -7,3 +7,23 @@
 (1,2,3,4,5,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35)
 (11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,1,2,3,4,5)
 (11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60)
+(head)
+(head,1,2,3,4,5)
+(head,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35)
+(head,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57)
+()
+(2,3,4,5)
+(12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35)
+(37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58)
+()
+(2,3,4,5,6)
+(21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45)
+()
+()
+()
+()
+()
+((1,6),(2,7),(3,8),(4,9),(5,10))
+((1,11),(2,12),(3,13),(4,14),(5,15))
+((11,1),(12,2),(13,3),(14,4),(15,5))
+((11,36),(12,37),(13,38),(14,39),(15,40),(16,41),(17,42),(18,43),(19,44),(20,45),(21,46),(22,47),(23,48),(24,49),(25,50),(26,51),(27,52),(28,53),(29,54),(30,55),(31,56),(32,57),(33,58),(34,59),(35,60))

tests/run/tuple-tests/tuple-concat.scala

@@ -1,21 +1,12 @@
 
-object Test extends App {
+def concat(): Unit = {
   val emptyTuple: Tuple = ()
   val tuple1: Tuple = ("1", "2", "3", "4", "5")
   val tuple2: Tuple = ("6", "7", "8", "9", "10")
   val tupleXXL1: Tuple = ("11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "30", "31", "32", "33", "34", "35")
   val tupleXXL2: Tuple = ("36", "37", "38", "39", "40", "41", "42", "43", "44", "45", "46", "47", "48", "49", "50", "51", "52", "53", "54", "55", "56", "57", "58", "59", "60")
 
-  // Try all possible kinds of concatenations (small === <=22):
-  // empty + empty
-  // small + empty
-  // empty + small
-  // xxl + empty
-  // empty + xxl
-  // small + small
-  // small + xxl
-  // xxl + small
-  // xxl + xxl
+  // All possible combinations of concatenating two tuples
   println(emptyTuple ++ emptyTuple)
   println(emptyTuple ++ tuple1)
   println(tuple1 ++ emptyTuple)

tests/run/tuple-tests/tuple-cons.scala

@@ -0,0 +1,13 @@
+
+def cons(): Unit = {
+  val emptyTuple: Tuple = ()
+  val tuple: Tuple = ("1", "2", "3", "4", "5")
+  val tupleXXL: Tuple = ("11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "30", "31", "32", "33", "34", "35")
+  val tuple22: Tuple = ("36", "37", "38", "39", "40", "41", "42", "43", "44", "45", "46", "47", "48", "49", "50", "51", "52", "53", "54", "55", "56", "57")
+
+  // Test all possible combinations of making
+  println("head" *: emptyTuple)
+  println("head" *: tuple)
+  println("head" *: tupleXXL)
+  println("head" *: tuple22)
+}

tests/run/tuple-tests/tuple-map.scala

@@ -0,0 +1,17 @@
+
+def map(): Unit = {
+  val emptyTuple: Tuple = ()
+  val tuple: Tuple = ("1", "2", "3", "4", "5")
+  val tupleXXL: Tuple = ("11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "30", "31", "32", "33", "34", "35")
+
+  type Id[X] = X
+  val f: [t] => t => Id[t] = [t] => (x: t) => {
+    val str = x.asInstanceOf[String]
+    str.updated(0, (str(0) + 1).toChar).asInstanceOf[t]
+  }
+
+  // Test all possible combinations of making
+  println(emptyTuple.map(f))
+  println(tuple.map(f))
+  println(tupleXXL.map(f))
+}

tests/run/tuple-tests/tuple-tail.scala

@@ -0,0 +1,13 @@
+
+def tail(): Unit = {
+  val singletonTuple: NonEmptyTuple = Tuple1("59")
+  val tuple: NonEmptyTuple = ("1", "2", "3", "4", "5")
+  val tupleXXL: NonEmptyTuple = ("11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "30", "31", "32", "33", "34", "35")
+  val tuple23: NonEmptyTuple = ("36", "37", "38", "39", "40", "41", "42", "43", "44", "45", "46", "47", "48", "49", "50", "51", "52", "53", "54", "55", "56", "57", "58")
+
+  // Test all possible combinations of making
+  println(singletonTuple.tail)
+  println(tuple.tail)
+  println(tupleXXL.tail)
+  println(tuple23.tail)
+}

tests/run/tuple-tests/tuple-tests.scala

@@ -0,0 +1,8 @@
+
+object Test extends App {
+  concat()
+  cons()
+  tail()
+  map()
+  zip()
+}

tests/run/tuple-tests/tuple-zip.scala

@@ -0,0 +1,20 @@
+
+def zip(): Unit = {
+  val emptyTuple: Tuple = ()
+  val tuple1: Tuple = ("1", "2", "3", "4", "5")
+  val tuple2: Tuple = ("6", "7", "8", "9", "10")
+  val tupleXXL1: Tuple = ("11", "12", "13", "14", "15", "16", "17", "18", "19", "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "30", "31", "32", "33", "34", "35")
+  val tupleXXL2: Tuple = ("36", "37", "38", "39", "40", "41", "42", "43", "44", "45", "46", "47", "48", "49", "50", "51", "52", "53", "54", "55", "56", "57", "58", "59", "60")
+
+  // All possible combinations of zipping two tuples
+  println(emptyTuple zip emptyTuple)
+  println(emptyTuple zip tuple1)
+  println(tuple1 zip emptyTuple)
+  println(tupleXXL1 zip emptyTuple)
+  println(emptyTuple zip tupleXXL1)
+  println(tuple1 zip tuple2)
+  println(tuple1 zip tupleXXL1)
+  println(tupleXXL1 zip tuple1)
+  println(tupleXXL1 zip tupleXXL2)
+}
+