Merge branch 'add-toCurrency' of https://github.com/Chalarangelo/30-seconds-of-code into add-toCurrency

test/anagrams/anagrams.test.js

@@ -6,9 +6,11 @@ test('Testing anagrams', (t) => {
   //Please go to https://github.com/substack/tape
   t.true(typeof anagrams === 'function', 'anagrams is a Function');
   t.deepEqual(anagrams('abc'), ['abc','acb','bac','bca','cab','cba'], "Generates all anagrams of a string");
+  t.deepEqual(anagrams('a'), ['a'], "Works for single-letter strings");
+  t.deepEqual(anagrams(''), [''], "Works for empty strings");
   //t.deepEqual(anagrams(args..), 'Expected');
   //t.equal(anagrams(args..), 'Expected');
   //t.false(anagrams(args..), 'Expected');
   //t.throws(anagrams(args..), 'Expected');
   t.end();
-});
+});

test/ary/ary.test.js

@@ -5,9 +5,11 @@ test('Testing ary', (t) => {
   //For more information on all the methods supported by tape
   //Please go to https://github.com/substack/tape
   t.true(typeof ary === 'function', 'ary is a Function');
+  const firstTwoMax = ary(Math.max, 2);
+  t.deepEquals([[2, 6, 'a'], [8, 4, 6], [10]].map(x => firstTwoMax(...x)), [6, 8, 10], 'Discards arguments with index >=n')
   //t.deepEqual(ary(args..), 'Expected');
   //t.equal(ary(args..), 'Expected');
   //t.false(ary(args..), 'Expected');
   //t.throws(ary(args..), 'Expected');
   t.end();
-});
+});

test/attempt/attempt.js

@@ -0,0 +1,8 @@
+const attempt = (fn, ...args) => {
+try {
+return fn(args);
+} catch (e) {
+return e instanceof Error ? e : new Error(e);
+}
+};
+module.exports = attempt

test/attempt/attempt.test.js

@@ -0,0 +1,15 @@
+const test = require('tape');
+const attempt = require('./attempt.js');
+
+test('Testing attempt', (t) => {
+  //For more information on all the methods supported by tape
+  //Please go to https://github.com/substack/tape
+  t.true(typeof attempt === 'function', 'attempt is a Function');
+  t.equals(attempt(() => 0), 0, 'Returns a value');
+  t.true(attempt(() => {throw new Error()}) instanceof Error, 'Returns an error');
+  //t.deepEqual(attempt(args..), 'Expected');
+  //t.equal(attempt(args..), 'Expected');
+  //t.false(attempt(args..), 'Expected');
+  //t.throws(attempt(args..), 'Expected');
+  t.end();
+});

test/bind/bind.test.js

@@ -5,9 +5,15 @@ test('Testing bind', (t) => {
   //For more information on all the methods supported by tape
   //Please go to https://github.com/substack/tape
   t.true(typeof bind === 'function', 'bind is a Function');
+  function greet(greeting, punctuation) {
+    return greeting + ' ' + this.user + punctuation;
+  }
+  const freddy = { user: 'fred' };
+  const freddyBound = bind(greet, freddy);
+  t.equals(freddyBound('hi', '!'),'hi fred!', 'Binds to an object context');
   //t.deepEqual(bind(args..), 'Expected');
   //t.equal(bind(args..), 'Expected');
   //t.false(bind(args..), 'Expected');
   //t.throws(bind(args..), 'Expected');
   t.end();
-});
+});

test/bindAll/bindAll.js

@@ -1,8 +1,10 @@
 const bindAll = (obj, ...fns) =>
 fns.forEach(
-fn =>
+fn => (
+(f = obj[fn]),
 (obj[fn] = function() {
-return fn.apply(obj);
+return f.apply(obj);
 })
+)
 );
 module.exports = bindAll

test/bindAll/bindAll.test.js

