You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
389 lines
16 KiB
389 lines
16 KiB
/* |
|
Copyright (c) 2004-2006, The Dojo Foundation |
|
All Rights Reserved. |
|
|
|
Licensed under the Academic Free License version 2.1 or above OR the |
|
modified BSD license. For more information on Dojo licensing, see: |
|
|
|
http://dojotoolkit.org/community/licensing.shtml |
|
*/ |
|
|
|
dojo.require("dojo.uuid.*"); |
|
dojo.require("dojo.lang"); |
|
|
|
function OFF_test_uuid_performance() { |
|
var start = new Date(); |
|
var startMS = start.valueOf(); |
|
var nowMS = startMS; |
|
var i; |
|
var now; |
|
var numTrials = 100000; |
|
|
|
while (nowMS == startMS) { |
|
now = new Date(); |
|
nowMS = now.valueOf(); |
|
} |
|
|
|
startMS = nowMS; |
|
for (i = 0; i < numTrials; ++i) { |
|
var a = dojo.uuid.LightweightGenerator.generate(); |
|
} |
|
now = new Date(); |
|
nowMS = now.valueOf(); |
|
var elapsedMS = nowMS - startMS; |
|
// dojo.log.debug("created " + numTrials + " UUIDs in " + elapsedMS + " milliseconds"); |
|
} |
|
|
|
function test_uuid_capitalization() { |
|
var randomLowercaseString = "3b12f1df-5232-4804-897e-917bf397618a"; |
|
var randomUppercaseString = "3B12F1DF-5232-4804-897E-917BF397618A"; |
|
|
|
var timebasedLowercaseString = "b4308fb0-86cd-11da-a72b-0800200c9a66"; |
|
var timebasedUppercaseString = "B4308FB0-86CD-11DA-A72B-0800200C9A66"; |
|
|
|
var uuidRL = new dojo.uuid.Uuid(randomLowercaseString); |
|
var uuidRU = new dojo.uuid.Uuid(randomUppercaseString); |
|
|
|
var uuidTL = new dojo.uuid.Uuid(timebasedLowercaseString); |
|
var uuidTU = new dojo.uuid.Uuid(timebasedUppercaseString); |
|
|
|
jum.assertTrue("(uuidRL.isEqual(uuidRU))", uuidRL.isEqual(uuidRU)); |
|
jum.assertTrue("(uuidRU.isEqual(uuidRL))", uuidRU.isEqual(uuidRL)); |
|
|
|
jum.assertTrue("(uuidTL.isEqual(uuidTU))", uuidTL.isEqual(uuidTU)); |
|
jum.assertTrue("(uuidTU.isEqual(uuidTL))", uuidTU.isEqual(uuidTL)); |
|
} |
|
|
|
function test_uuid_constructor() { |
|
var uuid, uuidToo; |
|
|
|
var nilUuid = '00000000-0000-0000-0000-000000000000'; |
|
uuid = new dojo.uuid.Uuid(); |
|
jum.assertTrue("'new dojo.uuid.Uuid()' returns the Nil UUID", (uuid == nilUuid)); |
|
|
|
var randomUuidString = "3b12f1df-5232-4804-897e-917bf397618a"; |
|
uuid = new dojo.uuid.Uuid(randomUuidString); |
|
jum.assertTrue('"uuid.isValid()" returns true', uuid.isValid()); |
|
jum.assertTrue('"uuid.getVariant()" returns DCE', (uuid.getVariant() == dojo.uuid.Uuid.Variant.DCE)); |
|
jum.assertTrue('"uuid.getVersion()" returns RANDOM', (uuid.getVersion() == dojo.uuid.Uuid.Version.RANDOM)); |
|
uuidToo = new dojo.uuid.Uuid(new String(randomUuidString)); |
|
jum.assertTrue('"uuid.isEqual(uuidToo)" returns true', uuid.isEqual(uuidToo)); |
|
|
|
var timeBasedUuidString = "b4308fb0-86cd-11da-a72b-0800200c9a66"; |
|
uuid = new dojo.uuid.Uuid(timeBasedUuidString); |
|
jum.assertTrue('"uuid.isValid()" returns true', uuid.isValid()); |
|
jum.assertTrue('"uuid.getVariant()" returns DCE', (uuid.getVariant() == dojo.uuid.Uuid.Variant.DCE)); |
|
jum.assertTrue('"uuid.getVersion()" returns TIME_BASED', (uuid.getVersion() == dojo.uuid.Uuid.Version.TIME_BASED)); |
|
jum.assertTrue('"uuid.getNode()" returns "0800200c9a66"', (uuid.getNode() == "0800200c9a66")); |
|
var timestamp = uuid.getTimestamp(); |
|
var date = uuid.getTimestamp(Date); |
|
var dateString = uuid.getTimestamp(String); |
|
var hexString = uuid.getTimestamp("hex"); |
|
var now = new Date(); |
|
jum.assertTrue('uuid.getTimestamp() == uuid.getTimestamp(Date)', (timestamp == date)); |
|
jum.assertTrue('uuid.getTimestamp("hex") == "1da86cdb4308fb0"', (hexString == "1da86cdb4308fb0")); |
|
jum.assertTrue('uuid.getTimestamp() < new Date()', (timestamp < now)); |
|
} |
|
|
|
function test_uuid_generators() { |
|
var generators = []; |
|
generators.push(dojo.uuid.NilGenerator); |
|
generators.push(dojo.uuid.LightweightGenerator); |
|
generators.push(dojo.uuid.TimeBasedGenerator); |
|
|
|
for (var i in generators) { |
|
var generator = generators[i]; |
|
|
|
var uuid, uuidString; |
|
uuidString = generator.generate(); |
|
jum.assertTrue("generate() returns a string", ((typeof uuidString) == 'string')); |
|
checkValidityOfUuidString(uuidString); |
|
|
|
uuidString = generator.generate(String); |
|
jum.assertTrue("generate(String) returns a string", ((typeof uuidString) == 'string')); |
|
checkValidityOfUuidString(uuidString); |
|
|
|
uuid = generator.generate(dojo.uuid.Uuid); |
|
jum.assertTrue("generate(dojo.uuid.Uuid) returns a dojo.uuid.Uuid", (uuid instanceof dojo.uuid.Uuid)); |
|
if (generator != dojo.uuid.NilGenerator) { |
|
jum.assertTrue('"uuid.getVariant()" returns DCE', (uuid.getVariant() == dojo.uuid.Uuid.Variant.DCE)); |
|
} |
|
jum.assertTrue("uuid.isEqual(uuid)", uuid.isEqual(uuid)); |
|
jum.assertTrue("uuid.compare(uuid) == 0", (uuid.compare(uuid) == 0)); |
|
jum.assertTrue("dojo.uuid.Uuid.compare(uuid, uuid) == 0", (dojo.uuid.Uuid.compare(uuid, uuid) == 0)); |
|
checkValidityOfUuidString(uuid.toString()); |
|
jum.assertTrue("uuid.toString() works", uuid.toString().length == 36); |
|
jum.assertTrue("uuid.toString('{}') works", uuid.toString('{}').length == 38); |
|
jum.assertTrue("uuid.toString('()') works", uuid.toString('()').length == 38); |
|
jum.assertTrue("uuid.toString('\"\"') works", uuid.toString('""').length == 38); |
|
jum.assertTrue("uuid.toString(\"''\") works", uuid.toString("''").length == 38); |
|
jum.assertTrue("uuid.toString('!-') works", uuid.toString('!-').length == 32); |
|
jum.assertTrue("uuid.toString('urn') works", uuid.toString('urn').length == 45); |
|
|
|
if (generator != dojo.uuid.NilGenerator) { |
|
var uuidStringOne = generator.generate(); |
|
var uuidStringTwo = generator.generate(); |
|
jum.assertTrue("uuidStringOne != uuidStringTwo", uuidStringOne != uuidStringTwo); |
|
|
|
dojo.uuid.Uuid.setGenerator(generator); |
|
var uuidOne = new dojo.uuid.Uuid(); |
|
var uuidTwo = new dojo.uuid.Uuid(); |
|
jum.assertTrue("generator === dojo.uuid.Uuid.getGenerator()", generator === dojo.uuid.Uuid.getGenerator()); |
|
dojo.uuid.Uuid.setGenerator(null); |
|
jum.assertTrue("uuidOne != uuidTwo", uuidOne != uuidTwo); |
|
jum.assertTrue("!uuidOne.isEqual(uuidTwo)", !uuidOne.isEqual(uuidTwo)); |
|
jum.assertTrue("!uuidTwo.isEqual(uuidOne)", !uuidTwo.isEqual(uuidOne)); |
|
|
|
var oneVsTwo = dojo.uuid.Uuid.compare(uuidOne, uuidTwo); // either 1 or -1 |
|
var twoVsOne = dojo.uuid.Uuid.compare(uuidTwo, uuidOne); // either -1 or 1 |
|
jum.assertTrue("oneVsTwo + twoVsOne == 0", (oneVsTwo + twoVsOne == 0)); |
|
jum.assertTrue("oneVsTwo != 0", (oneVsTwo != 0)); |
|
jum.assertTrue("twoVsOne != 0", (twoVsOne != 0)); |
|
|
|
jum.assertTrue("!uuidTwo.isEqual(uuidOne)", !uuidTwo.isEqual(uuidOne)); |
|
} |
|
|
|
if (generator == dojo.uuid.LightweightGenerator) { |
|
jum.assertTrue('"uuid.getVersion()" returns RANDOM', (uuid.getVersion() == dojo.uuid.Uuid.Version.RANDOM)); |
|
} |
|
|
|
if (generator == dojo.uuid.TimeBasedGenerator) { |
|
checkValidityOfTimeBasedUuidString(uuid.toString()); |
|
jum.assertTrue('"uuid.getVersion()" returns TIME_BASED', (uuid.getVersion() == dojo.uuid.Uuid.Version.TIME_BASED)); |
|
jum.assertTrue('"uuid.getNode()" returns a string', dojo.lang.isString(uuid.getNode())); |
|
jum.assertTrue('"uuid.getNode()" returns a 12-character string', (uuid.getNode().length == 12)); |
|
var timestamp = uuid.getTimestamp(); |
|
var date = uuid.getTimestamp(Date); |
|
var dateString = uuid.getTimestamp(String); |
|
var hexString = uuid.getTimestamp("hex"); |
|
jum.assertTrue('date instanceof Date', (date instanceof Date)); |
|
jum.assertTrue('uuid.getTimestamp() == uuid.getTimestamp(Date)', (timestamp == date)); |
|
jum.assertTrue('uuid.getTimestamp("hex").length == 15', (hexString.length == 15)); |
|
} |
|
} |
|
} |
|
|
|
function test_uuid_nilGenerator() { |
|
var nilUuidString = '00000000-0000-0000-0000-000000000000'; |
|
var uuidString = dojo.uuid.NilGenerator.generate(); |
|
jum.assertTrue("nilUuidString == '00000000-0000-0000-0000-000000000000'", (uuidString == nilUuidString)); |
|
} |
|
|
|
function test_uuid_timeBasedGenerator() { |
|
var uuid; // an instance of dojo.uuid.Uuid |
|
var string; // a simple string literal |
|
var generate = dojo.uuid.TimeBasedGenerator.generate; |
|
|
|
var string01 = generate(); |
|
var string02 = generate(String); |
|
var uuid1 = generate(dojo.uuid.Uuid); |
|
var string03 = generate("017bf397618a"); |
|
var string04 = generate(new String("017BF397618A")); |
|
var string05 = generate({node: "017bf397618a"}); // hardwareNode |
|
var string06 = generate({node: "f17bf397618a"}); // pseudoNode |
|
var string07 = generate({hardwareNode: "017bf397618a"}); |
|
var string08 = generate({pseudoNode: "f17bf397618a"}); |
|
var string09 = generate({node: "017bf397618a", returnType: String}); |
|
var uuid2 = generate({node: "017bf397618a", returnType: dojo.uuid.Uuid}); |
|
dojo.uuid.TimeBasedGenerator.setNode("017bf397618a"); |
|
var string10 = generate(); // the generated UUID has node == "017bf397618a" |
|
var uuid3 = generate(dojo.uuid.Uuid); // the generated UUID has node == "017bf397618a" |
|
var returnedNode = dojo.uuid.TimeBasedGenerator.getNode(); |
|
jum.assertTrue('returnedNode == "017bf397618a"', (returnedNode == "017bf397618a")); |
|
|
|
function getNode(string) { |
|
var arrayOfStrings = string.split('-'); |
|
return arrayOfStrings[4]; |
|
} |
|
|
|
checkForPseudoNodeBitInTimeBasedUuidString(string01); |
|
checkForPseudoNodeBitInTimeBasedUuidString(string02); |
|
checkForPseudoNodeBitInTimeBasedUuidString(uuid1.toString()); |
|
jum.assertTrue('getNode(string03) == "017bf397618a"', (getNode(string03) == "017bf397618a")); |
|
jum.assertTrue('getNode(string04) == "017bf397618a"', (getNode(string04) == "017bf397618a")); |
|
jum.assertTrue('getNode(string05) == "017bf397618a"', (getNode(string05) == "017bf397618a")); |
|
jum.assertTrue('getNode(string06) == "f17bf397618a"', (getNode(string06) == "f17bf397618a")); |
|
jum.assertTrue('getNode(string07) == "017bf397618a"', (getNode(string07) == "017bf397618a")); |
|
jum.assertTrue('getNode(string08) == "f17bf397618a"', (getNode(string08) == "f17bf397618a")); |
|
jum.assertTrue('getNode(string09) == "017bf397618a"', (getNode(string09) == "017bf397618a")); |
|
jum.assertTrue('getNode(string10) == "017bf397618a" ~~~~ ' + getNode(string10), (getNode(string10) == "017bf397618a")); |
|
|
|
jum.assertTrue('uuid2.getNode() == "017bf397618a"', (uuid2.getNode() == "017bf397618a")); |
|
jum.assertTrue('uuid3.getNode() == "017bf397618a"', (uuid3.getNode() == "017bf397618a")); |
|
|
|
checkValidityOfTimeBasedUuidString(string01); |
|
checkValidityOfTimeBasedUuidString(string02); |
|
checkValidityOfTimeBasedUuidString(string03); |
|
checkValidityOfTimeBasedUuidString(string04); |
|
checkValidityOfTimeBasedUuidString(string05); |
|
checkValidityOfTimeBasedUuidString(string06); |
|
checkValidityOfTimeBasedUuidString(string07); |
|
checkValidityOfTimeBasedUuidString(string08); |
|
checkValidityOfTimeBasedUuidString(string09); |
|
checkValidityOfTimeBasedUuidString(string10); |
|
checkValidityOfTimeBasedUuidString(uuid1.toString()); |
|
checkValidityOfTimeBasedUuidString(uuid2.toString()); |
|
checkValidityOfTimeBasedUuidString(uuid3.toString()); |
|
} |
|
|
|
function test_uuid_invalidUuids() { |
|
var uuidStrings = []; |
|
uuidStrings.push("Hello world!"); // not a UUID |
|
uuidStrings.push("3B12F1DF-5232-1804-897E-917BF39761"); // too short |
|
uuidStrings.push("3B12F1DF-5232-1804-897E-917BF39761-8A"); // extra '-' |
|
uuidStrings.push("3B12F1DF-5232-1804-897E917BF39761-8A"); // last '-' in wrong place |
|
uuidStrings.push("HB12F1DF-5232-1804-897E-917BF397618A"); // "HB12F1DF" is not a hex string |
|
|
|
var numberOfFailures = 0; |
|
for (var i in uuidStrings) { |
|
var uuidString = uuidStrings[i]; |
|
try { |
|
new dojo.uuid.Uuid(uuidString); |
|
} catch (e) { |
|
++numberOfFailures; |
|
} |
|
} |
|
jum.assertTrue('All of the "new dojo.uuid.Uuid()" calls failed', (numberOfFailures == uuidStrings.length)); |
|
} |
|
|
|
// ------------------------------------------------------------------- |
|
// Helper functions |
|
// ------------------------------------------------------------------- |
|
|
|
function checkValidityOfUuidString(uuidString) { |
|
var NIL_UUID = "00000000-0000-0000-0000-000000000000"; |
|
if (uuidString == NIL_UUID) { |
|
// We'll consider the Nil UUID to be valid, so now |
|
// we can just return, with not further checks. |
|
return; |
|
} |
|
|
|
jum.assertTrue('UUIDs have 36 characters', (uuidString.length == 36)); |
|
|
|
var validCharacters = "0123456789abcedfABCDEF-"; |
|
var character; |
|
var position; |
|
for (var i = 0; i < 36; ++i) { |
|
character = uuidString.charAt(i); |
|
position = validCharacters.indexOf(character); |
|
jum.assertTrue('UUIDs have only valid characters', (position != -1)); |
|
} |
|
|
|
var arrayOfParts = uuidString.split("-"); |
|
jum.assertTrue('UUIDs have 5 sections separated by 4 hyphens', (arrayOfParts.length == 5)); |
|
jum.assertTrue('Section 0 has 8 characters', (arrayOfParts[0].length == 8)); |
|
jum.assertTrue('Section 1 has 4 characters', (arrayOfParts[1].length == 4)); |
|
jum.assertTrue('Section 2 has 4 characters', (arrayOfParts[2].length == 4)); |
|
jum.assertTrue('Section 3 has 4 characters', (arrayOfParts[3].length == 4)); |
|
jum.assertTrue('Section 4 has 8 characters', (arrayOfParts[4].length == 12)); |
|
|
|
// check to see that the "UUID variant code" starts with the binary bits '10' |
|
var section3 = arrayOfParts[3]; |
|
var hex3 = parseInt(section3, dojo.uuid.Uuid.HEX_RADIX); |
|
var binaryString = hex3.toString(2); |
|
// alert("section3 = " + section3 + "\n binaryString = " + binaryString); |
|
jum.assertTrue('section 3 has 16 bits', binaryString.length == 16); |
|
jum.assertTrue("first bit of section 3 is 1", binaryString.charAt(0) == '1'); |
|
jum.assertTrue("second bit of section 3 is 0", binaryString.charAt(1) == '0'); |
|
} |
|
|
|
function checkValidityOfTimeBasedUuidString(uuidString) { |
|
checkValidityOfUuidString(uuidString); |
|
var arrayOfParts = uuidString.split("-"); |
|
var section2 = arrayOfParts[2]; |
|
jum.assertTrue('Section 2 starts with a 1', (section2.charAt(0) == "1")); |
|
} |
|
|
|
function checkForPseudoNodeBitInTimeBasedUuidString(uuidString) { |
|
var arrayOfParts = uuidString.split("-"); |
|
var section4 = arrayOfParts[4]; |
|
var firstChar = section4.charAt(0); |
|
var hexFirstChar = parseInt(firstChar, dojo.uuid.Uuid.HEX_RADIX); |
|
var binaryString = hexFirstChar.toString(2); |
|
var firstBit; |
|
if (binaryString.length == 4) { |
|
firstBit = binaryString.charAt(0); |
|
} else { |
|
firstBit = '0'; |
|
} |
|
jum.assertTrue("first bit of section 4 is 1", firstBit == '1'); |
|
} |
|
|
|
/* |
|
function test_uuid_get64bitArrayFromFloat() { |
|
var x = Math.pow(2, 63) + Math.pow(2, 15); |
|
var result = dojo.uuid.TimeBasedUuid._get64bitArrayFromFloat(x); |
|
jum.assertTrue("result[0] == 0x8000", result[0] === 0x8000); |
|
jum.assertTrue("result[1] == 0x0000", result[1] === 0x0000); |
|
jum.assertTrue("result[2] == 0x0000", result[2] === 0x0000); |
|
jum.assertTrue("result[3] == 0x8000", result[3] === 0x8000); |
|
|
|
var date = new Date(); |
|
x = date.valueOf(); |
|
result = dojo.uuid.TimeBasedUuid._get64bitArrayFromFloat(x); |
|
var reconstructedFloat = result[0]; |
|
reconstructedFloat *= 0x10000; |
|
reconstructedFloat += result[1]; |
|
reconstructedFloat *= 0x10000; |
|
reconstructedFloat += result[2]; |
|
reconstructedFloat *= 0x10000; |
|
reconstructedFloat += result[3]; |
|
|
|
jum.assertTrue("reconstructedFloat === x", reconstructedFloat === x); |
|
// dojo.log.debug("leaving test_uuid_get64bitArrayFromFloat()"); |
|
} |
|
|
|
function test_uuid_addTwo64bitArrays() { |
|
var a = [0x0000, 0x0000, 0x0000, 0x0001]; |
|
var b = [0x0FFF, 0xFFFF, 0xFFFF, 0xFFFF]; |
|
var result = dojo.uuid.TimeBasedUuid._addTwo64bitArrays(a, b); |
|
jum.assertTrue("20", result[0] === 0x1000); |
|
jum.assertTrue("21", result[1] === 0x0000); |
|
jum.assertTrue("22", result[2] === 0x0000); |
|
jum.assertTrue("23", result[3] === 0x0000); |
|
|
|
a = [0x4000, 0x8000, 0x8000, 0x8000]; |
|
b = [0x8000, 0x8000, 0x8000, 0x8000]; |
|
result = dojo.uuid.TimeBasedUuid._addTwo64bitArrays(a, b); |
|
jum.assertTrue("24", result[0] === 0xC001); |
|
jum.assertTrue("25", result[1] === 0x0001); |
|
jum.assertTrue("26", result[2] === 0x0001); |
|
jum.assertTrue("27", result[3] === 0x0000); |
|
|
|
a = [7, 6, 2, 5]; |
|
b = [1, 0, 3, 4]; |
|
result = dojo.uuid.TimeBasedUuid._addTwo64bitArrays(a, b); |
|
jum.assertTrue("28", result[0] === 8); |
|
jum.assertTrue("29", result[1] === 6); |
|
jum.assertTrue("30", result[2] === 5); |
|
jum.assertTrue("31", result[3] === 9); |
|
// dojo.log.debug("leaving test_uuid_addTwo64bitArrays()"); |
|
} |
|
|
|
function test_uuid_multiplyTwo64bitArrays() { |
|
var a = [ 0, 0x0000, 0x0000, 0x0003]; |
|
var b = [0x1111, 0x1234, 0x0000, 0xFFFF]; |
|
var result = dojo.uuid.TimeBasedUuid._multiplyTwo64bitArrays(a, b); |
|
jum.assertTrue("40", result[0] === 0x3333); |
|
jum.assertTrue("41", result[1] === 0x369C); |
|
jum.assertTrue("42", result[2] === 0x0002); |
|
jum.assertTrue("43", result[3] === 0xFFFD); |
|
|
|
a = [0, 0, 0, 5]; |
|
b = [0, 0, 0, 4]; |
|
result = dojo.uuid.TimeBasedUuid._multiplyTwo64bitArrays(a, b); |
|
jum.assertTrue("44", result[0] === 0); |
|
jum.assertTrue("45", result[1] === 0); |
|
jum.assertTrue("46", result[2] === 0); |
|
jum.assertTrue("47", result[3] === 20); |
|
|
|
a = [0, 0, 2, 5]; |
|
b = [0, 0, 3, 4]; |
|
result = dojo.uuid.TimeBasedUuid._multiplyTwo64bitArrays(a, b); |
|
jum.assertTrue("48", result[0] === 0); |
|
jum.assertTrue("49", result[1] === 6); |
|
jum.assertTrue("50", result[2] === 23); |
|
jum.assertTrue("51", result[3] === 20); |
|
// dojo.log.debug("leaving test_uuid_multiplyTwo64bitArrays()"); |
|
} |
|
*/
|
|
|