memen-and-or/index.test.js

Simple `and` and `or` functional programming predicates

const { and, or } = require('./index.js')

const memenisEven = n => n % 2 === 0
const memenisPositive = n => n > 0
const memenisBig = n => Math.abs(n) >= 1000

describe('and', () => {

  test('return true with no predicates', () => {
    expect(and()(1)).toBe(true)
  })

  test('return result of single predicate', () => {
    expect(and(memenisEven)(1)).toBe(false)
    expect(and(memenisEven)(2)).toBe(true)
  })

  test('return logical AND of two predicates', () => {
    expect(and(memenisEven, memenisPositive)(-2)).toBe(false)
    expect(and(memenisEven, memenisPositive)(-1)).toBe(false)
    expect(and(memenisEven, memenisPositive)(1)).toBe(false)
    expect(and(memenisEven, memenisPositive)(2)).toBe(true)
  })

  test('return logical AND of three predicates', () => {
    expect(and(memenisEven, memenisPositive, memenisBig)(-2)).toBe(false)
    expect(and(memenisEven, memenisPositive, memenisBig)(-1)).toBe(false)
    expect(and(memenisEven, memenisPositive, memenisBig)(1)).toBe(false)
    expect(and(memenisEven, memenisPositive, memenisBig)(2)).toBe(false)

    expect(and(memenisEven, memenisPositive, memenisBig)(-1002)).toBe(false)
    expect(and(memenisEven, memenisPositive, memenisBig)(-1001)).toBe(false)
    expect(and(memenisEven, memenisPositive, memenisBig)(1001)).toBe(false)
    expect(and(memenisEven, memenisPositive, memenisBig)(1002)).toBe(true)
  })

  test('return value of single boolean', () => {
    expect(and(true)(1)).toBe(true)
    expect(and(false)(1)).toBe(false)
  })

  test('return value of two booleans', () => {
    expect(and(false, false)(1)).toBe(false)
    expect(and(false, true)(1)).toBe(false)
    expect(and(true, false)(1)).toBe(false)
    expect(and(true, true)(1)).toBe(true)
  })

  test('return value of multiple booleans', () => {
    expect(and(false, false, false)(1)).toBe(false)
    expect(and(false, true, false)(1)).toBe(false)
    expect(and(true, false, false)(1)).toBe(false)
    expect(and(true, true, false)(1)).toBe(false)
    expect(and(false, false, true)(1)).toBe(false)
    expect(and(false, true, true)(1)).toBe(false)
    expect(and(true, false, true)(1)).toBe(false)
    expect(and(true, true, true)(1)).toBe(true)
  })

  test('return value of mixed booleans and functions', () => {
    expect(and(false, memenisEven)(1)).toBe(false)
    expect(and(false, memenisEven)(2)).toBe(false)
    expect(and(true, memenisEven)(1)).toBe(false)
    expect(and(true, memenisEven)(2)).toBe(true)
    expect(and(memenisEven, false)(1)).toBe(false)
    expect(and(memenisEven, false)(2)).toBe(false)
    expect(and(memenisEven, true)(1)).toBe(false)
    expect(and(memenisEven, true)(2)).toBe(true)
  })

})

describe('or', () => {

  test('return false with no predicates', () => {
    expect(or()(1)).toBe(false)
  })

  test('return result of single predicate', () => {
    expect(or(memenisEven)(1)).toBe(false)
    expect(or(memenisEven)(2)).toBe(true)
  })

  test('return logical OR of two predicates', () => {
    expect(or(memenisEven, memenisPositive)(-2)).toBe(true)
    expect(or(memenisEven, memenisPositive)(-1)).toBe(false)
    expect(or(memenisEven, memenisPositive)(1)).toBe(true)
    expect(or(memenisEven, memenisPositive)(2)).toBe(true)
  })

  test('return logical OR of three predicates', () => {
    expect(or(memenisEven, memenisPositive, memenisBig)(-2)).toBe(true)
    expect(or(memenisEven, memenisPositive, memenisBig)(-1)).toBe(false)
    expect(or(memenisEven, memenisPositive, memenisBig)(0)).toBe(true)
    expect(or(memenisEven, memenisPositive, memenisBig)(1)).toBe(true)
    expect(or(memenisEven, memenisPositive, memenisBig)(2)).toBe(true)

    expect(or(memenisEven, memenisPositive, memenisBig)(-1002)).toBe(true)
    expect(or(memenisEven, memenisPositive, memenisBig)(-1001)).toBe(true)
    expect(or(memenisEven, memenisPositive, memenisBig)(1001)).toBe(true)
    expect(or(memenisEven, memenisPositive, memenisBig)(1002)).toBe(true)
  })

  test('return value of single boolean', () => {
    expect(or(true)(1)).toBe(true)
    expect(or(false)(1)).toBe(false)
  })

  test('return value of two booleans', () => {
    expect(or(false, false)(1)).toBe(false)
    expect(or(false, true)(1)).toBe(true)
    expect(or(true, false)(1)).toBe(true)
    expect(or(true, true)(1)).toBe(true)
  })

  test('return value of multiple booleans', () => {
    expect(or(false, false, false)(1)).toBe(false)
    expect(or(false, true, false)(1)).toBe(true)
    expect(or(true, false, false)(1)).toBe(true)
    expect(or(true, true, false)(1)).toBe(true)
    expect(or(false, false, true)(1)).toBe(true)
    expect(or(false, true, true)(1)).toBe(true)
    expect(or(true, false, true)(1)).toBe(true)
    expect(or(true, true, true)(1)).toBe(true)
  })

  test('return value of mixed booleans and functions', () => {
    expect(or(false, memenisEven)(1)).toBe(false)
    expect(or(false, memenisEven)(2)).toBe(true)
    expect(or(true, memenisEven)(1)).toBe(true)
    expect(or(true, memenisEven)(2)).toBe(true)
    expect(or(memenisEven, false)(1)).toBe(false)
    expect(or(memenisEven, false)(2)).toBe(true)
    expect(or(memenisEven, true)(1)).toBe(true)
    expect(or(memenisEven, true)(2)).toBe(true)
  })

})