violations/build/test/util.js

get violated arguments for validation and assertion

'use strict';

var assert = require('assert');
var _ = require('../src').util;

describe('util', function () {
  it('isString', function () {
    assert(_.isString('a'));
    assert(_.isString(''));

    var values = [[], function () {}, true, 10, undefined, null, {}, new Date(), /abc/, new Error('test')];
    values.forEach(function (v) {
      assert.strictEqual(_.isString(v), false, 'isString(' + v + ')');
    });
  });

  it('isFunction', function () {
    assert(_.isFunction(function () {}));
    assert(_.isFunction(function () {}));

    var values = ['a', [], true, 10, undefined, null, '', {}, new Date(), /abc/, new Error('test')];
    values.forEach(function (v) {
      assert.strictEqual(_.isFunction(v), false, 'isFunction(' + v + ')');
    });
  });

  it('isBoolean', function () {
    assert(_.isBoolean(true));
    assert(_.isBoolean(false));

    var values = ['a', [], function () {}, 10, undefined, null, '', {}, new Date(), /abc/, new Error('test')];
    values.forEach(function (v) {
      assert.strictEqual(_.isBoolean(v), false, 'isBoolean(' + v + ')');
    });
  });

  it('isNumber', function () {
    assert(_.isNumber(0));
    assert(_.isNumber(1));
    assert(_.isNumber(1.1));
    assert(_.isNumber(new Number()));

    // negative
    assert(!_.isNumber(NaN));

    var values = ['a', [], function () {}, true, undefined, null, '', {}, new Date(), /abc/, new Error('test')];
    values.forEach(function (v) {
      assert.strictEqual(_.isNumber(v), false, 'isNumber(' + v + ')');
    });
  });

  it('isInteger', function () {
    assert(_.isInteger(0));
    assert(_.isInteger(1));

    // negative
    assert(!_.isInteger(1.1));
    assert(!_.isInteger(NaN));

    var values = ['a', [], function () {}, true, undefined, null, '', {}, new Date(), /abc/, new Error('test')];
    values.forEach(function (v) {
      assert.strictEqual(_.isInteger(v), false, 'isInteger(' + v + ')');
    });
  });

  it('isUndefined', function () {
    assert(_.isUndefined(undefined));

    var values = ['a', [], function () {}, false, 10, null, '', {}, new Date(), /abc/, new Error('test')];
    values.forEach(function (v) {
      assert.strictEqual(_.isUndefined(v), false, 'isUndefined(' + v + ')');
    });
  });

  it('isArray', function () {
    assert(_.isArray([]));
    assert(_.isArray(new Array()));

    var values = ['a', function () {}, true, 10, undefined, null, '', {}, new Date(), /abc/, new Error('test')];
    values.forEach(function (v) {
      assert.strictEqual(_.isArray(v), false, 'isArray(' + v + ')');
    });
  });

  it('isNull', function () {
    assert(_.isNull(null));

    var values = ['a', [], function () {}, false, 10, undefined, '', {}, new Date(), /abc/, new Error('test')];
    values.forEach(function (v) {
      assert.strictEqual(_.isNull(v), false, 'isNull(' + v + ')');
    });
  });

  it('isEmpty', function () {
    assert(_.isEmpty(''));
    assert(_.isEmpty(null));
    assert(_.isEmpty(undefined));

    var values = ['a', [], function () {}, true, 10, {}, new Date(), /abc/, new Error('test')];
    values.forEach(function (v) {
      assert.strictEqual(_.isEmpty(v), false, 'isEmpty(' + v + ')');
    });
  });

  it('isObject', function () {
    assert(_.isObject({}));
    assert(_.isObject({ a: {} }));
    assert(_.isObject(new Object()));
    assert(_.isObject(new Error()));

    // negative
    assert(!_.isObject(null));
    assert(!_.isObject(new Date()));
    assert(!_.isObject(new RegExp()));
    assert(!_.isObject(new Function()));
    assert(!_.isObject(new Number()));
    assert(!_.isObject(new Array()));

    var values = ['a', [], function () {}, true, 10, undefined, null, '', new Date(), /abc/];
    values.forEach(function (v) {
      assert.strictEqual(_.isObject(v), false, 'isObject(' + v + ')');
    });
  });

  it('isDate', function () {
    assert(_.isDate(new Date()));

    var values = ['a', [], function () {}, true, 10, undefined, null, '', {}, /abc/, new Error('test')];
    values.forEach(function (v) {
      assert.strictEqual(_.isDate(v), false, 'isDate(' + v + ')');
    });
  });

  it('isRegExp', function () {
    assert(_.isRegExp(/a/));
    assert(_.isRegExp(new RegExp()));

    var values = ['a', [], function () {}, true, 10, undefined, null, '', {}, new Date(), new Error('test')];
    values.forEach(function (v) {
      assert.strictEqual(_.isRegExp(v), false, 'isRegExp(' + v + ')');
    });
  });

  it('isError', function () {
    assert(_.isError(new Error()));
    assert(_.isError(new EvalError()));
    assert(_.isError(new RangeError()));
    assert(_.isError(new ReferenceError()));
    assert(_.isError(new SyntaxError()));
    assert(_.isError(new TypeError()));
    assert(_.isError(new URIError()));

    var values = ['a', [], function () {}, true, 10, undefined, null, '', {}, new Date(), /abc/];
    values.forEach(function (v) {
      assert.strictEqual(_.isError(v), false, 'isError(' + v + ')');
    });
  });

  it('isEmail', function () {
    assert(_.isEmail('mail@example.com'));
    assert(!_.isEmail('http://example.com'));

    var values = ['a', [], function () {}, true, 10, undefined, null, '', {}, new Date(), /abc/, new Error('test')];
    values.forEach(function (v) {
      assert.strictEqual(_.isEmail(v), false, 'isError(' + v + ')');
    });
  });
});