ActorsTesting.ns

Newspeak3
'Actors'
class ActorsTesting usingPlatform: p actors: a testActor: ta minitest: m = (|
	private TestActor = ta.
	private TestContext = m TestContext.
	private MessageNotUnderstood = p kernel MessageNotUnderstood.
	private List = p collections List.
	private Resolver = a Resolver.
	private Timer = a Timer.
	private Stopwatch = p kernel Stopwatch.
	private Actor = a Actor.
	private Promise = a Promise.
|) (
class FooError = Error () (
) : (
)
class HappensAfterChecker eventCount: n = (|
	events = List new.
	eventCount = n.
	resolver = Resolver new.
	public whenDone = resolver promise.
|) (
public check: event happensAfter: predecessor = (
	nil = predecessor ifFalse:
		[(events includes: predecessor) ifFalse:
			[resolver break: event, ' happened, but ', predecessor, ' has not yet happened'. ^self]].
	events add: event.
	events size = eventCount ifTrue: [resolver fulfill: events size].
)
) : (
)
public class MultiActorTests = TestBase () (
public testPipeliningImmediateLocalResolution1 = (
	| a1 a2 p p1 p2 |
	a1:: ((Actor named: 'otherX') seed: TestActor) <-: new.
	a2:: ((Actor named: 'otherX') seed: TestActor) <-: new.
	a1 <-: link: a2.

	p1:: a1 <-: forwardReturn42.
	p2:: a1 <-: forwardReturn42.
	p:: a1 <-: forwardNoWaitAdd: p1 and: p2.

	^assert: p resolvesTo: 84.
)
public testPipeliningImmediateLocalResolution1Forking = (
	| a1 a2 p p1 p2 |
	a1:: ((Actor named: 'otherX') seed: TestActor) <-: new.
	a2:: ((Actor named: 'otherX') seed: TestActor) <-: new.
	a1 <-: link: a2.

	p1:: a1 <-: forwardReturn42.
	p1 <-: yourself.
	p2:: a1 <-: forwardReturn42.
	p2 <-: yourself.
	p:: a1 <-: forwardNoWaitAdd: p1 and: p2. (* Questionable. *)

	^assert: p resolvesTo: 84.
)
public testTokenRingPassByRef = (
	| a1 a2 a3 p |
	a1:: ((Actor named: 'A1') seed: TestActor) <-: new.
	a2:: ((Actor named: 'A2') seed: TestActor) <-: new.
	a3:: ((Actor named: 'A3') seed: TestActor) <-: new.
	a1 <-: link: a2.
	a3 <-: link: a3.

	p:: a1 <-: pass: self.

	^assert: p resolvesTo: self.
)
public testTokenRingPromisePostResolved = (
	| a1 a2 a3 r p |
	a1:: ((Actor named: 'A1') seed: TestActor) <-: new.
	a2:: ((Actor named: 'A2') seed: TestActor) <-: new.
	a3:: ((Actor named: 'A3') seed: TestActor) <-: new.
	a1 <-: link: a2.
	a3 <-: link: a3.

	r:: Resolver new.
	p:: a1 <-: pass: r promise.
	r fulfill: #after.

	^assert: p resolvesTo: #after.
)
public testTokenRingPromisePreResolved = (
	| a1 a2 a3 r p |
	a1:: ((Actor named: 'A1') seed: TestActor) <-: new.
	a2:: ((Actor named: 'A2') seed: TestActor) <-: new.
	a3:: ((Actor named: 'A3') seed: TestActor) <-: new.
	a1 <-: link: a2.
	a3 <-: link: a3.

	r:: Resolver new.
	r fulfill: #before.
	p:: a1 <-: pass: r promise.

	^assert: p resolvesTo: #before.
)
public testTokenRingValue = (
	| a1 a2 a3 p |
	a1:: ((Actor named: 'A1') seed: TestActor) <-: new.
	a2:: ((Actor named: 'A2') seed: TestActor) <-: new.
	a3:: ((Actor named: 'A3') seed: TestActor) <-: new.
	a1 <-: link: a2.
	a3 <-: link: a3.

	p:: a1 <-: pass: #token.

	^assert: p resolvesTo: #token.
)
) : (
TEST_CONTEXT = ()
)
public class SingleActorTests = TestBase () (
public factorial: n = (
	^n > 1
		ifTrue: [(self <-: factorial: n - 1) <-: * n]
		ifFalse: [1]
)
public returnBrokenPromise = (
	^self <-: doesNotExist
)
public returnPromise = (
	^self <-: yourself
)
public returnPromise: n = (
	^n = 0
		ifTrue: [self]
		ifFalse: [self <-: returnPromise: n - 1].
)
public run: block = (
	^block value
)
public signalError = (
	Error signal: 'some error'.
)
public testAddPromises = (
	(* :todo: Do we want this property? What this tests is really an issue with the Number implementation, not the Promise implementation, namely it uses a double-dispatching the works with proxies. *)
	(* | p1 p2 |
	p1:: Resolver new fulfill: 3; promise.
	p2:: Resolver new fulfill: 4; promise.

	assert: p1 + p2 equals: 7. *)
)
public testBrokenPromiseContagion1 = (
	| p |
	p:: (self <-: signalError) <-: doesNotExist.

	^assert: p smashedWith: Error. (* Not MessageNotUnderstood *)
)
public testBrokenPromiseContagion2 = (
	| p |
	p:: (self <-: signalError) <-: yourself.

	^assert: p smashedWith: Error.
)
public testBrokenPromiseContagion3 = (
	| p |
	p:: when: (self <-: signalError) fulfilled: [halt].

	^assert: p smashedWith: Error.
)
public testChainAfterBroken = (
	| r p r2 p2 |
	r:: Resolver new.
	p:: r promise.
	r2:: Resolver new.
	p2:: r2 promise.
	when: p fulfilled: [halt] broken: [when: p fulfilled: [halt] broken: [r2 fulfill: 42]].
	r break: 21.

	^assert: p2 resolvesTo: 42.
)
public testChainAfterForwarded = (
	| r p r2 p2 p3 |
	r:: Resolver new.
	p:: r promise.
	r2:: Resolver new.
	p2:: r2 promise.
	when: p fulfilled: [:res | deny: res isPromise].
	p3:: [ (*A*) [ when: p (*B*) fulfilled: [r2 fulfill: 42]] <-: value. 21] <-: value.
	assert: [p3 isPromise].
	r fulfill: p3.

	(* No way to guarantee B happens after p is resolved to p3, but this happens in the current implementation. *)

	^assert: p2 resolvesTo: 42.
)
public testChainAfterResolved = (
	| r p r2 p2 |
	r:: Resolver new.
	p:: r promise.
	r2:: Resolver new.
	p2:: r2 promise.
	when: p fulfilled: [when: p fulfilled: [r2 fulfill: 42]].
	r fulfill: 21.

	^assert: p2 resolvesTo: 42.
)
public testChainPromiseToError = (
	| p |
	p:: self <-: returnBrokenPromise.
	assert: [p isPromise].

	^assert: p smashedWith: MessageNotUnderstood.
)
public testChainPromiseToValue = (
	| p |
	p:: self <-: returnPromise.
	assert: [p isPromise].

	^assert: p resolvesTo: self.
)
public testDatalock = (
	| weHaveAlwaysBeenAtWarWithEurasia epimenides |
	weHaveAlwaysBeenAtWarWithEurasia:: true.
	epimenides:: [weHaveAlwaysBeenAtWarWithEurasia <-: not].
	weHaveAlwaysBeenAtWarWithEurasia:: epimenides <-: value.

	when: weHaveAlwaysBeenAtWarWithEurasia fulfilled: [halt] broken: [halt].
)
public testDeeplyChainedPromise = (
	| p |
	p:: self <-: returnPromise: 20.
	assert: [p isPromise].

	^assert: p resolvesTo: self.
)
public testDoubleResolution = (
	| r p |
	p:: Resolver new promise.

	(* Initially settled. *)
	r:: Resolver new.
	r fulfill: 1.
	should: [r fulfill: 1] signal: Error.

	r:: Resolver new.
	r fulfill: 1.
	should: [r fulfill: p] signal: Error.

	r:: Resolver new.
	r fulfill: 1.
	should: [r break: 1] signal: Error.

	(* Initially forwarded. *)
	r:: Resolver new.
	r fulfill: p.
	should: [r fulfill: 1] signal: Error.

	r:: Resolver new.
	r fulfill: p.
	should: [r fulfill: p] signal: Error.

	r:: Resolver new.
	r fulfill: p.
	should: [r break: 1] signal: Error.

	(* Initially broken. *)
	r:: Resolver new.
	r break: 1.
	should: [r fulfill: 1] signal: Error.

	r:: Resolver new.
	r break: 1.
	should: [r fulfill: p] signal: Error.

	r:: Resolver new.
	r break: 1.
	should: [r break: 1] signal: Error.
)
public testEventualSendToNearPromiseError = (
	| p |
	p:: (self <-: yourself) <-: doesNotExist.
	assert: [p isPromise].

	^assert: p smashedWith: MessageNotUnderstood.
)
public testEventualSendToNearPromiseValue = (
	| p |
	p:: (self <-: yourself) <-: yourself.
	assert: [p isPromise].

	^assert: p resolvesTo: self.
)
public testEventualSendToNearRefError = (
	| p |
	p:: self <-: doesNotExist.
	assert: [p isPromise].

	^assert: p smashedWith: MessageNotUnderstood.
)
public testEventualSendToNearRefValue = (
	| p |
	p:: self <-: yourself.
	assert: [p isPromise].

	^assert: p resolvesTo: self.
)
public testFactorial = (
	^assert: (factorial: 10) resolvesTo: 3628800.
)
public testImmediateResolution = (
	| p p2 |
	p:: self <-: run: [3].
	p2:: self <-: run: [p + 4].

	^assert: p2 resolvesTo: 7.
)
public testImmediateSendToBroken = (
	| p |
	p:: Resolver new break: FooError new; promise.
	should: [p size] signal: Error. (* Not FooError. *)
)
public testImmediateSendToResolved = (
	| p |
	p:: Resolver new fulfill: {1. 2. 3}; promise.
	assert: p size equals: 3.
)
public testImmediateSendToUnresolved = (
	| p |
	p:: Resolver new promise.
	should: [p size] signal: Error.
)
public testMissingWhenBroken = (
	| r p |
	r:: Resolver new.
	p:: when: r promise fulfilled: [:v | halt].
	assert: [p isPromise].
	r break: Error new.

	^assert: p smashedWith: Error.
)
public testNearReferenceWhen = (
	(* Does when need to be a message to some object other than the reference being observed? *)
	(* If this doesn't work, how can one write a method that accepts input from another actor that might sometimes be a near ref because the argument was a Value but otherwise a far ref? *)
	| o p |
	o:: 42.
	p:: when: o fulfilled: [:v | v * 2] broken: [:e | fail].
	^assert: p resolvesTo: 84.
)
public testPromiseStopContagion = (
	| p |
	p:: when: (self <-: signalError)
		fulfilled: [halt]
		broken: [:e | 'Return without exception'].
	assert: [p isPromise].

	^assert: p resolvesTo: 'Return without exception'.
)
public testResolveAfterWhen = (
	| r p |
	r:: Resolver new.
	p:: r promise.
	p:: when: p fulfilled: [:v | assert: v equals: #foo. 1].
	r fulfill: #foo.

	^assert: p resolvesTo: 1.
)
public testResolveBeforeWhen = (
	| r p |
	r:: Resolver new.
	p:: r promise.
	r fulfill: #foo.
	p:: when: p fulfilled: [:v | assert: v equals: #foo. 1].

	^assert: p resolvesTo: 1.
)
public testUnresolved = (
	| r p |
	r:: Resolver new.
	p:: r promise.

	deny: [p isResolved].
)
public testViciousResolutionDirect = (
	| r p |
	r:: Resolver new.
	p:: r promise.
	r fulfill: p.

	^assert: p smashedWith: Error. (* CyclicResolutionError *)
)
public testViciousResolutionIndirect = (
	| r1 p1 r2 p2 joinResolver outstanding |
	r1:: Resolver new.
	p1:: r1 promise.
	r2:: Resolver new.
	p2:: r2 promise.

	r1 fulfill: p2.
	r2 fulfill: p1.

	outstanding:: 2.
	joinResolver:: Resolver new.
	when: p1
		fulfilled: [:resolution | joinResolver break: (Error new messageText: 'p1 was not smashed')]
		broken: [:error | outstanding:: outstanding - 1. 0 = outstanding ifTrue: [joinResolver fulfill: nil]].
	when: p2
		fulfilled: [:resolution | joinResolver break: (Error new messageText: 'p2 was not smashed')]
		broken: [:error | outstanding:: outstanding - 1. 0 = outstanding ifTrue: [joinResolver fulfill: nil]].
	^joinResolver promise
)
public testWhenBrokenError = (
	| r p |
	r:: Resolver new.
	p:: when: r promise
		fulfilled: [:v | halt]
		broken: [:e | doesNotExist].
	assert: [p isPromise].
	r break: Error new.

	^assert: p smashedWith: MessageNotUnderstood.
)
public testWhenBrokenValue = (
	| r p |
	r:: Resolver new.
	p:: when: r promise
		fulfilled: [:v | halt]
		broken: [:e | 42].
	assert: [p isPromise].
	r break: Error new.

	^assert: p resolvesTo: 42.
)
public testWhenResolvedError = (
	| r p |
	r:: Resolver new.
	p:: when: r promise
		fulfilled: [:v | Error signal: 'Something']
		broken: [:e | fail].
	assert: [p isPromise].
	r fulfill: 21.

	^assert: p smashedWith: Error.
)
public testWhenResolvedValue = (
	| r p |
	r:: Resolver new.
	p:: when: r promise
		fulfilled: [:v | v * 2]
		broken: [:e | fail].
	assert: [p isPromise].
	r fulfill: 21.

	^assert: p resolvesTo: 42.
)
) : (
TEST_CONTEXT = ()
)
class TestBase = TestContext () (
assert: promise resolvesTo: expectedValue = (
	^Promise
		when: promise
		fulfilled: [:value | assert: value equals: expectedValue]
		broken: [:error | ^failWithMessage: 'Expected resolution of ', expectedValue printString, ' but broken with ', error printString]
)
assert: promise smashedWith: expectedErrorClass = (
	^Promise
		when: promise
		fulfilled: [:value | ^failWithMessage: 'Expected broken with ', expectedErrorClass printString, ' but resolved with ', value printString]
		broken: [:error | (* assert: resolution class equals: expectedErrorClass. *)]
)
) : (
)
public class TimerTests = TestBase () (
busyMilliseconds: millis = (
	| stopwatch = Stopwatch new. |
	stopwatch start.
	[stopwatch elapsedMilliseconds < millis] whileTrue.
)
public testCoTimers = (
	| r ticks t1 t2 |
	r:: Resolver new.
	ticks:: 0.
	t1:: Timer every: 20 do: [:t | ticks:: ticks + 1].
	t2:: Timer after: 30 do: [t1 cancel. r fulfill: ticks].

	^assert: r promise resolvesTo: 1
)
public testOneShotTimer = (
	| r t |
	r:: Resolver new.
	t:: Timer after: 100 do: [deny: [t isActive]. r fulfill: 42].
	assert: [t isActive].

	^assert: r promise resolvesTo: 42
)
public testOneShotTimerInvalidCallback = (
	| fired t r |
	fired:: false.
	t:: Timer after: 4 do: [:timer | fired:: true].

	r:: Resolver new.
	Timer after: 8 do: [t cancel. r fulfill: 42].

	^when: r promise fulfilled:
		[:result |
		assert: result equals: 42.
		deny: fired]
)
public testRepeatingTimer = (
	| count ::= 0. r t |
	r:: Resolver new.
	t:: Timer every: 10 do:
		[:timer |
		assert: timer equals: t.
		count:: count + 1.
		assert: [timer isActive].
		count = 5 ifTrue: [timer cancel. deny: [timer isActive]. r fulfill: 42].
		count > 5 ifTrue: [failWithMessage: 'Cancel failed']].

	^assert: r promise resolvesTo: 42
)
public testRepeatingTimerContinuesWithExceptions = (
	| count ::= 0. r t |
	r:: Resolver new.
	t:: Timer every: 4 do:
		[:timer |
		count:: count + 1.
		count = 5
			ifTrue: [timer cancel. r fulfill: 42]
			ifFalse: [causeException]].

	^when: r promise fulfilled:
		[:result |
		 assert: result equals: 42.
		 assert: count equals: 5]
)
public testRepeatingTimerDoesNotFireMidTurn = (
	| fired t r |
	fired:: false.
	t:: Timer every: 4 do: [:timer | fired:: true. timer cancel].
	busyMilliseconds: 8.
	deny: fired.
	t cancel.

	[yieldMilliseconds: 8] ensure: [t cancel].

	deny: fired.
)
public testRepeatingTimerInvalidCallback = (
	| fired t r |
	fired:: false.
	t:: Timer every: 4 do: [fired:: true].

	r:: Resolver new.
	Timer after: 16 do: [t cancel. r fulfill: 42].

	^when: r promise fulfilled:
		[:result |
		assert: result equals: 42.
		deny: fired]
)
public testTimerDoesNotFireEarlyMicros = (
	| r s t elapsedMicros |
	r:: Resolver new.
	s:: Stopwatch new start.
	t:: Timer after: 16 do: [elapsedMicros:: s elapsedMicroseconds. r fulfill: 42].
	assert: [t isActive].

	^when: r promise fulfilled:
		[:result |
		assert: result equals: 42.
		assert: elapsedMicros >= 16000]
)
public testTimerDoesNotFireEarlyMillis = (
	| r s t elapsedMillis |
	r:: Resolver new.
	s:: Stopwatch new start.
	t:: Timer after: 16 do: [elapsedMillis:: s elapsedMilliseconds. r fulfill: 42].
	assert: [t isActive].

	^when: r promise fulfilled:
		[:result |
		assert: result equals: 42.
		assert: elapsedMillis >= 16]
)
public testTimerDoesNotFireMidTurn = (
	| fired t r |
	fired:: false.
	t:: Timer after: 4 do: [fired:: true].
	busyMilliseconds: 8.
	deny: fired.
	t cancel.

	[yieldMilliseconds: 8] ensure: [t cancel].

	deny: fired.
)
public testTimerHeapGrowth = (
	| r inOrder nextExpected |
	r:: Resolver new.
	inOrder:: true.
	nextExpected:: 1.

	1 to: 129 do: [:i |
		Timer after: 1 do:
			[nextExpected = i ifFalse: [inOrder:: false].
			 nextExpected:: nextExpected + 1.
			 nextExpected = 130 ifTrue: [r fulfill: #done]]].

	^when: r promise fulfilled:
		[:resolution |
		 assert: resolution equals: #done.
		 assert: inOrder]
)
public testTimerHeapGrowthWithCancellation = (
	| r timers inOrder nextExpected |
	r:: Resolver new.
	timers:: Array new: 129.
	inOrder:: true.
	nextExpected:: 1.

	1 to: 129 do: [:i | | timer |
		timer:: Timer after: 1 do:
			[nextExpected = i ifFalse: [inOrder:: false].
			 nextExpected:: nextExpected + 1.
			 i \\ 5 = 0 ifTrue:
				[(timers at: i + 1) cancel.
				 nextExpected:: nextExpected + 1.].
			 nextExpected = 130 ifTrue: [r fulfill: #done]].
		timers at: i put: timer].

	^when: r promise fulfilled:
		[:result |
		assert: result equals: #done.
		assert: inOrder]
)
yieldMilliseconds: millis = (
	| r |
	r:: Resolver new.
	Timer after: millis do: [r fulfill: 42].
	assert: r promise resolvesTo: 42.
)
) : (
TEST_CONTEXT = ()
)
public class TwoActorTests = TestBase () (
public echoItself: o = (
	^o <-: yourself
)
public testFarRefImmediateSend = (
	| testActorP r |
	testActorP:: ((Actor named: 'other') seed: TestActor) <-: new.
	r:: Resolver new.
	when: testActorP fulfilled:
		[:testActorRef |
		should: [testActorRef return42] signal: Error.
		r fulfill: true].

	^assert: r promise resolvesTo: true.
)
public testFarRefWhen = (
	| testActorP p |
	testActorP:: ((Actor named: 'other') seed: TestActor) <-: new.
	p:: when: testActorP fulfilled:
		[:testActorRef | when: testActorRef fulfilled: [42] broken: [21]].

	^assert: p resolvesTo: 42.
)
public testFarSendEcho = (
	| testActor p |
	testActor:: ((Actor named: 'other') seed: TestActor) <-: new.
	p:: testActor <-: echo: self.

	^assert: p resolvesTo: self.
)
public testFarSendError1 = (
	| testActor p |
	testActor:: ((Actor named: 'other') seed: TestActor) <-: new.
	p:: testActor <-: signalError.

	^assert: p smashedWith: Error.
)
public testFarSendError2 = (
	| testActor p |
	testActor:: ((Actor named: 'other') seed: TestActor) <-: new.
	p:: testActor <-: doesNotExist.

	^assert: p smashedWith: MessageNotUnderstood.
)
public testFarSendPromiseValue1 = (
	| testActor p |
	testActor:: ((Actor named: 'other') seed: TestActor) <-: new.
	p:: testActor <-: returnPromise42.

	^assert: p resolvesTo: 42.
)
public testFarSendPromiseValue2 = (
	| testActor p |
	testActor:: ((Actor named: 'other') seed: TestActor) <-: new.
	p:: testActor <-: returnPromiseYourself.

	^assert: (when: p fulfilled: [:testActorRef | testActor <-: = testActorRef]) resolvesTo: true.
)
public testFarSendValue = (
	| testActor p |
	testActor:: ((Actor named: 'other') seed: TestActor) <-: new.
	p:: testActor <-: return42.

	^assert: p resolvesTo: 42.
)
public testPipelining = (
	| testActor p |
	testActor:: ((Actor named: 'other') seed: TestActor) <-: new.
	testActor <-: Promise: Promise.

	(* add:and: should not be waiting on the 42 promises in this actor to be resolved. *)
	p:: testActor <-: waitAdd: (testActor <-: returnPromise42) and: (testActor <-: returnPromise42).

	^assert: p resolvesTo: 84.
)
public testPipeliningImmediateLocalResolution1 = (
	| testActor p p1 p2 |
	testActor:: ((Actor named: 'otherX') seed: TestActor) <-: new.

	p1:: testActor <-: return42.
	p2:: testActor <-: return42.
	p:: testActor <-: noWaitAdd: p1 and: p2.

	^assert: p resolvesTo: 84.
)
public testPipeliningImmediateLocalResolution1Forking = (
	| testActor p p1 p2 |
	testActor:: ((Actor named: 'otherX') seed: TestActor) <-: new.

	p1:: testActor <-: return42.
	p1 <-: yourself.
	p2:: testActor <-: return42.
	p2 <-: yourself.
	p:: testActor <-: noWaitAdd: p1 and: p2. (* Questionable. *)

	^assert: p resolvesTo: 84.
)
public testPipeliningImmediateLocalResolution2 = (
	| testActor r p1 p2 |
	testActor:: ((Actor named: 'other') seed: TestActor) <-: new.

	r:: Resolver new.
	p1:: 42 <-: yourself.
	p2:: 42 <-: yourself.
	[r fulfill: (testActor <-: noWaitAdd: p1 and: p2)] <-: value.

	^assert: r promise resolvesTo: 84.
)
public testPipeliningImmediateLocalResolution2Forking = (
	| testActor r p1 p2 |
	testActor:: ((Actor named: 'other') seed: TestActor) <-: new.

	r:: Resolver new.
	p1:: 42 <-: yourself.
	p1 <-: yourself.
	p2:: 42 <-: yourself.
	p2 <-: yourself.
	[r fulfill: (testActor <-: noWaitAdd: p1 and: p2)] <-: value. (* Questionable. *)

	^assert: r promise resolvesTo: 84.
)
public testPromiseForking1 = (
	| testActor p1 p2 p3 |
	testActor:: ((Actor named: 'other') seed: TestActor) <-: new.
	p1:: HappensAfterChecker <-: eventCount: 15.

	p1 <-: check: 'A' happensAfter: nil.
		p2:: testActor <-: on: p1 check: 'B' happensAfter: 'A'.
			p2 <-: check: 'C' happensAfter: 'B'.
			p2 <-: check: 'D' happensAfter: 'C'.
				testActor <-: on: p2 check: 'E' happensAfter: 'D'.
			p2 <-: check: 'F' happensAfter: 'D'.
	p1 <-: check: 'G' happensAfter: 'A'.
	p1 <-: check: 'H' happensAfter: 'G'.
		p3:: testActor <-: on: p1 check: 'I' happensAfter: 'H'.
			p3 <-: check: 'J' happensAfter: 'I'.
			p3 <-: check: 'K' happensAfter: 'J'.
				testActor <-: on: p3 check: 'L' happensAfter: 'K'.
			p3 <-: check: 'M' happensAfter: 'K'.
	p1 <-: check: 'N' happensAfter: 'H'.
	p1 <-: check: 'O' happensAfter: 'N'.

	^assert: p1 <-: whenDone resolvesTo: 15.
)
public testPromiseForking2 = (
	| testActor r p1 p2 p3 |
	testActor:: ((Actor named: 'other') seed: TestActor) <-: new.
	r:: Resolver new.
	p1:: r promise.

	p1 <-: check: 'A' happensAfter: nil.
		p2:: testActor <-: on: p1 check: 'B' happensAfter: 'A'.
			p2 <-: check: 'C' happensAfter: 'B'.
			p2 <-: check: 'D' happensAfter: 'C'.
				testActor <-: on: p2 check: 'E' happensAfter: 'D'.
			p2 <-: check: 'F' happensAfter: 'D'.
	p1 <-: check: 'G' happensAfter: 'A'.
	p1 <-: check: 'H' happensAfter: 'G'.
		p3:: testActor <-: on: p1 check: 'I' happensAfter: 'H'.
			p3 <-: check: 'J' happensAfter: 'I'.
			p3 <-: check: 'K' happensAfter: 'J'.
				testActor <-: on: p3 check: 'L' happensAfter: 'K'.
			p3 <-: check: 'M' happensAfter: 'K'.
	p1 <-: check: 'N' happensAfter: 'H'.
	p1 <-: check: 'O' happensAfter: 'N'.

	when: (testActor <-: yourself) fulfilled: [r fulfill: (HappensAfterChecker <-: eventCount: 15)].
	^assert: p1 <-: whenDone resolvesTo: 15.
)
public testPromiseLocalRemoteFlipFlop = (
	| testActor r p |
	testActor:: ((Actor named: 'other') seed: TestActor) <-: new.
	r:: Resolver new.
	p:: testActor <-: echoItself: r promise.
	p:: self <-: echoItself: p.
	p:: testActor <-: echoItself: r promise.
	p:: self <-: echoItself: p.
	p:: testActor <-: echoItself: r promise.
	p:: self <-: echoItself: p.
	r fulfill: self.

	^assert: p resolvesTo: self.
)
public testViciousResolutionIndirectWithRemotePromise = (
	| testActor r p |
	testActor:: ((Actor named: 'other') seed: TestActor) <-: new.
	r:: Resolver new.
	p:: r promise.
	r fulfill: (testActor <-: echo: p).

	^assert: p smashedWith: Error. (* CyclicResolutionError *)
)
) : (
TEST_CONTEXT = ()
)
when: ref fulfilled: onValue = (
	^Promise when: ref fulfilled: onValue
)
when: ref fulfilled: onValue broken: onError = (
	^Promise when: ref fulfilled: onValue broken: onError
)
) : (
)