Add tuple tests to tck

tck/src/main/x/tck.x

@@ -12,5 +12,8 @@ module tck.xtclang.org {
 
 //        constructors.Reflect r = new constructors.Reflect();
 //        r.testAssertChain();
+
+//        tuple.Basic t = new tuple.Basic();
+//        t.testSlice();
     }
 }

tck/src/main/x/tck/array/Basic.x

@@ -2,7 +2,7 @@
  * Very basic array tests.
  */
 class Basic {
-    
+
     // -----------------------------
     // Create; set; get; size
     @Test
@@ -82,13 +82,13 @@ class Basic {
     }
 
     @Test
-    void mutImteralInts() {
+    void mutConstInts() {
         Int[] array = [0, 1];
         assert array.mutability == Constant;
     }
 
     @Test
-    void mutDefaultFixed() {
+    void mutDefaultInts() {
         Int[] array = new Int[2];
         assert array.mutability == Fixed;
     }
@@ -111,7 +111,7 @@ class Basic {
         assert array.mutability == Fixed;
     }
 
-    
+
     // -----------------------------
     // Plus add, delete, create allowing mutation
     @Test
@@ -177,7 +177,6 @@ class Basic {
         assert slice[2] == "four";
     }
 
-
     // -----------------------------
 
     @Test
@@ -210,10 +209,10 @@ class Basic {
         array = array.delete(1);
         assert array.mutability == Constant;
     }
-    
+
     // -----------------------------
     // Remove, delete
-    
+
     @Test
     void deleteUnordered() {
         Int[] array = new Int[].addAll([7, 2, 5, 21, 13, 42]);

tck/src/main/x/tck/tuple/Basic.x

@@ -0,0 +1,66 @@
+/**
+ * Basic tuple tests.
+ */
+class Basic {
+
+    @Test
+    void testConstAccess() {
+        Tuple<String, String, Int> t = ("hello", "world", 17);
+        assert t[0] == "hello";
+        assert t[2] == 17;
+    }
+
+    @Test
+    void testIndexAccess() {
+        Tuple t = ("hello", Int:17);
+        for (Int i : 0 ..< t.size) {
+            switch (i) {
+            case 0:
+                assert t[i].as(String) == "hello";
+                break;
+            case 1:
+                assert t[i].as(Int) == 17;
+                break;
+            }
+        }
+    }
+
+    @Test
+    void testEquality() {
+        static String BYE() = "goodbye";
+        Int    four = 4;
+        String now  = "now";
+
+        Tuple<String, Map<Int, String>> t1 = ("goodbye", [4="now"]);
+        Tuple<String, Map<Int, String>> t2 = Tuple:(BYE(), [four=now]);
+        assert t1 == t2;
+
+        Tuple<Int, String, Char> t3 = (1, "big", '?');
+        Tuple t4 = Tuple:().add(Int:1).add("big").add('?');
+        assert t3 == t4;
+    }
+
+    @Test
+    void testVoidConv() {
+        private static void getVoid() {}
+
+        Tuple tv = getVoid();
+        assert tv.size == 0;
+    }
+
+    @Test
+    void testIntConv() {
+        private static Int getInt() = 4;
+
+        Tuple<Int> ti = getInt();
+        assert ti.size == 1 && ti[0] == 4;
+    }
+
+    @Test
+    void testSlice() {
+        Int three = 3;
+        Tuple<Int, String, String, Char> t = (three, "blind", "mice", '!');
+        Tuple<String, String, Char> s = t[1..3];
+        assert s[three-1].as(Char) == s[2] == '!';
+    }
+}