@@ -5,9 +5,17 @@ test('Testing bindAll', (t) => {
   //For more information on all the methods supported by tape
   //Please go to https://github.com/substack/tape
   t.true(typeof bindAll === 'function', 'bindAll is a Function');
+  var view = {
+    label: 'docs',
+    'click': function() {
+      return 'clicked ' + this.label;
+    }
+  }
+  bindAll(view, 'click');
+  t.equal(view.click(), 'clicked docs', 'Binds to an object context')
   //t.deepEqual(bindAll(args..), 'Expected');
   //t.equal(bindAll(args..), 'Expected');
   //t.false(bindAll(args..), 'Expected');
   //t.throws(bindAll(args..), 'Expected');
   t.end();
-});
+});

test/bindKey/bindKey.test.js

@@ -5,9 +5,17 @@ test('Testing bindKey', (t) => {
   //For more information on all the methods supported by tape
   //Please go to https://github.com/substack/tape
   t.true(typeof bindKey === 'function', 'bindKey is a Function');
+  const freddy = {
+    user: 'fred',
+    greet: function(greeting, punctuation) {
+      return greeting + ' ' + this.user + punctuation;
+    }
+  };
+  const freddyBound = bindKey(freddy, 'greet');
+  t.equal(freddyBound('hi', '!'), 'hi fred!', 'Binds function to an object context');
   //t.deepEqual(bindKey(args..), 'Expected');
   //t.equal(bindKey(args..), 'Expected');
   //t.false(bindKey(args..), 'Expected');
   //t.throws(bindKey(args..), 'Expected');
   t.end();
-});
+});

test/byteSize/byteSize.test.js

@@ -5,6 +5,9 @@ test('Testing byteSize', (t) => {
   //For more information on all the methods supported by tape
   //Please go to https://github.com/substack/tape
   t.true(typeof byteSize === 'function', 'byteSize is a Function');
+  // Blob is not part of Node apparently?
+  //t.equal(byteSize('Hello World'), 11, 'Works for text');
+  //t.equal(byteSize('😀'), 4, 'Works for emojis');
   // Works only in browser
   // t.equal(byteSize('Hello World'), 11, "Returns the length of a string in bytes");
   //t.deepEqual(byteSize(args..), 'Expected');
@@ -12,4 +15,4 @@ test('Testing byteSize', (t) => {
   //t.false(byteSize(args..), 'Expected');
   //t.throws(byteSize(args..), 'Expected');
   t.end();
-});
+});

test/collectInto/collectInto.test.js

@@ -5,9 +5,14 @@ test('Testing collectInto', (t) => {
   //For more information on all the methods supported by tape
   //Please go to https://github.com/substack/tape
   t.true(typeof collectInto === 'function', 'collectInto is a Function');
+  const Pall = collectInto(Promise.all.bind(Promise));
+  let p1 = Promise.resolve(1);
+  let p2 = Promise.resolve(2);
+  let p3 = new Promise(resolve => setTimeout(resolve, 2000, 3));
+  Pall(p1, p2, p3).then(function(val){ t.deepEqual(val, [1,2,3], 'Works with multiple promises')}, function(reason){});
   //t.deepEqual(collectInto(args..), 'Expected');
   //t.equal(collectInto(args..), 'Expected');
   //t.false(collectInto(args..), 'Expected');
   //t.throws(collectInto(args..), 'Expected');
   t.end();
-});
+});

test/countBy/countBy.test.js

@@ -5,9 +5,11 @@ test('Testing countBy', (t) => {
   //For more information on all the methods supported by tape
   //Please go to https://github.com/substack/tape
   t.true(typeof countBy === 'function', 'countBy is a Function');
+  t.deepEqual(countBy([6.1, 4.2, 6.3], Math.floor), {4: 1, 6: 2}, 'Works for functions');
+  t.deepEqual(countBy(['one', 'two', 'three'], 'length'), {3: 2, 5: 1}, 'Works for property names');
   //t.deepEqual(countBy(args..), 'Expected');
   //t.equal(countBy(args..), 'Expected');
   //t.false(countBy(args..), 'Expected');
   //t.throws(countBy(args..), 'Expected');
   t.end();
-});
+});

