libs/js/jquery-mobile-1.2.0/node_modules/grunt/node_modules/nodeunit/node_modules/tap/node_modules/runforcover/node_modules/bunker/node_modules/burrito/node_modules/traverse/test/equal.js

   1 var assert = require('assert');
   2 var traverse = require('../');
   3 var deepEqual = require('./lib/deep_equal');
   4
   5 exports.deepDates = function () {
   6     assert.ok(
   7         deepEqual(
   8             { d : new Date, x : [ 1, 2, 3 ] },
   9             { d : new Date, x : [ 1, 2, 3 ] }
  10         ),
  11         'dates should be equal'
  12     );
  13
  14     var d0 = new Date;
  15     setTimeout(function () {
  16         assert.ok(
  17             !deepEqual(
  18                 { d : d0, x : [ 1, 2, 3 ], },
  19                 { d : new Date, x : [ 1, 2, 3 ] }
  20             ),
  21             'microseconds should count in date equality'
  22         );
  23     }, 5);
  24 };
  25
  26 exports.deepCircular = function () {
  27     var a = [1];
  28     a.push(a); // a = [ 1, *a ]
  29
  30     var b = [1];
  31     b.push(a); // b = [ 1, [ 1, *a ] ]
  32
  33     assert.ok(
  34         !deepEqual(a, b),
  35         'circular ref mount points count towards equality'
  36     );
  37
  38     var c = [1];
  39     c.push(c); // c = [ 1, *c ]
  40     assert.ok(
  41         deepEqual(a, c),
  42         'circular refs are structurally the same here'
  43     );
  44
  45     var d = [1];
  46     d.push(a); // c = [ 1, [ 1, *d ] ]
  47     assert.ok(
  48         deepEqual(b, d),
  49         'non-root circular ref structural comparison'
  50     );
  51 };
  52
  53 exports.deepInstances = function () {
  54     assert.ok(
  55         !deepEqual([ new Boolean(false) ], [ false ]),
  56         'boolean instances are not real booleans'
  57     );
  58
  59     assert.ok(
  60         !deepEqual([ new String('x') ], [ 'x' ]),
  61         'string instances are not real strings'
  62     );
  63
  64     assert.ok(
  65         !deepEqual([ new Number(4) ], [ 4 ]),
  66         'number instances are not real numbers'
  67     );
  68
  69     assert.ok(
  70         deepEqual([ new RegExp('x') ], [ /x/ ]),
  71         'regexp instances are real regexps'
  72     );
  73
  74     assert.ok(
  75         !deepEqual([ new RegExp(/./) ], [ /../ ]),
  76         'these regexps aren\'t the same'
  77     );
  78
  79     assert.ok(
  80         !deepEqual(
  81             [ function (x) { return x * 2 } ],
  82             [ function (x) { return x * 2 } ]
  83         ),
  84         'functions with the same .toString() aren\'t necessarily the same'
  85     );
  86
  87     var f = function (x) { return x * 2 };
  88     assert.ok(
  89         deepEqual([ f ], [ f ]),
  90         'these functions are actually equal'
  91     );
  92 };
  93
  94 exports.deepEqual = function () {
  95     assert.ok(
  96         !deepEqual([ 1, 2, 3 ], { 0 : 1, 1 : 2, 2 : 3 }),
  97         'arrays are not objects'
  98     );
  99 };
 100
 101 exports.falsy = function () {
 102     assert.ok(
 103         !deepEqual([ undefined ], [ null ]),
 104         'null is not undefined!'
 105     );
 106
 107     assert.ok(
 108         !deepEqual([ null ], [ undefined ]),
 109         'undefined is not null!'
 110     );
 111
 112     assert.ok(
 113         !deepEqual(
 114             { a : 1, b : 2, c : [ 3, undefined, 5 ] },
 115             { a : 1, b : 2, c : [ 3, null, 5 ] }
 116         ),
 117         'undefined is not null, however deeply!'
 118     );
 119
 120     assert.ok(
 121         !deepEqual(
 122             { a : 1, b : 2, c : [ 3, undefined, 5 ] },
 123             { a : 1, b : 2, c : [ 3, null, 5 ] }
 124         ),
 125         'null is not undefined, however deeply!'
 126     );
 127
 128     assert.ok(
 129         !deepEqual(
 130             { a : 1, b : 2, c : [ 3, undefined, 5 ] },
 131             { a : 1, b : 2, c : [ 3, null, 5 ] }
 132         ),
 133         'null is not undefined, however deeply!'
 134     );
 135 };
 136
 137 exports.deletedArrayEqual = function () {
 138     var xs = [ 1, 2, 3, 4 ];
 139     delete xs[2];
 140
 141     var ys = Object.create(Array.prototype);
 142     ys[0] = 1;
 143     ys[1] = 2;
 144     ys[3] = 4;
 145
 146     assert.ok(
 147         deepEqual(xs, ys),
 148         'arrays with deleted elements are only equal to'
 149         + ' arrays with similarly deleted elements'
 150     );
 151
 152     assert.ok(
 153         !deepEqual(xs, [ 1, 2, undefined, 4 ]),
 154         'deleted array elements cannot be undefined'
 155     );
 156
 157     assert.ok(
 158         !deepEqual(xs, [ 1, 2, null, 4 ]),
 159         'deleted array elements cannot be null'
 160     );
 161 };
 162
 163 exports.deletedObjectEqual = function () {
 164     var obj = { a : 1, b : 2, c : 3 };
 165     delete obj.c;
 166
 167     assert.ok(
 168         deepEqual(obj, { a : 1, b : 2 }),
 169         'deleted object elements should not show up'
 170     );
 171
 172     assert.ok(
 173         !deepEqual(obj, { a : 1, b : 2, c : undefined }),
 174         'deleted object elements are not undefined'
 175     );
 176
 177     assert.ok(
 178         !deepEqual(obj, { a : 1, b : 2, c : null }),
 179         'deleted object elements are not null'
 180     );
 181 };
 182
 183 exports.emptyKeyEqual = function () {
 184     assert.ok(!deepEqual(
 185         { a : 1 }, { a : 1, '' : 55 }
 186     ));
 187 };
 188
 189 exports.deepArguments = function () {
 190     assert.ok(
 191         !deepEqual(
 192             [ 4, 5, 6 ],
 193             (function () { return arguments })(4, 5, 6)
 194         ),
 195         'arguments are not arrays'
 196     );
 197
 198     assert.ok(
 199         deepEqual(
 200             (function () { return arguments })(4, 5, 6),
 201             (function () { return arguments })(4, 5, 6)
 202         ),
 203         'arguments should equal'
 204     );
 205 };
 206
 207 exports.deepUn = function () {
 208     assert.ok(!deepEqual({ a : 1, b : 2 }, undefined));
 209     assert.ok(!deepEqual({ a : 1, b : 2 }, {}));
 210     assert.ok(!deepEqual(undefined, { a : 1, b : 2 }));
 211     assert.ok(!deepEqual({}, { a : 1, b : 2 }));
 212     assert.ok(deepEqual(undefined, undefined));
 213     assert.ok(deepEqual(null, null));
 214     assert.ok(!deepEqual(undefined, null));
 215 };
 216
 217 exports.deepLevels = function () {
 218     var xs = [ 1, 2, [ 3, 4, [ 5, 6 ] ] ];
 219     assert.ok(!deepEqual(xs, []));
 220 };