create-prisma-php-app 1.0.0

package/vendor/ramsey/uuid/tests/Generator/UnixTimeGeneratorTest.php

@@ -0,0 +1,204 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Test\Generator;
+
+use DateTimeImmutable;
+use Mockery;
+use Mockery\MockInterface;
+use Ramsey\Uuid\Generator\RandomBytesGenerator;
+use Ramsey\Uuid\Generator\RandomGeneratorInterface;
+use Ramsey\Uuid\Generator\UnixTimeGenerator;
+use Ramsey\Uuid\Test\TestCase;
+
+class UnixTimeGeneratorTest extends TestCase
+{
+    /**
+     * @runInSeparateProcess since values are stored statically on the class
+     * @preserveGlobalState disabled
+     */
+    public function testGenerate(): void
+    {
+        $dateTime = new DateTimeImmutable('@1578612359.521023');
+        $expectedBytes = "\x01\x6f\x8c\xa1\x01\x61\x03\x00\xff\x00\xff\x00\xff\x00\xff\x00";
+
+        /** @var RandomGeneratorInterface&MockInterface $randomGenerator */
+        $randomGenerator = Mockery::mock(RandomGeneratorInterface::class);
+        $randomGenerator->expects()->generate(16)->andReturns(
+            "\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00\xff\x00",
+        );
+
+        $unixTimeGenerator = new UnixTimeGenerator($randomGenerator);
+
+        $bytes = $unixTimeGenerator->generate(null, null, $dateTime);
+
+        $this->assertSame($expectedBytes, $bytes);
+    }
+
+    /**
+     * @runInSeparateProcess since values are stored statically on the class
+     * @preserveGlobalState disabled
+     */
+    public function testGenerateProducesMonotonicResults(): void
+    {
+        $randomGenerator = new RandomBytesGenerator();
+        $unixTimeGenerator = new UnixTimeGenerator($randomGenerator);
+
+        $previous = '';
+        for ($i = 0; $i < 25; $i++) {
+            $bytes = $unixTimeGenerator->generate();
+            $this->assertTrue($bytes > $previous);
+        }
+    }
+
+    /**
+     * @runInSeparateProcess since values are stored statically on the class
+     * @preserveGlobalState disabled
+     */
+    public function testGenerateProducesMonotonicResultsWithSameDate(): void
+    {
+        $dateTime = new DateTimeImmutable('now');
+        $randomGenerator = new RandomBytesGenerator();
+        $unixTimeGenerator = new UnixTimeGenerator($randomGenerator);
+
+        $previous = '';
+        for ($i = 0; $i < 25; $i++) {
+            $bytes = $unixTimeGenerator->generate(null, null, $dateTime);
+            $this->assertTrue($bytes > $previous);
+        }
+    }
+
+    /**
+     * @runInSeparateProcess since values are stored statically on the class
+     * @preserveGlobalState disabled
+     */
+    public function testGenerateProducesMonotonicResultsFor32BitPath(): void
+    {
+        $randomGenerator = new RandomBytesGenerator();
+        $unixTimeGenerator = new UnixTimeGenerator($randomGenerator, 4);
+
+        $previous = '';
+        for ($i = 0; $i < 25; $i++) {
+            $bytes = $unixTimeGenerator->generate();
+            $this->assertTrue($bytes > $previous);
+        }
+    }
+
+    /**
+     * @runInSeparateProcess since values are stored statically on the class
+     * @preserveGlobalState disabled
+     */
+    public function testGenerateProducesMonotonicResultsWithSameDateFor32BitPath(): void
+    {
+        $dateTime = new DateTimeImmutable('now');
+        $randomGenerator = new RandomBytesGenerator();
+        $unixTimeGenerator = new UnixTimeGenerator($randomGenerator, 4);
+
+        $previous = '';
+        for ($i = 0; $i < 25; $i++) {
+            $bytes = $unixTimeGenerator->generate(null, null, $dateTime);
+            $this->assertTrue($bytes > $previous);
+        }
+    }
+
+    /**
+     * @runInSeparateProcess since values are stored statically on the class
+     * @preserveGlobalState disabled
+     */
+    public function testGenerateProducesMonotonicResultsStartingWithAllBitsSet(): void
+    {
+        /** @var RandomGeneratorInterface&MockInterface $randomGenerator */
+        $randomGenerator = Mockery::mock(RandomGeneratorInterface::class);
+        $randomGenerator->expects()->generate(16)->andReturns(
+            "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff",
+        );
+        $randomGenerator->expects()->generate(10)->times(24)->andReturns(
+            "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff",
+        );
+
+        $unixTimeGenerator = new UnixTimeGenerator($randomGenerator);
+
+        $previous = '';
+        for ($i = 0; $i < 25; $i++) {
+            $bytes = $unixTimeGenerator->generate();
+            $this->assertTrue($bytes > $previous);
+        }
+    }
+
+    /**
+     * @runInSeparateProcess since values are stored statically on the class
+     * @preserveGlobalState disabled
+     */
+    public function testGenerateProducesMonotonicResultsStartingWithAllBitsSetWithSameDate(): void
+    {
+        $dateTime = new DateTimeImmutable('now');
+
+        /** @var RandomGeneratorInterface&MockInterface $randomGenerator */
+        $randomGenerator = Mockery::mock(RandomGeneratorInterface::class);
+        $randomGenerator->expects()->generate(16)->andReturns(
+            "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff",
+        );
+        $randomGenerator->expects()->generate(10)->times(24)->andReturns(
+            "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff",
+        );
+
+        $unixTimeGenerator = new UnixTimeGenerator($randomGenerator);
+
+        $previous = '';
+        for ($i = 0; $i < 25; $i++) {
+            $bytes = $unixTimeGenerator->generate(null, null, $dateTime);
+            $this->assertTrue($bytes > $previous);
+        }
+    }
+
+    /**
+     * @runInSeparateProcess since values are stored statically on the class
+     * @preserveGlobalState disabled
+     */
+    public function testGenerateProducesMonotonicResultsStartingWithAllBitsSetFor32BitPath(): void
+    {
+        /** @var RandomGeneratorInterface&MockInterface $randomGenerator */
+        $randomGenerator = Mockery::mock(RandomGeneratorInterface::class);
+        $randomGenerator->expects()->generate(16)->andReturns(
+            "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff",
+        );
+        $randomGenerator->expects()->generate(10)->times(24)->andReturns(
+            "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff",
+        );
+
+        $unixTimeGenerator = new UnixTimeGenerator($randomGenerator, 4);
+
+        $previous = '';
+        for ($i = 0; $i < 25; $i++) {
+            $bytes = $unixTimeGenerator->generate();
+            $this->assertTrue($bytes > $previous);
+        }
+    }
+
+    /**
+     * @runInSeparateProcess since values are stored statically on the class
+     * @preserveGlobalState disabled
+     */
+    public function testGenerateProducesMonotonicResultsStartingWithAllBitsSetWithSameDateFor32BitPath(): void
+    {
+        $dateTime = new DateTimeImmutable('now');
+
+        /** @var RandomGeneratorInterface&MockInterface $randomGenerator */
+        $randomGenerator = Mockery::mock(RandomGeneratorInterface::class);
+        $randomGenerator->expects()->generate(16)->andReturns(
+            "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff",
+        );
+        $randomGenerator->expects()->generate(10)->times(24)->andReturns(
+            "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff",
+        );
+
+        $unixTimeGenerator = new UnixTimeGenerator($randomGenerator, 4);
+
+        $previous = '';
+        for ($i = 0; $i < 25; $i++) {
+            $bytes = $unixTimeGenerator->generate(null, null, $dateTime);
+            $this->assertTrue($bytes > $previous);
+        }
+    }
+}

