[tests] remove tests moved to hxcoro

tests/misc/coroutines/.gitignore

@@ -1,2 +0,0 @@
-/test.js
-/test.js.map

tests/misc/coroutines/build-base.hxml

@@ -1,5 +0,0 @@
---class-path src
---library utest
---main Main
---debug
--D UTEST-PRINT-TESTS

tests/misc/coroutines/build-cpp.hxml

@@ -1,3 +0,0 @@
-build-base.hxml
--D HXCPP_CATCH_SEGV
---cpp bin/cpp

tests/misc/coroutines/build-eval.hxml

@@ -1,2 +0,0 @@
-build-base.hxml
---interp

tests/misc/coroutines/build-hl.hxml

@@ -1,3 +0,0 @@
-build-base.hxml
---hl bin/coro.hl
---cmd hl bin/coro.hl

tests/misc/coroutines/build-js.hxml

@@ -1,3 +0,0 @@
-build-base.hxml
---js bin/coro.js
---cmd node bin/coro.js

tests/misc/coroutines/build-jvm.hxml

@@ -1,3 +0,0 @@
-build-base.hxml
---jvm bin/coro.jar
---cmd java -jar bin/coro.jar

tests/misc/coroutines/build-lua.hxml

@@ -1,3 +0,0 @@
-build-base.hxml
---lua bin/coro.lua
---cmd lua bin/coro.lua

tests/misc/coroutines/build-neko.hxml

@@ -1,3 +0,0 @@
-build-base.hxml
---neko bin/coro.n
---cmd neko bin/coro.n

tests/misc/coroutines/build-php.hxml

@@ -1,3 +0,0 @@
-build-base.hxml
---php bin/php
---cmd php bin/php/index.php

tests/misc/coroutines/build-python.hxml

@@ -1,3 +0,0 @@
-build-base.hxml
---python bin/coro.py
---cmd python bin/coro.py

tests/misc/coroutines/src/AssertAsync.hx

@@ -1,25 +0,0 @@
-import haxe.coro.Coroutine;
-
-import haxe.ValueException;
-
-class AssertAsync {
-	@:coroutine
-	static function _raisesImpl(method:Coroutine<() -> Void>, type:Any) {
-		var typeDescr = type != null ? "exception of type " + Type.getClassName(type) : "exception";
-
-		try {
-			method();
-		} catch (ex:Dynamic) {
-			var ex = Std.isOfType(ex, ValueException) ? (cast ex:ValueException).value : (ex:Any);
-
-			return Assert.isTrue(Std.isOfType(ex, type), "expected " + typeDescr + " but it is "  + ex);
-		}
-
-		return Assert.fail('Exception not thrown');
-	}
-
-	@:coroutine
-	public static function raises(method:Coroutine<() -> Void>, type:Any) : Bool {
-		return _raisesImpl(method, type);
-	}
-}

tests/misc/coroutines/src/BaseCase.hx

@@ -1,19 +0,0 @@
-@:keepSub
-@:keep
-class BaseCase implements utest.ITest {
-	var dummy:String = '';
-
-	public function new() {}
-
-	public function setup() {
-		dummy = '';
-	}
-
-	function assert<T>(expected:Array<T>, generator:Iterator<T>, ?p:haxe.PosInfos) {
-		dummy = '';
-		for (it in generator) {
-			Assert.equals(expected.shift(), it, p);
-		}
-		Assert.equals(0, expected.length, p);
-	}
-}

tests/misc/coroutines/src/Helper.hx

@@ -1,6 +0,0 @@
-import haxe.coro.schedulers.VirtualTimeScheduler;
-
-@:coroutine
-function mapCalls<TArg,TRet>(args:Array<TArg>, f:Coroutine<TArg->TRet>):Array<TRet> {
-	return [for (arg in args) f(arg)];
-}

tests/misc/coroutines/src/ImmediateScheduler.hx

@@ -1,27 +0,0 @@
-import haxe.Timer;
-import haxe.Int64;
-import haxe.Exception;
-import haxe.coro.schedulers.Scheduler;
-import haxe.coro.schedulers.IScheduleObject;
-
-class ImmediateScheduler extends Scheduler {
-	public function new() {
-		super();
-	}
-
-	public function schedule(ms:Int64, f:() -> Void) {
-		if (ms != 0) {
-			throw new Exception('Only immediate scheduling is allowed in this scheduler');
-		}
-		f();
-		return null;
-	}
-
-	public function scheduleObject(obj:IScheduleObject) {
-		obj.onSchedule();
-	}
-
-	public function now() {
-		return Timer.milliseconds();
-	}
-}

tests/misc/coroutines/src/Main.hx

@@ -1,39 +0,0 @@
-import yield.*;
-
-function main() {
-
-	var cases = [
-		new TestBasic(),
-		new TestTricky(),
-		new TestControlFlow(),
-		new TestTryCatch(),
-		new TestHoisting(),
-		new TestMisc(),
-		new TestTexpr(),
-		#if !hl
-		new TestGenerator(),
-		#end
-		#if js
-		new TestJsPromise(),
-		#end
-		#if (!coroutine.throw && (jvm || cpp || eval))
-		new TestCallStack(),
-		#end
-	];
-
-	var runner = new utest.Runner();
-
-	for (eachCase in cases) {
-		runner.addCase(eachCase);
-	}
-	runner.addCases("issues");
-	runner.addCases("ds");
-	runner.addCases("concurrent");
-	runner.addCases("components");
-	runner.addCases("structured");
-	runner.addCases("features");
-	runner.addCases("schedulers");
-
-    utest.ui.Report.create(runner);
-    runner.run();
-}

tests/misc/coroutines/src/TestBasic.hx

@@ -1,76 +0,0 @@
-import haxe.Exception;
-import haxe.coro.schedulers.VirtualTimeScheduler;
-
-class TestBasic extends utest.Test {
-	function testSimple() {
-		Assert.equals(42, CoroRun.run(@:coroutine function run() {
-			return simple(42);
-		}));
-	}
-
-	function testErrorDirect() {
-		Assert.raises(() -> CoroRun.run(error), String);
-	}
-
-	function testErrorPropagation() {
-		@:coroutine function propagate() {
-			error();
-		}
-
-		Assert.raises(() -> CoroRun.run(propagate), String);
-	}
-
-	function testResumeWithError() {
-		@:coroutine function foo() {
-			suspend(cont -> {
-				cont.resume(null, new Exception(""));
-			});
-		}
-
-		Assert.raises(() -> CoroRun.run(foo), Exception);
-	}
-
-	function testUnnamedLocalCoroutines() {
-		final c1 = @:coroutine function () {
-			yield();
-
-			return 10;
-		};
-
-		Assert.equals(10, CoroRun.run(c1));
-	}
-
-	function testLocalTypeParameters() {
-		CoroRun.run(@:coroutine function f<T>():T {
-			return null;
-		});
-		Assert.pass(); // The test is that this doesn't cause an unbound type parameter
-	}
-
-	#if sys
-
-	function testDelay() {
-		final scheduler = new VirtualTimeScheduler();
-		final task      = CoroRun.with(scheduler).create(_ -> {
-			delay(500);
-		});
-
-		task.start();
-
-		scheduler.advanceTo(499);
-		Assert.isTrue(task.isActive());
-
-		scheduler.advanceTo(500);
-		Assert.isFalse(task.isActive());
-	}
-
-	#end
-
-	@:coroutine static function simple(arg:Int):Int {
-		return arg;
-	}
-
-	@:coroutine static function error() {
-		throw "nope";
-	}
-}

tests/misc/coroutines/src/TestCallStack.hx

@@ -1,88 +0,0 @@
-import haxe.CallStack;
-import haxe.Exception;
-import callstack.CallStackInspector;
-
-class TestCallStack extends utest.Test {
-	function test() {
-		try {
-			callstack.Bottom.entry();
-			Assert.fail("Exception expected");
-		} catch(e:haxe.exceptions.NotImplementedException) {
-			final stack = e.stack.asArray();
-			var inspector = new CallStackInspector(stack);
-			var r = inspector.inspect([
-				File('callstack/Top.hx'),
-					Line(4),
-					Line(8),
-					Line(12),
-				File('callstack/CoroUpper.hx'),
-					Line(8),
-					Line(6),
-					Line(6),
-					Line(6),
-					Line(6),
-					Line(15),
-				Skip('callstack/SyncMiddle.hx'),
-					Line(4),
-					Line(8),
-				File('callstack/CoroLower.hx'),
-					Line(6),
-				Skip('callstack/Bottom.hx'),
-					Line(4)
-			]);
-			checkFailure(stack, r);
-		}
-	}
-
-	function checkFailure(stack:Array<StackItem>, r:Null<CallStackInspectorFailure>) {
-		if (r == null) {
-			Assert.pass();
-		} else {
-			var i = 0;
-			var lines = stack.map(item -> '\t[${i++}] $item');
-			Assert.fail('${r.toString()}\n${lines.join("\n")}');
-		}
-	}
-
-	function testFooBazBaz() {
-		function checkStack(e:Exception) {
-			final stack = e.stack.asArray();
-			var inspector = new CallStackInspector(stack);
-			var r = inspector.inspect([
-				File('callstack/FooBarBaz.hx'),
-				#if cpp
-				// TODO: cpp has inaccurate positions which causes the top stack to be wrong
-				Line(6),
-				Line(12),
-				Line(12),
-				Line(16),
-				#else
-				Line(7),
-				Line(12),
-				#end
-				// TODO: sync stack doesn't work yet
-				// Line(16)
-			]);
-			checkFailure(stack, r);
-		}
-		try {
-			CoroRun.run(callstack.FooBarBaz.foo);
-			Assert.fail("Exception expected");
-		} catch(e:Exception) {
-			checkStack(e);
-		}
-
-		try {
-			CoroRun.runScoped(scope -> {
-				scope.async(scope -> {
-					scope.async(_ -> {
-						callstack.FooBarBaz.foo();
-					});
-				});
-			});
-			Assert.fail("Exception expected");
-		} catch (e:Exception) {
-			checkStack(e);
-		}
-	}
-}

tests/misc/coroutines/src/TestControlFlow.hx

@@ -1,124 +0,0 @@
-import Helper;
-
-import hxcoro.Coro.*;
-
-class TestControlFlow extends utest.Test {
-	function testIfThen() {
-		@:coroutine function f(x) {
-			if (x) return 1;
-			return 2;
-		}
-
-		Assert.same(CoroRun.run(@:coroutine function run() {
-			return mapCalls([ true, false ], f);
-		}), [ 1, 2 ]);
-	}
-
-	function testIfThenReturnNoValue() {
-		var v = null;
-		@:coroutine function f(x) {
-			v = 1;
-			if (x) {
-				return;
-			}
-			v = 2;
-		}
-		@:coroutine function f2(x) { f(x); return v; }
-
-		Assert.same(CoroRun.run(@:coroutine function run() {
-			return mapCalls([ true, false ], f2);
-		}), [ 1, 2 ]);
-	}
-
-	function testIfThenElse() {
-		@:coroutine function f(x) {
-			return if (x) 1 else 2;
-		}
-
-		Assert.same(CoroRun.run(@:coroutine function run() {
-			return mapCalls([ true, false ], f);
-		}), [ 1, 2 ]);
-	}
-
-	function testSwitchNoDefault() {
-		@:coroutine function f(x) {
-			switch (x) {
-				case 1: return "a";
-				case 2: return "b";
-				case 3: return "c";
-			}
-			return "d";
-		}
-
-		Assert.same(CoroRun.run(@:coroutine function run() {
-			return mapCalls([ 1, 2, 3, 4 ], f);
-		}), ["a", "b", "c", "d"]);
-	}
-
-	function testSwitchDefault() {
-		@:coroutine function f(x) {
-			switch (x) {
-				case 1: return "a";
-				case 2: return "b";
-				case 3: return "c";
-				default: return "d";
-			}
-			return "e";
-		}
-		Assert.same(CoroRun.run(@:coroutine function run() {
-			return mapCalls([ 1, 2, 3, 4 ], f);
-		}), ["a", "b", "c", "d"]);
-	}
-
-	function testLoop() {
-		@:coroutine function f(x) {
-			var results = [];
-			var i = 0;
-			while (i < 10) {
-				if (i == 5 && x == 1) break;
-				if (i == 6 && x == 2) { i++; continue; }
-				results.push(i);
-				i++;
-			}
-			return results;
-		}
-		Assert.same([
-			[0,1,2,3,4,5,6,7,8,9],
-			[0,1,2,3,4],
-			[0,1,2,3,4,5,7,8,9]
-		], CoroRun.run(@:coroutine function run() {
-			return mapCalls([ 0, 1, 2 ], f);
-		}));
-	}
-
-	function testRecursion() {
-		var maxIters = 3;
-		var counter = 0;
-
-		@:coroutine function foo() {
-			if (++counter < maxIters) {
-				foo();
-			}
-		}
-
-		CoroRun.run(foo);
-
-		Assert.equals(counter, maxIters);
-	}
-
-	function testSuspendingRecursion() {
-		var maxIters = 3;
-		var counter = 0;
-
-		@:coroutine function foo() {
-			if (++counter < maxIters) {
-				yield();
-				foo();
-			}
-		}
-
-		CoroRun.run(foo);
-
-		Assert.equals(counter, maxIters);
-	}
-}

tests/misc/coroutines/src/TestGenerator.hx

@@ -1,108 +0,0 @@
-import haxe.coro.schedulers.IScheduleObject;
-import haxe.Int64;
-import haxe.coro.schedulers.Scheduler;
-import hxcoro.task.CoroTask;
-import haxe.coro.context.Context;
-import haxe.Exception;
-
-private typedef Yield<T> = Coroutine<T->Void>;
-
-private function sequence<T>(f:Coroutine<Yield<T>->Void>):Iterator<T> {
-	var hasValue = false;
-	var nextValue:T = null;
-	var exception:Null<Exception> = null;
-
-	var nextStep = null;
-	final scope = new CoroTask(Context.create(new ImmediateScheduler()), CoroTask.CoroScopeStrategy);
-
-	@:coroutine function yield(value:T) {
-		nextValue = value;
-		hasValue = true;
-		suspend(cont -> {
-			nextStep = () -> {
-				hasValue = false;
-				cont.resume(null, null);
-				if (!scope.isActive()) {
-					exception = scope.getError();
-				}
-			}
-		});
-	}
-
-	nextStep = () -> {
-		f(yield, scope);
-		scope.start();
-	}
-
-	function hasNext() {
-		nextStep();
-		if (exception != null) {
-			throw exception;
-		}
-		return hasValue;
-	}
-	function next() {
-		return nextValue;
-	}
-
-	return {hasNext: hasNext, next: next};
-}
-
-class TestGenerator extends utest.Test {
-	function testSimple() {
-		var iter = sequence(yield -> {
-			yield(1);
-			yield(2);
-			yield(3);
-		});
-		Assert.same([1,2,3], [for (v in iter) v]);
-	}
-
-	function testTreeIter() {
-		@:coroutine function iterTreeRec<T>(yield:Yield<T>, tree:Tree<T>) {
-			yield(tree.leaf);
-			if (tree.left != null) iterTreeRec(yield, tree.left);
-			if (tree.right != null) iterTreeRec(yield, tree.right);
-		}
-
-		function iterTree<T>(tree:Tree<T>):Iterator<T> {
-			return sequence(yield -> iterTreeRec(yield, tree));
-		}
-
-		var tree:Tree<Int> = {
-			leaf: 1,
-			left: {
-				leaf: 2,
-				left: {leaf: 3},
-				right: {leaf: 4, left: {leaf: 5}},
-			},
-			right: {
-				leaf: 6,
-				left: {leaf: 7}
-			}
-		};
-
-		Assert.same([1,2,3,4,5,6,7], [for (v in iterTree(tree)) v]);
-	}
-
-	function testException() {
-		final result = [];
-		Assert.raises(() -> {
-			for (i in sequence(yield -> {
-				yield(1);
-				yield(2);
-				throw "oh no";
-				yield(3);
-			})) {
-				result.push(i);
-			}
-		});
-		Assert.same([1, 2], result);
-	}
-}
-
-private typedef Tree<T> = {
-	var leaf:T;
-	var ?left:Tree<T>;
-	var ?right:Tree<T>;
-}

tests/misc/coroutines/src/TestHoisting.hx

@@ -1,147 +0,0 @@
-import hxcoro.Coro.*;
-
-class TestHoisting extends utest.Test {
-    function testLocalVariable() {
-
-        @:coroutine function foo() {
-            var bar = 7;
-
-            yield();
-
-            return bar;
-        }
-
-        Assert.equals(7, CoroRun.run(foo));
-    }
-
-    function testModifyingLocalVariable() {
-        @:coroutine function foo() {
-            var bar = 7;
-
-            yield();
-
-            bar *= 2;
-
-            yield();
-
-            return bar;
-        }
-
-        Assert.equals(14, CoroRun.run(foo));
-    }
-
-    @:coroutine function fooTestArgument(v:Int) {
-        yield();
-
-        return v;
-    }
-
-    function testArgument() {
-        Assert.equals(7, CoroRun.run(() -> {
-            return fooTestArgument(7);
-        }));
-    }
-
-    function testLocalArgument() {
-        Assert.equals(7, CoroRun.run(() -> {
-            @:coroutine function foo(v:Int) {
-                yield();
-
-                return v;
-            }
-
-            return foo(7);
-        }));
-    }
-
-    @:coroutine function fooTestModifyingArgument(v:Int) {
-        yield();
-
-        v *= 2;
-
-        yield();
-
-        return v;
-    }
-
-    function testModifyingArgument() {
-        Assert.equals(14, CoroRun.run(() -> {
-            return fooTestModifyingArgument(7);
-        }));
-    }
-
-    function testModifyingLocalArgument() {
-        Assert.equals(14, CoroRun.run(() -> {
-            @:coroutine function foo(v:Int) {
-                yield();
-
-                v *= 2;
-
-                yield();
-
-                return v;
-            }
-
-            return foo(7);
-        }));
-    }
-
-    function testCapturingLocal() {
-        var i = 0;
-
-        CoroRun.run(() -> {
-            i = 7;
-            yield();
-            i *= 2;
-        });
-
-        Assert.equals(14, i);
-    }
-
-    function testMultiHoisting() {
-        Assert.equals(14, CoroRun.run(() -> {
-
-            var i = 0;
-
-            @:coroutine function foo() {
-                yield();
-
-                i = 7;
-            }
-
-            foo();
-
-            return i * 2;
-
-        }));
-    }
-
-    function testLoopHoisting() {
-        final expected = [1, 2, 3];
-        final actual   = [];
-
-        CoroRun.runScoped(node -> {
-            for (x in expected) {
-                node.async(_ -> {
-                    actual.push(x);
-                });
-            }
-        });
-
-        Assert.same(expected, actual);
-    }
-
-    function testUninitialisedVariable() {
-        Assert.equals(7, CoroRun.run(() -> {
-            var i;
-
-            yield();
-
-            i = 7;
-
-            yield();
-
-            return i;
-        }));
-    }
-}

tests/misc/coroutines/src/TestJsPromise.hx

@@ -1,89 +0,0 @@
-import js.lib.Error;
-import js.lib.Promise;
-
-using TestJsPromise.CoroTools;
-
-class CoroTools {
-	static public function start<T, E>(c:Coroutine<() -> T>, f:(T, E) -> Void) {
-		try {
-			f(CoroRun.run(c), null);
-		} catch(e:Dynamic) {
-			f(null, e);
-		}
-	}
-}
-
-@:coroutine
-private function await<T>(p:Promise<T>) {
-	suspend(cont -> p.then(r -> cont.resume(r, null), e -> cont.resume(null, e)));
-}
-
-private function promise<T>(c:Coroutine<()->T>):Promise<T> {
-	return new Promise((resolve,reject) -> c.start((result, error) -> if (error != null) reject(error) else resolve(result)));
-}
-
-class TestJsPromise extends utest.Test {
-	// function testAwait(async:Async) {
-	// 	var p = Promise.resolve(41);
-
-	// 	@:coroutine function awaiting() {
-	// 		var x = await(p);
-	// 		return x + 1;
-	// 	}
-
-	// 	awaiting.start((result,error) -> {
-	// 		Assert.equals(42, result);
-	// 		async.done();
-	// 	});
-	// }
-
-	function testPromise(async:Async) {
-		var p = promise(() -> 42);
-		p.then(result -> {
-			Assert.equals(42, result);
-			async.done();
-		});
-	}
-
-	// function testAsyncAwait(async:Async) {
-	// 	var p1 = Promise.resolve(41);
-
-	// 	var p2 = promise(() -> {
-	// 		var x = await(p1);
-	// 		return x + 1;
-	// 	});
-
-	// 	p2.then(result -> {
-	// 		Assert.equals(42, result);
-	// 		async.done();
-	// 	});
-	// }
-
-	// function testAwaitRejected(async:Async) {
-	// 	var p = Promise.reject("oh no");
-
-	// 	@:coroutine function awaiting() {
-	// 		var x = await(p);
-	// 		return x + 1;
-	// 	}
-
-	// 	awaiting.start((result,error) -> {
-	// 		Assert.equals("oh no", error);
-	// 		async.done();
-	// 	});
-	// }
-
-	function testThrowInPromise(async:Async) {
-		var p = promise(() -> throw new Error("oh no"));
-		p.then(
-			function(result) {
-				Assert.fail();
-			},
-			function(error) {
-				Assert.isOfType(error, Error);
-				Assert.equals("oh no", (error : Error).message);
-				async.done();
-			}
-		);
-	}
-}

tests/misc/coroutines/src/TestMisc.hx

@@ -1,13 +0,0 @@
-import hxcoro.Coro.*;
-
-class TestMisc extends utest.Test {
-    function testDebugMetadataLocalFunction() {
-        @:coroutine @:coroutine.debgu function foo() {
-            yield();
-        }
-
-        CoroRun.run(foo);
-
-        Assert.pass();
-    }
-}

tests/misc/coroutines/src/TestTexpr.hx

@@ -1,82 +0,0 @@
-import hxcoro.Coro.*;
-
-private class C<T> {
-	final value:T;
-
-	public function new(value:T) {
-		this.value = value;
-	}
-
-	@:coroutine public function await() {
-		return value;
-	}
-
-	@:coroutine public function awaitYield() {
-		yield();
-		return value;
-	}
-}
-
-function run<T>(f:Coroutine<() -> T>) {
-	return CoroRun.run(f);
-}
-
-class TestTexpr extends utest.Test {
-	function testField() {
-		var c = new C("foo");
-
-		Assert.equals("f", run(() -> c.await().charAt(0)));
-		Assert.equals("f", run(() -> c.awaitYield().charAt(0)));
-	}
-
-	function testOp() {
-		var c = new C(8);
-		Assert.equals(16, run(() -> c.await() + c.await()));
-		// extensively tested in Issue93
-	}
-
-	function testCall() {
-		function id<T>(v:T) {
-			return v;
-		}
-		var c = new C(id);
-		var d = new C("foo");
-		Assert.equals("foo", run(() -> c.await()(d.await())));
-		Assert.equals("foo", run(() -> c.awaitYield()(d.await())));
-		Assert.equals("foo", run(() -> c.await()(d.awaitYield())));
-		Assert.equals("foo", run(() -> c.awaitYield()(d.awaitYield())));
-	}
-
-	function testArray() {
-		var a = [];
-		var c = new C(a);
-		var d = new C("foo");
-		var e = new C(0);
-		run(() -> {
-			Assert.same(a, c.await());
-			Assert.equals("foo", c.await()[e.await()] = d.await());
-			Assert.equals("foo", c.await()[e.await()]);
-			a.resize(0);
-			Assert.equals("foo", c.awaitYield()[e.await()] = d.await());
-			Assert.equals("foo", c.awaitYield()[e.await()]);
-			a.resize(0);
-			Assert.equals("foo", c.await()[e.awaitYield()] = d.await());
-			Assert.equals("foo", c.await()[e.awaitYield()]);
-			a.resize(0);
-			Assert.equals("foo", c.await()[e.await()] = d.awaitYield());
-			Assert.equals("foo", c.await()[e.await()]);
-			a.resize(0);
-			Assert.equals("foo", c.awaitYield()[e.awaitYield()] = d.await());
-			Assert.equals("foo", c.awaitYield()[e.awaitYield()]);
-			a.resize(0);
-			Assert.equals("foo", c.awaitYield()[e.await()] = d.awaitYield());
-			Assert.equals("foo", c.awaitYield()[e.await()]);
-			a.resize(0);
-			Assert.equals("foo", c.await()[e.awaitYield()] = d.awaitYield());
-			Assert.equals("foo", c.await()[e.awaitYield()]);
-			a.resize(0);
-			Assert.equals("foo", c.awaitYield()[e.awaitYield()] = d.awaitYield());
-			Assert.equals("foo", c.awaitYield()[e.awaitYield()]);
-		});
-	}
-}

