芝麻web文件管理V1.00

编辑当前文件:/home/conskgoa/doughi.co.uk/alt-php81-pecl-bitset_3.2.0-1.el8.zip

PK�����T��\�%�hd��d��"��tests/BitSet_previousClearBit.phptnu��[�����������--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"
PK�����T��\h"�$��������tests/BitSet_size.phptnu��[�����������--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)
PK�����T��\��_|��������tests/BitSet_clear.phptnu��[�����������--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 bitsPK�����T��\��ܨ��������tests/BitSet_andOp.phptnu��[�����������--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"
PK�����T��\�Z�֥�������tests/BitSet_orOp.phptnu��[�����������--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"
PK�����T��\Q#�Ow��w����tests/BitSet_nextSetBit.phptnu��[�����������--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
PK�����T��\-�g��g�� ��tests/BitSet_previousSetBit.phptnu��[�����������--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"

PK�����T��\d��������tests/BitSet_isEmpty.phptnu��[�����������--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)

PK�����T��\}<E@%��%����tests/BitSet_set.phptnu��[�����������--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"
PK�����T��\�	a.Q��Q����tests/BitSet_get.phptnu��[�����������--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
PK�����T��\�_3]��������tests/BitSet_fromArray.phptnu��[�����������--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)
}

PK�����T��\I�����������tests/BitSet_toArray.phptnu��[�����������--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)
}
PK�����T��\#�����������tests/BitSet_fromString.phptnu��[�����������--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"
PK�����T��\�[C���������tests/BitSet_construct.phptnu��[�����������--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"
PK�����T��\�3��������tests/BitSet_xorOp.phptnu��[�����������--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"
PK�����T��\c
*a��������tests/BitSet_fromRawValue.phptnu��[�����������--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=="

PK�����T��\���Ik��k����tests/BitSet_intersects.phptnu��[�����������--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)
PK�����T��\�H�,��������tests/BitSet_cardinality.phptnu��[�����������--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)

PK�����T��\�y᧝�������tests/bug63315.phptnu��[�����������--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"
}
PK�����T��\��%~��~����tests/BitSet_nextClearBit.phptnu��[�����������--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
PK�����T��\U��~��������tests/BitSet_andNotOp.phptnu��[�����������--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"
PK�����T��\*k�%��%����tests/BitSet_fromInteger.phptnu��[�����������--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

PK�����T��\m��S��������tests/BitSet_length.phptnu��[�����������--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)

PK�����T��\-�.��������tests/BitSet_getRawValue.phptnu��[�����������--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"
PK�������T��\�%�hd��d��"����������������tests/BitSet_previousClearBit.phptnu��[�����������PK�������T��\h"�$���������������������tests/BitSet_size.phptnu��[�����������PK�������T��\��_|���������������������tests/BitSet_clear.phptnu��[�����������PK�������T��\��ܨ�������������������	��tests/BitSet_andOp.phptnu��[�����������PK�������T��\�Z�֥��������������������tests/BitSet_orOp.phptnu��[�����������PK�������T��\Q#�Ow��w��������������n
��tests/BitSet_nextSetBit.phptnu��[�����������PK�������T��\-�g��g�� ������������1��tests/BitSet_previousSetBit.phptnu��[�����������PK�������T��\d���������������������tests/BitSet_isEmpty.phptnu��[�����������PK�������T��\}<E@%��%�����������������tests/BitSet_set.phptnu��[�����������PK�������T��\�	a.Q��Q��������������7��tests/BitSet_get.phptnu��[�����������PK�������T��\�_3]���������������������tests/BitSet_fromArray.phptnu��[�����������PK�������T��\I������������������������tests/BitSet_toArray.phptnu��[�����������PK�������T��\#���������������������!��tests/BitSet_fromString.phptnu��[�����������PK�������T��\�[C��������������������#��tests/BitSet_construct.phptnu��[�����������PK�������T��\�3�������������������&��tests/BitSet_xorOp.phptnu��[�����������PK�������T��\c
*a�������������������(��tests/BitSet_fromRawValue.phptnu��[�����������PK�������T��\���Ik��k���������������*��tests/BitSet_intersects.phptnu��[�����������PK�������T��\�H�,�������������������-��tests/BitSet_cardinality.phptnu��[�����������PK�������T��\�y᧝������������������/��tests/bug63315.phptnu��[�����������PK�������T��\��%~��~���������������1��tests/BitSet_nextClearBit.phptnu��[�����������PK�������T��\U��~������������������m4��tests/BitSet_andNotOp.phptnu��[�����������PK�������T��\*k�%��%��������������`6��tests/BitSet_fromInteger.phptnu��[�����������PK�������T��\m��S�������������������9��tests/BitSet_length.phptnu��[�����������PK�������T��\-�.������������������<��tests/BitSet_getRawValue.phptnu��[�����������PK������q��>����