tests/testthat/test-pmxClass.R

In ggPMXdevelopment/ggPMX: 'ggplot2' Based Tool to Facilitate Diagnostic Plots for NLME Models

if (helper_skip()) {

  context("Test pmxClass")
  pmxClassHelpers <- test_pmxClass_helpers()

  #test_that("can create pmx class", {
  #  ctr <- pmxClassHelpers$ctr
  #  expect_is(ctr, "pmxClass")
  #  expect_identical(
  #    sort(ctr %>% plot_names()),
  #    sort(c(
  #      "abs_iwres_ipred", "abs_iwres_time", "iwres_ipred", "npde_time", "iwres_time",
  #      "npde_pred", "dv_pred", "dv_ipred", "eta_hist", "eta_box", "individual",
  #      "eta_matrix", "eta_cats", "eta_conts",
  #      "iwres_qq", "npde_qq", "eta_qq", "iwres_dens"
  #    ))
  #  )
  #})
  #
  #test_that("can print pmx class", {
  #  ctr <- pmxClassHelpers$ctr
  #  expect_output(print(ctr), "pmx object:")
  #})
  #
  #test_that("can remove plot from pnmx class", {
  #  ctr <- pmxClassHelpers$ctr
  #  cplots <- ctr %>% plot_names()
  #  ctr$remove_plot(cplots[1])
  #  res <- setdiff(cplots, ctr %>% plot_names())
  #  expect_identical(res, cplots[1])
  #})
  #
  #test_that("can get pmx class config", {
  #  ctr <- pmxClassHelpers$ctr
  #  cplots <- ctr %>% plot_names()
  #  conf <- ctr$get_config("npde_time")
  #  clabels <- list(
  #    title = "NPDE vs TIME",
  #    subtitle = "",
  #    x = "TIME",
  #    y = "NPDE"
  #  )
  #  expect_identical(conf$gp$labels, clabels)
  #})
  ##------------------- get_data - start ------------------------------------------
  #
  #test_that("get_data: params NULL result: error missing arguments", {
  #  expect_error(get_data())
  #})
  #
  #test_that("get_data: params ctr result: error ctr is not a pmxClass object", {
  #  ctr <- ""
  #  expect_error(get_data(ctr))
  #})
  #
  #test_that("can get data from controller", {
  #  ctr <- pmxClassHelpers$ctr
  #  get_d <- ctr %>% get_data(data_set = "individual")
  #  expect_true(inherits(get_d, c("data.table", "data.frame")))
  #})
  #
  #test_that("can get data from controller", {
  #  ctr <- pmxClassHelpers$ctr
  #  inputData <- ctr %>% get_data("input")
  #  inNames <- c("ID", "DV", "TIME", "SEX", "WT0", "AGE0", "STUD")
  #  expect_true(all(inNames %in% names(inputData)))
  #
  #  peData <- ctr %>% get_data("estimates")
  #  peNames <- c("PARAM", "VALUE", "SE", "RSE", "PVALUE")
  #  expect_identical(names(peData), peNames)
  #
  #  mpData <- ctr %>% get_data("predictions")
  #  mpNames <- c(
  #    "ID", "TIME", "PRED", "NPDE", "IPRED", "IWRES", "DV",
  #    "SEX", "WT0", "AGE0", "STUD"
  #  )
  #  expect_true(all(mpNames %in% names(mpData)))
  #
  #  fgData <- ctr %>% get_data("finegrid")
  #  fgNames <- c("ID", "TIME", "PRED", "IPRED")
  #  expect_true(all(fgNames %in% names(fgData)))
  #})
  #
  ##------------------- get_data - end --------------------------------------------
  #
  ##------------------- set_plot - start ------------------------------------------
  #
  #test_that("set_plot: params NULL result: error missing arguments", {
  #  expect_error(set_plot())
  #})
  #
  #
  #test_that("set_plot: params ctr result: error ctr is not a pmxClass object", {
  #  ctr <- ""
  #  expect_error(set_plot(ctr))
  #})
  #
  #test_that("set_plot: params: ptype, pname, type result: error pname is not a character or NULL", {
  #  ctr <- pmxClassHelpers$ctr
  #  expect_error(ctr %>% set_plot("DIS", pname = 1, type = "box"))
  #})
  #
  #test_that("set_plot: params: ptype, pname result: error strat.color is not a character or NULL", {
  #  ctr <- pmxClassHelpers$ctr
  #  expect_error(ctr %>% set_plot("DIS", pname = "distr2", strat.color = TRUE))
  #})
  #
  #test_that("set_plot: params: ptype, pname result: error strat.facet is not a character or formula or NULL", {
  #  ctr <- pmxClassHelpers$ctr
  #  expect_error(ctr %>% set_plot("DIS", pname = "distr2", strat.facet = TRUE))
  #})
  #
  #
  #test_that("set_plot: params: ptype, pname result: identical names", {
  #  ctr <- pmxClassHelpers$ctr
  #  spl <- ctr %>% set_plot("DIS", pname = "distr1", type = "box")
  #  setNames <- c(
  #    ".__enclos_env__", "sim_blq", "time", "id", "bloq", "sim",
  #    "plot_file_name", "report_n", "report_queue", "save_dir", "footnote", "warnings",
  #    "endpoint", "abbrev", "re", "has_re", "settings", "strats",
  #    "occ", "conts", "cats", "dvid", "dv", "input_file",
  #    "input", "config", "data", "clone", "post_load", "plots",
  #    "get_plot", "set_config", "get_config", "remove_plot", "update_plot", "add_plot",
  #    "dequeue_plot", "enqueue_plot", "print", "initialize"
  #  )
  #  expect_identical(setNames, names(spl))
  #})
  #
  #test_that("can set plot and filter", {
  #  # set new plot
  #  ctr <- pmxClassHelpers$ctr
  #  ctr %>% set_plot("DIS", pname = "distr1", type = "box")
  #  p <- ctr %>% get_plot("distr1")
  #  pconf <- ggplot2::ggplot_build(p)
  #  expect_equal(length(pconf$data), 5)
  #  # set plot and filter
  #  ctr %>% set_plot("DIS", pname = "distr2", filter = ID < 10, type = "box")
  #  p <- ctr %>% get_plot("distr2")
  #  pconf <- ggplot2::ggplot_build(p)
  #  expect_equal(length(pconf$data), 5)
  #})
  #
  ##------------------- set_plot - end --------------------------------------------
  #
  #test_that("can disable draft for all plots", {
  #  theophylline <- file.path(
  #    system.file(package = "ggPMX"), "testdata",
  #    "theophylline"
  #  )
  #  WORK_DIR <- file.path(theophylline, "Monolix")
  #  input_file <- file.path(theophylline, "data_pk.csv")
  #
  #  ctr <-
  #    pmx_mlx(
  #      config = "standing",
  #      directory = WORK_DIR,
  #      input = input_file,
  #      dv = "Y",
  #      dvid = "DVID",
  #      cats = c("SEX"),
  #      conts = c("WT0", "AGE0"),
  #      strats = "STUD",
  #      settings = pmx_settings(is.draft = FALSE)
  #    )
  #
  #  is_draft <- vapply(
  #    ctr %>% plot_names(),
  #    function(p) {
  #      conf <- ctr %>% get_plot_config(p)
  #      conf$gp[["is.draft"]]
  #    }, TRUE
  #  )
  #  expect_false(any(is_draft))
  #})
  #
  #
  #test_that("can set draft to false for a single plot", {
  #  ctr <- pmxClassHelpers$ctr
  #  p <- ctr %>% pmx_plot_dv_pred(is.draft = FALSE)
  #})
  #
  #
  #
  #test_that("can create a controller with data.frame as input", {
  #  theophylline <- file.path(
  #    system.file(package = "ggPMX"), "testdata",
  #    "theophylline"
  #  )
  #  WORK_DIR <- file.path(theophylline, "Monolix")
  #  input_file <- file.path(theophylline, "data_pk.csv")
  #
  #  dat <- read.csv(input_file)
  #  dat$SEX <- factor(dat$SEX, levels = c(0, 1), labels = c("M", "F"))
  #
  #
  #  ctr4 <- pmx(
  #    config = "standing", sys = "mlx",
  #    directory = WORK_DIR,
  #    input = dat,
  #    dv = "Y",
  #    dvid = "DVID",
  #    cats = "SEX"
  #  )
  #
  #  expect_equal(nrow(ctr4 %>% get_data("input")), nrow(dat))
  #})
  #
  ##------------------- pmx_settings - start ---------------------------------------
  #
  #test_that("pmx_settings: params effects result: error effects should be a list", {
  #  effects <- c(
  #    levels = c("ka", "V", "Cl"),
  #    labels = c("Concentration", "Volume", "Clearance")
  #  )
  #  expect_error(pmx_settings(effects = effects))
  #})
  #
  #test_that("pmx_settings: params effects result: error effects should be a list
  #          that contains levels and labels", {
  #  effects <- list(
  #    lev = c("ka", "V", "Cl"),
  #    lab = c("Concentration", "Volume", "Clearance")
  #  )
  #  expect_error(pmx_settings(effects = effects))
  #})
  #
  #test_that("pmx_settings: params effects result: error effects should be a list
  #          that contains levels and labels have the same length", {
  #  effects <- list(
  #    levels = c("ka"),
  #    labels = c("Concentration", "Volume", "Clearance")
  #  )
  #  expect_error(pmx_settings(effects = effects))
  #})
  #
  #
  #test_that("pmx_settings: params is.draft result: identical names", {
  #  setg <- pmx_settings(is.draft = FALSE)
  #  settNames <- c(
  #    "is.draft", "use.abbrev", "color.scales", "use.labels", "cats.labels",
  #    "use.titles", "effects", "covariates"
  #  )
  #  expect_identical(settNames, names(setg))
  #})
  #
  #test_that(
  #  "can create controller global settings",
  #  expect_is(pmx_settings(), "pmxSettingsClass")
  #)
  #
  ##------------------- pmx_settings - start --------------------------------------
  #
  ##------------------- pmx_mlxtran - start ---------------------------------------
  #
  #test_that("pmx_mlxtran: params NULL result: error missing arguments", {
  #  expect_error(pmx_mlxtran())
  #})
  #
  #
  #test_that("pmx_mlxtran: params: file_name, endpoint, ect.;  result: identical structure", {
  #  mlxtran_path <- file.path(system.file(package = "ggPMX"), "testdata", "*_popPK_model", "project.mlxtran")
  #  ep <- pmx_endpoint(
  #    code = "1",
  #    file.code = "2"
  #  )
  #  ctr <- pmx_mlxtran(file_name = mlxtran_path, version = 1, endpoint = ep)
  #  expect_identical(ctr$endpoint$file.code, "2")
  #})
  #
  #test_that("pmx_mlxtran: params: file_name, endpoint, call = TRUE, ect.;  result: identical sturcture", {
  #  mlxtran_path <- file.path(system.file(package = "ggPMX"), "testdata", "*_popPK_model", "project.mlxtran")
  #  ep <- pmx_endpoint(
  #    code = "1",
  #    file.code = "2"
  #  )
  #  ctr <- pmx_mlxtran(file_name = mlxtran_path, version = 1, endpoint = ep, call = TRUE)
  #  expect_identical(ctr$config, "standing")
  #  expect_identical(ctr$dvid, "YTYPE")
  #  expect_identical(ctr$dv, "DV")
  #})
  #
  #
  #test_that("can create a controller from mlxtran with explicit path", {
  #  mlxtran_path <- file.path(system.file(package = "ggPMX"), "testdata", "1_popPK_model", "project.mlxtran")
  #  ctr <- pmx_mlxtran(file_name = mlxtran_path)
  #  expect_is(ctr, "pmxClass")
  #})
  #
  #test_that("can catch absence of version, when wildcard is used in file_name", {
  #  mlxtran_path <- file.path(system.file(package = "ggPMX"), "testdata", "*_popPK_model", "project.mlxtran")
  #  error_msg_wrong_version <- "Using wildcard in file_name assume providing non-negative version"
  #  error_msg_not_exist <- "file do not exist"
  #  expect_error(pmx_mlxtran(file_name = mlxtran_path), error_msg_wrong_version, fixed = TRUE)
  #  expect_error(pmx_mlxtran(file_name = mlxtran_path, version = -5), error_msg_wrong_version, fixed = TRUE)
  #  expect_error(pmx_mlxtran(file_name = mlxtran_path, version = 2), error_msg_not_exist, fixed = TRUE)
  #})
  #
  #test_that("can create a controller from mlxtran with wildcard in path", {
  #  mlxtran_path <- file.path(system.file(package = "ggPMX"), "testdata", "*_popPK_model", "project.mlxtran")
  #  ctr <- pmx_mlxtran(file_name = mlxtran_path, version = 1)
  #  expect_is(ctr, "pmxClass")
  #})
  ##------------------- pmx_mlxtran - end -----------------------------------------
  #
  ##------------------- pmx_sim - start -------------------------------------------
  #
  #test_that("pmx_sim: params result: pmxSimClass, list", {
  #  theo_path <- file.path(
  #    system.file(package = "ggPMX"), "testdata",
  #    "theophylline"
  #  )
  #  vpc_file <- file.path(theo_path, "sim.csv")
  #  sim <- pmx_sim(
  #    file = vpc_file,
  #    irun = "rep",
  #    idv = "TIME"
  #  )
  #
  #  expect_true(inherits(sim, c("pmxSimClass", "list")))
  #  expect_identical(sim$irun, "rep")
  #  simNames <- c("sim", "irun", "idv")
  #  expect_true(all(simNames %in% names(sim)))
  #  expect_error(pmx_sim())
  #})
  #
  #test_that("pmx_sim: params result: default values of the arguments", {
  #  theo_path <- file.path(
  #    system.file(package = "ggPMX"), "testdata",
  #    "theophylline"
  #  )
  #  vpc_file <- file.path(theo_path, "sim.csv")
  #  sim <- pmx_sim(
  #    file = vpc_file,
  #    irun = "rep"
  #  )
  #
  #  expect_identical(sim$data, NULL)
  #  expect_identical(sim$idv, "TIME")
  #  expect_true(inherits(sim$sim, c("data.table", "data.frame")))
  #})
  ##------------------- pmx_sim - end ---------------------------------------------
  #
  ##------------------- check_argument - start ------------------------------------
  #
  #test_that("check_argument: params value, pmxname = 'work_dir' result: identical inherits", {
  #  theophylline <- file.path(
  #    system.file(package = "ggPMX"), "testdata",
  #    "theophylline"
  #  )
  #  WORK_DIR <- file.path(theophylline, "Monolix")
  #  directory <- check_argument(WORK_DIR, "work_dir")
  #  expect_true(inherits(directory, "character"))
  #})
  #test_that("check_argument: params value, pmxname = 'input' result: identical inherits", {
  #  theophylline <- file.path(
  #    system.file(package = "ggPMX"), "testdata",
  #    "theophylline"
  #  )
  #
  #  input_file <- file.path(theophylline, "data_pk.csv")
  #  input <- check_argument(input_file, "input")
  #  expect_true(inherits(input, "character"))
  #})
  #
  #test_that("check_argument: params NULL result: error missing arguments", {
  #  expect_error(check_argument())
  #})
  #
  #test_that("check_argument: params value = NULL, pmxname  result: error set a NULL argument", {
  #  expect_error(check_argument(value = NULL, pmxname = "work_dir"))
  #})
  #
  ##------------------- check_argument - end --------------------------------------
  #
  ##------------------- pmx - start -----------------------------------------------
  #test_that("pmx: params NULL result: error missing arguments", {
  #  expect_error(pmx())
  #})
  #
  #test_that("pmx: params: fit result: default values of the arguments ", {
  #  theophylline <- file.path(
  #    system.file(package = "ggPMX"), "testdata",
  #    "theophylline"
  #  )
  #  WORK_DIR <- file.path(theophylline, "Monolix")
  #  input_file <- file.path(theophylline, "data_pk.csv")
  #  pm <- pmx(directory = WORK_DIR, input = input_file, dv = "EVID")
  #  settings <- pmx_settings()
  #
  #  expect_identical(pm$cats, "")
  #  expect_identical(pm$conts, "")
  #  expect_identical(pm$occ, "")
  #  expect_identical(pm$strats, "")
  #  expect_false(pm$sim_blq)
  #  expect_identical(pm$dvid, "DVID")
  #  expect_identical(pm$endpoint, NULL)
  #  expect_identical(pm$settings, settings)
  #  expect_identical(pm$bloq, NULL)
  #  expect_identical(pm$sim, NULL)
  #})
  #
  #test_that("pmx: params; result:  error class cat, conts, occ, strats, bloq
  #          are not valid character vectors", {
  #  theophylline <- file.path(
  #    system.file(package = "ggPMX"), "testdata",
  #    "theophylline"
  #  )
  #  WORK_DIR <- file.path(theophylline, "Monolix")
  #  input_file <- file.path(theophylline, "data_pk.csv")
  #  expect_error(pmx(directory = WORK_DIR, input = input_file, dv = "EVID", cats = 1))
  #  expect_error(pmx(directory = WORK_DIR, input = input_file, dv = "EVID", conts = 1))
  #  expect_error(pmx(directory = WORK_DIR, input = input_file, dv = "EVID", occ = 1))
  #  expect_error(pmx(directory = WORK_DIR, input = input_file, dv = "EVID", strats = 1))
  #  expect_error(pmx(directory = WORK_DIR, input = input_file, dv = "EVID", bloq = 1))
  #})
  #
  ##------------------- pmx - end -------------------------------------------------
  #
  #------------------- pmx_mlx - end ---------------------------------------------

  test_that("pmx_mlx: params NULL result: error missing arguments", {
    expect_error(pmx_mlx())
  })

  test_that("pmx_mlx: params; result: identical inherits", {
    theophylline <- file.path(
      system.file(package = "ggPMX"), "testdata",
      "theophylline"
    )
    WORK_DIR <- file.path(theophylline, "Monolix")
    input_file <- file.path(theophylline, "data_pk.csv")

    ctr <-
      pmx_mlx(
        config = "standing",
        directory = WORK_DIR,
        input = input_file,
        dv = "Y",
        dvid = "DVID",
        cats = c("SEX"),
        conts = c("WT0", "AGE0"),
        strats = "STUD",
        settings = pmx_settings(is.draft = FALSE)
      )
    expect_true(inherits(ctr, c("pmxClass", "R6")))
  })
  #------------------- pmx_mlx - end ---------------------------------------------

  #------------------- formula_to_text - end -------------------------------------

  test_that("formula_to_text: params NULL result: error missing arguments", {
    expect_error(formula_to_text())
  })

  test_that("formula_to_text: params form result: identical inherits", {
    f1 <- formula_to_text("strat.facet")
    f2 <- formula_to_text(EFFECT ~ variable)
    f3 <- formula_to_text(1)
    expect_true(inherits(f1, "character"))
    expect_true(inherits(f2, "character"))
    expect_true(inherits(f3, "numeric"))
  })

  test_that("pmx_settings are applied to the plot", {
    my_settings <- pmx_settings(
      effects=list(
        levels=c("Cl","ka","V"),
        labels=c("Clearance", "Absorption_rate", "Volume")
      ),
      covariates=pmx_cov(values=list("SEX"), labels=list("Sex"))
    )

    theophylline <- file.path(
      system.file(package="ggPMX"),
      "testdata",
      "theophylline"
    )

    WORK_DIR <- file.path(theophylline, "Monolix")
    input_file <- file.path(theophylline, "data_pk.csv")

    ctr <- pmx_mlx(
      directory=WORK_DIR,
      input=input_file,
      dv="Y",
      dvid="DVID",
      conts=c("WT0", "AGE0"),
      settings=my_settings,
      cats=c("SEX"),
      config="standing", strats=c("STUD")
    )

    p <- ctr %>% pmx_plot_eta_cats()
    expect_identical(levels(p[["data"]][["variable"]]), c("Sex"))
    expect_identical(
      levels(p[["data"]][["EFFECT"]]),
      c("Clearance", "Absorption_rate", "Volume")
    )
  })


  #------------------- formula_to_text - end -------------------------------------

  #------------------- pmx_endpoint - start --------------------------------------

  test_that("pmx_endpoint: params NULL result: error missing arguments", {
    expect_error(pmx_endpoint())
  })

  test_that("pmx_endpoint: params: code, file.code, ect.; result: error code is not a character vector ", {
    expect_error(pmx_endpoint(
      code = 3,
      file.code = "1"
    ))
  })

  test_that("pmx_endpoint: params: code, file.code, ect.; result: error file.code is not a character vector ", {
    expect_error(pmx_endpoint(
      code = "3",
      file.code = 1
    ))
  })

  test_that("pmx_endpoint: params: code, file.code, ect.; result: error label is not a character vector ", {
    expect_error(pmx_endpoint(
      label = 1,
      code = "3",
      file.code = "1"
    ))
  })

  test_that("pmx_endpoint: params: code, file.code, ect.; result: error trans is not a character vector ", {
    expect_error(pmx_endpoint(
      trans = NA,
      code = "3",
      file.code = "1"
    ))
  })

  test_that("pmx_endpoint: params: code, file.code, ect.; result: error unit is not a character vector ", {
    expect_error(pmx_endpoint(
      unit = TRUE,
      code = "3",
      file.code = "1"
    ))
  })

  test_that("pmx_endpoint: params: code, file.code, ect.; result: identical inherits ", {
    ep <- pmx_endpoint(
      code = "3",
      file.code = "1"
    )
    expect_true(inherits(ep, "pmxEndpointClass"))
  })

  test_that("pmx_endpoint: params: code, file.code, ect.; result: identical names ", {
    ep <- pmx_endpoint(
      code = "3",
      file.code = "1"
    )
    epNames <- c("code", "label", "unit", "file.code", "trans")
    expect_identical(names(ep), epNames)
  })

  #------------------- pmx_endpoint - end ----------------------------------------

  #------------------- pmx_bloq - start ------------------------------------------

  test_that("pmx_bloq: params NULL result: identical inherits", {
    expect_true(inherits(pmx_bloq(), "pmxBLOQClass"))
  })

  test_that("pmx_bloq: params: cens, limit; result: identical names ", {
    bloq <- pmx_bloq(cens = "BLOQ_name", limit = "LIMIT_name")
    blNames <- c("cens", "limit", "show", "colour", "size", "linewidth", "alpha")
    expect_identical(names(bloq), blNames)
  })

  test_that("pmx_bloq: params: cens, limit; result: identical structure ", {
    bloq <- pmx_bloq(cens = "BLOQ_name", limit = "LIMIT_name")
    expect_true(bloq$show)
    expect_identical(bloq$cens, "BLOQ_name")
    expect_identical(bloq$colour, "pink")
  })

  #------------------- pmx_bloq - end --------------------------------------------

  #------------------- print.abbreviation - start --------------------------------

  test_that("print.abbreviation: params x result: x is not an abbreviation ", {
    expect_error(print.abbreviation(x = ""))
  })

  test_that("print.abbreviation: params NULL result: error missing arguments", {
    expect_error(print.abbreviation())
  })

  #------------------- print.abbreviation - end ----------------------------------

  #------------------- get_abbrev - start ----------------------------------------

  test_that("get_abbrev: params NULL result: error missing arguments", {
    expect_error(get_abbrev())
  })

  #------------------- get_abbrev - end ------------------------------------------

  #------------------- set_abbrev - start ----------------------------------------

  test_that("set_abbrev: params ctr result: ctr is not a pmxClass", {
    ctr <- ""
    expect_error(ctr %>% set_abbrev())
  })

  test_that("set_abbrev: params NULL result: error missing arguments", {
    expect_error(set_abbrev())
  })

  test_that("set_abbrev: params ctr result: error attempt to set an attribute on NULL", {
    ctr <- pmxClassHelpers$ctr
    ctr$abbrev <- NULL
    expect_error(ctr %>% set_abbrev())
  })
  #------------------- set_abbrev - end ------------------------------------------

  #------------------- get_plot - start ------------------------------------------

  test_that("get_plot: params NULL result: error missing arguments", {
    expect_error(get_plot())
  })

  test_that("get_plot: params: ctr, nplot, which_pages  result: identical inherits", {
    ctr <- pmxClassHelpers$ctr
    get_p <- get_plot(ctr, nplot = "individual", which_pages = 1)
    expect_true(inherits(get_p, c("gg", "ggplot")))
  })

  test_that("get_plot: params: ctr, nplot, which_pages  result: error ctr is not a pmxClass", {
    ctr <- ""
    expect_error(get_plot(ctr, nplot = "individual", which_pages = 1))
  })

  test_that("get_plot: params: ctr, nplot, which_pages  result: error nplot is not a character", {
    ctr <- pmxClassHelpers$ctr
    expect_error(get_plot(ctr, nplot = list("individual", "eta_hist"), which_pages = 1))
  })

  test_that("get_plot: params: ctr, nplot, which_pages  result: error which_pages
          is not an integer or 'all' or 1L", {
            ctr <- pmxClassHelpers$ctr
            expect_error(get_plot(ctr, nplot = "individual", which_pages = "one"))
          })

  test_that("get_plot: params: ctr, nplot, which_pages  result: error nplot is not valid plot name", {
    ctr <- pmxClassHelpers$ctr
    expect_error(get_plot(ctr, nplot = "indiv", which_pages = 1L))
  })

  test_that("get_plot: params: ctr, nplot, which_pages  result: identical structure", {
    ctr <- pmxClassHelpers$ctr
    get_p <- get_plot(ctr, nplot = "individual", which_pages = 1L)
    expect_equal(get_p$facet$params$nrow, 4)
  })

  test_that("get_plot: params: ctr, nplot, which_pages  result: identical names", {
    ctr <- pmxClassHelpers$ctr
    get_p <- get_plot(ctr, nplot = "individual", which_pages = 1L)
    gplNames <- c(
      "data", "layers", "scales", "mapping", "theme", "coordinates",
      "facet", "plot_env", "labels"
    )
    expect_identical(gplNames, names(get_p))
  })

  #------------------- get_plot - end --------------------------------------------

  #------------------- plot_names - start ----------------------------------------

  test_that("plot_names: params NULL result: error missing arguments", {
    expect_error(plot_names())
  })

  test_that("plot_names: params: ctr result: error ctr is not a pmxClass", {
    ctr <- ""
    expect_error(plot_names(ctr))
  })

  #------------------- plot_names - end ------------------------------------------

  #------------------- plots - start ---------------------------------------------

  test_that("plots: params NULL result: error missing arguments", {
    expect_error(plots())
  })

  test_that("plots: params: ctr result: error ctr is not a pmxClass", {
    ctr <- ""
    expect_error(plots(ctr))
  })

  test_that("plots: params: ctr result: identical inherits", {
    ctr <- pmxClassHelpers$ctr
    pp <- plots(ctr)
    expect_true(inherits(pp, c("data.table", "data.frame")))
    expect_true(inherits(pp[[1]], "character"))
  })

  test_that("plots: params: ctr result: identical names", {
    ctr <- pmxClassHelpers$ctr
    pp <- plots(ctr)
    pNames <- c("plot_name", "plot_type", "plot_function")
    expect_identical(pNames, names(pp))
  })

  #------------------- plots - end -----------------------------------------------

  #------------------- get_plot_config - start -----------------------------------

  test_that("get_plot_config: params NULL result: error missing arguments", {
    expect_error(get_plot_config())
  })

  test_that("get_plot_config: params: ctr result: error ctr is not a pmxClass", {
    ctr <- ""
    expect_error(get_plot_config(ctr))
  })

  test_that("get_plot_config: params: ctr, pname result: identical inherits", {
    ctr <- pmxClassHelpers$ctr
    get_pconf <- get_plot_config(ctr, "individual")
    expect_true(inherits(get_pconf, c("individual", "pmx_gpar")))
  })

  test_that("get_plot_config: params: ctr, pname result: identical structure", {
    ctr <- pmxClassHelpers$ctr
    get_pconf <- get_plot_config(ctr, "individual")
    expect_identical(get_pconf$ptype, "IND")
  })

  #------------------- get_plot_config - end -------------------------------------

  #------------------- set_data - start ------------------------------------------

  test_that("set_data: params NULL result: error missing arguments", {
    expect_error(set_data())
  })

  test_that("set_data: params: ctr result: error ctr is not a pmxClass", {
    ctr <- ""
    expect_error(set_data(ctr))
  })

  test_that("set_data: params: ctr result: error each data set should be well named", {
    ctr <- pmxClassHelpers$ctr
    expect_error(set_data(ctr, "eta"))
  })

  test_that("set_data: params: ctr result: error arguments is of length zero", {
    ctr <- pmxClassHelpers$ctr
    expect_error(set_data(ctr))
  })

  test_that("set_data: params: ctr, eta result: identical names, inherits", {
    ctr <- theophylline()
    sd <- set_data(ctr, eta = get_data(ctr, "eta")[, EFFECT := factor(
      EFFECT,
      levels = c("ka", "V", "Cl"),
      labels = c("Concentration", "Volume", "Clearance")
    )])
    expect_identical(names(sd), "eta")
    expect_true(inherits(sd, "list"))
    expect_true(inherits(sd$eta, c("data.table", "data.frame")))
  })

  #------------------- set_data - end --------------------------------------------

  #------------------- get_cats - start ------------------------------------------

  test_that("get_cats: params NULL result: error missing arguments", {
    expect_error(get_cats())
  })

  test_that("get_cats: params: ctr result: error ctr is not a pmxClass", {
    ctr <- ""
    expect_error(get_cats(ctr))
  })

  test_that("get_cats: params: ctr result: identical inherits", {
    ctr <- theophylline()
    gcats <- get_cats(ctr)
    expect_true(inherits(gcats, "character"))
  })

  test_that("Can get cats: params: ctr", {
    ctr <- theophylline()
    gcats <- get_cats(ctr)
    expect_identical(gcats, "SEX")
  })
  #------------------- get_cats - end --------------------------------------------

  #------------------- get_strats - start ----------------------------------------
  test_that("get_strats: params NULL result: error missing arguments", {
    expect_error(get_strats())
  })

  test_that("get_strats: params: ctr result: error ctr is not a pmxClass", {
    ctr <- ""
    expect_error(get_strats(ctr))
  })

  test_that("get_strats: params: ctr result: identical inherits", {
    ctr <- theophylline()
    gstrats <- get_strats(ctr)
    expect_true(inherits(gstrats, "character"))
  })

  test_that("Can get strats: params: ctr ", {
    ctr <- theophylline()
    gstrats <- get_strats(ctr)
    expect_identical(gstrats, "STUD")
  })
  #------------------- get_strats - end ------------------------------------------

  #------------------- get_covariates - start ------------------------------------
  test_that("get_covariates: params NULL result: error missing arguments", {
    expect_error(get_covariates())
  })

  test_that("get_covariates: params: ctr result: error ctr is not a pmxClass", {
    ctr <- ""
    expect_error(get_covariates(ctr))
  })

  test_that("get_covariates: params: ctr result: identical inherits", {
    ctr <- theophylline()
    gcov <- get_covariates(ctr)
    expect_true(inherits(gcov, "character"))
  })

  test_that("Can get covariates: params: ctr", {
    ctr <- theophylline()
    gcov <- get_covariates(ctr)
    expect_identical(gcov, c("SEX", "WT0", "AGE0"))
  })
  #------------------- get_covariates - end --------------------------------------

  #------------------- get_conts - start -----------------------------------------

  test_that("get_conts: params NULL result: error missing arguments", {
    expect_error(get_conts())
  })

  test_that("get_conts: params: ctr result: error ctr is not a pmxClass", {
    ctr <- ""
    expect_error(get_conts(ctr))
  })

  test_that("get_conts: params: ctr result: identical inherits", {
    ctr <- theophylline()
    gconst <- get_conts(ctr)
    expect_true(inherits(gconst, "character"))
  })

  test_that("Can get conts: params: ctr", {
    ctr <- theophylline()
    gconst <- get_conts(ctr)
    expect_identical(gconst, c("WT0", "AGE0"))
  })
  #------------------- get_conts - end -------------------------------------------

  #------------------- get_occ - start -------------------------------------------

  test_that("get_occ: params NULL result: error missing arguments", {
    expect_error(get_occ())
  })

  test_that("get_occ: params: ctr result: error ctr is not a pmxClass", {
    ctr <- ""
    expect_error(get_occ(ctr))
  })

  test_that("get_occ: params: ctr result: identical inherits", {
    ctr <- theophylline()
    g_occ <- get_occ(ctr)
    expect_true(inherits(g_occ, "character"))
  })

  test_that("Can get occ: params: ctr", {
    ctr <- theophylline()
    g_occ <- get_occ(ctr)
    expect_identical(g_occ, "")
  })
  #------------------- get_occ - end ---------------------------------------------

  #------------------- pmx_print - start -----------------------------------------
  ctr <- pmxClassHelpers$ctr
  theophylline <- file.path(
    system.file(package = "ggPMX"), "testdata",
    "theophylline"
  )
  private <- list(
    .data_path = "",
    .input_path = "",
    .covariates = NULL,
    .plots = list(),
    .plots_configs = list()
  )
  WORK_DIR <- file.path(theophylline, "Monolix")
  input_file <- file.path(theophylline, "data_pk.csv")
  self <- pmx(
    sys = "mlx",
    config = "standing",
    directory = WORK_DIR,
    input = input_file,
    dv = "Y",
    dvid = "DVID"
  )

  test_that("pmx_print: params NULL result: error missing arguments", {
    expect_error(pmx_print())
  })

  test_that("pmx_print can print pmx class", {
    expect_output(pmx_print(self, private), "pmx object:")
  })

  test_that("pmx_print  params: self, private; result: identical inherits", {
    expect_true(inherits(pmx_print(self, private), "pmxConfig"))
  })


  test_that("pmx_shrink: params NULL result: list, pmxShrinkClass", {
    expect_true(inherits(pmx_shrink(), c("list", "pmxShrinkClass")))
  })


  test_that(
    "pmx_shrink: params: fun, size, color, vjust, hjust
  result: list, pmxShrinkClass", {
    expect_true(
      inherits(
        pmx_shrink(fun="sd", size=1, color="red", vjust=1, hjust=1),
        c("list", "pmxShrinkClass")
      )
    )}
  )


  test_that("pmx_shrink: params result: elements in the list", {
    sh_names <- c("fun", "size", "color", "vjust", "hjust")
    expect_true(all(sh_names %in% names(pmx_shrink())))
  })


  test_that("check_shrink: shrink_list result: logical ", {
    expect_true(
      inherits(
        check_shrink(list(fun="sd", size=1, color="red", vjust=1, hjust=1)),
        "logical"
      )
    )
  })


  test_that("check_shrink: shrink_list result: character ", {
    expect_true(
      inherits(
        check_shrink(list(fun="sd", size=1, color="red")), "character"
      )
    )
  })

  test_that("pmx_print params: self, private; result: identical structure", {
    pmx_pr <- pmx_print(self, private)
    expect_identical(pmx_pr$sys, "mlx")
    expect_identical(pmx_pr$plots$ABS_IWRES_IPRED$ptype, "SCATTER")
  })

  #------------------- pmx_print - end -------------------------------------------

  #------------------- pmx_transform - start -------------------------------------

  test_that("pmx_transform: params NULL result: error missing arguments", {
    expect_error(pmx_transform())
  })

  #------------------- pmx_transform - end ---------------------------------------

  #------------------- pmx_copy - end --------------------------------------------

  test_that("pmx_copy: params NULL result: error missing arguments", {
    expect_error(pmx_copy())
  })

  test_that("pmx_copy: params: ctr result: error ctr is not a pmxClass", {
    ctr <- ""
    expect_error(pmx_copy(ctr))
  })


  test_that("pmx_copy: params: ctr result: Creates a deep copy of the controller", {
    ctr <- pmxClassHelpers$ctr
    pmxNames <- c(
      "warnings", "update_plot", "time", "strats", "sim_blq",
      "sim", "settings", "set_config", "save_dir", "report_queue",
      "report_n", "remove_plot", "re", "print", "post_load",
      "plots", "plot_file_name", "occ", "input_file", "input",
      "initialize", "id", "has_re", "get_plot", "get_config",
      "footnote", "enqueue_plot", "endpoint", "dvid", "dv",
      "dequeue_plot", "data", "conts", "config", "clone",
      "cats", "bloq", "add_plot", "abbrev", ".__enclos_env__"
    )
    p_copy <- pmx_copy(ctr, is.draft = FALSE)
    expect_identical(names(p_copy), pmxNames)
    expect_identical(p_copy$conts, c("WT0", "AGE0"))
    expect_true(inherits(p_copy, c("pmxClass", "R6")))
  })

  #------------------- pmx_copy - end --------------------------------------------

  #------------------- print.pmxClass - start ------------------------------------

  test_that("print.pmxClass: params NULL result: error missing arguments", {
    expect_error(print.pmxClass())
  })

  test_that("Can print pmxClass: params ctr", {
    ctr <- pmxClassHelpers$ctr
    expect_output(print.pmxClass(ctr), "pmx object:")
  })

  test_that("print.pmxClass: params ctr is a pmxClass obj; result: identical inherits", {
    ctr <- theophylline()
    expect_true(inherits(print.pmxClass(ctr), "pmxConfig"))
  })
  #------------------- print.pmxClass - end --------------------------------------

  #------------------- pmx_fig_process_wrapup - start ----------------------------

  test_that("pmx_fig_process_wrapup: params NULL result: error missing arguments", {
    expect_error(pmx_fig_process_wrapup())
  })

  test_that("pmx_fig_process_wrapup can wrap up process: params self", {
    expect_true(pmx_fig_process_wrapup(self))
    expect_true(inherits(pmx_fig_process_wrapup(self), "logical"))
  })

  test_that("pmx_fig_process_wrapup params: self result: error queue is not empty", {
    expect_true(pmx_fig_process_wrapup(self))
    self$report_queue <- TRUE
    expect_error(pmx_fig_process_wrapup(self))
    self$report_queue <- list()
  })

  #------------------- pmx_fig_process_wrapup - end ------------------------------

  #------------------- pmx_fig_process_init - start ------------------------------

  test_that("pmx_fig_process_init: params: NULL result: identical inherits", {
    expect_true(inherits(pmx_fig_process_init(), "numeric"))
  })

  test_that("pmx_fig_process_init: params: self result: identical values", {
    pmx_f <- pmx_fig_process_init(self)
    expect_identical(pmx_f, 0)
  })

  #------------------- pmx_fig_process_init - end --------------------------------

  #------------------- pmx_dequeue_plot - start ----------------------------------

  test_that("pmx_dequeue_plot: params: NULL result: error missing arguments", {
    expect_error(pmx_dequeue_plot())
  })

  test_that("pmx_dequeue_plot: params: self result: warning: ... Footnotes may be wrong", {
    expect_message(pmx_dequeue_plot(self))
  })
  test_that("pmx_dequeue_plot: params: self result: identical inherits", {
    self$report_queue <- list(1, 2)
    expect_true(inherits(pmx_dequeue_plot(self), "numeric"))
  })

  test_that("pmx_dequeue_plot can dequeue plot: params: self", {
    self$report_queue <- TRUE
    expect_true(pmx_dequeue_plot(self))
    self$report_queue <- list()
  })

  #------------------- pmx_dequeue_plot - end ------------------------------------

  #------------------- pmx_get_config - start ------------------------------------

  test_that("pmx_get_config: params: NULL result: error missing arguments", {
    expect_error(pmx_get_config())
  })

  #------------------- pmx_get_config - end --------------------------------------

  #------------------- pmx_initialize - start ------------------------------------
  test_that("pmx_initialize: params NULL result: error expecting source path", {
    expect_error(pmx_initialize())
  })
  #------------------- pmx_initialize - start ------------------------------------
}