tests/misc/coroutines/src/TestTricky.hx

@@ -1,28 +0,0 @@
-class CoroFile {
-	public final file:String;
-
-	public function new(file) {
-		this.file = file;
-	}
-
-	@:coroutine public function write() {
-		return file;
-	}
-
-	@:coroutine public function almostWrite() {
-		return () -> file;
-	}
-}
-
-class TestTricky extends utest.Test {
-	function testCapturedThis() {
-		final file = new CoroFile("value");
-		Assert.equals("value", cast CoroRun.run(file.write));
-	}
-
-	function testPreviouslyCapturedThis() {
-		final file = new CoroFile("value");
-		final func : ()->String = cast CoroRun.run(file.almostWrite);
-		Assert.equals("value", func());
-	}
-}

tests/misc/coroutines/src/TestTryCatch.hx

@@ -1,274 +0,0 @@
-import hxcoro.Coro.*;
-import Helper;
-
-class TestTryCatch extends utest.Test {
-	function testTryCatch() {
-		Assert.same(["e1", "e2"], CoroRun.run(@:coroutine function run() {
-			return mapCalls([new E1(), new E2()], tryCatch);
-		}));
-	}
-
-	function testTryCatchFail() {
-		Assert.raises(() -> CoroRun.run(@:coroutine function run() {
-			return tryCatch(new E3());
-		}), E3);
-	}
-
-	function testTryCatchNonExc() {
-		Assert.same(["ne1", "ne2"], CoroRun.run(@:coroutine function run() {
-			return mapCalls([new NE1(), new NE2()], tryCatchNonExc);
-		}));
-	}
-
-	function testTryCatchNonExcFail() {
-		Assert.raises(() -> CoroRun.run(@:coroutine function run() {
-			return tryCatchNonExc(new NE3());
-		}), NE3);
-	}
-
-	function testTryCatchMixed() {
-		Assert.same(["e1", "e2", "ne1", "ne2"], CoroRun.run(@:coroutine function run() {
-			return mapCalls(([new E1(), new E2(), new NE1(), new NE2()] : Array<Dynamic>), tryCatchMixed);
-		}));
-	}
-
-	function testTryCatchMixedFail() {
-		Assert.raises(() -> CoroRun.run(@:coroutine function run() {
-			return tryCatchMixed("foo");
-		}), String);
-		Assert.raises(() -> CoroRun.run(@:coroutine function run() {
-			return tryCatchMixed(new E3());
-		}), E3);
-		Assert.raises(() -> CoroRun.run(@:coroutine function run() {
-			return tryCatchMixed(new NE3());
-		}), NE3);
-	}
-
-	function testTryCatchNoCatch() {
-		@:coroutine function f(yield:Coroutine<Int->Void>) {
-			var dummy = '1';
-			try {
-				dummy += '2';
-				yield(10);
-				dummy += '3';
-			} catch (e:Dynamic) {
-				dummy += '4';
-			}
-			dummy += '5';
-			return dummy;
-		}
-		var a = [];
-		Assert.equals("1235", CoroRun.run(() -> f(i -> a.push(i))));
-		Assert.same([10], a);
-		a = [];
-		Assert.equals("1245", CoroRun.run(() -> f(i -> throw i)));
-		Assert.same([], a);
-	}
-
-	function testTryCatchOneCatch() {
-		@:coroutine function f(yield:Coroutine<Int->Void>) {
-			var dummy = '1';
-			try {
-				dummy += '2';
-				throw 'Error!';
-				dummy += '3';
-			} catch (e:Dynamic) {
-				dummy += '4';
-				yield(10);
-				dummy += '5';
-			}
-			dummy += '6';
-			return dummy;
-		}
-		var a = [];
-		Assert.equals("12456", CoroRun.run(() -> f(i -> a.push(i))));
-		Assert.same([10], a);
-	}
-
-	function testTryCatchMultiCatch() {
-		@:coroutine function f(yield:Coroutine<Int->Void>, throwValue:Dynamic) {
-			var dummy = '1';
-			try {
-				dummy += '2';
-				throw throwValue;
-				dummy += '3';
-			} catch (e:String) {
-				dummy += '4';
-				yield(10);
-				dummy += '5';
-			} catch (e:Dynamic) {
-				dummy += '6';
-				yield(20);
-				dummy += '7';
-			}
-			dummy += '8';
-			return dummy;
-		}
-		var a = [];
-		Assert.equals("12458", CoroRun.run(() -> f(i -> a.push(i), 'Error')));
-		Assert.same([10], a);
-		a = [];
-		Assert.equals("12678", CoroRun.run(() -> f(i -> a.push(i), 123)));
-		Assert.same([20], a);
-	}
-
-	function testTryCatchNested() {
-		@:coroutine function f(yield:Coroutine<String->Void>, throwValue:Dynamic) {
-			var dummy = '1';
-			try {
-				try {
-					dummy += '2';
-					throw throwValue;
-					dummy += '3';
-				} catch (e:Int) {
-					dummy += '4';
-					yield("10");
-					dummy += '5';
-				}
-				dummy += '6';
-			} catch (e:Dynamic) {
-				dummy += '7';
-				yield('caught: $e, dummy: $dummy');
-				dummy += '8';
-			}
-			dummy += '9';
-			return dummy;
-		}
-		var a = [];
-		Assert.equals("124569", CoroRun.run(() -> f(i -> a.push(i), 1)));
-		Assert.same(["10"], a);
-		a = [];
-		Assert.equals("12789", CoroRun.run(() -> f(i -> a.push(i), "foo")));
-		Assert.same(["caught: foo, dummy: 127"], a);
-		a = [];
-		Assert.equals("124789", CoroRun.run(() -> f(i -> i == "10"?throw i:a.push(i), 1)));
-		Assert.same(["caught: 10, dummy: 1247"], a);
-		final yieldThrow = @:coroutine i -> throw i;
-		// TODO: gives "Cannot use Void as value" without the explicit :Void type-hint
-		final yieldThrowInChildCoro = @:coroutine function(i):Void return CoroRun.run(() -> throw i);
-		for (yield in [yieldThrow, yieldThrowInChildCoro]) {
-			try {
-				CoroRun.run(() -> f(yield, "foo"));
-				Assert.fail();
-			} catch (e:String) {
-				Assert.equals('caught: foo, dummy: 127', e);
-			}
-			try {
-				CoroRun.run(() -> f(yield, 1));
-				Assert.fail();
-			} catch (e:String) {
-				Assert.equals('caught: 10, dummy: 1247', e);
-			}
-		}
-	}
-
-	function testTryCatchExceptionNotCaughtThrownOutOfYieldContext() { // wtf?
-		var dummy = '1';
-		@:coroutine function f(yield:Coroutine<Int->Void>) {
-			try {
-				dummy += '2';
-				throw "Error!";
-				dummy += '3';
-				yield(10);
-				dummy += '4';
-			} catch (e:Int) {
-				dummy += '5';
-			}
-			dummy += '6';
-			return dummy;
-		}
-		try {
-			CoroRun.run(() -> f(i -> Assert.fail()));
-			Assert.fail();
-		} catch (e:String) {
-			Assert.equals('Error!', e);
-			Assert.equals('12', dummy);
-		}
-	}
-
-	function testTryCatchYieldCapture() {
-		@:coroutine function f(yield:Coroutine<Int->Void>) {
-			var dummy = '1';
-			try {
-				dummy += '2';
-				throw 10;
-				dummy += '3';
-			} catch (e:Int) {
-				dummy += '4';
-				yield(e);
-				dummy += '5';
-			}
-			dummy += '6';
-			return dummy;
-		}
-		var a = [];
-		Assert.equals("12456", CoroRun.run(() -> f(i -> a.push(i))));
-		Assert.same([10], a);
-	}
-
-	@:coroutine function tryCatch(e:haxe.Exception) {
-		try {
-			throw e;
-		} catch (e:E1) {
-			return "e1";
-		} catch (e:E2) {
-			return "e2";
-		}
-		return "none";
-	}
-
-	@:coroutine function tryCatchNonExc(e:NE) {
-		try {
-			throw e;
-		} catch (e:NE1) {
-			return "ne1";
-		} catch (e:NE2) {
-			return "ne2";
-		}
-		return "none";
-	}
-
-	@:coroutine function tryCatchMixed(e:Any) {
-		try {
-			throw e;
-		} catch (e:E1) {
-			return "e1";
-		} catch (e:E2) {
-			return "e2";
-		} catch (e:NE1) {
-			return "ne1";
-		} catch (e:NE2) {
-			return "ne2";
-		}
-		return "none";
-	}
-}
-
-private class E1 extends haxe.Exception {
-	public function new()
-		super("E1");
-}
-
-private class E2 extends haxe.Exception {
-	public function new()
-		super("E2");
-}
-
-private class E3 extends haxe.Exception {
-	public function new()
-		super("E3");
-}
-
-interface NE {}
-
-private class NE1 implements NE {
-	public function new() {};
-}
-
-private class NE2 implements NE {
-	public function new() {};
-}
-
-private class NE3 implements NE {
-	public function new() {};
-}

tests/misc/coroutines/src/callstack/Bottom.hx

@@ -1,5 +0,0 @@
-package callstack;
-
-function entry() {
-	CoroRun.run(() -> CoroLower.foo());
-}

tests/misc/coroutines/src/callstack/CallStackInspector.hx

@@ -1,82 +0,0 @@
-package callstack;
-
-import haxe.CallStack;
-using StringTools;
-
-enum CallStackInspect {
-	File(file:String);
-	Line(line:Int);
-	Skip(file:String);
-}
-
-class CallStackInspectorFailure extends haxe.Exception {
-	public function new(reason:String) {
-		super(reason);
-	}
-}
-
-class CallStackInspector {
-	final stack:Array<StackItem>;
-	var offset:Int;
-	var expectedFile:Null<String>;
-	var performedTests:Int;
-	var inspectOffset:Int;
-
-	public function new(stack:Array<StackItem>) {
-		this.stack = stack;
-		offset = 0;
-		inspectOffset = -1;
-		performedTests = 0;
-	}
-
-	public function inspect(items:Array<CallStackInspect>) {
-		try {
-			for (item in items) {
-				doInspect(item);
-			}
-			return null;
-		} catch (e:CallStackInspectorFailure) {
-			return e;
-		}
-	}
-
-	function fail(inspect: CallStackInspect, reason:String) {
-		throw new CallStackInspectorFailure('Failure at stack offset $offset, inspect offset $inspectOffset with $inspect: $reason');
-	}
-
-	function doInspect(inspect:CallStackInspect) {
-		++inspectOffset;
-		switch (inspect) {
-			case File(file):
-				this.expectedFile = file;
-			case Line(expectedLine):
-				final index = offset++;
-				switch (stack[index]) {
-					case FilePos(_, file, line):
-						if (!file.endsWith(expectedFile)) {
-							fail(inspect, 'file $file should be $expectedFile');
-						}
-						performedTests++;
-						if (line != expectedLine) {
-							fail(inspect, 'line $line should be $expectedLine');
-						}
-						performedTests++;
-					case v:
-						fail(inspect, '$v should be FilePos');
-				}
-			case Skip(file):
-				while (true) {
-					if (offset == stack.length) {
-						fail(inspect, '$offset went out of bounds while skipping until $file');
-					}
-					switch (stack[offset]) {
-						case FilePos(Method(_), file2, _) if (file2.endsWith(file)):
-							expectedFile = file;
-							break;
-						case _:
-							offset++;
-					}
-				}
-		}
-	}
-}

tests/misc/coroutines/src/callstack/CoroLower.hx

@@ -1,7 +0,0 @@
-package callstack;
-
-@:coroutine function foo() {
-	yield();
-
-	SyncMiddle.syncFun1();
-}

tests/misc/coroutines/src/callstack/CoroUpper.hx

@@ -1,16 +0,0 @@
-package callstack;
-
-@:coroutine function recursion(i:Int, acc:Int) {
-	yield();
-	return if (i > 0) {
-		recursion(i - 1, acc + i);
-	} else {
-		Top.topCall1();
-	}
-}
-
-@:coroutine function bar() {
-	yield();
-
-	recursion(4, 0);
-}

tests/misc/coroutines/src/callstack/FooBarBaz.hx

@@ -1,17 +0,0 @@
-package callstack;
-
-import haxe.Exception;
-import hxcoro.Coro.*;
-
-@:coroutine function baz() {
-	throw new Exception('hello');
-}
-
-@:coroutine function bar() {
-	yield();
-	baz();
-}
-
-@:coroutine function foo() {
-	bar();
-}

tests/misc/coroutines/src/callstack/SyncMiddle.hx

@@ -1,9 +0,0 @@
-package callstack;
-
-function syncFun2() {
-	CoroRun.run(() -> CoroUpper.bar());
-}
-
-function syncFun1() {
-	syncFun2();
-}

tests/misc/coroutines/src/callstack/Top.hx

@@ -1,13 +0,0 @@
-package callstack;
-
-function throwing() {
-	throw new haxe.exceptions.NotImplementedException();
-}
-
-function topCall2() {
-	throwing();
-}
-
-function topCall1() {
-	topCall2();
-}

tests/misc/coroutines/src/components/TestCoroName.hx

@@ -1,49 +0,0 @@
-package components;
-
-import hxcoro.components.CoroName;
-
-class TestCoroName extends utest.Test {
-	@:coroutine
-	function logDebug() {
-		return suspend(cont -> {
-			cont.resume(cont.context.get(CoroName).name, null);
-		});
-	}
-
-	function test() {
-		CoroRun.runScoped(scope -> {
-			scope.with(new CoroName("first name")).async(_ -> {
-				Assert.equals("first name", logDebug());
-			});
-		});
-	}
-
-	function testScope() {
-		CoroRun.runScoped(node -> {
-			node.with(new CoroName("first name")).async(_ -> {
-				scope(_ -> {
-					Assert.equals("first name", logDebug());
-				});
-			});
-		});
-	}
-
-	function testChildrenNames() {
-		final result = CoroRun.with(new CoroName("Parent")).run(node -> {
-			final children = [for (i in 0...10) node.with(new CoroName('Name: $i')).async(node -> node.context.get(CoroName).name)];
-			[for (child in children) child.await()];
-		});
-		final expected = [for (i in 0...10) 'Name: $i'];
-		Assert.same(expected, result);
-	}
-
-	function testEntrypoint() {
-		CoroRun.with(new CoroName("first name")).run(scope -> {
-			Assert.equals("first name", logDebug());
-		});
-
-		CoroRun.with(new CoroName("wrong name")).with(new CoroName("first name")).run(scope -> {
-			Assert.equals("first name", logDebug());
-		});
-	}
-}

tests/misc/coroutines/src/concurrent/TestMutex.hx

@@ -1,255 +0,0 @@
-package concurrent;
-
-import hxcoro.ds.channels.Channel;
-import haxe.exceptions.CancellationException;
-import hxcoro.concurrent.CoroSemaphore;
-import haxe.coro.schedulers.VirtualTimeScheduler;
-import haxe.coro.Mutex;
-import hxcoro.concurrent.CoroMutex;
-
-class TestMutex extends utest.Test {
-	function testSimple() {
-		final m = new Mutex();
-        m.acquire();
-        m.release();
-        Assert.equals(true, m.tryAcquire());
-        m.release();
-	}
-
-	function testPromptCancellation() {
-		var scheduler = new VirtualTimeScheduler();
-		final lines = [];
-		function report(s:String) {
-			final now = scheduler.now();
-			lines.push('$now: $s');
-		}
-		final task = CoroRun.with(scheduler).create(node -> {
-			final m = new CoroMutex();
-
-			node.async(_ -> {
-				report("0 acquiring");
-				m.acquire();
-				report("0 acquired");
-				delay(1000);
-
-				m.release();
-				report("0 released");
-			});
-
-			node.async(_ -> {
-				try {
-					timeout(500, _ -> {
-						report("1 acquiring");
-						m.acquire();
-						report('1 acquired');
-						m.release();
-						report("1 released");
-					});
-				} catch (_) {
-					report("1 timeout");
-				}
-			});
-
-			node.async(_ -> {
-				report("2 acquiring");
-				m.acquire();
-				report("2 acquired");
-				m.release();
-				report("2 released");
-			});
-		});
-		task.start();
-		while (task.isActive()) {
-			scheduler.advanceBy(1);
-		}
-		Assert.same([
-			   "0: 0 acquiring",
-			   "0: 0 acquired",
-			   "0: 1 acquiring",
-			   "0: 2 acquiring",
-			 "500: 1 timeout",
-			"1000: 0 released",
-			"1000: 2 acquired",
-			"1000: 2 released",
-		], lines);
-	}
-
-	function testSemaphoreAcquire() {
-		var scheduler = new VirtualTimeScheduler();
-		final numTasks = 500;
-		final numTasksHalved = Std.int(numTasks / 2);
-		var numTasksCompleted = 0;
-		final task = CoroRun.with(scheduler).create(node -> {
-			final m = new CoroSemaphore(numTasksHalved);
-			for (_ in 0...numTasks) {
-				node.async(_ -> {
-					m.acquire();
-					delay(500);
-					m.release();
-					numTasksCompleted++;
-				});
-			}
-		});
-		task.start();
-		scheduler.advanceTo(499);
-		Assert.equals(0, numTasksCompleted);
-		scheduler.advanceTo(500);
-		Assert.equals(numTasksHalved, numTasksCompleted);
-		scheduler.advanceTo(999);
-		Assert.equals(numTasksHalved, numTasksCompleted);
-		scheduler.advanceTo(1000);
-		Assert.equals(numTasks, numTasksCompleted);
-	}
-
-	function testSemaphoreTryAcquire() {
-		var scheduler = new VirtualTimeScheduler();
-		final numTasks = 500;
-		final numTasksHalved = Std.int(numTasks / 2);
-		var numTasksCompleted = 0;
-		var numEarlyAcquires = 0;
-		var numLateAcquires = 0;
-		final task = CoroRun.with(scheduler).create(node -> {
-			final m = new CoroSemaphore(numTasksHalved);
-			for (i in 0...numTasks) {
-				node.async(_ -> {
-					final odd = i & 1 == 1;
-					delay(odd ? 1 : 0);
-					if (m.tryAcquire()) {
-						numEarlyAcquires++;
-						delay(odd ? 0 : 1);
-					} else {
-						delay(odd ? 0 : 1);
-						Assert.isTrue(m.tryAcquire());
-						numLateAcquires++;
-					}
-					m.release();
-					numTasksCompleted++;
-				});
-			}
-		});
-		task.start();
-		while (task.isActive()) {
-			scheduler.advanceBy(1);
-		}
-		Assert.equals(numTasks, numTasksCompleted);
-		Assert.equals(numTasksHalved, numEarlyAcquires);
-		Assert.equals(numTasksHalved, numLateAcquires);
-	}
-
-	function testMutexCancelling() {
-		var scheduler = new VirtualTimeScheduler();
-		final lines = [];
-		function report(s:String) {
-			final now = scheduler.now();
-			lines.push('$now: $s');
-		}
-		final task = CoroRun.with(scheduler).create(node -> {
-			final mutex1 = new CoroMutex();
-			final mutex2 = new CoroMutex();
-			final child1 = node.async(_ -> {
-				report("1 acquiring 1");
-				mutex1.acquire();
-				report("1 acquired 1");
-				delay(2);
-				report("1 acquiring 2 (deadlock)");
-				try {
-					mutex2.acquire();
-				} catch (e:CancellationException) {
-					report("1 cancelled");
-					mutex1.release();
-					throw e;
-				}
-				report("1 acquired 2");
-			});
-			final child2 = node.async(_ -> {
-				delay(1);
-				report("2 acquiring 2");
-				mutex2.acquire();
-				report("2 acquired 2");
-				delay(1);
-				report("2 acquiring 1 (deadlock)");
-				mutex1.acquire();
-				report("2 acquired 1");
-				report("2 releasing 1");
-				mutex1.release();
-				report("2 released 1");
-				report("2 releasing 2");
-				mutex2.release();
-				report("2 released 2");
-			});
-			delay(3);
-			report("parent cancelling 1");
-			child1.cancel();
-			report("parent cancelled 1");
-			delay(1);
-			report('1 active: ${child1.isActive()}');
-			report('2 active: ${child2.isActive()}');
-		});
-		task.start();
-		while (task.isActive()) {
-			scheduler.advanceBy(1);
-		}
-		Assert.same([
-			"0: 1 acquiring 1",
-			"0: 1 acquired 1",
-			"1: 2 acquiring 2",
-			"1: 2 acquired 2",
-			"2: 1 acquiring 2 (deadlock)",
-			"2: 2 acquiring 1 (deadlock)",
-			"3: parent cancelling 1",
-			"3: parent cancelled 1",
-			"3: 1 cancelled",
-			"3: 2 acquired 1",
-			"3: 2 releasing 1",
-			"3: 2 released 1",
-			"3: 2 releasing 2",
-			"3: 2 released 2",
-			"4: 1 active: false",
-			"4: 2 active: false",
-		], lines);
-	}
-
-	function testRandomSemaphoreCancelling() {
-		for (semaphoreSize in [1, 2, 4, 8]) {
-			for (numTasks in [1, 2, 10, 100]) {
-				var scheduler = new VirtualTimeScheduler();
-				var semaphore = new CoroSemaphore(semaphoreSize);
-				var semaphoreHolders = Channel.createBounded({ size : 1 });
-				var hangingMutex = new CoroMutex();
-				final task = CoroRun.with(scheduler).create(node -> {
-					hangingMutex.acquire();
-					var numCompletedTasks = 0;
-					for (_ in 0...numTasks) {
-						node.async(node -> {
-							delay(Std.random(15));
-							semaphore.acquire();
-							semaphoreHolders.writer.write(node);
-							try {
-								hangingMutex.acquire(); // will never succeed
-							} catch(e:CancellationException) {
-								semaphore.release();
-								numCompletedTasks++;
-								throw e;
-							}
-						});
-					}
-					delay(1);
-					while (numCompletedTasks != numTasks) {
-						var holder = semaphoreHolders.reader.read();
-						holder.cancel();
-						// this is weird, how do we wait here properly?
-						yield();
-						yield();
-					}
-					hangingMutex.release();
-					numCompletedTasks;
-				});
-				task.start();
-				while (task.isActive()) {
-					scheduler.advanceBy(1);
-				}
-				Assert.equals(numTasks, task.get());
-			}
-		}
-	}
-}

tests/misc/coroutines/src/ds/TestConcurrentCircularBuffer.hx

@@ -1,41 +0,0 @@
-package ds;
-
-import haxe.exceptions.ArgumentException;
-import hxcoro.ds.Out;
-import hxcoro.ds.ConcurrentCircularBuffer;
-
-class TestConcurrentCircularBuffer extends utest.Test {
-	public function test_invalid_capacity() {
-		Assert.raises(() -> new ConcurrentCircularBuffer(0), ArgumentException);
-	}
-
-	public function test_push_pop() {
-		final buffer = new ConcurrentCircularBuffer(3);
-
-		Assert.isTrue(buffer.tryPush(1));
-		Assert.isTrue(buffer.tryPush(2));
-		Assert.isTrue(buffer.tryPush(3));
-		Assert.isFalse(buffer.tryPush(4));
-
-		final out = new Out();
-		Assert.isTrue(buffer.tryPop(out));
-		Assert.equals(1, out.get());
-		Assert.isTrue(buffer.tryPop(out));
-		Assert.equals(2, out.get());
-		Assert.isTrue(buffer.tryPop(out));
-		Assert.equals(3, out.get());
-
-		Assert.isFalse(buffer.tryPop(out));
-	}
-
-	public function test_push_pop_wrap_around() {
-		final buffer = new ConcurrentCircularBuffer(3);
-		final out    = new Out();
-
-		for (i in 0...10) {
-			Assert.isTrue(buffer.tryPush(i));
-			Assert.isTrue(buffer.tryPop(out));
-			Assert.equals(i, out.get());
-		}
-	}
-}

tests/misc/coroutines/src/ds/TestPagedDeque.hx

@@ -1,227 +0,0 @@
-package ds;
-
-import haxe.ds.ArraySort;
-import hxcoro.ds.PagedDeque;
-
-class TestPagedDeque extends utest.Test {
-	public function test() {
-		function expect<T>(expected:Array<T>, d:Page<Any>, ?pos:haxe.PosInfos) {
-			final actual = [for (x in d.data) x];
-			Assert.same(expected, actual, true, null, null, pos);
-		}
-
-		var d:PagedDeque<Any> = new PagedDeque(9);
-		d.push(0);
-		d.push(1);
-		d.push(2);
-		d.push(3);
-		final page = d.push(4);
-		final nnull = #if cpp 0 #else null #end; // I don't get it though
-		expect([0, 1, 2, 3, 4, nnull, nnull, nnull, nnull], page);
-		// delete non-existing
-		Assert.isFalse(d.remove(page, 5));
-		Assert.isFalse(d.isEmpty());
-		expect([0, 1, 2, 3, 4, nnull, nnull, nnull, nnull], page);
-		// delete first
-		Assert.isTrue(d.remove(page, 0));
-		Assert.isFalse(d.isEmpty());
-		expect([1, 2, 3, 4, nnull, nnull, nnull, nnull, nnull], page);
-		// delete last
-		Assert.isTrue(d.remove(page, 4));
-		Assert.isFalse(d.isEmpty());
-		expect([1, 2, 3, nnull, nnull, nnull, nnull, nnull, nnull], page);
-		// delete middle
-		Assert.isTrue(d.remove(page, 2));
-		Assert.isFalse(d.isEmpty());
-		expect([1, 3, nnull, nnull, nnull, nnull, nnull, nnull, nnull], page);
-		// push afterwards
-		d.push(5);
-		Assert.isFalse(d.isEmpty());
-		expect([1, 3, 5, nnull, nnull, nnull, nnull, nnull, nnull], page);
-		// drain
-		Assert.isTrue(d.remove(page, 1));
-		Assert.isTrue(d.remove(page, 3));
-		Assert.isTrue(d.remove(page, 5));
-		Assert.isTrue(d.isEmpty());
-		// push after empty
-		d.push(6);
-		Assert.isFalse(d.isEmpty());
-		Assert.equals(6, d.pop());
-		Assert.isTrue(d.isEmpty());
-	}
-
-	function createTwoPageDeck(pageSize:Int) {
-		var d:PagedDeque<Any> = new PagedDeque(pageSize);
-		final pages = [
-			for (i in 0...pageSize << 1) {
-				d.push(i);
-			}
-		];
-		return {
-			deque: d,
-			pages: pages
-		}
-	}
-
-	public function testBounds1() {
-		final data = createTwoPageDeck(1);
-		final pages = data.pages;
-		final d = data.deque;
-		Assert.notEquals(pages[0], pages[1]);
-		Assert.isFalse(d.remove(pages[0], 1));
-		Assert.isFalse(d.remove(pages[1], 0));
-		// delete last, then push
-		Assert.isTrue(d.remove(pages[1], 1));
-		d.push(2);
-		Assert.equals(0, d.pop());
-		Assert.equals(2, d.pop());
-		Assert.isTrue(d.isEmpty());
-	}
-
-	public function testBounds2() {
-		final data = createTwoPageDeck(2);
-		final pages = data.pages;
-		final d = data.deque;
-		Assert.equals(pages[0], pages[1]);
-		Assert.equals(pages[2], pages[3]);
-		Assert.notEquals(pages[0], pages[2]);
-		Assert.isFalse(d.remove(pages[0], 2));
-		Assert.isFalse(d.remove(pages[0], 3));
-		Assert.isFalse(d.remove(pages[2], 0));
-		Assert.isFalse(d.remove(pages[2], 1));
-		// delete first and last
-		Assert.isTrue(d.remove(pages[0], 0));
-		Assert.isTrue(d.remove(pages[2], 3));
-		Assert.equals(1, d.pop());
-		Assert.equals(2, d.pop());
-		Assert.isTrue(d.isEmpty());
-	}
-
-	public function testBounds3() {
-		final data = createTwoPageDeck(3);
-		final pages = data.pages;
-		final d = data.deque;
-		// delete middle
-		Assert.isTrue(d.remove(pages[0], 1));
-		Assert.isTrue(d.remove(pages[3], 4));
-		Assert.equals(0, d.pop());
-		Assert.equals(2, d.pop());
-		Assert.equals(3, d.pop());
-		Assert.equals(5, d.pop());
-		Assert.isTrue(d.isEmpty());
-	}
-
-	public function testWildDeletion() {
-		final data = createTwoPageDeck(100);
-		final pages = data.pages;
-		final page1 = pages[0];
-		final page2 = pages[100];
-		final d = data.deque;
-		final values = [for (i in 0...200) i];
-		ArraySort.sort(values, (_, _) -> Math.random() > 0.5 ? 1 : -1);
-		Assert.isFalse(d.isEmpty());
-		for (i in values) {
-			switch [d.remove(page1, i), d.remove(page2, i)] {
-				case [true, false] | [false, true]:
-				case [true, true]:
-					Assert.fail('Deleted $i from two pages');
-				case [false, false]:
-					Assert.fail('Couldn\'t delete $i from any page');
-			}
-		}
-		Assert.isTrue(d.isEmpty());
-	}
-
-	public function testDeleteDelete() {
-		// delete + delete
-		final d = new PagedDeque(1);
-		final page1 = d.push(1);
-		final page2 = d.push(2);
-		Assert.isTrue(d.remove(page1, 1));
-		Assert.isTrue(d.remove(page2, 2));
-		Assert.isTrue(d.isEmpty());
-		// again
-		final page1 = d.push(1);
-		final page2 = d.push(2);
-		Assert.isTrue(d.remove(page1, 1));
-		Assert.isTrue(d.remove(page2, 2));
-		Assert.isTrue(d.isEmpty());
-	}
-
-	public function testDeletePop() {
-		// delete + pop
-		final d = new PagedDeque(1);
-		final page1 = d.push(1);
-		d.push(2);
-		Assert.isTrue(d.remove(page1, 1));
-		Assert.equals(2, d.pop());
-		Assert.isTrue(d.isEmpty());
-		// again
-		final page1 = d.push(1);
-		d.push(2);
-		Assert.isTrue(d.remove(page1, 1));
-		Assert.equals(2, d.pop());
-		Assert.isTrue(d.isEmpty());
-	}
-
-	public function testPopDelete() {
-		// delete + pop
-		final d = new PagedDeque(1);
-		d.push(1);
-		final page1 = d.push(2);
-		Assert.equals(1, d.pop());
-		Assert.isTrue(d.remove(page1, 2));
-		Assert.isTrue(d.isEmpty());
-		// again
-		d.push(1);
-		final page1 = d.push(2);
-		Assert.equals(1, d.pop());
-		Assert.isTrue(d.remove(page1, 2));
-		Assert.isTrue(d.isEmpty());
-	}
-
-	public function testDeleteAfterPopOnCurrent() {
-		final d = new PagedDeque(4);
-		final page = d.push(1);
-		d.push(2);
-		Assert.equals(1, d.pop());
-		Assert.equals(2, d.pop());
-		Assert.isTrue(d.isEmpty());
-		Assert.isFalse(d.remove(page, 1));
-		Assert.isFalse(d.remove(page, 2));
-		Assert.isTrue(d.isEmpty());
-		d.push(3);
-		Assert.isFalse(d.isEmpty());
-		d.push(4);
-		Assert.isFalse(d.isEmpty());
-		Assert.equals(3, d.pop());
-		Assert.isFalse(d.isEmpty());
-		Assert.equals(4, d.pop());
-		Assert.isTrue(d.isEmpty());
-		final page2 = d.push(5);
-		Assert.isTrue(page == page2); // assert page reuse
-		Assert.isFalse(d.isEmpty());
-		Assert.equals(5, d.pop());
-		Assert.isTrue(d.isEmpty());
-	}
-
-	public function testDeleteMiddlePage() {
-		final d = new PagedDeque(2);
-		final pages = [
-			for (i in 0...6) {
-				d.push(i);
-			}
-		];
-		final middlePage = pages[2];
-		d.remove(middlePage, 2);
-		d.remove(middlePage, 3);
-		Assert.equals(0, d.pop());
-		Assert.isFalse(d.isEmpty());
-		Assert.equals(1, d.pop());
-		Assert.isFalse(d.isEmpty());
-		Assert.equals(4, d.pop());
-		Assert.isFalse(d.isEmpty());
-		Assert.equals(5, d.pop());
-		Assert.isTrue(d.isEmpty());
-	}
-}

tests/misc/coroutines/src/ds/channels/TestBoundedChannel.hx

@@ -1,286 +0,0 @@
-package ds.channels;
-
-import haxe.ds.Option;
-import haxe.coro.schedulers.VirtualTimeScheduler;
-import haxe.exceptions.ArgumentException;
-import hxcoro.ds.Out;
-import hxcoro.ds.channels.Channel;
-import hxcoro.exceptions.TimeoutException;
-
-class TestBoundedChannel extends utest.Test {
-	public function test_creating() {
-		Assert.notNull(Channel.createBounded({ size : 3 }));
-	}
-
-	public function test_invalid_size() {
-		Assert.raises(() -> Channel.createBounded({ size : 0 }), ArgumentException);
-	}
-
-	public function test_general() {
-		final size = 100;
-		final channel = Channel.createBounded({ size : 3 });
-		final scheduler = new VirtualTimeScheduler();
-		final task = CoroRun.with(scheduler).create(node -> {
-			final output = [];
-			final writer = node.async(_ -> {
-				var i = size;
-
-				while (i >= 0) {
-					channel.writer.write(i);
-
-					i--;
-
-					delay(Std.random(5));
-				}
-			});
-			for (_ in 0...size + 1) {
-				output.push(channel.reader.read());
-				delay(Std.random(5));
-			}
-			writer.cancel();
-			output;
-		});
-		task.start();
-		while (task.isActive()) {
-			scheduler.run();
-			scheduler.advanceBy(1);
-		}
-		final expected = [for (i in 0...size + 1) i];
-		expected.reverse();
-		Assert.same(expected, task.get());
-	}
-
-	public function test_fifo_buffered_read_writes() {
-		final actual    = [];
-		final channel   = Channel.createBounded({ size : 2 });
-		final scheduler = new VirtualTimeScheduler();
-		final task      = CoroRun.with(scheduler).create(node -> {
-			channel.writer.write('Hello');
-			channel.writer.write('World');
-
-			actual.push(channel.reader.read());
-			actual.push(channel.reader.read());
-		});
-
-		task.start();
-
-		scheduler.advanceBy(1);
-		
-		Assert.isFalse(task.isActive());
-		Assert.same([ 'Hello', 'World' ], actual);
-	}
-
-	public function test_fifo_suspended_read_writes() {
-		final actual    = [];
-		final channel   = Channel.createBounded({ size : 1 });
-		final scheduler = new VirtualTimeScheduler();
-		final task      = CoroRun.with(scheduler).create(node -> {
-			channel.writer.write('dummy');
-
-			node.async(_ -> {
-				channel.writer.write('Hello');
-			});
-
-			node.async(_ -> {
-				channel.writer.write('World');
-			});
-
-			delay(100);
-
-			actual.push(channel.reader.read());
-			actual.push(channel.reader.read());
-			actual.push(channel.reader.read());
-		});
-
-		task.start();
-
-		scheduler.advanceBy(100);
-		
-		Assert.isFalse(task.isActive());
-		Assert.same([ 'dummy', 'Hello', 'World' ], actual);
-	}
-
-		function test_write_cancellation() {
-		final actual     = [];
-		final exceptions = [];
-		final channel    = Channel.createBounded({ size : 1 });
-		final scheduler  = new VirtualTimeScheduler();
-		final task       = CoroRun.with(scheduler).create(node -> {
-			channel.writer.write('dummy');
-
-			node.async(_ -> {
-				try {
-					timeout(100, _ -> {
-						channel.writer.write('Hello');
-					});
-				} catch (_:TimeoutException) {
-					exceptions.push(scheduler.now());
-				}
-			});
-
-			node.async(_ -> {
-				channel.writer.write('World');
-			});
-
-			delay(200);
-
-			Assert.equals('dummy', channel.reader.read());
-			
-			actual.push(channel.reader.read());
-		});
-
-		task.start();
-
-		scheduler.advanceBy(99);
-		Assert.same([], actual);
-
-		scheduler.advanceBy(1);
-		Assert.same([], actual);
-		Assert.equals(1, exceptions.length);
-		Assert.isTrue(100i64 == exceptions[0]);
-
-		scheduler.advanceBy(100);
-		Assert.same([ 'World' ], actual);
-
-		Assert.isFalse(task.isActive());
-	}
-
-	function test_read_cancellation() {
-		final actual     = [];
-		final exceptions = [];
-		final channel    = Channel.createBounded({ size : 1 });
-		final scheduler  = new VirtualTimeScheduler();
-		final task       = CoroRun.with(scheduler).create(node -> {
-			node.async(_ -> {
-				try {
-					timeout(100, _ -> {
-						return channel.reader.read();
-					});
-				} catch(_:TimeoutException) {
-					exceptions.push(scheduler.now());
-					"";
-				}
-			});
-
-			node.async(_ -> {
-				actual.push(channel.reader.read());
-			});
-
-			delay(200);
-
-			channel.writer.write('Hello');
-		});
-
-		task.start();
-
-		scheduler.advanceBy(100);
-
-		Assert.isTrue(task.isActive());
-		Assert.same([], actual);
-		Assert.equals(1, exceptions.length);
-		Assert.isTrue(100i64 == exceptions[0]);
-
-		scheduler.advanceBy(100);
-
-		Assert.isFalse(task.isActive());
-		Assert.same([ 'Hello' ], actual);
-	}
-
-		function test_try_read() {
-		final channel = Channel.createBounded({ size : 1 });
-		final scheduler = new VirtualTimeScheduler();
-		final task = CoroRun.with(scheduler).create(node -> {
-			final output = [];
-			node.async(node -> {
-				var out = new Out();
-				function report(didRead:Bool) {
-					if (didRead) {
-						output.push(Some(out.get()));
-					} else {
-						output.push(None);
-					}
-				}
-				// from buffer
-				report(channel.reader.tryRead(out));
-				delay(2);
-				report(channel.reader.tryRead(out));
-				report(channel.reader.tryRead(out));
-
-				// from suspense
-				delay(2);
-				report(channel.reader.tryRead(out));
-				yield();
-				report(channel.reader.tryRead(out));
-				yield();
-				report(channel.reader.tryRead(out));
-			});
-			delay(1);
-			channel.writer.write(1);
-			delay(2);
-			channel.writer.write(2);
-			channel.writer.write(3);
-			output;
-		});
-		task.start();
-		while (task.isActive()) {
-			scheduler.run();
-			scheduler.advanceBy(1);
-		}
-		Assert.same([None, Some(1), None, Some(2), Some(3), None], task.get());
-	}
-
-	function test_single_writer_multiple_reader() {
-		final channel  = Channel.createBounded({ size : 3 });
-		final expected = [ for (i in 0...100) i ];
-		final actual   = [];
-
-		CoroRun.runScoped(node -> {
-			node.async(_ -> {
-				for (v in expected) {
-					channel.writer.write(v);
-				}
-
-				channel.writer.close();
-			});
-
-			for (_ in 0...5) {
-				node.async(_ -> {
-					final out = new Out();
-
-					while (channel.reader.waitForRead()) {
-						if (channel.reader.tryRead(out)) {
-							actual.push(out.get());
-						}
-					}
-				});
-			}
-		});
-
-		Assert.same(expected, actual);
-	}
-
-	// var todoHoisting = 0;
-
-	// function test_iterator() {
-	// 	final size = 50;
-	// 	for (bufferSize in [1, 25, 50]) {
-	// 		todoHoisting = 0;
-	// 		final channel = Channel.createBounded(bufferSize);
-	// 		final scheduler = new VirtualTimeScheduler();
-	// 		final task = CoroRun.with(scheduler).create(node -> {
-	// 			for (i in 0...size) {
-	// 				node.async(_ -> channel.writer.write(todoHoisting++));
-	// 			}
-	// 			delay(1);
-	// 			final res = [for (i in channel) i];
-	// 			res;
-	// 		});
-	// 		task.start();
-	// 		while (task.isActive()) {
-	// 			scheduler.run();
-	// 			scheduler.advanceBy(1);
-	// 		}
-	// 		Assert.same([for (i in 0...size) i], task.get());
-	// 	}
-	// }
-}

tests/misc/coroutines/src/ds/channels/TestBoundedReader.hx

