tests/testthat/test-numeric.R

In wwbrannon/schemeR: Ports of Lisp/Scheme Features to R

context("Numeric aliases and functions")

test_that("Numeric aliases work correctly", {
    expect_identical(modulo, remainder)

    expect_equal((-3) ^ 5, expt(-3, 5))
    expect_equal(0 ^ 1, expt(0, 5))
    expect_equal(0 ^ 0, expt(0, 0))
    expect_equal(4 ^ (-5), expt(4, -5))
    expect_error(expt("foo", 5))
    expect_error(expt(list(1,2), 5))
    expect_null(expt(nil, 3))
    expect_null(expt(3, nil))
    expect_null(expt(nil, nil))

    expect_equal(15 %/% 3, quotient(15, 3))
    expect_equal(0 %/% 1, quotient(0, 1))
    expect_equal(5 %/% 0, quotient(5, 0))
    expect_equal(35 %/% -4, quotient(35, -4))
    expect_true(is.nan(quotient(0, 0)))
    expect_error(quotient("foo", 5))
    expect_error(quotient(list(1,2), 5))
    expect_null(quotient(nil, 3))
    expect_null(quotient(3, nil))
    expect_null(quotient(nil, nil))

    expect_equal(15 %% 3, remainder(15, 3))
    expect_equal(0 %% 1, remainder(0, 1))
    expect_equal(5 %% 0, remainder(5, 0))
    expect_equal(35 %% -4, remainder(35, -4))
    expect_true(is.nan(remainder(0, 0)))
    expect_error(remainder("foo", 5))
    expect_error(remainder(list(1,2), 5))
    expect_null(remainder(nil, 3))
    expect_null(remainder(3, nil))
    expect_null(remainder(nil, nil))
})

test_that("Numeric predicates work correctly", {
    expect_true(is.number(numeric(0)))
    expect_true(is.number(0))
    expect_true(is.number(1.0))
    expect_true(is.number(134.124))
    expect_true(is.number(-134.124))
    expect_false(is.number(complex(real=14, im=124)))
    expect_false(is.number(nil))
    expect_false(is.number("foo"))
    expect_false(is.number(expression))

    expect_true(is.even(0))
    expect_true(is.even(2))
    expect_true(is.even(11352354))
    expect_true(is.even(-2))
    expect_true(is.even(-234))
    expect_true(is.even(234.0))
    expect_true(is.even(-234.0))
    expect_false(is.even(1))
    expect_false(is.even(135))
    expect_false(is.even(134.1243))
    expect_false(is.even(135.1243))
    expect_false(is.even(-135.1243))
    expect_false(is.even(nil))
    expect_error(is.even(sum))
    expect_error(is.even("foo"))
    expect_error(is.even(list(1,2,3)))

    expect_true(is.odd(1))
    expect_true(is.odd(3))
    expect_true(is.odd(11352355))
    expect_true(is.odd(-3))
    expect_true(is.odd(-235))
    expect_true(is.odd(235.0))
    expect_true(is.odd(-235.0))
    expect_false(is.odd(0))
    expect_false(is.odd(134))
    expect_false(is.odd(134.1243))
    expect_false(is.odd(135.1243))
    expect_false(is.odd(-135.1243))
    expect_false(is.odd(nil))
    expect_error(is.odd(sum))
    expect_error(is.odd("foo"))
    expect_error(is.odd(list(1,2,3)))

    expect_true(is.zero(0))
    expect_true(is.zero(-0))
    expect_true(is.zero(0.0))
    expect_true(is.zero(-0.0))
    expect_false(is.zero(1))
    expect_false(is.zero(nil))
    expect_false(is.zero(-1))
    expect_error(is.zero(sum))
    expect_error(is.zero("foo"))
    expect_error(is.zero(list(1,2,3)))

    expect_true(is.positive(1))
    expect_true(is.positive(3))
    expect_true(is.positive(11352355))
    expect_false(is.positive(-3))
    expect_false(is.positive(-235))
    expect_true(is.positive(235.0))
    expect_false(is.positive(-235.0))
    expect_false(is.positive(0))
    expect_true(is.positive(134))
    expect_true(is.positive(134.1243))
    expect_true(is.positive(135.1243))
    expect_false(is.positive(-135.1243))
    expect_false(is.positive(nil))
    expect_error(is.positive(sum))
    expect_error(is.positive("foo"))
    expect_error(is.positive(list(1,2,3)))

    expect_false(is.negative(1))
    expect_false(is.negative(3))
    expect_false(is.negative(11352355))
    expect_true(is.negative(-3))
    expect_true(is.negative(-235))
    expect_false(is.negative(235.0))
    expect_true(is.negative(-235.0))
    expect_false(is.negative(0))
    expect_false(is.negative(134))
    expect_false(is.negative(134.1243))
    expect_false(is.negative(135.1243))
    expect_true(is.negative(-135.1243))
    expect_false(is.negative(nil))
    expect_error(is.negative(sum))
    expect_error(is.negative("foo"))
    expect_error(is.negative(list(1,2,3)))
})