Uncomment recently-no-longer-failing std.deque tests. Add a few arbitrary-access checks.

1 files changed, 74 insertions, 30 deletions

diff --git a/src/test/run-pass/lib-deque.rs b/src/test/run-pass/lib-deque.rs
index c7516e3d..ecd8bc44 100644
--- a/src/test/run-pass/lib-deque.rs
+++ b/src/test/run-pass/lib-deque.rs
@@ -35,8 +35,25 @@ fn test_simple() {
   log i;
   check (i == 17);
 
-  /* FIXME (issue #138):  Test d.get() once it no longer causes
-   * segfault. */
+  check (d.size() == 0u);
+  d.add_back(3);
+  check (d.size() == 1u);
+  d.add_front(2);
+  check (d.size() == 2u);
+  d.add_back(4);
+  check (d.size() == 3u);
+  d.add_front(1);
+  check (d.size() == 4u);
+
+  log d.get(0);
+  log d.get(1);
+  log d.get(2);
+  log d.get(3);
+
+  check (d.get(0) == 1);
+  check (d.get(1) == 2);
+  check (d.get(2) == 3);
+  check (d.get(3) == 4);
 }
 
 fn test_boxes(@int a, @int b, @int c, @int d) {
@@ -57,13 +74,25 @@ fn test_boxes(@int a, @int b, @int c, @int d) {
   check (deq.pop_back() == c);
   check (deq.pop_back() == a);
 
-  /* FIXME (issue #138):  Test d.get() once it no longer causes
-   * segfault. */
+  check (deq.size() == 0u);
+  deq.add_back(c);
+  check (deq.size() == 1u);
+  deq.add_front(b);
+  check (deq.size() == 2u);
+  deq.add_back(d);
+  check (deq.size() == 3u);
+  deq.add_front(a);
+  check (deq.size() == 4u);
+
+  check (deq.get(0) == a);
+  check (deq.get(1) == b);
+  check (deq.get(2) == c);
+  check (deq.get(3) == d);
 }
 
-type eqfn[T] = fn(&T a, &T b) -> bool;
+type eqfn[T] = fn(T a, T b) -> bool;
 
-fn test_parameterized[T](eqfn[T] e, &T a, &T b, &T c, &T d) {
+fn test_parameterized[T](eqfn[T] e, T a, T b, T c, T d) {
   let deque.t[T] deq = deque.create[T]();
   check (deq.size() == 0u);
   deq.add_front(a);
@@ -81,8 +110,20 @@ fn test_parameterized[T](eqfn[T] e, &T a, &T b, &T c, &T d) {
   check (e(deq.pop_back(), c));
   check (e(deq.pop_back(), a));
 
-  /* FIXME (issue #138):  Test d.get() once it no longer causes
-   * segfault. */
+  check (deq.size() == 0u);
+  deq.add_back(c);
+  check (deq.size() == 1u);
+  deq.add_front(b);
+  check (deq.size() == 2u);
+  deq.add_back(d);
+  check (deq.size() == 3u);
+  deq.add_front(a);
+  check (deq.size() == 4u);
+
+  check (e(deq.get(0), a));
+  check (e(deq.get(1), b));
+  check (e(deq.get(2), c));
+  check (e(deq.get(3), d));
 }
 
 type taggy = tag(one(int), two(int, int), three(int, int, int));
@@ -94,15 +135,15 @@ type taggypar[T] = tag(onepar(int),
 type reccy = rec(int x, int y, taggy t);
 
 fn main() {
-  fn inteq(&int a, &int b) -> bool {
+  fn inteq(int a, int b) -> bool {
     ret a == b;
   }
 
-  fn intboxeq(&@int a, &@int b) -> bool {
+  fn intboxeq(@int a, @int b) -> bool {
     ret a == b;
   }
 
-  fn taggyeq(&taggy a, &taggy b) -> bool {
+  fn taggyeq(taggy a, taggy b) -> bool {
     alt (a) {
       case (one(a1)) {
         alt (b) {
@@ -125,7 +166,7 @@ fn main() {
     }
   }
 
-  fn taggypareq[T](&taggypar[T] a, &taggypar[T] b) -> bool {
+  fn taggypareq[T](taggypar[T] a, taggypar[T] b) -> bool {
     alt (a) {
       case (onepar[T](a1)) {
         alt (b) {
@@ -150,65 +191,68 @@ fn main() {
     }
   }
 
-  fn reccyeq(&reccy a, &reccy b) -> bool {
+  fn reccyeq(reccy a, reccy b) -> bool {
     ret (a.x == b.x && a.y == b.y && taggyeq(a.t, b.t));
   }
 
-  log "test simple";
+  log "*** starting";
+
+  log "*** test simple";
   test_simple();
+  log "*** end test simple";
 
   /*
    * FIXME: Causes "Invalid read of size 4" under valgrind.
 
-  log "test boxes";
+  log "*** test boxes";
   test_boxes(@5, @72, @64, @175);
+  log "*** end test boxes";
 
    */
 
   log "test parameterized: int";
-  let eqfn[int] eq1 = bind inteq(_, _);
+  let eqfn[int] eq1 = inteq;
   test_parameterized[int](eq1, 5, 72, 64, 175);
 
   /*
    * FIXME: Appears to segfault after an upcall_grow_task
 
-  log "test parameterized: @int";
-  let eqfn[@int] eq2 = bind intboxeq(_, _);
+  log "*** test parameterized: @int";
+  let eqfn[@int] eq2 = intboxeq;
   test_parameterized[@int](eq2, @5, @72, @64, @175);
+  log "*** end test parameterized @int";
 
-   */
+  */
 
   log "test parameterized: taggy";
-  let eqfn[taggy] eq3 = bind taggyeq(_, _);
+  let eqfn[taggy] eq3 = taggyeq;
   test_parameterized[taggy](eq3,
                             one(1), two(1, 2), three(1, 2, 3), two(17, 42));
 
   /*
-   * FIXME: Segfault.
+   * FIXME: Segfault.  Also appears to be caused only after upcall_grow_task
 
-  log "test parameterized: taggypar[int]";
-  let eqfn[taggypar[int]] eq4 = bind taggypareq[int](_, _);
+  log "*** test parameterized: taggypar[int]";
+  let eqfn[taggypar[int]] eq4 = taggypareq[int];
   test_parameterized[taggypar[int]](eq4,
                                     onepar[int](1),
                                     twopar[int](1, 2),
                                     threepar[int](1, 2, 3),
                                     twopar[int](17, 42));
+  log "*** end test parameterized: taggypar[int]";
 
    */
 
-  /*
-   * FIXME: Segfault.
-
-  log "test parameterized: reccy";
+  log "*** test parameterized: reccy";
   let reccy reccy1 = rec(x=1, y=2, t=one(1));
   let reccy reccy2 = rec(x=345, y=2, t=two(1, 2));
   let reccy reccy3 = rec(x=1, y=777, t=three(1, 2, 3));
   let reccy reccy4 = rec(x=19, y=252, t=two(17, 42));
-  let eqfn[reccy] eq5 = bind reccyeq(_, _);
+  let eqfn[reccy] eq5 = reccyeq;
   test_parameterized[reccy](eq5,
                             reccy1, reccy2, reccy3, reccy4);
+  log "*** end test parameterized: reccy";
 
-   */
 
-  log "done";
+  log "*** done";
 }