BVB Source Codes

reactide Show test.js Source code

Return Download reactide: download test.js Source code - Download reactide Source code - Type:.js
  1. // Copyright Joyent, Inc. and other Node contributors.
  2. //
  3. // Permission is hereby granted, free of charge, to any person obtaining a
  4. // copy of this software and associated documentation files (the
  5. // "Software"), to deal in the Software without restriction, including
  6. // without limitation the rights to use, copy, modify, merge, publish,
  7. // distribute, sublicense, and/or sell copies of the Software, and to permit
  8. // persons to whom the Software is furnished to do so, subject to the
  9. // following conditions:
  10. //
  11. // The above copyright notice and this permission notice shall be included
  12. // in all copies or substantial portions of the Software.
  13. //
  14. // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  15. // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  16. // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
  17. // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
  18. // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
  19. // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
  20. // USE OR OTHER DEALINGS IN THE SOFTWARE.
  21.  
  22. var nodeAssert = require('assert');
  23. var ourAssert = require('./');
  24. var keys = Object.keys;
  25. if (process.env.TEST_NATIVE === true) {
  26.   tests(nodeAssert, 'node assert');
  27. } else {
  28.   tests(ourAssert, 'our assert');
  29. }
  30.  
  31. function makeBlock(f) {
  32.   var args = Array.prototype.slice.call(arguments, 1);
  33.   return function() {
  34.     return f.apply(this, args);
  35.   };
  36. }
  37.  
  38. function tests (assert, what) {
  39.     test('assert.ok', function () {
  40.       assert.throws(makeBlock(assert, false), assert.AssertionError, 'ok(false)');
  41.  
  42.       assert.doesNotThrow(makeBlock(assert, true), assert.AssertionError, 'ok(true)');
  43.  
  44.       assert.doesNotThrow(makeBlock(assert, 'test', 'ok(\'test\')'));
  45.  
  46.       assert.throws(makeBlock(assert.ok, false),
  47.                     assert.AssertionError, 'ok(false)');
  48.  
  49.       assert.doesNotThrow(makeBlock(assert.ok, true),
  50.                           assert.AssertionError, 'ok(true)');
  51.  
  52.       assert.doesNotThrow(makeBlock(assert.ok, 'test'), 'ok(\'test\')');
  53.     });
  54.  
  55.     test('assert.equal', function () {
  56.       assert.throws(makeBlock(assert.equal, true, false), assert.AssertionError, 'equal');
  57.  
  58.       assert.doesNotThrow(makeBlock(assert.equal, null, null), 'equal');
  59.  
  60.       assert.doesNotThrow(makeBlock(assert.equal, undefined, undefined), 'equal');
  61.  
  62.       assert.doesNotThrow(makeBlock(assert.equal, null, undefined), 'equal');
  63.  
  64.       assert.doesNotThrow(makeBlock(assert.equal, true, true), 'equal');
  65.  
  66.       assert.doesNotThrow(makeBlock(assert.equal, 2, '2'), 'equal');
  67.  
  68.       assert.doesNotThrow(makeBlock(assert.notEqual, true, false), 'notEqual');
  69.  
  70.       assert.throws(makeBlock(assert.notEqual, true, true),
  71.                     assert.AssertionError, 'notEqual');
  72.     });
  73.  
  74.     test('assert.strictEqual', function () {
  75.       assert.throws(makeBlock(assert.strictEqual, 2, '2'),
  76.                     assert.AssertionError, 'strictEqual');
  77.  
  78.       assert.throws(makeBlock(assert.strictEqual, null, undefined),
  79.                     assert.AssertionError, 'strictEqual');
  80.  
  81.       assert.doesNotThrow(makeBlock(assert.notStrictEqual, 2, '2'), 'notStrictEqual');
  82.     });
  83.  
  84.     test('assert.deepStrictEqual', function () {
  85.       assert.throws(makeBlock(assert.deepStrictEqual, [2], ['2']),
  86.                     assert.AssertionError, 'deepStrictEqual');
  87.  
  88.       assert.throws(makeBlock(assert.deepStrictEqual, [null], [undefined]),
  89.                     assert.AssertionError, 'deepStrictEqual');
  90.  
  91.       assert.doesNotThrow(makeBlock(assert.notDeepStrictEqual, [2], ['2']), 'notDeepStrictEqual');
  92.     });
  93.  
  94.     test('assert.deepEqual - 7.2', function () {
  95.       assert.doesNotThrow(makeBlock(assert.deepEqual, new Date(2000, 3, 14),
  96.                           new Date(2000, 3, 14)), 'deepEqual date');
  97.  
  98.       assert.throws(makeBlock(assert.deepEqual, new Date(), new Date(2000, 3, 14)),
  99.                     assert.AssertionError,
  100.                     'deepEqual date');
  101.     });
  102.  
  103.     test('assert.deepEqual - 7.3', function () {
  104.       assert.doesNotThrow(makeBlock(assert.deepEqual, /a/, /a/));
  105.       assert.doesNotThrow(makeBlock(assert.deepEqual, /a/g, /a/g));
  106.       assert.doesNotThrow(makeBlock(assert.deepEqual, /a/i, /a/i));
  107.       assert.doesNotThrow(makeBlock(assert.deepEqual, /a/m, /a/m));
  108.       assert.doesNotThrow(makeBlock(assert.deepEqual, /a/igm, /a/igm));
  109.       assert.throws(makeBlock(assert.deepEqual, /ab/, /a/));
  110.       assert.throws(makeBlock(assert.deepEqual, /a/g, /a/));
  111.       assert.throws(makeBlock(assert.deepEqual, /a/i, /a/));
  112.       assert.throws(makeBlock(assert.deepEqual, /a/m, /a/));
  113.       assert.throws(makeBlock(assert.deepEqual, /a/igm, /a/im));
  114.  
  115.       var re1 = /a/;
  116.       re1.lastIndex = 3;
  117.       assert.throws(makeBlock(assert.deepEqual, re1, /a/));
  118.     });
  119.  
  120.     test('assert.deepEqual - 7.4', function () {
  121.       assert.doesNotThrow(makeBlock(assert.deepEqual, 4, '4'), 'deepEqual == check');
  122.       assert.doesNotThrow(makeBlock(assert.deepEqual, true, 1), 'deepEqual == check');
  123.       assert.throws(makeBlock(assert.deepEqual, 4, '5'),
  124.                 assert.AssertionError,
  125.                 'deepEqual == check');
  126.     });
  127.  
  128.     test('assert.deepEqual - 7.5', function () {
  129.       // having the same number of owned properties && the same set of keys
  130.       assert.doesNotThrow(makeBlock(assert.deepEqual, {a: 4}, {a: 4}));
  131.       assert.doesNotThrow(makeBlock(assert.deepEqual, {a: 4, b: '2'}, {a: 4, b: '2'}));
  132.       assert.doesNotThrow(makeBlock(assert.deepEqual, [4], ['4']));
  133.       assert.throws(makeBlock(assert.deepEqual, {a: 4}, {a: 4, b: true}),
  134.                 assert.AssertionError);
  135.       assert.doesNotThrow(makeBlock(assert.deepEqual, ['a'], {0: 'a'}));
  136.       //(although not necessarily the same order),
  137.       assert.doesNotThrow(makeBlock(assert.deepEqual, {a: 4, b: '1'}, {b: '1', a: 4}));
  138.       var a1 = [1, 2, 3];
  139.       var a2 = [1, 2, 3];
  140.       a1.a = 'test';
  141.       a1.b = true;
  142.       a2.b = true;
  143.       a2.a = 'test';
  144.       assert.throws(makeBlock(assert.deepEqual, keys(a1), keys(a2)),
  145.                 assert.AssertionError);
  146.       assert.doesNotThrow(makeBlock(assert.deepEqual, a1, a2));
  147.     });
  148.  
  149.     test('assert.deepEqual - ES6 primitives', function () {
  150.       assert.throws(makeBlock(assert.deepEqual, null, {}), assert.AssertionError);
  151.       assert.throws(makeBlock(assert.deepEqual, undefined, {}), assert.AssertionError);
  152.       assert.throws(makeBlock(assert.deepEqual, 'a', ['a']), assert.AssertionError);
  153.       assert.throws(makeBlock(assert.deepEqual, 'a', {0: 'a'}), assert.AssertionError);
  154.       assert.throws(makeBlock(assert.deepEqual, 1, {}), assert.AssertionError);
  155.       assert.throws(makeBlock(assert.deepEqual, true, {}), assert.AssertionError);
  156.       if (typeof Symbol === 'symbol') {
  157.         assert.throws(makeBlock(assert.deepEqual, Symbol(), {}), assert.AssertionError);
  158.       }
  159.     });
  160.  
  161.     test('assert.deepEqual - object wrappers', function () {
  162.       assert.doesNotThrow(makeBlock(assert.deepEqual, new String('a'), ['a']));
  163.       assert.doesNotThrow(makeBlock(assert.deepEqual, new String('a'), {0: 'a'}));
  164.       assert.doesNotThrow(makeBlock(assert.deepEqual, new Number(1), {}));
  165.       assert.doesNotThrow(makeBlock(assert.deepEqual, new Boolean(true), {}));
  166.     });
  167.  
  168.     test('assert.deepEqual - Buffers', function () {
  169.       assert.doesNotThrow(makeBlock(assert.deepEqual, new Buffer([1, 2, 3]), new Buffer([1, 2, 3])));
  170.       if (typeof global.Uint8Array === 'function') {
  171.         assert.throws(makeBlock(assert.deepEqual, new Buffer([1, 2, 3]), new Uint8Array([1, 2, 3])));
  172.       }
  173.       if (typeof global.Uint16Array === 'function') {
  174.         assert.doesNotThrow(makeBlock(assert.deepEqual, new Uint16Array([1, 2, 3]), new Uint16Array([1, 2, 3])));
  175.       }
  176.     });
  177.  
  178.     function thrower(errorConstructor) {
  179.       throw new errorConstructor('test');
  180.     }
  181.  
  182.     test('assert - Testing the throwing', function () {
  183.       var aethrow = makeBlock(thrower, assert.AssertionError);
  184.       aethrow = makeBlock(thrower, assert.AssertionError);
  185.  
  186.       // the basic calls work
  187.       assert.throws(makeBlock(thrower, assert.AssertionError),
  188.                     assert.AssertionError, 'message');
  189.       assert.throws(makeBlock(thrower, assert.AssertionError), assert.AssertionError);
  190.       assert.throws(makeBlock(thrower, assert.AssertionError));
  191.  
  192.       // if not passing an error, catch all.
  193.       assert.throws(makeBlock(thrower, TypeError));
  194.  
  195.       // when passing a type, only catch errors of the appropriate type
  196.       var threw = false;
  197.       try {
  198.         assert.throws(makeBlock(thrower, TypeError), assert.AssertionError);
  199.       } catch (e) {
  200.         threw = true;
  201.         assert.ok(e instanceof TypeError, 'type');
  202.       }
  203.       assert.equal(true, threw,
  204.                    'a.throws with an explicit error is eating extra errors',
  205.                    assert.AssertionError);
  206.       threw = false;
  207.  
  208.       // doesNotThrow should pass through all errors
  209.       try {
  210.         assert.doesNotThrow(makeBlock(thrower, TypeError), assert.AssertionError);
  211.       } catch (e) {
  212.         threw = true;
  213.         assert.ok(e instanceof TypeError);
  214.       }
  215.       assert.equal(true, threw,
  216.                    'a.doesNotThrow with an explicit error is eating extra errors');
  217.  
  218.       // key difference is that throwing our correct error makes an assertion error
  219.       try {
  220.         assert.doesNotThrow(makeBlock(thrower, TypeError), TypeError);
  221.       } catch (e) {
  222.         threw = true;
  223.         assert.ok(e instanceof assert.AssertionError);
  224.       }
  225.       assert.equal(true, threw,
  226.                    'a.doesNotThrow is not catching type matching errors');
  227.     });
  228.  
  229.     test('assert.ifError', function () {
  230.       assert.throws(function() {assert.ifError(new Error('test error'))});
  231.       assert.doesNotThrow(function() {assert.ifError(null)});
  232.       assert.doesNotThrow(function() {assert.ifError()});
  233.     });
  234.  
  235.     test('assert - make sure that validating using constructor really works', function () {
  236.       var threw = false;
  237.       try {
  238.         assert.throws(
  239.             function() {
  240.               throw ({});
  241.             },
  242.             Array
  243.         );
  244.       } catch (e) {
  245.         threw = true;
  246.       }
  247.       assert.ok(threw, 'wrong constructor validation');
  248.     });
  249.  
  250.     test('assert -  use a RegExp to validate error message', function () {
  251.       assert.throws(makeBlock(thrower, TypeError), /test/);
  252.     });
  253.  
  254.     test('assert - se a fn to validate error object', function () {
  255.       assert.throws(makeBlock(thrower, TypeError), function(err) {
  256.         if ((err instanceof TypeError) && /test/.test(err)) {
  257.           return true;
  258.         }
  259.       });
  260.     });
  261.  
  262.     test('assert - Make sure deepEqual doesn\'t loop forever on circular refs', function () {
  263.       var b = {};
  264.       b.b = b;
  265.  
  266.       var c = {};
  267.       c.b = c;
  268.  
  269.       var gotError = false;
  270.       var equal = true;
  271.       try {
  272.         equal = assert.deepEqual(b, c);
  273.       } catch (e) {
  274.         gotError = true;
  275.       }
  276.       assert.ok(gotError || !equal, gotError ? 'got error': 'are equal');
  277.     });
  278.  
  279.     test('assert - Ensure reflexivity of deepEqual with `arguments` objects', function() {
  280.         var args = (function() { return arguments; })();
  281.         assert.throws(makeBlock(assert.deepEqual, [], args), assert.AssertionError);
  282.         assert.throws(makeBlock(assert.deepEqual, args, []), assert.AssertionError);
  283.     });
  284.  
  285.     test('assert - test assertion message', function () {
  286.       function testAssertionMessage(actual, expected) {
  287.         try {
  288.           assert.equal(actual, '');
  289.         } catch (e) {
  290.           assert.equal(e.toString(),
  291.               ['AssertionError:', expected, '==', '\'\''].join(' '));
  292.         }
  293.       }
  294.       testAssertionMessage(undefined, 'undefined');
  295.       testAssertionMessage(null, 'null');
  296.       testAssertionMessage(true, 'true');
  297.       testAssertionMessage(false, 'false');
  298.       testAssertionMessage(0, '0');
  299.       testAssertionMessage(100, '100');
  300.       testAssertionMessage(NaN, 'NaN');
  301.       testAssertionMessage(Infinity, 'Infinity');
  302.       testAssertionMessage(-Infinity, '-Infinity');
  303.       testAssertionMessage('', '""');
  304.       testAssertionMessage('foo', '\'foo\'');
  305.       testAssertionMessage([], '[]');
  306.       testAssertionMessage([1, 2, 3], '[ 1, 2, 3 ]');
  307.       testAssertionMessage(new Buffer([1, 2, 3]), '<Buffer 01 02 03>');
  308.       if (typeof global.Uint8Array === 'function' && Object.getOwnPropertyNames( new Uint8Array([])).length === 0) {
  309.         // todo fix util.inspect
  310.         testAssertionMessage(new Uint8Array([1, 2, 3]), '{ \'0\': 1, \'1\': 2, \'2\': 3 }');
  311.       }
  312.       testAssertionMessage(/a/, '/a/');
  313.       testAssertionMessage(function f() {}, '[Function: f]');
  314.       testAssertionMessage({}, '{}');
  315.       testAssertionMessage({a: undefined, b: null}, '{ a: undefined, b: null }');
  316.       testAssertionMessage({a: NaN, b: Infinity, c: -Infinity},
  317.           '{ a: NaN, b: Infinity, c: -Infinity }');
  318.     });
  319.  
  320.     test('assert - regressions from node.js testcase', function () {
  321.       var threw = false;
  322.  
  323.       try {
  324.         assert.throws(function () {
  325.           assert.ifError(null);
  326.         });
  327.       } catch (e) {
  328.         threw = true;
  329.         assert.equal(e.message, 'Missing expected exception..');
  330.       }
  331.       assert.ok(threw);
  332.  
  333.       try {
  334.         assert.equal(1, 2);
  335.       } catch (e) {
  336.         assert.equal(e.toString().split('\n')[0], 'AssertionError: 1 == 2');
  337.       }
  338.  
  339.       try {
  340.         assert.equal(1, 2, 'oh no');
  341.       } catch (e) {
  342.         assert.equal(e.toString().split('\n')[0], 'AssertionError: oh no');
  343.       }
  344.     });
  345. }
  346.  
downloadtest.js Source code - Download reactide Source code
Related Source Codes/Software:
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
postal - 2017-06-11
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top