/home/lnzliplg/public_html/alt-php80-pecl-bitset_3.2.0-1.el8.tar
tests/BitSet_previousSetBit.phpt000064400000001547151731414440013057 0ustar00--TEST--
BitSet BitSet::previousSetBit() - Verifies the previous set bit is valid based on the provided index
--SKIPIF--
<?php if (!extension_loaded('bitset')) die('skipping missing extension'); ?>
--FILE--
<?php
$b = new BitSet(); // 64 bits is fine
$b->set(20);
$b->set(18);
try {
    var_dump($b->previousSetBit(0));
} catch (Exception $e) {
    var_dump(get_class($e).': '.$e->getMessage());
}
var_dump($b->previousSetBit(20));
var_dump($b->previousSetBit(18));
$b->set(1);
var_dump($b->previousSetBit(5));
try {
    var_dump($b->previousSetBit(65));
} catch (Exception $e) {
    var_dump(get_class($e).': '.$e->getMessage());
}
?>
--EXPECT--
string(75) "InvalidArgumentException: There are no bits smaller than the index provided"
int(18)
bool(false)
int(1)
string(93) "OutOfRangeException: The specified index parameter exceeds the total number of bits available"

tests/BitSet_andOp.phpt000064400000000651151731414450011125 0ustar00--TEST--
BitSet BitSet::andOp() - Test that logical AND operations actually work
--SKIPIF--
<?php if (!extension_loaded('bitset')) die('skipping missing extension'); ?>
--FILE--
<?php
$b = new BitSet(); // 64 bits is fine
$b->set(2);
$b->set(6);
$c = new BitSet();
$c->set(2);
$c->set(50);
$b->andOp($c);
var_dump($b->__toString());
?>
--EXPECT--
string(64) "0010000000000000000000000000000000000000000000000000000000000000"
tests/BitSet_clear.phpt000064400000001672151731414450011156 0ustar00--TEST--
BitSet BitSet::clear() - Test clearing bits individually, as sets and as a whole
--SKIPIF--
<?php if (!extension_loaded('bitset')) die('skipping missing extension'); ?>
--FILE--
<?php
$b = new BitSet();
$b->set(50);
$b->set(63);
var_dump($b->get(50));
$b->clear(50);
var_dump($b->get(50));
$b->clear();
var_dump($b->__toString());

$b->set(5);
$b->set(10);
$b->set(20);
$b->clear(5, 11);
var_dump($b->__toString());

