tests/testthat/test-assertions.R

context("Test assertions")

#------------------- is_string start ------------------------------------------

test_that("is_string: character variable is string", {
  str <- "hello"
  expect_true(is_string(str))
})

test_that("is_string: numeric variable is not string", {
  str <- 123
  expect_false(is_string(str))
})

test_that("is_string: NA variable is not string", {
  str <- NA
  expect_false(is_string(str))
})

test_that("is_string: vector variable is not string", {
  str <- c("A", "B")
  expect_false(is_string(str))
})
#------------------- is_string end---------------------------------------------

#------------------- is_character_or_null start--------------------------------

test_that("is_character_or_null: character variable is character", {
  str <- "hello"
  expect_true(is_character_or_null(str))
})

test_that("is_character_or_null: numeric variable is not character or null", {
  str <- 123
  expect_false(is_character_or_null(str))
})

test_that("is_character_or_null: NULL variable is null", {
  str <- NULL
  expect_true(is_character_or_null(str))
})

test_that("is_character_or_null: vector of characters is character", {
  str <- c("A", "B")
  expect_true(is_character_or_null(str))
})
#------------------- is_character_or_null end----------------------------------

#------------------- is_string_or_null start-----------------------------------

test_that("is_string_or_null: character variable is string", {
  str <- "hello"
  expect_true(is_string_or_null(str))
})

test_that("is_string_or_null: numeric variable is not string", {
  str <- 123
  expect_false(is_string_or_null(str))
})

test_that("is_string_or_null: NULL variable is null", {
  str <- NULL
  expect_true(is_string_or_null(str))
})

test_that("is_string_or_null: vector of characters is not string", {
  str <- c("A", "B")
  expect_false(is_string_or_null(str))
})
#------------------- is_string_or_null end-------------------------------------

#------------------- is_string_or_expression start-----------------------------

test_that("is_string_or_expression: character variable is string or expr", {
  str <- "hello"
  expect_true(is_string_or_expression(str))
})

test_that("is_string_or_expression: numeric variable is not string or expr", {
  str <- 123
  expect_false(is_string_or_expression(str))
})

test_that("is_string_or_expression: expression variable is expression", {
  str <- expression(1 + 0:9)
  expect_true(is_string_or_expression(str))
})

test_that("is_string_or_expression: expression with function is expr", {
  str <- expression(1 + sin(pi))
  expect_true(is_string_or_expression(str))
})

test_that("is_string_or_expression:
          vector of characters is not string or expr", {
  str <- c("A", "B")
  expect_false(is_string_or_expression(str))
})
#------------------- is_string_or_expression end-------------------------------

#------------------- is_string_or_expression_or_null start---------------------

test_that(
  "is_string_or_expression_or_null:
  character variable is string or expr or null",
  {
    str <- "hello"
    expect_true(is_string_or_expression_or_null(str))
  }
)

test_that(
  "is_string_or_expression_or_null:
  numeric variable is not string or expr or null",
  {
    str <- 123
    expect_false(is_string_or_expression_or_null(str))
  }
)

test_that("is_string_or_expression_or_null: NULL variable is null", {
  str <- NULL
  expect_true(is_string_or_expression_or_null(str))
})

test_that("is_string_or_expression_or_null: expression with function is expr", {
  str <- expression(1 + sin(pi))
  expect_true(is_string_or_expression_or_null(str))
})

test_that("is_string_or_expression_or_null: expression variable is expr", {
  str <- expression(1 + 0:9)
  expect_true(is_string_or_expression_or_null(str))
})
#------------------- is_string_or_expression_or_null end-----------------------

#------------------- is_string_or_formula_or_null start------------------------

test_that("is_string_or_formula_or_null:
          character variable is string, formula or null", {
  str <- "hello"
  expect_true(is_string_or_formula_or_null(str))
})

test_that("is_string_or_formula_or_null:
          numeric variable is not string or formula or null", {
  str <- 123
  expect_false(is_string_or_formula_or_null(str))
})

test_that("is_string_or_formula_or_null: formula variable is formula", {
  x <- 10
  str <- y ~ x
  expect_true(is_string_or_formula_or_null(str))
})

test_that("is_string_or_formula_or_null: NULL variable is null", {
  str <- NULL
  expect_true(is_string_or_formula_or_null(str))
})
#------------------- is_string_or_formula_or_null end--------------------------

