tests/testthat/test-sd-binary.R

test_that("the sample SD is `NA` for fewer than two values", {
  # The formula used to return `Inf` or `NaN` with the warning suppressed:
  sd_binary_groups(1, 0)          |> expect_na()
  sd_binary_0_n(1, 1)             |> expect_na()
  sd_binary_1_n(0, 1)             |> expect_na()
  sd_binary_mean_n(0.5, 1)        |> expect_na()
  sd_binary_mean_n(0.5, c(1, 2))  |> expect_equal(c(NA, sqrt(0.5)))
  sd_binary_groups(127, 153)      |> expect_equal(sqrt((280 / 279) * (127 * 153) / 280^2))
})


test_that("impossible counts and means are errors, not `NaN`", {
  -1  |> sd_binary_groups(5) |> expect_error("must not be negative")
  3   |> sd_binary_0_n(2)    |> expect_error("from 0 to `n`")
  -1  |> sd_binary_1_n(2)    |> expect_error("from 0 to `n`")
  1.5 |> sd_binary_mean_n(4) |> expect_error("between 0 and 1")
})


test_that("a near-whole `n` is the whole number it is", {
  1           |> sd_binary_0_n(2 - 1e-9)    |> expect_equal(sd_binary_0_n(1, 2))
  1           |> sd_binary_1_n(2 - 1e-9)    |> expect_equal(sd_binary_1_n(1, 2))
  0.5         |> sd_binary_mean_n(2 - 1e-9) |> expect_equal(sd_binary_mean_n(0.5, 2))
  (1 - 1e-9)  |> sd_binary_groups(1)        |> expect_equal(sd_binary_groups(1, 1))
})


test_that("input of the wrong type or length is an error", {
  # These failed in base R or recycled with only a base warning:
  "1"     |> sd_binary_1_n(3)       |> expect_error("`group_1` must be one of these types")
  "0.5"   |> sd_binary_mean_n(3)    |> expect_error("`x` must be one of these types")
  c(1, 2, 3) |> sd_binary_0_n(c(5, 6)) |> expect_error("Can't recycle")
  # A negative `n` is named as the culprit, not the count:
  1       |> sd_binary_1_n(-3)      |> expect_error("`n` must not be negative")
  NA      |> sd_binary_1_n(5)       |> expect_na()
  # A character `NA` used to reach the arithmetic:
  NA_character_ |> sd_binary_mean_n(5) |> expect_error("`x` must be one of these types")
  NA_character_ |> sd_binary_0_n(5)    |> expect_error("`group_0` must be one of these types")
})


test_that("a fractional count or `n` is `NA`, as it describes no data", {
  0.5 |> sd_binary_mean_n(10.5) |> expect_na()
  1.5 |> sd_binary_groups(2)    |> expect_na()
  1.5 |> sd_binary_0_n(10)      |> expect_na()
  c(127, 1.5) |> sd_binary_groups(153) |> is.na() |> expect_equal(c(FALSE, TRUE))
})


test_that("integer counts don't overflow", {
  # `group_0 * group_1` was an integer product, `NA` from 46,341 each:
  50000L |> sd_binary_groups(50000L) |> expect_equal(sd_binary_groups(50000, 50000))
  50000L |> sd_binary_0_n(100000L)   |> expect_equal(sd_binary_0_n(50000, 100000))
  50000L |> sd_binary_1_n(100000L)   |> expect_equal(sd_binary_1_n(50000, 100000))
})


test_that("huge counts don't overflow", {
  # `n^2` is `Inf` from about 1e154, which made the SD 0:
  1e200 |> sd_binary_groups(3e200) |> expect_equal(sqrt(0.25 * 0.75))
  1e200 |> sd_binary_0_n(4e200)    |> expect_equal(sqrt(0.25 * 0.75))
  3e200 |> sd_binary_1_n(4e200)    |> expect_equal(sqrt(0.25 * 0.75))
  # Nor does the SE underflow, which was 0 from about 1e300:
  1 |> sd_binary_1_n(1e300, sd_meaning = "se") |> expect_equal(1e-300)
  1 |> sd_binary_1_n(1e160, sd_meaning = "se") |> expect_equal(1e-160)
})


test_that("an infinite or `NaN` count, `n`, or mean is `NA`, not `NaN`", {
  Inf |> sd_binary_groups(10)  |> is.nan() |> expect_false()
  5   |> sd_binary_0_n(Inf)    |> is.nan() |> expect_false()
  0.5 |> sd_binary_mean_n(Inf) |> is.nan() |> expect_false()
  NaN |> sd_binary_mean_n(10)  |> is.nan() |> expect_false()
  NaN |> sd_binary_0_n(10)     |> is.nan() |> expect_false()
  c(Inf, 5) |> sd_binary_groups(10) |> is.na() |> expect_equal(c(TRUE, FALSE))
})


test_that("`sd_meaning` gives the population SD and the standard error", {
  sample <- sd_binary_groups(127, 153)
  127 |> sd_binary_groups(153, sd_meaning = "sd_pop") |> expect_equal(sample * sqrt(279 / 280))
  127 |> sd_binary_groups(153, sd_meaning = "se")     |> expect_equal(sample / sqrt(280))
  127 |> sd_binary_0_n(280, sd_meaning = "se")        |> expect_equal(sample / sqrt(280))
  153 |> sd_binary_1_n(280, sd_meaning = "sd_pop")    |> expect_equal(sample * sqrt(279 / 280))
  (153 / 280) |> sd_binary_mean_n(280, sd_meaning = "se") |> expect_equal(sample / sqrt(280))
  # A population SD needs one value only; the others need two:
  1 |> sd_binary_1_n(1, sd_meaning = "sd_pop") |> expect_equal(0)
  1 |> sd_binary_1_n(1, sd_meaning = "se")     |> expect_na()
  # Huge counts as above, where `n * (n - 1)` would overflow:
  1e200 |> sd_binary_groups(3e200, sd_meaning = "se") |> expect_equal(sqrt(0.25 * 0.75 / (4e200 - 1)))
  127 |> sd_binary_groups(153, sd_meaning = "sd_sample_or_pop") |> expect_error("can't be \"sd_sample_or_pop\"", fixed = TRUE)
  127 |> sd_binary_groups(153, sd_meaning = "var")              |> expect_error("sd_meaning")
  127 |> sd_binary_groups(153, sd_meaning = c("sd_pop", "se"))   |> expect_error("must have length 1")
})


test_that("`debit()` accepts the SDs computed under each `sd_meaning`", {
  for (sd_meaning in c("sd_sample", "sd_pop", "se")) {
    k <- 0:40
    sd <- k |> sd_binary_1_n(40, sd_meaning = sd_meaning) |> round(3)
    (k / 40) |> round(3) |> debit(sd, 40, 3, 3, "integer", sd_meaning = sd_meaning) |> all() |> expect_true()
  }
})


test_that("`sd_binary_mean_n()` still takes `mean`, with a warning", {
  rlang::local_options(lifecycle_verbosity = "warning")
  sd_binary_mean_n(mean = 0.3, n = 30) |> expect_warning("Please use the `x` argument")
  sd_binary_mean_n(mean = 0.3, n = 30) |> suppressWarnings() |> expect_equal(sd_binary_mean_n(0.3, 30))
  sd_binary_mean_n(mean = 0.3, x = 0.3, n = 30) |> expect_error("can't both be given")
})

Try the scrutiny package in your browser

Any scripts or data that you put into this service are public.

scrutiny documentation built on Nov. 11, 2026, 1:09 a.m.