test/debounce/debounce.js

@@ -0,0 +1,10 @@
+const debounce = (fn, wait = 0) => {
+let inDebounce;
+return function() {
+const context = this,
+args = arguments;
+clearTimeout(inDebounce);
+inDebounce = setTimeout(() => fn.apply(context, args), wait);
+};
+};
+module.exports = debounce

test/debounce/debounce.test.js

@@ -0,0 +1,13 @@
+const test = require('tape');
+const debounce = require('./debounce.js');
+
+test('Testing debounce', (t) => {
+  //For more information on all the methods supported by tape
+  //Please go to https://github.com/substack/tape
+  t.true(typeof debounce === 'function', 'debounce is a Function');
+  //t.deepEqual(debounce(args..), 'Expected');
+  //t.equal(debounce(args..), 'Expected');
+  //t.false(debounce(args..), 'Expected');
+  //t.throws(debounce(args..), 'Expected');
+  t.end();
+});

test/decapitalize/decapitalize.test.js

@@ -5,9 +5,11 @@ test('Testing decapitalize', (t) => {
   //For more information on all the methods supported by tape
   //Please go to https://github.com/substack/tape
   t.true(typeof decapitalize === 'function', 'decapitalize is a Function');
+  t.equal(decapitalize('FooBar'), 'fooBar', 'Works with default parameter');
+  t.equal(decapitalize('FooBar', true), 'fOOBAR', 'Works with second parameter set to true');
   //t.deepEqual(decapitalize(args..), 'Expected');
   //t.equal(decapitalize(args..), 'Expected');
   //t.false(decapitalize(args..), 'Expected');
   //t.throws(decapitalize(args..), 'Expected');
   t.end();
-});
+});

test/dropWhile/dropWhile.test.js

@@ -10,4 +10,4 @@ test('Testing dropWhile', (t) => {
   //t.false(dropWhile(args..), 'Expected');
   //t.throws(dropWhile(args..), 'Expected');
   t.end();
-});
+});

test/overArgs/overArgs.js

@@ -0,0 +1,2 @@
+const overArgs = (fn, transforms) => (...args) => fn(...args.map((val, i) => transforms[i](val)));
+module.exports = overArgs

test/overArgs/overArgs.test.js

@@ -0,0 +1,13 @@
+const test = require('tape');
+const overArgs = require('./overArgs.js');
+
+test('Testing overArgs', (t) => {
+  //For more information on all the methods supported by tape
+  //Please go to https://github.com/substack/tape
+  t.true(typeof overArgs === 'function', 'overArgs is a Function');
+  //t.deepEqual(overArgs(args..), 'Expected');
+  //t.equal(overArgs(args..), 'Expected');
+  //t.false(overArgs(args..), 'Expected');
+  //t.throws(overArgs(args..), 'Expected');
+  t.end();
+});

test/pipeAsyncFunctions/pipeAsyncFunctions.js

@@ -0,0 +1,2 @@
+const pipeAsyncFunctions = (...fns) => arg => fns.reduce((p, f) => p.then(f), Promise.resolve(arg));
+module.exports = pipeAsyncFunctions

test/pipeAsyncFunctions/pipeAsyncFunctions.test.js

@@ -0,0 +1,24 @@
+const test = require('tape');
+const pipeAsyncFunctions = require('./pipeAsyncFunctions.js');
+
+test('Testing pipeAsyncFunctions', async (t) => {
+  //For more information on all the methods supported by tape
+  //Please go to https://github.com/substack/tape
+  t.true(typeof pipeAsyncFunctions === 'function', 'pipeAsyncFunctions is a Function');
+  //t.deepEqual(pipeAsyncFunctions(args..), 'Expected');
+  //t.equal(pipeAsyncFunctions(args..), 'Expected');
+  //t.false(pipeAsyncFunctions(args..), 'Expected');
+  //t.throws(pipeAsyncFunctions(args..), 'Expected');
+  t.equal(
+    await pipeAsyncFunctions(
+      (x) => x + 1,
+      (x) => new Promise((resolve) => setTimeout(() => resolve(x + 2), 0)),
+      (x) => x + 3,
+      async (x) => await x + 4,
+    )
+    (5),
+    15,
+    'pipeAsyncFunctions result should be 15'
+  );
+  t.end();
+});

