smparkes-envjs 0.0.6 → 0.0.7

Sign up to get free protection for your applications and to get access to all the features.
Files changed (24) hide show
  1. data/README +25 -13
  2. data/bin/jquery-1.3.2-test.js +7 -6
  3. data/bin/test-jquery.sh +2 -2
  4. data/lib/envjs/env.js +11043 -92
  5. data/lib/envjs/runtime.rb +22 -1
  6. data/test/call-load-test.js +1 -1
  7. data/test/envjs-call-load-test.js +2 -0
  8. data/test/envjs-prototype.js +2 -0
  9. data/test/html/malformed.html +180 -0
  10. data/test/index.html +4 -1
  11. data/test/rhino-prototype.js +5 -0
  12. data/test/unit/dom.js +2 -1
  13. data/test/unit/elementmembers.js +1 -1
  14. data/test/unit/iframe.js +1 -1
  15. data/test/unit/onload.js +9 -3
  16. metadata +4 -10
  17. data/lib/envjs/runtime.rb.smp +0 -133
  18. data/test/qunit/qunit/qunit.js.smp +0 -1002
  19. data/test/qunit.smp/package.json +0 -21
  20. data/test/qunit.smp/qunit/qunit.css +0 -17
  21. data/test/qunit.smp/qunit/qunit.js +0 -997
  22. data/test/qunit.smp/test/index.html +0 -17
  23. data/test/qunit.smp/test/same.js +0 -1368
  24. data/test/qunit.smp/test/test.js +0 -136
