create-berna-stencil 1.0.46 → 1.0.48

package/src/backend/_core/vendor/phpoption/phpoption/tests/PhpOption/Tests/LazyOptionTest.php

@@ -1,357 +0,0 @@
-<?php
-
-namespace PhpOption\Tests;
-
-use PhpOption\LazyOption;
-use PhpOption\None;
-use PhpOption\Option;
-use PhpOption\Some;
-use PHPUnit\Framework\TestCase;
-
-class LazyOptionTest extends TestCase
-{
-    private static function createSubject($default = null): object
-    {
-        return new class ($default) {
-            private $default;
-
-            public function __construct($default)
-            {
-                $this->default = $default;
-            }
-
-            public function execute($v = null): Option
-            {
-                return Option::fromValue($v ?? $this->default);
-            }
-        };
-    }
-
-    private static function createInvalidSubject(): object
-    {
-        return new class {
-            public function execute($v = null)
-            {
-                return null;
-            }
-        };
-    }
-
-    public function testGetWithArgumentsAndConstructor(): void
-    {
-        $some = LazyOption::create([self::createSubject(), 'execute'], ['foo']);
-
-        self::assertSame('foo', $some->get());
-        self::assertSame('foo', $some->getOrElse(null));
-        self::assertSame('foo', $some->getOrCall('does_not_exist'));
-        self::assertSame('foo', $some->getOrThrow(new \RuntimeException('does_not_exist')));
-        self::assertFalse($some->isEmpty());
-    }
-
-    public function testGetWithArgumentsAndCreate(): void
-    {
-        $some = new LazyOption([self::createSubject(), 'execute'], ['foo']);
-
-        self::assertSame('foo', $some->get());
-        self::assertSame('foo', $some->getOrElse(null));
-        self::assertSame('foo', $some->getOrCall('does_not_exist'));
-        self::assertSame('foo', $some->getOrThrow(new \RuntimeException('does_not_exist')));
-        self::assertFalse($some->isEmpty());
-    }
-
-    public function testGetWithoutArgumentsAndConstructor(): void
-    {
-        $some = new LazyOption([self::createSubject('foo'), 'execute']);
-
-        self::assertSame('foo', $some->get());
-        self::assertSame('foo', $some->getOrElse(null));
-        self::assertSame('foo', $some->getOrCall('does_not_exist'));
-        self::assertSame('foo', $some->getOrThrow(new \RuntimeException('does_not_exist')));
-        self::assertFalse($some->isEmpty());
-    }
-
-    public function testGetWithoutArgumentsAndCreate(): void
-    {
-        $option = LazyOption::create([self::createSubject('foo'), 'execute']);
-
-        self::assertTrue($option->isDefined());
-        self::assertFalse($option->isEmpty());
-        self::assertSame('foo', $option->get());
-        self::assertSame('foo', $option->getOrElse(null));
-        self::assertSame('foo', $option->getOrCall('does_not_exist'));
-        self::assertSame('foo', $option->getOrThrow(new \RuntimeException('does_not_exist')));
-    }
-
-    public function testCallbackReturnsNull(): void
-    {
-        if (method_exists($this, 'expectException')) {
-            $this->expectException('RuntimeException');
-            $this->expectExceptionMessage('None has no value');
-        } else {
-            $this->setExpectedException('RuntimeException', 'None has no value');
-        }
-
-        $option = LazyOption::create([self::createSubject(), 'execute']);
-
-        self::assertFalse($option->isDefined());
-        self::assertTrue($option->isEmpty());
-        self::assertSame('alt', $option->getOrElse('alt'));
-        self::assertSame('alt', $option->getOrCall(function () {
-            return 'alt';
-        }));
-
-        $option->get();
-    }
-
-    public function testExceptionIsThrownIfCallbackReturnsNonOption(): void
-    {
-        $option = LazyOption::create([self::createInvalidSubject(), 'execute']);
-
-        if (method_exists($this, 'expectException')) {
-            $this->expectException('RuntimeException');
-            $this->expectExceptionMessage('Expected instance of PhpOption\Option');
-        } else {
-            $this->setExpectedException('RuntimeException', 'Expected instance of PhpOption\Option');
-        }
-
-        $option->isDefined();
-    }
-
-    public function testInvalidCallbackAndConstructor(): void
-    {
-        if (method_exists($this, 'expectException')) {
-            $this->expectException('InvalidArgumentException');
-            $this->expectExceptionMessage('Invalid callback given');
-        } else {
-            $this->setExpectedException('InvalidArgumentException', 'Invalid callback given');
-        }
-
-        new LazyOption('invalidCallback');
-    }
-
-    public function testInvalidCallbackAndCreate(): void
-    {
-        if (method_exists($this, 'expectException')) {
-            $this->expectException('InvalidArgumentException');
-            $this->expectExceptionMessage('Invalid callback given');
-        } else {
-            $this->setExpectedException('InvalidArgumentException', 'Invalid callback given');
-        }
-
-        LazyOption::create('invalidCallback');
-    }
-
-    public function testifDefined(): void
-    {
-        $called = false;
-        $self = $this;
-        LazyOption::fromValue('foo')->ifDefined(function ($v) use (&$called, $self) {
-            $called = true;
-            $self->assertSame('foo', $v);
-        });
-        self::assertTrue($called);
-    }
-
-    public function testForAll(): void
-    {
-        $called = false;
-        $self = $this;
-        self::assertInstanceOf(Some::class, LazyOption::fromValue('foo')->forAll(function ($v) use (&$called, $self) {
-            $called = true;
-            $self->assertSame('foo', $v);
-        }));
-        self::assertTrue($called);
-    }
-
-    public function testOrElse(): void
-    {
-        $some = Some::create('foo');
-        $lazy = LazyOption::create(function () use ($some) {
-            return $some;
-        });
-        self::assertSame($some, $lazy->orElse(None::create()));
-        self::assertSame($some, $lazy->orElse(Some::create('bar')));
-    }
-
-    public function testFoldLeftRight(): void
-    {
-        $callback = function () {
-        };
-
-        // Use TestOption as a concrete implementation to test with
-        $option = self::createPartialMock(TestOption::class, ['foldLeft', 'foldRight']);
-        $option->expects(self::once())
-            ->method('foldLeft')
-            ->with(5, $callback)
-            ->willReturn(6);
-        $lazyOption = new LazyOption(function () use ($option) {
-            return $option;
-        });
-        self::assertSame(6, $lazyOption->foldLeft(5, $callback));
-
-        $option->expects(self::once())
-            ->method('foldRight')
-            ->with(5, $callback)
-            ->willReturn(6);
-        $lazyOption = new LazyOption(function () use ($option) {
-            return $option;
-        });
-        self::assertSame(6, $lazyOption->foldRight(5, $callback));
-    }
-}
-
-class TestOption extends Option
-{
-    private $value;
-
-    public function __construct($value = null)
-    {
-        $this->value = $value;
-    }
-
-    public function get()
-    {
-        return $this->value;
-    }
-
-    public function getOrElse($default)
-    {
-        if ($this->isDefined()) {
-            return $this->value;
-        }
-
-        return $default;
-    }
-
-    public function getOrCall($callable)
-    {
-        if ($this->isDefined()) {
-            return $this->value;
-        }
-
-        return call_user_func($callable);
-    }
-
-    public function getOrThrow(\Exception $ex)
-    {
-        if ($this->isDefined()) {
-            return $this->value;
-        }
-
-        throw $ex;
-    }
-
-    public function isEmpty()
-    {
-        return $this->value === null;
-    }
-
-    public function isDefined()
-    {
-        return $this->value !== null;
-    }
-
-    public function orElse(Option $else)
-    {
-        if ($this->isDefined()) {
-            return $this;
-        }
-
-        return $else;
-    }
-
-    public function ifDefined($callable)
-    {
-        if ($this->isDefined()) {
-            call_user_func($callable, $this->value);
-        }
-    }
-
-    public function forAll($callable)
-    {
-        if ($this->isDefined()) {
-            call_user_func($callable, $this->value);
-        }
-    }
-
-    public function map($callable)
-    {
-        if ($this->isDefined()) {
-            return new self(call_user_func($callable, $this->value));
-        }
-
-        return $this;
-    }
-
-    public function flatMap($callable)
-    {
-        if ($this->isDefined()) {
-            return call_user_func($callable, $this->value);
-        }
-
-        return $this;
-    }
-
-    public function filter($callable)
-    {
-        if ($this->isDefined() && call_user_func($callable, $this->value)) {
-            return $this;
-        }
-
-        return None::create();
-    }
-
-    public function filterNot($callable)
-    {
-        if ($this->isDefined() && !call_user_func($callable, $this->value)) {
-            return $this;
-        }
-
-        return None::create();
-    }
-
-    public function select($value)
-    {
-        if ($this->isDefined() && $this->value === $value) {
-            return $this;
-        }
-
-        return None::create();
-    }
-
-    public function reject($value)
-    {
-        if ($this->isDefined() && $this->value !== $value) {
-            return $this;
-        }
-
-        return None::create();
-    }
-
-    public function foldLeft($initialValue, $callable)
-    {
-        if ($this->isDefined()) {
-            return call_user_func($callable, $initialValue, $this->value);
-        }
-
-        return $initialValue;
-    }
-
-    public function foldRight($initialValue, $callable)
-    {
-        if ($this->isDefined()) {
-            return call_user_func($callable, $this->value, $initialValue);
-        }
-
-        return $initialValue;
-    }
-
-    public function getIterator(): \Traversable
-    {
-        if ($this->isDefined()) {
-            return new \ArrayIterator([$this->value]);
-        }
-
-        return new \ArrayIterator([]);
-    }
-}