package/vendor/ramsey/uuid/tests/Guid/FieldsTest.php

@@ -0,0 +1,235 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Test\Guid;
+
+use Ramsey\Uuid\Exception\InvalidArgumentException;
+use Ramsey\Uuid\Guid\Fields;
+use Ramsey\Uuid\Rfc4122\Version;
+use Ramsey\Uuid\Test\TestCase;
+use Ramsey\Uuid\Type\Hexadecimal;
+use Ramsey\Uuid\Variant;
+
+use function hex2bin;
+use function serialize;
+use function unserialize;
+
+class FieldsTest extends TestCase
+{
+    public function testConstructorThrowsExceptionIfNotSixteenByteString(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage(
+            'The byte string must be 16 bytes long; received 6 bytes'
+        );
+
+        new Fields('foobar');
+    }
+
+    /**
+     * @dataProvider nonRfc4122GuidVariantProvider
+     */
+    public function testConstructorThrowsExceptionIfNotRfc4122Variant(string $guid): void
+    {
+        /** @var non-empty-string $bytes */
+        $bytes = (string) hex2bin($guid);
+
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage(
+            'The byte string received does not conform to the RFC 4122 or '
+            . 'Microsoft Corporation variants'
+        );
+
+        new Fields($bytes);
+    }
+
+    /**
+     * These values are already in GUID byte order, for easy testing.
+     *
+     * @phpcsSuppress SlevomatCodingStandard.TypeHints.ReturnTypeHint.MissingTraversableTypeHintSpecification
+     */
+    public function nonRfc4122GuidVariantProvider(): array
+    {
+        // In string representation, the following IDs would begin as:
+        // ff6f8cb0-c57d-11e1-...
+        return [
+            ['b08c6fff7dc5e1110b210800200c9a66'],
+            ['b08c6fff7dc5e1111b210800200c9a66'],
+            ['b08c6fff7dc5e1112b210800200c9a66'],
+            ['b08c6fff7dc5e1113b210800200c9a66'],
+            ['b08c6fff7dc5e1114b210800200c9a66'],
+            ['b08c6fff7dc5e1115b210800200c9a66'],
+            ['b08c6fff7dc5e1116b210800200c9a66'],
+            ['b08c6fff7dc5e1117b210800200c9a66'],
+            ['b08c6fff7dc5e111eb210800200c9a66'],
+            ['b08c6fff7dc5e111fb210800200c9a66'],
+        ];
+    }
+
+    /**
+     * @dataProvider invalidVersionProvider
+     */
+    public function testConstructorThrowsExceptionIfInvalidVersion(string $guid): void
+    {
+        /** @var non-empty-string $bytes */
+        $bytes = (string) hex2bin($guid);
+
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage(
+            'The byte string received does not contain a valid version'
+        );
+
+        new Fields($bytes);
+    }
+
+    /**
+     * @phpcsSuppress SlevomatCodingStandard.TypeHints.ReturnTypeHint.MissingTraversableTypeHintSpecification
+     */
+    public function invalidVersionProvider(): array
+    {
+        // The following UUIDs are in GUID byte order. Dashes have
+        // been removed in the tests to distinguish these from string
+        // representations, which are never in GUID byte order.
+        return [
+            ['b08c6fff7dc5e1018b210800200c9a66'],
+            ['b08c6fff7dc5e191bb210800200c9a66'],
+            ['b08c6fff7dc5e1a19b210800200c9a66'],
+            ['b08c6fff7dc5e1b1ab210800200c9a66'],
+            ['b08c6fff7dc5e1c1ab210800200c9a66'],
+            ['b08c6fff7dc5e1d1ab210800200c9a66'],
+            ['b08c6fff7dc5e1e1ab210800200c9a66'],
+            ['b08c6fff7dc5e1f1ab210800200c9a66'],
+        ];
+    }
+
+    /**
+     * @dataProvider fieldGetterMethodProvider
+     */
+    public function testFieldGetterMethods(
+        string $bytes,
+        string $methodName,
+        bool | string | Variant | Version | null $expectedValue
+    ): void {
+        /** @var non-empty-string $bytes */
+        $bytes = (string) hex2bin($bytes);
+        $fields = new Fields($bytes);
+
+        $result = $fields->$methodName();
+
+        if ($result instanceof Hexadecimal) {
+            $this->assertSame($expectedValue, $result->toString());
+        } else {
+            $this->assertSame($expectedValue, $result);
+        }
+    }
+
+    /**
+     * @phpcsSuppress SlevomatCodingStandard.TypeHints.ReturnTypeHint.MissingTraversableTypeHintSpecification
+     */
+    public function fieldGetterMethodProvider(): array
+    {
+        // The following UUIDs are in GUID byte order. Dashes have
+        // been removed in the tests to distinguish these from string
+        // representations, which are never in GUID byte order.
+        return [
+            // For ff6f8cb0-c57d-11e1-cb21-0800200c9a66
+            ['b08c6fff7dc5e111cb210800200c9a66', 'getClockSeq', '0b21'],
+            ['b08c6fff7dc5e111cb210800200c9a66', 'getClockSeqHiAndReserved', 'cb'],
+            ['b08c6fff7dc5e111cb210800200c9a66', 'getClockSeqLow', '21'],
+            ['b08c6fff7dc5e111cb210800200c9a66', 'getNode', '0800200c9a66'],
+            ['b08c6fff7dc5e111cb210800200c9a66', 'getTimeHiAndVersion', '11e1'],
+            ['b08c6fff7dc5e111cb210800200c9a66', 'getTimeLow', 'ff6f8cb0'],
+            ['b08c6fff7dc5e111cb210800200c9a66', 'getTimeMid', 'c57d'],
+            ['b08c6fff7dc5e111cb210800200c9a66', 'getTimestamp', '1e1c57dff6f8cb0'],
+            ['b08c6fff7dc5e111cb210800200c9a66', 'getVariant', Variant::ReservedMicrosoft],
+            ['b08c6fff7dc5e111cb210800200c9a66', 'getVersion', Version::Time],
+            ['b08c6fff7dc5e111cb210800200c9a66', 'isNil', false],
+            ['b08c6fff7dc5e111cb210800200c9a66', 'isMax', false],
+
+            // For ff6f8cb0-c57d-41e1-db21-0800200c9a66
+            ['b08c6fff7dc5e141db210800200c9a66', 'getClockSeq', '1b21'],
+            ['b08c6fff7dc5e141db210800200c9a66', 'getClockSeqHiAndReserved', 'db'],
+            ['b08c6fff7dc5e141db210800200c9a66', 'getClockSeqLow', '21'],
+            ['b08c6fff7dc5e141db210800200c9a66', 'getNode', '0800200c9a66'],
+            ['b08c6fff7dc5e141db210800200c9a66', 'getTimeHiAndVersion', '41e1'],
+            ['b08c6fff7dc5e141db210800200c9a66', 'getTimeLow', 'ff6f8cb0'],
+            ['b08c6fff7dc5e141db210800200c9a66', 'getTimeMid', 'c57d'],
+            ['b08c6fff7dc5e141db210800200c9a66', 'getTimestamp', '1e1c57dff6f8cb0'],
+            ['b08c6fff7dc5e141db210800200c9a66', 'getVariant', Variant::ReservedMicrosoft],
+            ['b08c6fff7dc5e141db210800200c9a66', 'getVersion', Version::Random],
+            ['b08c6fff7dc5e141db210800200c9a66', 'isNil', false],
+            ['b08c6fff7dc5e141db210800200c9a66', 'isMax', false],
+
+            // For ff6f8cb0-c57d-31e1-8b21-0800200c9a66
+            ['b08c6fff7dc5e1318b210800200c9a66', 'getClockSeq', '0b21'],
+            ['b08c6fff7dc5e1318b210800200c9a66', 'getClockSeqHiAndReserved', '8b'],
+            ['b08c6fff7dc5e1318b210800200c9a66', 'getClockSeqLow', '21'],
+            ['b08c6fff7dc5e1318b210800200c9a66', 'getNode', '0800200c9a66'],
+            ['b08c6fff7dc5e1318b210800200c9a66', 'getTimeHiAndVersion', '31e1'],
+            ['b08c6fff7dc5e1318b210800200c9a66', 'getTimeLow', 'ff6f8cb0'],
+            ['b08c6fff7dc5e1318b210800200c9a66', 'getTimeMid', 'c57d'],
+            ['b08c6fff7dc5e1318b210800200c9a66', 'getTimestamp', '1e1c57dff6f8cb0'],
+            ['b08c6fff7dc5e1318b210800200c9a66', 'getVariant', Variant::Rfc4122],
+            ['b08c6fff7dc5e1318b210800200c9a66', 'getVersion', Version::HashMd5],
+            ['b08c6fff7dc5e1318b210800200c9a66', 'isNil', false],
+            ['b08c6fff7dc5e1318b210800200c9a66', 'isMax', false],
+
+            // For ff6f8cb0-c57d-51e1-9b21-0800200c9a66
+            ['b08c6fff7dc5e1519b210800200c9a66', 'getClockSeq', '1b21'],
+            ['b08c6fff7dc5e1519b210800200c9a66', 'getClockSeqHiAndReserved', '9b'],
+            ['b08c6fff7dc5e1519b210800200c9a66', 'getClockSeqLow', '21'],
+            ['b08c6fff7dc5e1519b210800200c9a66', 'getNode', '0800200c9a66'],
+            ['b08c6fff7dc5e1519b210800200c9a66', 'getTimeHiAndVersion', '51e1'],
+            ['b08c6fff7dc5e1519b210800200c9a66', 'getTimeLow', 'ff6f8cb0'],
+            ['b08c6fff7dc5e1519b210800200c9a66', 'getTimeMid', 'c57d'],
+            ['b08c6fff7dc5e1519b210800200c9a66', 'getTimestamp', '1e1c57dff6f8cb0'],
+            ['b08c6fff7dc5e1519b210800200c9a66', 'getVariant', Variant::Rfc4122],
+            ['b08c6fff7dc5e1519b210800200c9a66', 'getVersion', Version::HashSha1],
+            ['b08c6fff7dc5e1519b210800200c9a66', 'isNil', false],
+            ['b08c6fff7dc5e1519b210800200c9a66', 'isMax', false],
+
+            // For 00000000-0000-0000-0000-000000000000
+            ['00000000000000000000000000000000', 'getClockSeq', '0000'],
+            ['00000000000000000000000000000000', 'getClockSeqHiAndReserved', '00'],
+            ['00000000000000000000000000000000', 'getClockSeqLow', '00'],
+            ['00000000000000000000000000000000', 'getNode', '000000000000'],
+            ['00000000000000000000000000000000', 'getTimeHiAndVersion', '0000'],
+            ['00000000000000000000000000000000', 'getTimeLow', '00000000'],
+            ['00000000000000000000000000000000', 'getTimeMid', '0000'],
+            ['00000000000000000000000000000000', 'getTimestamp', '000000000000000'],
+            ['00000000000000000000000000000000', 'getVariant', Variant::Rfc4122],
+            ['00000000000000000000000000000000', 'getVersion', null],
+            ['00000000000000000000000000000000', 'isNil', true],
+            ['00000000000000000000000000000000', 'isMax', false],
+
+            // For ffffffff-ffff-ffff-ffff-ffffffffffff
+            ['ffffffffffffffffffffffffffffffff', 'getClockSeq', 'ffff'],
+            ['ffffffffffffffffffffffffffffffff', 'getClockSeqHiAndReserved', 'ff'],
+            ['ffffffffffffffffffffffffffffffff', 'getClockSeqLow', 'ff'],
+            ['ffffffffffffffffffffffffffffffff', 'getNode', 'ffffffffffff'],
+            ['ffffffffffffffffffffffffffffffff', 'getTimeHiAndVersion', 'ffff'],
+            ['ffffffffffffffffffffffffffffffff', 'getTimeLow', 'ffffffff'],
+            ['ffffffffffffffffffffffffffffffff', 'getTimeMid', 'ffff'],
+            ['ffffffffffffffffffffffffffffffff', 'getTimestamp', 'fffffffffffffff'],
+            ['ffffffffffffffffffffffffffffffff', 'getVariant', Variant::Rfc4122],
+            ['ffffffffffffffffffffffffffffffff', 'getVersion', null],
+            ['ffffffffffffffffffffffffffffffff', 'isNil', false],
+            ['ffffffffffffffffffffffffffffffff', 'isMax', true],
+        ];
+    }
+
+    public function testSerializingFields(): void
+    {
+        /** @var non-empty-string $bytes */
+        $bytes = (string) hex2bin('b08c6fff7dc5e111cb210800200c9a66');
+        $fields = new Fields($bytes);
+
+        $serializedFields = serialize($fields);
+
+        /** @var Fields $unserializedFields */
+        $unserializedFields = unserialize($serializedFields);
+
+        $this->assertSame($fields->getBytes(), $unserializedFields->getBytes());
+    }
+}

