197 lines
8.0 KiB
Plaintext
197 lines
8.0 KiB
Plaintext
increment(item: Int) (answer: Int) {
|
|
answer = item + 1
|
|
}
|
|
|
|
add(item: Int, state: Int) (next: Int) {
|
|
next = state + item
|
|
}
|
|
|
|
stopAdd(item: Int, state: Int) (next: Int, stop: Bool) {
|
|
next = state + item
|
|
stop = item == 128
|
|
}
|
|
|
|
total(bytes: Bytes) (answer: Int) {
|
|
answer = reduce(add, bytes, 0)
|
|
}
|
|
|
|
incremented(bytes: Bytes) (answer: List<Int>) {
|
|
answer = each(increment, bytes)
|
|
}
|
|
|
|
encode(text: Text) (answer: Bytes) {
|
|
answer = dever.bytes.fromText(text)
|
|
}
|
|
|
|
decode(bytes: Bytes) (answer: Text) {
|
|
answer = dever.bytes.toText(bytes)
|
|
}
|
|
|
|
convert(values: List<Int>) (answer: Bytes) {
|
|
answer = dever.bytes.fromInts(values)
|
|
}
|
|
|
|
middle(bytes: Bytes) (answer: Bytes) {
|
|
answer = dever.bytes.slice(bytes, 1, length(bytes) - 1)
|
|
}
|
|
|
|
join(bytes: Bytes) (answer: Bytes) {
|
|
answer = dever.bytes.concat(bytes, bytes)
|
|
}
|
|
|
|
copyBytes(bytes: Bytes) (answer: Bytes) {
|
|
answer = dever.bytes.slice(bytes, 0, length(bytes))
|
|
}
|
|
|
|
identity(bytes: Bytes) (answer: Bytes) { answer = bytes }
|
|
|
|
roundtrip(text: Text) (answer: Text) {
|
|
answer = dever.bytes.toText(dever.bytes.fromText(text))
|
|
}
|
|
|
|
bufferFailed(result: dever.bytes.BufferResult.Ready(bytes)) (answer: Bool) recover("verify expected conversion failures") {
|
|
answer = false
|
|
}
|
|
bufferFailed(result: dever.bytes.BufferResult.Failed(message)) (answer: Bool) recover("verify expected conversion failures") {
|
|
answer = message == "byte value must be between 0 and 255" or message == "invalid byte slice range"
|
|
}
|
|
|
|
decodeFailed(result: dever.bytes.DecodeResult.Decoded(text)) (answer: Bool) recover("verify expected conversion failures") {
|
|
answer = false
|
|
}
|
|
decodeFailed(result: dever.bytes.DecodeResult.Failed(message)) (answer: Bool) recover("verify expected conversion failures") {
|
|
answer = message == "invalid UTF-8"
|
|
}
|
|
|
|
lengthOrZero(bytes: Bytes) (answer: Int) {
|
|
answer = length(bytes)
|
|
}
|
|
lengthOrZero(bytes: null) (answer: Int) {
|
|
answer = -1
|
|
}
|
|
|
|
verify() (answer: Bool) {
|
|
bytes = convert([0, 127, 128, 255])
|
|
answer = length(bytes) == 4 and dever.bytes.length(bytes) == 4
|
|
answer = answer and dever.bytes.at(bytes, 0) == 0 and dever.bytes.at(bytes, 3) == 255
|
|
answer = answer and dever.bytes.at(bytes, -1) == null and dever.bytes.at(bytes, 4) == null
|
|
answer = answer and dever.bytes.at(bytes, 9223372036854775807) == null
|
|
answer = answer and total(bytes) == 510 and incremented(bytes) == [1, 128, 129, 256]
|
|
answer = answer and reduceUntil(stopAdd, bytes, 1) == 256
|
|
answer = answer and total(convert([])) == 0 and length(incremented(convert([]))) == 0
|
|
answer = answer and reduce(add, bytes, -510) == 0
|
|
answer = answer and reduce(add, bytes, 9223372036854775297) == 9223372036854775807
|
|
answer = answer and reduce(add, convert([]), 9223372036854775807) == 9223372036854775807
|
|
answer = answer and lengthOrZero(convert([])) == 0 and lengthOrZero(null) == -1
|
|
answer = answer and middle(bytes) == convert([127, 128])
|
|
answer = answer and dever.bytes.slice(bytes, 4, 4) == convert([])
|
|
answer = answer and bufferFailed(result(convert([-1]))) and bufferFailed(result(convert([256])))
|
|
answer = answer and bufferFailed(result(dever.bytes.slice(bytes, 2, 1)))
|
|
answer = answer and bufferFailed(result(dever.bytes.slice(bytes, -1, 0)))
|
|
answer = answer and bufferFailed(result(dever.bytes.slice(bytes, 0, 5)))
|
|
answer = answer and decodeFailed(result(decode(convert([255]))))
|
|
answer = answer and decodeFailed(result(decode(convert([192, 128]))))
|
|
answer = answer and decodeFailed(result(decode(convert([237, 160, 128]))))
|
|
answer = answer and decodeFailed(result(decode(convert([226, 130]))))
|
|
text = "雪🙂"
|
|
answer = answer and length(encode(text)) == 7 and roundtrip(text) == text
|
|
answer = answer and roundtrip("") == ""
|
|
texts = ["雪🙂", "", "a"]
|
|
encoded = each(dever.bytes.fromText, texts)
|
|
answer = answer and texts == ["雪🙂", "", "a"]
|
|
answer = answer and each(dever.bytes.toText, encoded) == texts
|
|
answer = answer and each(dever.bytes.toText, each(dever.bytes.fromText, ["雪🙂", "", "a"])) == texts
|
|
answer = answer and length(each(dever.bytes.fromText, [])) == 0
|
|
answer = answer and each(dever.bytes.toText, each(dever.bytes.fromText, text.split("雪,\u{0},🙂", ","))) == ["雪", "\u{0}", "🙂"]
|
|
answer = answer and each(dever.bytes.toText, each(dever.bytes.fromText, text.split("雪🙂", ""))) == ["雪", "🙂"]
|
|
answer = answer and each(dever.bytes.toText, each(dever.bytes.fromText, text.split(",x,", ","))) == ["", "x", ""]
|
|
answer = answer and length(each(dever.bytes.fromText, text.split("", ""))) == 0
|
|
answer = answer and each(dever.bytes.toText, [convert([0]), convert([97])]) == ["\u{0}", "a"]
|
|
answer = answer and encode(decode(convert([97, 0, 98]))) == convert([97, 0, 98])
|
|
combined = join(bytes)
|
|
answer = answer and combined == convert([0, 127, 128, 255, 0, 127, 128, 255])
|
|
answer = answer and bytes == convert([0, 127, 128, 255])
|
|
prefix = "雪\u{0}🙂"
|
|
saved_prefix = prefix
|
|
expected_prefix = convert([233, 155, 170, 0, 240, 159, 153, 130])
|
|
prefixed_bytes = prefixed(bytes)
|
|
answer = answer and prefixed_bytes == dever.bytes.concat(expected_prefix, bytes)
|
|
answer = answer and prefixed(convert([])) == expected_prefix
|
|
answer = answer and dever.bytes.concat(dever.bytes.fromText(""), bytes) == bytes
|
|
answer = answer and dever.bytes.concat(dever.bytes.fromText(prefix), bytes) == prefixed_bytes
|
|
answer = answer and prefix == saved_prefix and bytes == convert([0, 127, 128, 255])
|
|
seed = convert([1, 2])
|
|
saved = seed
|
|
joined = reduce(joinPart, [convert([0, 255]), convert([]), convert([3])], seed)
|
|
answer = answer and joined == convert([1, 2, 0, 255, 3]) and saved == convert([1, 2])
|
|
answer = answer and reduce(joinPart, [], bytes) == bytes
|
|
answer = answer and reduce(joinPart, [bytes, bytes], convert([])) == combined
|
|
answer = answer and reduce(joinPart, stream([convert([1]), convert([]), convert([255])]), convert([])) == convert([1, 255])
|
|
answer = answer and dever.bytes.toText(reduce(joinPart, [encode("a"), encode("雪")], encode("开始"))) == "开始a雪"
|
|
answer = answer and reduce(joinPart, [], encode("")) == convert([])
|
|
answer = answer and joinedText("雪\u{0}🙂", seed) == dever.bytes.concat(seed, expected_prefix)
|
|
answer = answer and joinedText("", seed) == seed and seed == saved
|
|
answer = answer and joinedReplaced("雪🙂", seed) == dever.bytes.concat(dever.bytes.concat(seed, encode("雪🙂")), seed)
|
|
}
|
|
|
|
joinPart(item: Bytes, state: Bytes) (answer: Bytes) { answer = dever.bytes.concat(state, item) }
|
|
|
|
prefixed(bytes: Bytes) (answer: Bytes) {
|
|
answer = dever.bytes.concat(dever.bytes.fromText("雪\u{0}🙂"), bytes)
|
|
}
|
|
|
|
suffixOnce() (bytes: Bytes) {
|
|
dever.io.println("suffix")
|
|
bytes = convert([0, 255])
|
|
}
|
|
|
|
concatOrderEntry() (answer: Bool) {
|
|
bytes = dever.bytes.concat(dever.bytes.fromText("雪\u{0}🙂"), suffixOnce())
|
|
answer = bytes == convert([233, 155, 170, 0, 240, 159, 153, 130, 0, 255])
|
|
}
|
|
|
|
concatArgumentEntry() (answer: Bytes) {
|
|
answer = dever.bytes.concat(dever.bytes.fromText("雪\u{0}"), convert([256]))
|
|
}
|
|
|
|
concatLeftErrorEntry() (answer: Bytes) {
|
|
answer = dever.bytes.concat(dever.bytes.fromText(decode(convert([255]))), convert([256]))
|
|
}
|
|
|
|
invalidEntry() (answer: Text) {
|
|
answer = decode(convert([255]))
|
|
}
|
|
|
|
invalidListEntry() (answer: List<Text>) {
|
|
answer = each(dever.bytes.toText, [convert([97]), convert([255])])
|
|
}
|
|
|
|
overflowEntry() (answer: Int) {
|
|
answer = reduce(add, convert([1]), 9223372036854775807)
|
|
}
|
|
|
|
argumentEntry() (answer: dever.bytes.DecodeResult) {
|
|
answer = result(decode(convert([256])))
|
|
}
|
|
|
|
joinedText(text: Text, seed: Bytes) (answer: Bytes) {
|
|
parts = each(dever.bytes.fromText, text.split(text, ""))
|
|
answer = reduce(joinPart, parts, seed)
|
|
}
|
|
|
|
joinedReplaced(text: Text, seed: Bytes) (answer: Bytes) {
|
|
parts = each(dever.bytes.fromText, text.split(text, ""))
|
|
first = reduce(joinPart, parts, seed)
|
|
parts = [seed]
|
|
answer = reduce(joinPart, parts, first)
|
|
}
|
|
|
|
joinedSeedErrorEntry() (answer: Bytes) {
|
|
answer = joinedSeedError("雪🙂")
|
|
}
|
|
|
|
joinedSeedError(text: Text) (answer: Bytes) {
|
|
parts = each(dever.bytes.fromText, text.split(text, ""))
|
|
answer = reduce(joinPart, parts, convert([256]))
|
|
}
|