$b->set(0, 1);
$b->clear(0);
var_dump($b->__toString());
try {
    var_dump($b->clear(64));
} catch (Exception $e) {
    echo get_class($e).': '.$e->getMessage()."\n";
}
?>
--EXPECT--
bool(true)
bool(false)
string(64) "0000000000000000000000000000000000000000000000000000000000000000"
string(64) "0000000000000000000010000000000000000000000000000000000000000000"
string(64) "0100000000000000000010000000000000000000000000000000000000000000"
OutOfRangeException: The requested start index is greater than the total number of bitstests/BitSet_get.phpt000064400000001121151731414450010634 0ustar00--TEST--
BitSet BitSet::get() - Verifies integrity of bit index retrieval
--SKIPIF--
<?php if (!extension_loaded('bitset')) die('skipping missing extension'); ?>
--FILE--
<?php
$b = new BitSet(); // 64 bits is fine
$b->set(5);
var_dump($b->get(0));
var_dump($b->get(5));
var_dump($b->get(20));
$b->set(20);
var_dump($b->get(20));
try {
    var_dump($b->get(64));
} catch (Exception $e) {
    echo get_class($e).'-'.$e->getMessage()."\n";
}
?>
--EXPECT--
bool(false)
bool(true)
bool(false)
bool(true)
OutOfRangeException-The specified index parameter exceeds the total number of bits available
tests/BitSet_intersects.phpt000064400000001153151731414450012245 0ustar00--TEST--
BitSet BitSet::intersects() - if the provided value has any bits set to true that are also true in this object
--SKIPIF--
<?php if (!extension_loaded('bitset')) die('skipping missing extension'); ?>
--FILE--
<?php
$b = new BitSet(16);
$c = new BitSet(16);
var_dump($b->intersects($c)); // false
var_dump($c->intersects($b)); // false
$b->set(2);
$c->set(10);
var_dump($b->intersects($c)); // false
var_dump($c->intersects($b)); // false
$b->set(10);
var_dump($b->intersects($c)); // true
var_dump($c->intersects($b)); // true
?>
--EXPECT--
bool(false)
bool(false)
bool(false)
bool(false)
bool(true)
bool(true)
tests/BitSet_xorOp.phpt000064400000000634151731414450011174 0ustar00--TEST--
BitSet BitSet::xorOp() - Test that logical XOR operations actually work
--SKIPIF--
<?php if (!extension_loaded('bitset')) die('skipping missing extension'); ?>
--FILE--
<?php
$b = new BitSet(); // 64 bits is fine
$c = new BitSet();
$b->set(2);
$b->set(6);
$c->set(2);
$b->xorOp($c);
var_dump($b->__toString());
?>
--EXPECT--
string(64) "0000001000000000000000000000000000000000000000000000000000000000"
tests/BitSet_isEmpty.phpt000064400000000634151731414460011520 0ustar00--TEST--
BitSet BitSet::isEmpty() - Verifies that isEmpty truly checks for all off bits
--SKIPIF--
<?php if (!extension_loaded('bitset')) die('skipping missing extension'); ?>
--FILE--
<?php
$b = new BitSet(); // 64 bits is fine
var_dump($b->isEmpty()); 

$b->set(32);
var_dump($b->isEmpty());

$b->clear(32);
$b->set(40);
$b->clear(40);
var_dump($b->isEmpty());
?>
--EXPECT--
bool(true)
bool(false)
bool(true)

tests/BitSet_fromString.phpt000064400000001211151731414460012210 0ustar00--TEST--
BitSet BitSet::fromString() - Verifies BitSet correctly parses incoming strings to its binary representation
--SKIPIF--
<?php if (!extension_loaded('bitset')) die('skipping missing extension'); ?>
--FILE--
<?php
$b = BitSet::fromString('0110');
var_dump($b->__toString());

$b = BitSet::fromString('0010000010');
var_dump($b->__toString());

$b = BitSet::fromString('0200100010');
var_dump($b->__toString());

$b = BitSet::fromString('');
var_dump($b->__toString());
?>
--EXPECT--
string(8) "01100000"
string(16) "0010000010000000"
string(16) "0000100010000000"
string(64) "0000000000000000000000000000000000000000000000000000000000000000"
tests/BitSet_fromArray.phpt000064400000001306151731414460012025 0ustar00--TEST--
BitSet BitSet::fromArray() - Verifies the provided input array is represented in set bits
--SKIPIF--
<?php if (!extension_loaded('bitset')) die('skipping missing extension'); ?>
--FILE--
<?php
$arr = [1, 6, 17, 2];
$b = BitSet::fromArray($arr);
var_dump($b->__toString());
var_dump($b->toArray());

$b = BitSet::fromArray([0]);
var_dump($b->__toString());
var_dump($b->toArray());

$b = BitSet::fromArray([7]);
var_dump($b->__toString());
var_dump($b->toArray());
?>
--EXPECT--
string(24) "011000100000000001000000"
array(4) {
  [0]=>
  int(1)
  [1]=>
  int(2)
  [2]=>
  int(6)
  [3]=>
  int(17)
}
string(8) "10000000"
array(1) {
  [0]=>
  int(0)
}
string(8) "00000001"
array(1) {
  [0]=>
  int(7)
}