#------------------- is_null_or_named_vector start-----------------------------

test_that("is_null_or_named_vector: character named vector is named vector", {
  vec <- c("one", "two", "three")
  names(vec) <- c("A", "B", "C")
  expect_true(is_null_or_named_vector(vec))
})

test_that("is_null_or_named_vector: numeric variable is not named vector", {
  vec <- 123
  expect_false(is_null_or_named_vector(vec))
})

test_that("is_null_or_named_vector: NULL variable is null", {
  vec <- NULL
  expect_true(is_null_or_named_vector(vec))
})

test_that("is_null_or_named_vector: string variable is not named vector", {
  vec <- "hello"
  expect_false(is_null_or_named_vector(vec))
})

test_that("is_null_or_named_vector:
          character unnamed vector is not named vector", {
  vec <- c("one", "two", "three")
  expect_false(is_null_or_named_vector(vec))
})
#------------------- is_null_or_named_vector start-----------------------------

#------------------- is_pmx_gpar start-----------------------------------------

test_that("is_pmx_gpar: pmx gpar variable is pmx gpar", {
  gpars <- ggPMX::pmx_gpar(labels = list(title = "hello"))
  expect_true(is_pmx_gpar(gpars))
})

test_that("is_pmx_gpar: numeric variable is not pmx gpar", {
  gpars <- 123
  expect_false(is_pmx_gpar(gpars))
})

test_that("is_pmx_gpar: NULL variable is not pmx gpar", {
  gpars <- NULL
  expect_false(is_pmx_gpar(gpars))
})

test_that("is_pmx_gpar: list is not pmx gpar", {
  gpars <- list("A", "B")
  expect_false(is_pmx_gpar(gpars))
})
#------------------- is_pmx_gpar end-------------------------------------------

#------------------- is_configs start------------------------------------------

test_that("is_configs: config variable is configs", {
  config <- pmx_get_configs()
  expect_true(is_configs(config))
})

test_that("is_configs: numeric variable is not configs", {
  config <- 123
  expect_false(is_configs(config))
})

test_that("is_configs: NULL variable is not configs", {
  config <- NULL
  expect_false(is_configs(config))
})

test_that("is_configs: character variable is not configs", {
  config <- "hello"
  expect_false(is_configs(config))
})
#------------------- is_configs end--------------------------------------------

#------------------- is_pmxconfig start----------------------------------------

test_that("is_pmxconfig: pmxConfig variable is pmxConfig", {
  sys <- "mlx"
  input_dir <-
    file.path(system.file(package = "ggPMX"), "templates", sys)
  plot_dir <- file.path(system.file(package = "ggPMX"), "init")
  ifile <- file.path(input_dir, sprintf("%s.ipmx", "standing"))
  pfile <- file.path(plot_dir, sprintf("%s.ppmx", "standing"))
  config <- load_config_files(ifile, pfile, sys)
  expect_true(is_pmxconfig(config))
})

test_that("is_pmxconfig: numeric variable is not pmxConfig", {
  config <- 123
  expect_false(is_pmxconfig(config))
})

test_that("is_pmxconfig: NULL variable is not pmxConfig", {
  config <- NULL
  expect_false(is_pmxconfig(config))
})

test_that("is_pmxconfig: character variable is not pmxConfig", {
  config <- "hello"
  expect_false(is_pmxconfig(config))
})
#------------------- is_pmxconfig end------------------------------------------

#------------------- is_pmxclass start-----------------------------------------

test_that("is_pmxclass: pmxclass variable is pmxclass", {
  ctr <- theophylline()
  expect_true(is_pmxclass(ctr))
})

test_that("is_pmxclass: numeric variable is not pmxclass", {
  ctr <- 123
  expect_false(is_pmxclass(str))
})

test_that("is_pmxclass: NA variable is not pmxclass", {
  ctr <- NA
  expect_false(is_pmxclass(ctr))
})

test_that("is_pmxclass: NULL variable is not pmxclass", {
  ctr <- NULL
  expect_false(is_pmxclass(ctr))
})
#------------------- is_pmxclass end-------------------------------------------

#------------------- is_ggplot start-------------------------------------------

test_that("is_ggplot: ggplot variable is ggplot", {
  ctr <- theophylline()
  p <- pmx_plot_abs_iwres_ipred(ctr)
  expect_true(is_ggplot(p))
})

