Merge branch 'master' into add-toCurrency

CONTRIBUTING.md

@@ -38,14 +38,17 @@ Here's what you can do to help:
 - You can start creating a new snippet, by using the [snippet template](snippet-template.md) to format your snippets.
 
 ### Writing tests
-- Before writing any tests run `npm run tdd` script. It will update test directory to include new snippets as well as update old ones if needed.
+- Before writing any tests run `npm run tester` script. It will update test directory to include new snippets as well as update old ones if needed.
 - **DO NOT MODIFY THE snippetName.js files** under test directory.
 - We are using [tape](https://github.com/substack/tape) for testing.
 - Write tests under `snippetName.test.js` file. If you have trouble doing so, check out tests of other snippets.
 - Be sure to run `npm run test`. It is going to run all tests for all snippets.
 - Make a new pull request **only if all the tests are passing**.
 
-
+#### Browser specific tests
+- If your snippet belongs to `browser` category, then you will need to modify the tests to make them work.
+- By default, `Node.js` isn't browser environment. That said we have to use an external package to help us simulate the browser for our tests.
+- We use [jsdom](https://www.npmjs.com/package/jsdom) for our browser specific tests. You can find their [documentation](https://github.com/jsdom/jsdom) on GitHub as well.
 
 ### Additional guidelines and conventions regarding snippets
 

README.md

@@ -82,8 +82,11 @@ average(1, 2, 3);
 * [`collectInto`](#collectinto)
 * [`flip`](#flip)
 * [`over`](#over)
+* [`overArgs`](#overargs)
+* [`pipeAsyncFunctions`](#pipeasyncfunctions)
 * [`pipeFunctions`](#pipefunctions)
 * [`promisify`](#promisify)
+* [`rearg`](#rearg)
 * [`spreadOver`](#spreadover)
 * [`unary`](#unary)
 
@@ -219,12 +222,14 @@ average(1, 2, 3);
 <details>
 <summary>View contents</summary>
 
+* [`attempt`](#attempt)
 * [`bind`](#bind)
 * [`bindKey`](#bindkey)
 * [`chainAsync`](#chainasync)
 * [`compose`](#compose)
 * [`composeRight`](#composeright)
 * [`curry`](#curry)
+* [`debounce`](#debounce)
 * [`defer`](#defer)
 * [`delay`](#delay)
 * [`functionName`](#functionname)
@@ -235,6 +240,7 @@ average(1, 2, 3);
 * [`partialRight`](#partialright)
 * [`runPromisesInSeries`](#runpromisesinseries)
 * [`sleep`](#sleep)
+* [`throttle`](#throttle)
 * [`times`](#times)
 * [`unfold`](#unfold)
 
@@ -495,7 +501,7 @@ 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(console.log);
+Pall(p1, p2, p3).then(console.log); // [1, 2, 3] (after about 2 seconds)
 ```
 
 </details>
@@ -554,6 +560,66 @@ minMax(1, 2, 3, 4, 5); // [1,5]
 <br>[⬆ Back to top](#table-of-contents)
 
 
+### overArgs
+
+Creates a function that invokes the provided function with its arguments transformed.
+
+Use `Array.map()` to apply `transforms` to `args` in combination with the spread operator (`...`) to pass the transformed arguments to `fn`.
+
+```js
+const overArgs = (fn, transforms) => (...args) => fn(...args.map((val, i) => transforms[i](val)));
+```
+
+<details>
+<summary>Examples</summary>
+
+```js
+var func = overArgs(
+  function(x, y) {
+    return [x, y];
+  },
+  [square, doubled]
+);
+func(9, 3); // [81, 6]
+```
+
+</details>
+
+<br>[⬆ Back to top](#table-of-contents)
+
+
+### pipeAsyncFunctions
+
+Performs left-to-right function composition for asynchronous functions.
+
+Use `Array.reduce()` with the spread operator (`...`) to perform left-to-right function composition using `Promise.then()`.
+The functions can return a combination of: simple values, `Promise`'s, or they can be defined as `async` ones returning through `await`.
+All functions must be unary.
+
+```js
+const pipeAsyncFunctions = (...fns) => arg => fns.reduce((p, f) => p.then(f), Promise.resolve(arg));
+```
+
+<details>
+<summary>Examples</summary>
+
+```js
+const sum = pipeAsyncFunctions(
+  x => x + 1,
+  x => new Promise(resolve => setTimeout(() => resolve(x + 2), 1000)),
+  x => x + 3,
+  async x => (await x) + 4
+);
+(async () => {
+  console.log(await sum(5)); // 15 (after one second)
+})();
+```
+
+</details>
+
+<br>[⬆ Back to top](#table-of-contents)
+
+
 ### pipeFunctions
 
 Performs left-to-right function composition.
@@ -609,6 +675,40 @@ delay(2000).then(() => console.log('Hi!')); // // Promise resolves after 2s
 <br>[⬆ Back to top](#table-of-contents)
 
 
+### rearg
+
+Creates a function that invokes the provided function with its arguments arranged according to the specified indexes.
+
+Use `Array.reduce()` and `Array.indexOf()` to reorder arguments based on `indexes` in combination with the spread operator (`...`) to pass the transformed arguments to `fn`.
+
+```js
+const rearg = (fn, indexes) => (...args) =>
+  fn(
+    ...args.reduce(
+      (acc, val, i) => ((acc[indexes.indexOf(i)] = val), acc),
+      Array.from({ length: indexes.length })
+    )
+  );
+```
+
+<details>
+<summary>Examples</summary>
+
+```js
+var rearged = rearg(
+  function(a, b, c) {
+    return [a, b, c];
+  },
+  [2, 0, 1]
+);
+rearged('b', 'c', 'a'); // ['a', 'b', 'c']
+```
+
+</details>
+
+<br>[⬆ Back to top](#table-of-contents)
+
+
 ### spreadOver
 
 Takes a variadic function and returns a closure that accepts an array of arguments to map to the inputs of the function.
@@ -3432,6 +3532,37 @@ tomorrow(); // 2017-12-27 (if current date is 2017-12-26)
 ---
  ## 🎛️ Function
 
+### attempt
+
+Attempts to invoke a function with the provided arguments, returning either the result or the caught error object.
+
+Use a `try... catch` block to return either the result of the function or an appropriate error.
+
+```js
+const attempt = (fn, ...args) => {
+  try {
+    return fn(args);
+  } catch (e) {
+    return e instanceof Error ? e : new Error(e);
+  }
+};
+```
+
+<details>
+<summary>Examples</summary>
+
+```js
+var elements = attempt(function(selector) {
+  return document.querySelectorAll(selector);
+}, '>_>');
+if (elements instanceof Error) elements = []; // elements = []
+```
+
+</details>
+
+<br>[⬆ Back to top](#table-of-contents)
+
+
 ### bind
 
 Creates a function that invokes `fn` with a given context, optionally adding any additional supplied parameters to the beginning of the arguments.
@@ -3609,6 +3740,44 @@ curry(Math.min, 3)(10)(50)(2); // 2
 <br>[⬆ Back to top](#table-of-contents)
 
 
+### debounce
+
+Creates a debounced function that delays invoking the provided function until after `wait` milliseconds have elapsed since the last time the debounced function was invoked.
+
+Use `setTimeout()` and `clearTimeout()` to debounce the given method, `fn`.
+Use `Function.apply()` to apply the `this` context to the function and provide the necessary `arguments`.
+Omit the second argument, `wait`, to set the timeout at a default of 0 ms.
+
+```js
+const debounce = (fn, wait = 0) => {
+  let inDebounce;
+  return function() {
+    const context = this,
+      args = arguments;
+    clearTimeout(inDebounce);
+    inDebounce = setTimeout(() => fn.apply(context, args), wait);
+  };
+};
+```
+
+<details>
+<summary>Examples</summary>
+
+```js
+window.addEventListener(
+  'resize',
+  debounce(function(evt) {
+    console.log(window.innerWidth);
+    console.log(window.innerHeight);
+  }, 250)
+); // Will log the window dimensions at most every 250ms
+```
+
+</details>
+
+<br>[⬆ Back to top](#table-of-contents)
+
+
 ### defer
 
 Defers invoking a function until the current call stack has cleared.
@@ -3879,6 +4048,56 @@ async function sleepyWork() {
 <br>[⬆ Back to top](#table-of-contents)
 
 
+### throttle
+
+Creates a throttled function that only invokes the provided function at most once per every `wait` milliseconds
+
+Use `setTimeout()` and `clearTimeout()` to throttle the given method, `fn`.
+Use `Function.apply()` to apply the `this` context to the function and provide the necessary `arguments`.
+Use `Date.now()` to keep track of the last time the throttled function was invoked.
+Omit the second argument, `wait`, to set the timeout at a default of 0 ms.
+
+```js
+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));
+    }
+  };
+};
+```
+
+<details>
+<summary>Examples</summary>
+
+```js
+window.addEventListener(
+  'resize',
+  throttle(function(evt) {
+    console.log(window.innerWidth);
+    console.log(window.innerHeight);
+  }, 250)
+); // Will log the window dimensions at most every 250ms
+```
+
+</details>
+
+<br>[⬆ Back to top](#table-of-contents)
+
+
 ### times
 
 Iterates over a callback `n` times
@@ -5095,17 +5314,17 @@ UUIDGeneratorNode(); // '79c7c136-60ee-40a2-beb2-856f1feabefc'
 
 ### bindAll
 
-Explain briefly what the snippet does.
-
 Use `Array.forEach()` to return a `function` that uses `Function.apply()` to apply the given context (`obj`) to `fn` for each function specified.
 
 ```js
 const bindAll = (obj, ...fns) =>
   fns.forEach(
-    fn =>
+    fn => (
+      (f = obj[fn]),
       (obj[fn] = function() {
-        return fn.apply(obj);
+        return f.apply(obj);
       })
+    )
   );
 ```
 

snippets/attempt.md

@@ -0,0 +1,22 @@
+### attempt
+
+Attempts to invoke a function with the provided arguments, returning either the result or the caught error object.
+
+Use a `try... catch` block to return either the result of the function or an appropriate error.
+
+```js
+const attempt = (fn, ...args) => {
+  try {
+    return fn(args);
+  } catch (e) {
+    return e instanceof Error ? e : new Error(e);
+  }
+};
+```
+
+```js
+var elements = attempt(function(selector) {
+  return document.querySelectorAll(selector);
+}, '>_>');
+if (elements instanceof Error) elements = []; // elements = []
+```

snippets/bindAll.md

@@ -1,16 +1,16 @@
 ### bindAll
 
-Explain briefly what the snippet does.
-
 Use `Array.forEach()` to return a `function` that uses `Function.apply()` to apply the given context (`obj`) to `fn` for each function specified.
 
 ```js
 const bindAll = (obj, ...fns) =>
   fns.forEach(
-    fn =>
+    fn => (
+      (f = obj[fn]),
       (obj[fn] = function() {
-        return fn.apply(obj);
+        return f.apply(obj);
       })
+    )
   );
 ```
 

snippets/collectInto.md

@@ -13,5 +13,5 @@ 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(console.log);
+Pall(p1, p2, p3).then(console.log); // [1, 2, 3] (after about 2 seconds)
 ```

snippets/debounce.md

@@ -0,0 +1,29 @@
+### debounce
+
+Creates a debounced function that delays invoking the provided function until after `wait` milliseconds have elapsed since the last time the debounced function was invoked.
+
+Use `setTimeout()` and `clearTimeout()` to debounce the given method, `fn`.
+Use `Function.apply()` to apply the `this` context to the function and provide the necessary `arguments`.
+Omit the second argument, `wait`, to set the timeout at a default of 0 ms.
+
+```js
+const debounce = (fn, wait = 0) => {
+  let inDebounce;
+  return function() {
+    const context = this,
+      args = arguments;
+    clearTimeout(inDebounce);
+    inDebounce = setTimeout(() => fn.apply(context, args), wait);
+  };
+};
+```
+
+```js
+window.addEventListener(
+  'resize',
+  debounce(function(evt) {
+    console.log(window.innerWidth);
+    console.log(window.innerHeight);
+  }, 250)
+); // Will log the window dimensions at most every 250ms
+```

snippets/overArgs.md

@@ -0,0 +1,19 @@
+### overArgs
+
+Creates a function that invokes the provided function with its arguments transformed.
+
+Use `Array.map()` to apply `transforms` to `args` in combination with the spread operator (`...`) to pass the transformed arguments to `fn`.
+
+```js
+const overArgs = (fn, transforms) => (...args) => fn(...args.map((val, i) => transforms[i](val)));
+```
+
+```js
+var func = overArgs(
+  function(x, y) {
+    return [x, y];
+  },
+  [square, doubled]
+);
+func(9, 3); // [81, 6]
+```

snippets/pipeAsyncFunctions.md

@@ -0,0 +1,23 @@
+### pipeAsyncFunctions
+
+Performs left-to-right function composition for asynchronous functions.
+
+Use `Array.reduce()` with the spread operator (`...`) to perform left-to-right function composition using `Promise.then()`.
+The functions can return a combination of: simple values, `Promise`'s, or they can be defined as `async` ones returning through `await`.
+All functions must be unary.
+
+```js
+const pipeAsyncFunctions = (...fns) => arg => fns.reduce((p, f) => p.then(f), Promise.resolve(arg));
+```
+
+```js
+const sum = pipeAsyncFunctions(
+  x => x + 1,
+  x => new Promise(resolve => setTimeout(() => resolve(x + 2), 1000)),
+  x => x + 3,
+  async x => (await x) + 4
+);
+(async () => {
+  console.log(await sum(5)); // 15 (after one second)
+})();
+```

snippets/rearg.md

@@ -0,0 +1,25 @@
+### rearg
+
+Creates a function that invokes the provided function with its arguments arranged according to the specified indexes.
+
+Use `Array.reduce()` and `Array.indexOf()` to reorder arguments based on `indexes` in combination with the spread operator (`...`) to pass the transformed arguments to `fn`.
+
+```js
+const rearg = (fn, indexes) => (...args) =>
+  fn(
+    ...args.reduce(
+      (acc, val, i) => ((acc[indexes.indexOf(i)] = val), acc),
+      Array.from({ length: indexes.length })
+    )
+  );
+```
+
+```js
+var rearged = rearg(
+  function(a, b, c) {
+    return [a, b, c];
+  },
+  [2, 0, 1]
+);
+rearged('b', 'c', 'a'); // ['a', 'b', 'c']
+```

snippets/throttle.md

@@ -0,0 +1,41 @@
+### throttle
+
+Creates a throttled function that only invokes the provided function at most once per every `wait` milliseconds
+
+Use `setTimeout()` and `clearTimeout()` to throttle the given method, `fn`.
+Use `Function.apply()` to apply the `this` context to the function and provide the necessary `arguments`.
+Use `Date.now()` to keep track of the last time the throttled function was invoked.
+Omit the second argument, `wait`, to set the timeout at a default of 0 ms.
+
+```js
+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));
+    }
+  };
+};
+```
+
+```js
+window.addEventListener(
+  'resize',
+  throttle(function(evt) {
+    console.log(window.innerWidth);
+    console.log(window.innerHeight);
+  }, 250)
+); // Will log the window dimensions at most every 250ms
+```

tag_database

@@ -2,6 +2,7 @@ anagrams:string,recursion
 arrayToHtmlList:browser,array
 ary:adapter,function
 atob:node,string,utility
+attempt:function
 average:math,array
 averageBy:math,array,function
 bind:function,object
@@ -32,6 +33,7 @@ createElement:browser,utility
 createEventHub:browser,event,advanced
 currentURL:browser,url
 curry:function,recursion
+debounce:function
 decapitalize:string,array
 deepClone:object,recursion
 deepFlatten:array,recursion
@@ -161,6 +163,7 @@ once:function
 onUserInputChange:browser,event,advanced
 orderBy:object,array
 over:adapter,function
+overArgs:adapter,function
 palindrome:string
 parseCookie:utility,string
 partial:function
@@ -169,6 +172,7 @@ partition:array,object,function
 percentile:math
 pick:object,array
 pickBy:object,array,function
+pipeAsyncFunctions:adapter,function,promise
 pipeFunctions:adapter,function
 pluralize:string
 powerset:math
@@ -184,6 +188,7 @@ randomIntArrayInRange:math,utility,random
 randomIntegerInRange:math,utility,random
 randomNumberInRange:math,utility,random
 readFileLines:node,array,string
+rearg:adapter,function
 redirect:browser,url
 reducedFilter:array
 reduceSuccessive:array,function
@@ -227,6 +232,7 @@ take:array
 takeRight:array
 takeRightWhile:array,function
 takeWhile:array,function
+throttle:function
 times:function
 timeTaken:utility
 toCamelCase:string,regexp

test/anagrams/anagrams.test.js

@@ -6,6 +6,8 @@ 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');

test/ary/ary.test.js

@@ -5,6 +5,8 @@ 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');

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,6 +5,12 @@ 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');

test/bindAll/bindAll.js

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

test/bindAll/bindAll.test.js

@@ -5,6 +5,14 @@ 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');

test/bindKey/bindKey.test.js

@@ -5,6 +5,14 @@ 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');

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');

test/collectInto/collectInto.test.js

@@ -5,6 +5,11 @@ 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');

test/countBy/countBy.test.js

@@ -5,6 +5,8 @@ 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');

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,6 +5,8 @@ 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');

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(1.005, 2), 1.01, "round(1.005, 2) returns 1.01");
-  //t.equal(round(args..), 'Expected');
+  t.equal(round(123.3423345345345345344, 11), 123.34233453453, "round(123.3423345345345345344, 11) returns 123.34233453453");
-  //t.false(round(args..), 'Expected');
+  t.equal(round(3.342, 11), 3.342, "round(3.342, 11) returns 3.342");
-  //t.throws(round(args..), 'Expected');
+  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/testlog

@@ -1,6 +1,6 @@
-Test log for: Sun Jan 28 2018 14:42:53 GMT-0500 (Eastern Standard Time)
+Test log for: Sun Jan 28 2018 16:40:59 GMT+0200 (GTB Standard Time)
 
-> 30-seconds-of-code@0.0.1 test C:\Users\King David\Desktop\github-repo\30-seconds-of-code
+> 30-seconds-of-code@0.0.1 test G:\My Files\git Repositories\30-seconds-of-code
 > tape test/**/*.test.js | tap-spec
 
 
@@ -8,14 +8,20 @@ Test log for: Sun Jan 28 2018 14:42:53 GMT-0500 (Eastern Standard Time)
 
     √ anagrams is a Function
     √ Generates all anagrams of a string
+    √ Works for single-letter strings
+    √ Works for empty strings
+
 
   Testing arrayToHtmlList
 
     √ arrayToHtmlList is a Function
+    √ Generates and fills a list element
 
   Testing ary
 
     √ ary is a Function
+    √ Discards arguments with index >=n
+
 
   Testing atob
 
@@ -23,6 +29,12 @@ Test log for: Sun Jan 28 2018 14:42:53 GMT-0500 (Eastern Standard Time)
     √ atob("Zm9vYmFy") equals "foobar"
     √ atob("Z") returns ""
 
+  Testing attempt
+
+    √ attempt is a Function
+    √ Returns a value
+    √ Returns an error
+    
   Testing average
 
     √ average is a Function
@@ -51,14 +63,17 @@ Test log for: Sun Jan 28 2018 14:42:53 GMT-0500 (Eastern Standard Time)
   Testing bind
 
     √ bind is a Function
+    √ Binds to an object context
 
   Testing bindAll
 
     √ bindAll is a Function
+    √ Binds to an object context
 
   Testing bindKey
 
     √ bindKey is a Function
+    √ Binds function to an object context
 
   Testing bottomVisible
 
@@ -173,6 +188,8 @@ Test log for: Sun Jan 28 2018 14:42:53 GMT-0500 (Eastern Standard Time)
   Testing countBy
 
     √ countBy is a Function
+    √ Works for functions
+    √ Works for property names
 
   Testing countOccurrences
 
@@ -205,6 +222,16 @@ Test log for: Sun Jan 28 2018 14:42:53 GMT-0500 (Eastern Standard Time)
 
     √ decapitalize is a Function
 
+  Testing debounce
+
+    √ debounce is a Function
+
+  Testing decapitalize
+
+    √ decapitalize is a Function
+    √ Works with default parameter
+    √ Works with second parameter set to true
+
   Testing deepClone
 
     √ deepClone is a Function
@@ -460,6 +487,7 @@ Test log for: Sun Jan 28 2018 14:42:53 GMT-0500 (Eastern Standard Time)
   Testing hasClass
 
     √ hasClass is a Function
+    √ element has the specified class
 
   Testing hasFlags
 
@@ -957,6 +985,10 @@ Test log for: Sun Jan 28 2018 14:42:53 GMT-0500 (Eastern Standard Time)
 
     √ over is a Function
 
+  Testing overArgs
+
+    √ overArgs is a Function
+
   Testing palindrome
 
     √ palindrome is a Function
@@ -994,6 +1026,11 @@ Test log for: Sun Jan 28 2018 14:42:53 GMT-0500 (Eastern Standard Time)
 
     √ pickBy is a Function
 
+  Testing pipeAsyncFunctions
+
+    √ pipeAsyncFunctions is a Function
+    √ pipeAsyncFunctions result should be 15
+
   Testing pipeFunctions
 
     √ pipeFunctions is a Function
@@ -1075,6 +1112,10 @@ Test log for: Sun Jan 28 2018 14:42:53 GMT-0500 (Eastern Standard Time)
 
     √ README is a Function
 
+  Testing rearg
+
+    √ rearg is a Function
+
   Testing redirect
 
     √ redirect is a Function
@@ -1118,7 +1159,16 @@ Test log for: Sun Jan 28 2018 14:42:53 GMT-0500 (Eastern Standard Time)
   Testing round
 
     √ round is a Function
-    √ Rounds a number to a specified amount of digits.
+    √ round(1.005, 2) returns 1.01
+    √ round(123.3423345345345345344, 11) returns 123.34233453453
+    √ round(3.342, 11) returns 3.342
+    √ round(1.005) returns 1
+    √ round([1.005, 2]) returns NaN
+    √ round(string) returns NaN
+    √ round() returns NaN
+    √ round(132, 413, 4134) returns NaN
+    √ round({a: 132}, 413) returns NaN
+    √ round(123.3423345345345345344, 11) takes less than 2s to run
 
   Testing runAsync
 
@@ -1288,6 +1338,10 @@ Test log for: Sun Jan 28 2018 14:42:53 GMT-0500 (Eastern Standard Time)
 
     √ takeWhile is a Function
 
+  Testing throttle
+
+    √ throttle is a Function
+
   Testing times
 
     √ times is a Function
@@ -1299,15 +1353,21 @@ Test log for: Sun Jan 28 2018 14:42:53 GMT-0500 (Eastern Standard Time)
   Testing toCamelCase
 
     √ toCamelCase is a Function
-    √ Converts a string to camelCase
+    √ toCamelCase('some_database_field_name') returns someDatabaseFieldName
-    √ Converts a string to camelCase
+    √ toCamelCase('Some label that needs to be camelized') returns someLabelThatNeedsToBeCamelized
-    √ Converts a string to camelCase
+    √ toCamelCase('some-javascript-property') return someJavascriptProperty
-    √ Converts a string to camelCase
+    √ toCamelCase('some-mixed_string with spaces_underscores-and-hyphens') returns someMixedStringWithSpacesUnderscoresAndHyphens
+    √ toCamelCase() throws a error
+    √ toCamelCase([]) throws a error
+    √ toCamelCase({}) throws a error
+    √ toCamelCase(123) throws a error
+    √ toCamelCase(some-mixed_string with spaces_underscores-and-hyphens) takes less than 2s to run
 
   Testing toCurrency
 
     √ toCurrency is a Function
 
+
   Testing toDecimalMark
 
     √ toDecimalMark is a Function
@@ -1320,10 +1380,15 @@ Test log for: Sun Jan 28 2018 14:42:53 GMT-0500 (Eastern Standard Time)
   Testing toKebabCase
 
     √ toKebabCase is a Function
-    √ string converts to snake case
+    √ toKebabCase('camelCase') returns camel-case
-    √ string converts to snake case
+    √ toKebabCase('some text') returns some-text
-    √ string converts to snake case
+    √ toKebabCase('some-mixed-string With spaces-underscores-and-hyphens') returns some-mixed-string-with-spaces-underscores-and-hyphens
-    √ string converts to snake case
+    √ toKebabCase('IAmListeningToFMWhileLoadingDifferentURLOnMyBrowserAndAlsoEditingSomeXMLAndHTML') returns i-am-listening-to-fm-while-loading-different-url-on-my-browser-and-also-editing-some-xml-and-html
+    √ toKebabCase() return undefined
+    √ toKebabCase([]) throws an error
+    √ toKebabCase({}) throws an error
+    √ toKebabCase(123) throws an error
+    √ toKebabCase(IAmListeningToFMWhileLoadingDifferentURLOnMyBrowserAndAlsoEditingSomeXMLAndHTML) takes less than 2s to run
 
   Testing tomorrow
 
@@ -1340,19 +1405,30 @@ Test log for: Sun Jan 28 2018 14:42:53 GMT-0500 (Eastern Standard Time)
   Testing toSafeInteger
 
     √ toSafeInteger is a Function
+    √ Number(toSafeInteger(3.2)) is a number
     √ Converts a value to a safe integer
-    √ Converts a value to a safe integer
+    √ toSafeInteger('4.2') returns 4
-    √ Converts a value to a safe integer
+    √ toSafeInteger(4.6) returns 5
-    √ Converts a value to a safe integer
+    √ toSafeInteger([]) returns 0
-    √ Converts a value to a safe integer
+    √ isNaN(toSafeInteger([1.5, 3124])) is true
+    √ isNaN(toSafeInteger('string')) is true
+    √ isNaN(toSafeInteger({})) is true
+    √ isNaN(toSafeInteger()) is true
+    √ toSafeInteger(Infinity) returns 9007199254740991
+    √ toSafeInteger(3.2) takes less than 2s to run
 
   Testing toSnakeCase
 
     √ toSnakeCase is a Function
-    √ string converts to snake case
+    √ toSnakeCase('camelCase') returns camel_case
-    √ string converts to snake case
+    √ toSnakeCase('some text') returns some_text
-    √ string converts to snake case
+    √ toSnakeCase('some-mixed_string With spaces_underscores-and-hyphens') returns some_mixed_string_with_spaces_underscores_and_hyphens
-    √ string converts to snake case
+    √ toSnakeCase('IAmListeningToFMWhileLoadingDifferentURLOnMyBrowserAndAlsoEditingSomeXMLAndHTML') returns i_am_listening_to_fm_while_loading_different_url_on_my_browser_and_also_editing_some_xml_and_html
+    √ toSnakeCase() returns undefined
+    √ toSnakeCase([]) throws an error
+    √ toSnakeCase({}) throws an error
+    √ toSnakeCase(123) throws an error
+    √ toSnakeCase(IAmListeningToFMWhileLoadingDifferentURLOnMyBrowserAndAlsoEditingSomeXMLAndHTML) takes less than 2s to run
 
   Testing transform
 
@@ -1384,7 +1460,17 @@ Test log for: Sun Jan 28 2018 14:42:53 GMT-0500 (Eastern Standard Time)
   Testing union
 
     √ union is a Function
-    √ Returns every element that exists in any of the two arrays once
+    √ union([1, 2, 3], [4, 3, 2]) returns [1, 2, 3, 4]
+    √ union('str', 'asd') returns [ 's', 't', 'r', 'a', 'd' ]
+    √ union([[], {}], [1, 2, 3]) returns [[], {}, 1, 2, 3]
+    √ union([], []) returns []
+    √ union() throws an error
+    √ union(true, str) throws an error
+    √ union(false, true) throws an error
+    √ union(123, {}) throws an error
+    √ union([], {}) throws an error
+    √ union(undefined, null) throws an error
+    √ union([1, 2, 3], [4, 3, 2]) takes less than 2s to run
 
   Testing unionBy
 
@@ -1397,7 +1483,18 @@ Test log for: Sun Jan 28 2018 14:42:53 GMT-0500 (Eastern Standard Time)
   Testing uniqueElements
 
     √ uniqueElements is a Function
-    √ Returns all unique values of an array
+    √ uniqueElements([1, 2, 2, 3, 4, 4, 5]) returns [1,2,3,4,5]
+    √ uniqueElements([1, 23, 53]) returns [1, 23, 53]
+    √ uniqueElements([true, 0, 1, false, false, undefined, null, '']) returns [true, 0, 1, false, false, undefined, null, '']
+    √ uniqueElements() returns []
+    √ uniqueElements(null) returns []
+    √ uniqueElements(undefined) returns []
+    √ uniqueElements('strt') returns ['s', 't', 'r']
+    √ uniqueElements(1, 1, 2543, 534, 5) throws an error
+    √ uniqueElements({}) throws an error
+    √ uniqueElements(true) throws an error
+    √ uniqueElements(false) throws an error
+    √ uniqueElements([true, 0, 1, false, false, undefined, null]) takes less than 2s to run
 
   Testing untildify
 
@@ -1519,10 +1616,9 @@ Test log for: Sun Jan 28 2018 14:42:53 GMT-0500 (Eastern Standard Time)
   Testing zipWith
 
     √ zipWith is a Function
+    √ Works with multiple promises
 
 
-  total:     649
+  total:     721
-  passing:   649
+  passing:   721
-  duration:  499ms
+  duration:  3.1s
-
-

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_database_field_name'), 'someDatabaseFieldName', "toCamelCase('some_database_field_name') returns someDatabaseFieldName");
-  t.equal(toCamelCase('Some label that needs to be camelized'), 'someLabelThatNeedsToBeCamelized', "Converts a string to camelCase");
+  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', "Converts a string to camelCase");
+  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', "Converts a string to camelCase");
+  t.equal(toCamelCase('some-mixed_string with spaces_underscores-and-hyphens'), 'someMixedStringWithSpacesUnderscoresAndHyphens', "toCamelCase('some-mixed_string with spaces_underscores-and-hyphens') returns someMixedStringWithSpacesUnderscoresAndHyphens");
-  //t.deepEqual(toCamelCase(args..), 'Expected');
+  t.throws(() => toCamelCase(), 'toCamelCase() throws a error');
-  //t.equal(toCamelCase(args..), 'Expected');
+  t.throws(() => toCamelCase([]), 'toCamelCase([]) throws a error');
-  //t.false(toCamelCase(args..), 'Expected');
+  t.throws(() => toCamelCase({}), 'toCamelCase({}) throws a error');
-  //t.throws(toCamelCase(args..), 'Expected');
+  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('camelCase'), 'camel-case', "toKebabCase('camelCase') returns camel-case");
-  t.equal(toKebabCase('some text'), 'some-text', "string converts to snake 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', "string converts to snake case");
+  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', "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', "toKebabCase('IAmListeningToFMWhileLoadingDifferentURLOnMyBrowserAndAlsoEditingSomeXMLAndHTML') returns i-am-listening-to-fm-while-loading-different-url-on-my-browser-and-also-editing-some-xml-and-html");
-  //t.deepEqual(toKebabCase(args..), 'Expected');
+  t.equal(toKebabCase(), undefined, 'toKebabCase() return undefined');
-  //t.equal(toKebabCase(args..), 'Expected');
+  t.throws(() => toKebabCase([]), 'toKebabCase([]) throws an error');
-  //t.false(toKebabCase(args..), 'Expected');
+  t.throws(() => toKebabCase({}), 'toKebabCase({}) throws an error');
-  //t.throws(toKebabCase(args..), 'Expected');
+  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.2'), 4, "toSafeInteger('4.2') returns 4");
-  t.equal(toSafeInteger(4.6), 5, "Converts a value to a safe integer");
+  t.equal(toSafeInteger(4.6), 5, "toSafeInteger(4.6) returns 5");
-  t.equal(toSafeInteger(1.5), 2, "Converts a value to a safe integer");
+  t.equal(toSafeInteger([]), 0, "toSafeInteger([]) returns 0");
-  t.equal(toSafeInteger(Infinity), 9007199254740991, "Converts a value to a safe integer");
+  t.true(isNaN(toSafeInteger([1.5, 3124])), "isNaN(toSafeInteger([1.5, 3124])) is true");
-  //t.deepEqual(toSafeInteger(args..), 'Expected');
+  t.true(isNaN(toSafeInteger('string')), "isNaN(toSafeInteger('string')) is true");
-  //t.equal(toSafeInteger(args..), 'Expected');
+  t.true(isNaN(toSafeInteger({})), "isNaN(toSafeInteger({})) is true");
-  //t.false(toSafeInteger(args..), 'Expected');
+  t.true(isNaN(toSafeInteger()), "isNaN(toSafeInteger()) is true");
-  //t.throws(toSafeInteger(args..), 'Expected');
+  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('camelCase'), 'camel_case', "toSnakeCase('camelCase') returns camel_case");
-  t.equal(toSnakeCase('some text'), 'some_text', "string converts to snake 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', "string converts to snake case");
+  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', "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', "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');
+  let start = new Date().getTime();
-  //t.equal(toSnakeCase(args..), 'Expected');
+  toSnakeCase('IAmListeningToFMWhileLoadingDifferentURLOnMyBrowserAndAlsoEditingSomeXMLAndHTML');
-  //t.false(toSnakeCase(args..), 'Expected');
+  let end = new Date().getTime();
-  //t.throws(toSnakeCase(args..), 'Expected');
+  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([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(args..), 'Expected');
+  t.deepEqual(union('str', 'asd'), [ 's', 't', 'r', 'a', 'd' ], "union('str', 'asd') returns [ 's', 't', 'r', 'a', 'd' ]");
-  //t.equal(union(args..), 'Expected');
+  t.deepEqual(union([[], {}], [1, 2, 3]), [[], {}, 1, 2, 3], "union([[], {}], [1, 2, 3]) returns [[], {}, 1, 2, 3]");
-  //t.false(union(args..), 'Expected');
+  t.deepEqual(union([], []), [], "union([], []) returns []");
-  //t.throws(union(args..), 'Expected');
+  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([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(args..), 'Expected');
+  t.deepEqual(uniqueElements([1, 23, 53]), [1, 23, 53], "uniqueElements([1, 23, 53]) returns [1, 23, 53]");
-  //t.equal(uniqueElements(args..), 'Expected');
+  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.false(uniqueElements(args..), 'Expected');
+  t.deepEqual(uniqueElements(), [], "uniqueElements() returns []");
-  //t.throws(uniqueElements(args..), 'Expected');
+  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]