contrib/php-uuid
1
0
Fork 0
mirror of https://github.com/ramsey/uuid.git synced 2026-06-14 15:56:48 +03:00
Code Issues Packages Projects Releases Wiki Activity
Files
1a43ec52f4a5a70b11fab956cd0aa79501b18896
php-uuid/tests/Rhumsaa/Uuid/UuidTest.php
T

1396 lines
45 KiB
PHP
Raw Blame History

<?php
namespace Rhumsaa\Uuid;
require_once 'functions.php';
class UuidTest extends \PHPUnit_Framework_TestCase
{
protected function setUp()
{
Uuid::$timeOfDayTest = null;
Uuid::$force32Bit = false;
Uuid::$forceNoBigNumber = false;
Uuid::$ignoreSystemNode = false;
}
/**
* If the system is 32-bit, this will mark a test as skipped
*/
protected function skip64BitTest()
{
if (PHP_INT_SIZE == 4) {
$this->markTestSkipped(
'Skipping test that can run only on a 64-bit build of PHP.'
);
}
}
/**
* @covers Rhumsaa\Uuid\Uuid::fromString
* @covers Rhumsaa\Uuid\Uuid::__construct
*/
public function testFromString()
{
$uuid = Uuid::fromString('ff6f8cb0-c57d-11e1-9b21-0800200c9a66');
$this->assertInstanceOf('\Rhumsaa\Uuid\Uuid', $uuid);
$this->assertEquals('ff6f8cb0-c57d-11e1-9b21-0800200c9a66', $uuid->toString());
}
/**
* @covers Rhumsaa\Uuid\Uuid::fromString
*/
public function testFromStringWithCurlyBraces()
{
$uuid = Uuid::fromString('{ff6f8cb0-c57d-11e1-9b21-0800200c9a66}');
$this->assertInstanceOf('\Rhumsaa\Uuid\Uuid', $uuid);
$this->assertEquals('ff6f8cb0-c57d-11e1-9b21-0800200c9a66', $uuid->toString());
}
/**
* @covers Rhumsaa\Uuid\Uuid::fromString
* @expectedException InvalidArgumentException
* @expectedExceptionMessage Invalid UUID string:
*/
public function testFromStringWithInvalidUuidString()
{
$uuid = Uuid::fromString('ff6f8cb0-c57d-11e1-9b21');
}
/**
* @covers Rhumsaa\Uuid\Uuid::fromString
*/
public function testFromStringWithUrn()
{
$uuid = Uuid::fromString('urn:uuid:ff6f8cb0-c57d-11e1-9b21-0800200c9a66');
$this->assertInstanceOf('\Rhumsaa\Uuid\Uuid', $uuid);
$this->assertEquals('ff6f8cb0-c57d-11e1-9b21-0800200c9a66', $uuid->toString());
}
/**
* @covers Rhumsaa\Uuid\Uuid::getBytes
*/
public function testGetBytes()
{
$uuid = Uuid::fromString('ff6f8cb0-c57d-11e1-9b21-0800200c9a66');
$this->assertEquals(16, strlen($uuid->getBytes()));
$this->assertEquals('/2+MsMV9EeGbIQgAIAyaZg==', base64_encode($uuid->getBytes()));
}
/**
* @covers Rhumsaa\Uuid\Uuid::getClockSeqHiAndReserved
*/
public function testGetClockSeqHiAndReserved()
{
$uuid = Uuid::fromString('ff6f8cb0-c57d-11e1-9b21-0800200c9a66');
$this->assertEquals(155, $uuid->getClockSeqHiAndReserved());
}
/**
* @covers Rhumsaa\Uuid\Uuid::getClockSeqHiAndReservedHex
*/
public function testGetClockSeqHiAndReservedHex()
{
$uuid = Uuid::fromString('ff6f8cb0-c57d-11e1-9b21-0800200c9a66');
$this->assertEquals('9b', $uuid->getClockSeqHiAndReservedHex());
}
/**
* @covers Rhumsaa\Uuid\Uuid::getClockSeqLow
*/
public function testGetClockSeqLow()
{
$uuid = Uuid::fromString('ff6f8cb0-c57d-11e1-9b21-0800200c9a66');
$this->assertEquals(33, $uuid->getClockSeqLow());
}
/**
* @covers Rhumsaa\Uuid\Uuid::getClockSeqLowHex
*/
public function testGetClockSeqLowHex()
{
$uuid = Uuid::fromString('ff6f8cb0-c57d-11e1-9b21-0800200c9a66');
$this->assertEquals('21', $uuid->getClockSeqLowHex());
}
/**
* @covers Rhumsaa\Uuid\Uuid::getClockSequence
*/
public function testGetClockSequence()
{
$uuid = Uuid::fromString('ff6f8cb0-c57d-11e1-9b21-0800200c9a66');
$this->assertEquals(6945, $uuid->getClockSequence());
}
/**
* @covers Rhumsaa\Uuid\Uuid::getClockSequenceHex
*/
public function testGetClockSequenceHex()
{
$uuid = Uuid::fromString('ff6f8cb0-c57d-11e1-9b21-0800200c9a66');
$this->assertEquals('1b21', $uuid->getClockSequenceHex());
}
/**
* @covers Rhumsaa\Uuid\Uuid::getDateTime
*/
public function testGetDateTime()
{
// Check a recent date
$uuid = Uuid::fromString('ff6f8cb0-c57d-11e1-9b21-0800200c9a66');
$this->assertInstanceOf('\DateTime', $uuid->getDateTime());
$this->assertEquals('Wed, 04 Jul 2012 02:14:34 +0000', $uuid->getDateTime()->format('r'));
// Check an old date
$uuid = Uuid::fromString('0901e600-0154-1000-9b21-0800200c9a66');
$this->assertInstanceOf('\DateTime', $uuid->getDateTime());
$this->assertEquals('Sun, 16 Oct 1582 16:34:04 +0000', $uuid->getDateTime()->format('r'));
// Check a future date
$uuid = Uuid::fromString('ff9785f6-ffff-1fff-9669-00007ffffffe');
$this->assertInstanceOf('\DateTime', $uuid->getDateTime());
$this->assertEquals('Mon, 31 Mar 5236 21:21:00 +0000', $uuid->getDateTime()->format('r'));
// Check the oldest date
$uuid = Uuid::fromString('00000000-0000-1000-9669-00007ffffffe');
$this->assertInstanceOf('\DateTime', $uuid->getDateTime());
$this->assertEquals('Sat, 15 Oct 1582 00:00:00 +0000', $uuid->getDateTime()->format('r'));
}
/**
* @covers Rhumsaa\Uuid\Uuid::getDateTime
*/
public function testGetDateTime32Bit()
{
Uuid::$force32Bit = true;
// Check a recent date
$uuid = Uuid::fromString('ff6f8cb0-c57d-11e1-9b21-0800200c9a66');
$this->assertInstanceOf('\DateTime', $uuid->getDateTime());
$this->assertEquals('Wed, 04 Jul 2012 02:14:34 +0000', $uuid->getDateTime()->format('r'));
// Check an old date
$uuid = Uuid::fromString('0901e600-0154-1000-9b21-0800200c9a66');
$this->assertInstanceOf('\DateTime', $uuid->getDateTime());
$this->assertEquals('Sun, 16 Oct 1582 16:34:04 +0000', $uuid->getDateTime()->format('r'));
// Check a future date
$uuid = Uuid::fromString('ff9785f6-ffff-1fff-9669-00007ffffffe');
$this->assertInstanceOf('\DateTime', $uuid->getDateTime());
$this->assertEquals('Mon, 31 Mar 5236 21:21:00 +0000', $uuid->getDateTime()->format('r'));
// Check the oldest date
$uuid = Uuid::fromString('00000000-0000-1000-9669-00007ffffffe');
$this->assertInstanceOf('\DateTime', $uuid->getDateTime());
$this->assertEquals('Sat, 15 Oct 1582 00:00:00 +0000', $uuid->getDateTime()->format('r'));
}
/**
* @covers Rhumsaa\Uuid\Uuid::getDateTime
* @expectedException Rhumsaa\Uuid\Exception\UnsatisfiedDependencyException
*/
public function testGetDateTimeThrownException()
{
Uuid::$force32Bit = true;
Uuid::$forceNoBigNumber = true;
$uuid = Uuid::fromString('ff6f8cb0-c57d-11e1-9b21-0800200c9a66');
$date = $uuid->getDateTime();
}
/**
* @covers Rhumsaa\Uuid\Uuid::getDateTime
* @covers Rhumsaa\Uuid\Exception\UnsupportedOperationException
* @expectedException Rhumsaa\Uuid\Exception\UnsupportedOperationException
* @expectedExceptionMessage Not a time-based UUID
*/
public function testGetDateTimeFromNonVersion1Uuid()
{
// Using a version 4 UUID to test
$uuid = Uuid::fromString('bf17b594-41f2-474f-bf70-4c90220f75de');
$date = $uuid->getDateTime();
}
/**
* @covers Rhumsaa\Uuid\Uuid::getFields
*/
public function testGetFields()
{
$this->skip64BitTest();
$fields = array(
'time_low' => 4285500592,
'time_mid' => 50557,
'time_hi_and_version' => 4577,
'clock_seq_hi_and_reserved' => 155,
'clock_seq_low' => 33,
'node' => 8796630719078,
);
$uuid = Uuid::fromString('ff6f8cb0-c57d-11e1-9b21-0800200c9a66');
$this->assertEquals($fields, $uuid->getFields());
}
/**
* @covers Rhumsaa\Uuid\Uuid::getFields
* @expectedException Rhumsaa\Uuid\Exception\UnsatisfiedDependencyException
*/
public function testGetFields32Bit()
{
Uuid::$force32Bit = true;
$uuid = Uuid::fromString('ff6f8cb0-c57d-11e1-9b21-0800200c9a66');
$fields = $uuid->getFields();
}
/**
* @covers Rhumsaa\Uuid\Uuid::getFieldsHex
*/
public function testGetFieldsHex()
{
$fields = array(
'time_low' => 'ff6f8cb0',
'time_mid' => 'c57d',
'time_hi_and_version' => '11e1',
'clock_seq_hi_and_reserved' => '9b',
'clock_seq_low' => '21',
'node' => '0800200c9a66',
);
$uuid = Uuid::fromString('ff6f8cb0-c57d-11e1-9b21-0800200c9a66');
$this->assertEquals($fields, $uuid->getFieldsHex());
}
/**
* @covers Rhumsaa\Uuid\Uuid::getLeastSignificantBits
*/
public function testGetLeastSignificantBits()
{
$uuid = Uuid::fromString('ff6f8cb0-c57d-11e1-9b21-0800200c9a66');
$this->assertInstanceOf('Moontoast\Math\BigNumber', $uuid->getLeastSignificantBits());
$this->assertEquals('11178224546741000806', $uuid->getLeastSignificantBits()->getValue());
}
/**
* @covers Rhumsaa\Uuid\Uuid::getLeastSignificantBits
* @expectedException Rhumsaa\Uuid\Exception\UnsatisfiedDependencyException
*/
public function testGetLeastSignificantBitsException()
{
Uuid::$forceNoBigNumber = true;
$uuid = Uuid::fromString('ff6f8cb0-c57d-11e1-9b21-0800200c9a66');
$bn = $uuid->getLeastSignificantBits();
}
/**
* @covers Rhumsaa\Uuid\Uuid::getLeastSignificantBitsHex
*/
public function testGetLeastSignificantBitsHex()
{
$uuid = Uuid::fromString('ff6f8cb0-c57d-11e1-9b21-0800200c9a66');
$this->assertEquals('9b210800200c9a66', $uuid->getLeastSignificantBitsHex());
}
/**
* @covers Rhumsaa\Uuid\Uuid::getMostSignificantBits
*/
public function testGetMostSignificantBits()
{
$uuid = Uuid::fromString('ff6f8cb0-c57d-11e1-9b21-0800200c9a66');
$this->assertInstanceOf('Moontoast\Math\BigNumber', $uuid->getMostSignificantBits());
$this->assertEquals('18406084892941947361', $uuid->getMostSignificantBits()->getValue());
}
/**
* @covers Rhumsaa\Uuid\Uuid::getMostSignificantBits
* @expectedException Rhumsaa\Uuid\Exception\UnsatisfiedDependencyException
*/
public function testGetMostSignificantBitsException()
{
Uuid::$forceNoBigNumber = true;
$uuid = Uuid::fromString('ff6f8cb0-c57d-11e1-9b21-0800200c9a66');
$bn = $uuid->getMostSignificantBits();
}
/**
* @covers Rhumsaa\Uuid\Uuid::getMostSignificantBitsHex
*/
public function testGetMostSignificantBitsHex()
{
$uuid = Uuid::fromString('ff6f8cb0-c57d-11e1-9b21-0800200c9a66');
$this->assertEquals('ff6f8cb0c57d11e1', $uuid->getMostSignificantBitsHex());
}
/**
* @covers Rhumsaa\Uuid\Uuid::getNode
*/
public function testGetNode()
{
$this->skip64BitTest();
$uuid = Uuid::fromString('ff6f8cb0-c57d-11e1-9b21-0800200c9a66');
$this->assertEquals(8796630719078, $uuid->getNode());
}
/**
* @covers Rhumsaa\Uuid\Uuid::getNode
* @expectedException Rhumsaa\Uuid\Exception\UnsatisfiedDependencyException
*/
public function testGetNode32Bit()
{
Uuid::$force32Bit = true;
$uuid = Uuid::fromString('ff6f8cb0-c57d-11e1-9b21-0800200c9a66');
$node = $uuid->getNode();
}
/**
* @covers Rhumsaa\Uuid\Uuid::getNodeHex
*/
public function testGetNodeHex()
{
$uuid = Uuid::fromString('ff6f8cb0-c57d-11e1-9b21-0800200c9a66');
$this->assertEquals('0800200c9a66', $uuid->getNodeHex());
}
/**
* @covers Rhumsaa\Uuid\Uuid::getTimeHiAndVersion
*/
public function testGetTimeHiAndVersion()
{
$uuid = Uuid::fromString('ff6f8cb0-c57d-11e1-9b21-0800200c9a66');
$this->assertEquals(4577, $uuid->getTimeHiAndVersion());
}
/**
* @covers Rhumsaa\Uuid\Uuid::getTimeHiAndVersionHex
*/
public function testGetTimeHiAndVersionHex()
{
$uuid = Uuid::fromString('ff6f8cb0-c57d-11e1-9b21-0800200c9a66');
$this->assertEquals('11e1', $uuid->getTimeHiAndVersionHex());
}
/**
* @covers Rhumsaa\Uuid\Uuid::getTimeLow
*/
public function testGetTimeLow()
{
$this->skip64BitTest();
$uuid = Uuid::fromString('ff6f8cb0-c57d-11e1-9b21-0800200c9a66');
$this->assertEquals(4285500592, $uuid->getTimeLow());
}
/**
* @covers Rhumsaa\Uuid\Uuid::getTimeLow
* @expectedException Rhumsaa\Uuid\Exception\UnsatisfiedDependencyException
*/
public function testGetTimeLow32Bit()
{
Uuid::$force32Bit = true;
$uuid = Uuid::fromString('ff6f8cb0-c57d-11e1-9b21-0800200c9a66');
$timeLow = $uuid->getTimeLow();
}
/**
* @covers Rhumsaa\Uuid\Uuid::getTimeLowHex
*/
public function testGetTimeLowHex()
{
$uuid = Uuid::fromString('ff6f8cb0-c57d-11e1-9b21-0800200c9a66');
$this->assertEquals('ff6f8cb0', $uuid->getTimeLowHex());
}
/**
* @covers Rhumsaa\Uuid\Uuid::getTimeMid
*/
public function testGetTimeMid()
{
$uuid = Uuid::fromString('ff6f8cb0-c57d-11e1-9b21-0800200c9a66');
$this->assertEquals(50557, $uuid->getTimeMid());
}
/**
* @covers Rhumsaa\Uuid\Uuid::getTimeMidHex
*/
public function testGetTimeMidHex()
{
$uuid = Uuid::fromString('ff6f8cb0-c57d-11e1-9b21-0800200c9a66');
$this->assertEquals('c57d', $uuid->getTimeMidHex());
}
/**
* @covers Rhumsaa\Uuid\Uuid::getTimestamp
*/
public function testGetTimestamp()
{
$this->skip64BitTest();
// Check for a recent date
$uuid = Uuid::fromString('ff6f8cb0-c57d-11e1-9b21-0800200c9a66');
$this->assertEquals(135606608744910000, $uuid->getTimestamp());
// Check for an old date
$uuid = Uuid::fromString('0901e600-0154-1000-9b21-0800200c9a66');
$this->assertEquals(1460440000000, $uuid->getTimestamp());
}
/**
* @covers Rhumsaa\Uuid\Uuid::getTimestampHex
*/
public function testGetTimestampHex()
{
// Check for a recent date
$uuid = Uuid::fromString('ff6f8cb0-c57d-11e1-9b21-0800200c9a66');
$this->assertEquals('1e1c57dff6f8cb0', $uuid->getTimestampHex());
// Check for an old date
$uuid = Uuid::fromString('0901e600-0154-1000-9b21-0800200c9a66');
$this->assertEquals('00001540901e600', $uuid->getTimestampHex());
}
/**
* @covers Rhumsaa\Uuid\Uuid::getTimestamp
* @covers Rhumsaa\Uuid\Exception\UnsupportedOperationException
* @expectedException Rhumsaa\Uuid\Exception\UnsupportedOperationException
* @expectedExceptionMessage Not a time-based UUID
*/
public function testGetTimestampFromNonVersion1Uuid()
{
// Using a version 4 UUID to test
$uuid = Uuid::fromString('bf17b594-41f2-474f-bf70-4c90220f75de');
$ts = $uuid->getTimestamp();
}
/**
* @covers Rhumsaa\Uuid\Uuid::getTimestampHex
* @covers Rhumsaa\Uuid\Exception\UnsupportedOperationException
* @expectedException Rhumsaa\Uuid\Exception\UnsupportedOperationException
* @expectedExceptionMessage Not a time-based UUID
*/
public function testGetTimestampHexFromNonVersion1Uuid()
{
// Using a version 4 UUID to test
$uuid = Uuid::fromString('bf17b594-41f2-474f-bf70-4c90220f75de');
$ts = $uuid->getTimestampHex();
}
/**
* @covers Rhumsaa\Uuid\Uuid::getTimestamp
* @expectedException Rhumsaa\Uuid\Exception\UnsatisfiedDependencyException
*/
public function testGetTimestamp32Bit()
{
Uuid::$force32Bit = true;
$uuid = Uuid::fromString('ff6f8cb0-c57d-11e1-9b21-0800200c9a66');
$ts = $uuid->getTimestamp();
}
/**
* @covers Rhumsaa\Uuid\Uuid::getUrn
*/
public function testGetUrn()
{
$uuid = Uuid::fromString('ff6f8cb0-c57d-11e1-9b21-0800200c9a66');
$this->assertEquals('urn:uuid:ff6f8cb0-c57d-11e1-9b21-0800200c9a66', $uuid->getUrn());
}
/**
* @covers Rhumsaa\Uuid\Uuid::getVariant
*/
public function testGetVariantForReservedNcs()
{
$uuid1 = Uuid::fromString('ff6f8cb0-c57d-11e1-0b21-0800200c9a66');
$this->assertEquals(0, $uuid1->getVariant());
$uuid2 = Uuid::fromString('ff6f8cb0-c57d-11e1-1b21-0800200c9a66');
$this->assertEquals(0, $uuid2->getVariant());
$uuid3 = Uuid::fromString('ff6f8cb0-c57d-11e1-2b21-0800200c9a66');
$this->assertEquals(0, $uuid3->getVariant());
$uuid4 = Uuid::fromString('ff6f8cb0-c57d-11e1-3b21-0800200c9a66');
$this->assertEquals(0, $uuid4->getVariant());
$uuid5 = Uuid::fromString('ff6f8cb0-c57d-11e1-4b21-0800200c9a66');
$this->assertEquals(0, $uuid5->getVariant());
$uuid6 = Uuid::fromString('ff6f8cb0-c57d-11e1-5b21-0800200c9a66');
$this->assertEquals(0, $uuid6->getVariant());
$uuid7 = Uuid::fromString('ff6f8cb0-c57d-11e1-6b21-0800200c9a66');
$this->assertEquals(0, $uuid7->getVariant());
$uuid8 = Uuid::fromString('ff6f8cb0-c57d-11e1-7b21-0800200c9a66');
$this->assertEquals(0, $uuid8->getVariant());
}
/**
* @covers Rhumsaa\Uuid\Uuid::getVariant
*/
public function testGetVariantForRfc4122()
{
$uuid1 = Uuid::fromString('ff6f8cb0-c57d-11e1-8b21-0800200c9a66');
$this->assertEquals(2, $uuid1->getVariant());
$uuid2 = Uuid::fromString('ff6f8cb0-c57d-11e1-9b21-0800200c9a66');
$this->assertEquals(2, $uuid2->getVariant());
$uuid3 = Uuid::fromString('ff6f8cb0-c57d-11e1-ab21-0800200c9a66');
$this->assertEquals(2, $uuid3->getVariant());
$uuid4 = Uuid::fromString('ff6f8cb0-c57d-11e1-bb21-0800200c9a66');
$this->assertEquals(2, $uuid4->getVariant());
}
/**
* @covers Rhumsaa\Uuid\Uuid::getVariant
*/
public function testGetVariantForReservedMicrosoft()
{
$uuid1 = Uuid::fromString('ff6f8cb0-c57d-11e1-cb21-0800200c9a66');
$this->assertEquals(6, $uuid1->getVariant());
$uuid2 = Uuid::fromString('ff6f8cb0-c57d-11e1-db21-0800200c9a66');
$this->assertEquals(6, $uuid2->getVariant());
}
/**
* @covers Rhumsaa\Uuid\Uuid::getVariant
*/
public function testGetVariantForReservedFuture()
{
$uuid1 = Uuid::fromString('ff6f8cb0-c57d-11e1-eb21-0800200c9a66');
$this->assertEquals(7, $uuid1->getVariant());
$uuid2 = Uuid::fromString('ff6f8cb0-c57d-11e1-fb21-0800200c9a66');
$this->assertEquals(7, $uuid2->getVariant());
}
/**
* @covers Rhumsaa\Uuid\Uuid::getVersion
*/
public function testGetVersionForVersion1()
{
$uuid = Uuid::fromString('ff6f8cb0-c57d-11e1-9b21-0800200c9a66');
$this->assertEquals(1, $uuid->getVersion());
}
/**
* @covers Rhumsaa\Uuid\Uuid::getVersion
*/
public function testGetVersionForVersion2()
{
$uuid = Uuid::fromString('6fa459ea-ee8a-2ca4-894e-db77e160355e');
$this->assertEquals(2, $uuid->getVersion());
}
/**
* @covers Rhumsaa\Uuid\Uuid::getVersion
*/
public function testGetVersionForVersion3()
{
$uuid = Uuid::fromString('6fa459ea-ee8a-3ca4-894e-db77e160355e');
$this->assertEquals(3, $uuid->getVersion());
}
/**
* @covers Rhumsaa\Uuid\Uuid::getVersion
*/
public function testGetVersionForVersion4()
{
$uuid = Uuid::fromString('6fabf0bc-603a-42f2-925b-d9f779bd0032');
$this->assertEquals(4, $uuid->getVersion());
}
/**
* @covers Rhumsaa\Uuid\Uuid::getVersion
*/
public function testGetVersionForVersion5()
{
$uuid = Uuid::fromString('886313e1-3b8a-5372-9b90-0c9aee199e5d');
$this->assertEquals(5, $uuid->getVersion());
}
/**
* @covers Rhumsaa\Uuid\Uuid::toString
* @covers Rhumsaa\Uuid\Uuid::__toString
*/
public function testToString()
{
// Check with a recent date
$uuid = Uuid::fromString('ff6f8cb0-c57d-11e1-9b21-0800200c9a66');
$this->assertEquals('ff6f8cb0-c57d-11e1-9b21-0800200c9a66', $uuid->toString());
$this->assertEquals('ff6f8cb0-c57d-11e1-9b21-0800200c9a66', sprintf('%s', $uuid));
// Check with an old date
$uuid = Uuid::fromString('0901e600-0154-1000-9b21-0800200c9a66');
$this->assertEquals('0901e600-0154-1000-9b21-0800200c9a66', $uuid->toString());
$this->assertEquals('0901e600-0154-1000-9b21-0800200c9a66', sprintf('%s', $uuid));
}
/**
* This calls php_uname() in getNodeFromSystem. The first time it is
* called, it returns "WIN." Each additional times, it returns the
* normal system php_uname().
*
* See the bottom of this test file to see where we are overriding
* php_uname() for the purpose of this test.
*
* @covers Rhumsaa\Uuid\Uuid::uuid1
* @covers Rhumsaa\Uuid\Uuid::getNodeFromSystem
*/
public function testUuid1CoverageForWindows()
{
$uuid = Uuid::uuid1();
$this->assertInstanceOf('\Rhumsaa\Uuid\Uuid', $uuid);
$this->assertInstanceOf('\DateTime', $uuid->getDateTime());
$this->assertEquals(2, $uuid->getVariant());
$this->assertEquals(1, $uuid->getVersion());
}
/**
* @covers Rhumsaa\Uuid\Uuid::uuid1
* @covers Rhumsaa\Uuid\Uuid::getNodeFromSystem
*/
public function testUuid1()
{
$uuid = Uuid::uuid1();
$this->assertInstanceOf('\Rhumsaa\Uuid\Uuid', $uuid);
$this->assertInstanceOf('\DateTime', $uuid->getDateTime());
$this->assertEquals(2, $uuid->getVariant());
$this->assertEquals(1, $uuid->getVersion());
}
/**
* @covers Rhumsaa\Uuid\Uuid::uuid1
*/
public function testUuid1WithNodeAndClockSequence()
{
$this->skip64BitTest();
$uuid = Uuid::uuid1(0x0800200c9a66, 0x1669);
$this->assertInstanceOf('\Rhumsaa\Uuid\Uuid', $uuid);
$this->assertInstanceOf('\DateTime', $uuid->getDateTime());
$this->assertEquals(2, $uuid->getVariant());
$this->assertEquals(1, $uuid->getVersion());
$this->assertEquals(5737, $uuid->getClockSequence());
$this->assertEquals(8796630719078, $uuid->getNode());
$this->assertEquals('9669-0800200c9a66', substr($uuid->toString(), 19));
}
/**
* @covers Rhumsaa\Uuid\Uuid::uuid1
*/
public function testUuid1WithHexadecimalNode()
{
$uuid = Uuid::uuid1('7160355e');
$this->assertInstanceOf('\Rhumsaa\Uuid\Uuid', $uuid);
$this->assertInstanceOf('\DateTime', $uuid->getDateTime());
$this->assertEquals(2, $uuid->getVariant());
$this->assertEquals(1, $uuid->getVersion());
$this->assertEquals('00007160355e', $uuid->getNodeHex());
if (PHP_INT_SIZE == 8) {
$this->assertEquals(1902130526, $uuid->getNode());
}
}
/**
* @covers Rhumsaa\Uuid\Uuid::uuid1
*/
public function testUuid1WithMixedCaseHexadecimalNode()
{
$uuid = Uuid::uuid1('71B0aD5e');
$this->assertInstanceOf('\Rhumsaa\Uuid\Uuid', $uuid);
$this->assertInstanceOf('\DateTime', $uuid->getDateTime());
$this->assertEquals(2, $uuid->getVariant());
$this->assertEquals(1, $uuid->getVersion());
$this->assertEquals('000071b0ad5e', $uuid->getNodeHex());
if (PHP_INT_SIZE == 8) {
$this->assertEquals(1907404126, $uuid->getNode());
}
}
/**
* @covers Rhumsaa\Uuid\Uuid::uuid1
*/
public function testUuid1WithNodeAndClockSequence32Bit()
{
$uuid = Uuid::uuid1(0x7fffffff, 0x1669);
$this->assertInstanceOf('\Rhumsaa\Uuid\Uuid', $uuid);
$this->assertInstanceOf('\DateTime', $uuid->getDateTime());
$this->assertEquals(2, $uuid->getVariant());
$this->assertEquals(1, $uuid->getVersion());
$this->assertEquals(5737, $uuid->getClockSequence());
$this->assertEquals('00007fffffff', $uuid->getNodeHex());
$this->assertEquals('9669-00007fffffff', substr($uuid->toString(), 19));
if (PHP_INT_SIZE == 8) {
$this->assertEquals(2147483647, $uuid->getNode());
}
}
/**
* @covers Rhumsaa\Uuid\Uuid::uuid1
* @expectedException InvalidArgumentException
* @expectedExceptionMessage Invalid node value
*/
public function testUuid1WithOutOfBoundsNode()
{
$uuid = Uuid::uuid1(9223372036854775808);
}
/**
* @covers Rhumsaa\Uuid\Uuid::uuid1
* @expectedException InvalidArgumentException
* @expectedExceptionMessage Invalid node value
*/
public function testUuid1WithNonHexadecimalNode()
{
$uuid = Uuid::uuid1('db77e160355g');
}
/**
* @covers Rhumsaa\Uuid\Uuid::uuid1
* @expectedException InvalidArgumentException
* @expectedExceptionMessage Invalid node value
*/
public function testUuid1WithNon48bitNumber()
{
$uuid = Uuid::uuid1('db77e160355ef');
}
/**
* @covers Rhumsaa\Uuid\Uuid::uuid1
*/
public function testUuid1WithRandomNode()
{
Uuid::$ignoreSystemNode = true;
$uuid = Uuid::uuid1();
$this->assertInstanceOf('\Rhumsaa\Uuid\Uuid', $uuid);
$this->assertInstanceOf('\DateTime', $uuid->getDateTime());
$this->assertEquals(2, $uuid->getVariant());
$this->assertEquals(1, $uuid->getVersion());
}
/**
* The "python.org" UUID is a known entity, so we're testing that this
* library generates a matching UUID for the same name.
* @see http://docs.python.org/library/uuid.html
*
* @covers Rhumsaa\Uuid\Uuid::uuid3
* @covers Rhumsaa\Uuid\Uuid::uuidFromHashedName
*/
public function testUuid3WithNamespaceAsUuidObject()
{
$nsUuid = Uuid::fromString(Uuid::NAMESPACE_DNS);
$uuid = Uuid::uuid3($nsUuid, 'python.org');
$this->assertEquals('6fa459ea-ee8a-3ca4-894e-db77e160355e', $uuid->toString());
$this->assertEquals(2, $uuid->getVariant());
$this->assertEquals(3, $uuid->getVersion());
}
/**
* The "python.org" UUID is a known entity, so we're testing that this
* library generates a matching UUID for the same name.
* @see http://docs.python.org/library/uuid.html
*
* @covers Rhumsaa\Uuid\Uuid::uuid3
* @covers Rhumsaa\Uuid\Uuid::uuidFromHashedName
*/
public function testUuid3WithNamespaceAsUuidString()
{
$uuid = Uuid::uuid3(Uuid::NAMESPACE_DNS, 'python.org');
$this->assertEquals('6fa459ea-ee8a-3ca4-894e-db77e160355e', $uuid->toString());
$this->assertEquals(2, $uuid->getVariant());
$this->assertEquals(3, $uuid->getVersion());
}
/**
* @covers Rhumsaa\Uuid\Uuid::uuid4
* @covers Rhumsaa\Uuid\Uuid::uuidFromHashedName
*/
public function testUuid4()
{
$uuid = Uuid::uuid4();
$this->assertInstanceOf('Rhumsaa\Uuid\Uuid', $uuid);
$this->assertEquals(2, $uuid->getVariant());
$this->assertEquals(4, $uuid->getVersion());
}
/**
* The "python.org" UUID is a known entity, so we're testing that this
* library generates a matching UUID for the same name.
* @see http://docs.python.org/library/uuid.html
*
* @covers Rhumsaa\Uuid\Uuid::uuid5
* @covers Rhumsaa\Uuid\Uuid::uuidFromHashedName
*/
public function testUuid5WithNamespaceAsUuidObject()
{
$nsUuid = Uuid::fromString(Uuid::NAMESPACE_DNS);
$uuid = Uuid::uuid5($nsUuid, 'python.org');
$this->assertEquals('886313e1-3b8a-5372-9b90-0c9aee199e5d', $uuid->toString());
$this->assertEquals(2, $uuid->getVariant());
$this->assertEquals(5, $uuid->getVersion());
}
/**
* The "python.org" UUID is a known entity, so we're testing that this
* library generates a matching UUID for the same name.
* @see http://docs.python.org/library/uuid.html
*
* @covers Rhumsaa\Uuid\Uuid::uuid5
* @covers Rhumsaa\Uuid\Uuid::uuidFromHashedName
*/
public function testUuid5WithNamespaceAsUuidString()
{
$uuid = Uuid::uuid5(Uuid::NAMESPACE_DNS, 'python.org');
$this->assertEquals('886313e1-3b8a-5372-9b90-0c9aee199e5d', $uuid->toString());
$this->assertEquals(2, $uuid->getVariant());
$this->assertEquals(5, $uuid->getVersion());
}
/**
* @covers Rhumsaa\Uuid\Uuid::compareTo
*/
public function testCompareTo()
{
// $uuid1 and $uuid2 are identical
$uuid1 = Uuid::fromString('ff6f8cb0-c57d-11e1-9b21-0800200c9a66');
$uuid2 = Uuid::fromString('ff6f8cb0-c57d-11e1-9b21-0800200c9a66');
// The next three UUIDs are used for comparing msb and lsb in
// the compareTo() method
// msb are less than $uuid4, lsb are greater than $uuid5
$uuid3 = Uuid::fromString('44cca71e-d13d-11e1-a959-c8bcc8a476f4');
// msb are greater than $uuid3, lsb are equal to those in $uuid3
$uuid4 = Uuid::fromString('44cca71e-d13d-11e2-a959-c8bcc8a476f4');
// msb are equal to those in $uuid3, lsb are less than in $uuid3
$uuid5 = Uuid::fromString('44cca71e-d13d-11e1-a959-c8bcc8a476f3');
$this->assertEquals(0, $uuid1->compareTo($uuid2));
$this->assertEquals(0, $uuid2->compareTo($uuid1));
$this->assertEquals(-1, $uuid3->compareTo($uuid4));
$this->assertEquals(1, $uuid4->compareTo($uuid3));
$this->assertEquals(-1, $uuid5->compareTo($uuid3));
$this->assertEquals(1, $uuid3->compareto($uuid5));
}
/**
* @covers Rhumsaa\Uuid\Uuid::equals
*/
public function testEquals()
{
$uuid1 = Uuid::uuid5(Uuid::NAMESPACE_DNS, 'python.org');
$uuid2 = Uuid::uuid5(Uuid::NAMESPACE_DNS, 'python.org');
$uuid3 = Uuid::uuid5(Uuid::NAMESPACE_DNS, 'php.net');
$this->assertTrue($uuid1->equals($uuid2));
$this->assertFalse($uuid1->equals($uuid3));
$this->assertFalse($uuid1->equals(null));
$this->assertFalse($uuid1->equals(new \stdClass()));
}
/**
* @covers Rhumsaa\Uuid\Uuid::uuid1
* @covers Rhumsaa\Uuid\Uuid::calculateUuidTime
*/
public function testCalculateUuidTime()
{
$timeOfDay = array(
'sec' => 1348845514,
'usec' => 277885,
'minuteswest' => 0,
'dsttime' => 0,
);
// For usec = 277885
Uuid::$timeOfDayTest = $timeOfDay;
$uuidA = Uuid::uuid1(0x00007ffffffe, 0x1669);
$this->assertEquals('c4dbe7e2-097f-11e2-9669-00007ffffffe', (string) $uuidA);
$this->assertEquals('c4dbe7e2', $uuidA->getTimeLowHex());
$this->assertEquals('097f', $uuidA->getTimeMidHex());
$this->assertEquals('11e2', $uuidA->getTimeHiAndVersionHex());
// For usec = 0
Uuid::$timeOfDayTest['usec'] = 0;
$uuidB = Uuid::uuid1(0x00007ffffffe, 0x1669);
$this->assertEquals('c4b18100-097f-11e2-9669-00007ffffffe', (string) $uuidB);
$this->assertEquals('c4b18100', $uuidB->getTimeLowHex());
$this->assertEquals('097f', $uuidB->getTimeMidHex());
$this->assertEquals('11e2', $uuidB->getTimeHiAndVersionHex());
// For usec = 999999
Uuid::$timeOfDayTest['usec'] = 999999;
$uuidC = Uuid::uuid1(0x00007ffffffe, 0x1669);
$this->assertEquals('c54a1776-097f-11e2-9669-00007ffffffe', (string) $uuidC);
$this->assertEquals('c54a1776', $uuidC->getTimeLowHex());
$this->assertEquals('097f', $uuidC->getTimeMidHex());
$this->assertEquals('11e2', $uuidC->getTimeHiAndVersionHex());
}
/**
* @covers Rhumsaa\Uuid\Uuid::uuid1
* @covers Rhumsaa\Uuid\Uuid::calculateUuidTime
*/
public function testCalculateUuidTimeForce32BitPath()
{
Uuid::$force32Bit = true;
$timeOfDay = array(
'sec' => 1348845514,
'usec' => 277885,
'minuteswest' => 0,
'dsttime' => 0,
);
// For usec = 277885
Uuid::$timeOfDayTest = $timeOfDay;
$uuidA = Uuid::uuid1(0x00007ffffffe, 0x1669);
$this->assertEquals('c4dbe7e2-097f-11e2-9669-00007ffffffe', (string) $uuidA);
$this->assertEquals('c4dbe7e2', $uuidA->getTimeLowHex());
$this->assertEquals('097f', $uuidA->getTimeMidHex());
$this->assertEquals('11e2', $uuidA->getTimeHiAndVersionHex());
// For usec = 0
Uuid::$timeOfDayTest['usec'] = 0;
$uuidB = Uuid::uuid1(0x00007ffffffe, 0x1669);
$this->assertEquals('c4b18100-097f-11e2-9669-00007ffffffe', (string) $uuidB);
$this->assertEquals('c4b18100', $uuidB->getTimeLowHex());
$this->assertEquals('097f', $uuidB->getTimeMidHex());
$this->assertEquals('11e2', $uuidB->getTimeHiAndVersionHex());
// For usec = 999999
Uuid::$timeOfDayTest['usec'] = 999999;
$uuidC = Uuid::uuid1(0x00007ffffffe, 0x1669);
$this->assertEquals('c54a1776-097f-11e2-9669-00007ffffffe', (string) $uuidC);
$this->assertEquals('c54a1776', $uuidC->getTimeLowHex());
$this->assertEquals('097f', $uuidC->getTimeMidHex());
$this->assertEquals('11e2', $uuidC->getTimeHiAndVersionHex());
}
/**
* @covers Rhumsaa\Uuid\Uuid::uuid1
* @covers Rhumsaa\Uuid\Uuid::calculateUuidTime
*/
public function testCalculateUuidTimeUpperLowerBounds64Bit()
{
$this->skip64BitTest();
// Mon, 31 Mar 5236 21:20:59 +0000
$timeOfDay = array(
'sec' => 103072857659,
'usec' => 999999,
'minuteswest' => 0,
'dsttime' => 0,
);
Uuid::$timeOfDayTest = $timeOfDay;
$uuidA = Uuid::uuid1(0x00007ffffffe, 0x1669);
$this->assertEquals('ff9785f6-ffff-1fff-9669-00007ffffffe', (string) $uuidA);
$this->assertEquals('ff9785f6', $uuidA->getTimeLowHex());
$this->assertEquals('ffff', $uuidA->getTimeMidHex());
$this->assertEquals('1fff', $uuidA->getTimeHiAndVersionHex());
// Sat, 15 Oct 1582 00:00:00 +0000
$timeOfDay = array(
'sec' => -12219292800,
'usec' => 0,
'minuteswest' => 0,
'dsttime' => 0,
);
Uuid::$timeOfDayTest = $timeOfDay;
$uuidB = Uuid::uuid1(0x00007ffffffe, 0x1669);
$this->assertEquals('00000000-0000-1000-9669-00007ffffffe', (string) $uuidB);
$this->assertEquals('00000000', $uuidB->getTimeLowHex());
$this->assertEquals('0000', $uuidB->getTimeMidHex());
$this->assertEquals('1000', $uuidB->getTimeHiAndVersionHex());
}
/**
* This test ensures that the UUIDs generated by the 32-bit path match
* those generated by the 64-bit path, given the same 64-bit time values.
*
* @covers Rhumsaa\Uuid\Uuid::uuid1
* @covers Rhumsaa\Uuid\Uuid::calculateUuidTime
*/
public function testCalculateUuidTimeUpperLowerBounds64BitThrough32BitPath()
{
$this->skip64BitTest();
Uuid::$force32Bit = true;
// Mon, 31 Mar 5236 21:20:59 +0000
$timeOfDay = array(
'sec' => 103072857659,
'usec' => 999999,
'minuteswest' => 0,
'dsttime' => 0,
);
Uuid::$timeOfDayTest = $timeOfDay;
$uuidA = Uuid::uuid1(0x00007ffffffe, 0x1669);
$this->assertEquals('ff9785f6-ffff-1fff-9669-00007ffffffe', (string) $uuidA);
$this->assertEquals('ff9785f6', $uuidA->getTimeLowHex());
$this->assertEquals('ffff', $uuidA->getTimeMidHex());
$this->assertEquals('1fff', $uuidA->getTimeHiAndVersionHex());
// Sat, 15 Oct 1582 00:00:00 +0000
$timeOfDay = array(
'sec' => -12219292800,
'usec' => 0,
'minuteswest' => 0,
'dsttime' => 0,
);
Uuid::$timeOfDayTest = $timeOfDay;
$uuidB = Uuid::uuid1(0x00007ffffffe, 0x1669);
$this->assertEquals('00000000-0000-1000-9669-00007ffffffe', (string) $uuidB);
$this->assertEquals('00000000', $uuidB->getTimeLowHex());
$this->assertEquals('0000', $uuidB->getTimeMidHex());
$this->assertEquals('1000', $uuidB->getTimeHiAndVersionHex());
}
/**
* @covers Rhumsaa\Uuid\Uuid::uuid1
* @covers Rhumsaa\Uuid\Uuid::calculateUuidTime
*/
public function testCalculateUuidTimeUpperLowerBounds32Bit()
{
Uuid::$force32Bit = true;
// Tue, 19 Jan 2038 03:14:07 +0000
$timeOfDay = array(
'sec' => 2147483647,
'usec' => 999999,
'minuteswest' => 0,
'dsttime' => 0,
);
Uuid::$timeOfDayTest = $timeOfDay;
$uuidA = Uuid::uuid1(0x00007ffffffe, 0x1669);
$this->assertEquals('13813ff6-6912-11fe-9669-00007ffffffe', (string) $uuidA);
$this->assertEquals('13813ff6', $uuidA->getTimeLowHex());
$this->assertEquals('6912', $uuidA->getTimeMidHex());
$this->assertEquals('11fe', $uuidA->getTimeHiAndVersionHex());
// Fri, 13 Dec 1901 20:45:53 +0000
$timeOfDay = array(
'sec' => -2147483647,
'usec' => 0,
'minuteswest' => 0,
'dsttime' => 0,
);
Uuid::$timeOfDayTest = $timeOfDay;
$uuidB = Uuid::uuid1(0x00007ffffffe, 0x1669);
$this->assertEquals('1419d680-d292-1165-9669-00007ffffffe', (string) $uuidB);
$this->assertEquals('1419d680', $uuidB->getTimeLowHex());
$this->assertEquals('d292', $uuidB->getTimeMidHex());
$this->assertEquals('1165', $uuidB->getTimeHiAndVersionHex());
}
/**
* This test ensures that the UUIDs generated by the 64-bit path match
* those generated by the 32-bit path, given the same 32-bit time values.
*
* @covers Rhumsaa\Uuid\Uuid::uuid1
* @covers Rhumsaa\Uuid\Uuid::calculateUuidTime
*/
public function testCalculateUuidTimeUpperLowerBounds32BitThrough64BitPath()
{
$this->skip64BitTest();
// Tue, 19 Jan 2038 03:14:07 +0000
$timeOfDay = array(
'sec' => 2147483647,
'usec' => 999999,
'minuteswest' => 0,
'dsttime' => 0,
);
Uuid::$timeOfDayTest = $timeOfDay;
$uuidA = Uuid::uuid1(0x00007ffffffe, 0x1669);
$this->assertEquals('13813ff6-6912-11fe-9669-00007ffffffe', (string) $uuidA);
$this->assertEquals('13813ff6', $uuidA->getTimeLowHex());
$this->assertEquals('6912', $uuidA->getTimeMidHex());
$this->assertEquals('11fe', $uuidA->getTimeHiAndVersionHex());
// Fri, 13 Dec 1901 20:45:53 +0000
$timeOfDay = array(
'sec' => -2147483647,
'usec' => 0,
'minuteswest' => 0,
'dsttime' => 0,
);
Uuid::$timeOfDayTest = $timeOfDay;
$uuidB = Uuid::uuid1(0x00007ffffffe, 0x1669);
$this->assertEquals('1419d680-d292-1165-9669-00007ffffffe', (string) $uuidB);
$this->assertEquals('1419d680', $uuidB->getTimeLowHex());
$this->assertEquals('d292', $uuidB->getTimeMidHex());
$this->assertEquals('1165', $uuidB->getTimeHiAndVersionHex());
}
/**
* Iterates over a 3600-second period and tests to ensure that, for each
* second in the period, the 32-bit and 64-bit versions of the UUID match
*/
public function test32BitMatch64BitForOneHourPeriod()
{
$this->skip64BitTest();
$currentTime = strtotime('Tue, 11 Dec 2012 00:00:00 +0000');
$endTime = $currentTime + 3600;
while ($currentTime <= $endTime) {
$timeOfDay = array(
'sec' => $currentTime,
'usec' => 999999,
'minuteswest' => 0,
'dsttime' => 0,
);
Uuid::$timeOfDayTest = $timeOfDay;
Uuid::$force32Bit = true;
$uuid32 = Uuid::uuid1(0x00007ffffffe, 0x1669);
Uuid::$force32Bit = false;
$uuid64 = Uuid::uuid1(0x00007ffffffe, 0x1669);
$this->assertTrue(
$uuid32->equals($uuid64),
'Breaks at ' . gmdate('r', $currentTime) . "; 32-bit: {$uuid32->toString()}, 64-bit: {$uuid64->toString()}"
);
$currentTime++;
}
}
/**
* @covers Rhumsaa\Uuid\Uuid::calculateUuidTime
* @expectedException Rhumsaa\Uuid\Exception\UnsatisfiedDependencyException
*/
public function testCalculateUuidTimeThrownException()
{
Uuid::$force32Bit = true;
Uuid::$forceNoBigNumber = true;
$uuid = Uuid::uuid1(0x00007ffffffe, 0x1669);
}
/**
* @covers Rhumsaa\Uuid\Uuid::hasBigNumber
*/
public function testHasBigNumber()
{
$hasBigNumber = new \ReflectionMethod(
'Rhumsaa\Uuid\Uuid', 'hasBigNumber'
);
$hasBigNumber->setAccessible(true);
$uuid = Uuid::fromString('ff6f8cb0-c57d-11e1-9b21-0800200c9a66');
$this->assertTrue($hasBigNumber->invoke($uuid));
Uuid::$forceNoBigNumber = true;
$this->assertFalse($hasBigNumber->invoke($uuid));
}
/**
* @covers Rhumsaa\Uuid\Uuid::is64BitSystem
*/
public function testIs64BitSystem()
{
$is64BitSystem = new \ReflectionMethod(
'Rhumsaa\Uuid\Uuid', 'is64BitSystem'
);
$is64BitSystem->setAccessible(true);
$uuid = Uuid::fromString('ff6f8cb0-c57d-11e1-9b21-0800200c9a66');
if (PHP_INT_SIZE == 8) {
$this->assertTrue($is64BitSystem->invoke($uuid));
} else {
$this->assertFalse($is64BitSystem->invoke($uuid));
}
Uuid::$force32Bit = true;
$this->assertFalse($is64BitSystem->invoke($uuid));
}
/**
* @covers Rhumsaa\Uuid\Uuid::isValid
*/
public function testIsValidGoodVersion1()
{
$valid = Uuid::isValid('ff6f8cb0-c57d-11e1-9b21-0800200c9a66');
$this->assertTrue($valid);
}
/**
* @covers Rhumsaa\Uuid\Uuid::isValid
*/
public function testIsValidGoodVersion2()
{
$valid = Uuid::isValid('ff6f8cb0-c57d-21e1-9b21-0800200c9a66');
$this->assertTrue($valid);
}
/**
* @covers Rhumsaa\Uuid\Uuid::isValid
*/
public function testIsValidGoodVersion3()
{
$valid = Uuid::isValid('ff6f8cb0-c57d-31e1-9b21-0800200c9a66');
$this->assertTrue($valid);
}
/**
* @covers Rhumsaa\Uuid\Uuid::isValid
*/
public function testIsValidGoodVersion4()
{
$valid = Uuid::isValid('ff6f8cb0-c57d-41e1-9b21-0800200c9a66');
$this->assertTrue($valid);
}
/**
* @covers Rhumsaa\Uuid\Uuid::isValid
*/
public function testIsValidGoodVersion5()
{
$valid = Uuid::isValid('ff6f8cb0-c57d-51e1-9b21-0800200c9a66');
$this->assertTrue($valid);
}
/**
* @covers Rhumsaa\Uuid\Uuid::isValid
*/
public function testIsValidBadVersion6()
{
$valid = Uuid::isValid('ff6f8cb0-c57d-61e1-9b21-0800200c9a66');
$this->assertFalse($valid);
}
/**
* @covers Rhumsaa\Uuid\Uuid::isValid
*/
public function testIsValidGoodUpperCase()
{
$valid = Uuid::isValid('FF6F8CB0-C57D-11E1-9B21-0800200C9A66');
$this->assertTrue($valid);
}
/**
* @covers Rhumsaa\Uuid\Uuid::isValid
*/
public function testIsValidBadHex()
{
$valid = Uuid::isValid('zf6f8cb0-c57d-11e1-9b21-0800200c9a66');
$this->assertFalse($valid);
}
/**
* @covers Rhumsaa\Uuid\Uuid::isValid
*/
public function testIsValidTooShort1()
{
$valid = Uuid::isValid('3f6f8cb0-c57d-11e1-9b21-0800200c9a6');
$this->assertFalse($valid);
}
/**
* @covers Rhumsaa\Uuid\Uuid::isValid
*/
public function testIsValidTooShort2()
{
$valid = Uuid::isValid('af6f8cb-c57d-11e1-9b21-0800200c9a66');
$this->assertFalse($valid);
}
/**
* @covers Rhumsaa\Uuid\Uuid::isValid
*/
public function testIsValidNoDashes()
{
$valid = Uuid::isValid('af6f8cb0c57d11e19b210800200c9a66');
$this->assertFalse($valid);
}
/**
* @covers Rhumsaa\Uuid\Uuid::isValid
*/
public function testIsValidTooLong()
{
$valid = Uuid::isValid('ff6f8cb0-c57da-51e1-9b21-0800200c9a66');
$this->assertFalse($valid);
}
/**
* @covers Rhumsaa\Uuid\Uuid::isValid
*/
public function testUsingNilAsValidUuid()
{
$this->assertInstanceOf('Rhumsaa\Uuid\Uuid', Uuid::uuid3(Uuid::NIL, 'randomtext'));
$this->assertInstanceOf('Rhumsaa\Uuid\Uuid', Uuid::uuid5(Uuid::NIL, 'randomtext'));
}
/**
* @covers Rhumsaa\Uuid\Uuid::fromBytes
*/
public function testFromBytes()
{
$uuid = Uuid::fromString('ff6f8cb0-c57d-11e1-9b21-0800200c9a66');
$bytes = $uuid->getBytes();
$fromBytesUuid = Uuid::fromBytes($bytes);
$this->assertTrue($uuid->equals($fromBytesUuid));
}
/**
* @covers Rhumsaa\Uuid\Uuid::fromBytes
* @expectedException InvalidArgumentException
*/
public function testFromBytesArgumentTooShort()
{
Uuid::fromBytes('thisisveryshort');
}
/**
* @covers Rhumsaa\Uuid\Uuid::fromBytes
* @expectedException InvalidArgumentException
*/
public function testFromBytesArgumentTooLong()
{
Uuid::fromBytes('thisisabittoolong');
}
}
Reference in New Issue View Git Blame Copy Permalink