package/src/backend/_core/vendor/phpoption/phpoption/tests/PhpOption/Tests/NoneTest.php

@@ -1,153 +0,0 @@
-<?php
-
-namespace PhpOption\Tests;
-
-use PhpOption\None;
-use PhpOption\Some;
-use PHPUnit\Framework\TestCase;
-
-class NoneTest extends TestCase
-{
-    public function testGet(): void
-    {
-        if (method_exists($this, 'expectException')) {
-            $this->expectException('RuntimeException');
-        } else {
-            $this->setExpectedException('RuntimeException');
-        }
-
-        $none = None::create();
-        $none->get();
-    }
-
-    public function testGetOrElse(): void
-    {
-        $none = None::create();
-        self::assertSame('foo', $none->getOrElse('foo'));
-    }
-
-    public function testGetOrCall(): void
-    {
-        $none = None::create();
-        self::assertSame('foo', $none->getOrCall(function () {
-            return 'foo';
-        }));
-    }
-
-    public function testGetOrThrow(): void
-    {
-        if (method_exists($this, 'expectException')) {
-            $this->expectException('RuntimeException');
-            $this->expectExceptionMessage('Not Found!');
-        } else {
-            $this->setExpectedException('RuntimeException', 'Not Found!');
-        }
-
-        None::create()->getOrThrow(new \RuntimeException('Not Found!'));
-    }
-
-    public function testIsEmpty(): void
-    {
-        $none = None::create();
-        self::assertTrue($none->isEmpty());
-    }
-
-    public function testOrElse(): void
-    {
-        $option = Some::create('foo');
-        self::assertSame($option, None::create()->orElse($option));
-    }
-
-    public function testifDefined(): void
-    {
-        $none = None::create();
-
-        self::assertNull($none->ifDefined(function () {
-            throw new \LogicException('Should never be called.');
-        }));
-    }
-
-    public function testForAll(): void
-    {
-        $none = None::create();
-
-        self::assertSame($none, $none->forAll(function () {
-            throw new \LogicException('Should never be called.');
-        }));
-    }
-
-    public function testMap(): void
-    {
-        $none = None::create();
-
-        self::assertSame($none, $none->map(function () {
-            throw new \LogicException('Should not be called.');
-        }));
-    }
-
-    public function testFlatMap(): void
-    {
-        $none = None::create();
-
-        self::assertSame($none, $none->flatMap(function () {
-            throw new \LogicException('Should not be called.');
-        }));
-    }
-
-    public function testFilter(): void
-    {
-        $none = None::create();
-
-        self::assertSame($none, $none->filter(function () {
-            throw new \LogicException('Should not be called.');
-        }));
-    }
-
-    public function testFilterNot(): void
-    {
-        $none = None::create();
-
-        self::assertSame($none, $none->filterNot(function () {
-            throw new \LogicException('Should not be called.');
-        }));
-    }
-
-    public function testSelect(): void
-    {
-        $none = None::create();
-
-        self::assertSame($none, $none->select(null));
-    }
-
-    public function testReject(): void
-    {
-        $none = None::create();
-
-        self::assertSame($none, $none->reject(null));
-    }
-
-    public function testForeach(): void
-    {
-        $none = None::create();
-
-        $called = 0;
-        foreach ($none as $value) {
-            $called++;
-        }
-
-        self::assertSame(0, $called);
-    }
-
-    public function testFoldLeftRight(): void
-    {
-        $none = None::create();
-
-        self::assertSame(1, $none->foldLeft(1, function () {
-            $this->fail();
-        }));
-
-        self::assertSame(1, $none->foldRight(1, function () {
-            $this->fail();
-        }));
-    }
-}

