63 lines
2.1 KiB
Text
63 lines
2.1 KiB
Text
# queue_test.ludic - Queue<T>: first in first out, drain empties, undrained queues are named.
|
|
# A generic call is not resolved inside a `test` body yet, so each case is a function.
|
|
import "ludic.base"
|
|
program QueueTest {
|
|
numbers float
|
|
property Caught { species: int = 0, weight: float = 0.0 }
|
|
|
|
function caught(sp: int, w: float) -> Caught {
|
|
let c = new Caught
|
|
c.species = sp
|
|
c.weight = w
|
|
return c
|
|
}
|
|
|
|
function fifo_case(base_st: mut BaseState) -> void {
|
|
let q: Queue<int> = queue_new(base_st, "ints")
|
|
q_push(base_st, q, 3)
|
|
q_push(base_st, q, 1)
|
|
q_push(base_st, q, 2)
|
|
expect_eq(q_len(q), 3)
|
|
let xs = q_drain(base_st, q)
|
|
expect_eq(len(xs), 3)
|
|
expect_eq(xs[0], 3)
|
|
expect_eq(xs[1], 1)
|
|
expect_eq(xs[2], 2)
|
|
expect_eq(q_len(q), 0)
|
|
expect_eq(len(q_drain(base_st, q)), 0)
|
|
}
|
|
|
|
function record_case(base_st: mut BaseState) -> void {
|
|
let q: Queue<Caught> = queue_new(base_st, "caught")
|
|
q_push(base_st, q, caught(2, 1.5))
|
|
q_push(base_st, q, caught(4, 0.25))
|
|
let cs = q_drain(base_st, q)
|
|
expect_eq(cs[1].species, 4)
|
|
expect(cs[0].weight == 1.5)
|
|
}
|
|
|
|
function clear_case(base_st: mut BaseState) -> void {
|
|
let q: Queue<string> = queue_new(base_st, "words")
|
|
q_push(base_st, q, "a")
|
|
q_clear(base_st, q)
|
|
expect_eq(q_len(q), 0)
|
|
}
|
|
|
|
function undrained_case(base_st: mut BaseState) -> void {
|
|
let a: Queue<int> = queue_new(base_st, "left_behind")
|
|
let b: Queue<int> = queue_new(base_st, "read")
|
|
q_push(base_st, a, 1)
|
|
q_push(base_st, b, 2)
|
|
q_drain(base_st, b)
|
|
let names = core_undrained(base_st)
|
|
expect_eq(len(names), 1)
|
|
expect(names[0] == "left_behind")
|
|
q_drain(base_st, a)
|
|
expect_eq(len(core_undrained(base_st)), 0)
|
|
}
|
|
|
|
test "a queue drains in the order it was pushed" (base_st: mut BaseState) { fifo_case(base_st) }
|
|
test "a queue holds records" (base_st: mut BaseState) { record_case(base_st) }
|
|
test "clear drops what is waiting" (base_st: mut BaseState) { clear_case(base_st) }
|
|
test "the undrained queues are named, and a drain clears the report" (base_st: mut BaseState) { undrained_case(base_st) }
|
|
}
|