test/rearg/rearg.js

@@ -0,0 +1,8 @@
+const rearg = (fn, indexes) => (...args) =>
+fn(
+...args.reduce(
+(acc, val, i) => ((acc[indexes.indexOf(i)] = val), acc),
+Array.from({ length: indexes.length })
+)
+);
+module.exports = rearg

test/rearg/rearg.test.js

@@ -0,0 +1,13 @@
+const test = require('tape');
+const rearg = require('./rearg.js');
+
+test('Testing rearg', (t) => {
+  //For more information on all the methods supported by tape
+  //Please go to https://github.com/substack/tape
+  t.true(typeof rearg === 'function', 'rearg is a Function');
+  //t.deepEqual(rearg(args..), 'Expected');
+  //t.equal(rearg(args..), 'Expected');
+  //t.false(rearg(args..), 'Expected');
+  //t.throws(rearg(args..), 'Expected');
+  t.end();
+});

test/round/round.test.js

@@ -5,9 +5,19 @@ test('Testing round', (t) => {
   //For more information on all the methods supported by tape
   //Please go to https://github.com/substack/tape
   t.true(typeof round === 'function', 'round is a Function');
-  t.equal(round(1.005, 2), 1.01, "Rounds a number to a specified amount of digits.");
-  //t.equal(round(args..), 'Expected');
-  //t.false(round(args..), 'Expected');
-  //t.throws(round(args..), 'Expected');
+  t.equal(round(1.005, 2), 1.01, "round(1.005, 2) returns 1.01");
+  t.equal(round(123.3423345345345345344, 11), 123.34233453453, "round(123.3423345345345345344, 11) returns 123.34233453453");
+  t.equal(round(3.342, 11), 3.342, "round(3.342, 11) returns 3.342");
+  t.equal(round(1.005), 1, "round(1.005) returns 1");
+  t.true(isNaN(round([1.005, 2])), 'round([1.005, 2]) returns NaN');
+  t.true(isNaN(round('string')), 'round(string) returns NaN');
+  t.true(isNaN(round()), 'round() returns NaN');
+  t.true(isNaN(round(132, 413, 4134)), 'round(132, 413, 4134) returns NaN');
+  t.true(isNaN(round({a: 132}, 413)), 'round({a: 132}, 413) returns NaN');
+
+  let start = new Date().getTime();
+  round(123.3423345345345345344, 11);
+  let end = new Date().getTime();
+  t.true((end - start) < 2000, 'round(123.3423345345345345344, 11) takes less than 2s to run');
   t.end();
-});
+});

test/throttle/throttle.js

@@ -0,0 +1,21 @@
+const throttle = (fn, wait) => {
+let inThrottle, lastFn, lastTime;
+return function() {
+const context = this,
+args = arguments;
+if (!inThrottle) {
+fn.apply(context, args);
+lastTime = Date.now();
+inThrottle = true;
+} else {
+clearTimeout(lastFn);
+lastFn = setTimeout(function() {
+if (Date.now() - lastTime >= wait) {
+fn.apply(context, args);
+lastTime = Date.now();
+}
+}, wait - (Date.now() - lastTime));
+}
+};
+};
+module.exports = throttle

test/throttle/throttle.test.js

@@ -0,0 +1,13 @@
+const test = require('tape');
+const throttle = require('./throttle.js');
+
+test('Testing throttle', (t) => {
+  //For more information on all the methods supported by tape
+  //Please go to https://github.com/substack/tape
+  t.true(typeof throttle === 'function', 'throttle is a Function');
+  //t.deepEqual(throttle(args..), 'Expected');
+  //t.equal(throttle(args..), 'Expected');
+  //t.false(throttle(args..), 'Expected');
+  //t.throws(throttle(args..), 'Expected');
+  t.end();
+});