tests/BitSet_set.phpt000064400000001445151731414460010662 0ustar00--TEST--
BitSet BitSet::set() - Tests for setting bits or a range of bits on
--SKIPIF--
<?php if (!extension_loaded('bitset')) die('skipping missing extension'); ?>
--FILE--
<?php
$b = new BitSet(8);
var_dump($b->__toString());
$b->set(2);
var_dump($b->__toString());

$b->set(2, 4);
var_dump($b->__toString());

$b->set(0);
var_dump($b->__toString());

$b->set(7);
var_dump($b->__toString());

$b->set(); // Set all bits on
var_dump($b->__toString());

try {
    var_dump($b->set(8));
} catch (Exception $e) {
    var_dump(get_class($e).': '.$e->getMessage());
}
?>
--EXPECT--
string(8) "00000000"
string(8) "00100000"
string(8) "00111000"
string(8) "10111000"
string(8) "10111001"
string(8) "11111111"
string(87) "OutOfRangeException: The requested start index is greater than the total number of bits"
tests/BitSet_size.phpt000064400000000626151731414460011041 0ustar00--TEST--
BitSet BitSet::size() - Tests to verify the total bits are maintained and correctly represented
--SKIPIF--
<?php if (!extension_loaded('bitset')) die('skipping missing extension'); ?>
--FILE--
<?php
$b = new BitSet();
var_dump($b->size());

$b = new BitSet(8);
$b->set(2, 4);
$b->clear(3);
var_dump($b->size());

$b = new BitSet(2048);
var_dump($b->size());
?>
--EXPECT--
int(64)
int(8)
int(2048)
tests/BitSet_length.phpt000064400000000756151731414460011354 0ustar00--TEST--
BitSet BitSet::length() - Verifies the highest bit + 1 is returned 
--SKIPIF--
<?php if (!extension_loaded('bitset')) die('skipping missing extension'); ?>
--FILE--
<?php
$b = new BitSet(); // 64 bits is fine
var_dump($b->length());

$b->set(0);
var_dump($b->length());

$b->set(33);
var_dump($b->length());

$b->set(22);
var_dump($b->length());

$b->set(55);
var_dump($b->length());

$b->clear(55);
var_dump($b->length());
?>
--EXPECT--
int(0)
int(1)
int(34)
int(34)
int(56)
int(34)

tests/BitSet_fromRawValue.phpt000064400000000743151731414460012501 0ustar00--TEST--
BitSet BitSet::fromRawValue() - Verifies the provided input raw value is represented in set bits
--SKIPIF--
<?php if (!extension_loaded('bitset')) die('skipping missing extension'); ?>
--FILE--
<?php
$b = BitSet::fromRawValue(base64_decode('AA=='));
var_dump($b->__toString());
$b = BitSet::fromRawValue(base64_decode('IA=='));
var_dump($b->__toString());
var_dump(base64_encode($b->getRawValue()));
?>
--EXPECT--
string(8) "00000000"
string(8) "00000100"
string(4) "IA=="

tests/bug63315.phpt000064400000000635151731414460007774 0ustar00--TEST--
Bug #63315 (BitSet::fromArray may modify original array value)
--SKIPIF--
<?php if (!extension_loaded('bitset')) die('skipping missing extension'); ?>
--FILE--
<?php
$arr = array(5, 6, '7');
var_dump($arr);
BitSet::fromArray($arr);
var_dump($arr);
?>
--EXPECT--
array(3) {
  [0]=>
  int(5)
  [1]=>
  int(6)
  [2]=>
  string(1) "7"
}
array(3) {
  [0]=>
  int(5)
  [1]=>
  int(6)
  [2]=>
  string(1) "7"
}
tests/BitSet_fromInteger.phpt000064400000001445151731414460012350 0ustar00--TEST--
BitSet BitSet::fromInteger() - Verifies the provided value is represented in set bits
--SKIPIF--
<?php if (!extension_loaded('bitset')) die('skipping missing extension'); ?>
--FILE--
<?php
$b = BitSet::fromInteger(0);
var_dump($b->__toString());
var_dump($b->toInteger());