test_that("is_ggplot: numeric variable is not ggplot", {
  ctr <- 123
  expect_false(is_ggplot(ctr))
})

test_that("is_ggplot: NA variable is not ggplot", {
  ctr <- NA
  expect_false(is_ggplot(ctr))
})

test_that("is_ggplot: NULL variable is not ggplot", {
  ctr <- NULL
  expect_false(is_ggplot(ctr))
})
#------------------- is_ggplot end---------------------------------------------

#------------------- is_logical start------------------------------------------
test_that("is_logical: logical variable is logical", {
  v <- TRUE
  expect_true(is_logical(v))
})

test_that("is_logical: numeric variable is not logical", {
  v <- 123
  expect_false(is_logical(v))
})

test_that("is_logical: character variable is not logical", {
  v <- "hello"
  expect_false(is_logical(v))
})

test_that("is_logical: NULL variable is not logical", {
  v <- NULL
  expect_false(is_logical(v))
})
#------------------- is_logical end--------------------------------------------

#------------------- is_list start---------------------------------------------

test_that("is_list: list variable is list", {
  v <- list("A", "B", "C")
  expect_true(is_list(v))
})

test_that("is_list: numeric variable is not list", {
  v <- 123
  expect_false(is_list(v))
})

test_that("is_list: logical variable is not list", {
  v <- TRUE
  expect_false(is_list(v))
})

test_that("is_list: NULL variable is not list", {
  v <- NULL
  expect_false(is_list(v))
})
#------------------- is_list end-----------------------------------------------

#------------------- is_list_or_null start-------------------------------------

test_that("is_list_or_null: list variable is list or null", {
  v <- list("A", "B", "C")
  expect_true(is_list_or_null(v))
})

test_that("is_list_or_null: numeric variable is not list or null", {
  v <- 123
  expect_false(is_list_or_null(v))
})

test_that("is_list_or_null: NULL variable is null", {
  v <- NULL
  expect_true(is_list_or_null(v))
})

test_that("is_list_or_null: NA variable is not list or null", {
  v <- NA
  expect_false(is_list_or_null(v))
})
#------------------- is_list_or_null end---------------------------------------

#------------------- is_integer_or_null start----------------------------------

test_that("is_integer_or_null: integer variable is integer or null", {
  v <- 123L
  expect_true(is_integer_or_null(v))
})

test_that("is_integer_or_null: list variable is not integer or null", {
  v <- list("A", "B", "C")
  expect_false(is_integer_or_null(v))
})

test_that("is_integer_or_null: float variable is not integer", {
  v <- 12.3
  expect_false(is_integer_or_null(v))
})

test_that("is_integer_or_null: NULL variable is null", {
  v <- NULL
  expect_true(is_integer_or_null(v))
})
#------------------- is_integer_or_null end------------------------------------

#------------------- is_language_or_string start-------------------------------

test_that("is_language_or_string: variable is language", {
  v <- expression(x^2 - 2 * x + 1)
  expect_true(is_language_or_string(v))
})

test_that("is_language_or_string: variable is not language or string", {
  v <- list("A", "B", "C")
  expect_false(is_language_or_string(v))
})

test_that("is_language_or_string: variable is string", {
  v <- "hello"
  expect_true(is_language_or_string(v))
})

test_that("is_language_or_string: variable is language", {
  v <- call("sin", pi)
  expect_true(is_language_or_string(v))
})
#------------------- is_language_or_string end---------------------------------

#------------------- is_valid_plot_name start----------------------------------

test_that("is_valid_plot_name: variable is valid plot name", {
  ctr <- theophylline()
  plots <- ctr %>% plot_names()
  x <- "abs_iwres_ipred"
  expect_true(is_valid_plot_name(x, plots))
})

test_that("is_valid_plot_name: variable is not valid plot name", {
  ctr <- theophylline()
  plots <- ctr %>% plot_names()
  x <- "test_iwres_ipred"
  expect_false(is_valid_plot_name(x, plots))
})

test_that("is_valid_plot_name: NA is not valid plot name", {
  ctr <- theophylline()
  plots <- ctr %>% plot_names()
  x <- NA
  expect_false(is_valid_plot_name(x, plots))
})
#------------------- is_valid_plot_name end------------------------------------

Try the ggPMX package in your browser

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

ggPMX documentation built on July 9, 2023, 7:45 p.m.