package/vendor/ramsey/uuid/tests/Guid/GuidBuilderTest.php

@@ -0,0 +1,33 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Test\Guid;
+
+use Mockery;
+use Ramsey\Uuid\Codec\CodecInterface;
+use Ramsey\Uuid\Exception\UnableToBuildUuidException;
+use Ramsey\Uuid\Guid\GuidBuilder;
+use Ramsey\Uuid\Test\TestCase;
+use RuntimeException;
+
+class GuidBuilderTest extends TestCase
+{
+    public function testBuildThrowsException(): void
+    {
+        $codec = Mockery::mock(CodecInterface::class);
+
+        $builder = Mockery::mock(GuidBuilder::class);
+        $builder->shouldAllowMockingProtectedMethods();
+        $builder->shouldReceive('buildFields')->andThrow(
+            RuntimeException::class,
+            'exception thrown'
+        );
+        $builder->shouldReceive('build')->passthru();
+
+        $this->expectException(UnableToBuildUuidException::class);
+        $this->expectExceptionMessage('exception thrown');
+
+        $builder->build($codec, 'foobar');
+    }
+}

package/vendor/ramsey/uuid/tests/Math/BrickMathCalculatorTest.php

@@ -0,0 +1,116 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Test\Math;
+
+use Ramsey\Uuid\Exception\InvalidArgumentException;
+use Ramsey\Uuid\Math\BrickMathCalculator;
+use Ramsey\Uuid\Math\RoundingMode;
+use Ramsey\Uuid\Test\TestCase;
+use Ramsey\Uuid\Type\Hexadecimal;
+use Ramsey\Uuid\Type\Integer as IntegerObject;
+
+class BrickMathCalculatorTest extends TestCase
+{
+    public function testAdd(): void
+    {
+        $int1 = new IntegerObject(5);
+        $int2 = new IntegerObject(6);
+        $int3 = new IntegerObject(7);
+
+        $calculator = new BrickMathCalculator();
+
+        $result = $calculator->add($int1, $int2, $int3);
+
+        $this->assertSame('18', $result->toString());
+    }
+
+    public function testSubtract(): void
+    {
+        $int1 = new IntegerObject(5);
+        $int2 = new IntegerObject(6);
+        $int3 = new IntegerObject(7);
+
+        $calculator = new BrickMathCalculator();
+
+        $result = $calculator->subtract($int1, $int2, $int3);
+
+        $this->assertSame('-8', $result->toString());
+    }
+
+    public function testMultiply(): void
+    {
+        $int1 = new IntegerObject(5);
+        $int2 = new IntegerObject(6);
+        $int3 = new IntegerObject(7);
+
+        $calculator = new BrickMathCalculator();
+
+        $result = $calculator->multiply($int1, $int2, $int3);
+
+        $this->assertSame('210', $result->toString());
+    }
+
+    public function testDivide(): void
+    {
+        $int1 = new IntegerObject(1023);
+        $int2 = new IntegerObject(6);
+        $int3 = new IntegerObject(7);
+
+        $calculator = new BrickMathCalculator();
+
+        $result = $calculator->divide(RoundingMode::HALF_UP, 0, $int1, $int2, $int3);
+
+        $this->assertSame('24', $result->toString());
+    }
+
+    public function testFromBase(): void
+    {
+        $calculator = new BrickMathCalculator();
+
+        $result = $calculator->fromBase('ffffffffffffffffffff', 16);
+
+        $this->assertInstanceOf(IntegerObject::class, $result);
+        $this->assertSame('1208925819614629174706175', $result->toString());
+    }
+
+    public function testToBase(): void
+    {
+        $intValue = new IntegerObject('1208925819614629174706175');
+        $calculator = new BrickMathCalculator();
+
+        $this->assertSame('ffffffffffffffffffff', $calculator->toBase($intValue, 16));
+    }
+
+    public function testToHexadecimal(): void
+    {
+        $intValue = new IntegerObject('1208925819614629174706175');
+        $calculator = new BrickMathCalculator();
+
+        $result = $calculator->toHexadecimal($intValue);
+
+        $this->assertInstanceOf(Hexadecimal::class, $result);
+        $this->assertSame('ffffffffffffffffffff', $result->toString());
+    }
+
+    public function testFromBaseThrowsException(): void
+    {
+        $calculator = new BrickMathCalculator();
+
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('"o" is not a valid character in base 16');
+
+        $calculator->fromBase('foobar', 16);
+    }
+
+    public function testToBaseThrowsException(): void
+    {
+        $calculator = new BrickMathCalculator();
+
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage('Base 1024 is out of range [2, 36]');
+
+        $calculator->toBase(new IntegerObject(42), 1024);
+    }
+}

