report(value: Int, label: Text) () { dever.io.println(label) }

chunk(event: dever.io.ReadEvent.Chunk(bytes)) () { dever.io.println("chunk") }
chunk(event: dever.io.ReadEvent.Failed(message)) () { fail(dever.io.ReadEvent.Failed(message)) }

sendOne(value: Int, target: Channel<Int>) () { send(target, value) }

add(value: Int, state: Int) (next: Int) pure { next = value + state }

bad(value: Int) () { dever.task.sleep(-1) }

badSync(value: Int) () { fail(dever.io.ReadEvent.Failed("sync worker")) }

failing(values: AsyncStream<Int>) () { parallelEach(bad, values, 2) }

observed(value: dever.time.SleepResult.Done) (answer: Bool) recover("观察并行失败") { answer = false }
observed(value: dever.time.SleepResult.Failed(message)) (answer: Bool) recover("观察并行失败") { answer = length(message) > 0 }

syncVerify() (answer: Bool) { parallelEach(report, [1, 2, 3, 4], 2, "sync")
 parallelEach(report, dever.bytes.fromText("AB"), 2, "byte")
 answer = true }

workerVerify() (answer: Bool) { label = "worker"
 borrowed = reportMany([1, 2, 3, 4], label)
 values = [1, 2]
 parallelEach(report, values, 2, int.toText(length(append(values, 3))))
 answer = borrowed and label == "worker" }

reportMany(values: List<Int>, label: Text) (answer: Bool) {
 dever.task.sleep(0)
 parallelEach(report, values, 2, label)
 answer = length(label) > 0
}

streamVerify() (answer: Bool) {
 file = dever.io.create("PARALLEL_FIXTURE_PATH")
 dever.io.write(file, dever.bytes.fromText("ABCD"))
 dever.io.close(file)
 file = dever.io.open("PARALLEL_FIXTURE_PATH")
 values = dever.io.chunks(file, 1)
 parallelEach(chunk, values, 2)
 dever.io.close(file)
 answer = true
}

asyncVerify() (answer: Bool) { target = channel(Int, 4)
 parallelEach(sendOne, [1, 2, 3, 4], 2, target)
 close(target)
 total = reduce(add, stream(target), 0)
 bytes_target = channel(Int, 2)
 parallelEach(sendOne, dever.bytes.fromText("AB"), 2, bytes_target)
 close(bytes_target)
 bytes_total = reduce(add, stream(bytes_target), 0)
 answer = total == 10 and bytes_total == 131 }

nestedSend(value: Int, target: Channel<Int>) () { parallelEach(sendOne, [value], 1, target) }

nestedVerify() (answer: Bool) {
 target = channel(Int, 4)
 each(nestedSend, [1, 2, 3, 4], target)
 close(target)
 answer = reduce(add, stream(target), 0) == 10
}

sourceFailure() (answer: Bool) { source = channel(Int, 1)
 send(source, 1)
 values = stream(source)
 failure = observed(result(failing(values)))
 remaining = reduce(add, values, 0)
 send(source, 2)
 received = receive(source)
 answer = failure and remaining == 0 and received == 2 }

syncFailure() () { parallelEach(badSync, [1, 2, 3], 2) }

syncInvalid() () { parallelEach(report, [], 0, "unused") }

asyncInvalid() () { parallelEach(sendOne, [], 65537, channel(Int, 1)) }

workerInvalid() () { dever.task.sleep(0)
 parallelEach(report, [], 257, "unused") }

blocked(value: Int, signal: Channel<Int>) () { send(signal, value)
 dever.task.sleep(60000) }

cancelConsumer(values: AsyncStream<Int>, signal: Channel<Int>) () { parallelEach(blocked, values, 1, signal) }

cancelVerify() (answer: Bool) { source = channel(Int, 2)
 send(source, 1)
 send(source, 2)
 close(source)
 values = stream(source)
 signal = channel(Int, 1)
 pending = run(cancelConsumer(values, signal))
 started = receive(signal)
 stop(pending)
 remaining = reduce(add, values, 0)
 unpulled = receive(source)
 answer = started == 1 and remaining == 0 and unpulled == 2 }