text: define([
          './defined',
          './DeveloperError'
      ], function(
          defined,
          DeveloperError) {
      'use strict';
  
      /**
       * Contains functions for checking that supplied arguments are of a specified type
       * or meet specified conditions
       * @private
       */
      var Check = {};
  
      /**
       * Contains type checking functions, all using the typeof operator
       */
      Check.typeOf = {};
  
      function getUndefinedErrorMessage(name) {
          return name + ' is required, actual value was undefined';
      }
  
      function getFailedTypeErrorMessage(actual, expected, name) {
          return 'Expected ' + name + ' to be typeof ' + expected + ', actual typeof was ' + actual;
      }
  
      /**
       * Throws if test is not defined
       *
       * @param {String} name The name of the variable being tested
       * @param {*} test The value that is to be checked
       * @exception {DeveloperError} test must be defined
       */
      Check.defined = function (name, test) {
          if (!defined(test)) {
              throw new DeveloperError(getUndefinedErrorMessage(name));
          }
      };
  
      /**
       * Throws if test is not typeof 'function'
       *
       * @param {String} name The name of the variable being tested
       * @param {*} test The value to test
       * @exception {DeveloperError} test must be typeof 'function'
       */
      Check.typeOf.func = function (name, test) {
          if (typeof test !== 'function') {
              throw new DeveloperError(getFailedTypeErrorMessage(typeof test, 'function', name));
          }
      };
  
      /**
       * Throws if test is not typeof 'string'
       *
       * @param {String} name The name of the variable being tested
       * @param {*} test The value to test
       * @exception {DeveloperError} test must be typeof 'string'
       */
      Check.typeOf.string = function (name, test) {
          if (typeof test !== 'string') {
              throw new DeveloperError(getFailedTypeErrorMessage(typeof test, 'string', name));
          }
      };
  
      /**
       * Throws if test is not typeof 'number'
       *
       * @param {String} name The name of the variable being tested
       * @param {*} test The value to test
       * @exception {DeveloperError} test must be typeof 'number'
       */
      Check.typeOf.number = function (name, test) {
          if (typeof test !== 'number') {
              throw new DeveloperError(getFailedTypeErrorMessage(typeof test, 'number', name));
          }
      };
  
      /**
       * Throws if test is not typeof 'number' and less than limit
       *
       * @param {String} name The name of the variable being tested
       * @param {*} test The value to test
       * @param {Number} limit The limit value to compare against
       * @exception {DeveloperError} test must be typeof 'number' and less than limit
       */
      Check.typeOf.number.lessThan = function (name, test, limit) {
          Check.typeOf.number(name, test);
          if (test >= limit) {
              throw new DeveloperError('Expected ' + name + ' to be less than ' + limit + ', actual value was ' + test);
          }
      };
  
      /**
       * Throws if test is not typeof 'number' and less than or equal to limit
       *
       * @param {String} name The name of the variable being tested
       * @param {*} test The value to test
       * @param {Number} limit The limit value to compare against
       * @exception {DeveloperError} test must be typeof 'number' and less than or equal to limit
       */
      Check.typeOf.number.lessThanOrEquals = function (name, test, limit) {
          Check.typeOf.number(name, test);
          if (test > limit) {
              throw new DeveloperError('Expected ' + name + ' to be less than or equal to ' + limit + ', actual value was ' + test);
          }
      };
  
      /**
       * Throws if test is not typeof 'number' and greater than limit
       *
       * @param {String} name The name of the variable being tested
       * @param {*} test The value to test
       * @param {Number} limit The limit value to compare against
       * @exception {DeveloperError} test must be typeof 'number' and greater than limit
       */
      Check.typeOf.number.greaterThan = function (name, test, limit) {
          Check.typeOf.number(name, test);
          if (test <= limit) {
              throw new DeveloperError('Expected ' + name + ' to be greater than ' + limit + ', actual value was ' + test);
          }
      };
  
      /**
       * Throws if test is not typeof 'number' and greater than or equal to limit
       *
       * @param {String} name The name of the variable being tested
       * @param {*} test The value to test
       * @param {Number} limit The limit value to compare against
       * @exception {DeveloperError} test must be typeof 'number' and greater than or equal to limit
       */
      Check.typeOf.number.greaterThanOrEquals = function (name, test, limit) {
          Check.typeOf.number(name, test);
          if (test < limit) {
              throw new DeveloperError('Expected ' + name + ' to be greater than or equal to' + limit + ', actual value was ' + test);
          }
      };
  
      /**
       * Throws if test is not typeof 'object'
       *
       * @param {String} name The name of the variable being tested
       * @param {*} test The value to test
       * @exception {DeveloperError} test must be typeof 'object'
       */
      Check.typeOf.object = function (name, test) {
          if (typeof test !== 'object') {
              throw new DeveloperError(getFailedTypeErrorMessage(typeof test, 'object', name));
          }
      };
  
      /**
       * Throws if test is not typeof 'boolean'
       *
       * @param {String} name The name of the variable being tested
       * @param {*} test The value to test
       * @exception {DeveloperError} test must be typeof 'boolean'
       */
      Check.typeOf.bool = function (name, test) {
          if (typeof test !== 'boolean') {
              throw new DeveloperError(getFailedTypeErrorMessage(typeof test, 'boolean', name));
          }
      };
  
      /**
       * Throws if test1 and test2 is not typeof 'number' and not equal in value
       *
       * @param {String} name1 The name of the first variable being tested
       * @param {String} name2 The name of the second variable being tested against
       * @param {*} test1 The value to test
       * @param {*} test2 The value to test against
       * @exception {DeveloperError} test1 and test2 should be type of 'number' and be equal in value
       */
      Check.typeOf.number.equals = function (name1, name2, test1, test2) {
          Check.typeOf.number(name1, test1);
          Check.typeOf.number(name2, test2);
          if (test1 !== test2) {
              throw new DeveloperError(name1 + ' must be equal to ' + name2 + ', the actual values are ' + test1 + ' and ' + test2);
          }
      };
  
      return Check;
  });
  