提交代码

vendor/bacon/bacon-qr-code/tests/BaconQrCode/Common/BitArrayTest.php

@@ -0,0 +1,201 @@
+<?php
+/**
+ * BaconQrCode
+ *
+ * @link      http://github.com/Bacon/BaconQrCode For the canonical source repository
+ * @copyright 2013 Ben 'DASPRiD' Scholzen
+ * @license   http://opensource.org/licenses/BSD-2-Clause Simplified BSD License
+ */
+
+namespace BaconQrCode\Common;
+
+use PHPUnit_Framework_TestCase as TestCase;
+
+class BitArrayTest extends TestCase
+{
+    public function testGetSet()
+    {
+        $array = new BitArray(33);
+
+        for ($i = 0; $i < 33; $i++) {
+            $this->assertFalse($array->get($i));
+            $array->set($i);
+            $this->assertTrue($array->get($i));
+        }
+    }
+
+    public function testGetNextSet1()
+    {
+        $array = new BitArray(32);
+
+        for ($i = 0; $i < $array->getSize(); $i++) {
+            $this->assertEquals($i, 32, '', $array->getNextSet($i));
+        }
+
+        $array = new BitArray(33);
+
+        for ($i = 0; $i < $array->getSize(); $i++) {
+            $this->assertEquals($i, 33, '', $array->getNextSet($i));
+        }
+    }
+
+    public function testGetNextSet2()
+    {
+        $array = new BitArray(33);
+
+        for ($i = 0; $i < $array->getSize(); $i++) {
+            $this->assertEquals($i, $i <= 31 ? 31 : 33, '', $array->getNextSet($i));
+        }
+
+        $array = new BitArray(33);
+
+        for ($i = 0; $i < $array->getSize(); $i++) {
+            $this->assertEquals($i, 32, '', $array->getNextSet($i));
+        }
+    }
+
+    public function testGetNextSet3()
+    {
+        $array = new BitArray(63);
+        $array->set(31);
+        $array->set(32);
+
+        for ($i = 0; $i < $array->getSize(); $i++) {
+            if ($i <= 31) {
+                $expected = 31;
+            } elseif ($i <= 32) {
+                $expected = 32;
+            } else {
+                $expected = 63;
+            }
+
+            $this->assertEquals($i, $expected, '', $array->getNextSet($i));
+        }
+    }
+
+    public function testGetNextSet4()
+    {
+        $array = new BitArray(63);
+        $array->set(33);
+        $array->set(40);
+
+        for ($i = 0; $i < $array->getSize(); $i++) {
+            if ($i <= 33) {
+                $expected = 33;
+            } elseif ($i <= 40) {
+                $expected = 40;
+            } else {
+                $expected = 63;
+            }
+
+            $this->assertEquals($i, $expected, '', $array->getNextSet($i));
+        }
+    }
+
+    public function testGetNextSet5()
+    {
+        if (defined('MT_RAND_PHP')) {
+            mt_srand(0xdeadbeef, MT_RAND_PHP);
+        } else {
+            mt_srand(0xdeadbeef);
+        }
+
+        for ($i = 0; $i < 10; $i++) {
+            $array  = new BitArray(mt_rand(1, 100));
+            $numSet = mt_rand(0, 19);
+
+            for ($j = 0; $j < $numSet; $j++) {
+                $array->set(mt_rand(0, $array->getSize() - 1));
+            }
+
+            $numQueries = mt_rand(0, 19);
+
+            for ($j = 0; $j < $numQueries; $j++) {
+                $query    = mt_rand(0, $array->getSize() - 1);
+                $expected = $query;
+
+                while ($expected < $array->getSize() && !$array->get($expected)) {
+                    $expected++;
+                }
+
+                $actual = $array->getNextSet($query);
+
+                if ($actual !== $expected) {
+                    $array->getNextSet($query);
+                }
+
+                $this->assertEquals($expected, $actual);
+            }
+        }
+    }
+
+    public function testSetBulk()
+    {
+        $array = new BitArray(64);
+        $array->setBulk(32, 0xFFFF0000);
+
+        for ($i = 0; $i < 48; $i++) {
+            $this->assertFalse($array->get($i));
+        }
+
+        for ($i = 48; $i < 64; $i++) {
+            $this->assertTrue($array->get($i));
+        }
+    }
+
+    public function testClear()
+    {
+        $array = new BitArray(32);
+
+        for ($i = 0; $i < 32; $i++) {
+            $array->set($i);
+        }
+
+        $array->clear();
+
+        for ($i = 0; $i < 32; $i++) {
+            $this->assertFalse($array->get($i));
+        }
+    }
+
+    public function testGetArray()
+    {
+        $array = new BitArray(64);
+        $array->set(0);
+        $array->set(63);
+
+        $ints = $array->getBitArray();
+
+        $this->assertEquals(1, $ints[0]);
+        $this->assertEquals(0x80000000, $ints[1]);
+    }
+
+    public function testIsRange()
+    {
+        $array = new BitArray(64);
+        $this->assertTrue($array->isRange(0, 64, false));
+        $this->assertFalse($array->isRange(0, 64, true));
+
+        $array->set(32);
+        $this->assertTrue($array->isRange(32, 33, true));
+
+        $array->set(31);
+        $this->assertTrue($array->isRange(31, 33, true));
+
+        $array->set(34);
+        $this->assertFalse($array->isRange(31, 35, true));
+
+        for ($i = 0; $i < 31; $i++) {
+            $array->set($i);
+        }
+
+        $this->assertTrue($array->isRange(0, 33, true));
+
+        for ($i = 33; $i < 64; $i++) {
+            $array->set($i);
+        }
+
+        $this->assertTrue($array->isRange(0, 64, true));
+        $this->assertFalse($array->isRange(0, 64, false));
+    }
+}