test/toCamelCase/toCamelCase.test.js

@@ -5,13 +5,18 @@ test('Testing toCamelCase', (t) => {
   //For more information on all the methods supported by tape
   //Please go to https://github.com/substack/tape
   t.true(typeof toCamelCase === 'function', 'toCamelCase is a Function');
-  t.equal(toCamelCase('some_database_field_name'), 'someDatabaseFieldName', "Converts a string to camelCase");
-  t.equal(toCamelCase('Some label that needs to be camelized'), 'someLabelThatNeedsToBeCamelized', "Converts a string to camelCase");
-  t.equal(toCamelCase('some-javascript-property'), 'someJavascriptProperty', "Converts a string to camelCase");
-  t.equal(toCamelCase('some-mixed_string with spaces_underscores-and-hyphens'), 'someMixedStringWithSpacesUnderscoresAndHyphens', "Converts a string to camelCase");
-  //t.deepEqual(toCamelCase(args..), 'Expected');
-  //t.equal(toCamelCase(args..), 'Expected');
-  //t.false(toCamelCase(args..), 'Expected');
-  //t.throws(toCamelCase(args..), 'Expected');
+  t.equal(toCamelCase('some_database_field_name'), 'someDatabaseFieldName', "toCamelCase('some_database_field_name') returns someDatabaseFieldName");
+  t.equal(toCamelCase('Some label that needs to be camelized'), 'someLabelThatNeedsToBeCamelized', "toCamelCase('Some label that needs to be camelized') returns someLabelThatNeedsToBeCamelized");
+  t.equal(toCamelCase('some-javascript-property'), 'someJavascriptProperty', "toCamelCase('some-javascript-property') return someJavascriptProperty");
+  t.equal(toCamelCase('some-mixed_string with spaces_underscores-and-hyphens'), 'someMixedStringWithSpacesUnderscoresAndHyphens', "toCamelCase('some-mixed_string with spaces_underscores-and-hyphens') returns someMixedStringWithSpacesUnderscoresAndHyphens");
+  t.throws(() => toCamelCase(), 'toCamelCase() throws a error');
+  t.throws(() => toCamelCase([]), 'toCamelCase([]) throws a error');
+  t.throws(() => toCamelCase({}), 'toCamelCase({}) throws a error');
+  t.throws(() => toCamelCase(123), 'toCamelCase(123) throws a error');
+
+  let start = new Date().getTime();
+  toCamelCase('some-mixed_string with spaces_underscores-and-hyphens');
+  let end = new Date().getTime();
+  t.true((end - start) < 2000, 'toCamelCase(some-mixed_string with spaces_underscores-and-hyphens) takes less than 2s to run');
   t.end();
-});
+});

test/toKebabCase/toKebabCase.test.js

@@ -5,13 +5,18 @@ test('Testing toKebabCase', (t) => {
   //For more information on all the methods supported by tape
   //Please go to https://github.com/substack/tape
   t.true(typeof toKebabCase === 'function', 'toKebabCase is a Function');
-  t.equal(toKebabCase('camelCase'), 'camel-case', "string converts to snake case");
-  t.equal(toKebabCase('some text'), 'some-text', "string converts to snake case");
-  t.equal(toKebabCase('some-mixed-string With spaces-underscores-and-hyphens'), 'some-mixed-string-with-spaces-underscores-and-hyphens', "string converts to snake case");
-  t.equal(toKebabCase('IAmListeningToFMWhileLoadingDifferentURLOnMyBrowserAndAlsoEditingSomeXMLAndHTML'), 'i-am-listening-to-fm-while-loading-different-url-on-my-browser-and-also-editing-some-xml-and-html', "string converts to snake case");
-  //t.deepEqual(toKebabCase(args..), 'Expected');
-  //t.equal(toKebabCase(args..), 'Expected');
-  //t.false(toKebabCase(args..), 'Expected');
-  //t.throws(toKebabCase(args..), 'Expected');
+  t.equal(toKebabCase('camelCase'), 'camel-case', "toKebabCase('camelCase') returns camel-case");
+  t.equal(toKebabCase('some text'), 'some-text', "toKebabCase('some text') returns some-text");
+  t.equal(toKebabCase('some-mixed-string With spaces-underscores-and-hyphens'), 'some-mixed-string-with-spaces-underscores-and-hyphens', "toKebabCase('some-mixed-string With spaces-underscores-and-hyphens') returns some-mixed-string-with-spaces-underscores-and-hyphens");
+  t.equal(toKebabCase('IAmListeningToFMWhileLoadingDifferentURLOnMyBrowserAndAlsoEditingSomeXMLAndHTML'), 'i-am-listening-to-fm-while-loading-different-url-on-my-browser-and-also-editing-some-xml-and-html', "toKebabCase('IAmListeningToFMWhileLoadingDifferentURLOnMyBrowserAndAlsoEditingSomeXMLAndHTML') returns i-am-listening-to-fm-while-loading-different-url-on-my-browser-and-also-editing-some-xml-and-html");
+  t.equal(toKebabCase(), undefined, 'toKebabCase() return undefined');
+  t.throws(() => toKebabCase([]), 'toKebabCase([]) throws an error');
+  t.throws(() => toKebabCase({}), 'toKebabCase({}) throws an error');
+  t.throws(() => toKebabCase(123), 'toKebabCase(123) throws an error');
+
+  let start = new Date().getTime();
+  toKebabCase('IAmListeningToFMWhileLoadingDifferentURLOnMyBrowserAndAlsoEditingSomeXMLAndHTML')
+  let end = new Date().getTime();
+  t.true((end - start) < 2000, 'toKebabCase(IAmListeningToFMWhileLoadingDifferentURLOnMyBrowserAndAlsoEditingSomeXMLAndHTML) takes less than 2s to run');
   t.end();
-});
+});

test/toSafeInteger/toSafeInteger.test.js

@@ -5,14 +5,20 @@ test('Testing toSafeInteger', (t) => {
   //For more information on all the methods supported by tape
   //Please go to https://github.com/substack/tape
   t.true(typeof toSafeInteger === 'function', 'toSafeInteger is a Function');
+  t.true(Number(toSafeInteger(3.2)), 'Number(toSafeInteger(3.2)) is a number');
   t.equal(toSafeInteger(3.2), 3, "Converts a value to a safe integer");
-  t.equal(toSafeInteger('4.2'), 4, "Converts a value to a safe integer");
-  t.equal(toSafeInteger(4.6), 5, "Converts a value to a safe integer");
-  t.equal(toSafeInteger(1.5), 2, "Converts a value to a safe integer");
-  t.equal(toSafeInteger(Infinity), 9007199254740991, "Converts a value to a safe integer");
-  //t.deepEqual(toSafeInteger(args..), 'Expected');
-  //t.equal(toSafeInteger(args..), 'Expected');
-  //t.false(toSafeInteger(args..), 'Expected');
-  //t.throws(toSafeInteger(args..), 'Expected');
+  t.equal(toSafeInteger('4.2'), 4, "toSafeInteger('4.2') returns 4");
+  t.equal(toSafeInteger(4.6), 5, "toSafeInteger(4.6) returns 5");
+  t.equal(toSafeInteger([]), 0, "toSafeInteger([]) returns 0");
+  t.true(isNaN(toSafeInteger([1.5, 3124])), "isNaN(toSafeInteger([1.5, 3124])) is true");
+  t.true(isNaN(toSafeInteger('string')), "isNaN(toSafeInteger('string')) is true");
+  t.true(isNaN(toSafeInteger({})), "isNaN(toSafeInteger({})) is true");
+  t.true(isNaN(toSafeInteger()), "isNaN(toSafeInteger()) is true");
+  t.equal(toSafeInteger(Infinity), 9007199254740991, "toSafeInteger(Infinity) returns 9007199254740991");
+
+  let start = new Date().getTime();
+  toSafeInteger(3.2);
+  let end = new Date().getTime();
+  t.true((end - start) < 2000, 'toSafeInteger(3.2) takes less than 2s to run');
   t.end();
-});
+});

test/toSnakeCase/toSnakeCase.test.js

@@ -5,14 +5,18 @@ test('Testing toSnakeCase', (t) => {
   //For more information on all the methods supported by tape
   //Please go to https://github.com/substack/tape
   t.true(typeof toSnakeCase === 'function', 'toSnakeCase is a Function');
-  t.equal(toSnakeCase('camelCase'), 'camel_case', "string converts to snake case");
-  t.equal(toSnakeCase('some text'), 'some_text', "string converts to snake case");
-  t.equal(toSnakeCase('some-mixed_string With spaces_underscores-and-hyphens'), 'some_mixed_string_with_spaces_underscores_and_hyphens', "string converts to snake case");
-  t.equal(toSnakeCase('IAmListeningToFMWhileLoadingDifferentURLOnMyBrowserAndAlsoEditingSomeXMLAndHTML'), 'i_am_listening_to_fm_while_loading_different_url_on_my_browser_and_also_editing_some_xml_and_html', "string converts to snake case");
+  t.equal(toSnakeCase('camelCase'), 'camel_case', "toSnakeCase('camelCase') returns camel_case");
+  t.equal(toSnakeCase('some text'), 'some_text', "toSnakeCase('some text') returns some_text");
+  t.equal(toSnakeCase('some-mixed_string With spaces_underscores-and-hyphens'), 'some_mixed_string_with_spaces_underscores_and_hyphens', "toSnakeCase('some-mixed_string With spaces_underscores-and-hyphens') returns some_mixed_string_with_spaces_underscores_and_hyphens");
+  t.equal(toSnakeCase('IAmListeningToFMWhileLoadingDifferentURLOnMyBrowserAndAlsoEditingSomeXMLAndHTML'), 'i_am_listening_to_fm_while_loading_different_url_on_my_browser_and_also_editing_some_xml_and_html', "toSnakeCase('IAmListeningToFMWhileLoadingDifferentURLOnMyBrowserAndAlsoEditingSomeXMLAndHTML') returns i_am_listening_to_fm_while_loading_different_url_on_my_browser_and_also_editing_some_xml_and_html");
+  t.equal(toSnakeCase(), undefined, 'toSnakeCase() returns undefined');
+  t.throws(() => toSnakeCase([]), 'toSnakeCase([]) throws an error');
+  t.throws(() => toSnakeCase({}), 'toSnakeCase({}) throws an error');
+  t.throws(() => toSnakeCase(123), 'toSnakeCase(123) throws an error');
 
-  //t.deepEqual(toSnakeCase(args..), 'Expected');
-  //t.equal(toSnakeCase(args..), 'Expected');
-  //t.false(toSnakeCase(args..), 'Expected');
-  //t.throws(toSnakeCase(args..), 'Expected');
+  let start = new Date().getTime();
+  toSnakeCase('IAmListeningToFMWhileLoadingDifferentURLOnMyBrowserAndAlsoEditingSomeXMLAndHTML');
+  let end = new Date().getTime();
+  t.true((end - start) < 2000, 'toSnakeCase(IAmListeningToFMWhileLoadingDifferentURLOnMyBrowserAndAlsoEditingSomeXMLAndHTML) takes less than 2s to run');
   t.end();
-});
+});

test/union/union.test.js

@@ -5,10 +5,20 @@ test('Testing union', (t) => {
   //For more information on all the methods supported by tape
   //Please go to https://github.com/substack/tape
   t.true(typeof union === 'function', 'union is a Function');
-  t.deepEqual(union([1, 2, 3], [4, 3, 2]), [1, 2, 3, 4], "Returns every element that exists in any of the two arrays once");
-  //t.deepEqual(union(args..), 'Expected');
-  //t.equal(union(args..), 'Expected');
-  //t.false(union(args..), 'Expected');
-  //t.throws(union(args..), 'Expected');
+  t.deepEqual(union([1, 2, 3], [4, 3, 2]), [1, 2, 3, 4], "union([1, 2, 3], [4, 3, 2]) returns [1, 2, 3, 4]");
+  t.deepEqual(union('str', 'asd'), [ 's', 't', 'r', 'a', 'd' ], "union('str', 'asd') returns [ 's', 't', 'r', 'a', 'd' ]");
+  t.deepEqual(union([[], {}], [1, 2, 3]), [[], {}, 1, 2, 3], "union([[], {}], [1, 2, 3]) returns [[], {}, 1, 2, 3]");
+  t.deepEqual(union([], []), [], "union([], []) returns []");
+  t.throws(() => union(), 'union() throws an error');
+  t.throws(() => union(true, 'str'), 'union(true, str) throws an error');
+  t.throws(() => union('false', true), 'union(false, true) throws an error');
+  t.throws(() => union(123, {}), 'union(123, {}) throws an error');
+  t.throws(() => union([], {}), 'union([], {}) throws an error');
+  t.throws(() => union(undefined, null), 'union(undefined, null) throws an error');
+
+  let start = new Date().getTime();
+  union([1, 2, 3], [4, 3, 2]);
+  let end = new Date().getTime();
+  t.true((end - start) < 2000, 'union([1, 2, 3], [4, 3, 2]) takes less than 2s to run');
   t.end();
-});
+});

test/uniqueElements/uniqueElements.test.js

@@ -5,10 +5,24 @@ test('Testing uniqueElements', (t) => {
   //For more information on all the methods supported by tape
   //Please go to https://github.com/substack/tape
   t.true(typeof uniqueElements === 'function', 'uniqueElements is a Function');
-  t.deepEqual(uniqueElements([1, 2, 2, 3, 4, 4, 5]), [1,2,3,4,5], "Returns all unique values of an array");
-  //t.deepEqual(uniqueElements(args..), 'Expected');
-  //t.equal(uniqueElements(args..), 'Expected');
-  //t.false(uniqueElements(args..), 'Expected');
-  //t.throws(uniqueElements(args..), 'Expected');
+  t.deepEqual(uniqueElements([1, 2, 2, 3, 4, 4, 5]), [1,2,3,4,5], "uniqueElements([1, 2, 2, 3, 4, 4, 5]) returns [1,2,3,4,5]");
+  t.deepEqual(uniqueElements([1, 23, 53]), [1, 23, 53], "uniqueElements([1, 23, 53]) returns [1, 23, 53]");
+  t.deepEqual(uniqueElements([true, 0, 1, false, false, undefined, null, '']), [true, 0, 1, false, undefined, null, ''], "uniqueElements([true, 0, 1, false, false, undefined, null, '']) returns [true, 0, 1, false, false, undefined, null, '']");
+  t.deepEqual(uniqueElements(), [], "uniqueElements() returns []");
+  t.deepEqual(uniqueElements(null), [], "uniqueElements(null) returns []");
+  t.deepEqual(uniqueElements(undefined), [], "uniqueElements(undefined) returns []");
+  t.deepEqual(uniqueElements('strt'), ['s', 't', 'r'], "uniqueElements('strt') returns ['s', 't', 'r']");
+  t.throws(() => uniqueElements(1, 1, 2543, 534, 5), 'uniqueElements(1, 1, 2543, 534, 5) throws an error');
+  t.throws(() => uniqueElements({}), 'uniqueElements({}) throws an error');
+  t.throws(() => uniqueElements(true), 'uniqueElements(true) throws an error');
+  t.throws(() => uniqueElements(false), 'uniqueElements(false) throws an error');
+
+  let start = new Date().getTime();
+  uniqueElements([true, 0, 1, false, false, undefined, null, ''])
+  let end = new Date().getTime();
+  t.true((end - start) < 2000, 'uniqueElements([true, 0, 1, false, false, undefined, null]) takes less than 2s to run');
+
   t.end();
-});
+});
+
+uniqueElements([1, 2, 2, '1', 4, 4, 4, 5, true]); // [1,2,3,4,5]