Initial Dever 0.0.1

test/rust/fixtures/parallel.dever

@@ -0,0 +1,99 @@
+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 }