147 lines
3.2 KiB
Go
147 lines
3.2 KiB
Go
package typeset
|
|
|
|
import "slices"
|
|
import "testing"
|
|
|
|
func rl (run rune) runeLayout { return runeLayout { run: run } }
|
|
func tk (kind tokenKind, value string) token {
|
|
tok := token {
|
|
kind: kind,
|
|
}
|
|
runeValue := []rune(value)
|
|
tok.runes = make([]runeLayout, len(runeValue))
|
|
for index, run := range runeValue {
|
|
tok.runes[index] = rl(run)
|
|
}
|
|
return tok
|
|
}
|
|
func compareTokens (got, correct []token) bool {
|
|
for index, tok := range got {
|
|
correctTok := correct[index]
|
|
isCorrect :=
|
|
correctTok.kind == tok.kind &&
|
|
correctTok.width == tok.width &&
|
|
slices.Equal(correctTok.runes, tok.runes)
|
|
if !isCorrect { return false }
|
|
}
|
|
return true
|
|
}
|
|
func logTokens (test *testing.T, tokens []token) {
|
|
for _, token := range tokens {
|
|
test.Logf("- %-40v | %v", token, token.runes)
|
|
}
|
|
}
|
|
|
|
func TestParseString (test *testing.T) {
|
|
// ---- processing ----
|
|
runes, tokens := parseString("hello \rworld!\nfoo\n\r\nbar\tbaz\t\tsomething")
|
|
|
|
// ---- correct data ----
|
|
correctRunes := []runeLayout {
|
|
rl('h'),
|
|
rl('e'),
|
|
rl('l'),
|
|
rl('l'),
|
|
rl('o'),
|
|
rl(' '),
|
|
rl('\r'),
|
|
rl('w'),
|
|
rl('o'),
|
|
rl('r'),
|
|
rl('l'),
|
|
rl('d'),
|
|
rl('!'),
|
|
rl('\n'),
|
|
rl('f'),
|
|
rl('o'),
|
|
rl('o'),
|
|
rl('\n'),
|
|
rl('\r'),
|
|
rl('\n'),
|
|
rl('b'),
|
|
rl('a'),
|
|
rl('r'),
|
|
rl('\t'),
|
|
rl('b'),
|
|
rl('a'),
|
|
rl('z'),
|
|
rl('\t'),
|
|
rl('\t'),
|
|
rl('s'),
|
|
rl('o'),
|
|
rl('m'),
|
|
rl('e'),
|
|
rl('t'),
|
|
rl('h'),
|
|
rl('i'),
|
|
rl('n'),
|
|
rl('g'),
|
|
}
|
|
correctTokens := []token {
|
|
tk(tokenKindWord, "hello"),
|
|
tk(tokenKindSpace, " "),
|
|
tk(tokenKindWord, "\rworld!"),
|
|
tk(tokenKindLineBreak, "\n"),
|
|
tk(tokenKindWord, "foo"),
|
|
tk(tokenKindLineBreak, "\n"),
|
|
tk(tokenKindLineBreak, "\r\n"),
|
|
tk(tokenKindWord, "bar"),
|
|
tk(tokenKindTab, "\t"),
|
|
tk(tokenKindWord, "baz"),
|
|
tk(tokenKindTab, "\t\t"),
|
|
tk(tokenKindWord, "something"),
|
|
}
|
|
|
|
// ---- testing ----
|
|
if len(runes) != len(correctRunes) {
|
|
test.Logf("len(runes) != len(correctRunes): %d, %d", len(runes), len(correctRunes))
|
|
test.Log(runes)
|
|
test.Log(correctRunes)
|
|
test.FailNow()
|
|
}
|
|
if !slices.Equal(runes, correctRunes) {
|
|
test.Log("runes != correctRunes:")
|
|
test.Log(runes)
|
|
test.Log(correctRunes)
|
|
test.FailNow()
|
|
}
|
|
if len(tokens) != len(correctTokens) {
|
|
test.Logf("len(tokens) != len(correctTokens): %d, %d", len(tokens), len(correctTokens))
|
|
test.Log("GOT")
|
|
logTokens(test, tokens)
|
|
test.Log("CORRECT")
|
|
logTokens(test, correctTokens)
|
|
test.FailNow()
|
|
}
|
|
if !compareTokens(tokens, correctTokens) {
|
|
test.Log("tokens != correctTokens:")
|
|
test.Log("GOT")
|
|
logTokens(test, tokens)
|
|
test.Log("CORRECT")
|
|
logTokens(test, correctTokens)
|
|
test.FailNow()
|
|
}
|
|
test.Logf("changing first rune from %c to x", runes[0].run)
|
|
runes[0].run = 'x'
|
|
test.Logf("first rune is now %c", runes[0].run)
|
|
tokenRune := tokens[0].runes[0].run
|
|
if tokenRune != 'x' {
|
|
test.Fatalf (
|
|
"tokens does not reference the same memory as runes after changing runes: %c, %c",
|
|
runes[0].run, tokenRune)
|
|
}
|
|
runeIndex := 0
|
|
for tokenIndex, token := range tokens {
|
|
tokenRunePtr := &token.runes[0]
|
|
runePtr := &runes[runeIndex]
|
|
|
|
if runePtr != tokenRunePtr {
|
|
test.Fatalf (
|
|
"tokens[%d] does not reference runes[%d]: %p, %p",
|
|
tokenIndex, runeIndex, tokenRunePtr, runePtr)
|
|
}
|
|
|
|
runeIndex += len(token.runes)
|
|
}
|
|
}
|