verify() (ok: Bool) {
  file = dever.io.open("input")
  invalid = creationFailed(result(dever.io.chunks(file, 0)))
  stream = dever.io.chunks(file, 2)
  alias = stream
  head = reduceUntil(take, stream, 0)
  tail = reduce(count, alias, 0)
  end = reduce(count, stream, 0)
  close(alias)
  close(stream)
  file_end = dever.io.read(file, 1)
  dever.io.close(file)
  closed = creationFailed(result(dever.io.chunks(file, 1)))
  file_two = dever.io.open("input")
  broken = dever.io.chunks(file_two, 2)
  dever.io.close(file_two)
  terminal = reduce(observe, broken, 0)
  terminal_end = reduce(observe, broken, 0)
  file_three = dever.io.open("input")
  stopped = dever.io.chunks(file_three, 2)
  each(stopReading, stopped, stopped)
  remaining = dever.io.read(file_three, 99)
  file_four = dever.io.open("input")
  interrupted = dever.io.chunks(file_four, 2)
  failed = consumeFailed(result(consume(interrupted)))
  after_failure = reduce(count, interrupted, 0)
  ok = invalid and closed and head == 2 and tail == 4 and end == 0 and file_end == dever.io.ReadState.End and terminal == 1000 and terminal_end == 0 and remaining == dever.io.ReadState.Read(dever.bytes.fromText("cdef")) and failed and after_failure == 4
}

count(event: dever.io.ReadEvent.Chunk(bytes), state: Int) (next: Int) {
  next = state + dever.bytes.length(bytes)
}
count(event: dever.io.ReadEvent.Failed(message), state: Int) (next: Int) {
  fail(dever.io.ReadEvent.Failed(message))
}

take(event: dever.io.ReadEvent, state: Int) (next: Int, stop: Bool) {
  next = count(event, state)
  stop = true
}

observe(event: dever.io.ReadEvent.Chunk(bytes), state: Int) (next: Int) recover("test observes terminal read failure") {
  next = state + dever.bytes.length(bytes)
}
observe(event: dever.io.ReadEvent.Failed(message), state: Int) (next: Int) recover("test observes terminal read failure") {
  next = state + 1000
}

creationFailed(value: dever.io.ReadStreamResult.Streaming(stream)) (ok: Bool) recover("test expects invalid stream construction") {
  close(stream)
  ok = false
}
creationFailed(value: dever.io.ReadStreamResult.Failed(message)) (ok: Bool) recover("test expects invalid stream construction") {
  ok = length(message) > 0
}

stopReading(event: dever.io.ReadEvent.Chunk(bytes), stream: Stream<dever.io.ReadEvent>) () {
  close(stream)
}
stopReading(event: dever.io.ReadEvent.Failed(message), stream: Stream<dever.io.ReadEvent>) () {
  fail(dever.io.ReadEvent.Failed(message))
}

abort(event: dever.io.ReadEvent.Chunk(bytes)) () {
  fail(dever.io.ReadResult.Failed("handler stopped"))
}
abort(event: dever.io.ReadEvent.Failed(message)) () {
  fail(dever.io.ReadResult.Failed(message))
}

consume(stream: Stream<dever.io.ReadEvent>) (state: dever.io.ReadState) {
  each(abort, stream)
  state = dever.io.ReadState.End
}

consumeFailed(value: dever.io.ReadResult.Done(state)) (ok: Bool) recover("test observes handler failure without closing an external stream alias") {
  ok = false
}
consumeFailed(value: dever.io.ReadResult.Failed(message)) (ok: Bool) recover("test observes handler failure without closing an external stream alias") {
  ok = message == "handler stopped"
}