30-seconds-of-code/test/testlog

Test log for: Wed May 30 2018 21:16:49 GMT+0000 (UTC)

> 30-seconds-of-code@0.0.3 test /home/travis/build/Chalarangelo/30-seconds-of-code
> tape test/**/*.test.js | tap-spec


  Testing JSONToDate

    ✔ JSONToDate is a Function

  Testing JSONToFile

    ✔ JSONToFile is a Function
    ✔ Tested on 09/02/2018 by @chalarangelo

  Testing RGBToHex

    ✔ RGBToHex is a Function
    ✔ Converts the values of RGB components to a color code.

  Testing URLJoin

    ✔ URLJoin is a Function
    ✔ Returns proper URL
    ✔ Returns proper URL

  Testing UUIDGeneratorBrowser

    ✔ UUIDGeneratorBrowser is a Function
    ✔ Tested 09/02/2018 by @chalarangelo

  Testing UUIDGeneratorNode

    ✔ UUIDGeneratorNode is a Function
    ✔ Contains dashes in the proper places
    ✔ Only contains hexadecimal digits

  Testing all

    ✔ all is a Function
    ✔ Returns true for arrays with no falsey values
    ✔ Returns false for arrays with 0
    ✔ Returns false for arrays with NaN
    ✔ Returns false for arrays with undefined
    ✔ Returns false for arrays with null
    ✔ Returns false for arrays with empty strings
    ✔ Returns true with predicate function
    ✔ Returns false with a predicate function

  Testing any

    ✔ any is a Function
    ✔ Returns true for arrays with at least one truthy value
    ✔ Returns false for arrays with no truthy values
    ✔ Returns false for arrays with no truthy values
    ✔ Returns true with predicate function
    ✔ Returns false with a predicate function

  Testing approximatelyEqual

    ✔ approximatelyEqual is a Function
    ✔ Works for PI / 2
    ✔ Works for 0.1 + 0.2 === 0.3
    ✔ Works for exactly equal values
    ✔ Works for a custom epsilon

  Testing arrayToHtmlList

    ✔ arrayToHtmlList is a Function
    ✔ Tested by @chalarangelo on 16/02/2018

  Testing ary

    ✔ ary is a Function
    ✔ Discards arguments with index >=n

  Testing atob

    ✔ atob is a Function
    ✔ 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
    ✔ average(true) returns 0
    ✔ average(false) returns 1
    ✔ average(9, 1) returns 5
    ✔ average(153, 44, 55, 64, 71, 1122, 322774, 2232, 23423, 234, 3631) returns 32163.909090909092 
    ✔ average(1, 2, 3) returns 2
    ✔ average(null) returns 0
    ✔ average(1, 2, 3) returns NaN
    ✔ average(String) returns NaN
    ✔ average({ a: 123}) returns NaN
    ✔ average([undefined, 0, string]) returns NaN
    ✔ average([1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 1122, 32124, 23232]) takes less than 2s to run

  Testing averageBy

    ✔ averageBy is a Function
    ✔ Produces the right result with a function
    ✔ Produces the right result with a property name

  Testing bifurcate

    ✔ bifurcate is a Function
    ✔ Splits the collection into two groups

  Testing bifurcateBy

    ✔ bifurcateBy is a Function
    ✔ Splits the collection into two groups

  Testing binarySearch

    ✔ binarySearch is a Function
    ✔ Finds item in array
    ✔ Returns -1 when not found
    ✔ Works with empty arrays
    ✔ Works for one element arrays

  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 binomialCoefficient

    ✔ binomialCoefficient is a Function
    ✔ Returns the appropriate value
    ✔ Returns the appropriate value
    ✔ Returns the appropriate value
    ✔ Returns NaN
    ✔ Returns NaN

  Testing bottomVisible

    ✔ bottomVisible is a Function
    ✔ Tested on 09/02/2018 by @chalarangelo

  Testing btoa

    ✔ btoa is a Function
    ✔ btoa("foobar") equals "Zm9vYmFy"

  Testing byteSize

    ✔ byteSize is a Function
    ✔ Works for a single letter
    ✔ Works for a common string
    ✔ Works for emoji

  Testing call

    ✔ call is a Function
    ✔ Calls function on given object

  Testing capitalize

    ✔ capitalize is a Function
    ✔ Capitalizes the first letter of a string
    ✔ Capitalizes the first letter of a string
    ✔ Works with characters
    ✔ Works with single character words

  Testing capitalizeEveryWord

    ✔ capitalizeEveryWord is a Function
    ✔ Capitalizes the first letter of every word in a string
    ✔ Works with characters
    ✔ Works with one word string

  Testing castArray

    ✔ castArray is a Function
    ✔ Works for single values
    ✔ Works for arrays with one value
    ✔ Works for arrays with multiple value
    ✔ Works for strings
    ✔ Works for objects

  Testing chainAsync

    ✔ chainAsync is a Function
    ✔ Calls all functions in an array

  Testing chunk

    ✔ chunk is a Function
    ✔ chunk([1, 2, 3, 4, 5], 2) returns [[1,2],[3,4],[5]] 
    ✔ chunk([]) returns []
    ✔ chunk(123) returns []
    ✔ chunk({ a: 123}) returns []
    ✔ chunk(string, 2) returns [ st, ri, ng ]
    ✔ chunk() throws an error
    ✔ chunk(undefined) throws an error
    ✔ chunk(null) throws an error
    ✔ chunk(This is a string, 2) takes less than 2s to run

  Testing clampNumber

    ✔ clampNumber is a Function
    ✔ Clamps num within the inclusive range specified by the boundary values a and b

  Testing cleanObj

    ✔ cleanObj is a Function
    ✔ Removes any properties except the ones specified from a JSON object

  Testing cloneRegExp

    ✔ cloneRegExp is a Function
    ✔ Clones regular expressions properly

  Testing coalesce

    ✔ coalesce is a Function
    ✔ Returns the first non-null/undefined argument

  Testing coalesceFactory

    ✔ coalesceFactory is a Function
    ✔ Returns a customized coalesce function

  Testing collatz

    ✔ collatz is a Function
    ✔ When n is even, divide by 2
    ✔ When n is odd, times by 3 and add 1
    ✔ Eventually reaches 1

  Testing collectInto

    ✔ collectInto is a Function

  Testing colorize

    ✔ colorize is a Function
    ✔ Tested on 09/02/2018 by @chalarangelo

  Testing compact

    ✔ compact is a Function
    ✔ Removes falsey values from an array

  Testing compose

    ✔ compose is a Function
    ✔ Performs right-to-left function composition

  Testing composeRight

    ✔ composeRight is a Function
    ✔ Performs left-to-right function composition

  Testing converge

    ✔ converge is a Function
    ✔ Produces the average of the array
    ✔ Produces the strange concatenation

  Testing copyToClipboard

    ✔ copyToClipboard is a Function
    ✔ Tested on 09/02/2018 by @chalarangelo

  Testing countBy

    ✔ countBy is a Function
    ✔ Works for functions
    ✔ Works for property names

  Testing countOccurrences

    ✔ countOccurrences is a Function
    ✔ Counts the occurrences of a value in an array

  Testing countVowels

    ✔ countVowels is a Function

  Testing counter

    ✔ counter is a Function

  Testing createElement

    ✔ createElement is a Function
    ✔ Tested by @chalarangelo on 16/02/2018

  Testing createEventHub

    ✔ createEventHub is a Function
    ✔ Tested by @chalarangelo on 16/02/2018

  Testing currentURL

    ✔ currentURL is a Function
    ✔ Tested by @chalarangelo on 16/02/2018

  Testing curry

    ✔ curry is a Function
    ✔ curries a Math.pow
    ✔ curries a Math.min

  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
    ✔ Shallow cloning works
    ✔ Deep cloning works
    ✔ Array shallow cloning works
    ✔ Array deep cloning works

  Testing deepFlatten

    ✔ deepFlatten is a Function
    ✔ Deep flattens an array

  Testing defaults

    ✔ defaults is a Function
    ✔ Assigns default values for undefined properties

  Testing defer

    ✔ defer is a Function
    ✔ Tested by @chalarangelo on 16/02/2018

  Testing degreesToRads

    ✔ degreesToRads is a Function
    ✔ Returns the appropriate value

  Testing delay

    ✔ delay is a Function

  Testing detectDeviceType

    ✔ detectDeviceType is a Function
    ✔ Tested on 09/02/2018 by @chalarangelo

  Testing difference

    ✔ difference is a Function
    ✔ Returns the difference between two arrays

  Testing differenceBy

    ✔ differenceBy is a Function
    ✔ Works using a native function and numbers
    ✔ Works with arrow function and objects

  Testing differenceWith

    ✔ differenceWith is a Function
    ✔ Filters out all values from an array

  Testing digitize

    ✔ digitize is a Function
    ✔ Converts a number to an array of digits

  Testing distance

    ✔ distance is a Function
    ✔ Calculates the distance between two points

  Testing drop

    ✔ drop is a Function
    ✔ Works without the last argument
    ✔ Removes appropriate element count as specified
    ✔ Empties array given a count greater than length

  Testing dropRight

    ✔ dropRight is a Function
    ✔ Returns a new array with n elements removed from the right
    ✔ Returns a new array with n elements removed from the right
    ✔ Returns a new array with n elements removed from the right

  Testing dropRightWhile

    ✔ dropRightWhile is a Function
    ✔ Removes elements from the end of an array until the passed function returns true.

  Testing dropWhile

    ✔ dropWhile is a Function
    ✔ Removes elements in an array until the passed function returns true.

  Testing elementIsVisibleInViewport

    ✔ elementIsVisibleInViewport is a Function
    ✔ Tested on 09/02/2018 by @chalarangelo

  Testing elo

    ✔ elo is a Function
    ✔ Standard 1v1s
    ✔ should be equivalent
    ✔ 4 player FFA, all same rank

  Testing equals

    ✔ equals is a Function
    ✔ { a: [2, {e: 3}], b: [4], c: 'foo' } is equal to { a: [2, {e: 3}], b: [4], c: 'foo' }
    ✔ [1,2,3] is equal to [1,2,3]
    ✔ { a: [2, 3], b: [4] } is not equal to { a: [2, 3], b: [6] }
    ✔ [1,2,3] is not equal to [1,2,4]
    ✔ [1, 2, 3] should be equal to { 0: 1, 1: 2, 2: 3 }) - type is different, but their enumerable properties match.

  Testing escapeHTML

    ✔ escapeHTML is a Function
    ✔ Escapes a string for use in HTML

  Testing escapeRegExp

    ✔ escapeRegExp is a Function
    ✔ Escapes a string to use in a regular expression

  Testing everyNth

    ✔ everyNth is a Function
    ✔ Returns every nth element in an array

  Testing extendHex

    ✔ extendHex is a Function
    ✔ Extends a 3-digit color code to a 6-digit color code
    ✔ Extends a 3-digit color code to a 6-digit color code

  Testing factorial

    ✔ factorial is a Function
    ✔ Calculates the factorial of 720
    ✔ Calculates the factorial of 0
    ✔ Calculates the factorial of 1
    ✔ Calculates the factorial of 4
    ✔ Calculates the factorial of 10

  Testing factors

    ✔ factors is a Function

  Testing fibonacci

    ✔ fibonacci is a Function
    ✔ Generates an array, containing the Fibonacci sequence

  Testing fibonacciCountUntilNum

    ✔ fibonacciCountUntilNum is a Function

  Testing fibonacciUntilNum

    ✔ fibonacciUntilNum is a Function

  Testing filterNonUnique

    ✔ filterNonUnique is a Function
    ✔ Filters out the non-unique values in an array

  Testing findKey

    ✔ findKey is a Function
    ✔ Returns the appropriate key

  Testing findLast

    ✔ findLast is a Function
    ✔ Finds last element for which the given function returns true

  Testing findLastIndex

    ✔ findLastIndex is a Function
    ✔ Finds last index for which the given function returns true

  Testing findLastKey

    ✔ findLastKey is a Function
    ✔ Returns the appropriate key

  Testing flatten

    ✔ flatten is a Function
    ✔ Flattens an array
    ✔ Flattens an array

  Testing flattenObject

    ✔ flattenObject is a Function
    ✔ Flattens an object with the paths for keys
    ✔ Works with arrays

  Testing flip

    ✔ flip is a Function
    ✔ Flips argument order

  Testing forEachRight

    ✔ forEachRight is a Function
    ✔ Iterates over the array in reverse

  Testing forOwn

    ✔ forOwn is a Function
    ✔ Iterates over an element's key-value pairs

  Testing forOwnRight

    ✔ forOwnRight is a Function
    ✔ Iterates over an element's key-value pairs in reverse

  Testing formatDuration

    ✔ formatDuration is a Function
    ✔ Returns the human readable format of the given number of milliseconds
    ✔ Returns the human readable format of the given number of milliseconds

  Testing fromCamelCase

    ✔ fromCamelCase is a Function
    ✔ Converts a string from camelcase
    ✔ Converts a string from camelcase
    ✔ Converts a string from camelcase

  Testing functionName

    ✔ functionName is a Function
    ✔ Works for native functions
    ✔ Works for functions
    ✔ Works for arrow functions

  Testing functions

    ✔ functions is a Function
    ✔ Returns own methods
    ✔ Returns own and inherited methods

  Testing gcd

    ✔ gcd is a Function
    ✔ Calculates the greatest common divisor between two or more numbers/arrays
    ✔ Calculates the greatest common divisor between two or more numbers/arrays

  Testing geometricProgression

    ✔ geometricProgression is a Function
    ✔ Initializes an array containing the numbers in the specified range
    ✔ Initializes an array containing the numbers in the specified range
    ✔ Initializes an array containing the numbers in the specified range

  Testing get

    ✔ get is a Function
    ✔ Retrieve a property indicated by the selector from an object.

  Testing getColonTimeFromDate

    ✔ getColonTimeFromDate is a Function

  Testing getDaysDiffBetweenDates

    ✔ getDaysDiffBetweenDates is a Function
    ✔ Returns the difference in days between two dates

  Testing getMeridiemSuffixOfInteger

    ✔ getMeridiemSuffixOfInteger is a Function

  Testing getScrollPosition

    ✔ getScrollPosition is a Function
    ✔ Tested by @chalarangelo on 16/02/2018

  Testing getStyle

    ✔ getStyle is a Function
    ✔ Tested by @chalarangelo on 16/02/2018

  Testing getType

    ✔ getType is a Function
    ✔ Returns the native type of a value

  Testing getURLParameters

    ✔ getURLParameters is a Function
    ✔ Returns an object containing the parameters of the current URL

  Testing groupBy

    ✔ groupBy is a Function
    ✔ Groups the elements of an array based on the given function
    ✔ Groups the elements of an array based on the given function

  Testing hammingDistance

    ✔ hammingDistance is a Function
    ✔ retuns hamming disance between 2 values

  Testing hasClass

    ✔ hasClass is a Function

  Testing hasFlags

    ✔ hasFlags is a Function
    ✔ Tested by @chalarangelo on 16/02/2018

  Testing hashBrowser

    ✔ hashBrowser is a Function
    ✔ Tested by @chalarangelo on 16/02/2018

  Testing hashNode

    ✔ hashNode is a Function

  Testing head

    ✔ head is a Function
    ✔ head({ a: 1234}) returns undefined
    ✔ head([1, 2, 3]) returns 1
    ✔ head({ 0: false}) returns false
    ✔ head(String) returns S
    ✔ head(null) throws an Error
    ✔ head(undefined) throws an Error
    ✔ head() throws an Error
    ✔ head([1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 1122, 32124, 23232]) takes less than 2s to run

  Testing hexToRGB

    ✔ hexToRGB is a Function
    ✔ Converts a color code to a rgb() or rgba() string
    ✔ Converts a color code to a rgb() or rgba() string
    ✔ Converts a color code to a rgb() or rgba() string

  Testing hide

    ✔ hide is a Function
    ✔ Tested by @chalarangelo on 16/02/2018

  Testing howManyTimes

    ✔ howManyTimes is a Function

  Testing httpDelete

    ✔ httpDelete is a Function

  Testing httpGet

    ✔ httpGet is a Function

  Testing httpPost

    ✔ httpPost is a Function

  Testing httpPut

    ✔ httpPut is a Function

  Testing httpsRedirect

    ✔ httpsRedirect is a Function
    ✔ Tested on 09/02/2018 by @chalarangelo

  Testing hz

    ✔ hz is a Function

  Testing inRange

    ✔ inRange is a Function
    ✔ The given number falls within the given range
    ✔ The given number falls within the given range
    ✔ The given number does not falls within the given range
    ✔ The given number does not falls within the given range

  Testing indexOfAll

    ✔ indexOfAll is a Function
    ✔ Returns all indices of val in an array
    ✔ Returns all indices of val in an array

  Testing initial

    ✔ initial is a Function
    ✔ Returns all the elements of an array except the last one

  Testing initialize2DArray

    ✔ initialize2DArray is a Function
    ✔ Initializes a 2D array of given width and height and value

  Testing initializeArrayWithRange

    ✔ initializeArrayWithRange is a Function
    ✔ Initializes an array containing the numbers in the specified range

  Testing initializeArrayWithRangeRight

    ✔ initializeArrayWithRangeRight is a Function

  Testing initializeArrayWithValues

    ✔ initializeArrayWithValues is a Function
    ✔ Initializes and fills an array with the specified values

  Testing initializeNDArray

    ✔ initializeNDArray is a Function

  Testing intersection

    ✔ intersection is a Function
    ✔ Returns a list of elements that exist in both arrays

  Testing intersectionBy

    ✔ intersectionBy is a Function
    ✔ Returns a list of elements that exist in both arrays, after applying the provided function to each array element of both

  Testing intersectionWith

    ✔ intersectionWith is a Function
    ✔ Returns a list of elements that exist in both arrays, using a provided comparator function

  Testing invertKeyValues

    ✔ invertKeyValues is a Function
    ✔ invertKeyValues({ a: 1, b: 2, c: 1 }) returns { 1: [ 'a', 'c' ], 2: [ 'b' ] }
    ✔ invertKeyValues({ a: 1, b: 2, c: 1 }, value => 'group' + value) returns { group1: [ 'a', 'c' ], group2: [ 'b' ] }

  Testing is

    ✔ is is a Function
    ✔ Works for arrays with data
    ✔ Works for empty arrays
    ✔ Works for arrays, not objects
    ✔ Works for objects
    ✔ Works for maps
    ✔ Works for regular expressions
    ✔ Works for sets
    ✔ Works for weak maps
    ✔ Works for weak sets
    ✔ Works for strings - returns true for primitive
    ✔ Works for strings - returns true when using constructor
    ✔ Works for numbers - returns true for primitive
    ✔ Works for numbers - returns true when using constructor
    ✔ Works for booleans - returns true for primitive
    ✔ Works for booleans - returns true when using constructor
    ✔ Works for functions

  Testing isAbsoluteURL

    ✔ isAbsoluteURL is a Function
    ✔ Given string is an absolute URL
    ✔ Given string is an absolute URL
    ✔ Given string is not an absolute URL

  Testing isAnagram

    ✔ isAnagram is a Function
    ✔ Checks valid anagram
    ✔ Works with spaces
    ✔ Ignores case
    ✔ Ignores special characters

  Testing isArmstrongNumber

    ✔ isArmstrongNumber is a Function

  Testing isArray

    ✔ isArray is a Function
    ✔ passed value is an array
    ✔ passed value is not an array

  Testing isArrayBuffer

    ✔ isArrayBuffer is a Function

  Testing isArrayLike

    ✔ isArrayLike is a Function
    ✔ Returns true for a string
    ✔ Returns true for an array
    ✔ Returns false for null

  Testing isBoolean

    ✔ isBoolean is a Function
    ✔ passed value is not a boolean
    ✔ passed value is not a boolean

  Testing isBrowser

    ✔ isBrowser is a Function

  Testing isBrowserTabFocused

    ✔ isBrowserTabFocused is a Function

  Testing isDivisible

    ✔ isDivisible is a Function
    ✔ The number 6 is divisible by 3

  Testing isEmpty

    ✔ isEmpty is a Function
    ✔ Returns true for empty Map
    ✔ Returns true for empty Set
    ✔ Returns true for empty array
    ✔ Returns true for empty object
    ✔ Returns true for empty string
    ✔ Returns false for non-empty array
    ✔ Returns false for non-empty object
    ✔ Returns false for non-empty string
    ✔ Returns true - type is not considered a collection
    ✔ Returns true - type is not considered a collection

  Testing isEven

    ✔ isEven is a Function
    ✔ 4 is even number
    ✔ undefined

  Testing isFunction

    ✔ isFunction is a Function
    ✔ passed value is a function
    ✔ passed value is not a function

  Testing isLowerCase

    ✔ isLowerCase is a Function
    ✔ passed string is a lowercase
    ✔ passed string is a lowercase
    ✔ passed value is not a lowercase

  Testing isMap

    ✔ isMap is a Function

  Testing isNil

    ✔ isNil is a Function
    ✔ Returns true for null
    ✔ Returns true for undefined
    ✔ Returns false for an empty string

  Testing isNull

    ✔ isNull is a Function
    ✔ passed argument is a null
    ✔ passed argument is a null

  Testing isNumber

    ✔ isNumber is a Function
    ✔ passed argument is a number
    ✔ passed argument is not a number

  Testing isObject

    ✔ isObject is a Function
    ✔ isObject([1, 2, 3, 4]) is a object
    ✔ isObject([]) is a object
    ✔ isObject({ a:1 }) is a object
    ✔ isObject(true) is not a object

  Testing isObjectLike

    ✔ isObjectLike is a Function
    ✔ Returns true for an object
    ✔ Returns true for an array
    ✔ Returns false for a function
    ✔ Returns false for null

  Testing isPlainObject

    ✔ isPlainObject is a Function
    ✔ Returns true for a plain object
    ✔ Returns false for a Map (example of non-plain object)

  Testing isPrime

    ✔ isPrime is a Function
    ✔ passed number is a prime

  Testing isPrimitive

    ✔ isPrimitive is a Function
    ✔ isPrimitive(null) is primitive
    ✔ isPrimitive(undefined) is primitive
    ✔ isPrimitive(string) is primitive
    ✔ isPrimitive(true) is primitive
    ✔ isPrimitive(50) is primitive
    ✔ isPrimitive('Hello') is primitive
    ✔ isPrimitive(false) is primitive
    ✔ isPrimitive(Symbol()) is primitive
    ✔ isPrimitive([1, 2, 3]) is not primitive
    ✔ isPrimitive({ a: 123 }) is not primitive
    ✔ isPrimitive({ a: 123 }) takes less than 2s to run

  Testing isPromiseLike

    ✔ isPromiseLike is a Function
    ✔ Returns true for a promise-like object
    ✔ Returns false for null
    ✔ Returns false for an empty object

  Testing isRegExp

    ✔ isRegExp is a Function

  Testing isSet

    ✔ isSet is a Function

  Testing isSimilar

    ✔ isSimilar is a Function

  Testing isSorted

    ✔ isSorted is a Function
    ✔ Array is sorted in ascending order
    ✔ Array is sorted in ascending order
    ✔ Array is sorted in ascending order
    ✔ Array is sorted in ascending order
    ✔ Array is sorted in descending order
    ✔ Array is sorted in descending order
    ✔ Array is sorted in descending order
    ✔ Array is sorted in descending order
    ✔ Array is empty
    ✔ Array is not sorted, direction changed in array
    ✔ Array is not sorted, direction changed in array

  Testing isString

    ✔ isString is a Function
    ✔ foo is a string
    ✔ "10" is a string
    ✔ Empty string is a string
    ✔ 10 is not a string
    ✔ true is not string

  Testing isSymbol

    ✔ isSymbol is a Function
    ✔ Checks if the given argument is a symbol

  Testing isTravisCI

    ✔ isTravisCI is a Function
    ✔ Running on Travis, correctly evaluates

  Testing isTypedArray

    ✔ isTypedArray is a Function

  Testing isUndefined

    ✔ isUndefined is a Function
    ✔ Returns true for undefined

  Testing isUpperCase

    ✔ isUpperCase is a Function
    ✔ ABC is all upper case
    ✔ abc is not all upper case
    ✔ A3@$ is all uppercase

  Testing isValidJSON

    ✔ isValidJSON is a Function
    ✔ {"name":"Adam","age":20} is a valid JSON
    ✔ {"name":"Adam",age:"20"} is not a valid JSON
    ✔ null is a valid JSON

  Testing isWeakMap

    ✔ isWeakMap is a Function

  Testing isWeakSet

    ✔ isWeakSet is a Function

  Testing join

    ✔ join is a Function
    ✔ Joins all elements of an array into a string and returns this string
    ✔ Joins all elements of an array into a string and returns this string
    ✔ Joins all elements of an array into a string and returns this string

  Testing last

    ✔ last is a Function
    ✔ last({ a: 1234}) returns undefined
    ✔ last([1, 2, 3]) returns 3
    ✔ last({ 0: false}) returns undefined
    ✔ last(String) returns g
    ✔ last(null) throws an Error
    ✔ last(undefined) throws an Error
    ✔ last() throws an Error
    ✔ last([1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 1122, 32124, 23232]) takes less than 2s to run

  Testing lcm

    ✔ lcm is a Function
    ✔ Returns the least common multiple of two or more numbers.
    ✔ Returns the least common multiple of two or more numbers.

  Testing levenshteinDistance

    ✔ levenshteinDistance is a Function

  Testing longestItem

    ✔ longestItem is a Function
    ✔ Returns the longest object

  Testing lowercaseKeys

    ✔ lowercaseKeys is a Function
    ✔ Lowercases object keys
    ✔ Does not mutate original object

  Testing luhnCheck

    ✔ luhnCheck is a Function
    ✔ validates identification number
    ✔ validates identification number
    ✔ validates identification number

  Testing mapKeys

    ✔ mapKeys is a Function
    ✔ Maps keys

  Testing mapObject

    ✔ mapObject is a Function
    ✔ mapObject([1, 2, 3], a => a * a) returns { 1: 1, 2: 4, 3: 9 }
    ✔ mapObject([1, 2, 3, 4], (a, b) => b - a) returns { 1: -1, 2: -1, 3: -1, 4: -1 }
    ✔ mapObject([1, 2, 3, 4], (a, b) => a - b) returns { 1: 1, 2: 1, 3: 1, 4: 1 }

  Testing mapValues

    ✔ mapValues is a Function
    ✔ Maps values

  Testing mask

    ✔ mask is a Function
    ✔ Replaces all but the last num of characters with the specified mask character
    ✔ Replaces all but the last num of characters with the specified mask character
    ✔ Replaces all but the last num of characters with the specified mask character

  Testing matches

    ✔ matches is a Function
    ✔ Matches returns true for two similar objects
    ✔ Matches returns false for two non-similar objects

  Testing matchesWith

    ✔ matchesWith is a Function
    ✔ Returns true for two objects with similar values, based on the provided function

  Testing maxBy

    ✔ maxBy is a Function
    ✔ Produces the right result with a function
    ✔ Produces the right result with a property name

  Testing maxN

    ✔ maxN is a Function
    ✔ Returns the n maximum elements from the provided array
    ✔ Returns the n maximum elements from the provided array

  Testing median

    ✔ median is a Function
    ✔ Returns the median of an array of numbers
    ✔ Returns the median of an array of numbers

  Testing memoize

    ✔ memoize is a Function
    ✔ Function works properly
    ✔ Function works properly
    ✔ Cache stores values

  Testing merge

    ✔ merge is a Function
    ✔ Merges two objects

  Testing minBy

    ✔ minBy is a Function
    ✔ Produces the right result with a function
    ✔ Produces the right result with a property name

  Testing minN

    ✔ minN is a Function
    ✔ Returns the n minimum elements from the provided array
    ✔ Returns the n minimum elements from the provided array

  Testing mostPerformant

    ✔ mostPerformant is a Function
    ✔ Tested by @chalarangelo on 16/02/2018

  Testing negate

    ✔ negate is a Function
    ✔ Negates a predicate function

  Testing nest

    ✔ nest is a Function

  Testing nodeListToArray

    ✔ nodeListToArray is a Function

  Testing none

    ✔ none is a Function
    ✔ Returns true for arrays with no truthy values
    ✔ Returns false for arrays with at least one truthy value
    ✔ Returns true with a predicate function
    ✔ Returns false with predicate function

  Testing nthArg

    ✔ nthArg is a Function
    ✔ Returns the nth argument
    ✔ Returns undefined if arguments too few
    ✔ Works for negative values

  Testing nthElement

    ✔ nthElement is a Function
    ✔ Returns the nth element of an array.
    ✔ Returns the nth element of an array.

  Testing objectFromPairs

    ✔ objectFromPairs is a Function
    ✔ Creates an object from the given key-value pairs.

  Testing objectToPairs

    ✔ objectToPairs is a Function
    ✔ Creates an array of key-value pair arrays from an object.

  Testing observeMutations

    ✔ observeMutations is a Function
    ✔ Tested on 09/02/2018 by @chalarangelo

  Testing off

    ✔ off is a Function
    ✔ Tested by @chalarangelo on 16/02/2018

  Testing offset

    ✔ offset is a Function
    ✔ Offset of 0 returns the same array.
    ✔ Offset > 0 returns the offsetted array.
    ✔ Offset < 0 returns the reverse offsetted array.
    ✔ Offset greater than the length of the array returns the same array.
    ✔ Offset less than the negative length of the array returns the same array.
    ✔ Offsetting empty array returns an empty array.

  Testing omit

    ✔ omit is a Function
    ✔ Omits the key-value pairs corresponding to the given keys from an object

  Testing omitBy

    ✔ omitBy is a Function
    ✔ Creates an object composed of the properties the given function returns falsey for

  Testing on

    ✔ on is a Function
    ✔ Tested by @chalarangelo on 16/02/2018

  Testing onUserInputChange

    ✔ onUserInputChange is a Function
    ✔ Tested by @chalarangelo on 16/02/2018

  Testing once

    ✔ once is a Function
    ✔ Tested by @chalarangelo on 16/02/2018

  Testing orderBy

    ✔ orderBy is a Function
    ✔ Returns a sorted array of objects ordered by properties and orders.
    ✔ Returns a sorted array of objects ordered by properties and orders.

  Testing over

    ✔ over is a Function
    ✔ Applies given functions over multiple arguments

  Testing overArgs

    ✔ overArgs is a Function
    ✔ Invokes the provided function with its arguments transformed

  Testing pad

    ✔ pad is a Function
    ✔ cat is padded on both sides
    ✔ length of string is 8
    ✔ pads 42 with "0"
    ✔ does not truncates if string exceeds length

  Testing palindrome

    ✔ palindrome is a Function
    ✔ Given string is a palindrome
    ✔ Given string is not a palindrome

  Testing parseCookie

    ✔ parseCookie is a Function
    ✔ Parses the cookie

  Testing partial

    ✔ partial is a Function
    ✔ Prepends arguments

  Testing partialRight

    ✔ partialRight is a Function
    ✔ Appends arguments

  Testing partition

    ✔ partition is a Function
    ✔ Groups the elements into two arrays, depending on the provided function's truthiness for each element.

  Testing percentile

    ✔ percentile is a Function
    ✔ Uses the percentile formula to calculate how many numbers in the given array are less or equal to the given value.

  Testing permutations

    ✔ permutations is a Function
    ✔ Generates all permutations of an array

  Testing pick

    ✔ pick is a Function
    ✔ Picks the key-value pairs corresponding to the given keys from an object.

  Testing pickBy

    ✔ pickBy is a Function
    ✔ Creates an object composed of the properties the given function returns truthy for.

  Testing pipeAsyncFunctions

    ✔ pipeAsyncFunctions is a Function
    ✔ Produces the appropriate hash
    ✔ pipeAsyncFunctions result should be 15

  Testing pipeFunctions

    ✔ pipeFunctions is a Function
    ✔ Performs left-to-right function composition

  Testing pluralize

    ✔ pluralize is a Function
    ✔ Produces the plural of the word
    ✔ Produces the singular of the word
    ✔ Produces the plural of the word
    ✔ Prodices the defined plural of the word
    ✔ Works with a dictionary

  Testing powerset

    ✔ powerset is a Function
    ✔ Returns the powerset of a given array of numbers.

  Testing prefix

    ✔ prefix is a Function

  Testing prettyBytes

    ✔ prettyBytes is a Function
    ✔ Converts a number in bytes to a human-readable string.
    ✔ Converts a number in bytes to a human-readable string.
    ✔ Converts a number in bytes to a human-readable string.

  Testing primes

    ✔ primes is a Function
    ✔ Generates primes up to a given number, using the Sieve of Eratosthenes.

  Testing promisify

    ✔ promisify is a Function
    ✔ Returns a promise

  Testing pull

    ✔ pull is a Function
    ✔ Pulls the specified values

  Testing pullAtIndex

    ✔ pullAtIndex is a Function
    ✔ Pulls the given values
    ✔ Pulls the given values

  Testing pullAtValue

    ✔ pullAtValue is a Function
    ✔ Pulls the specified values
    ✔ Pulls the specified values

  Testing pullBy

    ✔ pullBy is a Function
    ✔ Pulls the specified values

  Testing quickSort

    ✔ quickSort is a Function
    ✔ quickSort([5, 6, 4, 3, 1, 2]) returns [1, 2, 3, 4, 5, 6]
    ✔ quickSort([-1, 0, -2]) returns [-2, -1, 0]
    ✔ quickSort() throws an error
    ✔ quickSort(123) throws an error
    ✔ quickSort({ 234: string}) throws an error
    ✔ quickSort(null) throws an error
    ✔ quickSort(undefined) throws an error
    ✔ quickSort([11, 1, 324, 23232, -1, 53, 2, 524, 32, 13, 156, 133, 62, 12, 4]) takes less than 2s to run

  Testing radsToDegrees

    ✔ radsToDegrees is a Function
    ✔ Returns the appropriate value

  Testing randomHexColorCode

    ✔ randomHexColorCode is a Function
    ✔ should be equal
    ✔ The color code starts with "#"
    ✔ The color code contains only valid hex-digits

  Testing randomIntArrayInRange

    ✔ randomIntArrayInRange is a Function
    ✔ The returned array contains only integers
    ✔ The returned array has the proper length
    ✔ The returned array's values lie between provided lowerLimit and upperLimit (both inclusive).

  Testing randomIntegerInRange

    ✔ randomIntegerInRange is a Function
    ✔ The returned value is an integer
    ✔ The returned value lies between provided lowerLimit and upperLimit (both inclusive).

  Testing randomNumberInRange

    ✔ randomNumberInRange is a Function
    ✔ The returned value is a number
    ✔ The returned value lies between provided lowerLimit and upperLimit (both inclusive).

  Testing readFileLines

    ✔ readFileLines is a Function
    ✔ Tested on 09/02/2018 by @chalarangelo

  Testing rearg

    ✔ rearg is a Function
    ✔ Reorders arguments in invoked function

  Testing recordAnimationFrames

    ✔ recordAnimationFrames is a Function

  Testing redirect

    ✔ redirect is a Function
    ✔ Tested on 09/02/2018 by @chalarangelo

  Testing reduceSuccessive

    ✔ reduceSuccessive is a Function
    ✔ Returns the array of successively reduced values

  Testing reduceWhich

    ✔ reduceWhich is a Function
    ✔ Returns the minimum of an array
    ✔ Returns the maximum of an array
    ✔ Returns the object with the minimum specified value in an array

  Testing reducedFilter

    ✔ reducedFilter is a Function
    ✔ Filter an array of objects based on a condition while also filtering out unspecified keys.

  Testing reject

    ✔ reject is a Function
    ✔ should be equivalent
    ✔ should be equivalent

  Testing remove

    ✔ remove is a Function
    ✔ Removes elements from an array for which the given function returns false

  Testing removeNonASCII

    ✔ removeNonASCII is a Function
    ✔ Removes non-ASCII characters

  Testing removeVowels

    ✔ removeVowels is a Function

  Testing renameKeys

    ✔ renameKeys is a Function
    ✔ should be equivalent

  Testing reverseString

    ✔ reverseString is a Function
    ✔ Reverses a string.

  Testing round

    ✔ round is a Function
    ✔ 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

    ✔ runAsync is a Function
    ✔ Tested on 09/02/2018 by @chalarangelo

  Testing runPromisesInSeries

    ✔ runPromisesInSeries is a Function

  Testing sample

    ✔ sample is a Function
    ✔ Returns a random element from the array
    ✔ Works for single-element arrays
    ✔ Returns undefined for empty array

  Testing sampleSize

    ✔ sampleSize is a Function
    ✔ Returns a single element without n specified
    ✔ Returns a random sample of specified size from an array
    ✔ Returns all elements in an array if n >= length
    ✔ Returns an empty array if original array is empty
    ✔ Returns an empty array if n = 0

  Testing scrollToTop

    ✔ scrollToTop is a Function
    ✔ Tested on 09/02/2018 by @chalarangelo

  Testing sdbm

    ✔ sdbm is a Function
    ✔ Hashes the input string into a whole number.

  Testing serializeCookie

    ✔ serializeCookie is a Function
    ✔ Serializes the cookie

  Testing setStyle

    ✔ setStyle is a Function
    ✔ Tested by @chalarangelo on 16/02/2018

  Testing shallowClone

    ✔ shallowClone is a Function
    ✔ Shallow cloning works
    ✔ Does not clone deeply

  Testing show

    ✔ show is a Function
    ✔ Tested by @chalarangelo on 16/02/2018

  Testing shuffle

    ✔ shuffle is a Function
    ✔ Shuffles the array
    ✔ New array contains all original elements
    ✔ Works for empty arrays
    ✔ Works for single-element arrays

  Testing similarity

    ✔ similarity is a Function
    ✔ Returns an array of elements that appear in both arrays.

  Testing size

    ✔ size is a Function
    ✔ Get size of arrays, objects or strings.
    ✔ Get size of arrays, objects or strings.

  Testing sleep

    ✔ sleep is a Function

  Testing smoothScroll

    ✔ smoothScroll is a Function

  Testing solveRPN

    ✔ solveRPN is a Function

  Testing sortCharactersInString

    ✔ sortCharactersInString is a Function
    ✔ Alphabetically sorts the characters in a string.

  Testing sortedIndex

    ✔ sortedIndex is a Function
    ✔ Returns the lowest index at which value should be inserted into array in order to maintain its sort order.
    ✔ Returns the lowest index at which value should be inserted into array in order to maintain its sort order.

  Testing sortedIndexBy

    ✔ sortedIndexBy is a Function
    ✔ Returns the lowest index to insert the element without messing up the list order

  Testing sortedLastIndex

    ✔ sortedLastIndex is a Function
    ✔ Returns the highest index to insert the element without messing up the list order

  Testing sortedLastIndexBy

    ✔ sortedLastIndexBy is a Function
    ✔ Returns the highest index to insert the element without messing up the list order

  Testing speechSynthesis

    ✔ speechSynthesis is a Function

  Testing splitLines

    ✔ splitLines is a Function
    ✔ Splits a multiline string into an array of lines.

  Testing spreadOver

    ✔ spreadOver is a Function
    ✔ Takes a variadic function and returns a closure that accepts an array of arguments to map to the inputs of the function.

  Testing stableSort

    ✔ stableSort is a Function
    ✔ Array is properly sorted

  Testing standardDeviation

    ✔ standardDeviation is a Function
    ✔ Returns the standard deviation of an array of numbers
    ✔ Returns the standard deviation of an array of numbers

  Testing stringPermutations

    ✔ stringPermutations is a Function
    ✔ Generates all stringPermutations of a string
    ✔ Works for single-letter strings
    ✔ Works for empty strings

  Testing stripHTMLTags

    ✔ stripHTMLTags is a Function
    ✔ Removes HTML tags

  Testing sum

    ✔ sum is a Function
    ✔ Returns the sum of two or more numbers/arrays.

  Testing sumBy

    ✔ sumBy is a Function

  Testing sumPower

    ✔ sumPower is a Function
    ✔ Returns the sum of the powers of all the numbers from start to end
    ✔ Returns the sum of the powers of all the numbers from start to end
    ✔ Returns the sum of the powers of all the numbers from start to end

  Testing symmetricDifference

    ✔ symmetricDifference is a Function
    ✔ Returns the symmetric difference between two arrays.

  Testing symmetricDifferenceBy

    ✔ symmetricDifferenceBy is a Function
    ✔ Returns the symmetric difference between two arrays, after applying the provided function to each array element of both

  Testing symmetricDifferenceWith

    ✔ symmetricDifferenceWith is a Function
    ✔ Returns the symmetric difference between two arrays, using a provided function as a comparator

  Testing tail

    ✔ tail is a Function
    ✔ Returns tail
    ✔ Returns tail

  Testing take

    ✔ take is a Function
    ✔ Returns an array with n elements removed from the beginning.
    ✔ Returns an array with n elements removed from the beginning.

  Testing takeRight

    ✔ takeRight is a Function
    ✔ Returns an array with n elements removed from the end
    ✔ Returns an array with n elements removed from the end

  Testing takeRightWhile

    ✔ takeRightWhile is a Function
    ✔ Removes elements until the function returns true

  Testing takeWhile

    ✔ takeWhile is a Function
    ✔ Removes elements until the function returns true

  Testing throttle

    ✔ throttle is a Function
    ✔ Tested by @chalarangelo on 16/02/2018

  Testing timeTaken

    ✔ timeTaken is a Function
    ✔ Tested by @chalarangelo on 16/02/2018

  Testing times

    ✔ times is a Function
    ✔ Runs a function the specified amount of times

  Testing toCamelCase

    ✔ toCamelCase is a Function
    ✔ toCamelCase('some_database_field_name') returns someDatabaseFieldName
    ✔ toCamelCase('Some label that needs to be camelized') returns someLabelThatNeedsToBeCamelized
    ✔ toCamelCase('some-javascript-property') return someJavascriptProperty
    ✔ 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

    ✖ currency: Euro | currencyLangFormat: Local
    ---------------------------------------------
      operator: equal
      expected: '€ 123,456.79'
      actual:   '€123,456.79'
      at: Test.test (/home/travis/build/Chalarangelo/30-seconds-of-code/test/toCurrency/toCurrency.test.js:8:5)
      stack: |-

    ✔ currency: US Dollar | currencyLangFormat: English (United States)

    ✖ currency: Japanese Yen | currencyLangFormat: Local
    -----------------------------------------------------
      operator: equal
      expected: 'JP¥ 322,342,436,423'
      actual:   '¥322,342,436,423'
      at: Test.test (/home/travis/build/Chalarangelo/30-seconds-of-code/test/toCurrency/toCurrency.test.js:11:5)
      stack: |-


  Testing toDecimalMark

    ✔ toDecimalMark is a Function
    ✔ convert a float-point arithmetic to the Decimal mark form

  Testing toKebabCase

    ✔ toKebabCase is a Function
    ✔ toKebabCase('camelCase') returns camel-case
    ✔ toKebabCase('some text') returns some-text
    ✔ toKebabCase('some-mixed-string With spaces-underscores-and-hyphens') returns some-mixed-string-with-spaces-underscores-and-hyphens
    ✔ 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 toOrdinalSuffix

    ✔ toOrdinalSuffix is a Function
    ✔ Adds an ordinal suffix to a number
    ✔ Adds an ordinal suffix to a number
    ✔ Adds an ordinal suffix to a number
    ✔ Adds an ordinal suffix to a number

  Testing toSafeInteger

    ✔ toSafeInteger is a Function
    ✔ Number(toSafeInteger(3.2)) is a number
    ✔ Converts a value to a safe integer
    ✔ toSafeInteger('4.2') returns 4
    ✔ toSafeInteger(4.6) returns 5
    ✔ toSafeInteger([]) returns 0
    ✔ 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
    ✔ toSnakeCase('camelCase') returns camel_case
    ✔ toSnakeCase('some text') returns some_text
    ✔ toSnakeCase('some-mixed_string With spaces_underscores-and-hyphens') returns some_mixed_string_with_spaces_underscores_and_hyphens
    ✔ 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 toggleClass

    ✔ toggleClass is a Function
    ✔ Tested by @chalarangelo on 16/02/2018

  Testing tomorrow

    ✔ tomorrow is a Function
    ✔ Returns the correct year
    ✔ Returns the correct month
    ✔ Returns the correct date

  Testing transform

    ✔ transform is a Function
    ✔ Transforms an object

  Testing truncateString

    ✔ truncateString is a Function
    ✔ Truncates a "boomerang" up to a specified length.

  Testing truthCheckCollection

    ✔ truthCheckCollection is a Function
    ✔ second argument is truthy on all elements of a collection

  Testing unary

    ✔ unary is a Function
    ✔ Discards arguments after the first one

  Testing uncurry

    ✔ uncurry is a Function
    ✔ Works without a provided value for n
    ✔ Works without n = 2
    ✔ Works withoutn = 3

  Testing unescapeHTML

    ✔ unescapeHTML is a Function
    ✔ Unescapes escaped HTML characters.

  Testing unflattenObject

    ✔ unflattenObject is a Function
    ✔ Unflattens an object with the paths for keys

  Testing unfold

    ✔ unfold is a Function
    ✔ Works with a given function, producing an array

  Testing union

    ✔ union is a Function
    ✔ 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

    ✔ unionBy is a Function
    ✔ Produces the appropriate results

  Testing unionWith

    ✔ unionWith is a Function
    ✔ Produces the appropriate results

  Testing uniqueElements

    ✔ uniqueElements is a Function
    ✔ 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

    ✔ untildify is a Function
    ✔ Contains no tildes
    ✔ Does not alter the rest of the path
    ✔ Does not alter paths without tildes

  Testing unzip

    ✔ unzip is a Function
    ✔ unzip([['a', 1, true], ['b', 2, false]]) equals [['a', 'b'], [1, 2], [true, false]]
    ✔ unzip([['a', 1, true], ['b', 2]]) equals [['a', 'b'], [1, 2], [true]]

  Testing unzipWith

    ✔ unzipWith is a Function
    ✔ unzipWith([[1, 10, 100], [2, 20, 200]], (...args) => args.reduce((acc, v) => acc + v, 0)) equals [3, 30, 300]

  Testing validateNumber

    ✔ validateNumber is a Function
    ✔ validateNumber(9) returns true
    ✔ validateNumber(234asd.slice(0, 2)) returns true
    ✔ validateNumber(1232) returns true
    ✔ validateNumber(1232 + 13423) returns true
    ✔ validateNumber(1232 * 2342 * 123) returns true
    ✔ validateNumber(1232.23423536) returns true
    ✔ validateNumber(234asd) returns false
    ✔ validateNumber(e234d) returns false
    ✔ validateNumber(false) returns false
    ✔ validateNumber(true) returns false
    ✔ validateNumber(null) returns false
    ✔ validateNumber(123 * asd) returns false

  Testing when

    ✔ when is a Function
    ✔ should be truthy
    ✔ should be truthy

  Testing without

    ✔ without is a Function
    ✔ without([2, 1, 2, 3], 1, 2) returns [3]
    ✔ without([]) returns []
    ✔ without([3, 1, true, '3', true], '3', true) returns [3, 1]
    ✔ without('string'.split(''), 's', 't', 'g') returns ['r', 'i', 'n']
    ✔ without() throws an error
    ✔ without(null) throws an error
    ✔ without(undefined) throws an error
    ✔ without() throws an error
    ✔ without({}) throws an error

  Testing words

    ✔ words is a Function
    ✔ words('I love javaScript!!') returns [I, love, javaScript]
    ✔ words('python, javaScript & coffee') returns [python, javaScript, coffee]
    ✔ words(I love javaScript!!) returns an array
    ✔ words() throws a error
    ✔ words(null) throws a error
    ✔ words(undefined) throws a error
    ✔ words({}) throws a error
    ✔ words([]) throws a error
    ✔ words(1234) throws a error

  Testing xProd

    ✔ xProd is a Function
    ✔ xProd([1, 2], ['a', 'b']) returns [[1, 'a'], [1, 'b'], [2, 'a'], [2, 'b']]

  Testing yesNo

    ✔ yesNo is a Function
    ✔ yesNo(Y) returns true
    ✔ yesNo(yes) returns true
    ✔ yesNo(foo, true) returns true
    ✔ yesNo(No) returns false
    ✔ yesNo() returns false
    ✔ yesNo(null) returns false
    ✔ yesNo(undefined) returns false
    ✔ yesNo([123, null]) returns false
    ✔ yesNo([Yes, No]) returns false
    ✔ yesNo({ 2: Yes }) returns false
    ✔ yesNo([Yes, No], true) returns true
    ✔ yesNo({ 2: Yes }, true) returns true

  Testing zip

    ✔ zip is a Function
    ✔ zip([a, b], [1, 2], [true, false]) returns [[a, 1, true], [b, 2, false]]
    ✔ zip([a], [1, 2], [true, false]) returns [[a, 1, true], [undefined, 2, false]]
    ✔ zip([]) returns []
    ✔ zip(123) returns []
    ✔ zip([a, b], [1, 2], [true, false]) returns an Array
    ✔ zip([a], [1, 2], [true, false]) returns an Array
    ✔ zip(null) throws an error
    ✔ zip(undefined) throws an error

  Testing zipObject

    ✔ zipObject is a Function
    ✔ zipObject([a, b, c], [1, 2]) returns {a: 1, b: 2, c: undefined}
    ✔ zipObject([a, b], [1, 2, 3]) returns {a: 1, b: 2}
    ✔ zipObject([a, b, c], string) returns { a: s, b: t, c: r }
    ✔ zipObject([a], string) returns { a: s }
    ✔ zipObject() throws an error
    ✔ zipObject([string], null) throws an error
    ✔ zipObject(null, [1]) throws an error
    ✔ zipObject(string) throws an error
    ✔ zipObject(test, string) throws an error

  Testing zipWith

    ✔ zipWith is a Function
    ✔ Sends a GET request
    ✔ Sends a POST request
    ✔ Runs the function provided
    ✔ Runs promises in series
    ✔ Works as expecting, passing arguments properly
    ✔ Works with multiple promises



  Failed Tests: There were 2 failures

    Testing toCurrency

      ✖ currency: Euro | currencyLangFormat: Local
      ✖ currency: Japanese Yen | currencyLangFormat: Local


  total:     1021
  passing:   1019
  failing:   2
  duration:  2.3s


undefined