Asserter number()

number() behavior

Does not contains assertions from the assertions containers.

test
        .value(test.number(1).hasHeader)
          .isUndefined()
        .value(test.number(1).hasProperty)
          .isUndefined()
        .value(test.number(1).hasMessage)
          .isUndefined()
      ;

Assert that the tested value is a number.

test
        .number(2)
        .number(99.98)
        .case('Test failure', function(){
          test
            .exception(function(){
              test.number('0');
            })
            .exception(function(){
              test.number('1');
            })
            .exception(function(){
              test.number(/0/);
            })
            .exception(function(){
              test.number(/1/);
            })
            .exception(function(){
              test.number(true);
            })
            .exception(function(){
              test.number(false);
            })
            .exception(function(){
              test.number(null);
            })
            .exception(function(){
              test.number(undefined);
            })
          ;
        })
      ;

Assertions of number()

is(expected).

test
        .number(2)
          .is(2)
        .case('Test failure', function(){
          test
            .exception(function(){
              test.number(2).is(-2)
            })
            .exception(function(){
              test.number(2).is(2.02)
            })
          ;
        })
      ;

isNot(expected).

test
        .number(2)
          .isNot(3)
          .isNot('2')
          .isNot(2.1)
          .isNot(0.2)
          .isNot(0.02)
          .isNot(-2)
        .exception(function(){
          test.number(2).isNot(2);
        })
      ;

isIdenticalTo(expected).

test
        .number(1)
          .isIdenticalTo(1)
         .case('Test failure', function(){
          test
            .exception(function(){
              test.number(2).isIdenticalTo(-2)
            })
            .exception(function(){
              test.number(2).isIdenticalTo(2.02)
            })
          ;
        })
      ;

isNotIdenticalTo(expected).

test
        .number(2)
          .isNotIdenticalTo(3)
          .isNotIdenticalTo('2')
          .isNotIdenticalTo(2.1)
          .isNotIdenticalTo(0.2)
          .isNotIdenticalTo(-2)
        .exception(function(){
          test.number(2).isNotIdenticalTo(2);
        })
      ;

isEqualTo(expected).

test
        .number(1)
          .isEqualTo(1)
          .isEqualTo('1')
        .case('Test failure', function(){
          test
            .exception(function(){
              test.number(2).isEqualTo(-2)
            })
            .exception(function(){
              test.number(2).isEqualTo(2.02)
            })
          ;
        })
     ;

isNotEqualTo(expected).

test
        .number(2)
          .isNotEqualTo(3)
          .isNotEqualTo(-2)
          .isNotEqualTo(2.1)
          .isNotEqualTo('2.1')
        .exception(function(){
          test.number(2).isNotEqualTo(2);
        })
      ;

match(expected).

test
        // Assert with a RegExp
        .number(2014).match(/20+[1-4]/)
        // Assert with a number converted to RegExp
        .number(2014).match(201)
        // Assert with a function
        .number(2014).match(function(it){
          return it === 2014;
        })
        .exception(function(){
          test.number(2).match(/3/);
        })
      ;

notMatch(expected).

test
        // Assert with a RegExp
        .number(2014)
          .notMatch(/20+[5-6]/)
          .notMatch(/[a-z]/)
        // Assert with a number converted to RegExp
        .number(10)
          .notMatch(8)
        // Assert with a function
        .number(10)
          .notMatch(function(it){
            return it === 42;
          })
        .case('Test failure', function(){
          test
            .exception(function(){
              test.number(2).notMatch(/2/);
            })
            .exception(function(){
              test.number(2014).notMatch(function(it){
                return it === 2014;
              });
            })
          ;
        })
      ;

isValid(expected).

test
        // Assert with a RegExp
        .number(2014).isValid(/20+[1-4]/)
        // Assert with a number converted to RegExp
        .number(2014).isValid(201)
        // Assert with a function
        .number(2014).isValid(function(it){
          return it === 2014;
        })
        .exception(function(){
          test.number(2).isValid(/3/);
        })
      ;

