Test

Array Library Tests

test: .sortBy(source, propList)

test: .groupByProp(arr, groupVal)

test: .groupByFn(arr, groupFn)

test: .groupByPath(arr, groupPath)

test: .groupBy(...args)

test: .cloneArray(arrayToClone)

test: .without(source, item)

test: .compact(source)

test: .shuffle(arrToShuffle)

test: .reject(source, fn)

test: .filter(source, fn)

test: .take(array, numberOfLastElements = 1)

test: .takeRight(array, numberOfLastElements = 1)

test: .takeWhile(array = [], whileFn)

test: .takeRightWhile(array = [], rightWhileFn)

test: .pluck(array = [], propName)

test: .fill(value, number)

test: .fillRight(value, number, arr)

test: .fillLeft(value, number, arr)

test: .times(iterationNumber, fn)

test: .every(source = [], fn)

test: .flatten(arrayToConcat)

test: .zipWithProjection()

test: .map(arrayToMap, fn)

test: .zip(...arrayToZip)

test: .some(source = [], fn)

test: .any(source = [], fn)

test: .sample(source)

test: .find(source, fn)

test: .first(array = [])

test: .head(array = [])

test: .last(array = [])

test: .tail(array = [])

test: .nth(source, index)

test: .castArray(...valueToCast)

test: .changeOrder(argsArray, order)

test: .numAndStrComparator(first, second, prop)

uniq(source)

Context Library Tests

test: .using(ctx)

test: .using(ctx) with class

test: .invoke(ctx)

test: .invoke(ctx) with class

test: .invokeWithCtx(ctx, ...fns)

test: .invokeWithCtx(ctx, ...fns) with class

test: using(ctx) invoke(...fns) with .wrap(fn, ...args)

test: using(ctx) invoke(...fns) with .wrap(fn, ...args) with class

SafeTupleBuilder Tests

test: .of(...args)

Tuple Tests

test: .getAll()

test: .unpack()

test: .get(index)

Fantasy Land Library Tests

test: Functor

test: Apply

test: Applicative

test: Monad

test: LazyFunctor

test: Maybe

test: Maybe.fromNullable

test: Maybe.of

test: Maybe.just

test: Maybe.nothing

test: Maybe.Just/Maybe.Nothing#map(f)

test: Maybe.Just/Maybe.Nothing#getValue()

test: Maybe.Just/Maybe.Nothing#get()

test: Maybe.Just/Maybe.Nothing#getOrElse()

test: Maybe.Just/Maybe.Nothing#chain()

test: Maybe.Just/Maybe.Nothing#filter()

test: Either

test: Either.fromNullable

test: Either.of

test: Either.tryCatch with falsy value

test: Either.tryCatch with truthy value

test: double Either.tryCatch

test: Either.right

test: Either.left

test: Either.Right/Either.Left#map(f)

test: Either.Right/Either.Left#getValue()

test: Either.Right/Either.Left#get()

test: Either.Right/Either.Left#getOrElse()

test: Either.Right/Either.Left#chain()

test: Either.Right/Either.Left#filter()

test: Either.Rigth/Either.Left#getOrElseThrow(err)

test: Either.Rigth/Either.Left#orElse(f)

test: Setoid

test: .toSetoid(eqFn) with positive case

test: .toSetoid(eqFn) with negative case

test: .isSetoid(obj)

Function Combinators Library Tests

test: .identity(value) (I combinator)

test: .always(value)

test: .flip(fn)

test: .thrush(x)

test: .duplication(fn)

test: .fork(join, fn1, fn2)

test: .seq(...fns)

test: .alt(fn1, fn2)

test: .tap(fn)

Function Library Tests

test: .curry(fn)

test: .partial(fn)

test: .compose(...fns)

test: .pipe(...fns)

test: .once(fn)

test: .unary(fn)

test: .memoize(fn)

test: .rearg(fn, order)

test: .after(count, fn)

test: .orCurry(fn, args)

Lens Library Tests

test: prop(propName, source)

test: prop(propName, source) with inner object

test: prop(propName, source) with wrong first argument

test: prop(propName, source) with wrong second argument

test: prop(propName, source) with undefined first argument

test: prop(propName, source) with undefined second argument

test: lensIndex(index, source)

test: lensIndex(index, source) with inner object

test: lensIndex(index, source) with wrong first argument