@@ -1,452 +0,0 @@
-package ds.channels;
-
-import haxe.Exception;
-import haxe.coro.IContinuation;
-import haxe.coro.context.Context;
-import haxe.coro.schedulers.VirtualTimeScheduler;
-import haxe.exceptions.ArgumentException;
-import haxe.exceptions.CancellationException;
-import haxe.exceptions.NotImplementedException;
-import hxcoro.exceptions.ChannelClosedException;
-import hxcoro.ds.Out;
-import hxcoro.ds.PagedDeque;
-import hxcoro.ds.CircularBuffer;
-import hxcoro.ds.channels.bounded.BoundedReader;
-
-using hxcoro.util.Convenience;
-
-private class TestContinuation<T> implements IContinuation<Bool> {
-	final actual : Array<T>;
-	final value : T;
-
-	public var context (get, never) : Context;
-
-	function get_context():Context {
-		return Context.create(new ImmediateScheduler());
-	}
-
-	public function new(actual : Array<T>, value : T) {
-		this.actual = actual;
-		this.value  = value;
-	}
-
-	public function resume(_:Bool, _:Exception) {
-		actual.push(value);
-	}
-}
-
-class TestBoundedReader extends utest.Test {
-	function test_try_read_has_data() {
-		final buffer        = new CircularBuffer(1);
-		final writeWaiters  = new PagedDeque();
-		final readWaiters   = new PagedDeque();
-		final reader        = new BoundedReader(buffer, writeWaiters, readWaiters, new Out());
-		final out           = new Out();
-
-		Assert.isTrue(buffer.tryPush(10));
-		Assert.isTrue(reader.tryRead(out));
-		Assert.equals(10, out.get());
-		Assert.isTrue(buffer.wasEmpty());
-	}
-
-	function test_try_read_empty() {
-		final buffer        = new CircularBuffer(1);
-		final writeWaiters  = new PagedDeque();
-		final readWaiters   = new PagedDeque();
-		final reader        = new BoundedReader(buffer, writeWaiters, readWaiters, new Out());
-		final out           = new Out();
-
-		Assert.isFalse(reader.tryRead(out));
-		Assert.isTrue(buffer.wasEmpty());
-	}
-
-	function test_try_read_wakup_all_writers() {
-		final buffer        = new CircularBuffer(1);
-		final writeWaiters  = new PagedDeque();
-		final readWaiters   = new PagedDeque();
-		final reader        = new BoundedReader(buffer, writeWaiters, readWaiters, new Out());
-		final out           = new Out();
-		final actual        = [];
-
-		writeWaiters.push(new TestContinuation(actual, '1'));
-		writeWaiters.push(new TestContinuation(actual, '2'));
-
-		Assert.isTrue(buffer.tryPush(0));
-		Assert.isTrue(reader.tryRead(out));
-		Assert.isTrue(writeWaiters.isEmpty());
-		Assert.same([ '1', '2' ], actual);
-	}
-
-	function test_try_peek_has_data() {
-		final buffer = new CircularBuffer(1);
-		final reader = new BoundedReader(buffer, new PagedDeque(), new PagedDeque(), new Out());
-		
-		Assert.isTrue(buffer.tryPush(10));
-		
-		final out = new Out();
-		if (Assert.isTrue(reader.tryPeek(out))) {
-			Assert.equals(10, out.get());
-		}
-		
-		Assert.isFalse(buffer.wasEmpty());
-	}
-
-	function test_try_peek_many_data() {
-		final count  = 5;
-		final buffer = new CircularBuffer(count);
-		final reader = new BoundedReader(buffer, new PagedDeque(), new PagedDeque(), new Out());
-		final out    = new Out();
-
-		for (i in 0...count) {
-			Assert.isTrue(buffer.tryPush(i + 1));
-		}
-
-		Assert.isTrue(reader.tryPeek(out));
-		Assert.equals(count, out.get());
-	}
-
-	function test_try_peek_empty() {
-		final buffer = new CircularBuffer(1);
-		final reader = new BoundedReader(buffer, new PagedDeque(), new PagedDeque(), new Out());
-		final out    = new Out();
-
-		Assert.isFalse(reader.tryPeek(out));
-	}
-
-	function test_wait_for_read_has_data() {
-		final buffer       = new CircularBuffer(1);
-		final writeWaiters = new PagedDeque();
-		final readWaiters  = new PagedDeque();
-		final reader       = new BoundedReader(buffer, writeWaiters, readWaiters, new Out());
-		final scheduler    = new VirtualTimeScheduler();
-		final actual       = [];
-		final task         = CoroRun.with(scheduler).create(node -> {
-			actual.push(reader.waitForRead());
-		});
-
-		Assert.isTrue(buffer.tryPush(10));
-
-		task.start();
-
-		scheduler.advanceBy(1);
-
-		Assert.isFalse(task.isActive());
-		Assert.same([ true ], actual);
-		Assert.isTrue(readWaiters.isEmpty());
-	}
-
-	function test_wait_for_read_empty_buffer() {
-		final buffer       = new CircularBuffer(1);
-		final writeWaiters = new PagedDeque();
-		final readWaiters  = new PagedDeque();
-		final reader       = new BoundedReader(buffer, writeWaiters, readWaiters, new Out());
-		final out          = new Out();
-		final scheduler    = new VirtualTimeScheduler();
-		final actual       = [];
-		final task         = CoroRun.with(scheduler).create(node -> {
-			actual.push(reader.waitForRead());
-		});
-
-		task.start();
-
-		scheduler.advanceBy(1);
-
-		Assert.isTrue(task.isActive());
-		Assert.same([], actual);
-		Assert.isTrue(buffer.wasEmpty());
-		Assert.isFalse(readWaiters.isEmpty());
-	}
-
-	function test_wait_for_read_empty_buffer_wakeup() {
-		final buffer       = new CircularBuffer(1);
-		final writeWaiters = new PagedDeque();
-		final readWaiters  = new PagedDeque();
-		final reader       = new BoundedReader(buffer, writeWaiters, readWaiters, new Out());
-		final out          = new Out();
-		final scheduler    = new VirtualTimeScheduler();
-		final actual       = [];
-		final task         = CoroRun.with(scheduler).create(node -> {
-			actual.push(reader.waitForRead());
-		});
-
-		task.start();
-
-		scheduler.advanceBy(1);
-
-		readWaiters.pop().succeedAsync(true);
-
-		scheduler.advanceBy(1);
-
-		Assert.isFalse(task.isActive());
-		Assert.same([ true ], actual);
-		Assert.isTrue(readWaiters.isEmpty());
-	}
-
-	function test_wait_for_write_empty_buffer_cancellation() {
-		final buffer       = new CircularBuffer(1);
-		final writeWaiters = new PagedDeque();
-		final readWaiters  = new PagedDeque();
-		final reader       = new BoundedReader(buffer, writeWaiters, readWaiters, new Out());
-		final out          = new Out();
-		final scheduler    = new VirtualTimeScheduler();
-		final actual       = [];
-		final task         = CoroRun.with(scheduler).create(node -> {
-			actual.push(reader.waitForRead());
-		});
-
-		task.start();
-
-		scheduler.advanceBy(1);
-
-		task.cancel();
-
-		scheduler.advanceBy(1);
-
-		Assert.isFalse(task.isActive());
-		Assert.isOfType(task.getError(), CancellationException);
-		Assert.same([], actual);
-		Assert.isTrue(readWaiters.isEmpty());
-	}
-
-	function test_read_has_data() {
-		final buffer       = new CircularBuffer(1);
-		final writeWaiters = new PagedDeque();
-		final readWaiters  = new PagedDeque();
-		final reader       = new BoundedReader(buffer, writeWaiters, readWaiters, new Out());
-		final out          = new Out();
-		final scheduler    = new VirtualTimeScheduler();
-		final actual       = [];
-		final task         = CoroRun.with(scheduler).create(node -> {
-			actual.push(reader.read());
-		});
-
-		Assert.isTrue(buffer.tryPush(10));
-
-		task.start();
-
-		scheduler.advanceBy(1);
-
-		Assert.isFalse(task.isActive());
-		Assert.same([ 10 ], actual);
-		Assert.isTrue(buffer.wasEmpty());
-		Assert.isTrue(readWaiters.isEmpty());
-	}
-
-	function test_read_empty_buffer() {
-		final buffer       = new CircularBuffer(1);
-		final writeWaiters = new PagedDeque();
-		final readWaiters  = new PagedDeque();
-		final reader       = new BoundedReader(buffer, writeWaiters, readWaiters, new Out());
-		final out          = new Out();
-		final scheduler    = new VirtualTimeScheduler();
-		final actual       = [];
-		final task         = CoroRun.with(scheduler).create(node -> {
-			actual.push(reader.read());
-		});
-
-		task.start();
-
-		scheduler.advanceBy(1);
-
-		Assert.isTrue(task.isActive());
-		Assert.isTrue(buffer.wasEmpty());
-		Assert.same([], actual);
-		Assert.isFalse(readWaiters.isEmpty());
-	}
-
-	function test_read_wakeup_all_writers() {
-		final buffer       = new CircularBuffer(1);
-		final writeWaiters = new PagedDeque();
-		final readWaiters  = new PagedDeque();
-		final reader       = new BoundedReader(buffer, writeWaiters, readWaiters, new Out());
-		final out          = new Out();
-		final scheduler    = new VirtualTimeScheduler();
-		final actual       = [];
-		final task         = CoroRun.with(scheduler).create(node -> {
-			reader.read();
-		});
-
-		Assert.isTrue(buffer.tryPush(10));
-
-		writeWaiters.push(new TestContinuation(actual, '1'));
-		writeWaiters.push(new TestContinuation(actual, '2'));
-
-		task.start();
-
-		scheduler.advanceBy(1);
-
-		Assert.isFalse(task.isActive());
-		Assert.isTrue(writeWaiters.isEmpty());
-		Assert.same([ '1', '2' ], actual);
-	}
-
-	function test_read_empty_buffer_wakeup() {
-		final buffer       = new CircularBuffer(1);
-		final writeWaiters = new PagedDeque();
-		final readWaiters  = new PagedDeque();
-		final reader       = new BoundedReader(buffer, writeWaiters, readWaiters, new Out());
-		final out          = new Out();
-		final scheduler    = new VirtualTimeScheduler();
-		final actual       = [];
-		final task         = CoroRun.with(scheduler).create(node -> {
-			actual.push(reader.read());
-		});
-
-		task.start();
-
-		scheduler.advanceBy(1);
-
-		Assert.isTrue(task.isActive());
-		Assert.isTrue(buffer.wasEmpty());
-
-		Assert.isTrue(buffer.tryPush(10));
-		readWaiters.pop().succeedAsync(true);
-
-		scheduler.advanceBy(1);
-
-		Assert.isFalse(task.isActive());
-		Assert.same([ 10 ], actual);
-		Assert.isTrue(buffer.wasEmpty());
-	}
-
-	function test_read_cancellation() {
-		final buffer       = new CircularBuffer(1);
-		final writeWaiters = new PagedDeque();
-		final readWaiters  = new PagedDeque();
-		final reader       = new BoundedReader(buffer, writeWaiters, readWaiters, new Out());
-		final out          = new Out();
-		final scheduler    = new VirtualTimeScheduler();
-		final actual       = [];
-		final task         = CoroRun.with(scheduler).create(node -> {
-			actual.push(reader.read());
-		});
-
-		task.start();
-		scheduler.advanceBy(1);
-		task.cancel();
-		scheduler.advanceBy(1);
-
-		Assert.isFalse(task.isActive());
-		Assert.isOfType(task.getError(), CancellationException);
-		Assert.isTrue(buffer.wasEmpty());
-		Assert.isTrue(readWaiters.isEmpty());
-	}
-
-	function test_wait_for_read_when_closed() {
-		final buffer       = new CircularBuffer(1);
-		final writeWaiters = new PagedDeque();
-		final readWaiters  = new PagedDeque();
-		final closed       = new Out();
-		final reader       = new BoundedReader(buffer, writeWaiters, readWaiters, closed);
-		final actual       = [];
-		final scheduler    = new VirtualTimeScheduler();
-		final task         = CoroRun.with(scheduler).create(node -> {
-			actual.push(reader.waitForRead());
-		});
-
-		closed.set(true);
-
-		task.start();
-		scheduler.advanceBy(1);
-
-		Assert.isFalse(task.isActive());
-		Assert.same([ false ], actual);
-	}
-
-	function test_wait_for_read_when_closed_with_remaining_data() {
-		final buffer       = new CircularBuffer(1);
-		final writeWaiters = new PagedDeque();
-		final readWaiters  = new PagedDeque();
-		final closed       = new Out();
-		final reader       = new BoundedReader(buffer, writeWaiters, readWaiters, closed);
-		final scheduler    = new VirtualTimeScheduler();
-		final actual       = [];
-		final task         = CoroRun.with(scheduler).create(node -> {
-			actual.push(reader.waitForRead());
-		});
-
-		Assert.isTrue(buffer.tryPush(10));
-
-		closed.set(true);
-
-		task.start();
-		scheduler.advanceBy(1);
-
-		Assert.isFalse(task.isActive());
-		Assert.same([ true ], actual);
-	}
-
-	function test_try_read_when_closed() {
-		final buffer       = new CircularBuffer(1);
-		final writeWaiters = new PagedDeque();
-		final readWaiters  = new PagedDeque();
-		final closed       = new Out();
-		final out          = new Out();
-		final reader       = new BoundedReader(buffer, writeWaiters, readWaiters, closed);
-
-		closed.set(true);
-
-		Assert.isFalse(reader.tryRead(out));
-	}
-
-	function test_try_read_when_closed_with_remaining_data() {
-		final buffer       = new CircularBuffer(1);
-		final writeWaiters = new PagedDeque();
-		final readWaiters  = new PagedDeque();
-		final closed       = new Out();
-		final out          = new Out();
-		final reader       = new BoundedReader(buffer, writeWaiters, readWaiters, closed);
-
-		Assert.isTrue(buffer.tryPush(10));
-
-		closed.set(true);
-
-		Assert.isTrue(reader.tryRead(out));
-		Assert.isTrue(buffer.wasEmpty());
-		Assert.equals(10, out.get());
-	}
-
-	function test_read_when_closed() {
-		final buffer       = new CircularBuffer(1);
-		final writeWaiters = new PagedDeque();
-		final readWaiters  = new PagedDeque();
-		final closed       = new Out();
-		final reader       = new BoundedReader(buffer, writeWaiters, readWaiters, closed);
-		final actual       = [];
-		final scheduler    = new VirtualTimeScheduler();
-		final task         = CoroRun.with(scheduler).create(node -> {
-			AssertAsync.raises(reader.read(), ChannelClosedException);
-		});
-
-		closed.set(true);
-
-		task.start();
-		scheduler.advanceBy(1);
-
-		Assert.isFalse(task.isActive());
-		Assert.same([], actual);
-	}
-
-	function test_read_when_closed_with_remaining_data() {
-		final buffer       = new CircularBuffer(1);
-		final writeWaiters = new PagedDeque();
-		final readWaiters  = new PagedDeque();
-		final closed       = new Out();
-		final reader       = new BoundedReader(buffer, writeWaiters, readWaiters, closed);
-		final actual       = [];
-		final scheduler    = new VirtualTimeScheduler();
-		final task         = CoroRun.with(scheduler).create(node -> {
-			actual.push(reader.read());
-		});
-
-		Assert.isTrue(buffer.tryPush(10));
-
-		closed.set(true);
-
-		task.start();
-		scheduler.advanceBy(1);
-
-		Assert.isFalse(task.isActive());
-		Assert.same([ 10 ], actual);
-	}
-}

tests/misc/coroutines/src/ds/channels/TestBoundedWriter.hx

@@ -1,519 +0,0 @@
-package ds.channels;
-
-import haxe.coro.context.Context;
-import haxe.coro.IContinuation;
-import haxe.Exception;
-import haxe.exceptions.CancellationException;
-import haxe.exceptions.NotImplementedException;
-import hxcoro.ds.channels.bounded.BoundedWriter;
-import hxcoro.ds.Out;
-import hxcoro.ds.CircularBuffer;
-import hxcoro.ds.PagedDeque;
-import hxcoro.exceptions.ChannelClosedException;
-import haxe.coro.schedulers.VirtualTimeScheduler;
-
-using hxcoro.util.Convenience;
-
-private class TestContinuation<T> implements IContinuation<Bool> {
-	final expected : Array<T>;
-	final mapper : Bool->T;
-
-	public var context (get, never) : Context;
-
-	function get_context():Context {
-		return Context.create(new ImmediateScheduler());
-	}
-
-	public function new(expected : Array<T>, mapper : Bool->T) {
-		this.expected = expected;
-		this.mapper   = mapper;
-	}
-
-	public function resume(result:Bool, _:Exception) {
-		expected.push(mapper(result));
-	}
-}
-
-class TestBoundedWriter extends utest.Test {
-	function test_try_write_has_space() {
-		final buffer        = new CircularBuffer(1);
-		final writeWaiters  = new PagedDeque();
-		final readWaiters   = new PagedDeque();
-		final writer        = new BoundedWriter(buffer, writeWaiters, readWaiters, new Out(), Wait);
-
-		Assert.isTrue(writer.tryWrite(10));
-
-		final out = new Out();
-		if (Assert.isTrue(buffer.tryPeekHead(out))) {
-			Assert.equals(10, out.get());
-		}
-	}
-
-	function test_try_write_full_buffer() {
-		final buffer        = new CircularBuffer(1);
-		final writeWaiters  = new PagedDeque();
-		final readWaiters   = new PagedDeque();
-		final writer        = new BoundedWriter(buffer, writeWaiters, readWaiters, new Out(), Wait);
-		final out           = new Out();
-
-		Assert.isTrue(buffer.tryPush(5));
-		Assert.isFalse(writer.tryWrite(10));
-		if (Assert.isTrue(buffer.tryPeekHead(out))) {
-			Assert.equals(5, out.get());
-		}
-	}
-
-	function test_try_write_wakeup_all_readers() {
-		final buffer        = new CircularBuffer(1);
-		final writeWaiters  = new PagedDeque();
-		final readWaiters   = new PagedDeque();
-		final writer        = new BoundedWriter(buffer, writeWaiters, readWaiters, new Out(), Wait);
-		final expected      = [];
-
-		readWaiters.push(new TestContinuation(expected, _ -> '1'));
-		readWaiters.push(new TestContinuation(expected, _ -> '2'));
-
-		Assert.isTrue(writer.tryWrite(10));
-		Assert.isTrue(readWaiters.isEmpty());
-		Assert.same([ '1', '2' ], expected);
-	}
-
-	function test_wait_for_write_empty_buffer() {
-		final buffer        = new CircularBuffer(2);
-		final writeWaiters  = new PagedDeque();
-		final readWaiters   = new PagedDeque();
-		final writer        = new BoundedWriter(buffer, writeWaiters, readWaiters, new Out(), Wait);
-		final scheduler     = new VirtualTimeScheduler();
-		final actual        = [];
-		final task          = CoroRun.with(scheduler).create(node -> {
-			actual.push(writer.waitForWrite());
-		});
-
-		task.start();
-
-		scheduler.advanceBy(1);
-
-		Assert.isFalse(task.isActive());
-		Assert.same([ true ], actual);
-		Assert.isTrue(writeWaiters.isEmpty());
-	}
-
-	function test_wait_for_write_partial_buffer() {
-		final buffer        = new CircularBuffer(2);
-		final writeWaiters  = new PagedDeque();
-		final readWaiters   = new PagedDeque();
-		final writer        = new BoundedWriter(buffer, writeWaiters, readWaiters, new Out(), Wait);
-		final scheduler     = new VirtualTimeScheduler();
-		final actual        = [];
-		final task          = CoroRun.with(scheduler).create(node -> {
-			actual.push(writer.waitForWrite());
-		});
-
-		Assert.isTrue(buffer.tryPush(0));
-
-		task.start();
-
-		scheduler.advanceBy(1);
-
-		Assert.isFalse(task.isActive());
-		Assert.same([ true ], actual);
-		Assert.isTrue(writeWaiters.isEmpty());
-	}
-
-	function test_wait_for_write_full_buffer() {
-		final buffer        = new CircularBuffer(2);
-		final writeWaiters  = new PagedDeque();
-		final readWaiters   = new PagedDeque();
-		final writer        = new BoundedWriter(buffer, writeWaiters, readWaiters, new Out(), Wait);
-		final scheduler     = new VirtualTimeScheduler();
-		final actual        = [];
-		final task = CoroRun.with(scheduler).create(node -> {
-			actual.push(writer.waitForWrite());
-		});
-
-		Assert.isTrue(buffer.tryPush(0));
-		Assert.isTrue(buffer.tryPush(0));
-
-		task.start();
-
-		scheduler.advanceBy(1);
-
-		Assert.isTrue(task.isActive());
-		Assert.same([], actual);
-		Assert.isFalse(writeWaiters.isEmpty());
-	}
-
-	function test_wait_for_write_full_buffer_wakeup() {
-		final buffer        = new CircularBuffer(2);
-		final writeWaiters  = new PagedDeque();
-		final readWaiters   = new PagedDeque();
-		final writer        = new BoundedWriter(buffer, writeWaiters, readWaiters, new Out(), Wait);
-		final scheduler     = new VirtualTimeScheduler();
-		final actual        = [];
-		final task          = CoroRun.with(scheduler).create(node -> {
-			actual.push(writer.waitForWrite());
-		});
-
-		Assert.isTrue(buffer.tryPush(0));
-		Assert.isTrue(buffer.tryPush(0));
-
-		task.start();
-
-		scheduler.advanceBy(1);
-
-		writeWaiters.pop().succeedAsync(true);
-
-		scheduler.advanceBy(1);
-
-		Assert.isFalse(task.isActive());
-		Assert.same([ true ], actual);
-		Assert.isTrue(writeWaiters.isEmpty());
-	}
-
-	function test_wait_for_write_full_buffer_cancellation() {
-		final buffer        = new CircularBuffer(2);
-		final writeWaiters  = new PagedDeque();
-		final readWaiters   = new PagedDeque();
-		final writer        = new BoundedWriter(buffer, writeWaiters, readWaiters, new Out(), Wait);
-		final scheduler     = new VirtualTimeScheduler();
-		final actual        = [];
-		final task          = CoroRun.with(scheduler).create(node -> {
-			actual.push(writer.waitForWrite());
-		});
-
-		Assert.isTrue(buffer.tryPush(0));
-		Assert.isTrue(buffer.tryPush(0));
-
-		task.start();
-
-		scheduler.advanceBy(1);
-
-		task.cancel();
-
-		scheduler.advanceBy(1);
-
-		Assert.isFalse(task.isActive());
-		Assert.isOfType(task.getError(), CancellationException);
-		Assert.same([], actual);
-		Assert.isTrue(writeWaiters.isEmpty());
-	}
-
-	function test_write_has_space() {
-		final buffer        = new CircularBuffer(1);
-		final writeWaiters  = new PagedDeque();
-		final readWaiters   = new PagedDeque();
-		final writer        = new BoundedWriter(buffer, writeWaiters, readWaiters, new Out(), Wait);
-		final scheduler     = new VirtualTimeScheduler();
-		final out           = new Out();
-		final task          = CoroRun.with(scheduler).create(node -> {
-			writer.write(10);
-		});
-
-		task.start();
-		scheduler.advanceBy(1);
-
-		Assert.isFalse(task.isActive());
-		if (Assert.isTrue(buffer.tryPeekHead(out))) {
-			Assert.equals(10, out.get());
-		}
-		Assert.isTrue(writeWaiters.isEmpty());
-	}
-
-	function test_write_wait_full_buffer() {
-		final buffer        = new CircularBuffer(1);
-		final writeWaiters  = new PagedDeque();
-		final readWaiters   = new PagedDeque();
-		final writer        = new BoundedWriter(buffer, writeWaiters, readWaiters, new Out(), Wait);
-		final scheduler     = new VirtualTimeScheduler();
-		final out           = new Out();
-		final task          = CoroRun.with(scheduler).create(node -> {
-			writer.write(20);
-		});
-
-		Assert.isTrue(buffer.tryPush(10));
-
-		task.start();
-		scheduler.advanceBy(1);
-
-		Assert.isTrue(task.isActive());
-		Assert.isFalse(writeWaiters.isEmpty());
-		if (Assert.isTrue(buffer.tryPeekHead(out))) {
-			Assert.equals(10, out.get());
-		}
-	}
-
-	function test_write_drop_write_full_buffer() {
-		final buffer        = new CircularBuffer(1);
-		final dropped       = [];
-		final maxBufferSize = 1;
-		final writeWaiters  = new PagedDeque();
-		final readWaiters   = new PagedDeque();
-		final writer        = new BoundedWriter(buffer, writeWaiters, readWaiters, new Out(), DropWrite(v -> dropped.push(v)));
-		final scheduler     = new VirtualTimeScheduler();
-		final out           = new Out();
-		final task          = CoroRun.with(scheduler).create(node -> {
-			writer.write(20);
-		});
-
-		Assert.isTrue(buffer.tryPush(10));
-
-		task.start();
-		scheduler.advanceBy(1);
-
-		Assert.isFalse(task.isActive());
-		Assert.same([ 20 ], dropped);
-		Assert.isTrue(writeWaiters.isEmpty());
-		if (Assert.isTrue(buffer.tryPeekHead(out))) {
-			Assert.equals(10, out.get());
-		}
-	}
-
-	function test_write_drop_newest_full_buffer() {
-		final buffer        = new CircularBuffer(3);
-		final dropped       = [];
-		final writeWaiters  = new PagedDeque();
-		final readWaiters   = new PagedDeque();
-		final writer        = new BoundedWriter(buffer, writeWaiters, readWaiters, new Out(), DropNewest(v -> dropped.push(v)));
-		final scheduler     = new VirtualTimeScheduler();
-		final out           = new Out();
-		final task          = CoroRun.with(scheduler).create(node -> {
-			writer.write(20);
-		});
-
-		Assert.isTrue(buffer.tryPush(1));
-		Assert.isTrue(buffer.tryPush(2));
-		Assert.isTrue(buffer.tryPush(3));
-
-		task.start();
-		scheduler.advanceBy(1);
-
-		Assert.isFalse(task.isActive());
-		Assert.same([ 3 ], dropped);
-		Assert.isTrue(writeWaiters.isEmpty());
-		if (Assert.isTrue(buffer.tryPeekHead(out))) {
-			Assert.equals(20, out.get());
-		}
-	}
-
-	function test_write_drop_oldest_full_buffer() {
-		final buffer        = new CircularBuffer(3);
-		final dropped       = [];
-		final writeWaiters  = new PagedDeque();
-		final readWaiters   = new PagedDeque();
-		final writer        = new BoundedWriter(buffer, writeWaiters, readWaiters, new Out(), DropOldest(v -> dropped.push(v)));
-		final scheduler     = new VirtualTimeScheduler();
-		final out           = new Out();
-		final task          = CoroRun.with(scheduler).create(node -> {
-			writer.write(20);
-		});
-
-		Assert.isTrue(buffer.tryPush(1));
-		Assert.isTrue(buffer.tryPush(2));
-		Assert.isTrue(buffer.tryPush(3));
-
-		task.start();
-		scheduler.advanceBy(1);
-
-		Assert.isFalse(task.isActive());
-		Assert.same([ 1 ], dropped);
-		Assert.isTrue(writeWaiters.isEmpty());
-		if (Assert.isTrue(buffer.tryPeekHead(out))) {
-			Assert.equals(20, out.get());
-		}
-	}
-
-	function test_write_wakup_all_readers() {
-		final buffer        = new CircularBuffer(1);
-		final writeWaiters  = new PagedDeque();
-		final readWaiters   = new PagedDeque();
-		final writer        = new BoundedWriter(buffer, writeWaiters, readWaiters, new Out(), Wait);
-		final scheduler     = new VirtualTimeScheduler();
-		final expected      = [];
-		final task          = CoroRun.with(scheduler).create(node -> {
-			writer.write(10);
-		});
-
-		readWaiters.push(new TestContinuation(expected, _ -> '1'));
-		readWaiters.push(new TestContinuation(expected, _ -> '2'));
-
-		task.start();
-		scheduler.advanceBy(1);
-
-		Assert.isFalse(task.isActive());
-		Assert.isTrue(readWaiters.isEmpty());
-		Assert.same([ '1', '2' ], expected);
-	}
-
-	function test_write_full_buffer_wakeup() {
-		final buffer        = new CircularBuffer(1);
-		final writeWaiters  = new PagedDeque();
-		final readWaiters   = new PagedDeque();
-		final writer        = new BoundedWriter(buffer, writeWaiters, readWaiters, new Out(), Wait);
-		final scheduler     = new VirtualTimeScheduler();
-		final task          = CoroRun.with(scheduler).create(node -> {
-			writer.write(10);
-		});
-
-		Assert.isTrue(buffer.tryPush(5));
-
-		task.start();
-		scheduler.advanceBy(1);
-
-		Assert.isTrue(task.isActive());
-
-		final out = new Out();
-		if (Assert.isTrue(buffer.tryPeekHead(out))) {
-			Assert.equals(5, out.get());
-		}
-
-		Assert.isTrue(buffer.tryPopHead(out));
-		Assert.isTrue(buffer.wasEmpty());
-		writeWaiters.pop().succeedAsync(true);
-
-		scheduler.advanceBy(1);
-
-		Assert.isFalse(task.isActive());
-		if (Assert.isTrue(buffer.tryPeekHead(out))) {
-			Assert.equals(10, out.get());
-		}
-	}
-
-	function test_write_cancellation() {
-		final buffer        = new CircularBuffer(1);
-		final writeWaiters  = new PagedDeque();
-		final readWaiters   = new PagedDeque();
-		final writer        = new BoundedWriter(buffer, writeWaiters, readWaiters, new Out(), Wait);
-		final scheduler     = new VirtualTimeScheduler();
-		final out           = new Out();
-		final task          = CoroRun.with(scheduler).create(node -> {
-			writer.write(10);
-		});
-
-		Assert.isTrue(buffer.tryPush(5));
-
-		task.start();
-		scheduler.advanceBy(1);
-		task.cancel();
-		scheduler.advanceBy(1);
-
-		Assert.isFalse(task.isActive());
-		Assert.isOfType(task.getError(), CancellationException);
-		Assert.isTrue(writeWaiters.isEmpty());
-		if (Assert.isTrue(buffer.tryPeekHead(out))) {
-			Assert.equals(5, out.get());
-		}
-	}
-
-	function test_close_sets_out() {
-		final buffer        = new CircularBuffer(1);
-		final writeWaiters  = new PagedDeque();
-		final readWaiters   = new PagedDeque();
-		final closed        = new Out();
-		final writer        = new BoundedWriter(buffer, writeWaiters, readWaiters, closed, Wait);
-
-		closed.set(false);
-		writer.close();
-
-		Assert.isTrue(closed.get());
-	}
-
-	function test_try_write_when_closed() {
-		final buffer        = new CircularBuffer(1);
-		final writeWaiters  = new PagedDeque();
-		final readWaiters   = new PagedDeque();
-		final writer        = new BoundedWriter(buffer, writeWaiters, readWaiters, new Out(), Wait);
-
-		writer.close();
-
-		Assert.isFalse(writer.tryWrite(10));
-		Assert.isTrue(buffer.wasEmpty());
-	}
-
-	function test_wait_for_write_when_closed() {
-		final buffer        = new CircularBuffer(1);
-		final writeWaiters  = new PagedDeque();
-		final readWaiters   = new PagedDeque();
-		final writer        = new BoundedWriter(buffer, writeWaiters, readWaiters, new Out(), Wait);
-		final scheduler     = new VirtualTimeScheduler();
-		final actual        = [];
-		final task          = CoroRun.with(scheduler).create(node -> {
-			actual.push(writer.waitForWrite());
-		});
-
-		writer.close();
-
-		task.start();
-		scheduler.advanceBy(1);
-
-		Assert.same([ false ], actual);
-	}
-
-	function test_write_when_closed() {
-		final buffer        = new CircularBuffer(1);
-		final writeWaiters  = new PagedDeque();
-		final readWaiters   = new PagedDeque();
-		final writer        = new BoundedWriter(buffer, writeWaiters, readWaiters, new Out(), Wait);
-		final scheduler     = new VirtualTimeScheduler();
-		final actual        = [];
-		final task          = CoroRun.with(scheduler).create(node -> {
-			AssertAsync.raises(() -> writer.write('hello'), ChannelClosedException);
-		});
-
-		writer.close();
-
-		task.start();
-		scheduler.advanceBy(1);
-
-		Assert.isFalse(task.isActive());
-	}
-
-	function test_closing_wakesup_write_waiters() {
-		final buffer        = new CircularBuffer(1);
-		final writeWaiters  = new PagedDeque();
-		final readWaiters   = new PagedDeque();
-		final writer        = new BoundedWriter(buffer, writeWaiters, readWaiters, new Out(), Wait);
-		final scheduler     = new VirtualTimeScheduler();
-		final actual        = [];
-		final task          = CoroRun.with(scheduler).create(node -> {
-			actual.push(writer.waitForWrite());
-		});
-
-		Assert.isTrue(buffer.tryPush(0));
-
-		task.start();
-
-		scheduler.advanceBy(1);
-		Assert.same([], actual);
-
-		writer.close();
-
-		scheduler.advanceBy(1);
-		Assert.same([ false ], actual);
-	}
-
-	function test_closing_wakesup_read_waiters() {
-		final buffer        = new CircularBuffer(1);
-		final writeWaiters  = new PagedDeque();
-		final readWaiters   = new PagedDeque();
-		final writer        = new BoundedWriter(buffer, writeWaiters, readWaiters, new Out(), Wait);
-		final scheduler     = new VirtualTimeScheduler();
-		final actual        = [];
-		final task          = CoroRun.with(scheduler).create(node -> {
-			writer.waitForWrite();
-		});
-
-		readWaiters.push(new TestContinuation(actual, b -> b));
-
-		Assert.isTrue(buffer.tryPush(0));
-
-		task.start();
-
-		scheduler.advanceBy(1);
-		Assert.same([], actual);
-
-		writer.close();
-
-		scheduler.advanceBy(1);
-		Assert.same([ false ], actual);
-	}
-}