isNotValid(expected).

test
        // Assert with a RegExp
        .number(2014)
          .isNotValid(/20+[5-6]/)
          .isNotValid(/[a-z]/)
        // Assert with a number converted to RegExp
        .number(10)
          .isNotValid(8)
        // Assert with a function
        .number(10)
          .isNotValid(function(it){
            return it === 42;
          })
        .case('Test failure', function(){
          test
            .exception(function(){
              test.number(2).isNotValid(/2/);
            })
            .exception(function(){
              test.number(2014).isNotValid(function(it){
                return it === 2014;
              });
            })
          ;
        })
      ;

matchEach(expected).

test
        .number(2014)
          .matchEach([2, 4, 1, 0])
          .matchEach([2014, function(it){
            return it === 2014;
          }])
        .case('Test failure', function(){
          test
            .exception(function(){
              test.number(2014).matchEach([2014, function(it){
                return it === 2041;
              }]);
            })
            .exception(function(){
              test.number(2).matchEach([2, 3]);
            })
            .exception(function(){
              test.number(2014).matchEach([2041, function(it){
                return it === 2014;
              }]);
            })
          ;
        })
      ;

notMatchEach(expected).

test
        .number(2014)
          .notMatchEach([3, 200])
          .notMatchEach([2012, function(it){
            return it !== 2014;
          }])
        .case('Test failure', function(){
          test
            .exception(function(){
              test.number(2).notMatchEach([2, 3]);
            })
            .exception(function(){
              test.number(2014).notMatchEach([2041, function(it){
                return it === 2014;
              }]);
            })
            .exception(function(){
              test.number(2014).notMatchEach([2012, function(it){
                return it === 2014;
              }]);
            })
          ;
        })
      ;

isBetween(begin, end).

test
        .number(2)
          .isBetween(2, 4)
        .number(3)
          .isBetween(2, 4)
        .number(4)
          .isBetween(2, 4)
        .number(4)
          .isBetween(3.99, 4.01)
        .number(1)
          .isBetween(-1.00000001, 1.0000000001)
        .case('Test failure', function(){
          test
            .exception(function(){
              test.number(2).isBetween(-3, -1);
            })
            .exception(function(){
              test.number(2).isBetween(3, 1);
            })
          ;
        })
      ;

isNotBetween(begin, end).

test
        .number(1)
          .isNotBetween(2, 4)
        .number(5)
          .isNotBetween(2, 4)
        .exception(function(){
          test.number(2).isNotBetween(1, 3);
        })
      ;

isBefore(expected).

test
        .number(1)
          .isBefore(2)
          .isBefore(1.01)
        .exception(function(){
          test.number(1).isBefore(0);
        })
      ;

isAfter(expected).

test
        .number(2)
          .isAfter(1)
          .isAfter(1.99)
          .isAfter(-3)
        .exception(function(){
          test.number(-1).isAfter(0);
        })
      ;

isLessThan(expected).

test
        .number(1)
          .isLessThan(2)
          .isLessThan(1.01)
        .exception(function(){
          test.number(1).isLessThan(0);
        })
      ;

isGreaterThan(expected).

test
        .number(2)
          .isGreaterThan(1)
          .isGreaterThan(1.99)
          .isGreaterThan(-3)
        .exception(function(){
          test.number(-1).isGreaterThan(0);
        })
      ;

isApprox(num, delta).

test
        .number(99.98)
          .isApprox(100, 0.02)
        .exception(function(){
          test.number(99.98).isApprox(100, 0.01);
        })
      ;

isInfinite().

test
        .number(1/0)
          .isInfinite()
        .exception(function(){
          test.number(1.333333333333333333333).isInfinite();
        })
      ;

isNotInfinite().

test
        .number(1.333333333333333333333333)
          .isNotInfinite()
        .exception(function(){
          test.number(1/0).isNotInfinite();
        })
      ;