Context Navigation

source: Dev/branches/rest-dojo-ui/client/dojox/uuid/tests/uuid.js @ 256

Last change on this file since 256 was 256, checked in by hendrikvanantwerpen, 13 years ago
Reworked project structure based on REST interaction and Dojo library. As soon as this is stable, the old jQueryUI branch can be removed (it's kept for reference).
File size: 12.9 KB

Line
1	define(['doh', 'dojo/_base/lang', '../_base', '../Uuid', '../generateRandomUuid', '../generateTimeBasedUuid'], function(doh, dojo, dxuuid, Uuid, generateRandomUuid, generateTimeBasedUuid){
2
3	var checkValidityOfUuidString = function(/String/uuidString){
4	// summary:
5	// A helper function that's used by the registered test functions
6	var NIL_UUID = "00000000-0000-0000-0000-000000000000";
7	if (uuidString == NIL_UUID) {
8	// We'll consider the Nil UUID to be valid, so now
9	// we can just return, with not further checks.
10	return;
11	}
12
13	doh.assertTrue(uuidString.length == 36); // UUIDs have 36 characters
14
15	var validCharacters = "0123456789abcedfABCDEF-";
16	var character;
17	var position;
18	for(var i = 0; i < 36; ++i){
19	character = uuidString.charAt(i);
20	position = validCharacters.indexOf(character);
21	doh.assertTrue(position != -1); // UUIDs have only valid characters
22	}
23
24	var arrayOfParts = uuidString.split("-");
25	doh.assertTrue(arrayOfParts.length == 5); // UUIDs have 5 sections separated by 4 hyphens
26	doh.assertTrue(arrayOfParts[0].length == 8); // Section 0 has 8 characters
27	doh.assertTrue(arrayOfParts[1].length == 4); // Section 1 has 4 characters
28	doh.assertTrue(arrayOfParts[2].length == 4); // Section 2 has 4 characters
29	doh.assertTrue(arrayOfParts[3].length == 4); // Section 3 has 4 characters
30	doh.assertTrue(arrayOfParts[4].length == 12); // Section 4 has 8 characters
31
32	// check to see that the "UUID variant code" starts with the binary bits '10'
33	var section3 = arrayOfParts[3];
34	var HEX_RADIX = 16;
35	var hex3 = parseInt(section3, HEX_RADIX);
36	var binaryString = hex3.toString(2);
37	// alert("section3 = " + section3 + "\n binaryString = " + binaryString);
38	doh.assertTrue(binaryString.length == 16); // section 3 has 16 bits
39	doh.assertTrue(binaryString.charAt(0) == '1'); // first bit of section 3 is 1
40	doh.assertTrue(binaryString.charAt(1) == '0'); // second bit of section 3 is 0
41	}
42
43	var checkValidityOfTimeBasedUuidString = function(/String/uuidString){
44	// summary:
45	// A helper function that's used by the registered test functions
46	checkValidityOfUuidString(uuidString);
47	var arrayOfParts = uuidString.split("-");
48	var section2 = arrayOfParts[2];
49	doh.assertTrue(section2.charAt(0) == "1"); // Section 2 starts with a 1
50	}
51
52	var checkForPseudoNodeBitInTimeBasedUuidString = function(/String/uuidString){
53	// summary:
54	// A helper function that's used by the registered test functions
55	var arrayOfParts = uuidString.split("-");
56	var section4 = arrayOfParts[4];
57	var firstChar = section4.charAt(0);
58	var HEX_RADIX = 16;
59	var hexFirstChar = parseInt(firstChar, HEX_RADIX);
60	var binaryString = hexFirstChar.toString(2);
61	var firstBit;
62	if(binaryString.length == 4){
63	firstBit = binaryString.charAt(0);
64	}else{
65	firstBit = '0';
66	}
67	doh.assertTrue(firstBit == '1'); // first bit of section 4 is 1
68	}
69
70	doh.register("dojox.uuid.tests.uuid",
71	[
72	/*
73	function test_uuid_performance(){
74	var start = new Date();
75	var startMS = start.valueOf();
76	var nowMS = startMS;
77	var i;
78	var now;
79	var numTrials = 100000;
80
81	while(nowMS == startMS){
82	now = new Date();
83	nowMS = now.valueOf();
84	}
85
86	startMS = nowMS;
87	for(i = 0; i < numTrials; ++i){
88	var a = dojox.uuid.LightweightGenerator.generate();
89	}
90	now = new Date();
91	nowMS = now.valueOf();
92	var elapsedMS = nowMS - startMS;
93	// dojo.log.debug("created " + numTrials + " UUIDs in " + elapsedMS + " milliseconds");
94	},
95	*/
96
97	function test_uuid_capitalization(){
98	var randomLowercaseString = "3b12f1df-5232-4804-897e-917bf397618a";
99	var randomUppercaseString = "3B12F1DF-5232-4804-897E-917BF397618A";
100
101	var timebasedLowercaseString = "b4308fb0-86cd-11da-a72b-0800200c9a66";
102	var timebasedUppercaseString = "B4308FB0-86CD-11DA-A72B-0800200C9A66";
103
104	var uuidRL = new Uuid(randomLowercaseString);
105	var uuidRU = new Uuid(randomUppercaseString);
106
107	var uuidTL = new Uuid(timebasedLowercaseString);
108	var uuidTU = new Uuid(timebasedUppercaseString);
109
110	doh.assertTrue(uuidRL.isEqual(uuidRU));
111	doh.assertTrue(uuidRU.isEqual(uuidRL));
112
113	doh.assertTrue(uuidTL.isEqual(uuidTU));
114	doh.assertTrue(uuidTU.isEqual(uuidTL));
115	},
116
117	function test_uuid_constructor(){
118	var uuid, uuidToo;
119
120	var nilUuid = '00000000-0000-0000-0000-000000000000';
121	uuid = new Uuid();
122	doh.assertTrue(uuid == nilUuid); // 'new dojox.uuid.Uuid()' returns the Nil UUID
123
124	var randomUuidString = "3b12f1df-5232-4804-897e-917bf397618a";
125	uuid = new Uuid(randomUuidString);
126	doh.assertTrue(uuid.isValid());
127	doh.assertTrue(uuid.getVariant() == dxuuid.variant.DCE);
128	doh.assertTrue(uuid.getVersion() == dxuuid.version.RANDOM);
129	uuidToo = new Uuid(new String(randomUuidString));
130	doh.assertTrue(uuid.isEqual(uuidToo));
131
132	var timeBasedUuidString = "b4308fb0-86cd-11da-a72b-0800200c9a66";
133	uuid = new Uuid(timeBasedUuidString);
134	doh.assertTrue(uuid.isValid());
135	doh.assertTrue(uuid.getVariant() == dxuuid.variant.DCE);
136	doh.assertTrue(uuid.getVersion() == dxuuid.version.TIME_BASED);
137	doh.assertTrue(uuid.getNode() == "0800200c9a66");
138	var timestamp = uuid.getTimestamp();
139	var date = uuid.getTimestamp(Date);
140	var dateString = uuid.getTimestamp(String);
141	var hexString = uuid.getTimestamp("hex");
142	var now = new Date();
143	doh.assertTrue(timestamp.valueOf() == date.valueOf());
144	doh.assertTrue(hexString == "1da86cdb4308fb0");
145	doh.assertTrue(timestamp < now);
146	},
147
148	function test_uuid_generators(){
149	var generators = [
150	dxuuid.generateNilUuid,
151	generateRandomUuid,
152	generateTimeBasedUuid
153	];
154
155	for(var i in generators){
156	var generator = generators[i];
157	var uuidString = generator();
158
159	doh.assertTrue((typeof uuidString) == 'string');
160	checkValidityOfUuidString(uuidString);
161
162	var uuid = new Uuid(uuidString);
163	if(generator != dxuuid.generateNilUuid){
164	doh.assertTrue(uuid.getVariant() == dxuuid.variant.DCE);
165	}
166
167	doh.assertTrue(uuid.isEqual(uuid));
168	doh.assertTrue(uuid.compare(uuid) == 0);
169	doh.assertTrue(Uuid.compare(uuid, uuid) == 0);
170	checkValidityOfUuidString(uuid.toString());
171	doh.assertTrue(uuid.toString().length == 36);
172
173	if(generator != dxuuid.generateNilUuid){
174	var uuidStringOne = generator();
175	var uuidStringTwo = generator();
176	doh.assertTrue(uuidStringOne != uuidStringTwo);
177
178	Uuid.setGenerator(generator);
179	var uuidOne = new Uuid();
180	var uuidTwo = new Uuid();
181	doh.assertTrue(generator === Uuid.getGenerator());
182	Uuid.setGenerator(null);
183	doh.assertTrue(uuidOne != uuidTwo);
184	doh.assertTrue(!uuidOne.isEqual(uuidTwo));
185	doh.assertTrue(!uuidTwo.isEqual(uuidOne));
186
187	var oneVsTwo = Uuid.compare(uuidOne, uuidTwo); // either 1 or -1
188	var twoVsOne = Uuid.compare(uuidTwo, uuidOne); // either -1 or 1
189	doh.assertTrue(oneVsTwo + twoVsOne == 0);
190	doh.assertTrue(oneVsTwo != 0);
191	doh.assertTrue(twoVsOne != 0);
192
193	doh.assertTrue(!uuidTwo.isEqual(uuidOne));
194	}
195
196	if(generator == generateRandomUuid){
197	doh.assertTrue(uuid.getVersion() == dxuuid.version.RANDOM);
198	}
199
200	if(generator == generateTimeBasedUuid){
201	checkValidityOfTimeBasedUuidString(uuid.toString());
202	doh.assertTrue(uuid.getVersion() == dxuuid.version.TIME_BASED);
203	doh.assertTrue(dojo.isString(uuid.getNode()));
204	doh.assertTrue(uuid.getNode().length == 12);
205	var timestamp = uuid.getTimestamp();
206	var date = uuid.getTimestamp(Date);
207	var dateString = uuid.getTimestamp(String);
208	var hexString = uuid.getTimestamp("hex");
209	doh.assertTrue(date instanceof Date);
210	doh.assertTrue(timestamp.valueOf() == date.valueOf());
211	doh.assertTrue(hexString.length == 15);
212	}
213	}
214	},
215
216	function test_uuid_nilGenerator(){
217	var nilUuidString = '00000000-0000-0000-0000-000000000000';
218	var uuidString = dxuuid.generateNilUuid();
219	doh.assertTrue(uuidString == nilUuidString);
220	},
221
222	function test_uuid_timeBasedGenerator(){
223	var uuid; // an instance of dojox.uuid.Uuid
224	var string; // a simple string literal
225	var generator = generateTimeBasedUuid;
226
227	var string1 = generator();
228	var uuid2 = new Uuid(generator());
229	var string3 = generator("017bf397618a"); // hardwareNode
230	var string4 = generator("f17bf397618a"); // pseudoNode
231	var string5 = generator(new String("017BF397618A"));
232
233	generateTimeBasedUuid.setNode("017bf397618a");
234	var string6 = generator(); // the generated UUID has node == "017bf397618a"
235	var uuid7 = new Uuid(generator()); // the generated UUID has node == "017bf397618a"
236	var returnedNode = generateTimeBasedUuid.getNode();
237	doh.assertTrue(returnedNode == "017bf397618a");
238
239	function getNode(string){
240	var arrayOfStrings = string.split('-');
241	return arrayOfStrings[4];
242	}
243	checkForPseudoNodeBitInTimeBasedUuidString(string1);
244	checkForPseudoNodeBitInTimeBasedUuidString(uuid2.toString());
245	checkForPseudoNodeBitInTimeBasedUuidString(string4);
246
247	doh.assertTrue(getNode(string3) == "017bf397618a");
248	doh.assertTrue(getNode(string4) == "f17bf397618a");
249	doh.assertTrue(getNode(string5) == "017bf397618a");
250	doh.assertTrue(getNode(string6) == "017bf397618a");
251	doh.assertTrue(uuid7.getNode() == "017bf397618a");
252
253	checkValidityOfTimeBasedUuidString(string1);
254	checkValidityOfTimeBasedUuidString(uuid2.toString());
255	checkValidityOfTimeBasedUuidString(string3);
256	checkValidityOfTimeBasedUuidString(string4);
257	checkValidityOfTimeBasedUuidString(string5);
258	checkValidityOfTimeBasedUuidString(string6);
259	checkValidityOfTimeBasedUuidString(uuid7.toString());
260	},
261
262	function test_uuid_invalidUuids(){
263	var uuidStrings = [];
264	uuidStrings.push("Hello world!"); // not a UUID
265	uuidStrings.push("3B12F1DF-5232-1804-897E-917BF39761"); // too short
266	uuidStrings.push("3B12F1DF-5232-1804-897E-917BF39761-8A"); // extra '-'
267	uuidStrings.push("3B12F1DF-5232-1804-897E917BF39761-8A"); // last '-' in wrong place
268	uuidStrings.push("HB12F1DF-5232-1804-897E-917BF397618A"); // "HB12F1DF" is not a hex string
269
270	var numberOfFailures = 0;
271	for(var i in uuidStrings){
272	var uuidString = uuidStrings[i];
273	try{
274	new Uuid(uuidString);
275	}catch (e){
276	++numberOfFailures;
277	}
278	}
279	doh.assertTrue(numberOfFailures == uuidStrings.length);
280	}
281	]
282	);
283
284
285
286	/*
287	function test_uuid_get64bitArrayFromFloat(){
288	// summary:
289	// This is a test we'd like to be able to run, but we can't run it
290	// because it tests a function which is private in generateTimeBasedUuid
291	var x = Math.pow(2, 63) + Math.pow(2, 15);
292	var result = generateTimeBasedUuid._get64bitArrayFromFloat(x);
293	doh.assertTrue(result[0] === 0x8000);
294	doh.assertTrue(result[1] === 0x0000);
295	doh.assertTrue(result[2] === 0x0000);
296	doh.assertTrue(result[3] === 0x8000);
297
298	var date = new Date();
299	x = date.valueOf();
300	result = generateTimeBasedUuid._get64bitArrayFromFloat(x);
301	var reconstructedFloat = result[0];
302	reconstructedFloat *= 0x10000;
303	reconstructedFloat += result[1];
304	reconstructedFloat *= 0x10000;
305	reconstructedFloat += result[2];
306	reconstructedFloat *= 0x10000;
307	reconstructedFloat += result[3];
308
309	doh.assertTrue(reconstructedFloat === x);
310	}
311
312	function test_uuid_addTwo64bitArrays(){
313	// summary:
314	// This is a test we'd like to be able to run, but we can't run it
315	// because it tests a function which is private in generateTimeBasedUuid
316	var a = [0x0000, 0x0000, 0x0000, 0x0001];
317	var b = [0x0FFF, 0xFFFF, 0xFFFF, 0xFFFF];
318	var result = generateTimeBasedUuid._addTwo64bitArrays(a, b);
319	doh.assertTrue(result[0] === 0x1000);
320	doh.assertTrue(result[1] === 0x0000);
321	doh.assertTrue(result[2] === 0x0000);
322	doh.assertTrue(result[3] === 0x0000);
323
324	a = [0x4000, 0x8000, 0x8000, 0x8000];
325	b = [0x8000, 0x8000, 0x8000, 0x8000];
326	result = generateTimeBasedUuid._addTwo64bitArrays(a, b);
327	doh.assertTrue(result[0] === 0xC001);
328	doh.assertTrue(result[1] === 0x0001);
329	doh.assertTrue(result[2] === 0x0001);
330	doh.assertTrue(result[3] === 0x0000);
331
332	a = [7, 6, 2, 5];
333	b = [1, 0, 3, 4];
334	result = generateTimeBasedUuid._addTwo64bitArrays(a, b);
335	doh.assertTrue(result[0] === 8);
336	doh.assertTrue(result[1] === 6);
337	doh.assertTrue(result[2] === 5);
338	doh.assertTrue(result[3] === 9);
339	}
340
341	function test_uuid_multiplyTwo64bitArrays(){
342	// summary:
343	// This is a test we'd like to be able to run, but we can't run it
344	// because it tests a function which is private in generateTimeBasedUuid
345	var a = [ 0, 0x0000, 0x0000, 0x0003];
346	var b = [0x1111, 0x1234, 0x0000, 0xFFFF];
347	var result = generateTimeBasedUuid._multiplyTwo64bitArrays(a, b);
348	doh.assertTrue(result[0] === 0x3333);
349	doh.assertTrue(result[1] === 0x369C);
350	doh.assertTrue(result[2] === 0x0002);
351	doh.assertTrue(result[3] === 0xFFFD);
352
353	a = [0, 0, 0, 5];
354	b = [0, 0, 0, 4];
355	result = generateTimeBasedUuid._multiplyTwo64bitArrays(a, b);
356	doh.assertTrue(result[0] === 0);
357	doh.assertTrue(result[1] === 0);
358	doh.assertTrue(result[2] === 0);
359	doh.assertTrue(result[3] === 20);
360
361	a = [0, 0, 2, 5];
362	b = [0, 0, 3, 4];
363	result = generateTimeBasedUuid._multiplyTwo64bitArrays(a, b);
364	doh.assertTrue(result[0] === 0);
365	doh.assertTrue(result[1] === 6);
366	doh.assertTrue(result[2] === 23);
367	doh.assertTrue(result[3] === 20);
368	}
369	*/
370	});

Note: See TracBrowser for help on using the repository browser.

Download in other formats: