blackberry10/node_modules/jake/node_modules/utilities/test/string.js - cordova-blackberry - Git at Google

 /*
  * Utilities: A classic collection of JavaScript utilities
  * Copyright 2112 Matthew Eernisse (mde@fleegix.org)
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *         http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
 */

 var assert = require('assert')
   , string = require('../lib/string')
   , tests;

 tests = {

   'test basic escapeXML for string': function () {
     var expected = '&lt;html&gt;&lt;/html&gt;'
       , actual = string.escapeXML('<html></html>');
     assert.equal(expected, actual);
   }

 , 'test all escape characters for escapeXML': function () {
     var expected = '&lt;&gt;&amp;&quot;&#39;'
       , actual = string.escapeXML('<>&"\'');
     assert.equal(expected, actual);
   }

 , 'test no escape characters with string for escapeXML': function () {
     var expected = 'Geddy'
       , actual = string.escapeXML('Geddy');
     assert.equal(expected, actual);
   }

 , 'test no escape characters with numbers for escapeXML': function () {
     var expected = 05
       , actual = string.escapeXML(05);
     assert.equal(expected, actual);
   }

 , 'test basic unescapeXML for string': function () {
     var expected = '<html></html>'
       , actual = string.unescapeXML('&lt;html&gt;&lt;/html&gt;');
     assert.equal(expected, actual);
   }

 , 'test all escape characters for unescapeXML': function () {
     var expected = '<>&"\''
       , actual = string.unescapeXML('&lt;&gt;&amp;&quot;&#39;');
     assert.equal(expected, actual);
   }

 , 'test no escape characters with string for unescapeXML': function () {
     var expected = 'Geddy'
       , actual = string.unescapeXML('Geddy');
     assert.equal(expected, actual);
   }

 , 'test no escape characters with numbers for unescapeXML': function () {
     var expected = 05
       , actual = string.unescapeXML(05);
     assert.equal(expected, actual);
   }

 , 'test basic needsEscape for string': function () {
     var expected = true
       , actual = string.needsEscape('Geddy>');
     assert.equal(expected, actual);
   }

 , 'test basic needsEscape thats false for string': function () {
     var expected = false
       , actual = string.needsEscape('Geddy');
     assert.equal(expected, actual);
   }

 , 'test basic needsUnescape for string': function () {
     var expected = true
       , actual = string.needsEscape('&quot;Geddy&quot;');
     assert.equal(expected, actual);
   }

 , 'test basic needsUnescape thats false for string': function () {
     var expected = false
       , actual = string.needsEscape('Geddy');
     assert.equal(expected, actual);
   }

 ,  'test escapeRegExpCharacters': function () {
     var expected = '\\^\\/\\.\\*\\+\\?\\|\\(\\)\\[\\]\\{\\}\\\\'
       actual = string.escapeRegExpChars('^/.*+?|()[]{}\\');
     assert.equal(expected, actual);
   }

 , 'test toArray for string': function () {
     var data = string.toArray('geddy')
       , expected = ['g', 'e', 'd', 'd', 'y'];

     // Loop through each item and check
     // if not, then the arrays aren't _really_ the same
     var i = expected.length;
     while (--i >= 0) {
       assert.equal(expected[i], data[i]);
     }
   }

 , 'test reverse for string': function () {
     var data = string.reverse('yddeg')
       , expected = 'geddy';
     assert.equal(expected, data);
   }

 , 'test basic ltrim for string': function () {
     var data = string.ltrim('   geddy')
       , expected = 'geddy';
     assert.equal(expected, data);
   }

 , 'test custom char ltrim for string': function () {
     var data = string.ltrim('&&geddy', '&')
       , expected = 'geddy';
     assert.equal(expected, data);
   }

 , 'test basic rtrim for string': function () {
     var data = string.rtrim('geddy  ')
       , expected = 'geddy';
     assert.equal(expected, data);
   }

 , 'test custom char rtrim for string': function () {
     var data = string.rtrim('geddy&&', '&')
       , expected = 'geddy';
     assert.equal(expected, data);
   }

 , 'test basic trim for string': function () {
     var data = string.trim(' geddy  ')
       , expected = 'geddy';
     assert.equal(expected, data);
   }

 , 'test custom char trim for string': function () {
     var data = string.trim('&geddy&&', '&')
       , expected = 'geddy';
     assert.equal(expected, data);
   }

 , 'test chop special-case line-ending': function () {
     var expected = 'geddy'
       , actual = string.chop('geddy\r\n');
     assert.equal(expected, actual);
   }

 , 'test chop not actual special-case line-ending': function () {
     var expected = 'geddy\n'
       , actual = string.chop('geddy\n\r');
     assert.equal(expected, actual);
   }

 , 'test chop normal line-ending': function () {
     var expected = 'geddy'
       , actual = string.chop('geddy\n');
     assert.equal(expected, actual);
   }

 , 'test chop whatever character': function () {
     var expected = 'gedd'
       , actual = string.chop('geddy');
     assert.equal(expected, actual);
   }

 , 'test chop empty string': function () {
     var expected = ''
       , actual = string.chop('');
     assert.equal(expected, actual);
   }

 , 'test basic lpad for string': function () {
     var data = string.lpad('geddy', '&', 7)
       , expected = '&&geddy';
     assert.equal(expected, data);
   }

 , 'test lpad without width for string': function () {
     var data = string.lpad('geddy', '&')
       , expected = 'geddy';
     assert.equal(expected, data);
   }

 , 'test lpad without width of char for string': function () {
     var data = string.lpad('geddy')
       , expected = 'geddy';
     assert.equal(expected, data);
   }

 , 'test basic rpad for string': function () {
     var data = string.rpad('geddy', '&', 7)
       , expected = 'geddy&&';
     assert.equal(expected, data);
   }

 , 'test rpad without width for string': function () {
     var data = string.rpad('geddy', '&')
       , expected = 'geddy';
     assert.equal(expected, data);
   }

 , 'test rpad without width of char for string': function () {
     var data = string.rpad('geddy')
       , expected = 'geddy';
     assert.equal(expected, data);
   }

 , 'test basic pad for string': function () {
     var data = string.pad('geddy', '&', 7)
       , expected = '&geddy&';
     assert.equal(expected, data);
   }

 , 'test pad without width for string': function () {
     var data = string.pad('geddy', '&')
       , expected = 'geddy';
     assert.equal(expected, data);
   }

 , 'test pad without width of char for string': function () {
     var data = string.pad('geddy')
       , expected = 'geddy';
     assert.equal(expected, data);
   }

 , 'test single tags in truncateHTML': function () {
     var str = string.truncateHTML('<p>Once upon a time in a world</p>', { length: 10 });
     assert.equal(str, '<p>Once up...</p>');
   }

 , 'test multiple tags in truncateHTML': function () {
     var str = string.truncateHTML('<p>Once upon a time <small>in a world</small></p>', { length: 10 });
     assert.equal(str, '<p>Once up...<small>in a wo...</small></p>');
   }

 , 'test multiple tags but only truncate once in truncateHTML': function () {
     var str = string.truncateHTML('<p>Once upon a time <small>in a world</small></p>', { length: 10, once: true });
     assert.equal(str, '<p>Once up...<small>in a world</small></p>');
   }

 , 'test standard truncate': function () {
     var str = string.truncate('Once upon a time in a world', { length: 10 });
     assert.equal(str, 'Once up...');
   }

 , 'test custom omission in truncate': function () {
     var str = string.truncate('Once upon a time in a world', { length: 10, omission: '///' });
     assert.equal(str, 'Once up///');
   }

 , 'test regex seperator in truncate': function () {
     var str = string.truncate('Once upon a time in a world', { length: 15, seperator: /\s/ });
     assert.equal(str, 'Once upon a...');
   }

 , 'test string seperator in truncate': function () {
     var str = string.truncate('Once upon a time in a world', { length: 15, seperator: ' ' });
     assert.equal(str, 'Once upon a...');
   }

 , 'test unsafe html in truncate': function () {
     var str = string.truncate('<p>Once upon a time in a world</p>', { length: 20 });
     assert.equal(str, '<p>Once upon a ti...');
   }

 , 'test nl2br for string': function () {
     var data = string.nl2br("geddy\n")
       , expected = 'geddy<br />';
     assert.equal(expected, data);
   }

 , 'test snakeize for string': function () {
     var data = string.snakeize("geddyJs")
       , expected = 'geddy_js';
     assert.equal(expected, data);
   }

 , 'test snakeize with beginning caps for string': function () {
     var data = string.snakeize("GeddyJs")
       , expected = 'geddy_js';
     assert.equal(expected, data);
   }

 , 'test camelize for string': function () {
     var data = string.camelize("geddy_js")
       , expected = 'geddyJs';
     assert.equal(expected, data);
   }

 , 'test camelize with initialCap for string': function () {
     var data = string.camelize("geddy_js", {initialCap: true})
       , expected = 'GeddyJs';
     assert.equal(expected, data);
   }

 , 'test camelize with leadingUnderscore with no underscore for string': function () {
     var data = string.camelize("geddy_js", {leadingUnderscore: true})
       , expected = 'geddyJs';
     assert.equal(expected, data);
   }

 , 'test camelize with leadingUnderscore with underscore for string': function () {
     var data = string.camelize("_geddy_js", {leadingUnderscore: true})
       , expected = '_geddyJs';
     assert.equal(expected, data);
   }

 , 'test decapitalize for string': function () {
     var data = string.decapitalize("Geddy")
       , expected = 'geddy';
     assert.equal(expected, data);
   }

 , 'test capitalize for string': function () {
     var data = string.capitalize("geddy")
       , expected = 'Geddy';
     assert.equal(expected, data);
   }

 , 'test dasherize for string': function () {
     var data = string.dasherize("geddyJs")
       , expected = 'geddy-js';
     assert.equal(expected, data);
   }

 , 'test dasherize with custom replace char for string': function () {
     var data = string.dasherize("geddyJs", "_")
       , expected = 'geddy_js';
     assert.equal(expected, data);
   }

 , 'test underscorize for string': function () {
     var data = string.underscorize("geddyJs")
       , expected = 'geddy_js';
     assert.equal(expected, data);
   }

 , 'test include for string with included string': function () {
     assert.ok(string.include('foobarbaz', 'foo'));
   }

 , 'test include for string with not included string': function () {
     assert.ok(!string.include('foobarbaz', 'qux'));
   }

 , 'test getInflections for string': function () {
     var actual = string.getInflections("string")
       , expected = {
         filename: {
             singular: "string"
           , plural: "strings"
         },
         constructor: {
             singular: "String"
           , plural: "Strings"
         },
         property: {
             singular: "string"
           , plural: "strings"
         },
       };

     assert.deepEqual(expected, actual);
   }

 , 'test inflection with odd name for string': function () {
     var actual = string.getInflections("snow_dog")
       , expected = {
         filename: {
             singular: "snow_dog"
           , plural: "snow_dogs"
         },
         constructor: {
             singular: "SnowDog"
           , plural: "SnowDogs"
         },
         property: {
             singular: "snowDog"
           , plural: "snowDogs"
         },
       };

     assert.deepEqual(expected, actual);
   }

 , 'test uuid length for string': function () {
     var data = string.uuid(5).length
       , expected = 5;
     assert.equal(expected, data);
   }

 };

 module.exports = tests;
	/*
	* Utilities: A classic collection of JavaScript utilities
	* Copyright 2112 Matthew Eernisse (mde@fleegix.org)
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*
	*/

	var assert = require('assert')
	, string = require('../lib/string')
	, tests;

	tests = {

	'test basic escapeXML for string': function () {
	var expected = '<html></html>'
	, actual = string.escapeXML('<html></html>');
	assert.equal(expected, actual);
	}

	, 'test all escape characters for escapeXML': function () {
	var expected = '<>&"''
	, actual = string.escapeXML('<>&"\'');
	assert.equal(expected, actual);
	}

	, 'test no escape characters with string for escapeXML': function () {
	var expected = 'Geddy'
	, actual = string.escapeXML('Geddy');
	assert.equal(expected, actual);
	}

	, 'test no escape characters with numbers for escapeXML': function () {
	var expected = 05
	, actual = string.escapeXML(05);
	assert.equal(expected, actual);
	}

	, 'test basic unescapeXML for string': function () {
	var expected = '<html></html>'
	, actual = string.unescapeXML('<html></html>');
	assert.equal(expected, actual);
	}

	, 'test all escape characters for unescapeXML': function () {
	var expected = '<>&"\''
	, actual = string.unescapeXML('<>&"'');
	assert.equal(expected, actual);
	}

	, 'test no escape characters with string for unescapeXML': function () {
	var expected = 'Geddy'
	, actual = string.unescapeXML('Geddy');
	assert.equal(expected, actual);
	}

	, 'test no escape characters with numbers for unescapeXML': function () {
	var expected = 05
	, actual = string.unescapeXML(05);
	assert.equal(expected, actual);
	}

	, 'test basic needsEscape for string': function () {
	var expected = true
	, actual = string.needsEscape('Geddy>');
	assert.equal(expected, actual);
	}

	, 'test basic needsEscape thats false for string': function () {
	var expected = false
	, actual = string.needsEscape('Geddy');
	assert.equal(expected, actual);
	}

	, 'test basic needsUnescape for string': function () {
	var expected = true
	, actual = string.needsEscape('"Geddy"');
	assert.equal(expected, actual);
	}

	, 'test basic needsUnescape thats false for string': function () {
	var expected = false
	, actual = string.needsEscape('Geddy');
	assert.equal(expected, actual);
	}

	, 'test escapeRegExpCharacters': function () {
	var expected = '\\^\\/\\.\\*\\+\\?\\\|\\(\\)\\[\\]\\{\\}\\\\'
	actual = string.escapeRegExpChars('^/.*+?\|()[]{}\\');
	assert.equal(expected, actual);
	}

	, 'test toArray for string': function () {
	var data = string.toArray('geddy')
	, expected = ['g', 'e', 'd', 'd', 'y'];

	// Loop through each item and check
	// if not, then the arrays aren't _really_ the same
	var i = expected.length;
	while (--i >= 0) {
	assert.equal(expected[i], data[i]);
	}
	}

	, 'test reverse for string': function () {
	var data = string.reverse('yddeg')
	, expected = 'geddy';
	assert.equal(expected, data);
	}

	, 'test basic ltrim for string': function () {
	var data = string.ltrim(' geddy')
	, expected = 'geddy';
	assert.equal(expected, data);
	}

	, 'test custom char ltrim for string': function () {
	var data = string.ltrim('&&geddy', '&')
	, expected = 'geddy';
	assert.equal(expected, data);
	}

	, 'test basic rtrim for string': function () {
	var data = string.rtrim('geddy ')
	, expected = 'geddy';
	assert.equal(expected, data);
	}

	, 'test custom char rtrim for string': function () {
	var data = string.rtrim('geddy&&', '&')
	, expected = 'geddy';
	assert.equal(expected, data);
	}

	, 'test basic trim for string': function () {
	var data = string.trim(' geddy ')
	, expected = 'geddy';
	assert.equal(expected, data);
	}

	, 'test custom char trim for string': function () {
	var data = string.trim('&geddy&&', '&')
	, expected = 'geddy';
	assert.equal(expected, data);
	}

	, 'test chop special-case line-ending': function () {
	var expected = 'geddy'
	, actual = string.chop('geddy\r\n');
	assert.equal(expected, actual);
	}

	, 'test chop not actual special-case line-ending': function () {
	var expected = 'geddy\n'
	, actual = string.chop('geddy\n\r');
	assert.equal(expected, actual);
	}

	, 'test chop normal line-ending': function () {
	var expected = 'geddy'
	, actual = string.chop('geddy\n');
	assert.equal(expected, actual);
	}

	, 'test chop whatever character': function () {
	var expected = 'gedd'
	, actual = string.chop('geddy');
	assert.equal(expected, actual);
	}

	, 'test chop empty string': function () {
	var expected = ''
	, actual = string.chop('');
	assert.equal(expected, actual);
	}

	, 'test basic lpad for string': function () {
	var data = string.lpad('geddy', '&', 7)
	, expected = '&&geddy';
	assert.equal(expected, data);
	}

	, 'test lpad without width for string': function () {
	var data = string.lpad('geddy', '&')
	, expected = 'geddy';
	assert.equal(expected, data);
	}

	, 'test lpad without width of char for string': function () {
	var data = string.lpad('geddy')
	, expected = 'geddy';
	assert.equal(expected, data);
	}

	, 'test basic rpad for string': function () {
	var data = string.rpad('geddy', '&', 7)
	, expected = 'geddy&&';
	assert.equal(expected, data);
	}

	, 'test rpad without width for string': function () {
	var data = string.rpad('geddy', '&')
	, expected = 'geddy';
	assert.equal(expected, data);
	}

	, 'test rpad without width of char for string': function () {
	var data = string.rpad('geddy')
	, expected = 'geddy';
	assert.equal(expected, data);
	}

	, 'test basic pad for string': function () {
	var data = string.pad('geddy', '&', 7)
	, expected = '&geddy&';
	assert.equal(expected, data);
	}

	, 'test pad without width for string': function () {
	var data = string.pad('geddy', '&')
	, expected = 'geddy';
	assert.equal(expected, data);
	}

	, 'test pad without width of char for string': function () {
	var data = string.pad('geddy')
	, expected = 'geddy';
	assert.equal(expected, data);
	}

	, 'test single tags in truncateHTML': function () {
	var str = string.truncateHTML('<p>Once upon a time in a world</p>', { length: 10 });
	assert.equal(str, '<p>Once up...</p>');
	}

	, 'test multiple tags in truncateHTML': function () {
	var str = string.truncateHTML('<p>Once upon a time <small>in a world</small></p>', { length: 10 });
	assert.equal(str, '<p>Once up...<small>in a wo...</small></p>');
	}

	, 'test multiple tags but only truncate once in truncateHTML': function () {
	var str = string.truncateHTML('<p>Once upon a time <small>in a world</small></p>', { length: 10, once: true });
	assert.equal(str, '<p>Once up...<small>in a world</small></p>');
	}

	, 'test standard truncate': function () {
	var str = string.truncate('Once upon a time in a world', { length: 10 });
	assert.equal(str, 'Once up...');
	}

	, 'test custom omission in truncate': function () {
	var str = string.truncate('Once upon a time in a world', { length: 10, omission: '///' });
	assert.equal(str, 'Once up///');
	}

	, 'test regex seperator in truncate': function () {
	var str = string.truncate('Once upon a time in a world', { length: 15, seperator: /\s/ });
	assert.equal(str, 'Once upon a...');
	}

	, 'test string seperator in truncate': function () {
	var str = string.truncate('Once upon a time in a world', { length: 15, seperator: ' ' });
	assert.equal(str, 'Once upon a...');
	}

	, 'test unsafe html in truncate': function () {
	var str = string.truncate('<p>Once upon a time in a world</p>', { length: 20 });
	assert.equal(str, '<p>Once upon a ti...');
	}

	, 'test nl2br for string': function () {
	var data = string.nl2br("geddy\n")
	, expected = 'geddy<br />';
	assert.equal(expected, data);
	}

	, 'test snakeize for string': function () {
	var data = string.snakeize("geddyJs")
	, expected = 'geddy_js';
	assert.equal(expected, data);
	}

	, 'test snakeize with beginning caps for string': function () {
	var data = string.snakeize("GeddyJs")
	, expected = 'geddy_js';
	assert.equal(expected, data);
	}

	, 'test camelize for string': function () {
	var data = string.camelize("geddy_js")
	, expected = 'geddyJs';
	assert.equal(expected, data);
	}

	, 'test camelize with initialCap for string': function () {
	var data = string.camelize("geddy_js", {initialCap: true})
	, expected = 'GeddyJs';
	assert.equal(expected, data);
	}

	, 'test camelize with leadingUnderscore with no underscore for string': function () {
	var data = string.camelize("geddy_js", {leadingUnderscore: true})
	, expected = 'geddyJs';
	assert.equal(expected, data);
	}

	, 'test camelize with leadingUnderscore with underscore for string': function () {
	var data = string.camelize("_geddy_js", {leadingUnderscore: true})
	, expected = '_geddyJs';
	assert.equal(expected, data);
	}

	, 'test decapitalize for string': function () {
	var data = string.decapitalize("Geddy")
	, expected = 'geddy';
	assert.equal(expected, data);
	}

	, 'test capitalize for string': function () {
	var data = string.capitalize("geddy")
	, expected = 'Geddy';
	assert.equal(expected, data);
	}

	, 'test dasherize for string': function () {
	var data = string.dasherize("geddyJs")
	, expected = 'geddy-js';
	assert.equal(expected, data);
	}

	, 'test dasherize with custom replace char for string': function () {
	var data = string.dasherize("geddyJs", "_")
	, expected = 'geddy_js';
	assert.equal(expected, data);
	}

	, 'test underscorize for string': function () {
	var data = string.underscorize("geddyJs")
	, expected = 'geddy_js';
	assert.equal(expected, data);
	}

	, 'test include for string with included string': function () {
	assert.ok(string.include('foobarbaz', 'foo'));
	}

	, 'test include for string with not included string': function () {
	assert.ok(!string.include('foobarbaz', 'qux'));
	}

	, 'test getInflections for string': function () {
	var actual = string.getInflections("string")
	, expected = {
	filename: {
	singular: "string"
	, plural: "strings"
	},
	constructor: {
	singular: "String"
	, plural: "Strings"
	},
	property: {
	singular: "string"
	, plural: "strings"
	},
	};

	assert.deepEqual(expected, actual);
	}

	, 'test inflection with odd name for string': function () {
	var actual = string.getInflections("snow_dog")
	, expected = {
	filename: {
	singular: "snow_dog"
	, plural: "snow_dogs"
	},
	constructor: {
	singular: "SnowDog"
	, plural: "SnowDogs"
	},
	property: {
	singular: "snowDog"
	, plural: "snowDogs"
	},
	};

	assert.deepEqual(expected, actual);
	}

	, 'test uuid length for string': function () {
	var data = string.uuid(5).length
	, expected = 5;
	assert.equal(expected, data);
	}

	};

	module.exports = tests;