vendor/bacon/bacon-qr-code/tests/BaconQrCode/Common/BitMatrixTest.php

@@ -0,0 +1,119 @@
+<?php
+/**
+ * BaconQrCode
+ *
+ * @link      http://github.com/Bacon/BaconQrCode For the canonical source repository
+ * @copyright 2013 Ben 'DASPRiD' Scholzen
+ * @license   http://opensource.org/licenses/BSD-2-Clause Simplified BSD License
+ */
+
+namespace BaconQrCode\Common;
+
+use PHPUnit_Framework_TestCase as TestCase;
+
+class BitMatrixTest extends TestCase
+{
+    public function testGetSet()
+    {
+        $matrix = new BitMatrix(33);
+        $this->assertEquals(33, $matrix->getHeight());
+
+        for ($y = 0; $y < 33; $y++) {
+            for ($x = 0; $x < 33; $x++) {
+                if ($y * $x % 3 === 0) {
+                    $matrix->set($x, $y);
+                }
+            }
+        }
+
+        for ($y = 0; $y < 33; $y++) {
+            for ($x = 0; $x < 33; $x++) {
+                $this->assertEquals($x * $y % 3 === 0, $matrix->get($x, $y));
+            }
+        }
+    }
+
+    public function testSetRegion()
+    {
+        $matrix = new BitMatrix(5);
+        $matrix->setRegion(1, 1, 3, 3);
+
+        for ($y = 0; $y < 5; $y++) {
+            for ($x = 0; $x < 5; $x++) {
+                $this->assertEquals($y >= 1 && $y <= 3 && $x >= 1 && $x <= 3, $matrix->get($x, $y));
+            }
+        }
+    }
+
+    public function testRectangularMatrix()
+    {
+        $matrix = new BitMatrix(75, 20);
+        $this->assertEquals(75, $matrix->getWidth());
+        $this->assertEquals(20, $matrix->getHeight());
+
+        $matrix->set(10, 0);
+        $matrix->set(11, 1);
+        $matrix->set(50, 2);
+        $matrix->set(51, 3);
+        $matrix->flip(74, 4);
+        $matrix->flip(0, 5);
+
+        $this->assertTrue($matrix->get(10, 0));
+        $this->assertTrue($matrix->get(11, 1));
+        $this->assertTrue($matrix->get(50, 2));
+        $this->assertTrue($matrix->get(51, 3));
+        $this->assertTrue($matrix->get(74, 4));
+        $this->assertTrue($matrix->get(0, 5));
+
+        $matrix->flip(50, 2);
+        $matrix->flip(51, 3);
+
+        $this->assertFalse($matrix->get(50, 2));
+        $this->assertFalse($matrix->get(51, 3));
+    }
+
+    public function testRectangularSetRegion()
+    {
+        $matrix = new BitMatrix(320, 240);
+        $this->assertEquals(320, $matrix->getWidth());
+        $this->assertEquals(240, $matrix->getHeight());
+
+        $matrix->setRegion(105, 22, 80, 12);
+
+        for ($y = 0; $y < 240; $y++) {
+            for ($x = 0; $x < 320; $x++) {
+                $this->assertEquals($y >= 22 && $y < 34 && $x >= 105 && $x < 185, $matrix->get($x, $y));
+            }
+        }
+    }
+
+    public function testGetRow()
+    {
+        $matrix = new BitMatrix(102, 5);
+
+        for ($x = 0; $x < 102; $x++) {
+            if ($x & 3 === 0) {
+                $matrix->set($x, 2);
+            }
+        }
+
+        $array1 = $matrix->getRow(2, null);
+        $this->assertEquals(102, $array1->getSize());
+
+        $array2 = new BitArray(60);
+        $array2 = $matrix->getRow(2, $array2);
+        $this->assertEquals(102, $array2->getSize());
+
+        $array3 = new BitArray(200);
+        $array3 = $matrix->getRow(2, $array3);
+        $this->assertEquals(200, $array3->getSize());
+
+        for ($x = 0; $x < 102; $x++) {
+            $on = ($x & 3 === 0);
+
+            $this->assertEquals($on, $array1->get($x));
+            $this->assertEquals($on, $array2->get($x));
+            $this->assertEquals($on, $array3->get($x));
+        }
+    }
+}