$b = BitSet::fromInteger(42);
var_dump($b->__toString());
var_dump($b->toInteger());

$b = BitSet::fromInteger(0x010203);
var_dump($b->__toString());
var_dump($b->toInteger());

$b = new BitSet(80);
try {
	var_dump($b->toInteger());
} catch (InvalidArgumentException $e) {
	echo "Exception: " . $e->getMessage() . "\n";
}

?>
--EXPECTF--
string(%d) "0000000000000000000%s"
int(0)
string(%d) "0101010000000000000%s"
int(42)
string(%d) "1100000001000000100%s"
int(66051)
Exception: The total bits doesn't fit in an integer

tests/BitSet_construct.phpt000064400000001302151731414460012103 0ustar00--TEST--
BitSet BitSet::__construct() - Generic constructor tests
--SKIPIF--
<?php if (!extension_loaded('bitset')) die('skipping missing extension'); ?>
--FILE--
<?php
// Verify we initially get 64 bits that are off
$b = new BitSet();
var_dump($b->__toString());

// Verify we get 8 bits that are off
$b = new BitSet(8);
var_dump($b->__toString());

/* Regardless of the value specified in the constructor, it should
 * always be rounded to the nearest byte in size
 */
$b = new BitSet(12); // CHAR_BIT = 8, so we should have 16 bits
var_dump($b->__toString());
?>
--EXPECT--
string(64) "0000000000000000000000000000000000000000000000000000000000000000"
string(8) "00000000"
string(16) "0000000000000000"
tests/BitSet_toArray.phpt000064400000000740151731414470011506 0ustar00--TEST--
BitSet BitSet::toArray() - Verifies set bits are correctly returned in the array
--SKIPIF--
<?php if (!extension_loaded('bitset')) die('skipping missing extension'); ?>
--FILE--
<?php
$b = new BitSet(); // 64 bits is fine. tired of seeing this comment yet?
$b->set(5);
$b->set(22);
var_dump($b->toArray());

$b->clear(22);
$b->set(36);
var_dump($b->toArray());
?>
--EXPECT--
array(2) {
  [0]=>
  int(5)
  [1]=>
  int(22)
}
array(2) {
  [0]=>
  int(5)
  [1]=>
  int(36)
}
tests/BitSet_cardinality.phpt000064400000000700151731414470012364 0ustar00--TEST--
BitSet BitSet::cardinality() - Verifies all true bits that are set are correctly counted
--SKIPIF--
<?php if (!extension_loaded('bitset')) die('skipping missing extension'); ?>
--FILE--
<?php
$b = new BitSet(); // 64 bits is fine
$b->set(5);
$b->set(33);
$b->set(63);

var_dump($b->cardinality());

$b->clear(63);

var_dump($b->cardinality());

$b->set(32);
$b->clear(33);

var_dump($b->cardinality());
?>
--EXPECT--
int(3)
int(2)
int(2)

tests/BitSet_orOp.phpt000064400000000645151731414470011010 0ustar00--TEST--
BitSet BitSet::orOp() - Test that logical OR operations actually work
--SKIPIF--
<?php if (!extension_loaded('bitset')) die('skipping missing extension'); ?>
--FILE--
<?php
$b = new BitSet(); // 64 bits is fine
$c = new BitSet();
$b->set(2);
$b->set(6);
$c->set(2);
$c->set(9);
$b->orOp($c);
var_dump($b->__toString());
?>
--EXPECT--
string(64) "0010001001000000000000000000000000000000000000000000000000000000"
tests/BitSet_getRawValue.phpt000064400000000674151731414470012321 0ustar00--TEST--
BitSet BitSet::getRawValue() - Verifies the binary string returned is as expected and integrity is maintained
--SKIPIF--
<?php if (!extension_loaded('bitset')) die('skipping missing extension'); ?>
--FILE--
<?php
$b = new BitSet(8);
var_dump(base64_encode($b->getRawValue()));

