// -*- rust -*- use std; import std::deque; fn test_simple() { let deque::t[int] d = deque::create[int](); assert (d.size() == 0u); d.add_front(17); d.add_front(42); d.add_back(137); assert (d.size() == 3u); d.add_back(137); assert (d.size() == 4u); log d.peek_front(); assert (d.peek_front() == 42); log d.peek_back(); assert (d.peek_back() == 137); let int i = d.pop_front(); log i; assert (i == 42); i = d.pop_back(); log i; assert (i == 137); i = d.pop_back(); log i; assert (i == 137); i = d.pop_back(); log i; assert (i == 17); assert (d.size() == 0u); d.add_back(3); assert (d.size() == 1u); d.add_front(2); assert (d.size() == 2u); d.add_back(4); assert (d.size() == 3u); d.add_front(1); assert (d.size() == 4u); log d.get(0); log d.get(1); log d.get(2); log d.get(3); assert (d.get(0) == 1); assert (d.get(1) == 2); assert (d.get(2) == 3); assert (d.get(3) == 4); } fn test_boxes(@int a, @int b, @int c, @int d) { let deque::t[@int] deq = deque::create[@int](); assert (deq.size() == 0u); deq.add_front(a); deq.add_front(b); deq.add_back(c); assert (deq.size() == 3u); deq.add_back(d); assert (deq.size() == 4u); assert (deq.peek_front() == b); assert (deq.peek_back() == d); assert (deq.pop_front() == b); assert (deq.pop_back() == d); assert (deq.pop_back() == c); assert (deq.pop_back() == a); assert (deq.size() == 0u); deq.add_back(c); assert (deq.size() == 1u); deq.add_front(b); assert (deq.size() == 2u); deq.add_back(d); assert (deq.size() == 3u); deq.add_front(a); assert (deq.size() == 4u); assert (deq.get(0) == a); assert (deq.get(1) == b); assert (deq.get(2) == c); assert (deq.get(3) == d); } type eqfn[T] = fn(&T a, &T b) -> bool; fn test_parameterized[T](eqfn[T] e, &T a, &T b, &T c, &T d) { let deque::t[T] deq = deque::create[T](); assert (deq.size() == 0u); deq.add_front(a); deq.add_front(b); deq.add_back(c); assert (deq.size() == 3u); deq.add_back(d); assert (deq.size() == 4u); assert (e(deq.peek_front(), b)); assert (e(deq.peek_back(), d)); assert (e(deq.pop_front(), b)); assert (e(deq.pop_back(), d)); assert (e(deq.pop_back(), c)); assert (e(deq.pop_back(), a)); assert (deq.size() == 0u); deq.add_back(c); assert (deq.size() == 1u); deq.add_front(b); assert (deq.size() == 2u); deq.add_back(d); assert (deq.size() == 3u); deq.add_front(a); assert (deq.size() == 4u); assert (e(deq.get(0), a)); assert (e(deq.get(1), b)); assert (e(deq.get(2), c)); assert (e(deq.get(3), d)); } tag taggy { one(int); two(int, int); three(int, int, int); } tag taggypar[T] { onepar(int); twopar(int, int); threepar(int, int, int); } type reccy = rec(int x, int y, taggy t); fn main() { fn inteq(&int a, &int b) -> bool { ret a == b; } fn intboxeq(&@int a, &@int b) -> bool { ret a == b; } fn taggyeq(&taggy a, &taggy b) -> bool { alt (a) { case (one(?a1)) { alt (b) { case (one(?b1)) { ret a1 == b1; } case (_) { ret false; } } } case (two(?a1, ?a2)) { alt (b) { case (two(?b1, ?b2)) { ret (a1 == b1 && a2 == b2); } case (_) { ret false; } } } case (three(?a1, ?a2, ?a3)) { alt (b) { case (three(?b1, ?b2, ?b3)) { ret (a1 == b1 && a2 == b2 && a3 == b3); } case (_) { ret false; } } } } } fn taggypareq[T](&taggypar[T] a, &taggypar[T] b) -> bool { alt (a) { case (onepar[T](?a1)) { alt (b) { case (onepar[T](?b1)) { ret a1 == b1; } case (_) { ret false; } } } case (twopar[T](?a1, ?a2)) { alt (b) { case (twopar[T](?b1, ?b2)) { ret (a1 == b1 && a2 == b2); } case (_) { ret false; } } } case (threepar[T](?a1, ?a2, ?a3)) { alt (b) { case (threepar[T](?b1, ?b2, ?b3)) { ret (a1 == b1 && a2 == b2 && a3 == b3); } case (_) { ret false; } } } } } fn reccyeq(&reccy a, &reccy b) -> bool { ret (a.x == b.x && a.y == b.y && taggyeq(a.t, b.t)); } log "*** starting"; log "*** test simple"; test_simple(); log "*** end test simple"; log "*** test boxes"; test_boxes(@5, @72, @64, @175); log "*** end test boxes"; log "test parameterized: int"; let eqfn[int] eq1 = inteq; test_parameterized[int](eq1, 5, 72, 64, 175); 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 = taggyeq; test_parameterized[taggy](eq3, one(1), two(1, 2), three(1, 2, 3), two(17, 42)); /* * FIXME: Segfault. Also appears to be caused only after upcall_grow_task 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]"; */ 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 = reccyeq; test_parameterized[reccy](eq5, reccy1, reccy2, reccy3, reccy4); log "*** end test parameterized: reccy"; log "*** done"; }