data/test/qunit.smp/test/same.js DELETED
@@ -1,1368 +0,0 @@
1
- module("equiv");
2
-
3
-
4
- test("Primitive types and constants", function () {
5
- equals(QUnit.equiv(null, null), true, "null");
6
- equals(QUnit.equiv(null, {}), false, "null");
7
- equals(QUnit.equiv(null, undefined), false, "null");
8
- equals(QUnit.equiv(null, 0), false, "null");
9
- equals(QUnit.equiv(null, false), false, "null");
10
- equals(QUnit.equiv(null, ''), false, "null");
11
- equals(QUnit.equiv(null, []), false, "null");
12
-
13
- equals(QUnit.equiv(undefined, undefined), true, "undefined");
14
- equals(QUnit.equiv(undefined, null), false, "undefined");
15
- equals(QUnit.equiv(undefined, 0), false, "undefined");
16
- equals(QUnit.equiv(undefined, false), false, "undefined");
17
- equals(QUnit.equiv(undefined, {}), false, "undefined");
18
- equals(QUnit.equiv(undefined, []), false, "undefined");
19
- equals(QUnit.equiv(undefined, ""), false, "undefined");
20
-
21
- // Nan usually doest not equal to Nan using the '==' operator.
22
- // Only isNaN() is able to do it.
23
- equals(QUnit.equiv(0/0, 0/0), true, "NaN"); // NaN VS NaN
24
- equals(QUnit.equiv(1/0, 2/0), true, "Infinity"); // Infinity VS Infinity
25
- equals(QUnit.equiv(-1/0, 2/0), false, "-Infinity, Infinity"); // -Infinity VS Infinity
26
- equals(QUnit.equiv(-1/0, -2/0), true, "-Infinity, -Infinity"); // -Infinity VS -Infinity
27
- equals(QUnit.equiv(0/0, 1/0), false, "NaN, Infinity"); // Nan VS Infinity
28
- equals(QUnit.equiv(1/0, 0/0), false, "NaN, Infinity"); // Nan VS Infinity
29
- equals(QUnit.equiv(0/0, null), false, "NaN");
30
- equals(QUnit.equiv(0/0, undefined), false, "NaN");
31
- equals(QUnit.equiv(0/0, 0), false, "NaN");
32
- equals(QUnit.equiv(0/0, false), false, "NaN");
33
- equals(QUnit.equiv(0/0, function () {}), false, "NaN");
34
- equals(QUnit.equiv(1/0, null), false, "NaN, Infinity");
35
- equals(QUnit.equiv(1/0, undefined), false, "NaN, Infinity");
36
- equals(QUnit.equiv(1/0, 0), false, "NaN, Infinity");
37
- equals(QUnit.equiv(1/0, 1), false, "NaN, Infinity");
38
- equals(QUnit.equiv(1/0, false), false, "NaN, Infinity");
39
- equals(QUnit.equiv(1/0, true), false, "NaN, Infinity");
40
- equals(QUnit.equiv(1/0, function () {}), false, "NaN, Infinity");
41
-
42
- equals(QUnit.equiv(0, 0), true, "number");
43
- equals(QUnit.equiv(0, 1), false, "number");
44
- equals(QUnit.equiv(1, 0), false, "number");
45
- equals(QUnit.equiv(1, 1), true, "number");
46
- equals(QUnit.equiv(1.1, 1.1), true, "number");
47
- equals(QUnit.equiv(0.0000005, 0.0000005), true, "number");
48
- equals(QUnit.equiv(0, ''), false, "number");
49
- equals(QUnit.equiv(0, '0'), false, "number");
50
- equals(QUnit.equiv(1, '1'), false, "number");
51
- equals(QUnit.equiv(0, false), false, "number");
52
- equals(QUnit.equiv(1, true), false, "number");
53
-
54
- equals(QUnit.equiv(true, true), true, "boolean");
55
- equals(QUnit.equiv(true, false), false, "boolean");
56
- equals(QUnit.equiv(false, true), false, "boolean");
57
- equals(QUnit.equiv(false, 0), false, "boolean");
58
- equals(QUnit.equiv(false, null), false, "boolean");
59
- equals(QUnit.equiv(false, undefined), false, "boolean");
60
- equals(QUnit.equiv(true, 1), false, "boolean");
61
- equals(QUnit.equiv(true, null), false, "boolean");
62
- equals(QUnit.equiv(true, undefined), false, "boolean");
63
-
64
- equals(QUnit.equiv('', ''), true, "string");
65
- equals(QUnit.equiv('a', 'a'), true, "string");
66
- equals(QUnit.equiv("foobar", "foobar"), true, "string");
67
- equals(QUnit.equiv("foobar", "foo"), false, "string");
68
- equals(QUnit.equiv('', 0), false, "string");
69
- equals(QUnit.equiv('', false), false, "string");
70
- equals(QUnit.equiv('', null), false, "string");
71
- equals(QUnit.equiv('', undefined), false, "string");
72
-
73
- // Short annotation VS new annotation
74
- equals(QUnit.equiv(0, new Number()), true, "short annotation VS new annotation");
75
- equals(QUnit.equiv(new Number(), 0), true, "short annotation VS new annotation");
76
- equals(QUnit.equiv(1, new Number(1)), true, "short annotation VS new annotation");
77
- equals(QUnit.equiv(new Number(1), 1), true, "short annotation VS new annotation");
78
- equals(QUnit.equiv(new Number(0), 1), false, "short annotation VS new annotation");
79
- equals(QUnit.equiv(0, new Number(1)), false, "short annotation VS new annotation");
80
-
81
- equals(QUnit.equiv(new String(), ""), true, "short annotation VS new annotation");
82
- equals(QUnit.equiv("", new String()), true, "short annotation VS new annotation");
83
- equals(QUnit.equiv(new String("My String"), "My String"), true, "short annotation VS new annotation");
84
- equals(QUnit.equiv("My String", new String("My String")), true, "short annotation VS new annotation");
85
- equals(QUnit.equiv("Bad String", new String("My String")), false, "short annotation VS new annotation");
86
- equals(QUnit.equiv(new String("Bad String"), "My String"), false, "short annotation VS new annotation");
87
-
88
- equals(QUnit.equiv(false, new Boolean()), true, "short annotation VS new annotation");
89
- equals(QUnit.equiv(new Boolean(), false), true, "short annotation VS new annotation");
90
- equals(QUnit.equiv(true, new Boolean(true)), true, "short annotation VS new annotation");
91
- equals(QUnit.equiv(new Boolean(true), true), true, "short annotation VS new annotation");
92
- equals(QUnit.equiv(true, new Boolean(1)), true, "short annotation VS new annotation");
93
- equals(QUnit.equiv(false, new Boolean(false)), true, "short annotation VS new annotation");
94
- equals(QUnit.equiv(new Boolean(false), false), true, "short annotation VS new annotation");
95
- equals(QUnit.equiv(false, new Boolean(0)), true, "short annotation VS new annotation");
96
- equals(QUnit.equiv(true, new Boolean(false)), false, "short annotation VS new annotation");
97
- equals(QUnit.equiv(new Boolean(false), true), false, "short annotation VS new annotation");
98
-
99
- equals(QUnit.equiv(new Object(), {}), true, "short annotation VS new annotation");
100
- equals(QUnit.equiv({}, new Object()), true, "short annotation VS new annotation");
101
- equals(QUnit.equiv(new Object(), {a:1}), false, "short annotation VS new annotation");
102
- equals(QUnit.equiv({a:1}, new Object()), false, "short annotation VS new annotation");
103
- equals(QUnit.equiv({a:undefined}, new Object()), false, "short annotation VS new annotation");
104
- equals(QUnit.equiv(new Object(), {a:undefined}), false, "short annotation VS new annotation");
105
- });
106
-
107
- test("Objects Basics.", function() {
108
- equals(QUnit.equiv({}, {}), true);
109
- equals(QUnit.equiv({}, null), false);
110
- equals(QUnit.equiv({}, undefined), false);
111
- equals(QUnit.equiv({}, 0), false);
112
- equals(QUnit.equiv({}, false), false);
113
-
114
- // This test is a hard one, it is very important
115
- // REASONS:
116
- // 1) They are of the same type "object"
117
- // 2) [] instanceof Object is true
118
- // 3) Their properties are the same (doesn't exists)
119
- equals(QUnit.equiv({}, []), false);
120
-
121
- equals(QUnit.equiv({a:1}, {a:1}), true);
122
- equals(QUnit.equiv({a:1}, {a:"1"}), false);
123
- equals(QUnit.equiv({a:[]}, {a:[]}), true);
124
- equals(QUnit.equiv({a:{}}, {a:null}), false);
125
- equals(QUnit.equiv({a:1}, {}), false);
126
- equals(QUnit.equiv({}, {a:1}), false);
127
-
128
- // Hard ones
129
- equals(QUnit.equiv({a:undefined}, {}), false);
130
- equals(QUnit.equiv({}, {a:undefined}), false);
131
- equals(QUnit.equiv(
132
- {
133
- a: [{ bar: undefined }]
134
- },
135
- {
136
- a: [{ bat: undefined }]
137
- }
138
- ), false);
139
- });
140
-
141
-
142
- test("Arrays Basics.", function() {
143
-
144
- equals(QUnit.equiv([], []), true);
145
-
146
- // May be a hard one, can invoke a crash at execution.
147
- // because their types are both "object" but null isn't
148
- // like a true object, it doesn't have any property at all.
149
- equals(QUnit.equiv([], null), false);
150
-
151
- equals(QUnit.equiv([], undefined), false);
152
- equals(QUnit.equiv([], false), false);
153
- equals(QUnit.equiv([], 0), false);
154
- equals(QUnit.equiv([], ""), false);
155
-
156
- // May be a hard one, but less hard
157
- // than {} with [] (note the order)
158
- equals(QUnit.equiv([], {}), false);
159
-
160
- equals(QUnit.equiv([null],[]), false);
161
- equals(QUnit.equiv([undefined],[]), false);
162
- equals(QUnit.equiv([],[null]), false);
163
- equals(QUnit.equiv([],[undefined]), false);
164
- equals(QUnit.equiv([null],[undefined]), false);
165
- equals(QUnit.equiv([[]],[[]]), true);
166
- equals(QUnit.equiv([[],[],[]],[[],[],[]]), true);
167
- equals(QUnit.equiv(
168
- [[],[],[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]],
169
- [[],[],[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]),
170
- true);
171
- equals(QUnit.equiv(
172
- [[],[],[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]],
173
- [[],[],[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]), // shorter
174
- false);
175
- equals(QUnit.equiv(
176
- [[],[],[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[{}]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]],
177
- [[],[],[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[[]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]), // deepest element not an array
178
- false);
179
-
180
- // same multidimensional
181
- equals(QUnit.equiv(
182
- [1,2,3,4,5,6,7,8,9, [
183
- 1,2,3,4,5,6,7,8,9, [
184
- 1,2,3,4,5,[
185
- [6,7,8,9, [
186
- [
187
- 1,2,3,4,[
188
- 2,3,4,[
189
- 1,2,[
190
- 1,2,3,4,[
191
- 1,2,3,4,5,6,7,8,9,[
192
- 0
193
- ],1,2,3,4,5,6,7,8,9
194
- ],5,6,7,8,9
195
- ],4,5,6,7,8,9
196
- ],5,6,7,8,9
197
- ],5,6,7
198
- ]
199
- ]
200
- ]
201
- ]
202
- ]]],
203
- [1,2,3,4,5,6,7,8,9, [
204
- 1,2,3,4,5,6,7,8,9, [
205
- 1,2,3,4,5,[
206
- [6,7,8,9, [
207
- [
208
- 1,2,3,4,[
209
- 2,3,4,[
210
- 1,2,[
211
- 1,2,3,4,[
212
- 1,2,3,4,5,6,7,8,9,[
213
- 0
214
- ],1,2,3,4,5,6,7,8,9
215
- ],5,6,7,8,9
216
- ],4,5,6,7,8,9
217
- ],5,6,7,8,9
218
- ],5,6,7
219
- ]
220
- ]
221
- ]
222
- ]
223
- ]]]),
224
- true, "Multidimensional");
225
-
226
- // different multidimensional
227
- equals(QUnit.equiv(
228
- [1,2,3,4,5,6,7,8,9, [
229
- 1,2,3,4,5,6,7,8,9, [
230
- 1,2,3,4,5,[
231
- [6,7,8,9, [
232
- [
233
- 1,2,3,4,[
234
- 2,3,4,[
235
- 1,2,[
236
- 1,2,3,4,[
237
- 1,2,3,4,5,6,7,8,9,[
238
- 0
239
- ],1,2,3,4,5,6,7,8,9
240
- ],5,6,7,8,9
241
- ],4,5,6,7,8,9
242
- ],5,6,7,8,9
243
- ],5,6,7
244
- ]
245
- ]
246
- ]
247
- ]
248
- ]]],
249
- [1,2,3,4,5,6,7,8,9, [
250
- 1,2,3,4,5,6,7,8,9, [
251
- 1,2,3,4,5,[
252
- [6,7,8,9, [
253
- [
254
- 1,2,3,4,[
255
- 2,3,4,[
256
- 1,2,[
257
- '1',2,3,4,[ // string instead of number
258
- 1,2,3,4,5,6,7,8,9,[
259
- 0
260
- ],1,2,3,4,5,6,7,8,9
261
- ],5,6,7,8,9
262
- ],4,5,6,7,8,9
263
- ],5,6,7,8,9
264
- ],5,6,7
265
- ]
266
- ]
267
- ]
268
- ]
269
- ]]]),
270
- false, "Multidimensional");
271
-
272
- // different multidimensional
273
- equals(QUnit.equiv(
274
- [1,2,3,4,5,6,7,8,9, [
275
- 1,2,3,4,5,6,7,8,9, [
276
- 1,2,3,4,5,[
277
- [6,7,8,9, [
278
- [
279
- 1,2,3,4,[
280
- 2,3,4,[
281
- 1,2,[
282
- 1,2,3,4,[
283
- 1,2,3,4,5,6,7,8,9,[
284
- 0
285
- ],1,2,3,4,5,6,7,8,9
286
- ],5,6,7,8,9
287
- ],4,5,6,7,8,9
288
- ],5,6,7,8,9
289
- ],5,6,7
290
- ]
291
- ]
292
- ]
293
- ]
294
- ]]],
295
- [1,2,3,4,5,6,7,8,9, [
296
- 1,2,3,4,5,6,7,8,9, [
297
- 1,2,3,4,5,[
298
- [6,7,8,9, [
299
- [
300
- 1,2,3,4,[
301
- 2,3,[ // missing an element (4)
302
- 1,2,[
303
- 1,2,3,4,[
304
- 1,2,3,4,5,6,7,8,9,[
305
- 0
306
- ],1,2,3,4,5,6,7,8,9
307
- ],5,6,7,8,9
308
- ],4,5,6,7,8,9
309
- ],5,6,7,8,9
310
- ],5,6,7
311
- ]
312
- ]
313
- ]
314
- ]
315
- ]]]),
316
- false, "Multidimensional");
317
- });
318
-
319
- test("Functions.", function() {
320
- var f0 = function () {};
321
- var f1 = function () {};
322
-
323
- // f2 and f3 have the same code, formatted differently
324
- var f2 = function () {var i = 0;};
325
- var f3 = function () {
326
- var i = 0 // this comment and no semicoma as difference
327
- };
328
-
329
- equals(QUnit.equiv(function() {}, function() {}), false, "Anonymous functions"); // exact source code
330
- equals(QUnit.equiv(function() {}, function() {return true;}), false, "Anonymous functions");
331
-
332
- equals(QUnit.equiv(f0, f0), true, "Function references"); // same references
333
- equals(QUnit.equiv(f0, f1), false, "Function references"); // exact source code, different references
334
- equals(QUnit.equiv(f2, f3), false, "Function references"); // equivalent source code, different references
335
- equals(QUnit.equiv(f1, f2), false, "Function references"); // different source code, different references
336
- equals(QUnit.equiv(function() {}, true), false);
337
- equals(QUnit.equiv(function() {}, undefined), false);
338
- equals(QUnit.equiv(function() {}, null), false);
339
- equals(QUnit.equiv(function() {}, {}), false);
340
- });
341
-
342
-
343
- test("Date instances.", function() {
344
- // Date, we don't need to test Date.parse() because it returns a number.
345
- // Only test the Date instances by setting them a fix date.
346
- // The date use is midnight January 1, 1970
347
-
348
- var d1 = new Date();
349
- d1.setTime(0); // fix the date
350
-
351
- var d2 = new Date();
352
- d2.setTime(0); // fix the date
353
-
354
- var d3 = new Date(); // The very now
355
-
356
- // Anyway their types differs, just in case the code fails in the order in which it deals with date
357
- equals(QUnit.equiv(d1, 0), false); // d1.valueOf() returns 0, but d1 and 0 are different
358
- // test same values date and different instances equality
359
- equals(QUnit.equiv(d1, d2), true);
360
- // test different date and different instances difference
361
- equals(QUnit.equiv(d1, d3), false);
362
- });
363
-
364
-
365
- test("RegExp.", function() {
366
- // Must test cases that imply those traps:
367
- // var a = /./;
368
- // a instanceof Object; // Oops
369
- // a instanceof RegExp; // Oops
370
- // typeof a === "function"; // Oops, false in IE and Opera, true in FF and Safari ("object")
371
-
372
- // Tests same regex with same modifiers in different order
373
- var r = /foo/;
374
- var r5 = /foo/gim;
375
- var r6 = /foo/gmi;
376
- var r7 = /foo/igm;
377
- var r8 = /foo/img;
378
- var r9 = /foo/mig;
379
- var r10 = /foo/mgi;
380
- var ri1 = /foo/i;
381
- var ri2 = /foo/i;
382
- var rm1 = /foo/m;
383
- var rm2 = /foo/m;
384
- var rg1 = /foo/g;
385
- var rg2 = /foo/g;
386
-
387
- equals(QUnit.equiv(r5, r6), true, "Modifier order");
388
- equals(QUnit.equiv(r5, r7), true, "Modifier order");
389
- equals(QUnit.equiv(r5, r8), true, "Modifier order");
390
- equals(QUnit.equiv(r5, r9), true, "Modifier order");
391
- equals(QUnit.equiv(r5, r10), true, "Modifier order");
392
- equals(QUnit.equiv(r, r5), false, "Modifier");
393
-
394
- equals(QUnit.equiv(ri1, ri2), true, "Modifier");
395
- equals(QUnit.equiv(r, ri1), false, "Modifier");
396
- equals(QUnit.equiv(ri1, rm1), false, "Modifier");
397
- equals(QUnit.equiv(r, rm1), false, "Modifier");
398
- equals(QUnit.equiv(rm1, ri1), false, "Modifier");
399
- equals(QUnit.equiv(rm1, rm2), true, "Modifier");
400
- equals(QUnit.equiv(rg1, rm1), false, "Modifier");
401
- equals(QUnit.equiv(rm1, rg1), false, "Modifier");
402
- equals(QUnit.equiv(rg1, rg2), true, "Modifier");
403
-
404
- // Different regex, same modifiers
405
- var r11 = /[a-z]/gi;
406
- var r13 = /[0-9]/gi; // oops! different
407
- equals(QUnit.equiv(r11, r13), false, "Regex pattern");
408
-
409
- var r14 = /0/ig;
410
- var r15 = /"0"/ig; // oops! different
411
- equals(QUnit.equiv(r14, r15), false, "Regex pattern");
412
-
413
- var r1 = /[\n\r\u2028\u2029]/g;
414
- var r2 = /[\n\r\u2028\u2029]/g;
415
- var r3 = /[\n\r\u2028\u2028]/g; // differs from r1
416
- var r4 = /[\n\r\u2028\u2029]/; // differs from r1
417
-
418
- equals(QUnit.equiv(r1, r2), true, "Regex pattern");
419
- equals(QUnit.equiv(r1, r3), false, "Regex pattern");
420
- equals(QUnit.equiv(r1, r4), false, "Regex pattern");
421
-
422
- // More complex regex
423
- var regex1 = "^[-_.a-z0-9]+@([-_a-z0-9]+\\.)+([A-Za-z][A-Za-z]|[A-Za-z][A-Za-z][A-Za-z])|(([0-9][0-9]?|[0-1][0-9][0-9]|[2][0-4][0-9]|[2][5][0-5]))$";
424
- var regex2 = "^[-_.a-z0-9]+@([-_a-z0-9]+\\.)+([A-Za-z][A-Za-z]|[A-Za-z][A-Za-z][A-Za-z])|(([0-9][0-9]?|[0-1][0-9][0-9]|[2][0-4][0-9]|[2][5][0-5]))$";
425
- // regex 3 is different: '.' not escaped
426
- var regex3 = "^[-_.a-z0-9]+@([-_a-z0-9]+.)+([A-Za-z][A-Za-z]|[A-Za-z][A-Za-z][A-Za-z])|(([0-9][0-9]?|[0-1][0-9][0-9]|[2][0-4][0-9]|[2][5][0-5]))$";
427
-
428
- var r21 = new RegExp(regex1);
429
- var r22 = new RegExp(regex2);
430
- var r23 = new RegExp(regex3); // diff from r21, not same pattern
431
- var r23a = new RegExp(regex3, "gi"); // diff from r23, not same modifier
432
- var r24a = new RegExp(regex3, "ig"); // same as r23a
433
-
434
- equals(QUnit.equiv(r21, r22), true, "Complex Regex");
435
- equals(QUnit.equiv(r21, r23), false, "Complex Regex");
436
- equals(QUnit.equiv(r23, r23a), false, "Complex Regex");
437
- equals(QUnit.equiv(r23a, r24a), true, "Complex Regex");
438
-
439
- // typeof r1 is "function" in some browsers and "object" in others so we must cover this test
440
- var re = / /;
441
- equals(QUnit.equiv(re, function () {}), false, "Regex internal");
442
- equals(QUnit.equiv(re, {}), false, "Regex internal");
443
- });
444
-
445
-
446
- test("Complex Objects.", function() {
447
-
448
- function fn1() {
449
- return "fn1";
450
- }
451
- function fn2() {
452
- return "fn2";
453
- }
454
-
455
- // Try to invert the order of some properties to make sure it is covered.
456
- // It can failed when properties are compared between unsorted arrays.
457
- equals(QUnit.equiv(
458
- {
459
- a: 1,
460
- b: null,
461
- c: [{}],
462
- d: {
463
- a: 3.14159,
464
- b: false,
465
- c: {
466
- e: fn1,
467
- f: [[[]]],
468
- g: {
469
- j: {
470
- k: {
471
- n: {
472
- r: "r",
473
- s: [1,2,3],
474
- t: undefined,
475
- u: 0,
476
- v: {
477
- w: {
478
- x: {
479
- y: "Yahoo!",
480
- z: null
481
- }
482
- }
483
- }
484
- },
485
- q: [],
486
- p: 1/0,
487
- o: 99
488
- },
489
- l: undefined,
490
- m: null
491
- }
492
- },
493
- d: 0,
494
- i: true,
495
- h: "false"
496
- }
497
- },
498
- e: undefined,
499
- g: "",
500
- h: "h",
501
- f: {},
502
- i: []
503
- },
504
- {
505
- a: 1,
506
- b: null,
507
- c: [{}],
508
- d: {
509
- b: false,
510
- a: 3.14159,
511
- c: {
512
- d: 0,
513
- e: fn1,
514
- f: [[[]]],
515
- g: {
516
- j: {
517
- k: {
518
- n: {
519
- r: "r",
520
- t: undefined,
521
- u: 0,
522
- s: [1,2,3],
523
- v: {
524
- w: {
525
- x: {
526
- z: null,
527
- y: "Yahoo!"
528
- }
529
- }
530
- }
531
- },
532
- o: 99,
533
- p: 1/0,
534
- q: []
535
- },
536
- l: undefined,
537
- m: null
538
- }
539
- },
540
- i: true,
541
- h: "false"
542
- }
543
- },
544
- e: undefined,
545
- g: "",
546
- f: {},
547
- h: "h",
548
- i: []
549
- }
550
- ), true);
551
-
552
- equals(QUnit.equiv(
553
- {
554
- a: 1,
555
- b: null,
556
- c: [{}],
557
- d: {
558
- a: 3.14159,
559
- b: false,
560
- c: {
561
- d: 0,
562
- e: fn1,
563
- f: [[[]]],
564
- g: {
565
- j: {
566
- k: {
567
- n: {
568
- //r: "r", // different: missing a property
569
- s: [1,2,3],
570
- t: undefined,
571
- u: 0,
572
- v: {
573
- w: {
574
- x: {
575
- y: "Yahoo!",
576
- z: null
577
- }
578
- }
579
- }
580
- },
581
- o: 99,
582
- p: 1/0,
583
- q: []
584
- },
585
- l: undefined,
586
- m: null
587
- }
588
- },
589
- h: "false",
590
- i: true
591
- }
592
- },
593
- e: undefined,
594
- f: {},
595
- g: "",
596
- h: "h",
597
- i: []
598
- },
599
- {
600
- a: 1,
601
- b: null,
602
- c: [{}],
603
- d: {
604
- a: 3.14159,
605
- b: false,
606
- c: {
607
- d: 0,
608
- e: fn1,
609
- f: [[[]]],
610
- g: {
611
- j: {
612
- k: {
613
- n: {
614
- r: "r",
615
- s: [1,2,3],
616
- t: undefined,
617
- u: 0,
618
- v: {
619
- w: {
620
- x: {
621
- y: "Yahoo!",
622
- z: null
623
- }
624
- }
625
- }
626
- },
627
- o: 99,
628
- p: 1/0,
629
- q: []
630
- },
631
- l: undefined,
632
- m: null
633
- }
634
- },
635
- h: "false",
636
- i: true
637
- }
638
- },
639
- e: undefined,
640
- f: {},
641
- g: "",
642
- h: "h",
643
- i: []
644
- }
645
- ), false);
646
-
647
- equals(QUnit.equiv(
648
- {
649
- a: 1,
650
- b: null,
651
- c: [{}],
652
- d: {
653
- a: 3.14159,
654
- b: false,
655
- c: {
656
- d: 0,
657
- e: fn1,
658
- f: [[[]]],
659
- g: {
660
- j: {
661
- k: {
662
- n: {
663
- r: "r",
664
- s: [1,2,3],
665
- t: undefined,
666
- u: 0,
667
- v: {
668
- w: {
669
- x: {
670
- y: "Yahoo!",
671
- z: null
672
- }
673
- }
674
- }
675
- },
676
- o: 99,
677
- p: 1/0,
678
- q: []
679
- },
680
- l: undefined,
681
- m: null
682
- }
683
- },
684
- h: "false",
685
- i: true
686
- }
687
- },
688
- e: undefined,
689
- f: {},
690
- g: "",
691
- h: "h",
692
- i: []
693
- },
694
- {
695
- a: 1,
696
- b: null,
697
- c: [{}],
698
- d: {
699
- a: 3.14159,
700
- b: false,
701
- c: {
702
- d: 0,
703
- e: fn1,
704
- f: [[[]]],
705
- g: {
706
- j: {
707
- k: {
708
- n: {
709
- r: "r",
710
- s: [1,2,3],
711
- //t: undefined, // different: missing a property with an undefined value
712
- u: 0,
713
- v: {
714
- w: {
715
- x: {
716
- y: "Yahoo!",
717
- z: null
718
- }
719
- }
720
- }
721
- },
722
- o: 99,
723
- p: 1/0,
724
- q: []
725
- },
726
- l: undefined,
727
- m: null
728
- }
729
- },
730
- h: "false",
731
- i: true
732
- }
733
- },
734
- e: undefined,
735
- f: {},
736
- g: "",
737
- h: "h",
738
- i: []
739
- }
740
- ), false);
741
-
742
- equals(QUnit.equiv(
743
- {
744
- a: 1,
745
- b: null,
746
- c: [{}],
747
- d: {
748
- a: 3.14159,
749
- b: false,
750
- c: {
751
- d: 0,
752
- e: fn1,
753
- f: [[[]]],
754
- g: {
755
- j: {
756
- k: {
757
- n: {
758
- r: "r",
759
- s: [1,2,3],
760
- t: undefined,
761
- u: 0,
762
- v: {
763
- w: {
764
- x: {
765
- y: "Yahoo!",
766
- z: null
767
- }
768
- }
769
- }
770
- },
771
- o: 99,
772
- p: 1/0,
773
- q: []
774
- },
775
- l: undefined,
776
- m: null
777
- }
778
- },
779
- h: "false",
780
- i: true
781
- }
782
- },
783
- e: undefined,
784
- f: {},
785
- g: "",
786
- h: "h",
787
- i: []
788
- },
789
- {
790
- a: 1,
791
- b: null,
792
- c: [{}],
793
- d: {
794
- a: 3.14159,
795
- b: false,
796
- c: {
797
- d: 0,
798
- e: fn1,
799
- f: [[[]]],
800
- g: {
801
- j: {
802
- k: {
803
- n: {
804
- r: "r",
805
- s: [1,2,3],
806
- t: undefined,
807
- u: 0,
808
- v: {
809
- w: {
810
- x: {
811
- y: "Yahoo!",
812
- z: null
813
- }
814
- }
815
- }
816
- },
817
- o: 99,
818
- p: 1/0,
819
- q: {} // different was []
820
- },
821
- l: undefined,
822
- m: null
823
- }
824
- },
825
- h: "false",
826
- i: true
827
- }
828
- },
829
- e: undefined,
830
- f: {},
831
- g: "",
832
- h: "h",
833
- i: []
834
- }
835
- ), false);
836
-
837
- var same1 = {
838
- a: [
839
- "string", null, 0, "1", 1, {
840
- prop: null,
841
- foo: [1,2,null,{}, [], [1,2,3]],
842
- bar: undefined
843
- }, 3, "Hey!", "Κάνε πάντα γνωρίζουμε ας των, μηχανής επιδιόρθωσης επιδιορθώσεις ώς μια. Κλπ ας"
844
- ],
845
- unicode: "老 汉语中存在 港澳和海外的华人圈中 贵州 我去了书店 现在尚有争",
846
- b: "b",
847
- c: fn1
848
- };
849
-
850
- var same2 = {
851
- a: [
852
- "string", null, 0, "1", 1, {
853
- prop: null,
854
- foo: [1,2,null,{}, [], [1,2,3]],
855
- bar: undefined
856
- }, 3, "Hey!", "Κάνε πάντα γνωρίζουμε ας των, μηχανής επιδιόρθωσης επιδιορθώσεις ώς μια. Κλπ ας"
857
- ],
858
- unicode: "老 汉语中存在 港澳和海外的华人圈中 贵州 我去了书店 现在尚有争",
859
- b: "b",
860
- c: fn1
861
- };
862
-
863
- var diff1 = {
864
- a: [
865
- "string", null, 0, "1", 1, {
866
- prop: null,
867
- foo: [1,2,null,{}, [], [1,2,3,4]], // different: 4 was add to the array
868
- bar: undefined
869
- }, 3, "Hey!", "Κάνε πάντα γνωρίζουμε ας των, μηχανής επιδιόρθωσης επιδιορθώσεις ώς μια. Κλπ ας"
870
- ],
871
- unicode: "老 汉语中存在 港澳和海外的华人圈中 贵州 我去了书店 现在尚有争",
872
- b: "b",
873
- c: fn1
874
- };
875
-
876
- var diff2 = {
877
- a: [
878
- "string", null, 0, "1", 1, {
879
- prop: null,
880
- foo: [1,2,null,{}, [], [1,2,3]],
881
- newprop: undefined, // different: newprop was added
882
- bar: undefined
883
- }, 3, "Hey!", "Κάνε πάντα γνωρίζουμε ας των, μηχανής επιδιόρθωσης επιδιορθώσεις ώς μια. Κλπ ας"
884
- ],
885
- unicode: "老 汉语中存在 港澳和海外的华人圈中 贵州 我去了书店 现在尚有争",
886
- b: "b",
887
- c: fn1
888
- };
889
-
890
- var diff3 = {
891
- a: [
892
- "string", null, 0, "1", 1, {
893
- prop: null,
894
- foo: [1,2,null,{}, [], [1,2,3]],
895
- bar: undefined
896
- }, 3, "Hey!", "Κάνε πάντα γνωρίζουμε ας των, μηχανής επιδιόρθωσης επιδιορθώσεις ώς μια. Κλπ α" // different: missing last char
897
- ],
898
- unicode: "老 汉语中存在 港澳和海外的华人圈中 贵州 我去了书店 现在尚有争",
899
- b: "b",
900
- c: fn1
901
- };
902
-
903
- var diff4 = {
904
- a: [
905
- "string", null, 0, "1", 1, {
906
- prop: null,
907
- foo: [1,2,undefined,{}, [], [1,2,3]], // different: undefined instead of null
908
- bar: undefined
909
- }, 3, "Hey!", "Κάνε πάντα γνωρίζουμε ας των, μηχανής επιδιόρθωσης επιδιορθώσεις ώς μια. Κλπ ας"
910
- ],
911
- unicode: "老 汉语中存在 港澳和海外的华人圈中 贵州 我去了书店 现在尚有争",
912
- b: "b",
913
- c: fn1
914
- };
915
-
916
- var diff5 = {
917
- a: [
918
- "string", null, 0, "1", 1, {
919
- prop: null,
920
- foo: [1,2,null,{}, [], [1,2,3]],
921
- bat: undefined // different: property name not "bar"
922
- }, 3, "Hey!", "Κάνε πάντα γνωρίζουμε ας των, μηχανής επιδιόρθωσης επιδιορθώσεις ώς μια. Κλπ ας"
923
- ],
924
- unicode: "老 汉语中存在 港澳和海外的华人圈中 贵州 我去了书店 现在尚有争",
925
- b: "b",
926
- c: fn1
927
- };
928
-
929
- equals(QUnit.equiv(same1, same2), true);
930
- equals(QUnit.equiv(same2, same1), true);
931
- equals(QUnit.equiv(same2, diff1), false);
932
- equals(QUnit.equiv(diff1, same2), false);
933
-
934
- equals(QUnit.equiv(same1, diff1), false);
935
- equals(QUnit.equiv(same1, diff2), false);
936
- equals(QUnit.equiv(same1, diff3), false);
937
- equals(QUnit.equiv(same1, diff3), false);
938
- equals(QUnit.equiv(same1, diff4), false);
939
- equals(QUnit.equiv(same1, diff5), false);
940
- equals(QUnit.equiv(diff5, diff1), false);
941
- });
942
-
943
-
944
- test("Complex Arrays.", function() {
945
-
946
- function fn() {
947
- }
948
-
949
- equals(QUnit.equiv(
950
- [1, 2, 3, true, {}, null, [
951
- {
952
- a: ["", '1', 0]
953
- },
954
- 5, 6, 7
955
- ], "foo"],
956
- [1, 2, 3, true, {}, null, [
957
- {
958
- a: ["", '1', 0]
959
- },
960
- 5, 6, 7
961
- ], "foo"]),
962
- true);
963
-
964
- equals(QUnit.equiv(
965
- [1, 2, 3, true, {}, null, [
966
- {
967
- a: ["", '1', 0]
968
- },
969
- 5, 6, 7
970
- ], "foo"],
971
- [1, 2, 3, true, {}, null, [
972
- {
973
- b: ["", '1', 0] // not same property name
974
- },
975
- 5, 6, 7
976
- ], "foo"]),
977
- false);
978
-
979
- var a = [{
980
- b: fn,
981
- c: false,
982
- "do": "reserved word",
983
- "for": {
984
- ar: [3,5,9,"hey!", [], {
985
- ar: [1,[
986
- 3,4,6,9, null, [], []
987
- ]],
988
- e: fn,
989
- f: undefined
990
- }]
991
- },
992
- e: 0.43445
993
- }, 5, "string", 0, fn, false, null, undefined, 0, [
994
- 4,5,6,7,8,9,11,22,33,44,55,"66", null, [], [[[[[3]]]], "3"], {}, 1/0
995
- ], [], [[[], "foo", null, {
996
- n: 1/0,
997
- z: {
998
- a: [3,4,5,6,"yep!", undefined, undefined],
999
- b: {}
1000
- }
1001
- }, {}]]];
1002
-
1003
- equals(QUnit.equiv(a,
1004
- [{
1005
- b: fn,
1006
- c: false,
1007
- "do": "reserved word",
1008
- "for": {
1009
- ar: [3,5,9,"hey!", [], {
1010
- ar: [1,[
1011
- 3,4,6,9, null, [], []
1012
- ]],
1013
- e: fn,
1014
- f: undefined
1015
- }]
1016
- },
1017
- e: 0.43445
1018
- }, 5, "string", 0, fn, false, null, undefined, 0, [
1019
- 4,5,6,7,8,9,11,22,33,44,55,"66", null, [], [[[[[3]]]], "3"], {}, 1/0
1020
- ], [], [[[], "foo", null, {
1021
- n: 1/0,
1022
- z: {
1023
- a: [3,4,5,6,"yep!", undefined, undefined],
1024
- b: {}
1025
- }
1026
- }, {}]]]), true);
1027
-
1028
- equals(QUnit.equiv(a,
1029
- [{
1030
- b: fn,
1031
- c: false,
1032
- "do": "reserved word",
1033
- "for": {
1034
- ar: [3,5,9,"hey!", [], {
1035
- ar: [1,[
1036
- 3,4,6,9, null, [], []
1037
- ]],
1038
- e: fn,
1039
- f: undefined
1040
- }]
1041
- },
1042
- e: 0.43445
1043
- }, 5, "string", 0, fn, false, null, undefined, 0, [
1044
- 4,5,6,7,8,9,11,22,33,44,55,"66", null, [], [[[[[2]]]], "3"], {}, 1/0 // different: [[[[[2]]]]] instead of [[[[[3]]]]]
1045
- ], [], [[[], "foo", null, {
1046
- n: 1/0,
1047
- z: {
1048
- a: [3,4,5,6,"yep!", undefined, undefined],
1049
- b: {}
1050
- }
1051
- }, {}]]]), false);
1052
-
1053
- equals(QUnit.equiv(a,
1054
- [{
1055
- b: fn,
1056
- c: false,
1057
- "do": "reserved word",
1058
- "for": {
1059
- ar: [3,5,9,"hey!", [], {
1060
- ar: [1,[
1061
- 3,4,6,9, null, [], []
1062
- ]],
1063
- e: fn,
1064
- f: undefined
1065
- }]
1066
- },
1067
- e: 0.43445
1068
- }, 5, "string", 0, fn, false, null, undefined, 0, [
1069
- 4,5,6,7,8,9,11,22,33,44,55,"66", null, [], [[[[[3]]]], "3"], {}, 1/0
1070
- ], [], [[[], "foo", null, {
1071
- n: -1/0, // different, -Infinity instead of Infinity
1072
- z: {
1073
- a: [3,4,5,6,"yep!", undefined, undefined],
1074
- b: {}
1075
- }
1076
- }, {}]]]), false);
1077
-
1078
- equals(QUnit.equiv(a,
1079
- [{
1080
- b: fn,
1081
- c: false,
1082
- "do": "reserved word",
1083
- "for": {
1084
- ar: [3,5,9,"hey!", [], {
1085
- ar: [1,[
1086
- 3,4,6,9, null, [], []
1087
- ]],
1088
- e: fn,
1089
- f: undefined
1090
- }]
1091
- },
1092
- e: 0.43445
1093
- }, 5, "string", 0, fn, false, null, undefined, 0, [
1094
- 4,5,6,7,8,9,11,22,33,44,55,"66", null, [], [[[[[3]]]], "3"], {}, 1/0
1095
- ], [], [[[], "foo", { // different: null is missing
1096
- n: 1/0,
1097
- z: {
1098
- a: [3,4,5,6,"yep!", undefined, undefined],
1099
- b: {}
1100
- }
1101
- }, {}]]]), false);
1102
-
1103
- equals(QUnit.equiv(a,
1104
- [{
1105
- b: fn,
1106
- c: false,
1107
- "do": "reserved word",
1108
- "for": {
1109
- ar: [3,5,9,"hey!", [], {
1110
- ar: [1,[
1111
- 3,4,6,9, null, [], []
1112
- ]],
1113
- e: fn
1114
- // different: missing property f: undefined
1115
- }]
1116
- },
1117
- e: 0.43445
1118
- }, 5, "string", 0, fn, false, null, undefined, 0, [
1119
- 4,5,6,7,8,9,11,22,33,44,55,"66", null, [], [[[[[3]]]], "3"], {}, 1/0
1120
- ], [], [[[], "foo", null, {
1121
- n: 1/0,
1122
- z: {
1123
- a: [3,4,5,6,"yep!", undefined, undefined],
1124
- b: {}
1125
- }
1126
- }, {}]]]), false);
1127
- });
1128
-
1129
-
1130
- test("Prototypal inheritance", function() {
1131
- function Gizmo(id) {
1132
- this.id = id;
1133
- }
1134
-
1135
- function Hoozit(id) {
1136
- this.id = id;
1137
- }
1138
- Hoozit.prototype = new Gizmo();
1139
-
1140
- var gizmo = new Gizmo("ok");
1141
- var hoozit = new Hoozit("ok");
1142
-
1143
- // Try this test many times after test on instances that hold function
1144
- // to make sure that our code does not mess with last object constructor memoization.
1145
- equals(QUnit.equiv(function () {}, function () {}), false);
1146
-
1147
- // Hoozit inherit from Gizmo
1148
- // hoozit instanceof Hoozit; // true
1149
- // hoozit instanceof Gizmo; // true
1150
- equals(QUnit.equiv(hoozit, gizmo), true);
1151
-
1152
- Gizmo.prototype.bar = true; // not a function just in case we skip them
1153
-
1154
- // Hoozit inherit from Gizmo
1155
- // They are equivalent
1156
- equals(QUnit.equiv(hoozit, gizmo), true);
1157
-
1158
- // Make sure this is still true !important
1159
- // The reason for this is that I forgot to reset the last
1160
- // caller to where it were called from.
1161
- equals(QUnit.equiv(function () {}, function () {}), false);
1162
-
1163
- // Make sure this is still true !important
1164
- equals(QUnit.equiv(hoozit, gizmo), true);
1165
-
1166
- Hoozit.prototype.foo = true; // not a function just in case we skip them
1167
-
1168
- // Gizmo does not inherit from Hoozit
1169
- // gizmo instanceof Gizmo; // true
1170
- // gizmo instanceof Hoozit; // false
1171
- // They are not equivalent
1172
- equals(QUnit.equiv(hoozit, gizmo), false);
1173
-
1174
- // Make sure this is still true !important
1175
- equals(QUnit.equiv(function () {}, function () {}), false);
1176
- });
1177
-
1178
-
1179
- test("Instances", function() {
1180
- function A() {}
1181
- var a1 = new A();
1182
- var a2 = new A();
1183
-
1184
- function B() {
1185
- this.fn = function () {};
1186
- }
1187
- var b1 = new B();
1188
- var b2 = new B();
1189
-
1190
- equals(QUnit.equiv(a1, a2), true, "Same property, same constructor");
1191
-
1192
- // b1.fn and b2.fn are functions but they are different references
1193
- // But we decided to skip function for instances.
1194
- equals(QUnit.equiv(b1, b2), true, "Same property, same constructor");
1195
- equals(QUnit.equiv(a1, b1), false, "Same properties but different constructor"); // failed
1196
-
1197
- function Car(year) {
1198
- var privateVar = 0;
1199
- this.year = year;
1200
- this.isOld = function() {
1201
- return year > 10;
1202
- };
1203
- }
1204
-
1205
- function Human(year) {
1206
- var privateVar = 1;
1207
- this.year = year;
1208
- this.isOld = function() {
1209
- return year > 80;
1210
- };
1211
- }
1212
-
1213
- var car = new Car(30);
1214
- var carSame = new Car(30);
1215
- var carDiff = new Car(10);
1216
- var human = new Human(30);
1217
-
1218
- var diff = {
1219
- year: 30
1220
- };
1221
-
1222
- var same = {
1223
- year: 30,
1224
- isOld: function () {}
1225
- };
1226
-
1227
- equals(QUnit.equiv(car, car), true);
1228
- equals(QUnit.equiv(car, carDiff), false);
1229
- equals(QUnit.equiv(car, carSame), true);
1230
- equals(QUnit.equiv(car, human), false);
1231
- });
1232
-
1233
-
1234
- test("Complex Instances Nesting (with function value in literals and/or in nested instances)", function() {
1235
- function A(fn) {
1236
- this.a = {};
1237
- this.fn = fn;
1238
- this.b = {a: []};
1239
- this.o = {};
1240
- this.fn1 = fn;
1241
- }
1242
- function B(fn) {
1243
- this.fn = fn;
1244
- this.fn1 = function () {};
1245
- this.a = new A(function () {});
1246
- }
1247
-
1248
- function fnOutside() {
1249
- }
1250
-
1251
- function C(fn) {
1252
- function fnInside() {
1253
- }
1254
- this.x = 10;
1255
- this.fn = fn;
1256
- this.fn1 = function () {};
1257
- this.fn2 = fnInside;
1258
- this.fn3 = {
1259
- a: true,
1260
- b: fnOutside // ok make reference to a function in all instances scope
1261
- };
1262
- this.o1 = {};
1263
-
1264
- // This function will be ignored.
1265
- // Even if it is not visible for all instances (e.g. locked in a closures),
1266
- // it is from a property that makes part of an instance (e.g. from the C constructor)
1267
- this.b1 = new B(function () {});
1268
- this.b2 = new B({
1269
- x: {
1270
- b2: new B(function() {})
1271
- }
1272
- });
1273
- }
1274
-
1275
- function D(fn) {
1276
- function fnInside() {
1277
- }
1278
- this.x = 10;
1279
- this.fn = fn;
1280
- this.fn1 = function () {};
1281
- this.fn2 = fnInside;
1282
- this.fn3 = {
1283
- a: true,
1284
- b: fnOutside, // ok make reference to a function in all instances scope
1285
-
1286
- // This function won't be ingored.
1287
- // It isn't visible for all C insances
1288
- // and it is not in a property of an instance. (in an Object instances e.g. the object literal)
1289
- c: fnInside
1290
- };
1291
- this.o1 = {};
1292
-
1293
- // This function will be ignored.
1294
- // Even if it is not visible for all instances (e.g. locked in a closures),
1295
- // it is from a property that makes part of an instance (e.g. from the C constructor)
1296
- this.b1 = new B(function () {});
1297
- this.b2 = new B({
1298
- x: {
1299
- b2: new B(function() {})
1300
- }
1301
- });
1302
- }
1303
-
1304
- function E(fn) {
1305
- function fnInside() {
1306
- }
1307
- this.x = 10;
1308
- this.fn = fn;
1309
- this.fn1 = function () {};
1310
- this.fn2 = fnInside;
1311
- this.fn3 = {
1312
- a: true,
1313
- b: fnOutside // ok make reference to a function in all instances scope
1314
- };
1315
- this.o1 = {};
1316
-
1317
- // This function will be ignored.
1318
- // Even if it is not visible for all instances (e.g. locked in a closures),
1319
- // it is from a property that makes part of an instance (e.g. from the C constructor)
1320
- this.b1 = new B(function () {});
1321
- this.b2 = new B({
1322
- x: {
1323
- b1: new B({a: function() {}}),
1324
- b2: new B(function() {})
1325
- }
1326
- });
1327
- }
1328
-
1329
-
1330
- var a1 = new A(function () {});
1331
- var a2 = new A(function () {});
1332
- equals(QUnit.equiv(a1, a2), true);
1333
-
1334
- equals(QUnit.equiv(a1, a2), true); // different instances
1335
-
1336
- var b1 = new B(function () {});
1337
- var b2 = new B(function () {});
1338
- equals(QUnit.equiv(a1, a2), true);
1339
-
1340
- var c1 = new C(function () {});
1341
- var c2 = new C(function () {});
1342
- equals(QUnit.equiv(c1, c2), true);
1343
-
1344
- var d1 = new D(function () {});
1345
- var d2 = new D(function () {});
1346
- equals(QUnit.equiv(d1, d2), false);
1347
-
1348
- var e1 = new E(function () {});
1349
- var e2 = new E(function () {});
1350
- equals(QUnit.equiv(e1, e2), false);
1351
-
1352
- });
1353
-
1354
-
1355
- test("Test that must be done at the end because they extend some primitive's prototype", function() {
1356
- // Try that a function looks like our regular expression.
1357
- // This tests if we check that a and b are really both instance of RegExp
1358
- Function.prototype.global = true;
1359
- Function.prototype.multiline = true;
1360
- Function.prototype.ignoreCase = false;
1361
- Function.prototype.source = "my regex";
1362
- var re = /my regex/gm;
1363
- equals(QUnit.equiv(re, function () {}), false, "A function that looks that a regex isn't a regex");
1364
- // This test will ensures it works in both ways, and ALSO especially that we can make differences
1365
- // between RegExp and Function constructor because typeof on a RegExpt instance is "function"
1366
- equals(QUnit.equiv(function () {}, re), false, "Same conversely, but ensures that function and regexp are distinct because their constructor are different");
1367
- });
1368
-