tests/misc/coroutines/src/ds/channels/TestUnboundedReader.hx

@@ -1,368 +0,0 @@
-package ds.channels;
-
-import haxe.coro.context.Context;
-import haxe.coro.IContinuation;
-import haxe.Exception;
-import haxe.exceptions.CancellationException;
-import haxe.exceptions.NotImplementedException;
-import hxcoro.ds.channels.unbounded.UnboundedReader;
-import hxcoro.ds.Out;
-import hxcoro.ds.PagedDeque;
-import hxcoro.exceptions.ChannelClosedException;
-import haxe.coro.schedulers.VirtualTimeScheduler;
-
-using hxcoro.util.Convenience;
-
-class TestUnboundedReader extends utest.Test {
-	function test_try_read_has_data() {
-		final out    = new Out();
-		final buffer = new PagedDeque();
-		final reader = new UnboundedReader(buffer, new PagedDeque(), new Out());
-
-		buffer.push(10);
-
-		Assert.isTrue(reader.tryRead(out));
-		Assert.equals(10, out.get());
-		Assert.isTrue(buffer.isEmpty());
-	}
-
-	function test_try_read_empty() {
-		final out    = new Out();
-		final buffer = new PagedDeque();
-		final reader = new UnboundedReader(buffer, new PagedDeque(), new Out());
-
-		Assert.isFalse(reader.tryRead(out));
-		Assert.isTrue(buffer.isEmpty());
-	}
-
-	function test_try_peek_has_data() {
-		final out    = new Out();
-		final buffer = new PagedDeque();
-		final reader = new UnboundedReader(buffer, new PagedDeque(), new Out());
-
-		buffer.push(10);
-
-		Assert.isTrue(reader.tryPeek(out));
-		Assert.equals(10, out.get());
-		if (Assert.isFalse(buffer.isEmpty())) {
-			Assert.equals(10, buffer.pop());
-		}
-	}
-
-	function test_try_peek_many_data() {
-		final out    = new Out();
-		final buffer = new PagedDeque();
-		final reader = new UnboundedReader(buffer, new PagedDeque(), new Out());
-
-		for (i in 0...10) {
-			buffer.push(i + 1);
-		}
-
-		Assert.isTrue(reader.tryPeek(out));
-		Assert.equals(10, out.get());
-		Assert.isFalse(buffer.isEmpty());
-	}
-
-	function test_try_peek_empty() {
-		final reader = new UnboundedReader(new PagedDeque(), new PagedDeque(), new Out());
-		final out    = new Out();
-
-		Assert.isFalse(reader.tryPeek(out));
-	}
-
-	function test_wait_for_read_has_data() {
-		final out     = new Out();
-		final buffer  = new PagedDeque();
-		final waiters = new PagedDeque();
-		final reader  = new UnboundedReader(buffer, waiters, new Out());
-
-		buffer.push(10);
-
-		final scheduler = new VirtualTimeScheduler();
-		final actual    = [];
-		final task      = CoroRun.with(scheduler).create(node -> {
-			actual.push(reader.waitForRead());
-		});
-
-		task.start();
-
-		scheduler.advanceBy(1);
-
-		Assert.isFalse(task.isActive());
-		Assert.same([ true ], actual);
-		Assert.isTrue(waiters.isEmpty());
-	}
-
-	function test_wait_for_read_empty_buffer() {
-		final out       = new Out();
-		final buffer    = new PagedDeque();
-		final waiters   = new PagedDeque();
-		final reader    = new UnboundedReader(buffer, waiters, new Out());
-		final scheduler = new VirtualTimeScheduler();
-		final actual    = [];
-		final task      = CoroRun.with(scheduler).create(node -> {
-			actual.push(reader.waitForRead());
-		});
-
-		task.start();
-
-		scheduler.advanceBy(1);
-
-		Assert.isTrue(task.isActive());
-		Assert.same([], actual);
-		Assert.isFalse(waiters.isEmpty());
-	}
-
-	function test_wait_for_read_empty_buffer_wakeup() {
-		final out       = new Out();
-		final buffer    = new PagedDeque();
-		final waiters   = new PagedDeque();
-		final reader    = new UnboundedReader(buffer, waiters, new Out());
-		final scheduler = new VirtualTimeScheduler();
-		final actual    = [];
-		final task      = CoroRun.with(scheduler).create(node -> {
-			actual.push(reader.waitForRead());
-		});
-
-		task.start();
-
-		scheduler.advanceBy(1);
-
-		waiters.pop().succeedAsync(true);
-
-		scheduler.advanceBy(1);
-
-		Assert.isFalse(task.isActive());
-		Assert.same([true], actual);
-		Assert.isTrue(waiters.isEmpty());
-	}
-
-	function test_wait_for_read_empty_buffer_cancellation() {
-		final out       = new Out();
-		final buffer    = new PagedDeque();
-		final waiters   = new PagedDeque();
-		final reader    = new UnboundedReader(buffer, waiters, new Out());
-		final scheduler = new VirtualTimeScheduler();
-		final actual    = [];
-		final task      = CoroRun.with(scheduler).create(node -> {
-			actual.push(reader.waitForRead());
-		});
-
-		task.start();
-
-		scheduler.advanceBy(1);
-
-		task.cancel();
-
-		scheduler.advanceBy(1);
-
-		Assert.isFalse(task.isActive());
-		Assert.isOfType(task.getError(), CancellationException);
-		Assert.same([], actual);
-		Assert.isTrue(waiters.isEmpty());
-	}
-
-	function test_read_has_data() {
-		final out     = new Out();
-		final buffer  = new PagedDeque();
-		final waiters = new PagedDeque();
-		final reader  = new UnboundedReader(buffer, waiters, new Out());
-
-		buffer.push(10);
-
-		final scheduler = new VirtualTimeScheduler();
-		final actual    = [];
-		final task      = CoroRun.with(scheduler).create(node -> {
-			actual.push(reader.read());
-		});
-
-		task.start();
-
-		scheduler.advanceBy(1);
-
-		Assert.isFalse(task.isActive());
-		Assert.same([ 10 ], actual);
-		Assert.isTrue(buffer.isEmpty());
-		Assert.isTrue(waiters.isEmpty());
-	}
-
-	function test_read_empty_buffer() {
-		final out       = new Out();
-		final buffer    = new PagedDeque();
-		final waiters   = new PagedDeque();
-		final reader    = new UnboundedReader(buffer, waiters, new Out());
-		final scheduler = new VirtualTimeScheduler();
-		final actual    = [];
-		final task      = CoroRun.with(scheduler).create(node -> {
-			actual.push(reader.read());
-		});
-
-		task.start();
-
-		scheduler.advanceBy(1);
-
-		Assert.isTrue(task.isActive());
-		Assert.same([], actual);
-		Assert.isTrue(buffer.isEmpty());
-		Assert.isFalse(waiters.isEmpty());
-	}
-
-	function test_read_empty_buffer_wakeup() {
-		final out       = new Out();
-		final buffer    = new PagedDeque();
-		final waiters   = new PagedDeque();
-		final reader    = new UnboundedReader(buffer, waiters, new Out());
-		final scheduler = new VirtualTimeScheduler();
-		final actual    = [];
-		final task      = CoroRun.with(scheduler).create(node -> {
-			actual.push(reader.read());
-		});
-
-		task.start();
-		
-		scheduler.advanceBy(1);
-
-		Assert.isTrue(task.isActive());
-		Assert.isTrue(buffer.isEmpty());
-
-		buffer.push(10);
-		waiters.pop().succeedAsync(true);
-
-		scheduler.advanceBy(1);
-
-		Assert.isFalse(task.isActive());
-		Assert.same([ 10 ], actual);
-		Assert.isTrue(waiters.isEmpty());
-		Assert.isTrue(buffer.isEmpty());
-	}
-
-	function test_read_cancellation() {
-		final out       = new Out();
-		final buffer    = new PagedDeque();
-		final waiters   = new PagedDeque();
-		final reader    = new UnboundedReader(buffer, waiters, new Out());
-		final scheduler = new VirtualTimeScheduler();
-		final actual    = [];
-		final task      = CoroRun.with(scheduler).create(node -> {
-			actual.push(reader.read());
-		});
-
-		task.start();
-		scheduler.advanceBy(1);
-		task.cancel();
-		scheduler.advanceBy(1);
-
-		Assert.isFalse(task.isActive());
-		Assert.isOfType(task.getError(), CancellationException);
-		Assert.isTrue(buffer.isEmpty());
-		Assert.isTrue(waiters.isEmpty());
-	}
-
-	function test_wait_for_Read_when_closed() {
-		final closed    = new Out();
-		final buffer    = new PagedDeque();
-		final waiters   = new PagedDeque();
-		final reader    = new UnboundedReader(buffer, waiters, closed);
-		final scheduler = new VirtualTimeScheduler();
-		final actual    = [];
-		final task      = CoroRun.with(scheduler).create(node -> {
-			actual.push(reader.waitForRead());
-		});
-
-		closed.set(true);
-
-		task.start();
-		scheduler.advanceBy(1);
-
-		Assert.isFalse(task.isActive());
-		Assert.same([ false ], actual);
-	}
-
-	function test_wait_for_read_when_closed_with_remaining_data() {
-		final closed    = new Out();
-		final buffer    = new PagedDeque();
-		final waiters   = new PagedDeque();
-		final reader    = new UnboundedReader(buffer, waiters, closed);
-		final scheduler = new VirtualTimeScheduler();
-		final actual    = [];
-		final task      = CoroRun.with(scheduler).create(node -> {
-			actual.push(reader.waitForRead());
-		});
-
-		buffer.push(10);
-		closed.set(true);
-
-		task.start();
-		scheduler.advanceBy(1);
-
-		Assert.isFalse(task.isActive());
-		Assert.same([ true ], actual);
-	}
-
-	function test_try_read_when_closed() {
-		final closed  = new Out();
-		final buffer  = new PagedDeque();
-		final waiters = new PagedDeque();
-		final reader  = new UnboundedReader(buffer, waiters, closed);
-
-		closed.set(true);
-
-		Assert.isFalse(reader.tryRead(new Out()));
-	}
-
-	function test_try_read_when_closed_with_remaining_data() {
-		final closed  = new Out();
-		final buffer  = new PagedDeque();
-		final waiters = new PagedDeque();
-		final reader  = new UnboundedReader(buffer, waiters, closed);
-		final out     = new Out();
-
-		buffer.push(10);
-		closed.set(true);
-
-		Assert.isTrue(reader.tryRead(out));
-		Assert.isTrue(buffer.isEmpty());
-		Assert.equals(10, out.get());
-	}
-
-	function test_read_when_closed() {
-		final closed    = new Out();
-		final buffer    = new PagedDeque();
-		final waiters   = new PagedDeque();
-		final reader    = new UnboundedReader(buffer, waiters, closed);
-		final scheduler = new VirtualTimeScheduler();
-		final actual    = [];
-		final task      = CoroRun.with(scheduler).create(node -> {
-			AssertAsync.raises(reader.read(), ChannelClosedException);
-		});
-
-		closed.set(true);
-
-		task.start();
-		scheduler.advanceBy(1);
-
-		Assert.isFalse(task.isActive());
-		Assert.same([], actual);
-	}
-
-	function test_read_when_closed_with_remaining_data() {
-		final closed    = new Out();
-		final buffer    = new PagedDeque();
-		final waiters   = new PagedDeque();
-		final reader    = new UnboundedReader(buffer, waiters, closed);
-		final scheduler = new VirtualTimeScheduler();
-		final actual    = [];
-		final task      = CoroRun.with(scheduler).create(node -> {
-			actual.push(reader.read());
-		});
-
-		closed.set(true);
-		buffer.push(10);
-
-		task.start();
-		scheduler.advanceBy(1);
-
-		Assert.isFalse(task.isActive());
-		Assert.same([10], actual);
-	}
-}

tests/misc/coroutines/src/ds/channels/TestUnboundedWriter.hx

@@ -1,261 +0,0 @@
-package ds.channels;
-
-import haxe.coro.context.Context;
-import haxe.coro.IContinuation;
-import haxe.Exception;
-import haxe.exceptions.CancellationException;
-import haxe.exceptions.NotImplementedException;
-import hxcoro.ds.channels.unbounded.UnboundedWriter;
-import hxcoro.ds.Out;
-import hxcoro.ds.PagedDeque;
-import hxcoro.exceptions.ChannelClosedException;
-import haxe.coro.schedulers.VirtualTimeScheduler;
-
-using hxcoro.util.Convenience;
-
-private class TestContinuation<T> implements IContinuation<Bool> {
-	final expected : Array<T>;
-	final mapper : Bool->T;
-
-	public var context (get, never) : Context;
-
-	function get_context():Context {
-		return Context.create(new ImmediateScheduler());
-	}
-
-	public function new(expected : Array<T>, mapper : Bool->T) {
-		this.expected = expected;
-		this.mapper   = mapper;
-	}
-
-	public function resume(result:Bool, _:Exception) {
-		expected.push(mapper(result));
-	}
-}
-
-class TestUnboundedWriter extends utest.Test {
-	function test_try_write() {
-		final out    = new Out();
-		final buffer = new PagedDeque();
-		final writer = new UnboundedWriter(buffer, new PagedDeque(), new Out());
-
-		Assert.isTrue(writer.tryWrite(1));
-		Assert.isTrue(writer.tryWrite(2));
-		Assert.isTrue(writer.tryWrite(3));
-
-		Assert.isFalse(buffer.isEmpty());
-
-		Assert.isTrue(buffer.tryPop(out));
-		Assert.equals(1, out.get());
-		Assert.isTrue(buffer.tryPop(out));
-		Assert.equals(2, out.get());
-		Assert.isTrue(buffer.tryPop(out));
-		Assert.equals(3, out.get());
-	}
-
-	function test_try_write_wakeup_all_readers() {
-		final buffer      = new PagedDeque();
-		final readWaiters = new PagedDeque();
-		final writer      = new UnboundedWriter(buffer, readWaiters, new Out());
-		final expected    = [];
-
-		readWaiters.push(new TestContinuation(expected, _ -> '1'));
-		readWaiters.push(new TestContinuation(expected, _ -> '2'));
-
-		Assert.isTrue(writer.tryWrite(10));
-		Assert.isTrue(readWaiters.isEmpty());
-		Assert.same([ '1', '2' ], expected);
-	}
-
-	function test_try_write_when_closed() {
-		final out    = new Out();
-		final buffer = new PagedDeque();
-		final writer = new UnboundedWriter(buffer, new PagedDeque(), out);
-
-		writer.close();
-
-		Assert.isFalse(writer.tryWrite(1));
-		Assert.isTrue(buffer.isEmpty());
-	}
-
-	function test_wait_for_write() {
-		final buffer      = new PagedDeque();
-		final readWaiters = new PagedDeque();
-		final writer      = new UnboundedWriter(buffer, readWaiters, new Out());
-		final scheduler   = new VirtualTimeScheduler();
-		final actual      = [];
-		final task        = CoroRun.with(scheduler).create(node -> {
-			actual.push(writer.waitForWrite());
-
-			buffer.push(0);
-
-			actual.push(writer.waitForWrite());
-		});
-
-		task.start();
-
-		scheduler.advanceBy(1);
-
-		Assert.isFalse(task.isActive());
-		Assert.same([ true, true ], actual);
-	}
-
-	function test_wait_for_write_prompt_cancellation() {
-		final buffer      = new PagedDeque();
-		final readWaiters = new PagedDeque();
-		final writer      = new UnboundedWriter(buffer, readWaiters, new Out());
-		final scheduler   = new VirtualTimeScheduler();
-		final actual      = [];
-		final task        = CoroRun.with(scheduler).create(node -> {
-			actual.push(writer.waitForWrite());
-		});
-
-		task.start();
-		task.cancel();
-
-		scheduler.advanceBy(1);
-
-		Assert.isFalse(task.isActive());
-		Assert.same([], actual);
-		Assert.isOfType(task.getError(), CancellationException);
-	}
-
-	function test_wait_for_write_when_closed() {
-		final buffer      = new PagedDeque();
-		final readWaiters = new PagedDeque();
-		final writer      = new UnboundedWriter(buffer, readWaiters, new Out());
-		final scheduler   = new VirtualTimeScheduler();
-		final actual      = [];
-		final task        = CoroRun.with(scheduler).create(node -> {
-			actual.push(writer.waitForWrite());
-		});
-
-		writer.close();
-		task.start();
-
-		scheduler.advanceBy(1);
-
-		Assert.isFalse(task.isActive());
-		Assert.same([ false ], actual);
-	}
-
-	function test_write() {
-		final out       = new Out();
-		final buffer    = new PagedDeque();
-		final writer    = new UnboundedWriter(buffer, new PagedDeque(), new Out());
-		final scheduler = new VirtualTimeScheduler();
-		final task      = CoroRun.with(scheduler).create(node -> {
-			writer.write(1);
-			writer.write(2);
-			writer.write(3);
-		});
-
-		task.start();
-
-		scheduler.advanceBy(1);
-
-		Assert.isFalse(task.isActive());
-		Assert.isFalse(buffer.isEmpty());
-
-		Assert.isTrue(buffer.tryPop(out));
-		Assert.equals(1, out.get());
-		Assert.isTrue(buffer.tryPop(out));
-		Assert.equals(2, out.get());
-		Assert.isTrue(buffer.tryPop(out));
-		Assert.equals(3, out.get());
-	}
-
-	function test_write_wakup_all_readers() {
-		final out         = new Out();
-		final buffer      = new PagedDeque();
-		final readWaiters = new PagedDeque();
-		final writer      = new UnboundedWriter(buffer, readWaiters, new Out());
-		final scheduler   = new VirtualTimeScheduler();
-		final expected    = [];
-		final task        = CoroRun.with(scheduler).create(node -> {
-			writer.write(1);
-		});
-
-		readWaiters.push(new TestContinuation(expected, _ -> '1'));
-		readWaiters.push(new TestContinuation(expected, _ -> '2'));
-
-		task.start();
-
-		task.start();
-		scheduler.advanceBy(1);
-
-		Assert.isFalse(task.isActive());
-		Assert.isTrue(readWaiters.isEmpty());
-		Assert.same([ '1', '2' ], expected);
-	}
-
-	function test_write_prompt_cancellation() {
-		final out       = new Out();
-		final buffer    = new PagedDeque();
-		final writer    = new UnboundedWriter(buffer, new PagedDeque(), new Out());
-		final scheduler = new VirtualTimeScheduler();
-		final task      = CoroRun.with(scheduler).create(node -> {
-			writer.write(1);
-		});
-
-		task.start();
-		task.cancel();
-
-		scheduler.advanceBy(1);
-
-		Assert.isFalse(task.isActive());
-		Assert.isTrue(buffer.isEmpty());
-		Assert.isOfType(task.getError(), CancellationException);
-	}
-
-	function test_write_when_closed() {
-		final buffer      = new PagedDeque();
-		final readWaiters = new PagedDeque();
-		final writer      = new UnboundedWriter(buffer, readWaiters, new Out());
-		final scheduler   = new VirtualTimeScheduler();
-		final task        = CoroRun.with(scheduler).create(node -> {
-			writer.write(0);
-		});
-
-		writer.close();
-		task.start();
-
-		scheduler.advanceBy(1);
-
-		Assert.isFalse(task.isActive());
-		Assert.isTrue(buffer.isEmpty());
-		Assert.isOfType(task.getError(), ChannelClosedException);
-	}
-
-	function test_close_sets_out() {
-		final buffer      = new PagedDeque();
-		final closed      = new Out();
-		final writer      = new UnboundedWriter(buffer, new PagedDeque(), closed);
-
-		closed.set(false);
-		writer.close();
-
-		Assert.isTrue(closed.get());
-	}
-
-	function test_closing_wakesup_read_waiters() {
-		final buffer      = new PagedDeque();
-		final readWaiters = new PagedDeque();
-		final writer      = new UnboundedWriter(buffer, readWaiters, new Out());
-		final scheduler   = new VirtualTimeScheduler();
-		final actual      = [];
-		final task        = CoroRun.with(scheduler).create(node -> {
-			yield();
-		});
-
-		readWaiters.push(new TestContinuation(actual, b -> b));
-
-		writer.close();
-
-		task.start();
-
-		scheduler.advanceBy(1);
-
-		Assert.same([ false ], actual);
-	}
-}