$b->set(5);
var_dump(base64_encode($b->getRawValue()));
var_dump(bin2hex($b->getRawValue()));
?>
--EXPECT--
string(4) "AA=="
string(4) "IA=="
string(2) "20"
tests/BitSet_previousClearBit.phpt000064400000001544151731414470013352 0ustar00--TEST--
BitSet BitSet::previousClearBit() - Verifies the previous clear bit is valid based on the provided index
--SKIPIF--
<?php if (!extension_loaded('bitset')) die('skipping missing extension'); ?>
--FILE--
<?php
$b = new BitSet(); // 64 bits is fine
$b->set(20);
$b->set(18);
try {
    var_dump($b->previousClearBit(0));
} catch (Exception $e) {
    var_dump(get_class($e).': '.$e->getMessage());
}
var_dump($b->previousClearBit(20));
var_dump($b->previousClearBit(18));
var_dump($b->previousClearBit(5));
try {
    var_dump($b->previousClearBit(65));
} catch (Exception $e) {
    var_dump(get_class($e).': '.$e->getMessage());
}
?>
--EXPECT--
string(75) "InvalidArgumentException: There are no bits smaller than the index provided"
int(19)
int(17)
int(4)
string(93) "OutOfRangeException: The specified index parameter exceeds the total number of bits available"
tests/BitSet_nextSetBit.phpt000064400000001167151731414470012162 0ustar00--TEST--
BitSet BitSet::nextSetBit() - Verifies the next set bit is valid based on the provided index
--SKIPIF--
<?php if (!extension_loaded('bitset')) die('skipping missing extension'); ?>
--FILE--
<?php
$b = new BitSet(); // 64 bits is fine
$b->set(20);
$b->set(18);
var_dump($b->nextSetBit(0));
var_dump($b->nextSetBit(20));
var_dump($b->nextSetBit(18));
var_dump($b->nextSetBit(5));
try {
    var_dump($b->nextSetBit(63));
} catch (Exception $e) {
    echo get_class($e).': '.$e->getMessage()."\n";
}

?>
--EXPECT--
int(18)
bool(false)
int(20)
int(18)
InvalidArgumentException: There are no bits larger than the index provided
tests/BitSet_nextClearBit.phpt000064400000001176151731414470012455 0ustar00--TEST--
BitSet BitSet::nextClearBit() - Verifies the next clear bit is valid based on the provided index
--SKIPIF--
<?php if (!extension_loaded('bitset')) die('skipping missing extension'); ?>
--FILE--
<?php
$b = new BitSet(); // 64 bits is fine
$b->set(20);
$b->set(18);
var_dump($b->nextClearBit(0));
var_dump($b->nextClearBit(20));
var_dump($b->nextClearBit(18));
var_dump($b->nextClearBit(5));
try {
    var_dump($b->nextClearBit(63));
} catch (Exception $e) {
    echo get_class($e).': '.$e->getMessage()."\n";
}
?>
--EXPECT--
int(1)
int(21)
int(19)
int(6)
InvalidArgumentException: There are no bits larger than the index provided
tests/BitSet_andNotOp.phpt000064400000000651151731414470011610 0ustar00--TEST--
BitSet BitSet::andNotOp() - Test that switching set bits to off with input BitSet
--SKIPIF--
<?php if (!extension_loaded('bitset')) die('skipping missing extension'); ?>
--FILE--
<?php
$b = new BitSet(); // 64 bits is fine
$c = new BitSet();
$b->set(2);
$b->set(6);
$c->set(2);
$b->andNotOp($c);
var_dump($b->__toString());
?>
--EXPECT--
string(64) "0000001000000000000000000000000000000000000000000000000000000000"
Path: home/lnzliplg/public_html