vendor/bacon/bacon-qr-code/tests/BaconQrCode/Common/BitUtilsTest.php

@@ -0,0 +1,30 @@
+<?php
+/**
+ * BaconQrCode
+ *
+ * @link      http://github.com/Bacon/BaconQrCode For the canonical source repository
+ * @copyright 2013 Ben 'DASPRiD' Scholzen
+ * @license   http://opensource.org/licenses/BSD-2-Clause Simplified BSD License
+ */
+
+namespace BaconQrCode\Common;
+
+use PHPUnit_Framework_TestCase as TestCase;
+
+class BitUtilsTest extends TestCase
+{
+    public function testUnsignedRightShift()
+    {
+        $this->assertEquals(1, BitUtils::unsignedRightShift(1, 0));
+        $this->assertEquals(1, BitUtils::unsignedRightShift(10, 3));
+        $this->assertEquals(536870910, BitUtils::unsignedRightShift(-10, 3));
+    }
+
+    public function testNumberOfTrailingZeros()
+    {
+        $this->assertEquals(32, BitUtils::numberOfTrailingZeros(0));
+        $this->assertEquals(1, BitUtils::numberOfTrailingZeros(10));
+        $this->assertEquals(0, BitUtils::numberOfTrailingZeros(15));
+        $this->assertEquals(2, BitUtils::numberOfTrailingZeros(20));
+    }
+}

vendor/bacon/bacon-qr-code/tests/BaconQrCode/Common/ErrorCorrectionLevelTest.php

@@ -0,0 +1,40 @@
+<?php
+/**
+ * BaconQrCode
+ *
+ * @link      http://github.com/Bacon/BaconQrCode For the canonical source repository
+ * @copyright 2013 Ben 'DASPRiD' Scholzen
+ * @license   http://opensource.org/licenses/BSD-2-Clause Simplified BSD License
+ */
+
+namespace BaconQrCode\Common;
+
+use PHPUnit_Framework_TestCase as TestCase;
+
+class ErrorCorrectionLevelTest extends TestCase
+{
+    public function testCreationThrowsNoException()
+    {
+        new ErrorCorrectionLevel(ErrorCorrectionLevel::M);
+        new ErrorCorrectionLevel(ErrorCorrectionLevel::L);
+        new ErrorCorrectionLevel(ErrorCorrectionLevel::H);
+        new ErrorCorrectionLevel(ErrorCorrectionLevel::Q);
+    }
+
+    public function testBitsMatchConstants()
+    {
+        $this->assertEquals(0x0, ErrorCorrectionLevel::M);
+        $this->assertEquals(0x1, ErrorCorrectionLevel::L);
+        $this->assertEquals(0x2, ErrorCorrectionLevel::H);
+        $this->assertEquals(0x3, ErrorCorrectionLevel::Q);
+    }
+
+    public function testInvalidErrorCorrectionLevelThrowsException()
+    {
+        $this->setExpectedException(
+            'BaconQrCode\Exception\UnexpectedValueException',
+            'Value not a const in enum BaconQrCode\Common\ErrorCorrectionLevel'
+        );
+        new ErrorCorrectionLevel(4);
+    }
+}