tests/misc/coroutines/src/features/TestCoroLocalContext.hx

@@ -1,39 +0,0 @@
-package features;
-
-import hxcoro.task.ICoroNode;
-import haxe.coro.context.Key;
-import hxcoro.task.ILocalContext;
-
-class TestCoroLocalContext extends utest.Test {
-	public function test() {
-		final stackKey = new Key<Array<String>>("stack");
-
-		function visit(node:ILocalContext) {
-			final element = node.getLocalElement(stackKey);
-			if (element == null) {
-				node.setLocalElement(stackKey, ["first time"]);
-				return;
-			}
-			if (element.length == 1) {
-				element.push("second time");
-			} else {
-				element.push('number ${element.length + 1}');
-			}
-		}
-
-		final result = CoroRun.runScoped(node -> {
-			final child1 = node.async(node -> {
-				visit(node);
-				visit(node);
-				visit(node);
-				node.getLocalElement(stackKey);
-			});
-			final child2 = node.async(node -> { });
-			visit(child2);
-			visit(child2);
-			Assert.same(["first time", "second time"], child2.getLocalElement(stackKey));
-			child1.await();
-		});
-		Assert.same(["first time", "second time", "number 3"], result);
-	}
-}

tests/misc/coroutines/src/import.hx

@@ -1,5 +0,0 @@
-import utest.Assert;
-import utest.Async;
-import haxe.coro.Coroutine;
-import hxcoro.Coro.*;
-import hxcoro.CoroRun;

tests/misc/coroutines/src/issues/aidan/Issue106.hx

@@ -1,39 +0,0 @@
-package issues.aidan;
-
-import haxe.coro.schedulers.VirtualTimeScheduler;
-import hxcoro.CoroRun;
-import hxcoro.Coro.*;
-import hxcoro.task.AbstractTask;
-
-class Issue106 extends utest.Test {
-	public function test() {
-		var scheduler = new VirtualTimeScheduler();
-
-		final numChildren = 1000;
-
-		final task = CoroRun.with(scheduler).create(node -> {
-			var k = 0;
-			for (_ in 0...numChildren) {
-				node.async(_ -> {
-					// https://github.com/Aidan63/haxe/issues/98 prevents writing a test utilizing loop variables
-					delay(Math.random() > 0.5 ? 5 : 10);
-					k++;
-				});
-			}
-			delay(11);
-			k;
-		});
-		task.start();
-		final atask:AbstractTask<Any> = cast task;
-		scheduler.advanceTo(5);
-		for (child in @:privateAccess atask.children) {
-			Assert.isTrue(child == null || child.isActive());
-		}
-		scheduler.advanceTo(10);
-		for (child in @:privateAccess atask.children) {
-			Assert.isTrue(child == null);
-		}
-		scheduler.advanceTo(11);
-		Assert.equals(numChildren, task.get());
-	}
-}

tests/misc/coroutines/src/issues/aidan/Issue108.hx

@@ -1,39 +0,0 @@
-package issues.aidan;
-
-class Issue108 extends utest.Test {
-	public function testCast() {
-		var a = [1];
-		Assert.equals(1, CoroRun.run(() -> {
-			var v = cast if (a.length == 0) {
-				null;
-			} else {
-				a.shift();
-			};
-			v;
-		}));
-	}
-
-	public function testParenthesis() {
-		var a = [1];
-		Assert.equals(1, CoroRun.run(() -> {
-			var v = (if (a.length == 0) {
-				null;
-			} else {
-				a.shift();
-			});
-			v;
-		}));
-	}
-
-	public function testMetadata() {
-		var a = [1];
-		Assert.equals(1, CoroRun.run(() -> {
-			var v = @:myMeta if (a.length == 0) {
-				null;
-			} else {
-				a.shift();
-			};
-			v;
-		}));
-	}
-}

tests/misc/coroutines/src/issues/aidan/Issue113.hx

@@ -1,158 +0,0 @@
-package issues.aidan;
-
-import structured.TestThrowingScopes;
-import haxe.coro.schedulers.VirtualTimeScheduler;
-import haxe.Exception;
-
-class Issue113 extends utest.Test {
-	function testAwaitSingleChild() {
-		var scheduler = new VirtualTimeScheduler();
-
-		final task = CoroRun.with(scheduler).create(node -> {
-			final child1 = node.async(_ -> delay(10));
-			node.awaitChildren();
-		});
-		task.start();
-		scheduler.advanceTo(9);
-		Assert.isTrue(task.isActive());
-		scheduler.advanceTo(10);
-		Assert.isFalse(task.isActive());
-	}
-
-	function testAwaitSingleThrowingChild() {
-		var scheduler = new VirtualTimeScheduler();
-
-		final task = CoroRun.with(scheduler).create(node -> {
-			final child1 = node.async(_ -> {
-				delay(10);
-				throw new Exception("thrown");
-			});
-			node.awaitChildren();
-		});
-		task.start();
-		scheduler.advanceTo(9);
-		Assert.isTrue(task.isActive());
-		scheduler.advanceTo(10);
-		Assert.isFalse(task.isActive());
-		Assert.equals("thrown", task.getError().message);
-	}
-
-	function testAwaitTwoChildren() {
-		var scheduler = new VirtualTimeScheduler();
-
-		final task = CoroRun.with(scheduler).create(node -> {
-			final child1 = node.async(_ -> delay(10));
-			final child2 = node.async(_ -> delay(20));
-			node.awaitChildren();
-		});
-		task.start();
-		scheduler.advanceTo(9);
-		Assert.isTrue(task.isActive());
-		scheduler.advanceTo(10);
-		Assert.isTrue(task.isActive());
-		scheduler.advanceTo(20);
-		Assert.isFalse(task.isActive());
-	}
-
-	function testAwaitLazyChild() {
-		var scheduler = new VirtualTimeScheduler();
-
-		final task = CoroRun.with(scheduler).create(node -> {
-			final child1 = node.lazy(_ -> delay(10));
-			node.awaitChildren();
-		});
-		task.start();
-		scheduler.advanceTo(9);
-		Assert.isTrue(task.isActive());
-		scheduler.advanceTo(10);
-		Assert.isFalse(task.isActive());
-	}
-
-	function testAwaitLazyChain() {
-		var scheduler = new VirtualTimeScheduler();
-
-		final task = CoroRun.with(scheduler).create(node -> {
-			final child1 = node.lazy(_ -> delay(10));
-			final child2 = node.lazy(_ -> {
-				child1.await();
-				delay(10);
-			});
-			node.awaitChildren();
-		});
-		task.start();
-		scheduler.advanceTo(9);
-		Assert.isTrue(task.isActive());
-		scheduler.advanceTo(10);
-		Assert.isTrue(task.isActive());
-		scheduler.advanceTo(15);
-		Assert.isTrue(task.isActive());
-		scheduler.advanceTo(20);
-		Assert.isFalse(task.isActive());
-	}
-
-	function testAwaitManyRandomChildren() {
-		var scheduler = new VirtualTimeScheduler();
-
-		final task = CoroRun.with(scheduler).create(node -> {
-			var k = 0;
-			for (_ in 0...1000) {
-				node.async(_ -> {
-					delay(Std.random(100));
-					k++;
-				});
-			}
-			node.awaitChildren();
-			k;
-		});
-		task.start();
-		Assert.isTrue(task.isActive());
-		scheduler.advanceTo(100);
-		Assert.isFalse(task.isActive());
-		Assert.equals(1000, task.get());
-	}
-
-	function testAwaitManyRandomLazyChildren() {
-		var scheduler = new VirtualTimeScheduler();
-
-		final task = CoroRun.with(scheduler).create(node -> {
-			var k = 0;
-			for (_ in 0...1000) {
-				node.lazy(_ -> {
-					delay(Std.random(100));
-					k++;
-				});
-			}
-			node.awaitChildren();
-			k;
-		});
-		task.start();
-		Assert.isTrue(task.isActive());
-		scheduler.advanceTo(100);
-		Assert.isFalse(task.isActive());
-		Assert.equals(1000, task.get());
-	}
-
-	function testAwaitManyRandomLazyChildrenAndOneOfThemThrows() {
-		var scheduler = new VirtualTimeScheduler();
-
-		final task = CoroRun.with(scheduler).create(node -> {
-			var k = 0;
-			for (_ in 0...1000) {
-				node.lazy(_ -> {
-					delay(Std.random(100));
-					k++;
-					if (k == 1000) {
-						throw new Exception('done: $k');
-					}
-				});
-			}
-			node.awaitChildren();
-			k;
-		});
-		task.start();
-		Assert.isTrue(task.isActive());
-		scheduler.advanceTo(100);
-		Assert.isFalse(task.isActive());
-		Assert.equals("done: 1000", task.getError().message);
-	}
-}

tests/misc/coroutines/src/issues/aidan/Issue124.hx

@@ -1,121 +0,0 @@
-package issues.aidan;
-
-import haxe.coro.Coroutine;
-import haxe.coro.context.Context;
-import hxcoro.task.ICoroTask;
-import hxcoro.task.CoroTask;
-import hxcoro.ds.channels.Channel;
-import hxcoro.task.ICoroNode;
-
-using issues.aidan.Issue124.NumberProducer;
-
-interface IReceiver<T> extends ICoroTask<haxe.Unit> {
-	@:coroutine function receive():T;
-}
-
-interface ISender<T> {
-	@:coroutine function send(v:T):Void;
-}
-
-class CoroChannelTask<T> extends CoroTask<haxe.Unit> implements IReceiver<T> implements ISender<T> {
-	final channel:Channel<T>;
-
-	public function new(context:Context, channel:Channel<T>) {
-		super(context, CoroTask.CoroScopeStrategy);
-		this.channel = channel;
-	}
-
-	@:coroutine public function receive() {
-		return channel.reader.read();
-	}
-
-	@:coroutine public function send(v:T) {
-		return channel.writer.write(v);
-	}
-}
-
-function produce<T>(context:Context, lambda:Coroutine<ISender<T>->Void>):IReceiver<T> {
-	final channel = Channel.createBounded({ size : 3 });
-	final task = new CoroChannelTask(context, channel);
-	final result = lambda(task, task);
-	switch result.state {
-		case Pending:
-
-		case Returned:
-			task.resume(result.result, null);
-		case Thrown:
-			task.resume(null, result.error);
-	}
-	return task;
-}
-
-class NumberProducer {
-	static public function produceNumbers(node:ICoroNode) {
-		return produce(node.context, node -> {
-			var i = 1;
-			while (true) {
-				node.send(i++);
-			}
-		});
-	}
-
-	static public function square(node:ICoroNode, numbers:IReceiver<Int>) {
-		return produce(node.context, node -> {
-			while (true) {
-				var x = numbers.receive();
-				node.send(x * x);
-			}
-		});
-	}
-
-	static public function numbersFrom(node:ICoroNode, start:Int) {
-		return produce(node.context, node -> {
-			var i = start;
-			while (true) {
-				node.send(i++);
-			}
-		});
-	}
-
-	static public function filter(node:ICoroNode, numbers:IReceiver<Int>, prime:Int) {
-		return produce(node.context, node -> {
-			while (true) {
-				final x = numbers.receive();
-				if (x % prime != 0) {
-					node.send(x);
-				}
-			}
-		});
-	}
-}
-
-class Issue124 extends utest.Test {
-	function test() {
-		final result = CoroRun.runScoped(node -> {
-			final numbers = node.produceNumbers();
-			final squares = node.square(numbers);
-			final result = [for (i in 1...10) {
-				squares.receive();
-			}];
-			node.cancelChildren();
-			result;
-		});
-		Assert.same([1, 4, 9, 16, 25, 36, 49, 64, 81], result);
-	}
-
-	function testPrime() {
-		final result = CoroRun.runScoped(node -> {
-			var cur = node.numbersFrom(2);
-			final result = [
-				for (_ in 0...10) {
-					final prime = cur.receive();
-					cur = node.filter(cur, prime);
-					prime;
-				}
-			];
-			node.cancelChildren();
-			result;
-		});
-		Assert.same([2, 3, 5, 7, 11, 13, 17, 19, 23, 29], result);
-	}
-}

tests/misc/coroutines/src/issues/aidan/Issue126.hx

@@ -1,130 +0,0 @@
-package issues.aidan;
-
-import haxe.coro.schedulers.VirtualTimeScheduler;
-import haxe.coro.schedulers.Scheduler;
-import hxcoro.ds.channels.Channel;
-import hxcoro.ds.PagedDeque;
-
-// class Junction {
-// 	var leftOpen:Bool;
-// 	var waiters:PagedDeque<SuspendedRead<Any>>;
-
-// 	public function new(leftOpen:Bool) {
-// 		this.leftOpen = leftOpen;
-// 		waiters = new PagedDeque();
-// 	}
-
-// 	function flushWaiters() {
-// 		while (!waiters.isEmpty()) {
-// 			final cont = waiters.pop();
-// 			cont.context.get(Scheduler).schedule(0, () -> cont.resume(null, null));
-// 		}
-// 	}
-
-// 	public function switchDirections() {
-// 		leftOpen = !leftOpen;
-// 		flushWaiters();
-// 	}
-
-// 	@:coroutine public function goLeft() {
-// 		if (leftOpen) {
-// 			return;
-// 		}
-// 		suspendCancellable(cont -> new SuspendedRead(cont, waiters));
-// 	}
-
-// 	public function openLeft() {
-// 		if (leftOpen) {
-// 			return;
-// 		}
-// 		leftOpen = true;
-// 		flushWaiters();
-// 	}
-
-// 	@:coroutine public function goRight() {
-// 		if (!leftOpen) {
-// 			return;
-// 		}
-// 		suspendCancellable(cont -> new SuspendedRead(cont, waiters));
-// 	}
-
-// 	public function openRight() {
-// 		if (!leftOpen) {
-// 			return;
-// 		}
-// 		leftOpen = false;
-// 		flushWaiters();
-// 	}
-// }
-
-class Issue126 extends utest.Test {
-	function test() {
-		Assert.pass('TODO!');
-		// final scheduler = new VirtualTimeScheduler();
-		// final task = CoroRun.with(scheduler).create(node -> {
-		// 	final channel = Channel.create(Bounded(1));
-		// 	@:coroutine function log(s:String) {
-		// 		channel.write('${scheduler.now()}: $s');
-		// 	}
-		// 	final junction = new Junction(true);
-		// 	final leftChild = node.async(node -> {
-		// 		while (true) {
-		// 			junction.goLeft();
-		// 			log("left");
-		// 			delay(500);
-		// 		}
-		// 	});
-		// 	final rightChild = node.async(node -> {
-		// 		while (true) {
-		// 			junction.goRight();
-		// 			log("right");
-		// 			delay(500);
-		// 		}
-		// 	});
-		// 	final directionSwitcher = node.async(node -> {
-		// 		while (true) {
-		// 			delay(2000);
-		// 			log("switching");
-		// 			junction.switchDirections();
-		// 		}
-		// 	});
-		// 	final output = [];
-		// 	while (output.length < 20) {
-		// 		output.push(channel.read());
-		// 	}
-		// 	leftChild.cancel();
-		// 	rightChild.cancel();
-		// 	directionSwitcher.cancel();
-		// 	output;
-		// });
-		// task.start();
-		// while (task.isActive()) {
-		// 	scheduler.advanceBy(1);
-		// }
-
-		// trace(task.get());
-
-		// Assert.same([
-		// 	   "0: left",
-		// 	 "500: left",
-		// 	"1000: left",
-		// 	"1500: left",
-		// 	"2000: switching",
-		// 	"2000: right",
-		// 	"2500: right",
-		// 	"3000: right",
-		// 	"3500: right",
-		// 	"4000: switching",
-		// 	"4000: left",
-		// 	"4500: left",
-		// 	"5000: left",
-		// 	"5500: left",
-		// 	"6000: switching",
-		// 	"6000: right",
-		// 	"6500: right",
-		// 	"7000: right",
-		// 	"7500: right",
-		// 	"8000: switching",
-		// ], task.get());
-	}
-}

tests/misc/coroutines/src/issues/aidan/Issue130.hx

@@ -1,33 +0,0 @@
-package issues.aidan;
-
-import haxe.coro.schedulers.VirtualTimeScheduler;
-import hxcoro.CoroRun;
-import hxcoro.Coro.*;
-
-class Issue130 extends utest.Test {
-	public function test() {
-		final count     = 10;
-		final actual    = [];
-		final scheduler = new VirtualTimeScheduler();
-		final task      = CoroRun.with(scheduler).create(node -> {
-			for (i in 0...count) {
-				node.async(_ -> {
-					final randomDelay = 100 + Std.random(400);
-					delay(randomDelay);
-					delay(500 - randomDelay);
-					actual.push(scheduler.now());
-				});
-			}
-		});
-
-		task.start();
-		while (task.isActive()) {
-			scheduler.advanceBy(1);
-		};
-
-		Assert.equals(count, actual.length);
-		for (time in actual) {
-			Assert.isTrue(time == 500i64);
-		}
-	}
-}

tests/misc/coroutines/src/issues/aidan/Issue145.hx

@@ -1,32 +0,0 @@
-package issues.aidan;
-
-@:coroutine function throwing() {
-	throw "throwing";
-}
-
-@:coroutine function throwingAfterYield() {
-	yield();
-	throw "throwing";
-}
-
-class Issue145 extends utest.Test {
-	function testSurprisinglySimple1() {
-		final result = CoroRun.run(() -> try {
-			throwing();
-			"oh no";
-		} catch(s:String) {
-			s;
-		});
-		Assert.equals("throwing", result);
-
-	}
-	function testSurprisinglySimple2() {
-		final result = CoroRun.run(() -> try {
-			throwingAfterYield();
-			"oh no";
-		} catch (s:String) {
-			s;
-		});
-		Assert.equals("throwing", result);
-	}
-}

tests/misc/coroutines/src/issues/aidan/Issue146.hx

@@ -1,9 +0,0 @@
-package issues.aidan;
-
-class Issue146 extends utest.Test {
-	function test() {
-		CoroRun.runScoped(_ -> {
-			Assert.equals("time is 123456", 'time is ${123456i64}');
-		});
-	}
-}

tests/misc/coroutines/src/issues/aidan/Issue160.hx

@@ -1,19 +0,0 @@
-package issues.aidan;
-
-private enum abstract Foo(Int) {
-	var Bar;
-}
-
-class Issue160 extends utest.Test {
-	@:coroutine function foo(f:Foo) {
-		return 0;
-	}
-
-	function test() {
-		CoroRun.runScoped(_ -> {
-			foo(Bar);
-		});
-
-		Assert.pass('Should not result in a compilation error');
-	}
-}

tests/misc/coroutines/src/issues/aidan/Issue164.hx

@@ -1,12 +0,0 @@
-package issues.aidan;
-
-class Issue164 extends utest.Test {
-	@:coroutine function f() {
-		{};
-		throw "this won't run";
-	}
-
-	function test() {
-		Assert.raises(() -> CoroRun.run(f), String);
-	}
-}

tests/misc/coroutines/src/issues/aidan/Issue165.hx

@@ -1,13 +0,0 @@
-package issues.aidan;
-
-class Issue165 extends utest.Test {
-	@:coroutine function foo(i:haxe.Int64) {
-		yield();
-
-		return i;
-	}
-
-	function test() {
-		Assert.pass();
-	}
-}

tests/misc/coroutines/src/issues/aidan/Issue167.hx

@@ -1,19 +0,0 @@
-package issues.aidan;
-
-using issues.aidan.Issue167.Foo;
-
-private class Foo {
-	@:coroutine public static function bar(s:String) {
-		delay(100);
-
-		return s;
-	}
-}
-
-class Issue167 extends utest.Test {
-	function test() {
-		Assert.equals("test", CoroRun.run(() -> {
-			"test".bar();
-		}));
-	}
-}

tests/misc/coroutines/src/issues/aidan/Issue24.hx

@@ -1,24 +0,0 @@
-package issues.aidan;
-
-class MyCont {
-	public function new() {}
-
-	public function getOrThrow():Any {
-		return "foo";
-	}
-}
-
-@:coroutine
-private function await() {
-	var safe = new MyCont();
-	return {
-		var this1 = safe.getOrThrow();
-		this1;
-	};
-}
-
-class Issue24 extends utest.Test {
-	function test() {
-		Assert.equals("foo", CoroRun.run(await));
-	}
-}

tests/misc/coroutines/src/issues/aidan/Issue27.hx

@@ -1,112 +0,0 @@
-package issues.aidan;
-
-import haxe.ValueException;
-import haxe.coro.schedulers.Scheduler;
-import haxe.coro.schedulers.VirtualTimeScheduler;
-import haxe.coro.context.Key;
-import haxe.coro.context.IElement;
-import hxcoro.task.ICoroTask;
-
-class DebugName implements IElement<DebugName> {
-	static public final key = new Key<DebugName>("DebugName");
-
-	public var name:String;
-
-	public function new(name:String) {
-		this.name = name;
-	}
-
-	public function getKey() {
-		return key;
-	}
-
-	public function toString() {
-		return '[DebugName: $name]';
-	}
-}
-
-class Issue27 extends utest.Test {
-	@:coroutine
-	function logDebug() {
-		return suspend(cont -> {
-			cont.resume(cont.context.get(DebugName).name, null);
-		});
-	}
-
-	@:coroutine
-	function modifyDebug(name:String) {
-		suspend(cont -> {
-			cont.context.get(DebugName).name = name;
-			cont.resume(null, null);
-		});
-	}
-
-	function test() {
-		CoroRun.runScoped(scope ->  {
-			scope.with(new DebugName("first name")).async(_ -> {
-				Assert.equals("first name", logDebug());
-				modifyDebug("second name");
-				Assert.equals("second name", logDebug());
-			});
-		});
-	}
-
-	function testScope() {
-		CoroRun.runScoped(node -> {
-			node.with(new DebugName("first name")).async(_ -> {
-				scope(_ -> {
-					Assert.equals("first name", logDebug());
-					modifyDebug("second name");
-					Assert.equals("second name", logDebug());
-				});
-			});
-		});
-	}
-
-	function testEntrypoint() {
-		CoroRun.with(new DebugName("first name")).run(scope -> {
-			Assert.equals("first name", logDebug());
-			modifyDebug("second name");
-			Assert.equals("second name", logDebug());
-		});
-
-		CoroRun
-			.with(new DebugName("wrong name"))
-			.with(new DebugName("first name"))
-			.run(scope -> {
-				Assert.equals("first name", logDebug());
-				modifyDebug("second name");
-				Assert.equals("second name", logDebug());
-		});
-	}
-
-	// function testSchedulerReplacement() {
-	// 	final delayed = 10000000;
-
-	// 	final scheduler = new VirtualTimeScheduler();
-	// 	final task = Coroutine.with(scheduler).create(_ -> {
-	// 		delay(delayed);
-	// 		"done";
-	// 	});
-
-	// 	task.start();
-	// 	scheduler.advanceBy(delayed);
-
-	// 	if (Assert.isFalse(task.isActive())) {
-	// 		Assert.equals("done", task.get());
-	// 	}
-
-	// 	final scheduler = new VirtualTimeScheduler();
-	// 	final task      = Coroutine.with(scheduler).create(_ -> {
-	// 		delay(delayed);
-	// 		throw "oh no";
-	// 	});
-
-	// 	task.start();
-	// 	scheduler.advanceBy(delayed);
-
-	// 	if (Assert.isFalse(task.isActive())) {
-	// 		Assert.isOfType(task.getError(), ValueException);
-	// 	}
-	// }
-}