test: lensIndex(index, source) with wrong second argument

test: lensIndex(index, source) with undefined first argument

test: lensIndex(index, source) with undefined second argument

test: lensProp(propName)

test: lensProp(propName) with wrong first argument

test: lensProp(propName) with wrong second argument

test: lensProp(propName) with undefined first argument

test: lensProp(propName) with undefined first argument

test: assoc(propName, valueToBeSet, source)

test: assoc(propName, valueToBeSet, source) with inner object

test: assoc(propName, valueToBeSet, source) with wrong first argument

test: assoc(propName, valueToBeSet, source) with wrong third argument

test: assoc(propName, valueToBeSet, source) with undefined first argument

test: assoc(propName, valueToBeSet, source) with undefined third argument

test: assocPath(path, valueToBeSet, source)

test: assocPath(path, valueToBeSet, source) with array

test: assocPath(path, valueToBeSet, source) should not override old props

test: path(p, source)

test: pathEq(path, source, value)

test: pathOr(path, source, orValue)

test: pathSatisfies(path, source, satisfyFn)

Math Library Tests

test: .compareDecimalNumbers(number1, number2)

test: .add(augend, ...addendList)

test: .subtract(minuend, ...subtrahendList)

test: .multiply(multiplier, ...multiplicandList)

test: .divide(dividend, ...divisorList)

test: .getRandomInt(number)

test: .getRandomIntFromTo(number1, number2)

Object Library Tests

test: .deepFreeze(obj)

test: .cloneObject(objectToClone)

test: .deepClone(objectToDeepClone)

test: .pick(source, ...pickArray)

test: .omit(source, ...omitArray)

test: .safeGet(obj, ...props)

test: .safeGetOr(obj, orValue, ...props)

test: .safeGet(obj, ...props) with array

test: .safeGetOr(obj, orValue, ...props) with array

test: .getWithProps(obj, ...props)

test: .getWithCtx(obj, ...props)

test: .objectProjection(obj, cb, skipCb = (...args) => args)

test: conformsTo(object, predicateSetModel)

deepEquals(first, second)

Predicate Combinator Library Tests

test: .or(...predicates) - with number

test: .or(...predicates) - with array

test: .not(...predicates) - with number

test: .not(...predicates) - with array

test: .and(...predicates) - with string

test: .and(...predicates) - with array

test: .notOr(...predicates)

Predicate Library Tests

test: .lt(number)

test: .gt(number)

test: .range(number1, number2)

test: .lte(number)

test: .gte(number)

test: .rangeEqual(number1, number2)

test: .lt(number) combined with gt(number)

test: .eq(elem1)

test: .notEq(elem1)

String Library Tests

test: .buildResource(src, ...args)

test: .replaceAll(replaceable, from, to)

test: .replaceAllDifferences(replaceable, fromList, to)

test: .includes(source, includement)

test: .trim(strSource)

test: .equalsIgnoreCase(str1, str2)

test: .upperFirst(str = "")

test: .getFirstUpperLetter(strValue)

test: .getLastUpperLetter(strValue)

test: .getFirstLowerLetter(strValue)

test: .getLastLowerLetter(strValue)

test: .words(strValue)

test: .snakeCase(str)

test: .kebabCase(str)

test: .camelCase(str)

Type Library Tests

test: .isNull(value)

test: .isNotNull(value)

test: .isNaN(number)

test: .isNotNaN(number)

test: .isNegativeZero(number)

test: .isNotNegativeZero(number)

test: .isArray(value)

test: .isNotArray(value)

test: .isNumber(value)

test: .isNotNumber(value)

test: .isUndefined(value)

test: .isNotUndefined(value)

test: .isDate(value)

test: .isNotDate(value)

test: .isObject(value)

test: .isNotObject(value)

test: .isBoolean(value)

test: .isNotBoolean(value)

test: .isSymbol(value)

test: .isNotSymbol(value)

test: .isString(value)

test: .isNotString(value)

test: .isRegExp(value)

test: .isNotRegExp(value)

test: .isFunction(value)

test: .isNotFunction(value)

test: .isPrimitive(value)

test: .isNotPrimitive(value)

test: .getType(value)

test: .toBe(expectation)

test: .notToBe(expectation)

test: .getTypeByClass(clazz)

test .typeCheck(clazz, actualType) positive

test .typeCheck(clazz, actualType) negative