vendor/bacon/bacon-qr-code/tests/BaconQrCode/Common/FormatInformationTest.php

@@ -0,0 +1,104 @@
+<?php
+/**
+ * BaconQrCode
+ *
+ * @link      http://github.com/Bacon/BaconQrCode For the canonical source repository
+ * @copyright 2013 Ben 'DASPRiD' Scholzen
+ * @license   http://opensource.org/licenses/BSD-2-Clause Simplified BSD License
+ */
+
+namespace BaconQrCode\Common;
+
+use PHPUnit_Framework_TestCase as TestCase;
+
+class FormatInformationTest extends TestCase
+{
+    protected $maskedTestFormatInfo = 0x2bed;
+    protected $unmaskedTestFormatInfo;
+
+    public function setUp()
+    {
+        $this->unmaskedTestFormatInfo = $this->maskedTestFormatInfo ^ 0x5412;
+    }
+
+
+    public function testBitsDiffering()
+    {
+        $this->assertEquals(0, FormatInformation::numBitsDiffering(1, 1));
+        $this->assertEquals(1, FormatInformation::numBitsDiffering(0, 2));
+        $this->assertEquals(2, FormatInformation::numBitsDiffering(1, 2));
+        $this->assertEquals(32, FormatInformation::numBitsDiffering(-1, 0));
+    }
+
+    public function testDecode()
+    {
+        $expected = FormatInformation::decodeFormatInformation(
+            $this->maskedTestFormatInfo,
+            $this->maskedTestFormatInfo
+        );
+
+        $this->assertNotNull($expected);
+        $this->assertEquals(7, $expected->getDataMask());
+        $this->assertEquals(ErrorCorrectionLevel::Q, $expected->getErrorCorrectionLevel()->get());
+
+        $this->assertEquals(
+            $expected,
+            FormatInformation::decodeFormatInformation(
+                $this->unmaskedTestFormatInfo,
+                $this->maskedTestFormatInfo
+            )
+        );
+    }
+
+    public function testDecodeWithBitDifference()
+    {
+        $expected = FormatInformation::decodeFormatInformation(
+            $this->maskedTestFormatInfo,
+            $this->maskedTestFormatInfo
+        );
+
+        $this->assertEquals(
+            $expected,
+            FormatInformation::decodeFormatInformation(
+                $this->maskedTestFormatInfo ^ 0x1,
+                $this->maskedTestFormatInfo ^ 0x1
+            )
+        );
+        $this->assertEquals(
+            $expected,
+            FormatInformation::decodeFormatInformation(
+                $this->maskedTestFormatInfo ^ 0x3,
+                $this->maskedTestFormatInfo ^ 0x3
+            )
+        );
+        $this->assertEquals(
+            $expected,
+            FormatInformation::decodeFormatInformation(
+                $this->maskedTestFormatInfo ^ 0x7,
+                $this->maskedTestFormatInfo ^ 0x7
+            )
+        );
+        $this->assertNull(
+            FormatInformation::decodeFormatInformation(
+                $this->maskedTestFormatInfo ^ 0xf,
+                $this->maskedTestFormatInfo ^ 0xf
+            )
+        );
+    }
+
+    public function testDecodeWithMisRead()
+    {
+        $expected = FormatInformation::decodeFormatInformation(
+            $this->maskedTestFormatInfo,
+            $this->maskedTestFormatInfo
+        );
+
+        $this->assertEquals(
+            $expected,
+            FormatInformation::decodeFormatInformation(
+                $this->maskedTestFormatInfo ^ 0x3,
+                $this->maskedTestFormatInfo ^ 0xf
+            )
+        );
+    }
+}

vendor/bacon/bacon-qr-code/tests/BaconQrCode/Common/ModeTest.php