tests/misc/coroutines/src/issues/aidan/Issue38.hx

@@ -1,13 +0,0 @@
-package issues.aidan;
-
-@:coroutine function foo() : String {
-	return suspend(cont -> {
-		cont.resume('Hello, World!', null);
-	});
-}
-
-class Issue38 extends utest.Test {
-	function test() {
-		Assert.equals("Hello, World!", CoroRun.run(foo));
-	}
-}

tests/misc/coroutines/src/issues/aidan/Issue54.hx

@@ -1,21 +0,0 @@
-package issues.aidan;
-
-@:coroutine function suspendThenThrow() {
-	delay(1);
-	throw "fail";
-}
-
-@:coroutine function f() {
-	try {
-		suspendThenThrow();
-		return "wrong";
-	} catch (e:Dynamic) {
-		return 'caught: $e';
-	}
-}
-
-class Issue54 extends utest.Test {
-	public function test() {
-		Assert.equals("caught: fail", CoroRun.run(f));
-	}
-}

tests/misc/coroutines/src/issues/aidan/Issue55.hx

@@ -1,24 +0,0 @@
-package issues.aidan;
-
-import haxe.exceptions.NotImplementedException;
-
-function throwing(v:Dynamic) {
-	throw v;
-}
-
-@:coroutine function foo(v:Dynamic) {
-	var s = try {
-		throwing(v);
-		"";
-	} catch (s:String) {
-		s;
-	}
-	return s;
-}
-
-class Issue55 extends utest.Test {
-	public function test() {
-		Assert.equals("caught", CoroRun.run(() -> foo("caught")));
-		Assert.raises(() -> CoroRun.run(() -> foo(new haxe.exceptions.NotImplementedException())), NotImplementedException);
-	}
-}

tests/misc/coroutines/src/issues/aidan/Issue59.hx

@@ -1,21 +0,0 @@
-package issues.aidan;
-
-import haxe.exceptions.NotImplementedException;
-
-function throwing() {
-	throw new NotImplementedException();
-}
-
-@:coroutine function recursion(i:Int, acc:Int) {
-	yield();
-	return if (i > 0) {
-		recursion(i - 1, acc + i);
-	} else {
-		throwing();
-	}
-}
-class Issue59 extends utest.Test {
-	public function test() {
-		Assert.raises(() -> CoroRun.run(() -> recursion(2, 0)), NotImplementedException);
-	}
-}

tests/misc/coroutines/src/issues/aidan/Issue61.hx

@@ -1,19 +0,0 @@
-package issues.aidan;
-
-import utest.Assert;
-
-class Issue61 extends utest.Test {
-	public function test() {
-		CoroRun.run(foo);
-	}
-
-    @:coroutine function foo() {
-        var a = 2;
-        yield();
-        Assert.equals(2, a);
-
-        var a = 1;
-        yield();
-        Assert.equals(1, a);
-    }
-}

tests/misc/coroutines/src/issues/aidan/Issue69.hx

@@ -1,27 +0,0 @@
-package issues.aidan;
-
-import utest.Assert;
-
-private interface IFoo {
-    @:coroutine function bar():Void;
-}
-
-private class Foo implements IFoo {
-    public function new() {}
-
-    @:coroutine public function bar() {
-        yield();
-    }
-}
-
-class Issue69 extends utest.Test {
-    public function test() {
-        CoroRun.run(() -> {
-            final f : IFoo = new Foo();
-
-            f.bar();
-        });
-
-        Assert.pass();
-    }
-}

tests/misc/coroutines/src/issues/aidan/Issue75.hx

@@ -1,26 +0,0 @@
-package issues.aidan;
-
-import utest.Assert;
-import haxe.Exception;
-
-@:coroutine function foo() {
-	suspend(cont -> {
-		cont.resume(null, new Exception("error"));
-	});
-}
-
-class Issue75 extends utest.Test {
-    public function test() {
-		var s = "";
-		CoroRun.run(() -> {
-			try {
-				foo();
-			} catch (_:Dynamic) {
-				s += 'caught';
-			}
-
-			s += 'done';
-		});
-		Assert.equals("caughtdone", s);
-    }
-}

tests/misc/coroutines/src/issues/aidan/Issue79.hx

@@ -1,16 +0,0 @@
-package issues.aidan;
-
-function someCall(v:Dynamic) {}
-
-class Issue79 extends utest.Test {
-	function test() {
-		CoroRun.run(function() {
-			someCall({
-				var a = 1;
-				someCall(a);
-				a;
-			});
-		});
-		Assert.pass();
-	}
-}

tests/misc/coroutines/src/issues/aidan/Issue90.hx

@@ -1,31 +0,0 @@
-package issues.aidan;
-
-class Issue90 extends utest.Test {
-	function testIf() {
-		var val = "foo";
-		function ret(value:String) {
-			return value;
-		}
-		Assert.equals("foo", CoroRun.run(() -> ret(val == null ? "null" : val)));
-	}
-
-	function testSwitch() {
-		var val = "foo";
-		function ret(value:String) {
-			return value;
-		}
-		Assert.equals("foo", CoroRun.run(() -> ret(switch(val) {
-			case "bar": "bar";
-			case "foo": "foo";
-			case _: "_";
-		})));
-	}
-
-	function testTry() {
-		var val = "foo";
-		function ret(value:String) {
-			return value;
-		}
-		Assert.equals("foo", CoroRun.run(() -> ret(try val catch(e:Dynamic) null)));
-	}
-}

tests/misc/coroutines/src/issues/aidan/Issue91.hx

@@ -1,25 +0,0 @@
-package issues.aidan;
-
-class C1 {
-	public function new() {}
-
-	@:coroutine public function await() {}
-}
-
-class C2 {
-	public function new() {}
-
-	@:coroutine public function await() {}
-}
-
-class Issue91 extends utest.Test {
-	function test() {
-		final c1 = new C1();
-		final c2 = new C2();
-		CoroRun.run(() -> {
-			c1.await();
-			c2.await();
-		});
-		Assert.pass();
-	}
-}

tests/misc/coroutines/src/issues/aidan/Issue93.hx

@@ -1,50 +0,0 @@
-package issues.aidan;
-
-@:coroutine function doSomethingUsefulOne() {
-	return 13;
-}
-
-@:coroutine function doSomethingUsefulTwo() {
-	return 29;
-}
-
-@:coroutine function doSomethingUsefulOneYield() {
-	yield();
-	return 13;
-}
-
-@:coroutine function doSomethingUsefulTwoYield() {
-	yield();
-	return 29;
-}
-
-function sum(a:Int, b:Int) {
-	return a + b;
-}
-
-function id(a:Int) {
-	return a;
-}
-
-class Issue93 extends utest.Test {
-	public function test() {
-		Assert.equals(13, CoroRun.run(() -> doSomethingUsefulOne()));
-		Assert.equals(13, CoroRun.run(() -> id(doSomethingUsefulOne())));
-		Assert.equals(42, CoroRun.run(() -> doSomethingUsefulOne() + doSomethingUsefulTwo()));
-		Assert.equals(42, CoroRun.run(() -> doSomethingUsefulOneYield() + doSomethingUsefulTwo()));
-		Assert.equals(42, CoroRun.run(() -> doSomethingUsefulOne() + doSomethingUsefulTwoYield()));
-		Assert.equals(42, CoroRun.run(() -> doSomethingUsefulOneYield() + doSomethingUsefulTwoYield()));
-		Assert.equals(42, CoroRun.run(() -> sum(doSomethingUsefulOne(), doSomethingUsefulTwo())));
-		Assert.equals(42, CoroRun.run(() -> sum(doSomethingUsefulOneYield(), doSomethingUsefulTwo())));
-		Assert.equals(42, CoroRun.run(() -> sum(doSomethingUsefulOne(), doSomethingUsefulTwoYield())));
-		Assert.equals(42, CoroRun.run(() -> sum(doSomethingUsefulOneYield(), doSomethingUsefulTwoYield())));
-		Assert.equals(42, CoroRun.run(() -> id(doSomethingUsefulOne() + doSomethingUsefulTwo())));
-		Assert.equals(42, CoroRun.run(() -> id(doSomethingUsefulOneYield() + doSomethingUsefulTwo())));
-		Assert.equals(42, CoroRun.run(() -> id(doSomethingUsefulOne() + doSomethingUsefulTwoYield())));
-		Assert.equals(42, CoroRun.run(() -> id(doSomethingUsefulOneYield() + doSomethingUsefulTwoYield())));
-		Assert.equals(42, CoroRun.run(() -> id(sum(doSomethingUsefulOne(), doSomethingUsefulTwo()))));
-		Assert.equals(42, CoroRun.run(() -> id(sum(doSomethingUsefulOneYield(), doSomethingUsefulTwo()))));
-		Assert.equals(42, CoroRun.run(() -> id(sum(doSomethingUsefulOne(), doSomethingUsefulTwoYield()))));
-		Assert.equals(42, CoroRun.run(() -> id(sum(doSomethingUsefulOneYield(), doSomethingUsefulTwoYield()))));
-	}
-}

tests/misc/coroutines/src/schedulers/TestVirtualTimeScheduler.hx

@@ -1,177 +0,0 @@
-package schedulers;
-
-import haxe.coro.schedulers.VirtualTimeScheduler;
-import haxe.exceptions.ArgumentException;
-
-class TestVirtualTimeScheduler extends utest.Test {
-	public function test_time_after_advancing_by() {
-		final sut = new VirtualTimeScheduler();
-
-		Assert.isTrue(0i64 == sut.now());
-
-		sut.advanceBy(100);
-		Assert.isTrue(100i64 == sut.now());
-
-		sut.advanceBy(400);
-		Assert.isTrue(500i64 == sut.now());
-	}
-
-	public function test_time_after_advancing_to() {
-		final sut = new VirtualTimeScheduler();
-
-		Assert.isTrue(0i64 == sut.now());
-
-		sut.advanceTo(100);
-		Assert.isTrue(100i64 == sut.now());
-
-		sut.advanceTo(400);
-		Assert.isTrue(400i64 == sut.now());
-	}
-
-	public function test_scheduling_immediate_function() {
-		final result = [];
-		final sut    = new VirtualTimeScheduler();
-
-		sut.schedule(0, () -> result.push(0));
-		sut.run();
-
-		Assert.same([ 0 ], result);
-	}
-
-	public function test_scheduling_future_function() {
-		final result = [];
-		final sut    = new VirtualTimeScheduler();
-
-		sut.schedule(10, () -> result.push(0));
-		sut.advanceBy(10);
-
-		Assert.same([ 0 ], result);
-	}
-
-	public function test_scheduling_multiple_future_function_same_time() {
-		final result = [];
-		final sut    = new VirtualTimeScheduler();
-
-		sut.schedule(10, () -> result.push(0));
-		sut.schedule(10, () -> result.push(1));
-		sut.advanceBy(10);
-
-		Assert.same([ 0, 1 ], result);
-	}
-
-	public function test_scheduling_all_functions_up_to_time() {
-		final result = [];
-		final sut    = new VirtualTimeScheduler();
-
-		sut.schedule(10, () -> result.push(0));
-		sut.schedule(20, () -> result.push(1));
-		sut.advanceBy(20);
-
-		Assert.same([ 0, 1 ], result);
-	}
-
-	public function test_scheduling_functions_at_their_due_time() {
-		final result = [];
-		final sut    = new VirtualTimeScheduler();
-
-		sut.schedule(10, () -> result.push(sut.now()));
-		sut.schedule(20, () -> result.push(sut.now()));
-		sut.advanceBy(20);
-
-		Assert.isTrue(10i64 == result[0]);
-		Assert.isTrue(20i64 == result[1]);
-	}
-
-	public function test_scheduling_recursive_immediate_functions() {
-		final result = [];
-		final sut    = new VirtualTimeScheduler();
-
-		sut.schedule(0, () -> {
-			result.push(0);
-
-			sut.schedule(0, () -> {
-				result.push(1);
-
-				sut.schedule(0, () -> {
-					result.push(2);
-				});
-				sut.run();
-			});
-			sut.run();
-		});
-		sut.run();
-
-		Assert.same([ 0, 1, 2 ], result);
-	}
-
-	public function test_scheduling_negative_time() {
-		final sut = new VirtualTimeScheduler();
-
-		Assert.raises(() -> sut.schedule(-1, () -> {}), ArgumentException);
-	}
-
-	public function test_advancing_by_negative_time() {
-		final sut = new VirtualTimeScheduler();
-
-		Assert.raises(() -> sut.advanceBy(-1), ArgumentException);
-	}
-
-	public function test_advancing_to_the_past() {
-		final sut = new VirtualTimeScheduler();
-
-		sut.advanceTo(1000);
-
-		Assert.raises(() -> sut.advanceTo(500), ArgumentException);
-	}
-
-	public function test_cancelling_scheduled_event() {
-		final result = [];
-		final sut    = new VirtualTimeScheduler();
-		final _      = sut.schedule(10, () -> result.push(0));
-		final handle = sut.schedule(20, () -> result.push(1));
-		final _      = sut.schedule(30, () -> result.push(2));
-
-		handle.close();
-
-		sut.advanceTo(30);
-
-		Assert.same([ 0, 2 ], result);
-	}
-
-	public function test_cancelling_head() {
-		final result = [];
-		final sut    = new VirtualTimeScheduler();
-		final handle = sut.schedule(10, () -> result.push(0));
-		final _      = sut.schedule(20, () -> result.push(1));
-
-		handle.close();
-
-		sut.advanceTo(20);
-
-		Assert.same([ 1 ], result);
-	}
-
-	public function test_cancelling_single_head() {
-		final result = [];
-		final sut    = new VirtualTimeScheduler();
-		final handle = sut.schedule(10, () -> result.push(0));
-
-		handle.close();
-
-		sut.advanceTo(10);
-
-		Assert.same([], result);
-	}
-
-	public function test_cancelling_executed_function() {
-		final result = [];
-		final sut    = new VirtualTimeScheduler();
-		final handle = sut.schedule(10, () -> result.push(0));
-
-		sut.advanceTo(10);
-
-		handle.close();
-
-		Assert.same([ 0 ], result);
-	}
-}

tests/misc/coroutines/src/structured/TestCancellingSuspend.hx

@@ -1,156 +0,0 @@
-package structured;
-
-import haxe.coro.ICancellableContinuation;
-import haxe.coro.schedulers.VirtualTimeScheduler;
-import haxe.coro.cancellation.CancellationToken;
-import haxe.exceptions.ArgumentException;
-import haxe.exceptions.CancellationException;
-
-class TestCancellingSuspend extends utest.Test {
-	function test_callback() {
-		final actual    = [];
-		final scheduler = new VirtualTimeScheduler();
-		final task      = CoroRun.with(scheduler).create(node -> {
-			timeout(100, _ -> {
-				suspendCancellable(cont -> {
-					cont.onCancellationRequested = _ -> {
-						actual.push(scheduler.now());
-					}
-				});
-			});
-		});
-
-		task.start();
-
-		scheduler.advanceBy(100);
-
-		Assert.equals(1, actual.length);
-		Assert.isTrue(100i64 == actual[0]);
-		Assert.isFalse(task.isActive());
-		Assert.isOfType(task.getError(), CancellationException);
-	}
-
-	function test_resuming_successfully() {
-		final scheduler = new VirtualTimeScheduler();
-		final task      = CoroRun.with(scheduler).create(node -> {
-			AssertAsync.raises(() -> {
-				suspendCancellable(cont -> {
-					scheduler.schedule(0, () -> {
-						cont.resume(null, null);
-					});
-				});
-			}, CancellationException);
-		});
-
-		task.start();
-		task.cancel();
-
-		scheduler.advanceBy(0);
-
-		Assert.isFalse(task.isActive());
-		Assert.isOfType(task.getError(), CancellationException);
-	}
-
-	function test_failing() {
-		final scheduler = new VirtualTimeScheduler();
-		final task      = CoroRun.with(scheduler).create(node -> {
-			AssertAsync.raises(() -> {
-				suspendCancellable(cont -> {
-					scheduler.schedule(0, () -> {
-						cont.resume(null, new ArgumentException(''));
-					});
-				});
-			}, CancellationException);
-		});
-
-		task.start();
-		task.cancel();
-
-		scheduler.advanceBy(0);
-
-		Assert.isFalse(task.isActive());
-		Assert.isOfType(task.getError(), CancellationException);
-	}
-
-	function test_callback_is_unregistered() {
-		final actual    = [];
-		final scheduler = new VirtualTimeScheduler();
-		final task      = CoroRun.with(scheduler).create(node -> {
-			suspendCancellable(cont -> {
-				cont.onCancellationRequested = _ -> {
-					Assert.fail('should not be invoked');
-				}
-				cont.resume(null, null);
-			});
-
-			delay(1000);
-		});
-
-		task.start();
-
-		scheduler.advanceBy(100);
-
-		task.cancel();
-
-		scheduler.advanceBy(1);
-
-		Assert.isFalse(task.isActive());
-		Assert.isOfType(task.getError(), CancellationException);
-	}
-
-	function test_immediate_callback_execution() {
-		var stashed : ICancellableContinuation<Any> = null;
-
-		final scheduler = new VirtualTimeScheduler();
-		final task      = CoroRun.with(scheduler).create(node -> {
-			suspendCancellable(cont -> {
-				stashed = cont;
-
-				cont.resume(null, null);
-			});
-
-			node.context.get(hxcoro.task.CoroTask).cancel();
-
-			final actual = [];
-
-			stashed.onCancellationRequested = _ -> {
-				actual.push('hello');
-			}
-
-			Assert.same([ 'hello' ], actual);
-		});
-
-		task.start();
-
-		scheduler.advanceBy(1);
-
-		Assert.isFalse(task.isActive());
-	}
-
-	function test_disallow_multiple_callback_assignments() {
-		final scheduler = new VirtualTimeScheduler();
-		final task      = CoroRun.with(scheduler).create(node -> {
-			suspendCancellable(cont -> {
-				cont.onCancellationRequested = _ -> {
-					trace('foo');
-				}
-
-				Assert.raises(() -> {
-					cont.onCancellationRequested = _ -> {
-						trace('foo');
-					}
-				});
-
-				cont.resume(null, null);
-			});
-		});
-
-		task.start();
-		task.cancel();
-
-		scheduler.advanceBy(0);
-
-		Assert.isFalse(task.isActive());
-		Assert.isOfType(task.getError(), CancellationException);
-	}
-}

tests/misc/coroutines/src/structured/TestChildScopes.hx

@@ -1,225 +0,0 @@
-package structured;
-
-import haxe.coro.schedulers.VirtualTimeScheduler;
-
-class TestChildScopes extends utest.Test {
-	function test_waiting_for_child() {
-		var result = 0;
-
-		final scheduler = new VirtualTimeScheduler();
-		final task      = CoroRun.with(scheduler).create(node -> {
-			node.async(_ -> {
-				delay(1000);
-
-				result = 1;
-			});
-		});
-
-		task.start();
-
-		scheduler.advanceTo(999);
-		Assert.isTrue(task.isActive());
-		Assert.equals(result, 0);
-
-		scheduler.advanceTo(1000);
-		Assert.isFalse(task.isActive());
-		Assert.equals(result, 1);
-	}
-
-	function test_deeply_nested_child() {
-		var result = 0;
-
-		final scheduler = new VirtualTimeScheduler();
-		final task      = CoroRun.with(scheduler).create(node -> {
-			node.async(node -> {
-				node.async(node -> {
-					node.async(_ -> {
-						delay(1000);
-
-						result = 1;
-					});
-				});
-			});
-		});
-
-		task.start();
-
-		scheduler.advanceTo(999);
-		Assert.isTrue(task.isActive());
-		Assert.equals(result, 0);
-
-		scheduler.advanceTo(1000);
-		Assert.isFalse(task.isActive());
-		Assert.equals(result, 1);
-	}
-
-	function test_waiting_for_many_children() {
-		final result    = [];
-		final scheduler = new VirtualTimeScheduler();
-		final task      = CoroRun.with(scheduler).create(node -> {
-			node.async(_ -> {
-				delay(500);
-
-				result.push(0);
-			});
-
-			node.async(_ -> {
-				delay(1000);
-
-				result.push(1);
-			});
-		});
-
-		task.start();
-
-		scheduler.advanceTo(499);
-		Assert.same([], result);
-
-		scheduler.advanceTo(500);
-		Assert.same([ 0 ], result);
-
-		scheduler.advanceTo(999);
-		Assert.same([ 0 ], result);
-
-		scheduler.advanceTo(1000);
-		Assert.same([ 0, 1 ], result);
-
-		Assert.isFalse(task.isActive());
-	}
-
-	function test_waiting_for_many_nested_children() {
-		final result = [];
-
-		final scheduler = new VirtualTimeScheduler();
-		final task      = CoroRun.with(scheduler).create(node -> {
-			node.async(node -> {
-				node.async(_ -> {
-					delay(500);
-
-					result.push(0);
-				});
-			});
-
-			node.async(_ -> {
-				delay(1000);
-
-				result.push(1);
-			});
-		});
-
-		task.start();
-
-		scheduler.advanceTo(499);
-		Assert.same([], result);
-
-		scheduler.advanceTo(500);
-		Assert.same([ 0 ], result);
-
-		scheduler.advanceTo(999);
-		Assert.same([ 0 ], result);
-
-		scheduler.advanceTo(1000);
-		Assert.same([ 0, 1 ], result);
-
-		Assert.isFalse(task.isActive());
-	}
-
-	function test_awaiting_child() {
-		final expected = 'Hello, World';
-		final scheduler = new VirtualTimeScheduler();
-		final task      = CoroRun.with(scheduler).create(node -> {
-			final child = node.async(_ -> {
-				delay(1000);
-
-				return expected;
-			});
-
-			return child.await();
-		});
-
-		task.start();
-
-		scheduler.advanceTo(1000);
-		Assert.isFalse(task.isActive());
-		Assert.equals(expected, task.get());
-	}
-
-	function test_awaiting_nested_child() {
-		final expected = 'Hello, World';
-		final scheduler = new VirtualTimeScheduler();
-		final task      = CoroRun.with(scheduler).create(node -> {
-			final child = node.async(node -> {
-				return
-					node
-						.async(_ -> {
-							delay(1000);
-
-							return expected;
-						})
-						.await();
-
-			});
-
-			return child.await();
-		});
-
-		task.start();
-
-		scheduler.advanceTo(1000);
-		Assert.isFalse(task.isActive());
-		Assert.equals(expected, task.get());
-	}
-
-	function test_awaiting_single_child() {
-		var result = 0;
-
-		final scheduler = new VirtualTimeScheduler();
-		final task      = CoroRun.with(scheduler).create(node -> {
-			node.async(_ -> {
-				delay(500);
-
-				result = 1;
-			});
-
-			node
-				.async(_ -> delay(1000))
-				.await();
-		});
-
-		task.start();
-
-		scheduler.advanceTo(499);
-		Assert.isTrue(task.isActive());
-		Assert.equals(result, 0);
-
-		scheduler.advanceTo(500);
-		Assert.isTrue(task.isActive());
-		Assert.equals(result, 1);
-
-		scheduler.advanceTo(1000);
-		Assert.isFalse(task.isActive());
-		Assert.equals(result, 1);
-	}
-
-	function test_awaiting_completed_child() {
-		final expected  = 'Hello, World!';
-		final scheduler = new VirtualTimeScheduler();
-		final task      = CoroRun.with(scheduler).create(node -> {
-			final child = node.async(_ -> {
-				yield();
-
-				return expected;
-			});
-
-			delay(10);
-
-			return child.await();
-		});
-
-		task.start();
-		scheduler.advanceBy(10);
-
-		Assert.isFalse(task.isActive());
-		Assert.equals(expected, task.get());
-	}
-}

