fix #73, EnumSet::setBinaryBitset*() throws InvalidArgumentException on out-of-range bits

Author: marc-mabe

src/EnumSet.php

@@ -431,18 +431,26 @@ public function setBinaryBitsetLe($bitset)
             // add "\0" if the given bitset is not long enough
             $bitset .= str_repeat("\0", $size - $sizeIn);
         } elseif ($sizeIn > $size) {
+            if (trim(substr($bitset, $size), "\0") !== '') {
+                throw new InvalidArgumentException('Out-Of-Range bits detected');
+            }
             $bitset = substr($bitset, 0, $size);
         }
 
         // truncate out-of-range bits of last byte
         $lastByteMaxOrd = $this->ordinalMax % 8;
-        if ($lastByteMaxOrd === 0) {
-            $this->bitset = $bitset;
-        } else {
-            $lastByte     = chr((1 << $lastByteMaxOrd) - 1) & $bitset[$size - 1];
-            $this->bitset = substr($bitset, 0, -1) . $lastByte;
+        if ($lastByteMaxOrd !== 0) {
+            $lastByte         = $bitset[$size - 1];
+            $lastByteExpected = chr((1 << $lastByteMaxOrd) - 1) & $lastByte;
+            if ($lastByte !== $lastByteExpected) {
+                throw new InvalidArgumentException('Out-Of-Range bits detected');
+            }
+
+            $this->bitset = substr($bitset, 0, -1) . $lastByteExpected;
         }
 
+        $this->bitset = $bitset;
+
         // reset the iterator position
         $this->rewind();
     }

tests/MabeEnumTest/EnumSetTest.php

@@ -327,35 +327,6 @@ public function testSetBinaryBitsetLe()
         $this->assertTrue($enumSet->count() == 3);
     }
 
-    public function testSetBinaryBitsetLeTruncateHighBits()
-    {
-        // using Enum66 to make sure the max. ordinal number gets converted into a bitset
-        // Enum65 has max. ordinal number of 1 of the last byte. -> 00000001
-        // Enum66 has max. ordinal number of 2 of the last byte. -> 00000011
-        $enumSet = new EnumSet(Enum66::class);
-        foreach (Enum66::getEnumerators() as $enumerator) {
-            $enumSet->attach($enumerator);
-        }
-
-        $bitset    = $enumSet->getBinaryBitsetLe();
-        $newBitset = substr($bitset, 0, -1) . "\xff\xff";
-        $enumSet->setBinaryBitsetLe($newBitset);
-
-        $this->assertSame(bin2hex($bitset), bin2hex($enumSet->getBinaryBitsetLe()));
-    }
-
-    public function testSetBinaryBitsetBe()
-    {
-        $enumSet = new EnumSet(Enum65::class);
-        $enumSet->setBinaryBitsetBe("\x01\x80\x00\x00\x00\x00\x00\x00\x01");
-
-        $this->assertTrue($enumSet->contains(Enum65::ONE));
-        $this->assertFalse($enumSet->contains(Enum65::TWO));
-        $this->assertTrue($enumSet->contains(Enum65::SIXTYFIVE));
-        $this->assertTrue($enumSet->contains(Enum65::SIXTYFOUR));
-        $this->assertTrue($enumSet->count() == 3);
-    }
-
     public function testSetBinaryBitsetLeShort()
     {
         $enumSet = new EnumSet(Enum65::class);
@@ -366,10 +337,38 @@ public function testSetBinaryBitsetLeShort()
     public function testSetBinaryBitsetLeLong()
     {
         $enumSet = new EnumSet(EnumBasic::class);
-        $enumSet->setBinaryBitsetLe("\x0A\xFF\xFF\xFF\xFF\xFF");
+        $enumSet->setBinaryBitsetLe("\x0A\xFF\x00\x00\x00\x00");
         $this->assertSame("\x0A\xFF", $enumSet->getBinaryBitsetLe());
     }
 
+    public function testSetBinaryBitsetLeOutOrRangeBitsOfExtendedBytes1()
+    {
+        $enumSet = new EnumSet(EnumBasic::class);
+
+        $this->setExpectedException(InvalidArgumentException::class, 'Out-Of-Range');
+        $enumSet->setBinaryBitsetLe("\x0A\xFF\x01");
+    }
+
+    public function testSetBinaryBitsetLeOutOrRangeBitsOfExtendedBytes2()
+    {
+        $enumSet = new EnumSet(EnumBasic::class);
+
+        $this->setExpectedException(InvalidArgumentException::class, 'Out-Of-Range');
+        $enumSet->setBinaryBitsetLe("\x0A\xFF\x00\x02");
+    }
+
+    public function testSetBinaryBitsetLeOutOrRangeBitsOfLastValidByte()
+    {
+        // using Enum65 to detect Out-Of-Range bits of last valid byte
+        // Enum65 has max. ordinal number of 2 of the last byte. -> 0001
+        $enumSet   = new EnumSet(Enum65::class);
+        $bitset    = $enumSet->getBinaryBitsetLe();
+        $newBitset = substr($bitset, 0, -1) . "\x02";
+
+        $this->setExpectedException(InvalidArgumentException::class, 'Out-Of-Range');
+        $enumSet->setBinaryBitsetLe($newBitset);
+    }
+
     public function testSetBinaryBitsetLeArgumentExceptionIfNotString()
     {
         $this->setExpectedException(InvalidArgumentException::class);
@@ -378,6 +377,18 @@ public function testSetBinaryBitsetLeArgumentExceptionIfNotString()
         $enum->setBinaryBitsetLe(0);
     }
 
+    public function testSetBinaryBitsetBe()
+    {
+        $enumSet = new EnumSet(Enum65::class);
+        $enumSet->setBinaryBitsetBe("\x01\x80\x00\x00\x00\x00\x00\x00\x01");
+
+        $this->assertTrue($enumSet->contains(Enum65::ONE));
+        $this->assertFalse($enumSet->contains(Enum65::TWO));
+        $this->assertTrue($enumSet->contains(Enum65::SIXTYFIVE));
+        $this->assertTrue($enumSet->contains(Enum65::SIXTYFOUR));
+        $this->assertTrue($enumSet->count() == 3);
+    }
+
     public function testSetBinaryBitsetBeArgumentExceptionIfNotString()
     {
         $this->setExpectedException(InvalidArgumentException::class);