@@ -0,0 +1,42 @@
+<?php
+/**
+ * BaconQrCode
+ *
+ * @link      http://github.com/Bacon/BaconQrCode For the canonical source repository
+ * @copyright 2013 Ben 'DASPRiD' Scholzen
+ * @license   http://opensource.org/licenses/BSD-2-Clause Simplified BSD License
+ */
+
+namespace BaconQrCode\Common;
+
+use PHPUnit_Framework_TestCase as TestCase;
+
+class ModeTest extends TestCase
+{
+    public function testCreationThrowsNoException()
+    {
+        new Mode(Mode::TERMINATOR);
+        new Mode(Mode::NUMERIC);
+        new Mode(Mode::ALPHANUMERIC);
+        new Mode(Mode::BYTE);
+        new Mode(Mode::KANJI);
+    }
+
+    public function testBitsMatchConstants()
+    {
+        $this->assertEquals(0x0, Mode::TERMINATOR);
+        $this->assertEquals(0x1, Mode::NUMERIC);
+        $this->assertEquals(0x2, Mode::ALPHANUMERIC);
+        $this->assertEquals(0x4, Mode::BYTE);
+        $this->assertEquals(0x8, Mode::KANJI);
+    }
+
+    public function testInvalidModeThrowsException()
+    {
+        $this->setExpectedException(
+            'BaconQrCode\Exception\UnexpectedValueException',
+            'Value not a const in enum BaconQrCode\Common\Mode'
+        );
+        new Mode(10);
+    }
+}

vendor/bacon/bacon-qr-code/tests/BaconQrCode/Common/ReedSolomonCodecTest.php

@@ -0,0 +1,111 @@
+<?php
+/**
+ * BaconQrCode
+ *
+ * @link      http://github.com/Bacon/BaconQrCode For the canonical source repository
+ * @copyright 2013 Ben 'DASPRiD' Scholzen
+ * @license   http://opensource.org/licenses/BSD-2-Clause Simplified BSD License
+ */
+
+namespace BaconQrCode\Common;
+
+use PHPUnit_Framework_TestCase as TestCase;
+use SplFixedArray;
+
+class ReedSolomonTest extends TestCase
+{
+    public static function tabProvider()
+    {
+        return array(
+            array(2, 0x7,   1, 1, 1),
+            array(3, 0xb,   1, 1, 2),
+            array(4, 0x13,  1, 1, 4),
+            array(5, 0x25,  1, 1, 6),
+            array(6, 0x43,  1, 1, 8),
+            array(7, 0x89,  1, 1, 10),
+            array(8, 0x11d, 1, 1, 32),
+        );
+    }
+
+    /**
+     * @dataProvider tabProvider
+     * @param        integer $symbolSize
+     * @param        integer $generatorPoly
+     * @param        integer $firstRoot
+     * @param        integer $primitive
+     * @param        integer $numRoots
+     * @return       void
+     */
+    public function testCodec($symbolSize, $generatorPoly, $firstRoot, $primitive, $numRoots)
+    {
+        if (defined('MT_RAND_PHP')) {
+            mt_srand(0xdeadbeef, MT_RAND_PHP);
+        } else {
+            mt_srand(0xdeadbeef);
+        }
+
+        $blockSize = (1 << $symbolSize) - 1;
+        $dataSize  = $blockSize - $numRoots;
+        $codec     = new ReedSolomonCodec($symbolSize, $generatorPoly, $firstRoot, $primitive, $numRoots, 0);
+
+        for ($errors = 0; $errors <= $numRoots / 2; $errors++) {
+            // Load block with random data and encode
+            $block = SplFixedArray::fromArray(array_fill(0, $blockSize, 0), false);
+
+            for ($i = 0; $i < $dataSize; $i++) {
+                $block[$i] = mt_rand(0, $blockSize);
+            }
+
+            // Make temporary copy
+            $tBlock         = clone $block;
+            $parity         = SplFixedArray::fromArray(array_fill(0, $numRoots, 0), false);
+            $errorLocations = SplFixedArray::fromArray(array_fill(0, $blockSize, 0), false);
+            $erasures       = array();
+
+            // Create parity
+            $codec->encode($block, $parity);
+
+            // Copy parity into test blocks
+            for ($i = 0; $i < $numRoots; $i++) {
+                $block[$i + $dataSize] = $parity[$i];
+                $tBlock[$i + $dataSize] = $parity[$i];
+            }
+
+            // Seed with errors
+            for ($i = 0; $i < $errors; $i++) {
+                $errorValue = mt_rand(1, $blockSize);
+
+                do {
+                    $errorLocation = mt_rand(0, $blockSize);
+                } while ($errorLocations[$errorLocation] !== 0);
+
+                $errorLocations[$errorLocation] = 1;
+
+                if (mt_rand(0, 1)) {
+                    $erasures[] = $errorLocation;
+                }
+
+                $tBlock[$errorLocation] ^= $errorValue;
+            }
+
+            $erasures = SplFixedArray::fromArray($erasures, false);
+
+            // Decode the errored block
+            $foundErrors = $codec->decode($tBlock, $erasures);
+
+            if ($errors > 0 && $foundErrors === null) {
+                $this->assertEquals($block, $tBlock, 'Decoder failed to correct errors');
+            }
+
+            $this->assertEquals($errors, $foundErrors, 'Found errors do not equal expected errors');
+
+            for ($i = 0; $i < $foundErrors; $i++) {
+                if ($errorLocations[$erasures[$i]] === 0) {
+                    $this->fail(sprintf('Decoder indicates error in location %d without error', $erasures[$i]));
+                }
+            }
+
+            $this->assertEquals($block, $tBlock, 'Decoder did not correct errors');
+        }
+    }
+}

