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]))
}