package/src/backend/_core/vendor/phpoption/phpoption/tests/PhpOption/Tests/OptionTest.php

@@ -1,166 +0,0 @@
-<?php
-
-namespace PhpOption\Tests;
-
-use ArrayAccess;
-use LogicException;
-use PhpOption\LazyOption;
-use PhpOption\None;
-use PhpOption\Option;
-use PhpOption\Some;
-use PHPUnit\Framework\TestCase;
-
-class OptionTest extends TestCase
-{
-    public function testfromValueWithDefaultNoneValue(): void
-    {
-        self::assertInstanceOf(None::class, Option::fromValue(null));
-        self::assertInstanceOf(Some::class, Option::fromValue('value'));
-    }
-
-    public function testFromValueWithFalseNoneValue(): void
-    {
-        self::assertInstanceOf(None::class, Option::fromValue(false, false));
-        self::assertInstanceOf(Some::class, Option::fromValue('value', false));
-        self::assertInstanceOf(Some::class, Option::fromValue(null, false));
-    }
-
-    public function testFromArraysValue(): void
-    {
-        self::assertEquals(None::create(), Option::fromArraysValue('foo', 'bar'));
-        self::assertEquals(None::create(), Option::fromArraysValue(null, 'bar'));
-        self::assertEquals(None::create(), Option::fromArraysValue(['foo' => 'bar'], 'baz'));
-        self::assertEquals(None::create(), Option::fromArraysValue(['foo' => null], 'foo'));
-        self::assertEquals(None::create(), Option::fromArraysValue(['foo' => 'bar'], null));
-        self::assertEquals(new Some('foo'), Option::fromArraysValue(['foo' => 'foo'], 'foo'));
-        self::assertEquals(new Some('foo'), Option::fromArraysValue([13 => 'foo'], 13));
-
-        $object = new SomeArrayObject();
-        $object['foo'] = 'foo';
-        self::assertEquals(new Some('foo'), Option::fromArraysValue($object, 'foo'));
-
-        $object = new SomeArrayObject();
-        $object[13] = 'foo';
-        self::assertEquals(new Some('foo'), Option::fromArraysValue($object, 13));
-    }
-
-    public function testFromReturn(): void
-    {
-        $null = function () {
-        };
-        $false = function () {
-            return false;
-        };
-        $some = function () {
-            return 'foo';
-        };
-
-        self::assertTrue(Option::fromReturn($null)->isEmpty());
-        self::assertFalse(Option::fromReturn($false)->isEmpty());
-        self::assertTrue(Option::fromReturn($false, [], false)->isEmpty());
-        self::assertTrue(Option::fromReturn($some)->isDefined());
-        self::assertFalse(Option::fromReturn($some, [], 'foo')->isDefined());
-    }
-
-    public function testOrElse(): void
-    {
-        $a = new Some('a');
-        $b = new Some('b');
-
-        self::assertSame('a', $a->orElse($b)->get());
-    }
-
-    public function testOrElseWithNoneAsFirst(): void
-    {
-        $a = None::create();
-        $b = new Some('b');
-
-        self::assertSame('b', $a->orElse($b)->get());
-    }
-
-    public function testOrElseWithLazyOptions(): void
-    {
-        $throws = function () {
-            throw new LogicException('Should never be called.');
-        };
-
-        $a = new Some('a');
-        $b = new LazyOption($throws);
-
-        self::assertSame('a', $a->orElse($b)->get());
-    }
-
-    public function testOrElseWithMultipleAlternatives(): void
-    {
-        $throws = new LazyOption(function () {
-            throw new LogicException('Should never be called.');
-        });
-        $returns = new LazyOption(function () {
-            return new Some('foo');
-        });
-
-        $a = None::create();
-
-        self::assertSame('foo', $a->orElse($returns)->orElse($throws)->get());
-    }
-
-    public function testLift(): void
-    {
-        $f = function ($a, $b) {
-            return $a + $b;
-        };
-
-        $fL = Option::lift($f);
-
-        $a = new Some(1);
-        $b = new Some(5);
-        $n = None::create();
-
-        self::assertSame(6, $fL($a, $b)->get());
-        self::assertSame(6, $fL($b, $a)->get());
-        self::assertSame($n, $fL($a, $n));
-        self::assertSame($n, $fL($n, $a));
-        self::assertSame($n, $fL($n, $n));
-    }
-
-    public function testLiftDegenerate(): void
-    {
-        $f = function () {
-        };
-
-        $fL1 = Option::lift($f);
-        $fL2 = Option::lift($f, false);
-
-        self::assertEquals(None::create(), $fL1());
-        self::assertEquals(Some::create(null), $fL2());
-    }
-}
-
-class SomeArrayObject implements ArrayAccess
-{
-    private $data = [];
-
-    #[\ReturnTypeWillChange]
-    public function offsetExists($offset)
-    {
-        return isset($this->data[$offset]);
-    }
-
-    #[\ReturnTypeWillChange]
-    public function offsetGet($offset)
-    {
-        return $this->data[$offset];
-    }
-
-    #[\ReturnTypeWillChange]
-    public function offsetSet($offset, $value)
-    {
-        $this->data[$offset] = $value;
-    }
-
-    #[\ReturnTypeWillChange]
-    public function offsetUnset($offset)
-    {
-        unset($this->data[$offset]);
-    }
-}