vendor/bacon/bacon-qr-code/tests/BaconQrCode/Common/VersionTest.php

@@ -0,0 +1,88 @@
+<?php
+/**
+ * BaconQrCode
+ *
+ * @link      http://github.com/Bacon/BaconQrCode For the canonical source repository
+ * @copyright 2013 Ben 'DASPRiD' Scholzen
+ * @license   http://opensource.org/licenses/BSD-2-Clause Simplified BSD License
+ */
+
+namespace BaconQrCode\Common;
+
+use PHPUnit_Framework_TestCase as TestCase;
+
+class VersionTest extends TestCase
+{
+    public static function versionProvider()
+    {
+        $array = array();
+
+        for ($i = 1; $i <= 40; $i++) {
+            $array[] = array($i, 4 * $i + 17);
+        }
+
+        return $array;
+    }
+
+    public static function decodeInformationProvider()
+    {
+        return array(
+            array(7, 0x07c94),
+            array(12, 0x0c762),
+            array(17, 0x1145d),
+            array(22, 0x168c9),
+            array(27, 0x1b08e),
+            array(32, 0x209d5),
+        );
+    }
+
+    /**
+     * @dataProvider versionProvider
+     * @param        integer $versionNumber
+     * @param        integer $dimension
+     */
+    public function testVersionForNumber($versionNumber, $dimension)
+    {
+        $version = Version::getVersionForNumber($versionNumber);
+
+        $this->assertNotNull($version);
+        $this->assertEquals($versionNumber, $version->getVersionNumber());
+        $this->assertNotNull($version->getAlignmentPatternCenters());
+
+        if ($versionNumber > 1) {
+            $this->assertTrue(count($version->getAlignmentPatternCenters()) > 0);
+        }
+
+        $this->assertEquals($dimension, $version->getDimensionForVersion());
+        $this->assertNotNull($version->getEcBlocksForLevel(new ErrorCorrectionLevel(ErrorCorrectionLevel::H)));
+        $this->assertNotNull($version->getEcBlocksForLevel(new ErrorCorrectionLevel(ErrorCorrectionLevel::L)));
+        $this->assertNotNull($version->getEcBlocksForLevel(new ErrorCorrectionLevel(ErrorCorrectionLevel::M)));
+        $this->assertNotNull($version->getEcBlocksForLevel(new ErrorCorrectionLevel(ErrorCorrectionLevel::Q)));
+        $this->assertNotNull($version->buildFunctionPattern());
+    }
+
+    /**
+     * @dataProvider versionProvider
+     * @param        integer $versionNumber
+     * @param        integer $dimension
+     */
+    public function testGetProvisionalVersionForDimension($versionNumber, $dimension)
+    {
+        $this->assertEquals(
+            $versionNumber,
+            Version::getProvisionalVersionForDimension($dimension)->getVersionNumber()
+        );
+    }
+
+    /**
+     * @dataProvider decodeInformationProvider
+     * @param        integer $expectedVersion
+     * @param        integer $mask
+     */
+    public function testDecodeVersionInformation($expectedVersion, $mask)
+    {
+        $version = Version::decodeVersionInformation($mask);
+        $this->assertNotNull($version);
+        $this->assertEquals($expectedVersion, $version->getVersionNumber());
+    }
+}