tests/misc/coroutines/src/structured/TestCoroutineScope.hx

@@ -1,206 +0,0 @@
-package structured;
-
-import haxe.Exception;
-import haxe.exceptions.CancellationException;
-import haxe.coro.schedulers.VirtualTimeScheduler;
-
-private class FooException extends Exception {
-	public function new() {
-		super('foo');
-	}
-}
-
-function has(what:Array<String>, has:Array<String>, hasNot:Array<String>, ?p:haxe.PosInfos) {
-	for (has in has) {
-		Assert.contains(has, what, null, p);
-	}
-	for (hasNot in hasNot) {
-		Assert.notContains(hasNot, what, null, p);
-	}
-}
-
-class TestCoroutineScope extends utest.Test {
-	function test_scope_returning_value_suspending() {
-		final expected = 'Hello, World';
-		final actual   = CoroRun.runScoped(_ -> {
-			return scope(_ -> {
-				yield();
-
-				return expected;
-			});
-		});
-
-		Assert.equals(expected, actual);
-	}
-
-	function test_scope_throwing_suspending() {
-		CoroRun.runScoped(_ -> {
-			AssertAsync.raises(() -> CoroRun.runScoped(_ -> {
-				yield();
-
-				throw new FooException();
-			}), FooException);
-		});
-	}
-
-	function test_scope_with_children() {
-		final actual    = [];
-		final scheduler = new VirtualTimeScheduler();
-		final task      = CoroRun.with(scheduler).create(_ -> {
-			scope(node -> {
-				node.async(_ -> {
-					delay(500);
-
-					actual.push(0);
-				});
-
-				node.async(_ -> {
-					delay(500);
-
-					actual.push(1);
-				});
-			});
-		});
-
-		task.start();
-
-		scheduler.advanceTo(499);
-		Assert.same(actual, []);
-		Assert.isTrue(task.isActive());
-
-		scheduler.advanceTo(500);
-		Assert.same(actual, [ 0, 1 ]);
-		Assert.isFalse(task.isActive());
-	}
-
-	function test_try_raise() {
-		final acc = [];
-		Assert.raises(() ->
-			CoroRun.runScoped(node -> {
-				scope(_ -> {
-					acc.push("before yield");
-					yield();
-					acc.push("after yield");
-					throw new FooException();
-					acc.push("after throw");
-				});
-				acc.push("at exit");
-			}), FooException);
-		has(acc, ["before yield", "after yield"], ["after throw", "at exit"]);
-	}
-
-	function test_try_catch() {
-		final acc = [];
-		CoroRun.runScoped(node -> {
-			try {
-				scope(_ -> {
-					acc.push("before yield");
-					yield();
-					acc.push("after yield");
-					throw new FooException();
-					acc.push("after throw");
-				});
-				acc.push("after scope");
-			} catch(e:FooException) {
-				acc.push("in catch");
-			}
-			acc.push("at exit");
-		});
-		has(acc, ["before yield", "after yield", "in catch", "at exit"], ["after throw", "after scope"]);
-	}
-
-	function test_try_raise_async() {
-		final acc = [];
-		Assert.raises(() -> CoroRun.runScoped(node -> {
-			node.async(_ -> {
-				scope(_ -> {
-					acc.push("before yield");
-					yield();
-					acc.push("after yield");
-					throw new FooException();
-					acc.push("after throw");
-				});
-			});
-			acc.push("at exit");
-		}), FooException);
-		has(acc, ["before yield", "after yield", "at exit"], ["after throw"]);
-	}
-
-	function test_parent_scope_cancelling() {
-		final acc       = [];
-		final scheduler = new VirtualTimeScheduler();
-		final task      = CoroRun.with(scheduler).create(node -> {
-			final child = node.async(_ -> {
-				try {
-					scope(node -> {
-						while (true) {
-							yield();
-						}
-						acc.push("scope 1");
-					});
-				} catch (e:CancellationException) {
-					acc.push("scope 2");
-				}
-			});
-
-			delay(1000);
-			child.cancel();
-			acc.push("scope 3");
-		});
-
-		task.start();
-		scheduler.advanceBy(1000);
-
-		has(acc, ["scope 2", "scope 3"], ["scope 1"]);
-	}
-
-	function test_cancel_due_to_sibling_exception() {
-		final acc = [];
-		Assert.raises(() -> CoroRun.runScoped(node -> {
-			node.async(_ -> {
-				scope(_ -> {
-					acc.push("before yield 2");
-					yield();
-					acc.push("after yield 2");
-					throw new FooException();
-					acc.push("after throw 2");
-				});
-			});
-			node.async(_ -> {
-				scope(_ -> {
-					acc.push("before yield 1");
-					while (true) {
-						yield();
-					}
-					acc.push("after yield 1");
-				});
-			});
-			acc.push("at exit");
-		}), FooException);
-		has(acc, ["before yield 1", "before yield 2", "after yield 2", "at exit"], ["after yield 1", "after throw 2"]);
-
-		acc.resize(0);
-		Assert.raises(() -> CoroRun.runScoped(node -> {
-			node.async(_ -> {
-				scope(_ -> {
-					acc.push("before yield 1");
-					while (true) {
-						yield();
-					}
-					acc.push("after yield 1");
-				});
-			});
-			node.async(_ -> {
-				scope(_ -> {
-					acc.push("before yield 2");
-					yield();
-					acc.push("after yield 2");
-					throw new FooException();
-					acc.push("after throw 2");
-				});
-			});
-			acc.push("at exit");
-		}), FooException);
-		has(acc, ["before yield 1", "before yield 2", "after yield 2", "at exit"], ["after yield 1", "after throw 2"]);
-	}
-}

tests/misc/coroutines/src/structured/TestLazyScopes.hx

@@ -1,74 +0,0 @@
-package structured;
-
-import structured.TestThrowingScopes.FooException;
-
-class TestLazyScopes extends utest.Test {
-	function test_create_return() {
-		final result = CoroRun.runScoped(node -> {
-			final child = node.lazy(_ -> return "foo");
-			return child.await();
-		});
-		Assert.equals("foo", result);
-	}
-
-	function test_create_throw() {
-		Assert.raises(() -> CoroRun.runScoped(node -> {
-			final child = node.lazy(_ -> throw new FooException());
-			AssertAsync.raises(() -> child.await(), FooException);
-		}), FooException);
-	}
-
-	function test_create_unlaunched() {
-		Assert.raises(() -> CoroRun.runScoped(node -> {
-			node.lazy(_ -> {
-				throw new FooException();
-			});
-		}), FooException);
-	}
-
-	function test_create_unlaunched_nested() {
-		Assert.raises(() -> CoroRun.runScoped(node -> {
-			node.lazy(node -> {
-				node.lazy(node -> {
-					throw new FooException();
-				});
-			});
-		}), FooException);
-	}
-
-	function test_create_unlaunched_yield() {
-		Assert.raises(() -> CoroRun.runScoped(node -> {
-			node.lazy(_ -> {
-				yield();
-				throw new FooException();
-			});
-		}), FooException);
-	}
-
-	function test_create_unlaunched_yield_nested() {
-		Assert.raises(() -> CoroRun.runScoped(node -> {
-			node.lazy(node -> {
-				yield();
-				node.lazy(node -> {
-					yield();
-					throw new FooException();
-				});
-			});
-		}), FooException);
-	}
-
-	function test_create_catch() {
-		final result = CoroRun.runScoped(node -> {
-			try {
-				scope(node -> {
-					final child = node.lazy(_ -> throw new FooException());
-					child.await();
-				});
-				return "wrong";
-			} catch (exc:FooException) {
-				return exc.message;
-			}
-		});
-		Assert.equals("foo", result);
-	}
-}

tests/misc/coroutines/src/structured/TestSupervisorScopes.hx

@@ -1,61 +0,0 @@
-package structured;
-
-import haxe.Exception;
-import haxe.coro.schedulers.VirtualTimeScheduler;
-
-class TestSupervisorScopes extends utest.Test {
-	function testChildThrow() {
-		final result = CoroRun.runScoped(node -> {
-			supervisor(node -> {
-				final throwingChild = node.async(_ -> throw "oh no");
-				node.awaitChildren();
-				"ok";
-			});
-		});
-		Assert.equals("ok", result);
-	}
-
-	function testChildThrowAwaitChildren() {
-		final result = CoroRun.runScoped(node -> {
-			supervisor(node -> {
-				final throwingChild = node.async(_ -> throw "oh no");
-				node.awaitChildren();
-				"ok";
-			});
-		});
-		Assert.equals("ok", result);
-	}
-
-	function testChildThrowAwait() {
-		CoroRun.runScoped(node -> {
-			AssertAsync.raises(() -> {
-				supervisor(node -> {
-					final throwingChild = node.async(_ -> throw "oh no");
-					throwingChild.await();
-				});
-			}, String);
-		});
-	}
-
-	function testChildThrowAwaitTransitive() {
-		CoroRun.runScoped(node -> {
-			AssertAsync.raises(() -> {
-				supervisor(node -> {
-					final throwingChild = node.async(_ -> throw "oh no");
-					final awaitingChild = node.async(_ -> throwingChild.await());
-					awaitingChild.await();
-				});
-			}, String);
-		});
-	}
-
-	function testThrowSelf() {
-		CoroRun.runScoped(node -> {
-			AssertAsync.raises(() -> {
-				supervisor(node -> {
-					throw "oh no";
-				});
-			}, String);
-		});
-	}
-}

tests/misc/coroutines/src/structured/TestTaskCancellation.hx

@@ -1,66 +0,0 @@
-package structured;
-
-import haxe.exceptions.CancellationException;
-import haxe.coro.schedulers.VirtualTimeScheduler;
-import haxe.coro.cancellation.ICancellationHandle;
-import haxe.coro.cancellation.ICancellationCallback;
-import hxcoro.task.CoroTask;
-
-class ResultPusherHandle implements ICancellationCallback {
-	final result:Array<Int>;
-
-	public function new(result:Array<Int>) {
-		this.result = result;
-	}
-
-	public function onCancellation(cause:CancellationException) {
-		result.push(0);
-	}
-}
-
-class TestTaskCancellation extends utest.Test {
-	public function test_cancellation_callback() {
-		final result    = [];
-		final scheduler = new VirtualTimeScheduler();
-		final task      = CoroRun.with(scheduler).create(node -> {
-			node.context.get(CoroTask).onCancellationRequested(new ResultPusherHandle(result));
-
-			delay(1000);
-		});
-
-		task.start();
-		task.cancel();
-
-		scheduler.advanceBy(1);
-
-		Assert.isFalse(task.isActive());
-		Assert.same([ 0 ], result);
-	}
-
-	public function test_closing_cancellation_callback() {
-		var handle : ICancellationHandle = null;
-
-		final result    = [];
-		final scheduler = new VirtualTimeScheduler();
-		final task      = CoroRun.with(scheduler).create(node -> {
-			handle = node.context.get(CoroTask).onCancellationRequested(new ResultPusherHandle(result));
-
-			delay(1000);
-		});
-
-		task.start();
-
-		scheduler.advanceBy(1);
-
-		handle.close();
-
-		scheduler.advanceBy(1);
-
-		task.cancel();
-
-		scheduler.advanceBy(1);
-
-		Assert.isFalse(task.isActive());
-		Assert.same([], result);
-	}
-}

tests/misc/coroutines/src/structured/TestThrowingScopes.hx

@@ -1,140 +0,0 @@
-package structured;
-
-import haxe.Exception;
-import haxe.coro.schedulers.VirtualTimeScheduler;
-
-class FooException extends Exception {
-	public function new() {
-		super('foo');
-	}
-}
-
-class TestThrowingScopes extends utest.Test {
-	public function test_error_passes_up() {
-		Assert.raises(() -> {
-			CoroRun.runScoped(node -> {
-				node.async(_ -> {
-					throw new FooException();
-				});
-			});
-		}, FooException);
-	}
-
-	public function test_error_passes_up_deep_nesting() {
-		Assert.raises(() -> {
-			CoroRun.runScoped(node -> {
-				node.async(node -> {
-					node.async(_ -> {
-						throw new FooException();
-					});
-				});
-			});
-		}, FooException);
-	}
-
-	public function test_sibling_cancelled() {
-		Assert.raises(() -> {
-			CoroRun.runScoped(node -> {
-				node.async(_ -> {
-					while (true) {
-						yield();
-					}
-				});
-
-				throw new FooException();
-			});
-		}, FooException);
-	}
-
-	public function test_recursive_children_cancelled_non_suspending_root() {
-		Assert.raises(() -> {
-			CoroRun.runScoped(node -> {
-				node.async(node -> {
-					node.async(node -> {
-						while (true) {
-							yield();
-						}
-					});
-				});
-
-				throw new FooException();
-			});
-		}, FooException);
-	}
-
-	public function test_catching_awaiting_child() {
-		Assert.raises(() -> {
-			CoroRun.runScoped(node -> {
-				final child = node.async(node -> {
-					yield();
-
-					throw new FooException();
-				});
-
-				AssertAsync.raises(() -> child.await(), FooException);
-			});
-		}, FooException);
-	}
-
-	public function test_child_throwing_cancelling_parent() {
-		final scheduler = new VirtualTimeScheduler();
-		final task      = CoroRun.with(scheduler).create(node -> {
-			final child = node.async(node -> {
-				delay(1000);
-
-				throw new FooException();
-			});
-
-			while (true) {
-				yield();
-			}
-		});
-
-		task.start();
-
-		scheduler.advanceBy(1000);
-
-		Assert.isFalse(task.isActive());
-		Assert.isOfType(task.getError(), FooException);
-	}
-
-	public function test_manually_cancelling_child() {
-		final scheduler = new VirtualTimeScheduler();
-		final task      = CoroRun.with(scheduler).create(node -> {
-			final child = node.async(node -> {
-				delay(1000);
-			});
-
-			delay(500);
-
-			child.cancel();
-		});
-
-		task.start();
-
-		scheduler.advanceBy(500);
-
-		Assert.isFalse(task.isActive());
-	}
-
-	public function test_manually_cancelling_polling_child() {
-		final scheduler = new VirtualTimeScheduler();
-		final task      = CoroRun.with(scheduler).create(node -> {
-			final child = node.async(node -> {
-				while (true) {
-					yield();
-				}
-			});
-
-			delay(500);
-
-			child.cancel();
-		});
-
-		task.start();
-
-		scheduler.advanceBy(500);
-
-		Assert.isFalse(task.isActive());
-	}
-}

tests/misc/coroutines/src/structured/TestTimeout.hx

@@ -1,103 +0,0 @@
-package structured;
-
-import haxe.Exception;
-import haxe.exceptions.ArgumentException;
-import haxe.coro.schedulers.VirtualTimeScheduler;
-import hxcoro.exceptions.TimeoutException;
-
-class TestTimeout extends utest.Test {
-	function test_timeout() {
-		final scheduler = new VirtualTimeScheduler();
-		final task      = CoroRun.with(scheduler).create(node -> {
-			return timeout(500, _ -> {
-				delay(1000);
-
-				return 10;
-			});
-		});
-
-		task.start();
-
-		scheduler.advanceBy(500);
-
-		Assert.isFalse(task.isActive());
-		Assert.isOfType(task.getError(), TimeoutException);
-	}
-
-	function test_timeout_result() {
-		final scheduler = new VirtualTimeScheduler();
-		final task      = CoroRun.with(scheduler).create(node -> {
-			return timeout(1000, _ -> {
-				delay(500);
-
-				return 10;
-			});
-		});
-
-		task.start();
-
-		scheduler.advanceBy(500);
-
-		Assert.isFalse(task.isActive());
-		Assert.equals(10, task.get());
-	}
-
-	function test_zero_timeout() {
-		final result    = [];
-		final scheduler = new VirtualTimeScheduler();
-		final task      = CoroRun.with(scheduler).create(node -> {
-			return timeout(0, _ -> {
-				result.push(0);
-			});
-		});
-
-		task.start();
-
-		scheduler.advanceBy(0);
-
-		Assert.isFalse(task.isActive());
-		Assert.same([], result);
-	}
-
-	function test_negative_timeout() {
-		final scheduler = new VirtualTimeScheduler();
-		final task      = CoroRun.with(scheduler).create(node -> {
-			return timeout(-1, _ -> {
-				delay(1000);
-			});
-		});
-
-		task.start();
-
-		scheduler.advanceBy(0);
-
-		Assert.isFalse(task.isActive());
-		Assert.isOfType(task.getError(), ArgumentException);
-	}
-
-	function test_timeout_does_not_propagate_cancellation() {
-		final scheduler = new VirtualTimeScheduler();
-		final task      = CoroRun.with(scheduler).create(node -> {
-			node.async(_ -> {
-				try {
-					timeout(500, _ -> {
-						delay(1000);
-					});
-				} catch (_) {}
-			});
-
-			return node.async(_ -> {
-				delay(100);
-
-				return 10;
-			}).await();
-		});
-
-		task.start();
-
-		scheduler.advanceBy(500);
-
-		Assert.isFalse(task.isActive());
-		Assert.equals(10, task.get());
-	}
-}

tests/misc/projects/coro/unbound-type-params/Main.hx

@@ -1,24 +0,0 @@
-import hxcoro.CoroRun;
-
-class C<TC> {
-	public function new() {}
-
-	public function test<TF>() {
-		@:coroutine function f<TL>():{tc:TC, tf:TF, tl:TL} {
-			return null;
-		}
-
-		CoroRun.run(f);
-	}
-
-	@:coroutine public function coro<TF>():{tc: TC, tf:TF} {
-		return null;
-	}
-}
-
-function main() {
-	var c = new C();
-	c.test();
-
-	CoroRun.run(c.coro);
-}

tests/misc/projects/coro/unbound-type-params/compile.hxml

@@ -1,2 +0,0 @@
---main Main
---hxb bin/out.hxb

tests/runci/targets/Cpp.hx

@@ -74,10 +74,6 @@ class Cpp {
 				runCpp("bin/cppia/Host-debug", ["bin/unit.cppia", "-jit"]);
 		}
 
-		runci.tests.CoroutineTests.run(["build-cpp.hxml"], args ->
-			runCpp("bin/cpp/Main-debug")
-		);
-
 		Display.maybeRunDisplayTests(Cpp);
 
 		changeDirectory(sysDir);

tests/runci/targets/Hl.hx

@@ -145,8 +145,6 @@ class Hl {
 		runCommand("haxe", ["compile-hlc.hxml", "--undefine", "analyzer-optimize"].concat(args));
 		buildAndRunHlc("bin/hlc", "unit", runCommand);
 
-		runci.tests.CoroutineTests.run(["build-hl.hxml"]);
-
 		changeDirectory(threadsDir);
 		buildAndRun("build.hxml", "export/threads");
 

tests/runci/targets/Js.hx

@@ -76,8 +76,6 @@ class Js {
 		changeDirectory(getMiscSubDir("es6"));
 		runCommand("haxe", ["run.hxml"]);
 
-		runci.tests.CoroutineTests.run(["build-js.hxml"]);
-
 		haxelibInstallGit("HaxeFoundation", "hxnodejs");
 		final env = Sys.environment();
 		if (
@@ -125,6 +123,7 @@ class Js {
 
 		runci.targets.Jvm.getJavaDependencies(); // this is awkward
 		haxelibInstallGit("Simn", "haxeserver");
+		haxelibInstallGit("HaxeFoundation", "hxcoro");
 		changeDirectory(serverDir);
 		runCommand("haxe", ["build.hxml"]);
 		runCommand("node", ["test.js"]);

tests/runci/targets/Jvm.hx

@@ -33,10 +33,6 @@ class Jvm {
 			runCommand("java", ["-jar", "bin/unit.jar"]);
 		}
 
-		runci.tests.CoroutineTests.run(["build-jvm.hxml", "--hxb", "bin/coro.hxb"], args ->
-			runCommand("haxe", args.concat(["--hxb-lib", "bin/coro.hxb"]))
-		);
-
 		Display.maybeRunDisplayTests(Jvm);
 
 		changeDirectory(miscJavaDir);

tests/runci/targets/Lua.hx

@@ -101,8 +101,6 @@ class Lua {
 			runCommand("haxe", ["compile-lua.hxml"].concat(args).concat(luaVer));
 			runCommand("lua", ["bin/unit.lua"]);
 
-			runci.tests.CoroutineTests.run(["build-lua.hxml"]);
-
 			Display.maybeRunDisplayTests(Lua);
 
 			changeDirectory(sysDir);

tests/runci/targets/Macro.hx

@@ -8,8 +8,6 @@ class Macro {
 		runCommand("haxe", ["compile-macro.hxml", "--hxb", "bin/hxb/eval.zip"].concat(args));
 		runCommand("haxe", ["compile-macro.hxml", "--hxb-lib", "bin/hxb/eval.zip"].concat(args));
 
-		runci.tests.CoroutineTests.run(["build-eval.hxml"]);
-
 		changeDirectory(displayDir);
 		haxelibInstallGit("Simn", "haxeserver");
 
@@ -65,7 +63,6 @@ class Macro {
 		changeDirectory(partyDir);
 		runCommand("git", ["clone", "https://github.com/HaxeFoundation/hxcoro", "hxcoro"]);
 		changeDirectory("hxcoro");
-		runCommand("git", ["checkout", "setup-haxelib"]); // TODO: remove once merged
 		runCommand("haxelib", ["newrepo"]);
 		runCommand("haxelib", ["git", "utest", "https://github.com/Aidan63/utest.git", "coro"]);
 		runCommand("haxelib", ["dev", "hxcoro", "."]);

tests/runci/targets/Neko.hx

@@ -8,8 +8,6 @@ class Neko {
 		runCommand("haxe", ["compile-neko.hxml", "-D", "dump", "-D", "dump_ignore_var_ids"].concat(args));
 		runCommand("neko", ["bin/unit.n"]);
 
-		runci.tests.CoroutineTests.run(["build-neko.hxml"]);
-
 		changeDirectory(getMiscSubDir('neko'));
 		runCommand("haxe", ["run.hxml"].concat(args));
 

tests/runci/targets/Php.hx

@@ -89,8 +89,6 @@ class Php {
 			runCommand("haxe", ["compile-php.hxml"].concat(prefix).concat(args));
 			runCommand("php", generateArgs(binDir + "/index.php"));
 
-			runci.tests.CoroutineTests.run(["build-php.hxml"]);
-
 			Display.maybeRunDisplayTests(Php);
 
 			changeDirectory(sysDir);

tests/runci/targets/Python.hx

@@ -67,8 +67,6 @@ class Python {
 			runCommand(py, ["bin/unit34.py"]);
 		}
 
-		runci.tests.CoroutineTests.run(["build-python.hxml"]);
-
 		Display.maybeRunDisplayTests(Python);
 
 		changeDirectory(sysDir);

tests/runci/tests/CoroutineTests.hx

@@ -1,19 +0,0 @@
-package runci.tests;
-
-import runci.System.*;
-import runci.Config.*;
-
-class CoroutineTests {
-	static public function run(baseArgs:Array<String>, ?afterwards:(args:Array<String>) -> Void) {
-		infoMsg("Test coroutines:");
-		changeDirectory(getMiscSubDir("coroutines"));
-		// for (opt in [[], ["-D", "coroutine.noopt"]]) {
-			var args = baseArgs;
-			infoMsg("Running " + args.join(" "));
-			runCommand("haxe", args);
-			if (afterwards != null) {
-				afterwards(args);
-			}
-		// }
-	}
-}

tests/server/build.hxml

@@ -4,6 +4,7 @@
 -js test.js
 -lib hxnodejs
 -lib utest
+-lib hxcoro
 -lib haxeserver
 -D analyzer-optimize
 -D UTEST-PRINT-TESTS