1
0
mirror of https://github.com/danog/amp.git synced 2024-12-12 09:29:45 +01:00
amp/test/Future/FutureTest.php
2021-12-05 10:33:49 -06:00

368 lines
10 KiB
PHP

<?php
namespace Amp\Future;
use Amp\CancelledException;
use Amp\DeferredCancellation;
use Amp\DeferredFuture;
use Amp\Future;
use Amp\PHPUnit\AsyncTestCase;
use Amp\PHPUnit\TestException;
use Amp\PHPUnit\UnhandledException;
use Amp\TimeoutCancellation;
use Revolt\EventLoop;
use function Amp\async;
use function Amp\delay;
class FutureTest extends AsyncTestCase
{
public function testIterate(): void
{
$this->expectOutputString('a=1 b=0 c=2 ');
$a = $this->delay(0.1, 'a');
$b = $this->delay(0.2, 'b');
$c = $this->delay(0.3, 'c');
foreach (Future::iterate([$b, $a, $c]) as $index => $future) {
print $future->await() . '=' . $index . ' ';
}
}
public function testIterateCancelPending(): void
{
$this->expectOutputString('');
$a = $this->delay(0.1, 'a');
$this->expectException(CancelledException::class);
foreach (Future::iterate([$a], new TimeoutCancellation(0.01)) as $index => $future) {
print $future->await() . '=' . $index . ' ';
}
}
public function testIterateCancelNonPending(): void
{
$this->expectOutputString('a=0 ');
$a = $this->delay(0.1, 'a');
$b = $this->delay(0.2, 'b');
$this->expectException(CancelledException::class);
$deferredCancellation = new DeferredCancellation;
foreach (Future::iterate([$a, $b], $deferredCancellation->getCancellation()) as $index => $future) {
$deferredCancellation->cancel();
print $future->await() . '=' . $index . ' ';
}
}
public function testIterateGenerator(): void
{
$this->expectOutputString('a=1 ');
/**
* @var \Generator<int, Future<string>, void, void>
*/
$iterator = (function () {
yield (new DeferredFuture)->getFuture();
yield $this->delay(0.1, 'a');
// Never joins
(new DeferredFuture)->getFuture()->await();
})();
foreach (Future::iterate($iterator) as $index => $future) {
print $future->await() . '=' . $index . ' ';
break;
}
}
public function testComplete(): void
{
$deferred = new DeferredFuture;
$future = $deferred->getFuture();
$deferred->complete('result');
self::assertSame('result', $future->await());
}
public function testCompleteAsync(): void
{
$deferred = new DeferredFuture;
$future = $deferred->getFuture();
EventLoop::delay(0.01, fn () => $deferred->complete('result'));
self::assertSame('result', $future->await());
}
public function testCompleteImmediate(): void
{
$future = Future::complete('result');
self::assertSame('result', $future->await());
}
public function testError(): void
{
$deferred = new DeferredFuture;
$future = $deferred->getFuture();
$deferred->error(new \Exception('foo'));
$this->expectException(\Exception::class);
$this->expectExceptionMessage('foo');
$future->await();
}
public function testErrorAsync(): void
{
$deferred = new DeferredFuture;
$future = $deferred->getFuture();
EventLoop::delay(0.01, fn () => $deferred->error(new \Exception('foo')));
$this->expectException(\Exception::class);
$this->expectExceptionMessage('foo');
$future->await();
}
public function testErrorImmediate(): void
{
$future = Future::error(new \Exception('foo'));
$this->expectException(\Exception::class);
$this->expectExceptionMessage('foo');
$future->await();
}
public function testCompleteWithFuture(): void
{
$deferred = new DeferredFuture;
$this->expectException(\Error::class);
$this->expectExceptionMessage('Cannot complete with an instance of');
$deferred->complete(Future::complete());
}
public function testCancellation(): void
{
$future = $this->delay(0.02, true);
$cancellation = new TimeoutCancellation(0.01);
$this->expectException(CancelledException::class);
$future->await($cancellation);
}
public function testCompleteBeforeCancellation(): void
{
$future = $this->delay(0.01, true);
$cancellation = new TimeoutCancellation(0.02);
self::assertTrue($future->await($cancellation));
}
public function testCompleteThenCancelJoin(): void
{
$deferred = new DeferredFuture;
$source = new DeferredCancellation;
$future = $deferred->getFuture();
EventLoop::queue(function () use ($future, $source): void {
self::assertSame(1, $future->await($source->getCancellation()));
});
$deferred->complete(1);
$source->cancel();
}
public function testUnhandledError(): void
{
$deferred = new DeferredFuture;
$deferred->error(new TestException);
unset($deferred);
$this->expectException(UnhandledException::class);
}
public function testUnhandledErrorFromFutureError(): void
{
$future = Future::error(new TestException);
unset($future);
$this->expectException(UnhandledException::class);
}
public function testIgnoringUnhandledErrors(): void
{
$deferred = new DeferredFuture;
$deferred->getFuture()->ignore();
$deferred->error(new TestException);
unset($deferred);
EventLoop::setErrorHandler($this->createCallback(0));
}
public function testIgnoreUnhandledErrorFromFutureError(): void
{
$future = Future::error(new TestException);
$future->ignore();
unset($future);
EventLoop::setErrorHandler($this->createCallback(0));
}
public function testMapWithCompleteFuture(): void
{
$future = Future::complete(1);
$future = $future->map(static fn (int $value) => $value + 1);
self::assertSame(2, $future->await());
}
public function testMapWithSuspendInCallback(): void
{
$future = Future::complete(1);
$future = $future->map(static fn (int $value) => $value + Future::complete(1)->await());
self::assertSame(2, $future->await());
}
public function testMapWithPendingFuture(): void
{
$deferred = new DeferredFuture;
$future = $deferred->getFuture();
$future = $future->map(static fn (int $value) => $value + 1);
EventLoop::delay(0.1, static fn () => $deferred->complete(1));
self::assertSame(2, $future->await());
}
public function testMapWithErrorFuture(): void
{
$future = Future::error($exception = new TestException());
$future = $future->map($this->createCallback(0));
$this->expectExceptionObject($exception);
$future->await();
}
public function testMapWithThrowingCallback(): void
{
$exception = new TestException();
$future = Future::complete(1);
$future = $future->map(static fn () => throw $exception);
$this->expectExceptionObject($exception);
$future->await();
}
public function testCatchWithCompleteFuture(): void
{
$future = Future::complete(1);
$future = $future->catch($this->createCallback(0));
self::assertSame(1, $future->await());
}
public function testCatchWithSuspendInCallback(): void
{
$future = Future::error(new TestException());
$future = $future->catch(static fn (\Throwable $exception) => Future::complete(1)->await());
self::assertSame(1, $future->await());
}
public function testCatchWithPendingFuture(): void
{
$deferred = new DeferredFuture;
$future = $deferred->getFuture();
$future = $future->catch(static fn (\Throwable $exception) => 1);
EventLoop::delay(0.1, static fn () => $deferred->error(new TestException));
self::assertSame(1, $future->await());
}
public function testCatchWithThrowingCallback(): void
{
$exception = new TestException();
$future = Future::error(new \Error());
$future = $future->catch(static fn () => throw $exception);
$this->expectExceptionObject($exception);
$future->await();
}
public function testFinallyWithCompleteFuture(): void
{
$future = Future::complete(1);
$future = $future->finally($this->createCallback(1));
self::assertSame(1, $future->await());
}
public function testFinallyWithErrorFuture(): void
{
$exception = new TestException();
$future = Future::error($exception);
$future = $future->finally($this->createCallback(1));
$this->expectExceptionObject($exception);
$future->await();
}
public function testFinallyWithSuspendInCallback(): void
{
$future = Future::complete(1);
$future = $future->finally(static fn () => Future::complete()->await());
self::assertSame(1, $future->await());
}
public function testFinallyWithPendingFuture(): void
{
$deferred = new DeferredFuture;
$future = $deferred->getFuture();
$future = $future->finally($this->createCallback(1));
EventLoop::delay(0.1, static fn () => $deferred->complete(1));
self::assertSame(1, $future->await());
}
public function testFinallyWithThrowingCallback(): void
{
$exception = new TestException();
$future = Future::complete(1);
$future = $future->finally(static fn () => throw $exception);
$this->expectExceptionObject($exception);
$future->await();
}
/**
* @template T
*
* @param float $seconds
* @param T $value
*
* @return Future<T>
*/
private function delay(float $seconds, mixed $value): Future
{
return async(
/**
* @return T
*/
static function () use ($seconds, $value): mixed {
delay($seconds);
return $value;
}
);
}
}