runtime/tests/RuntimeTest.php at 261a3a2c3bcb813a620052ca126ae1df0ce56700 · reactphp-parallel/runtime · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
<?php

declare(strict_types=1);

namespace ReactParallel\Tests\Runtime;

use parallel\Runtime\Error\Closed;
use React\EventLoop\Loop;
use ReactParallel\EventLoop\EventLoopBridge;
use ReactParallel\Runtime\Runtime;
use TheOrville\Exceptions\LatchcombException;
use WyriHaximus\AsyncTestUtilities\AsyncTestCase;

use function React\Async\await;
use function sleep;
use function WyriHaximus\React\timedPromise;

final class RuntimeTest extends AsyncTestCase
{
    /** @test */
    public function convertSuccess(): void
    {
        $runtime = Runtime::create(new EventLoopBridge());

        try {
            $three = $runtime->run(static function (): int {
                sleep(3);

                return 3;
            });
        } finally {
            $runtime->kill();
        }

        self::assertSame(3, $three);
    }

    /** @test */
    public function convertFailure(): void
    {
        self::expectException(LatchcombException::class);
        self::expectExceptionMessage('Rethrow exception');

        $runtime = Runtime::create(new EventLoopBridge());

        try {
            $three = $runtime->run(static function (): void {
                sleep(3);

                throw new LatchcombException('Rethrow exception');
            });
        } finally {
            $runtime->close();
        }

//        self::assertSame(3, $three);
    }

    /** @test */
    public function weClosedTheThread(): void
    {
        self::expectException(Closed::class);
        self::expectExceptionMessage('Runtime closed');

        $runtime = Runtime::create(new EventLoopBridge());

        $promise = timedPromise(1, $runtime)->then(static function (Runtime $runtime) {
            return $runtime->run(static function (): int {
                return 3;
            });
        });

        Loop::futureTick(static function () use ($runtime): void {
            $runtime->close();
        });

        await($promise);
    }

    /** @test */
    public function weKilledTheThread(): void
    {
        self::expectException(Closed::class);
        self::expectExceptionMessage('Runtime closed');

        $runtime = Runtime::create(new EventLoopBridge());

        $promise = timedPromise(1, $runtime)->then(static function (Runtime $runtime) {
            return $runtime->run(static function (): int {
                return 3;
            });
        });

        Loop::futureTick(static function () use ($runtime): void {
            $runtime->kill();
        });

        await($promise);
    }
}