text: /* global describe, it, require */
  'use strict';
  
  // MODULES //
  
  var // Expectation library:
  	chai = require( 'chai' ),
  
  	// Module to be tested:
  	validate = require( './../lib/validate.js' );
  
  
  // VARIABLES //
  
  var expect = chai.expect,
  	assert = chai.assert;
  
  
  // TESTS //
  
  describe( 'validate', function tests() {
  
  	it( 'should export a function', function test() {
  		expect( validate ).to.be.a( 'function' );
  	});
  
  	it( 'should return an error if provided an options argument which is not an object', function test() {
  		var values = [
  			'5',
  			5,
  			true,
  			undefined,
  			null,
  			NaN,
  			function(){},
  			[]
  		];
  
  		for ( var i = 0; i < values.length; i++ ) {
  			assert.isTrue( validate( {}, values[ i ] ) instanceof TypeError );
  		}
  	});
  
  	it( 'should return an error if provided a `n` parameter which is not a non-negative integer', function test() {
  		var values, err;
  		 values = [
  			-2,
  			2.5,
  			'5',
  			[],
  			true,
  			undefined,
  			null,
  			NaN,
  			function(){},
  			{}
  		];
  
  		for ( var i = 0; i < values.length; i++ ) {
  			err = validate( {}, {
  				'n': values[ i ]
  			});
  			assert.isTrue( err instanceof TypeError );
  		}
  	});
  
  	it( 'should return an error if provided a `p` parameter which is not a number between 0 and 1', function test() {
  		var values, err;
  		 values = [
  			-2,
  			2,
  			'5',
  			[],
  			true,
  			undefined,
  			null,
  			NaN,
  			function(){},
  			{}
  		];
  
  		for ( var i = 0; i < values.length; i++ ) {
  			err = validate( {}, {
  				'p': values[ i ]
  			});
  			assert.isTrue( err instanceof TypeError );
  		}
  	});
  
  	it( 'should return an error if provided an accessor which is not a function', function test() {
  		var values, err;
  
  		values = [
  			'5',
  			5,
  			true,
  			undefined,
  			null,
  			NaN,
  			[],
  			{}
  		];
  
  		for ( var i = 0; i < values.length; i++ ) {
  			err = validate( {}, {
  				'accessor': values[ i ]
  			});
  			assert.isTrue( err instanceof TypeError );
  		}
  	});
  
  	it( 'should return an error if provided a copy option which is not a boolean primitive', function test() {
  		var values, err;
  
  		values = [
  			'5',
  			5,
  			new Boolean( true ),
  			undefined,
  			null,
  			NaN,
  			[],
  			{},
  			function(){}
  		];
  
  		for ( var i = 0; i < values.length; i++ ) {
  			err = validate( {}, {
  				'copy': values[ i ]
  			});
  			assert.isTrue( err instanceof TypeError );
  		}
  	});
  
  	it( 'should return an error if provided a path option which is not a string primitive', function test() {
  		var values, err;
  
  		values = [
  			5,
  			true,
  			undefined,
  			null,
  			NaN,
  			[],
  			{},
  			function(){}
  		];
  
  		for ( var i = 0; i < values.length; i++ ) {
  			err = validate( {}, {
  				'path': values[ i ]
  			});
  			assert.isTrue( err instanceof TypeError );
  		}
  	});
  
  	it( 'should return an error if provided a separator option which is not a string primitive', function test() {
  		var values, err;
  
  		values = [
  			5,
  			true,
  			undefined,
  			null,
  			NaN,
  			[],
  			{},
  			function(){}
  		];
  
  		for ( var i = 0; i < values.length; i++ ) {
  			err = validate( {}, {
  				'sep': values[ i ]
  			});
  			assert.isTrue( err instanceof TypeError );
  		}
  	});
  
  	it( 'should return an error if provided a dtype option which is not a string primitive', function test() {
  		var values, err;
  
  		values = [
  			5,
  			true,
  			undefined,
  			null,
  			NaN,
  			[],
  			{},
  			function(){}
  		];
  
  		for ( var i = 0; i < values.length; i++ ) {
  			err = validate( {}, {
  				'dtype': values[ i ]
  			});
  			assert.isTrue( err instanceof TypeError );
  		}
  	});
  
  	it( 'should return null if all options are valid', function test() {
  		var err;
  
  		err = validate( {}, {
  			'n': 1,
  			'p': 0.5,
  			'accessor': function getValue(){},
  			'copy': false,
  			'deepset': true,
  			'path': 'x/y',
  			'sep': '/',
  			'dtype': 'int32'
  		});
  
  		assert.isNull( err );
  
  		err = validate( {}, {
  			'beep': true, // misc options
  			'boop': 'bop'
  		});
  
  		assert.isNull( err );
  	});
  
  });
  