~endlessm/jasmine-gjs/trunk

Copyright (c) 2008-2016 Pivotal Labs

  if (typeof module !== 'undefined' && module.exports && typeof exports !== 'undefined') {

    j$.formatErrorMsg = jRequire.formatErrorMsg();

    j$.CallTracker = jRequire.CallTracker(j$);

    j$.SpyStrategy = jRequire.SpyStrategy(j$);

      'toBeGreaterThanOrEqual',

      'toBeLessThanOrEqual',

  j$.isFunction_ = function(value) {

    return j$.isA_('Function', value);

  };

 

    if (func.name) {

      return func.name;

    }

 

    var matches = func.toString().match(/^\s*function\s*(\w*)\s*\(/);

    return matches ? matches[1] : '<anonymous>';

      var fullName = [spec.description],

          suiteFullName = suite.getFullName();

 

      if (suiteFullName !== '') {

        fullName.unshift(suiteFullName);

      }

      return fullName.join(' ');

      expectationFactory: expectationFactory,

      expectationResultFactory: expectationResultFactory

      currentlyExecutingSuites.push(topSuite);

 

        clearResourcesForRunnable(topSuite.id);

        currentlyExecutingSuites.pop();

 

          order: order,

          failedExpectations: topSuite.result.failedExpectations

    this.provideFallbackReporter = function(reporterToAdd) {

      reporter.provideFallbackReporter(reporterToAdd);

    };

 

    this.clearReporters = function() {

      reporter.clearReporters();

    };

 

    this.allowRespy = function(allow){

      spyRegistry.allowRespy(allow);

    };

 

        throw new Error('describe does not expect any arguments');

getJasmineRequireObj().CallTracker = function(j$) {

    var opts = {};

 

    function argCloner(context) {

      var clonedArgs = [];

      var argsAsArray = j$.util.argsToArray(context.args);

      for(var i = 0; i < argsAsArray.length; i++) {

        if(Object.prototype.toString.apply(argsAsArray[i]).match(/^\[object/)) {

          clonedArgs.push(j$.util.clone(argsAsArray[i]));

        } else {

          clonedArgs.push(argsAsArray[i]);

        }

      }

      context.args = clonedArgs;

    }

      if(opts.cloneArgs) {

        argCloner(context);

      }

 

    this.saveArgumentsByValue = function() {

      opts.cloneArgs = true;

    };

 

        delayedFunctionScheduler.tick(millis, function(millis) { mockDate.tick(millis); });

    self.tick = function(millis, tickDate) {

      runScheduledFunctions(endTime, tickDate);

    function runScheduledFunctions(endTime, tickDate) {

      tickDate = tickDate || function() {};

        tickDate(endTime - currentTime);

        var newCurrentTime = scheduledLookup.shift();

        tickDate(newCurrentTime - currentTime);

 

        currentTime = newCurrentTime;

 

      // ran out of functions to call, but still time left on the clock

      if (currentTime !== endTime) {

        tickDate(endTime - currentTime);

      }

      return null;

    var fallbackReporter = null;

    this.provideFallbackReporter = function(reporter) {

      fallbackReporter = reporter;

    };

 

    this.clearReporters = function() {

      reporters = [];

    };

 

      if (reporters.length === 0 && fallbackReporter !== null) {

          reporters.push(fallbackReporter);

      }

  var getErrorMsg = j$.formatErrorMsg('<spyOn>', 'spyOn(<object>, <methodName>)');

 

    this.allowRespy = function(allow){

      this.respy = allow;

    };

 

 

        throw new Error(getErrorMsg('could not find an object to spy upon for ' + methodName + '()'));

        throw new Error(getErrorMsg('No method name supplied'));

        throw new Error(getErrorMsg(methodName + '() method does not exist'));

      if (obj[methodName] && j$.isSpy(obj[methodName])  ) {

        if ( !!this.respy ){

          return obj[methodName];

        }else {

          throw new Error(getErrorMsg(methodName + ' has already been spied upon'));

        }

        throw new Error(getErrorMsg(methodName + ' is not declared writable or has no setter'));

      }

 

      var originalMethod = obj[methodName],

        spiedMethod = j$.createSpy(methodName, originalMethod),

        restoreStrategy;

 

      if (Object.prototype.hasOwnProperty.call(obj, methodName)) {

        restoreStrategy = function() {

          obj[methodName] = originalMethod;

        };

      } else {

        restoreStrategy = function() {

          if (!delete obj[methodName]) {

            obj[methodName] = originalMethod;

          }

        };

      }

        restoreObjectToOriginalState: restoreStrategy

      obj[methodName] = spiedMethod;

      return spiedMethod;

      for (var i = spies.length - 1; i >= 0; i--) {

        spyEntry.restoreObjectToOriginalState();

getJasmineRequireObj().SpyStrategy = function(j$) {

      if(!j$.isFunction_(fn)) {

        throw new Error('Argument passed to callFake should be a function, got ' + fn);

      }

    var fullName = [];

    for (var parentSuite = this; parentSuite; parentSuite = parentSuite.parentSuite) {

        fullName.unshift(parentSuite.description);

    return fullName.join(' ');

getJasmineRequireObj().formatErrorMsg = function() {

  function generateErrorMsg(domain, usage) {

    var usageDefinition = usage ? '\nUsage: ' + usage : '';

 

    return function errorMsg(msg) {

      return domain + ' : ' + msg + usageDefinition;

    };

  }

 

  return generateErrorMsg;

};

 

    if (className == '[object Array]') {

      size = a.length;

      if (size !== b.length) {

        return false;

      }

 

      while (size--) {

        result = eq(a[size], b[size], aStack, bStack, customTesters);

        if (!result) {

          return false;

        }

      }

    } else {

 

      var aCtor = a.constructor, bCtor = b.constructor;

      if (aCtor !== bCtor && !(isObjectConstructor(aCtor) &&

                               isObjectConstructor(bCtor))) {

        return false;

      }

    }

 

    // Deep compare objects.

    var aKeys = keys(a, className == '[object Array]'), key;

    size = aKeys.length;

 

    // Ensure that both objects contain the same number of properties before comparing deep equality.

    if (keys(b, className == '[object Array]').length !== size) { return false; }

 

    while (size--) {

      key = aKeys[size];

      // Deep compare each member

      result = has(b, key) && eq(a[key], b[key], aStack, bStack, customTesters);

 

      if (!result) {

        return false;

    function keys(obj, isArray) {

      var allKeys = Object.keys ? Object.keys(obj) :

        (function(o) {

            var keys = [];

            for (var key in o) {

                if (has(o, key)) {

                    keys.push(key);

                }

            }

            return keys;

        })(obj);

 

      if (!isArray) {

        return allKeys;

      }

 

      var extraKeys = [];

      if (allKeys.length === 0) {

          return allKeys;

      }

 

      for (var x = 0; x < allKeys.length; x++) {

          if (!allKeys[x].match(/^[0-9]+$/)) {

              extraKeys.push(allKeys[x]);

          }

      }

 

      return extraKeys;

    }

  }

 

  function has(obj, key) {

    return Object.prototype.hasOwnProperty.call(obj, key);

  }

 

  function isFunction(obj) {

    return typeof obj === 'function';

  }

 

  function isObjectConstructor(ctor) {

    // aCtor instanceof aCtor is true for the Object and Function

    // constructors (since a constructor is-a Function and a function is-a

    // Object). We don't just compare ctor === Object because the constructor

    // might come from a different frame with different globals.

    return isFunction(ctor) && ctor instanceof ctor;

getJasmineRequireObj().toBeGreaterThanOrEqual = function() {

 

  function toBeGreaterThanOrEqual() {

    return {

      compare: function(actual, expected) {

        return {

          pass: actual >= expected

        };

      }

    };

  }

 

  return toBeGreaterThanOrEqual;

};

 

getJasmineRequireObj().toBeLessThanOrEqual = function() {

  function toBeLessThanOrEqual() {

    return {

 

      compare: function(actual, expected) {

        return {

          pass: actual <= expected

        };

      }

    };

  }

 

  return toBeLessThanOrEqual;

};

 

  var getErrorMsg = j$.formatErrorMsg('<toHaveBeenCalled>', 'expect(<spyObj>).toHaveBeenCalled()');

 

          throw new Error(getErrorMsg('Expected a spy, but got ' + j$.pp(actual) + '.'));

          throw new Error(getErrorMsg('Does not take arguments, use toHaveBeenCalledWith'));

  var getErrorMsg = j$.formatErrorMsg('<toHaveBeenCalledTimes>', 'expect(<spyObj>).toHaveBeenCalledTimes(<Number>)');

 

          throw new Error(getErrorMsg('Expected a spy, but got ' + j$.pp(actual) + '.'));

        if (!j$.isNumber_(expected)){

          throw new Error(getErrorMsg('The expected times failed is a required argument and must be a number.'));

  var getErrorMsg = j$.formatErrorMsg('<toHaveBeenCalledWith>', 'expect(<spyObj>).toHaveBeenCalledWith(...arguments)');

 

          throw new Error(getErrorMsg('Expected a spy, but got ' + j$.pp(actual) + '.'));

  var getErrorMsg = j$.formatErrorMsg('<toMatch>', 'expect(<expectation>).toMatch(<string> || <regexp>)');

 

          throw new Error(getErrorMsg('Expected is not a String or a RegExp'));

  var getErrorMsg = j$.formatErrorMsg('<toThrow>', 'expect(function() {<expectation>}).toThrow()');

 

          throw new Error(getErrorMsg('Actual is not a Function'));

 

  var getErrorMsg =  j$.formatErrorMsg('<toThrowError>', 'expect(function() {<expectation>}).toThrowError(<ErrorConstructor>, <message>)');

 

          throw new Error(getErrorMsg('Actual is not a Function'));

          throw new Error(getErrorMsg('Expected error type is not an Error.'));

          throw new Error(getErrorMsg('Expected error message is not a string or RegExp.'));

          throw new Error(getErrorMsg('Expected is not an Error, string, or RegExp.'));

  return '2.5.2';