package/vendor/ramsey/uuid/tests/Nonstandard/FieldsTest.php

@@ -0,0 +1,84 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Ramsey\Uuid\Test\Nonstandard;
+
+use Ramsey\Uuid\Exception\InvalidArgumentException;
+use Ramsey\Uuid\Nonstandard\Fields;
+use Ramsey\Uuid\Test\TestCase;
+use Ramsey\Uuid\Type\Hexadecimal;
+use Ramsey\Uuid\Variant;
+
+use function hex2bin;
+use function serialize;
+use function str_replace;
+use function unserialize;
+
+class FieldsTest extends TestCase
+{
+    public function testConstructorThrowsExceptionIfNotSixteenByteString(): void
+    {
+        $this->expectException(InvalidArgumentException::class);
+        $this->expectExceptionMessage(
+            'The byte string must be 16 bytes long; received 6 bytes'
+        );
+
+        new Fields('foobar');
+    }
+
+    /**
+     * @param string|int $expectedValue
+     *
+     * @dataProvider fieldGetterMethodProvider
+     */
+    public function testFieldGetterMethods(string $uuid, string $methodName, $expectedValue): void
+    {
+        /** @var non-empty-string $bytes */
+        $bytes = (string) hex2bin(str_replace('-', '', $uuid));
+        $fields = new Fields($bytes);
+
+        $result = $fields->$methodName();
+
+        if ($result instanceof Hexadecimal) {
+            $this->assertSame($expectedValue, $result->toString());
+        } else {
+            $this->assertSame($expectedValue, $result);
+        }
+    }
+
+    /**
+     * @phpcsSuppress SlevomatCodingStandard.TypeHints.ReturnTypeHint.MissingTraversableTypeHintSpecification
+     */
+    public function fieldGetterMethodProvider(): array
+    {
+        return [
+            ['ff6f8cb0-c57d-91e1-0b21-0800200c9a66', 'getClockSeq', '0b21'],
+            ['ff6f8cb0-c57d-91e1-0b21-0800200c9a66', 'getClockSeqHiAndReserved', '0b'],
+            ['ff6f8cb0-c57d-91e1-0b21-0800200c9a66', 'getClockSeqLow', '21'],
+            ['ff6f8cb0-c57d-91e1-0b21-0800200c9a66', 'getNode', '0800200c9a66'],
+            ['ff6f8cb0-c57d-91e1-0b21-0800200c9a66', 'getTimeHiAndVersion', '91e1'],
+            ['ff6f8cb0-c57d-91e1-0b21-0800200c9a66', 'getTimeLow', 'ff6f8cb0'],
+            ['ff6f8cb0-c57d-91e1-0b21-0800200c9a66', 'getTimeMid', 'c57d'],
+            ['ff6f8cb0-c57d-91e1-0b21-0800200c9a66', 'getTimestamp', '1e1c57dff6f8cb0'],
+            ['ff6f8cb0-c57d-91e1-0b21-0800200c9a66', 'getVariant', Variant::ReservedNcs],
+            ['ff6f8cb0-c57d-91e1-0b21-0800200c9a66', 'getVersion', null],
+            ['ff6f8cb0-c57d-91e1-0b21-0800200c9a66', 'isNil', false],
+            ['ff6f8cb0-c57d-91e1-0b21-0800200c9a66', 'isMax', false],
+        ];
+    }
+
+    public function testSerializingFields(): void
+    {
+        /** @var non-empty-string $bytes */
+        $bytes = (string) hex2bin(str_replace('-', '', 'ff6f8cb0-c57d-91e1-0b21-0800200c9a66'));
+        $fields = new Fields($bytes);
+
+        $serializedFields = serialize($fields);
+
+        /** @var Fields $unserializedFields */
+        $unserializedFields = unserialize($serializedFields);
+
+        $this->assertSame($fields->getBytes(), $unserializedFields->getBytes());
+    }
+}