Un-revert "Use different syntax for checks that matter to typestate", fixing the problem.

This reverts commit d08b443fffb1181d8d45ae5d061412f202dd4118.

1 files changed, 65 insertions, 65 deletions

diff --git a/src/test/run-pass/lib-map.rs b/src/test/run-pass/lib-map.rs
index 4c8afa7d..abd2041e 100644
--- a/src/test/run-pass/lib-map.rs
+++ b/src/test/run-pass/lib-map.rs
@@ -28,19 +28,19 @@ fn test_simple() {
   let map.hashmap[uint, uint] hm_uu = map.mk_hashmap[uint, uint](hasher_uint,
                                                                  eqer_uint);
 
-  check (hm_uu.insert(10u, 12u));
-  check (hm_uu.insert(11u, 13u));
-  check (hm_uu.insert(12u, 14u));
+  assert (hm_uu.insert(10u, 12u));
+  assert (hm_uu.insert(11u, 13u));
+  assert (hm_uu.insert(12u, 14u));
 
-  check (hm_uu.get(11u) == 13u);
-  check (hm_uu.get(12u) == 14u);
-  check (hm_uu.get(10u) == 12u);
+  assert (hm_uu.get(11u) == 13u);
+  assert (hm_uu.get(12u) == 14u);
+  assert (hm_uu.get(10u) == 12u);
 
-  check (!hm_uu.insert(12u, 14u));
-  check (hm_uu.get(12u) == 14u);
+  assert (!hm_uu.insert(12u, 14u));
+  assert (hm_uu.get(12u) == 14u);
 
-  check (!hm_uu.insert(12u, 12u));
-  check (hm_uu.get(12u) == 12u);
+  assert (!hm_uu.insert(12u, 12u));
+  assert (hm_uu.get(12u) == 12u);
 
 
   let str ten = "ten";
@@ -51,21 +51,21 @@ fn test_simple() {
 
   let map.hashmap[str, uint] hm_su = map.mk_hashmap[str, uint](hasher_str,
                                                                eqer_str);
-  check (hm_su.insert("ten", 12u));
-  check (hm_su.insert(eleven, 13u));
-  check (hm_su.insert("twelve", 14u));
+  assert (hm_su.insert("ten", 12u));
+  assert (hm_su.insert(eleven, 13u));
+  assert (hm_su.insert("twelve", 14u));
 
-  check (hm_su.get(eleven) == 13u);
+  assert (hm_su.get(eleven) == 13u);
 
-  check (hm_su.get("eleven") == 13u);
-  check (hm_su.get("twelve") == 14u);
-  check (hm_su.get("ten") == 12u);
+  assert (hm_su.get("eleven") == 13u);
+  assert (hm_su.get("twelve") == 14u);
+  assert (hm_su.get("ten") == 12u);
 
-  check (!hm_su.insert("twelve", 14u));
-  check (hm_su.get("twelve") == 14u);
+  assert (!hm_su.insert("twelve", 14u));
+  assert (hm_su.get("twelve") == 14u);
 
-  check (!hm_su.insert("twelve", 12u));
-  check (hm_su.get("twelve") == 12u);
+  assert (!hm_su.insert("twelve", 12u));
+  assert (hm_su.get("twelve") == 12u);
 
 
   log "uint -> str";
@@ -73,19 +73,19 @@ fn test_simple() {
   let map.hashmap[uint, str] hm_us = map.mk_hashmap[uint, str](hasher_uint,
                                                                eqer_uint);
 
-  check (hm_us.insert(10u, "twelve"));
-  check (hm_us.insert(11u, "thirteen"));
-  check (hm_us.insert(12u, "fourteen"));
+  assert (hm_us.insert(10u, "twelve"));
+  assert (hm_us.insert(11u, "thirteen"));
+  assert (hm_us.insert(12u, "fourteen"));
 
-  check (_str.eq(hm_us.get(11u), "thirteen"));
-  check (_str.eq(hm_us.get(12u), "fourteen"));
-  check (_str.eq(hm_us.get(10u), "twelve"));
+  assert (_str.eq(hm_us.get(11u), "thirteen"));
+  assert (_str.eq(hm_us.get(12u), "fourteen"));
+  assert (_str.eq(hm_us.get(10u), "twelve"));
 
-  check (!hm_us.insert(12u, "fourteen"));
-  check (_str.eq(hm_us.get(12u), "fourteen"));
+  assert (!hm_us.insert(12u, "fourteen"));
+  assert (_str.eq(hm_us.get(12u), "fourteen"));
 
-  check (!hm_us.insert(12u, "twelve"));
-  check (_str.eq(hm_us.get(12u), "twelve"));
+  assert (!hm_us.insert(12u, "twelve"));
+  assert (_str.eq(hm_us.get(12u), "twelve"));
 
 
   log "str -> str";
@@ -93,19 +93,19 @@ fn test_simple() {
   let map.hashmap[str, str] hm_ss = map.mk_hashmap[str, str](hasher_str,
                                                              eqer_str);
 
-  check (hm_ss.insert(ten, "twelve"));
-  check (hm_ss.insert(eleven, "thirteen"));
-  check (hm_ss.insert(twelve, "fourteen"));
+  assert (hm_ss.insert(ten, "twelve"));
+  assert (hm_ss.insert(eleven, "thirteen"));
+  assert (hm_ss.insert(twelve, "fourteen"));
 
-  check (_str.eq(hm_ss.get("eleven"), "thirteen"));
-  check (_str.eq(hm_ss.get("twelve"), "fourteen"));
-  check (_str.eq(hm_ss.get("ten"), "twelve"));
+  assert (_str.eq(hm_ss.get("eleven"), "thirteen"));
+  assert (_str.eq(hm_ss.get("twelve"), "fourteen"));
+  assert (_str.eq(hm_ss.get("ten"), "twelve"));
 
-  check (!hm_ss.insert("twelve", "fourteen"));
-  check (_str.eq(hm_ss.get("twelve"), "fourteen"));
+  assert (!hm_ss.insert("twelve", "fourteen"));
+  assert (_str.eq(hm_ss.get("twelve"), "fourteen"));
 
-  check (!hm_ss.insert("twelve", "twelve"));
-  check (_str.eq(hm_ss.get("twelve"), "twelve"));
+  assert (!hm_ss.insert("twelve", "twelve"));
+  assert (_str.eq(hm_ss.get("twelve"), "twelve"));
 
   log "*** finished test_simple";
 }
@@ -135,7 +135,7 @@ fn test_growth() {
 
   let uint i = 0u;
   while (i < num_to_insert) {
-    check (hm_uu.insert(i, i * i));
+    assert (hm_uu.insert(i, i * i));
     log "inserting " + _uint.to_str(i, 10u)
       + " -> " + _uint.to_str(i * i, 10u);
     i += 1u;
@@ -147,12 +147,12 @@ fn test_growth() {
   while (i < num_to_insert) {
     log "get(" + _uint.to_str(i, 10u) + ") = "
       + _uint.to_str(hm_uu.get(i), 10u);
-    check (hm_uu.get(i) == i * i);
+    assert (hm_uu.get(i) == i * i);
     i += 1u;
   }
 
-  check (hm_uu.insert(num_to_insert, 17u));
-  check (hm_uu.get(num_to_insert) == 17u);
+  assert (hm_uu.insert(num_to_insert, 17u));
+  assert (hm_uu.get(num_to_insert) == 17u);
 
   log "-----";
 
@@ -162,7 +162,7 @@ fn test_growth() {
   while (i < num_to_insert) {
     log "get(" + _uint.to_str(i, 10u) + ") = "
       + _uint.to_str(hm_uu.get(i), 10u);
-    check (hm_uu.get(i) == i * i);
+    assert (hm_uu.get(i) == i * i);
     i += 1u;
   }
 
@@ -176,7 +176,7 @@ fn test_growth() {
 
   i = 0u;
   while (i < num_to_insert) {
-    check (hm_ss.insert(_uint.to_str(i, 2u), _uint.to_str(i * i, 2u)));
+    assert (hm_ss.insert(_uint.to_str(i, 2u), _uint.to_str(i * i, 2u)));
     log "inserting \"" + _uint.to_str(i, 2u)
       + "\" -> \"" + _uint.to_str(i * i, 2u) + "\"";
     i += 1u;
@@ -191,15 +191,15 @@ fn test_growth() {
       + "\") = \""
       + hm_ss.get(_uint.to_str(i, 2u)) + "\"";
 
-    check (_str.eq(hm_ss.get(_uint.to_str(i, 2u)),
+    assert (_str.eq(hm_ss.get(_uint.to_str(i, 2u)),
                    _uint.to_str(i * i, 2u)));
     i += 1u;
   }
 
-  check (hm_ss.insert(_uint.to_str(num_to_insert, 2u),
+  assert (hm_ss.insert(_uint.to_str(num_to_insert, 2u),
                       _uint.to_str(17u, 2u)));
 
-  check (_str.eq(hm_ss.get(_uint.to_str(num_to_insert, 2u)),
+  assert (_str.eq(hm_ss.get(_uint.to_str(num_to_insert, 2u)),
                  _uint.to_str(17u, 2u)));
 
   log "-----";
@@ -210,7 +210,7 @@ fn test_growth() {
   while (i < num_to_insert) {
     log "get(\"" + _uint.to_str(i, 2u) + "\") = \""
       + hm_ss.get(_uint.to_str(i, 2u)) + "\"";
-    check (_str.eq(hm_ss.get(_uint.to_str(i, 2u)),
+    assert (_str.eq(hm_ss.get(_uint.to_str(i, 2u)),
                    _uint.to_str(i * i, 2u)));
     i += 1u;
   }
@@ -230,9 +230,9 @@ fn test_removal() {
     ret (u / 2u) * 2u;
   }
 
-  check (hash(0u) == hash(1u));
-  check (hash(2u) == hash(3u));
-  check (hash(0u) != hash(2u));
+  assert (hash(0u) == hash(1u));
+  assert (hash(2u) == hash(3u));
+  assert (hash(0u) != hash(2u));
 
   let map.hashfn[uint] hasher = hash;
   let map.eqfn[uint] eqer = eq;
@@ -240,13 +240,13 @@ fn test_removal() {
 
   let uint i = 0u;
   while (i < num_to_insert) {
-    check (hm.insert(i, i * i));
+    assert (hm.insert(i, i * i));
     log "inserting " + _uint.to_str(i, 10u)
       + " -> " + _uint.to_str(i * i, 10u);
     i += 1u;
   }
 
-  check (hm.size() == num_to_insert);
+  assert (hm.size() == num_to_insert);
 
   log "-----";
   log "removing evens";
@@ -260,7 +260,7 @@ fn test_removal() {
     let util.option[uint] v = hm.remove(i);
     alt (v) {
       case (util.some[uint](u)) {
-        check (u == (i * i));
+        assert (u == (i * i));
       }
       case (util.none[uint]()) { fail; }
     }
@@ -273,7 +273,7 @@ fn test_removal() {
     i += 2u;
   }
 
-  check (hm.size() == (num_to_insert / 2u));
+  assert (hm.size() == (num_to_insert / 2u));
 
   log "-----";
 
@@ -281,7 +281,7 @@ fn test_removal() {
   while (i < num_to_insert) {
     log "get(" + _uint.to_str(i, 10u) + ") = "
       + _uint.to_str(hm.get(i), 10u);
-    check (hm.get(i) == i * i);
+    assert (hm.get(i) == i * i);
     i += 2u;
   }
 
@@ -296,7 +296,7 @@ fn test_removal() {
   while (i < num_to_insert) {
     log "get(" + _uint.to_str(i, 10u) + ") = "
       + _uint.to_str(hm.get(i), 10u);
-    check (hm.get(i) == i * i);
+    assert (hm.get(i) == i * i);
     i += 2u;
   }
 
@@ -304,13 +304,13 @@ fn test_removal() {
 
   i = 0u;
   while (i < num_to_insert) {
-    check (hm.insert(i, i * i));
+    assert (hm.insert(i, i * i));
     log "inserting " + _uint.to_str(i, 10u)
       + " -> " + _uint.to_str(i * i, 10u);
     i += 2u;
   }
 
-  check (hm.size() == num_to_insert);
+  assert (hm.size() == num_to_insert);
 
   log "-----";
 
@@ -318,7 +318,7 @@ fn test_removal() {
   while (i < num_to_insert) {
     log "get(" + _uint.to_str(i, 10u) + ") = "
       + _uint.to_str(hm.get(i), 10u);
-    check (hm.get(i) == i * i);
+    assert (hm.get(i) == i * i);
     i += 1u;
   }
 
@@ -329,13 +329,13 @@ fn test_removal() {
 
   log "-----";
 
-  check (hm.size() == num_to_insert);
+  assert (hm.size() == num_to_insert);
 
   i = 0u;
   while (i < num_to_insert) {
     log "get(" + _uint.to_str(i, 10u) + ") = "
       + _uint.to_str(hm.get(i), 10u);
-    check (hm.get(i) == i * i);
+    assert (hm.get(i) == i * i);
     i += 1u;
   }