2016-07-08 18:10:18 -04:00
//This file is a copy of https://github.com/AnalyticalGraphicsInc/cesium/blob/master/Specs/addDefaultMatchers.js
2017-06-12 11:42:37 -04:00
/*eslint strict: ["error", "function"]*/
/*eslint-env amd*/
2017-06-12 15:10:35 -04:00
/*eslint-disable no-unused-vars*/
2016-07-08 18:10:18 -04:00
define ( [
'./equals' ,
'Cesium/Core/defined' ,
'Cesium/Core/DeveloperError' ,
'Cesium/Core/RuntimeError'
] , function (
equals ,
defined ,
DeveloperError ,
RuntimeError ) {
'use strict' ;
function createMissingFunctionMessageFunction ( item , actualPrototype , expectedInterfacePrototype ) {
return function ( ) {
return 'Expected function \'' + item + '\' to exist on ' + actualPrototype . constructor . name + ' because it should implement interface ' + expectedInterfacePrototype . constructor . name + '.' ;
} ;
}
function makeThrowFunction ( debug , Type , name ) {
if ( debug ) {
return function ( util , customEqualityTesters ) {
return {
compare : function ( actual , expected ) {
// based on the built-in Jasmine toThrow matcher
var result = false ;
var exception ;
if ( typeof actual !== 'function' ) {
throw new Error ( 'Actual is not a function' ) ;
}
try {
actual ( ) ;
} catch ( e ) {
exception = e ;
}
if ( exception ) {
result = exception instanceof Type ;
}
var message ;
if ( result ) {
message = [ 'Expected function not to throw ' + name + ' , but it threw' , exception . message || exception ] . join ( ' ' ) ;
if ( defined ( expected ) ) {
expect ( expected ) . toEqual ( exception . message ) ;
}
} else {
message = 'Expected function to throw ' + name + '.' ;
}
return {
pass : result ,
message : message
} ;
}
} ;
} ;
}
return function ( ) {
return {
compare : function ( actual , expected ) {
return { pass : true } ;
} ,
negativeCompare : function ( actual , expected ) {
return { pass : true } ;
}
} ;
} ;
}
function createDefaultMatchers ( debug ) {
return {
toBeGreaterThanOrEqualTo : function ( util , customEqualityTesters ) {
return {
compare : function ( actual , expected ) {
return { pass : actual >= expected } ;
}
} ;
} ,
toBeLessThanOrEqualTo : function ( util , customEqualityTesters ) {
return {
compare : function ( actual , expected ) {
return { pass : actual <= expected } ;
}
} ;
} ,
toBeBetween : function ( util , customEqualityTesters ) {
return {
compare : function ( actual , lower , upper ) {
if ( lower > upper ) {
var tmp = upper ;
upper = lower ;
lower = tmp ;
}
return { pass : actual >= lower && actual <= upper } ;
}
} ;
} ,
toStartWith : function ( util , customEqualityTesters ) {
return {
compare : function ( actual , expected ) {
return { pass : actual . slice ( 0 , expected . length ) === expected } ;
}
} ;
} ,
toEndWith : function ( util , customEqualityTesters ) {
return {
compare : function ( actual , expected ) {
return { pass : actual . slice ( - expected . length ) === expected } ;
}
} ;
} ,
toEqual : function ( util , customEqualityTesters ) {
return {
compare : function ( actual , expected ) {
return { pass : equals ( util , customEqualityTesters , actual , expected ) } ;
}
} ;
} ,
toEqualEpsilon : function ( util , customEqualityTesters ) {
return {
compare : function ( actual , expected , epsilon ) {
function equalityTester ( a , b ) {
var to _run ;
if ( defined ( a ) ) {
if ( typeof a . equalsEpsilon === 'function' ) {
return a . equalsEpsilon ( b , epsilon ) ;
} else if ( a instanceof Object ) {
// Check if the current object has a static function named 'equalsEpsilon'
to _run = Object . getPrototypeOf ( a ) . constructor . equalsEpsilon ;
if ( typeof to _run === 'function' ) {
return to _run ( a , b , epsilon ) ;
}
}
}
if ( defined ( b ) ) {
if ( typeof b . equalsEpsilon === 'function' ) {
return b . equalsEpsilon ( a , epsilon ) ;
} else if ( b instanceof Object ) {
// Check if the current object has a static function named 'equalsEpsilon'
to _run = Object . getPrototypeOf ( b ) . constructor . equalsEpsilon ;
if ( typeof to _run === 'function' ) {
return to _run ( b , a , epsilon ) ;
}
}
}
if ( typeof a === 'number' || typeof b === 'number' ) {
return Math . abs ( a - b ) <= epsilon ;
}
return undefined ;
}
var result = equals ( util , [ equalityTester ] , actual , expected ) ;
return { pass : result } ;
}
} ;
} ,
toConformToInterface : function ( util , customEqualityTesters ) {
return {
compare : function ( actual , expectedInterface ) {
// All function properties on the prototype should also exist on the actual's prototype.
var actualPrototype = actual . prototype ;
var expectedInterfacePrototype = expectedInterface . prototype ;
for ( var item in expectedInterfacePrototype ) {
if ( expectedInterfacePrototype . hasOwnProperty ( item ) && typeof expectedInterfacePrototype [ item ] === 'function' && ! actualPrototype . hasOwnProperty ( item ) ) {
return { pass : false , message : createMissingFunctionMessageFunction ( item , actualPrototype , expectedInterfacePrototype ) } ;
}
}
return { pass : true } ;
}
} ;
} ,
toBeInstanceOf : function ( util , customEqualityTesters ) {
return {
compare : function ( actual , expectedConstructor ) {
return { pass : actual instanceof expectedConstructor } ;
}
} ;
} ,
toThrow : function ( expectedConstructor ) {
throw new Error ( 'Do not use toThrow. Use toThrowDeveloperError or toThrowRuntimeError instead.' ) ;
} ,
toThrowDeveloperError : makeThrowFunction ( debug , DeveloperError , 'DeveloperError' ) ,
toThrowRuntimeError : makeThrowFunction ( true , RuntimeError , 'RuntimeError' )
} ;
}
return function ( debug ) {
return function ( ) {
this . addMatchers ( createDefaultMatchers ( debug ) ) ;
} ;
} ;
} ) ;