Plato on Github

dojo/tests/unit/_base/lang.js

Maintainability

67.41

Lines of code

397

Created with Raphaël 2.1.002550751002015-5-18

2015-5-18
Maintainability: 67.41

Created with Raphaël 2.1.001002003004002015-5-18

2015-5-18
Lines of Code: 397

Difficulty

44.35

Estimated Errors

4.78

Function weight

By Complexity

Created with Raphaël 2.1.0<anonymous>3

By SLOC

Created with Raphaël 2.1.0<anonymous>389
1
define([
2
    'intern!object',
3
    'intern/chai!assert',
4
    'dojo/_base/array',
5
    '../../../_base/lang',
6
    '../../../_base/kernel',
7
    'dojo/has',
8
    'dojo/has!host-browser?dojo/domReady!'
9
], function (registerSuite, assert, array, lang, kernel, has) {
10
    registerSuite({
11
        name: 'dojo/_base/lang',
12
 
13
        '.exists': function () {
14
            var test = {
15
                foo: 0
16
            };
17
            assert.isTrue(lang.exists('foo', test), 'test.foo should exist');
18
            assert.isFalse(lang.exists('foo.bar', test), 'test.foo.bar should not exist');
19
 
20
            // global tests
21
            assert.isFalse(lang.exists('_existsTest'), '_existsTest should not exist');
22
            kernel.global._existsTest = false;
23
            assert.isTrue(lang.exists('_existsTest'), '_existsTest should exist');
24
            assert.isFalse(lang.exists('_existsTest.bar'), '_existsTest.bar should not exist');
25
 
26
            // scopeMap tests
27
            assert.isTrue(lang.exists('dojo.dijit'), 'dojo.dijit should exist');
28
            assert.isFalse(lang.exists('dojo.foo'), 'dojo.foo should not exist');
29
        },
30
 
31
        '.getObject': function () {
32
            var test = {
33
                foo: {}
34
            };
35
 
36
            assert.strictEqual(lang.getObject('foo', false, test), test.foo);
37
            assert.strictEqual(typeof lang.getObject('foo.bar', false, test), 'undefined');
38
            assert.strictEqual(typeof lang.getObject('foo.bar', true, test), 'object');
39
 
40
            test.foo.bar.baz = 'test';
41
            assert.strictEqual(lang.getObject('foo.bar', false, test), test.foo.bar);
42
 
43
            // global tests
44
            assert.strictEqual(typeof lang.getObject('_getObjectTest.bar', false), 'undefined');
45
            kernel.global._getObjectTest = {};
46
            assert.strictEqual(lang.getObject('_getObjectTest', false), kernel.global._getObjectTest);
47
            assert.strictEqual(typeof lang.getObject('_getObjectTest.bar', true), 'object');
48
 
49
            // strangely, parser does this
50
            assert.strictEqual(typeof lang.getObject('./TestWidget'), 'undefined');
51
 
52
            // empty path should return the same object
53
            assert.strictEqual(lang.getObject('', false, test), test);
54
            assert.strictEqual(lang.getObject('', false, null), null);
55
            assert.strictEqual(lang.getObject(''), undefined);
56
        },
57
 
58
        '.setObject': function () {
59
            var test = {
60
                foo: 0
61
            };
62
 
63
            lang.setObject('foo', { bar: 'test' }, test);
64
            assert.deepEqual(test, { foo: { bar: 'test' } });
65
        },
66
 
67
        '.mixin': function () {
68
            var src = {
69
                foo: function () {
70
                    console.debug('foo');
71
                },
72
                bar: 'bar'
73
            };
74
            var dest = {};
75
            lang.mixin(dest, src);
76
 
77
            assert.typeOf(lang.mixin(), 'object');
78
            assert.typeOf(lang.mixin(undefined), 'object');
79
            assert.typeOf(lang.mixin(null), 'object');
80
            assert.typeOf(dest.foo, 'function');
81
            assert.typeOf(dest.bar, 'string');
82
        },
83
 
84
        '.extend': function () {
85
            var src = {
86
                foo: function () {
87
                    console.debug('foo');
88
                },
89
                bar: 'bar'
90
            };
91
            var test;
92
            function Dest() {}
93
 
94
            lang.extend(Dest, src);
95
            test = new Dest();
96
 
97
            assert.typeOf(test.foo, 'function');
98
            assert.typeOf(test.bar, 'string');
99
        },
100
 
101
        '.isFunction': function () {
102
            function test() {}
103
 
104
            assert.isTrue(lang.isFunction(new Function()));
Column: 55 "The Function constructor is a form of eval."
105
            assert.isTrue(lang.isFunction(test));
106
 
107
            if (has('host-browser')) { // test the Safari workaround for NodeList
108
                assert.isFalse(lang.isFunction(document.getElementsByName('html')));
109
                assert.isFalse(lang.isFunction(document.createElement('object')));
110
            }
111
        },
112
 
113
        '.isObject': function () {
114
            assert.isFalse(lang.isObject(true));
115
            assert.isFalse(lang.isObject(false));
116
            assert.isFalse(lang.isObject('foo'));
117
            /*jshint -W053 */
118
            assert.isTrue(lang.isObject(new String('foo')));
119
            assert.isTrue(lang.isObject(null));
120
            assert.isTrue(lang.isObject({}));
121
            assert.isTrue(lang.isObject([]));
122
            /*jshint -W009 */
123
            assert.isTrue(lang.isObject(new Array()));
124
        },
125
 
126
        '.isArray': function () {
127
            /*jshint -W009 */
128
            assert.isTrue(lang.isArray([]));
129
            assert.isTrue(lang.isArray(new Array()));
130
            assert.isFalse(lang.isArray({}));
131
            assert.isFalse(lang.isArray(''));
132
            assert.isFalse(lang.isArray(0));
133
            assert.isFalse(lang.isArray(NaN));
134
            assert.isFalse(lang.isArray(null));
135
            assert.isFalse(lang.isArray(undefined));
136
            if (typeof window !== 'undefined') {
137
                assert.isFalse(lang.isArray(window));
138
            }
139
            assert.isFalse(lang.isArray(Function));
140
            function Tricky() {}
141
            Tricky.prototype = [];
142
            assert.isFalse(lang.isArray(new Tricky()));
143
        },
144
 
145
        '.isArrayLike': function () {
146
            /*jshint -W009 */
147
            assert.isFalse(lang.isArrayLike('thinger'));
148
            assert.isTrue(lang.isArrayLike(new Array()));
149
            assert.isFalse(lang.isArrayLike({}));
150
            assert.isTrue(lang.isArrayLike(arguments));
151
            assert.isFalse(lang.isArrayLike(''));
152
            assert.isFalse(lang.isArrayLike(false));
153
            assert.isFalse(lang.isArrayLike(NaN));
154
            assert.isFalse(lang.isArrayLike(undefined));
155
            assert.isFalse(lang.isArrayLike(null));
156
            if(typeof window !== 'undefined'){
157
                assert.isTrue(lang.isArrayLike(window));
158
            }
159
            assert.isFalse(lang.isArrayLike(Function));
160
 
161
            assert.isTrue(lang.isArrayLike({0: 1, 1: 2, length: 2}));
162
            function Tricky() {}
163
            Tricky.prototype = [];
164
            assert.isTrue(lang.isArrayLike(new Tricky()));
165
        },
166
 
167
        '.isString': function () {
168
            /*jshint -W053 */
169
            assert.isFalse(lang.isString(true));
170
            assert.isFalse(lang.isString(false));
171
            assert.isTrue(lang.isString('foo'));
172
            assert.isTrue(lang.isString(new String('foo')));
173
            assert.isFalse(lang.isString(null));
174
            assert.isFalse(lang.isString({}));
175
            assert.isFalse(lang.isString([]));
176
        },
177
 
178
        '.partial': function () {
179
            var scope = { foo: 'bar' };
180
            var st1;
181
            var st2;
182
            var st3;
183
 
184
            function thinger(arg1, arg2) {
185
                return [this.foo, arg1, arg2];
186
            }
187
 
188
            st1 = lang.partial(thinger);
189
            assert.equal('bar', st1.call(scope)[0]);
190
            assert.equal(undefined, st1()[0]);
191
 
192
            st2 = lang.partial(thinger, 'foo', 'bar');
193
            assert.equal('bar', st2()[2]);
194
            st3 = lang.partial(thinger, 'foo', 'bar');
195
        },
196
 
197
        '.partial nested': function () {
198
            var st1;
199
            var st2;
200
 
201
            function thinger(arg1, arg2) {
202
                return [arg1, arg2];
203
            }
204
 
205
            st1 = lang.partial(thinger, 'foo');
206
            assert.equal(undefined, st1()[1]);
207
            assert.equal('bar', st1('bar')[1]);
208
 
209
            // partials can accumulate
210
            st2 = lang.partial(st1, 'thud');
211
            assert.equal('foo', st2()[0]);
212
            assert.equal('thud', st2()[1]);
213
        },
214
 
215
        '.hitch': function () {
216
            var scope = { foo: 'bar' };
217
            var scope2 = { foo: 'baz' };
218
            var st1;
219
            var st2;
220
 
221
            function thinger() {
222
                return [this.foo, arguments.length];
223
            }
224
 
225
            st1 = lang.hitch(scope, thinger);
226
            assert.equal('bar', st1()[0]);
227
            assert.equal(0, st1()[1]);
228
 
229
            st2 = lang.hitch(scope2, thinger);
230
            assert.equal('baz', st2()[0]);
231
            assert.equal(0, st1()[1]);
232
            assert.equal(1, st1('blah')[1]);
233
 
234
            // st2 should be "scope proof"
235
            assert.equal('baz', st2.call(scope)[0]);
236
        },
237
 
238
        '.hitch with args': function () {
239
            var scope = { foo: 'bar' };
240
            var scope2 = { foo: 'baz' };
241
            var st1;
242
            var st2;
243
 
244
            function thinger() {
245
                return [this.foo, arguments.length];
246
            }
247
 
248
            st1 = lang.hitch(scope, thinger, 'foo', 'bar');
249
            assert.equal('bar', st1()[0]);
250
            assert.equal(2, st1()[1]);
251
 
252
            st2 = lang.hitch(scope2, thinger, 'foo', 'bar');
253
            assert.equal('baz', st2()[0]);
254
            assert.equal(2, st2()[1]);
255
        },
256
 
257
        '.hitch as partial': function () {
258
            var scope = { foo: 'bar' };
259
            var st1;
260
            var st2;
261
 
262
            function thinger(arg1, arg2) {
263
                return [this.foo, arg1, arg2];
264
            }
265
 
266
            st1 = lang.hitch(null, thinger);
267
            assert.equal('bar', st1.call(scope)[0]);
268
            assert.equal(undefined, st1()[0]);
269
 
270
            st2 = lang.hitch(null, thinger, 'foo', 'bar');
271
            assert.equal('bar', st2()[2]);
272
        },
273
 
274
        '.toArray': function () {
275
            var obj1 = [ 'foo', 'bar', 'spam', 'ham' ];
276
            var obj2;
277
            var div;
278
            var result;
279
 
280
            function thinger() {
281
                return lang._toArray(arguments);
282
            }
283
 
284
            obj2 = thinger.apply(this, obj1);
285
            assert.equal(obj1[0], obj2[0]);
286
 
287
            if (has('host-browser')) {
288
                // test DomCollection
289
                div = document.createElement('div');
290
                div.innerHTML = '<a href="#"">link</a>text';
291
                result = lang._toArray(div.childNodes);
292
                assert.equal(2, result.length);
293
            }
294
        },
295
 
296
        '.clone': function () {
297
            var obj1 = {
298
                foo: 'bar',
299
                answer: 42,
300
                jan102007: new Date(2007, 0, 10),
301
                baz: {
302
                    a: null,
303
                    b: [1, 'b', 2.3, true, false],
304
                    c: {
305
                        d: undefined,
306
                        e: 99,
307
                        f: function () { console.log(42); return 42; },
308
                        g: /\d+/gm
309
                    }
310
                },
311
                toString: function () { return 'meow'; }
312
            };
313
 
314
            assert.deepEqual(obj1, lang.clone(obj1));
315
        },
316
 
317
        '.delegate': function () {
318
            var a = {
319
                x: 1,
320
                y: function () { return 2; },
321
                z1: 99
322
            };
323
            var b = {
324
                x: 11,
325
                y: function () { return 12; },
326
                z2: 33,
327
                toString: function () { return 'bark!'; },
328
                toLocaleString: function () { return 'le bark-s!'; }
329
            };
330
            var c;
331
 
332
            assert.strictEqual(1, a.x);
333
            assert.strictEqual(2, a.y());
334
            assert.strictEqual(99, a.z1);
335
 
336
            c = lang.delegate(a, b);
337
 
338
            assert.strictEqual(1, a.x);
339
            assert.strictEqual(2, a.y());
340
            assert.strictEqual(99, a.z1);
341
            assert.strictEqual(11, c.x);
342
            assert.strictEqual(12, c.y());
343
            assert.strictEqual('bark!', c.toString());
344
            assert.strictEqual('le bark-s!', c.toLocaleString());
345
            assert.strictEqual(99, c.z1);
346
            assert.strictEqual(33, c.z2);
347
        },
348
 
349
        '.replace with object': function () {
350
            var objectContext = {
351
                    nick: 'Bob',
352
                    name: {
353
                        first:  'Robert',
354
                        middle: 'X',
355
                        last:   'Cringely'
356
                    }
357
                };
358
            var s1 = lang.replace('Hello, {name.first} {name.last} AKA {nick}!', objectContext);
359
            assert.equal('Hello, Robert Cringely AKA Bob!', s1);
360
        },
361
 
362
        '.replace with array context': function () {
363
            var arrayContext = ['Robert', 'X', 'Cringely'];
364
            var s2 = lang.replace('Hello, {0} {2}!', arrayContext);
365
            assert.equal('Hello, Robert Cringely!', s2);
366
        },
367
 
368
        '.replace with function': function () {
369
            function sum(a) {
370
                var t = 0;
371
                array.forEach(a, function (x) { t += x; });
372
                return t;
373
            }
374
 
375
            var s1 = lang.replace(
376
                '{count} payments averaging {avg} USD per payment.',
377
                lang.hitch(
378
                    { payments: [11, 16, 12] },
379
                    function (_, key) {
380
                        switch (key) {
381
                            case 'count':
382
                                return this.payments.length;
383
                            case 'avg':
384
                                return sum(this.payments) / this.payments.length;
385
                        }
386
                        return '';
387
                    }
388
                ));
389
            assert.equal('3 payments averaging 13 USD per payment.', s1);
390
        },
391
 
392
        '.replace with regex': function () {
393
            var s4 = lang.replace('Hello, ${0} ${2}!', ['Robert', 'X', 'Cringely'], /\$\{([^\}]+)\}/g);
394
            assert.equal('Hello, Robert Cringely!', s4);
395
        }
396
    });
397
});