102 lines
3.3 KiB
Plaintext
102 lines
3.3 KiB
Plaintext
type Count {
|
|
expected: Id
|
|
total: Int
|
|
}
|
|
|
|
encode(text: Text) (answer: Id) {
|
|
answer = dever.id.fromText(text)
|
|
}
|
|
|
|
decode(value: Id) (answer: Text) {
|
|
answer = dever.id.toText(value)
|
|
}
|
|
|
|
roundtrip(text: Text) (answer: Text) {
|
|
answer = dever.id.toText(dever.id.fromText(text))
|
|
}
|
|
|
|
encodeAll(texts: List<Text>) (answer: List<Id>) {
|
|
answer = each(dever.id.fromText, texts)
|
|
}
|
|
|
|
countMatch(value: Id, state: Count) (next: Count) {
|
|
next = state
|
|
next.total = state.total + matching(value == state.expected)
|
|
}
|
|
|
|
matching(value: true) (answer: Int) { answer = 1 }
|
|
matching(value: false) (answer: Int) { answer = 0 }
|
|
|
|
countEqual(values: List<Id>, expected: Id) (answer: Int) {
|
|
state = reduce(countMatch, values, Count { expected = expected
|
|
total = 0 })
|
|
answer = state.total
|
|
}
|
|
|
|
readKey(key: Id, values: Map<Id, Int>) (answer: Int) {
|
|
answer = present(get(values, key))
|
|
}
|
|
|
|
present(value: Int) (answer: Int) { answer = value }
|
|
present(value: null) (answer: Int) { answer = 0 }
|
|
|
|
lookup(values: Map<Id, Int>, keys: List<Id>) (answer: Int) {
|
|
answer = sum(readKey, keys, values)
|
|
}
|
|
|
|
insert(text: Text, state: Map<Id, Int>) (next: Map<Id, Int>) {
|
|
next = put(state, dever.id.fromText(text), length(text))
|
|
}
|
|
|
|
buildMap(texts: List<Text>) (answer: Map<Id, Int>) {
|
|
answer = reduce(insert, texts, {})
|
|
}
|
|
|
|
buildEntries(texts: List<Text>) (answer: List<MapEntry<Id, Int>>) {
|
|
answer = entries(buildMap(texts))
|
|
}
|
|
|
|
optionalId(value: Id) (answer: Text) { answer = dever.id.toText(value) }
|
|
optionalId(value: null) (answer: Text) { answer = "missing" }
|
|
|
|
duplicate(left: Text, right: Text) (answer: Map<Id, Int>) {
|
|
answer = { dever.id.fromText(left) = 1
|
|
dever.id.fromText(right) = 2 }
|
|
}
|
|
|
|
duplicateEntry() (answer: Map<Id, Int>) {
|
|
answer = duplicate("same", "same")
|
|
}
|
|
|
|
failureEntry() (answer: Id) {
|
|
answer = dever.id.fromText(dever.bytes.toText(dever.bytes.fromInts([255])))
|
|
}
|
|
|
|
verify() (answer: Bool) {
|
|
original = encode("雪🙂")
|
|
alias = original
|
|
original = encode("changed")
|
|
answer = decode(alias) == "雪🙂" and decode(original) == "changed"
|
|
answer = answer and encode("same") == encode("same") and encode("Same") != encode("same")
|
|
answer = answer and encode("é") != encode("é") and roundtrip(" 雪\n\t") == " 雪\n\t"
|
|
answer = answer and optionalId(encode("")) == "" and optionalId(null) == "missing"
|
|
nul = dever.bytes.toText(dever.bytes.fromInts([97, 0, 98]))
|
|
answer = answer and roundtrip(nul) == nul
|
|
ids = encodeAll(["a", "a", "b"])
|
|
answer = answer and countEqual(ids, encode("a")) == 2 and countEqual([], encode("")) == 0
|
|
answer = answer and first(ids) == encode("a") and first(encodeAll([])) == null
|
|
state = Count { expected = alias
|
|
total = 2 }
|
|
changed = state
|
|
changed.expected = encode("new")
|
|
answer = answer and decode(state.expected) == "雪🙂" and decode(changed.expected) == "new"
|
|
values = buildMap(["雪", "a", "雪", "🙂"])
|
|
updated = put(values, encode("a"), 9)
|
|
removed = remove(updated, encode("雪"))
|
|
answer = answer and get(values, encode("a")) == 1 and get(updated, encode("a")) == 9
|
|
answer = answer and length(removed) == 2 and get(removed, encode("雪")) == null
|
|
answer = answer and lookup(values, encodeAll(["a", "missing", "雪"])) == 2
|
|
answer = answer and buildEntries(["a", "b", "a"]) == entries(buildMap(["a", "b"]))
|
|
answer = answer and values != buildMap(["a", "雪", "🙂"])
|
|
}
|