77 lines
2.3 KiB
Text
77 lines
2.3 KiB
Text
# text_test.ludic - text written into a kept buffer, and interned: one string per distinct text
|
|
import "ludic.base"
|
|
program TextTest {
|
|
numbers float
|
|
test "a buffer takes text, numbers and a pattern, and cuts at its end rather than past it" {
|
|
let sb = sb_new(64)
|
|
sb_add(sb, "day ")
|
|
sb_int(sb, 42)
|
|
sb_add(sb, " at ")
|
|
sb_int2(sb, 7)
|
|
sb_byte(sb, 58)
|
|
sb_int2(sb, 5)
|
|
let tb = strs_new(16)
|
|
expect_eq(sb_intern(sb, tb), "day 42 at 07:05")
|
|
sb_clear(sb)
|
|
sb_int(sb, -310)
|
|
sb_add(sb, " ")
|
|
sb_int(sb, 0)
|
|
expect_eq(sb_intern(sb, tb), "-310 0")
|
|
sb_clear(sb)
|
|
sb_pat(sb, "[{1}] {2}: {3} minutes - room for {4} more", "E", "Trout", "4", "2")
|
|
expect_eq(sb_intern(sb, tb), "[E] Trout: 4 minutes - room for 2 more")
|
|
let small = sb_new(16)
|
|
sb_add(small, "a line longer than its buffer")
|
|
expect_eq(sb_len(small), 16)
|
|
}
|
|
test "the same bytes intern to the one string, made once, up to the cap (past it is Mem.over, a failure)" {
|
|
let sb = sb_new(32)
|
|
let tb = strs_new(3)
|
|
sb_add(sb, "08:03")
|
|
let a = sb_intern(sb, tb)
|
|
sb_clear(sb)
|
|
sb_add(sb, "08:0")
|
|
sb_int(sb, 3)
|
|
let b = sb_intern(sb, tb)
|
|
expect_eq(strs_count(tb), 1)
|
|
let ap: pointer = a
|
|
let bp: pointer = b
|
|
expect(ap == bp)
|
|
for i in 0 .. 2 {
|
|
sb_clear(sb)
|
|
sb_int(sb, i)
|
|
expect_eq(sb_intern(sb, tb), string(i))
|
|
}
|
|
expect_eq(strs_count(tb), 3)
|
|
sb_clear(sb)
|
|
sb_add(sb, "08:03")
|
|
let c: pointer = sb_intern(sb, tb)
|
|
expect(c == ap)
|
|
}
|
|
test "a ring hands out its slots in turn, written in place, and makes nothing after it is made" {
|
|
let r = tr_new(3, 32)
|
|
let sb = sb_new(64)
|
|
sb_add(sb, "first")
|
|
let a = tr_put(r, sb)
|
|
expect_eq(a, "first")
|
|
sb_clear(sb)
|
|
sb_add(sb, "second")
|
|
let b = tr_put(r, sb)
|
|
expect_eq(b, "second")
|
|
expect_eq(a, "first")
|
|
let before = Os.heap_bytes()
|
|
for i in 0 .. 1000 {
|
|
sb_clear(sb)
|
|
sb_add(sb, "line ")
|
|
sb_int(sb, i)
|
|
tr_put(r, sb)
|
|
}
|
|
if before > 0 { expect(Os.heap_bytes() <= before) }
|
|
sb_clear(sb)
|
|
sb_add(sb, "a line far longer than the slot it has to go into")
|
|
expect_eq(len(tr_put(r, sb)), 31)
|
|
let ap: pointer = a
|
|
let back: pointer = tr_put(r, sb)
|
|
expect(ap == back or tr_slots(r) == 3)
|
|
}
|
|
}
|