From 45efbee821deb22f124e77c652e0c333c78cfd7d Mon Sep 17 00:00:00 2001
From: Indrajeet Patil <patilindrajeet.science@gmail.com>
Date: Tue, 21 Mar 2023 08:48:08 +0100
Subject: [PATCH 01/98] clean up pscl tests

https://github.com/easystats/easystats/issues/350
---
 tests/testthat/test-zeroinfl.R | 329 ++++++++++++++++-----------------
 1 file changed, 162 insertions(+), 167 deletions(-)

diff --git a/tests/testthat/test-zeroinfl.R b/tests/testthat/test-zeroinfl.R
index db48707d7..d4e586b3e 100644
--- a/tests/testthat/test-zeroinfl.R
+++ b/tests/testthat/test-zeroinfl.R
@@ -1,175 +1,170 @@
-.runThisTest <- Sys.getenv("RunAllinsightTests") == "yes"
-
-if (skip_if_not_or_load_if_installed("pscl")) {
-  data("bioChemists")
-
-  m1 <- zeroinfl(art ~ fem + mar + kid5 + ment | kid5 + phd, data = bioChemists)
-
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_poisson)
-    expect_true(model_info(m1)$is_zero_inflated)
-    expect_false(model_info(m1)$is_linear)
-  })
-
-  test_that("n_parameters", {
-    expect_equal(n_parameters(m1), 8)
-    expect_equal(n_parameters(m1, component = "conditional"), 5)
-  })
-
-  test_that("find_predictors", {
-    expect_identical(
-      find_predictors(m1),
-      list(
-        conditional = c("fem", "mar", "kid5", "ment"),
-        zero_inflated = c("kid5", "phd")
-      )
+skip_if_not_or_load_if_installed("pscl")
+data("bioChemists")
+
+m1 <- zeroinfl(art ~ fem + mar + kid5 + ment | kid5 + phd, data = bioChemists)
+
+test_that("model_info", {
+  expect_true(model_info(m1)$is_poisson)
+  expect_true(model_info(m1)$is_zero_inflated)
+  expect_false(model_info(m1)$is_linear)
+})
+
+test_that("n_parameters", {
+  expect_equal(n_parameters(m1), 8)
+  expect_equal(n_parameters(m1, component = "conditional"), 5)
+})
+
+test_that("find_predictors", {
+  expect_identical(
+    find_predictors(m1),
+    list(
+      conditional = c("fem", "mar", "kid5", "ment"),
+      zero_inflated = c("kid5", "phd")
     )
-    expect_identical(
-      find_predictors(m1, flatten = TRUE),
-      c("fem", "mar", "kid5", "ment", "phd")
+  )
+  expect_identical(
+    find_predictors(m1, flatten = TRUE),
+    c("fem", "mar", "kid5", "ment", "phd")
+  )
+  expect_null(find_predictors(m1, effects = "random"))
+})
+
+test_that("find_response", {
+  expect_identical(find_response(m1), "art")
+})
+
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), exp(0.2), tolerance = 1e-5)
+})
+
+test_that("get_data", {
+  expect_equal(nrow(get_data(m1)), 915)
+  expect_equal(
+    colnames(get_data(m1)),
+    c("art", "fem", "mar", "kid5", "ment", "phd")
+  )
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1), 2)
+  expect_equal(
+    find_formula(m1),
+    list(
+      conditional = as.formula("art ~ fem + mar + kid5 + ment"),
+      zero_inflated = as.formula("~kid5 + phd")
+    ),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_terms", {
+  expect_equal(
+    find_terms(m1),
+    list(
+      response = "art",
+      conditional = c("fem", "mar", "kid5", "ment"),
+      zero_inflated = c("kid5", "phd")
     )
-    expect_null(find_predictors(m1, effects = "random"))
-  })
-
-  test_that("find_response", {
-    expect_identical(find_response(m1), "art")
-  })
-
-  test_that("link_inverse", {
-    expect_equal(link_inverse(m1)(0.2), exp(0.2), tolerance = 1e-5)
-  })
-
-  test_that("get_data", {
-    expect_equal(nrow(get_data(m1)), 915)
-    expect_equal(
-      colnames(get_data(m1)),
-      c("art", "fem", "mar", "kid5", "ment", "phd")
-    )
-  })
-
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 2)
-    expect_equal(
-      find_formula(m1),
-      list(
-        conditional = as.formula("art ~ fem + mar + kid5 + ment"),
-        zero_inflated = as.formula("~kid5 + phd")
-      ),
-      ignore_attr = TRUE
-    )
-  })
-
-  test_that("find_terms", {
-    expect_equal(
-      find_terms(m1),
-      list(
-        response = "art",
-        conditional = c("fem", "mar", "kid5", "ment"),
-        zero_inflated = c("kid5", "phd")
-      )
-    )
-    expect_equal(
-      find_terms(m1, flatten = TRUE),
-      c("art", "fem", "mar", "kid5", "ment", "phd")
-    )
-  })
-
-  test_that("n_obs", {
-    expect_equal(n_obs(m1), 915)
-  })
-
-  test_that("linkfun", {
-    expect_false(is.null(link_function(m1)))
-  })
-
-  test_that("find_parameters", {
-    expect_equal(
-      find_parameters(m1),
-      list(
-        conditional = c(
-          "count_(Intercept)",
-          "count_femWomen",
-          "count_marMarried",
-          "count_kid5",
-          "count_ment"
-        ),
-        zero_inflated = c("zero_(Intercept)", "zero_kid5", "zero_phd")
-      )
-    )
-    expect_equal(nrow(get_parameters(m1)), 8)
-    expect_equal(nrow(get_parameters(m1, component = "zi")), 3)
-    expect_equal(
-      get_parameters(m1)$Parameter,
-      c(
+  )
+  expect_equal(
+    find_terms(m1, flatten = TRUE),
+    c("art", "fem", "mar", "kid5", "ment", "phd")
+  )
+})
+
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 915)
+})
+
+test_that("linkfun", {
+  expect_false(is.null(link_function(m1)))
+})
+
+test_that("find_parameters", {
+  expect_equal(
+    find_parameters(m1),
+    list(
+      conditional = c(
         "count_(Intercept)",
         "count_femWomen",
         "count_marMarried",
         "count_kid5",
-        "count_ment",
-        "zero_(Intercept)",
-        "zero_kid5",
-        "zero_phd"
-      )
-    )
-  })
-
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "z-statistic")
-  })
-
-  test_that("get_statistic", {
-    expect_equal(
-      get_statistic(m1)$Statistic,
-      c(8.26297, -3.90986, 2.07134, -3.43156, 10.05389, -2.143, 0.21384, -1.84259),
-      tolerance = 1e-3
-    )
-    expect_equal(
-      get_statistic(m1)$Component,
-      c(
-        "conditional", "conditional", "conditional", "conditional",
-        "conditional", "zero_inflated", "zero_inflated", "zero_inflated"
+        "count_ment"
       ),
-      tolerance = 1e-3
+      zero_inflated = c("zero_(Intercept)", "zero_kid5", "zero_phd")
+    )
+  )
+  expect_equal(nrow(get_parameters(m1)), 8)
+  expect_equal(nrow(get_parameters(m1, component = "zi")), 3)
+  expect_equal(
+    get_parameters(m1)$Parameter,
+    c(
+      "count_(Intercept)",
+      "count_femWomen",
+      "count_marMarried",
+      "count_kid5",
+      "count_ment",
+      "zero_(Intercept)",
+      "zero_kid5",
+      "zero_phd"
     )
-  })
-
-
-  if (.runThisTest && skip_if_not_or_load_if_installed("sandwich")) {
-    set.seed(123)
-    vc1 <- get_varcov(m1, component = "all", vcov = "BS", vcov_args = list(R = 50))
-    set.seed(123)
-    vc2 <- sandwich::vcovBS(m1, R = 50)
-    expect_equal(vc1, vc2, ignore_attr = TRUE)
-
-    set.seed(123)
-    vc1 <- get_varcov(m1, component = "conditional", vcov = "BS", vcov_args = list(R = 50))
-    count_col <- grepl("^count_", colnames(vc2))
-    expect_equal(vc1, vc2[count_col, count_col], ignore_attr = TRUE)
-
-    set.seed(123)
-    vc1 <- get_varcov(m1, component = "zero_inflated", vcov = "BS", vcov_args = list(R = 50))
-    zero_col <- grepl("^zero_", colnames(vc2))
-    expect_equal(vc1, vc2[zero_col, zero_col], ignore_attr = TRUE)
-  }
-
-  m2 <- zeroinfl(formula = art ~ . | 1, data = bioChemists, dist = "negbin")
-  .runThisTest <- Sys.getenv("RunAllinsightTests") == "yes"
-
-  if (.runThisTest || Sys.getenv("USER") == "travis") {
-    test_that("get_statistic", {
-      expect_equal(
-        get_statistic(m2)$Statistic,
-        c(1.84902, -2.97806, 1.83266, -3.32478, 0.42324, 8.38088, -0.14579),
-        tolerance = 1e-3
-      )
-      expect_equal(
-        get_statistic(m2)$Component,
-        c(
-          "conditional", "conditional", "conditional", "conditional",
-          "conditional", "conditional", "zero_inflated"
-        ),
-        tolerance = 1e-3
-      )
-    })
-  }
-}
+  )
+})
+
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "z-statistic")
+})
+
+test_that("get_statistic", {
+  expect_equal(
+    get_statistic(m1)$Statistic,
+    c(8.26297, -3.90986, 2.07134, -3.43156, 10.05389, -2.143, 0.21384, -1.84259),
+    tolerance = 1e-3
+  )
+  expect_equal(
+    get_statistic(m1)$Component,
+    c(
+      "conditional", "conditional", "conditional", "conditional",
+      "conditional", "zero_inflated", "zero_inflated", "zero_inflated"
+    ),
+    tolerance = 1e-3
+  )
+})
+
+test_that("get_varcov", {
+  skip_if_not_or_load_if_installed("sandwich")
+
+  set.seed(123)
+  vc1 <- get_varcov(m1, component = "all", vcov = "BS", vcov_args = list(R = 50))
+  set.seed(123)
+  vc2 <- sandwich::vcovBS(m1, R = 50)
+  expect_equal(vc1, vc2, ignore_attr = TRUE)
+
+  set.seed(123)
+  vc1 <- get_varcov(m1, component = "conditional", vcov = "BS", vcov_args = list(R = 50))
+  count_col <- grepl("^count_", colnames(vc2))
+  expect_equal(vc1, vc2[count_col, count_col], ignore_attr = TRUE)
+
+  set.seed(123)
+  vc1 <- get_varcov(m1, component = "zero_inflated", vcov = "BS", vcov_args = list(R = 50))
+  zero_col <- grepl("^zero_", colnames(vc2))
+  expect_equal(vc1, vc2[zero_col, zero_col], ignore_attr = TRUE)
+})
+
+m2 <- zeroinfl(formula = art ~ . | 1, data = bioChemists, dist = "negbin")
+
+test_that("get_statistic", {
+  expect_equal(
+    get_statistic(m2)$Statistic,
+    c(1.84902, -2.97806, 1.83266, -3.32478, 0.42324, 8.38088, -0.14579),
+    tolerance = 1e-3
+  )
+  expect_equal(
+    get_statistic(m2)$Component,
+    c(
+      "conditional", "conditional", "conditional", "conditional",
+      "conditional", "conditional", "zero_inflated"
+    ),
+    tolerance = 1e-3
+  )
+})

From 690d5c891a0614ca44a493c37db484f738a2271e Mon Sep 17 00:00:00 2001
From: Etienne Bacher <52219252+etiennebacher@users.noreply.github.com>
Date: Wed, 22 Mar 2023 08:34:50 +0100
Subject: [PATCH 02/98] Clean names for "weak instruments" in ivreg (#744)

* clean names for "weak instruments" in ivreg

* format p-weak-instruments

* performance adds _p suffix for FE models, no prefix

---------

Co-authored-by: Daniel <mail@danielluedecke.de>
---
 DESCRIPTION      | 2 +-
 R/format_table.R | 5 ++++-
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/DESCRIPTION b/DESCRIPTION
index 3e259d3b6..75b98b98f 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -1,7 +1,7 @@
 Type: Package
 Package: insight
 Title: Easy Access to Model Information for Various Model Objects
-Version: 0.19.1
+Version: 0.19.1.1
 Authors@R: 
     c(person(given = "Daniel",
              family = "Lüdecke",
diff --git a/R/format_table.R b/R/format_table.R
index d6ccec8db..a0ef48189 100644
--- a/R/format_table.R
+++ b/R/format_table.R
@@ -278,7 +278,8 @@ format_table <- function(x,
 
   for (stats in c(
     "p_CochransQ", "p_Omnibus", "p_Chi2", "p_Baseline", "p_RMSEA", "p_ROPE",
-    "p_MAP", "Wu_Hausman_p", "Sargan_p", "p_Omega2", "p_LR", "p_calibrated"
+    "p_MAP", "Wu_Hausman_p", "Sargan_p", "p_Omega2", "p_LR", "p_calibrated",
+    "weak_instruments_p"
   )) {
     if (stats %in% names(x)) {
       x[[stats]] <- format_p(
@@ -740,6 +741,8 @@ format_table <- function(x,
   if ("Performance_Score" %in% names(x)) names(x)[names(x) == "Performance_Score"] <- "Performance-Score"
   if ("Wu_Hausman" %in% names(x)) names(x)[names(x) == "Wu_Hausman"] <- "Wu & Hausman"
   if ("p(Wu_Hausman)" %in% names(x)) names(x)[names(x) == "p(Wu_Hausman)"] <- "p(Wu & Hausman)"
+  if ("weak_instruments" %in% names(x)) names(x)[names(x) == "weak_instruments"] <- "Weak instruments"
+  if ("weak_instruments_p" %in% names(x)) names(x)[names(x) == "weak_instruments_p"] <- "p(Weak instruments)"
 
   # Formatting if we have IC and IC weight columns ----
 

From f864fac850e4ff15e1827d43f232e9fa64d9176a Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Wed, 22 Mar 2023 08:40:27 +0100
Subject: [PATCH 03/98] comment

---
 R/format_table.R | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/R/format_table.R b/R/format_table.R
index a0ef48189..f0c3bd740 100644
--- a/R/format_table.R
+++ b/R/format_table.R
@@ -255,7 +255,7 @@ format_table <- function(x,
 # like bayestestR (p_ROPE, p_MAP) or performance (p_Chi2)
 
 .format_p_values <- function(x, stars = FALSE, p_digits) {
-  # Specify stars for which column
+  # Specify stars for which column (#656)
   if (is.character(stars)) {
     starlist <- list("p" = FALSE)
     starlist[stars] <- TRUE

From 8e1c77ae15ebc10bafaf17b7925827a82a30dbc5 Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Thu, 23 Mar 2023 17:07:33 +0100
Subject: [PATCH 04/98] fix mclogit support (#746)

* fix mclogit support

* test

* add tests

* news, version

* fix test

* update wordlist
---
 DESCRIPTION                   |  2 +-
 NAMESPACE                     |  2 +
 NEWS.md                       |  6 +++
 R/find_statistic.R            |  4 +-
 R/get_parameters.R            | 15 +++++-
 R/get_statistic.R             | 41 +++++++++++++++
 inst/WORDLIST                 |  3 ++
 tests/testthat/test-mclogit.R | 94 +++++++++++++++++++++++++++++++++++
 tests/testthat/test-mlogit.R  | 48 ++++++------------
 9 files changed, 177 insertions(+), 38 deletions(-)
 create mode 100644 tests/testthat/test-mclogit.R

diff --git a/DESCRIPTION b/DESCRIPTION
index 75b98b98f..fad592cc8 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -1,7 +1,7 @@
 Type: Package
 Package: insight
 Title: Easy Access to Model Information for Various Model Objects
-Version: 0.19.1.1
+Version: 0.19.1.2
 Authors@R: 
     c(person(given = "Daniel",
              family = "Lüdecke",
diff --git a/NAMESPACE b/NAMESPACE
index 6c54f6a9a..30ceb1adb 100644
--- a/NAMESPACE
+++ b/NAMESPACE
@@ -829,6 +829,8 @@ S3method(get_statistic,marginaleffects)
 S3method(get_statistic,marginaleffects.summary)
 S3method(get_statistic,margins)
 S3method(get_statistic,maxLik)
+S3method(get_statistic,mblogit)
+S3method(get_statistic,mclogit)
 S3method(get_statistic,mediate)
 S3method(get_statistic,merModList)
 S3method(get_statistic,metaplus)
diff --git a/NEWS.md b/NEWS.md
index 883f13659..204bd6cb0 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -1,3 +1,9 @@
+# insight 0.19.2
+
+## General
+
+* Improved support for `mclogit` models (package *mclogit*).
+
 # insight 0.19.1
 
 ## New supported models
diff --git a/R/find_statistic.R b/R/find_statistic.R
index 2215ed888..c55fa1162 100644
--- a/R/find_statistic.R
+++ b/R/find_statistic.R
@@ -125,8 +125,8 @@ find_statistic <- function(x, ...) {
     "hurdle",
     "lavaan", "loggammacenslmrob", "logitmfx", "logitor", "logitr", "LORgee", "lrm",
     "margins", "marginaleffects", "marginaleffects.summary", "metaplus", "mixor",
-    "MixMod", "mjoint", "mle", "mle2", "mlogit", "mclogit", "mmclogit", "mvmeta",
-    "mvord",
+    "MixMod", "mjoint", "mle", "mle2", "mlogit", "mblogit", "mclogit", "mmclogit",
+    "mvmeta", "mvord",
     "negbin", "negbinmfx", "negbinirr", "nlreg",
     "objectiveML", "orm",
     "poissonmfx", "poissonirr", "psm", "probitmfx", "pgmm",
diff --git a/R/get_parameters.R b/R/get_parameters.R
index 2a2aa9fb6..2cfb843f3 100644
--- a/R/get_parameters.R
+++ b/R/get_parameters.R
@@ -442,8 +442,21 @@ get_parameters.mblogit <- function(x, ...) {
   text_remove_backticks(out)
 }
 
+
 #' @export
-get_parameters.mclogit <- get_parameters.mblogit
+get_parameters.mclogit <- function(x, ...) {
+  params <- stats::coef(x)
+
+  out <- data.frame(
+    Parameter = names(params),
+    Estimate = unname(params),
+    stringsAsFactors = FALSE,
+    row.names = NULL
+  )
+
+  text_remove_backticks(out)
+}
+
 
 
 #' @export
diff --git a/R/get_statistic.R b/R/get_statistic.R
index 0df649960..9001e5525 100644
--- a/R/get_statistic.R
+++ b/R/get_statistic.R
@@ -972,6 +972,47 @@ get_statistic.mlogit <- function(x, ...) {
   }
 }
 
+#' @export
+get_statistic.mclogit <- function(x, ...) {
+  if (requireNamespace("mclogit", quietly = TRUE)) {
+    cs <- stats::coef(summary(x))
+
+    out <- data.frame(
+      Parameter = rownames(cs),
+      Statistic = as.vector(cs[, 3]),
+      stringsAsFactors = FALSE,
+      row.names = NULL
+    )
+
+    out <- text_remove_backticks(out)
+    attr(out, "statistic") <- find_statistic(x)
+    out
+  } else {
+    NULL
+  }
+}
+
+#' @export
+get_statistic.mblogit <- function(x, ...) {
+  if (requireNamespace("mclogit", quietly = TRUE)) {
+    cs <- stats::coef(summary(x))
+
+    out <- data.frame(
+      Parameter = gsub("(.*)~(.*)", "\\2", rownames(cs)),
+      Statistic = as.vector(cs[, 3]),
+      Response = gsub("(.*)~(.*)", "\\1", rownames(cs)),
+      stringsAsFactors = FALSE,
+      row.names = NULL
+    )
+
+    out <- text_remove_backticks(out)
+    attr(out, "statistic") <- find_statistic(x)
+    out
+  } else {
+    NULL
+  }
+}
+
 
 
 # mfx models -------------------------------------------------------
diff --git a/inst/WORDLIST b/inst/WORDLIST
index 49d668d4c..3f38abfed 100644
--- a/inst/WORDLIST
+++ b/inst/WORDLIST
@@ -111,6 +111,9 @@ logitr
 logloss
 lqmm
 marginaleffects
+mblogit
+mclogit
+mlogit
 md
 merMod
 merTools
diff --git a/tests/testthat/test-mclogit.R b/tests/testthat/test-mclogit.R
new file mode 100644
index 000000000..76c00e8cb
--- /dev/null
+++ b/tests/testthat/test-mclogit.R
@@ -0,0 +1,94 @@
+skip_if_not_or_load_if_installed("mclogit")
+
+data(Transport)
+mod_mb <- mblogit(factor(gear) ~ mpg + hp, data = mtcars, trace = FALSE)
+mod_mc <- mclogit(resp | suburb ~ distance + cost, data = Transport, trace = FALSE)
+
+test_that("mblogit and mclogit is not linear", {
+  if (packageVersion("mclogit") >= "0.9.1") {
+    expect_false(model_info(mod_mb)$is_linear)
+    expect_true(model_info(mod_mb)$is_logit)
+    expect_true(is_model(mod_mb))
+    expect_true(is_model_supported(mod_mb))
+
+    expect_false(model_info(mod_mc)$is_linear)
+    expect_true(model_info(mod_mc)$is_logit)
+    expect_true(is_model(mod_mc))
+    expect_true(is_model_supported(mod_mc))
+  }
+})
+
+test_that("get_parameters", {
+  out <- get_parameters(mod_mb)
+  expect_equal(
+    out$Estimate,
+    c(-5.76561, -30.95279, 0.5077, 1.05108, -0.03696, 0.0582),
+    tolerance = 1e-4
+  )
+  expect_identical(
+    out$Parameter,
+    gsub("(.*)~(.*)", "\\2", names(coef(mod_mb)))
+  )
+  expect_identical(
+    out$Response,
+    c("4", "5", "4", "5", "4", "5")
+  )
+  out <- get_parameters(mod_mc)
+  expect_equal(out$Estimate, c(-1.4394, -0.97753), tolerance = 1e-4)
+  expect_identical(colnames(out), c("Parameter", "Estimate"))
+})
+
+test_that("get_statistic", {
+  out <- get_statistic(mod_mb)
+  expect_equal(
+    out$Statistic,
+    c(-0.52735, -2.51803, 1.30274, 2.44884, -1.04056, 2.16406),
+    tolerance = 1e-4
+  )
+  expect_identical(
+    out$Parameter,
+    gsub("(.*)~(.*)", "\\2", names(coef(mod_mb)))
+  )
+  expect_identical(
+    out$Response,
+    c("4", "5", "4", "5", "4", "5")
+  )
+  out <- get_statistic(mod_mc)
+  expect_equal(out$Statistic, c(-27.06905, -24.51836), tolerance = 1e-4)
+  expect_identical(colnames(out), c("Parameter", "Statistic"))
+})
+
+test_that("find_predictors", {
+  expect_identical(
+    find_predictors(mod_mb),
+    list(conditional = c("mpg", "hp"))
+  )
+  expect_identical(
+    find_predictors(mod_mc),
+    list(conditional = c("distance", "cost"))
+  )
+})
+
+test_that("find_formula", {
+  expect_equal(
+    find_formula(mod_mb),
+    list(conditional = factor(gear) ~ mpg + hp),
+    ignore_attr = TRUE
+  )
+  expect_equal(
+    find_formula(mod_mc),
+    list(conditional = cbind(resp, suburb) ~ distance + cost),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_response", {
+  expect_identical(find_response(mod_mb), "gear")
+  expect_identical(find_response(mod_mc), "cbind(resp, suburb)")
+  expect_identical(find_response(mod_mc, combine = FALSE), c("resp", "suburb"))
+})
+
+test_that("find_statistic", {
+  expect_identical(find_statistic(mod_mb), "z-statistic")
+  expect_identical(find_statistic(mod_mc), "z-statistic")
+})
diff --git a/tests/testthat/test-mlogit.R b/tests/testthat/test-mlogit.R
index df83ceee1..f764b53a5 100644
--- a/tests/testthat/test-mlogit.R
+++ b/tests/testthat/test-mlogit.R
@@ -2,7 +2,7 @@ if (skip_if_not_or_load_if_installed("mlogit") && skip_if_not_or_load_if_install
   data("Fishing")
   Fish <-
     mlogit.data(Fishing,
-      varying = c(2:9),
+      varying = 2:9,
       shape = "wide",
       choice = "mode"
     )
@@ -37,19 +37,19 @@ if (skip_if_not_or_load_if_installed("mlogit") && skip_if_not_or_load_if_install
 
   if (getRversion() >= "3.6.0") {
     test_that("get_response", {
-      expect_equal(get_response(m1), as.vector(Fish$mode))
+      expect_identical(get_response(m1), as.vector(Fish$mode))
     })
 
     test_that("get_data", {
-      expect_equal(nrow(get_data(m1, verbose = FALSE)), 4728)
-      expect_equal(nrow(get_data(m2, verbose = FALSE)), 4728)
+      expect_identical(nrow(get_data(m1, verbose = FALSE)), 4728L)
+      expect_identical(nrow(get_data(m2, verbose = FALSE)), 4728L)
 
       if (packageVersion("mlogit") <= "1.0-3.1") {
-        expect_equal(
+        expect_identical(
           colnames(get_data(m1, verbose = FALSE)),
           c("mode", "price", "catch", "probabilities", "linpred")
         )
-        expect_equal(
+        expect_identical(
           colnames(get_data(m2, verbose = FALSE)),
           c(
             "mode",
@@ -61,11 +61,11 @@ if (skip_if_not_or_load_if_installed("mlogit") && skip_if_not_or_load_if_install
           )
         )
       } else {
-        expect_equal(
+        expect_identical(
           colnames(get_data(m1, verbose = FALSE)),
           c("mode", "price", "catch", "idx", "probabilities", "linpred")
         )
-        expect_equal(
+        expect_identical(
           colnames(get_data(m2, verbose = FALSE)),
           c(
             "mode",
@@ -93,24 +93,24 @@ if (skip_if_not_or_load_if_installed("mlogit") && skip_if_not_or_load_if_install
   })
 
   test_that("find_terms", {
-    expect_equal(find_terms(m1), list(
+    expect_identical(find_terms(m1), list(
       response = "mode",
       conditional = c("price", "catch")
     ))
-    expect_equal(find_terms(m1, flatten = TRUE), c("mode", "price", "catch"))
-    expect_equal(find_terms(m2), list(
+    expect_identical(find_terms(m1, flatten = TRUE), c("mode", "price", "catch"))
+    expect_identical(find_terms(m2), list(
       response = "mode",
       conditional = c("price", "catch", "income")
     ))
-    expect_equal(
+    expect_identical(
       find_terms(m2, flatten = TRUE),
       c("mode", "price", "catch", "income")
     )
   })
 
   test_that("n_obs", {
-    expect_equal(n_obs(m1), 4728)
-    expect_equal(n_obs(m2), 4728)
+    expect_identical(n_obs(m1), 4728L)
+    expect_identical(n_obs(m2), 4728L)
   })
 
   test_that("linkfun", {
@@ -123,23 +123,3 @@ if (skip_if_not_or_load_if_installed("mlogit") && skip_if_not_or_load_if_install
     expect_identical(find_statistic(m2), "z-statistic")
   })
 }
-
-
-test_that("mblogit and mclogit is not linear", {
-  skip_if_not_or_load_if_installed("mclogit")
-
-  if (packageVersion("mclogit") >= "0.9.1") {
-    data(Transport)
-    mod <- mblogit(factor(gear) ~ mpg + hp, data = mtcars, trace = FALSE)
-    expect_false(model_info(mod)$is_linear)
-    expect_true(model_info(mod)$is_logit)
-    expect_true(is_model(mod))
-    expect_true(is_model_supported(mod))
-
-    mod <- mclogit(resp | suburb ~ distance + cost, data = Transport, trace = FALSE)
-    expect_false(model_info(mod)$is_linear)
-    expect_true(model_info(mod)$is_logit)
-    expect_true(is_model(mod))
-    expect_true(is_model_supported(mod))
-  }
-})

From 86695f9ba0c538ddabba1790f6b7b1ed7ed105e8 Mon Sep 17 00:00:00 2001
From: Indrajeet Patil <patilindrajeet.science@gmail.com>
Date: Thu, 23 Mar 2023 19:51:55 +0100
Subject: [PATCH 05/98] Bump minimum needed R version to `R 3.6` (#747)

https://github.com/easystats/easystats/issues/304

- `R 4.3` release is a month away.
- We don't test `R 3.5` in our CI/CD either.
---
 DESCRIPTION | 2 +-
 NEWS.md     | 4 ++++
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/DESCRIPTION b/DESCRIPTION
index fad592cc8..ba83a9754 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -67,7 +67,7 @@ License: GPL-3
 URL: https://easystats.github.io/insight/
 BugReports: https://github.com/easystats/insight/issues
 Depends:
-    R (>= 3.5)
+    R (>= 3.6)
 Imports:
     methods,
     stats,
diff --git a/NEWS.md b/NEWS.md
index 204bd6cb0..7ecd038ea 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -1,5 +1,9 @@
 # insight 0.19.2
 
+## Breaking changes
+
+* The minimum needed R version has been bumped to `3.6`.
+
 ## General
 
 * Improved support for `mclogit` models (package *mclogit*).

From d63f2aa6a23c9509c07263d6d8781273b8dc9166 Mon Sep 17 00:00:00 2001
From: Indrajeet Patil <patilindrajeet.science@gmail.com>
Date: Thu, 23 Mar 2023 21:26:59 +0100
Subject: [PATCH 06/98] `str2lang()` available from `R 3.6` (#748)

So remove the backported copy for R 3.5.
---
 R/backports.R      | 6 ------
 R/find_response.R  | 2 +-
 R/get_datagrid.R   | 4 ++--
 R/null_model.R     | 4 ++--
 R/utils_get_data.R | 4 ++--
 5 files changed, 7 insertions(+), 13 deletions(-)
 delete mode 100644 R/backports.R

diff --git a/R/backports.R b/R/backports.R
deleted file mode 100644
index d079e6a73..000000000
--- a/R/backports.R
+++ /dev/null
@@ -1,6 +0,0 @@
-.str2lang <- function(s) {
-  stopifnot(length(s) == 1L)
-  ex <- parse(text = s, keep.source = FALSE)
-  stopifnot(length(ex) == 1L)
-  ex[[1L]]
-}
diff --git a/R/find_response.R b/R/find_response.R
index 847d31ce7..fb9d1a87d 100644
--- a/R/find_response.R
+++ b/R/find_response.R
@@ -185,7 +185,7 @@ check_cbind <- function(resp, combine, model) {
     # "all.vars()" will take care of extracting the correct variables.
     resp_combined_string <- paste(resp, collapse = "+")
     # create an expression, so all.vars() works similar like for formulas
-    resp_combined <- tryCatch(all.vars(.str2lang(resp_combined_string)),
+    resp_combined <- tryCatch(all.vars(str2lang(resp_combined_string)),
       error = function(e) resp_combined_string
     )
     # if we do not want to combine, or if we just have one variable as
diff --git a/R/get_datagrid.R b/R/get_datagrid.R
index 13adee3d9..d43793c18 100644
--- a/R/get_datagrid.R
+++ b/R/get_datagrid.R
@@ -934,7 +934,7 @@ get_datagrid.datagrid <- get_datagrid.visualisation_matrix
   terms <- find_terms(x, flatten = TRUE)
   factors <- grepl("^(as\\.factor|as_factor|factor|as\\.ordered|ordered)\\((.*)\\)", terms)
   if (any(factors)) {
-    factor_expressions <- lapply(terms[factors], .str2lang)
+    factor_expressions <- lapply(terms[factors], str2lang)
     cleaned_terms <- vapply(factor_expressions, all.vars, character(1))
     for (i in cleaned_terms) {
       if (is.numeric(data[[i]])) {
@@ -945,7 +945,7 @@ get_datagrid.datagrid <- get_datagrid.visualisation_matrix
   }
   logicals <- grepl("^(as\\.logical|as_logical|logical)\\((.*)\\)", terms)
   if (any(logicals)) {
-    logical_expressions <- lapply(terms[logicals], .str2lang)
+    logical_expressions <- lapply(terms[logicals], str2lang)
     cleaned_terms <- vapply(logical_expressions, all.vars, character(1))
     for (i in cleaned_terms) {
       if (is.numeric(data[[i]])) {
diff --git a/R/null_model.R b/R/null_model.R
index f0af09cb5..a03cb142e 100644
--- a/R/null_model.R
+++ b/R/null_model.R
@@ -44,7 +44,7 @@ null_model <- function(model, verbose = TRUE, ...) {
     if (!is.null(offset_term)) {
       tryCatch(
         {
-          do.call(stats::update, list(model, ~1, offset = .str2lang(offset_term)))
+          do.call(stats::update, list(model, ~1, offset = str2lang(offset_term)))
         },
         error = function(e) {
           if (verbose) {
@@ -80,7 +80,7 @@ null_model <- function(model, verbose = TRUE, ...) {
     null.model <- tryCatch(
       {
         if (!is.null(offset_term)) {
-          do.call(stats::update, list(model, formula = nullform, offset = .str2lang(offset_term)))
+          do.call(stats::update, list(model, formula = nullform, offset = str2lang(offset_term)))
         } else {
           stats::update(model, nullform)
         }
diff --git a/R/utils_get_data.R b/R/utils_get_data.R
index c44eac8eb..ba32c265d 100644
--- a/R/utils_get_data.R
+++ b/R/utils_get_data.R
@@ -857,12 +857,12 @@
         # exeception: list for kruskal-wallis
         if (grepl("Kruskal-Wallis", x$method, fixed = TRUE) &&
           (length(data_name) == 1 && startsWith(data_name, "list("))) {
-          l <- eval(.str2lang(x$data.name))
+          l <- eval(str2lang(x$data.name))
           names(l) <- paste0("x", seq_along(l))
           return(l)
         }
 
-        data_call <- lapply(data_name, .str2lang)
+        data_call <- lapply(data_name, str2lang)
         columns <- lapply(data_call, eval)
 
         # detect which kind of tests we have -----------------

From 5aa0c2ab9ed60cf3432e826d77a9582cf2821d61 Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Tue, 28 Mar 2023 08:17:04 +0200
Subject: [PATCH 07/98] Support phylolm (#749)

* Support phylolm

* more methods

* more methods

* more methods

* news, desc

* update readme

* more methods

* fix

* more methods
---
 DESCRIPTION            |   2 +-
 NAMESPACE              |  14 +++++
 NEWS.md                |   4 ++
 R/find_statistic.R     |   4 +-
 R/get_data.R           |  10 +++
 R/get_df.R             |  16 +++++
 R/get_loglikelihood.R  |  14 +++++
 R/get_predicted.R      |  50 +++++++++++++++
 R/is_model.R           |   1 +
 R/is_model_supported.R |   2 +-
 R/link_function.R      |  15 +++++
 R/link_inverse.R       |  13 ++++
 R/model_info.R         |  26 ++++++++
 R/n_obs.R              |   9 +++
 README.md              | 135 +++++++++++++++++++++--------------------
 15 files changed, 244 insertions(+), 71 deletions(-)

diff --git a/DESCRIPTION b/DESCRIPTION
index ba83a9754..7b55606bc 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -1,7 +1,7 @@
 Type: Package
 Package: insight
 Title: Easy Access to Model Information for Various Model Objects
-Version: 0.19.1.2
+Version: 0.19.1.3
 Authors@R: 
     c(person(given = "Daniel",
              family = "Lüdecke",
diff --git a/NAMESPACE b/NAMESPACE
index 30ceb1adb..437f6eb90 100644
--- a/NAMESPACE
+++ b/NAMESPACE
@@ -439,6 +439,8 @@ S3method(get_data,negbinmfx)
 S3method(get_data,nlrq)
 S3method(get_data,nls)
 S3method(get_data,pgmm)
+S3method(get_data,phyloglm)
+S3method(get_data,phylolm)
 S3method(get_data,plm)
 S3method(get_data,poissonirr)
 S3method(get_data,poissonmfx)
@@ -502,6 +504,8 @@ S3method(get_df,mmrm_tmb)
 S3method(get_df,model_fit)
 S3method(get_df,negbinirr)
 S3method(get_df,negbinmfx)
+S3method(get_df,phyloglm)
+S3method(get_df,phylolm)
 S3method(get_df,poissonirr)
 S3method(get_df,poissonmfx)
 S3method(get_df,probitmfx)
@@ -530,6 +534,8 @@ S3method(get_loglikelihood,mblogit)
 S3method(get_loglikelihood,mclogit)
 S3method(get_loglikelihood,mlogit)
 S3method(get_loglikelihood,model_fit)
+S3method(get_loglikelihood,phyloglm)
+S3method(get_loglikelihood,phylolm)
 S3method(get_loglikelihood,plm)
 S3method(get_loglikelihood,stanreg)
 S3method(get_loglikelihood,svycoxph)
@@ -707,6 +713,7 @@ S3method(get_predicted,lmerMod)
 S3method(get_predicted,lrm)
 S3method(get_predicted,merMod)
 S3method(get_predicted,multinom)
+S3method(get_predicted,phylolm)
 S3method(get_predicted,polr)
 S3method(get_predicted,prcomp)
 S3method(get_predicted,principal)
@@ -1085,6 +1092,7 @@ S3method(link_function,mvord)
 S3method(link_function,negbinirr)
 S3method(link_function,negbinmfx)
 S3method(link_function,orm)
+S3method(link_function,phylolm)
 S3method(link_function,plm)
 S3method(link_function,poissonirr)
 S3method(link_function,poissonmfx)
@@ -1204,6 +1212,8 @@ S3method(link_inverse,mvord)
 S3method(link_inverse,negbinirr)
 S3method(link_inverse,negbinmfx)
 S3method(link_inverse,orm)
+S3method(link_inverse,phyloglm)
+S3method(link_inverse,phylolm)
 S3method(link_inverse,plm)
 S3method(link_inverse,poissonmfx)
 S3method(link_inverse,polr)
@@ -1348,6 +1358,8 @@ S3method(model_info,negbinmfx)
 S3method(model_info,nlrq)
 S3method(model_info,nls)
 S3method(model_info,orm)
+S3method(model_info,phyloglm)
+S3method(model_info,phylolm)
 S3method(model_info,plm)
 S3method(model_info,poissonirr)
 S3method(model_info,poissonmfx)
@@ -1460,6 +1472,8 @@ S3method(n_obs,mvord)
 S3method(n_obs,negbinirr)
 S3method(n_obs,negbinmfx)
 S3method(n_obs,nlrq)
+S3method(n_obs,phyloglm)
+S3method(n_obs,phylolm)
 S3method(n_obs,poissonirr)
 S3method(n_obs,poissonmfx)
 S3method(n_obs,probitmfx)
diff --git a/NEWS.md b/NEWS.md
index 7ecd038ea..a3c23362e 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -8,6 +8,10 @@
 
 * Improved support for `mclogit` models (package *mclogit*).
 
+## New supported models
+
+* `phylolm` and `phyloglm` (package *phylolm*).
+
 # insight 0.19.1
 
 ## New supported models
diff --git a/R/find_statistic.R b/R/find_statistic.R
index c55fa1162..8b9fa83aa 100644
--- a/R/find_statistic.R
+++ b/R/find_statistic.R
@@ -100,7 +100,7 @@ find_statistic <- function(x, ...) {
     "mmrm_tmb",
     "nlmerMod", "nlrq", "nls",
     "ols", "orcutt",
-    "pb1", "pb2", "polr",
+    "pb1", "pb2", "polr", "phylolm",
     "rlm", "rms", "rlmerMod", "rq", "rqs", "rqss",
     "selection", "speedlm", "spml", "summary.lm", "svyglm", "svyolr", "systemfit",
     "truncreg",
@@ -129,7 +129,7 @@ find_statistic <- function(x, ...) {
     "mvmeta", "mvord",
     "negbin", "negbinmfx", "negbinirr", "nlreg",
     "objectiveML", "orm",
-    "poissonmfx", "poissonirr", "psm", "probitmfx", "pgmm",
+    "poissonmfx", "poissonirr", "psm", "probitmfx", "pgmm", "phyloglm",
     "qr", "QRNLMM", "QRLMM",
     "Rchoice", "riskRegression", "robmixglm", "rma", "rma.mv", "rma.uni", "rrvglm",
     "Sarlm", "sem", "SemiParBIV", "slm", "slopes", "survreg", "svy_vglm",
diff --git a/R/get_data.R b/R/get_data.R
index 2ea9ce3f9..6f35859b1 100644
--- a/R/get_data.R
+++ b/R/get_data.R
@@ -2077,6 +2077,16 @@ get_data.mlogit <- function(x, source = "environment", verbose = TRUE, ...) {
 }
 
 
+#' @export
+get_data.phylolm <- function(x, source = "environment", verbose = TRUE, ...) {
+  # try to recover data from environment
+  .get_data_from_environment(x, source = source, verbose = verbose, ...)
+}
+
+#' @export
+get_data.phyloglm <- get_data.phylolm
+
+
 #' @export
 #' @rdname get_data
 #' @param include_interval For meta-analysis models, should normal-approximation
diff --git a/R/get_df.R b/R/get_df.R
index 97b8fc729..e8ea95a67 100644
--- a/R/get_df.R
+++ b/R/get_df.R
@@ -221,6 +221,22 @@ get_df.coeftest <- function(x, ...) {
 }
 
 
+#' @export
+get_df.phylolm <- function(x, type = "residual", ...) {
+  type <- match.arg(
+    tolower(type),
+    choices = c("wald", "residual", "normal", "model")
+  )
+  type <- switch(type,
+    "model" = stats::logLik(x)$df,
+    get_df.default(x, type = "residual")
+  )
+}
+
+#' @export
+get_df.phyloglm <- get_df.phylolm
+
+
 #' @export
 get_df.fixest <- function(x, type = "residual", ...) {
   # fixest degrees of freedom can be tricky. best to use the function by the
diff --git a/R/get_loglikelihood.R b/R/get_loglikelihood.R
index dcca67ff2..8fcbb0985 100644
--- a/R/get_loglikelihood.R
+++ b/R/get_loglikelihood.R
@@ -386,6 +386,20 @@ get_loglikelihood.plm <- function(x, check_response = FALSE, verbose = TRUE, ...
 get_loglikelihood.cpglm <- get_loglikelihood.plm
 
 
+#' @export
+get_loglikelihood.phylolm <- function(x, check_response = FALSE, verbose = TRUE, ...) {
+  .loglikelihood_prep_output(
+    x,
+    lls = stats::logLik(x)$logLik,
+    df = get_df(x, type = "model"),
+    check_response = check_response,
+    verbose = verbose
+  )
+}
+
+#' @export
+get_loglikelihood.phyloglm <- get_loglikelihood.phylolm
+
 
 # Helpers -----------------------------------------------------------------
 
diff --git a/R/get_predicted.R b/R/get_predicted.R
index 9df6a575d..2ad366d83 100644
--- a/R/get_predicted.R
+++ b/R/get_predicted.R
@@ -607,6 +607,56 @@ get_predicted.afex_aov <- function(x, data = NULL, ...) {
 
 
 
+# phylolm ---------------------------------------------------------------
+# =======================================================================
+
+#' @export
+get_predicted.phylolm <- function(x,
+                                  data = NULL,
+                                  predict = "expectation",
+                                  verbose = TRUE,
+                                  ...) {
+  # evaluate arguments
+  args <- .get_predicted_args(x, data = data, predict = predict, verbose = verbose, ...)
+
+  # evaluate dots, remove some arguments that might be duplicated else
+  dot_args <- list(...)
+  dot_args[["newdata"]] <- NULL
+  dot_args[["type"]] <- NULL
+
+
+  # 1. step: predictions
+  predict_args <- compact_list(list(x, newdata = args$data, type = args$type, dot_args))
+  predictions <- .safe(do.call("predict", predict_args))
+
+  # may fail due to invalid "dot_args", so try shorter argument list
+  if (is.null(predictions)) {
+    predictions <- .safe(
+      do.call("predict", compact_list(list(x, newdata = args$data, type = args$type)))
+    )
+  }
+
+  # stop here if we have no predictions
+  if (is.null(predictions) && isTRUE(verbose)) {
+    format_warning(
+      paste0("Could not compute predictions for model of class `", class(x)[1], "`.")
+    )
+  }
+
+  # sometimes, a mtrix is returned
+  if (is.matrix(predictions)) {
+    predictions <- predictions[, 1]
+  }
+  # 2. step: final preparation
+  if (!is.null(out)) {
+    out <- .get_predicted_out(predictions, args = args, ci_data = NULL)
+  }
+
+  out
+}
+
+
+
 # ====================================================================
 # Utils --------------------------------------------------------------
 # ====================================================================
diff --git a/R/is_model.R b/R/is_model.R
index 28f401f96..a6605a3ba 100644
--- a/R/is_model.R
+++ b/R/is_model.R
@@ -130,6 +130,7 @@ is_regression_model <- function(x) {
     # p --------------------
     "pairwise.htest", "pb1", "pb2", "pgmm", "plm", "plmm", "PMCMR",
     "poissonmfx", "poissonirr", "polr", "pseudoglm", "psm", "probitmfx",
+    "phyloglm", "phylolm",
 
     # q --------------------
     "qr", "QRNLMM", "QRLMM",
diff --git a/R/is_model_supported.R b/R/is_model_supported.R
index db3988f87..8a462a0da 100644
--- a/R/is_model_supported.R
+++ b/R/is_model_supported.R
@@ -99,7 +99,7 @@ supported_models <- function() {
 
     # p ----------------------------
     "PMCMR", "poissonmfx", "poissonirr", "pgmm", "plm", "polr", "psm",
-    "probitmfx",
+    "probitmfx", "phyloglm", "phylolm",
 
     # r ----------------------------
     "Rchoice", "ridgelm", "riskRegression", "rjags", "rlm", "rlmerMod",
diff --git a/R/link_function.R b/R/link_function.R
index be2081959..2b1fa09cf 100644
--- a/R/link_function.R
+++ b/R/link_function.R
@@ -69,6 +69,9 @@ link_function.lm <- function(x, ...) {
   stats::gaussian(link = "identity")$linkfun
 }
 
+#' @export
+link_function.phylolm <- link_function.lm
+
 #' @export
 link_function.lme <- link_function.lm
 
@@ -252,6 +255,18 @@ link_function.riskRegression <- link_function.multinom
 link_function.comprisk <- link_function.multinom
 
 
+# Phylo glm ------------------------
+
+#' @export
+link_inverse.phyloglm <- function(x, ...) {
+  if (startsWith(x$method, "logistic")) {
+    stats::make.link("logit")$linkfun
+  } else {
+    stats::poisson(link = "log")$linkfun
+  }
+}
+
+
 # Probit link ------------------------
 
 #' @export
diff --git a/R/link_inverse.R b/R/link_inverse.R
index 87bbca323..58de095ac 100644
--- a/R/link_inverse.R
+++ b/R/link_inverse.R
@@ -95,6 +95,9 @@ link_inverse.lm <- function(x, ...) {
   stats::gaussian(link = "identity")$linkinv
 }
 
+#' @export
+link_inverse.phylolm <- link_inverse.lm
+
 #' @export
 link_inverse.bayesx <- link_inverse.lm
 
@@ -587,6 +590,16 @@ link_inverse.gbm <- function(x, ...) {
 }
 
 
+#' @export
+link_inverse.phyloglm <- function(x, ...) {
+  if (startsWith(x$method, "logistic")) {
+    stats::make.link("logit")$linkinv
+  } else {
+    stats::poisson(link = "log")$linkinv
+  }
+}
+
+
 #' @export
 link_inverse.brmsfit <- function(x, ...) {
   fam <- stats::family(x)
diff --git a/R/model_info.R b/R/model_info.R
index 3e83bd4c9..469fffbf8 100644
--- a/R/model_info.R
+++ b/R/model_info.R
@@ -345,6 +345,32 @@ model_info.gmnl <- model_info.logistf
 
 
 
+# Phylo logit and poisson family ------------------------------------
+
+#' @export
+model_info.phylolm <- function(x, verbose = TRUE, ...) {
+  .make_family(x, verbose = verbose, ...)
+}
+
+#' @export
+model_info.phyloglm <- function(x, verbose = TRUE, ...) {
+  if (startsWith(x$method, "logistic")) {
+    faminfo <- stats::binomial(link = "logit")
+  } else {
+    faminfo <- stats::poisson()
+  }
+  .make_family(
+    x = x,
+    fitfam = faminfo$family,
+    logit.link = faminfo$link == "logit",
+    link.fun = faminfo$link,
+    verbose = verbose,
+    ...
+  )
+}
+
+
+
 # Models with ordinal family ------------------------------------
 
 
diff --git a/R/n_obs.R b/R/n_obs.R
index 4126ec216..cce4654c7 100644
--- a/R/n_obs.R
+++ b/R/n_obs.R
@@ -353,6 +353,15 @@ n_obs.gbm <- function(x, ...) {
 }
 
 
+#' @export
+n_obs.phylolm <- function(x, ...) {
+  x$n
+}
+
+#' @export
+n_obs.phyloglm <- n_obs.phylolm
+
+
 #' @export
 #' @rdname n_obs
 #' @inheritParams get_data
diff --git a/README.md b/README.md
index d6efc8156..b7e31a212 100644
--- a/README.md
+++ b/README.md
@@ -7,7 +7,7 @@
 [![status](https://tinyverse.netlify.com/badge/insight)](https://CRAN.R-project.org/package=insight)
 [![lifecycle](https://img.shields.io/badge/lifecycle-maturing-blue.svg)](https://lifecycle.r-lib.org/articles/stages.html)
 
-**Gain insight into your models!**
+**Gain insight into your models\!**
 
 When fitting any statistical model, there are many useful pieces of
 information that are simultaneously calculated and stored beyond
@@ -27,7 +27,7 @@ to every aspect of many model objects via consistent syntax and output.
 
 ## Installation
 
-[![CRAN_Status_Badge](https://www.r-pkg.org/badges/version/insight)](https://cran.r-project.org/package=insight)
+[![CRAN\_Status\_Badge](https://www.r-pkg.org/badges/version/insight)](https://cran.r-project.org/package=insight)
 [![insight status
 badge](https://easystats.r-universe.dev/badges/insight)](https://easystats.r-universe.dev)
 [![R-CMD-check](https://github.com/easystats/insight/workflows/R-CMD-check/badge.svg?branch=main)](https://github.com/easystats/insight/actions)
@@ -36,7 +36,7 @@ The *insight* package is available on CRAN, while its latest development
 version is available on R-universe (from *rOpenSci*) or GitHub.
 
 | Type        | Source     | Command                                                                   |
-|-------------|------------|---------------------------------------------------------------------------|
+| ----------- | ---------- | ------------------------------------------------------------------------- |
 | Release     | CRAN       | `install.packages("insight")`                                             |
 | Development | r-universe | `install.packages("insight", repos = "https://easystats.r-universe.dev")` |
 | Development | GitHub     | `remotes::install_github("easystats/insight")`                            |
@@ -48,10 +48,10 @@ library("insight")
 ```
 
 > **Tip**
->
+> 
 > Instead of `library(insight)`, use `library(easystats)`. This will
 > make all features of the easystats-ecosystem available.
->
+> 
 > To stay updated, use `easystats::install_latest()`.
 
 ## Documentation
@@ -91,15 +91,15 @@ as *coefficients*.
 
 #### Response and Predictors
 
-- **response**: the outcome or response variable (dependent variable) of
-  a regression model.
-- **predictor**: independent variables of (the *fixed* part of) a
-  regression model. For mixed models, variables that are only in the
-  *random effects* part (i.e. grouping factors) of the model are not
-  returned as predictors by default. However, these can be included
-  using additional arguments in the function call, treating predictors
-  are “unique”. As such, if a variable appears as a fixed effect and a
-  random slope, it is treated as one (the same) predictor.
+  - **response**: the outcome or response variable (dependent variable)
+    of a regression model.
+  - **predictor**: independent variables of (the *fixed* part of) a
+    regression model. For mixed models, variables that are only in the
+    *random effects* part (i.e. grouping factors) of the model are not
+    returned as predictors by default. However, these can be included
+    using additional arguments in the function call, treating predictors
+    are “unique”. As such, if a variable appears as a fixed effect and a
+    random slope, it is treated as one (the same) predictor.
 
 #### Variables
 
@@ -117,10 +117,10 @@ and `poly(x, 2)`.
 
 #### Random Effects
 
-- **random slopes**: variables that are specified as random slopes in a
-  mixed effects model.
-- **random or grouping factors**: variables that are specified as
-  grouping variables in a mixed effects model.
+  - **random slopes**: variables that are specified as random slopes in
+    a mixed effects model.
+  - **random or grouping factors**: variables that are specified as
+    grouping variables in a mixed effects model.
 
 *Aren’t the predictors, terms and parameters the same thing?*
 
@@ -141,23 +141,23 @@ narrower level of statistical inspection and reporting (`get_*`).
 ![](https://raw.githubusercontent.com/easystats/insight/master/paper/figure1_small.png)
 
 In total, the **insight** package includes 16 core functions:
-[get_data()](https://easystats.github.io/insight/reference/get_data.html),
-[get_priors()](https://easystats.github.io/insight/reference/get_priors.html),
-[get_variance()](https://easystats.github.io/insight/reference/get_variance.html),
-[get_parameters()](https://easystats.github.io/insight/reference/get_parameters.html),
-[get_predictors()](https://easystats.github.io/insight/reference/get_predictors.html),
-[get_random()](https://easystats.github.io/insight/reference/get_random.html),
-[get_response()](https://easystats.github.io/insight/reference/get_response.html),
-[find_algorithm()](https://easystats.github.io/insight/reference/find_algorithm.html),
-[find_formula()](https://easystats.github.io/insight/reference/find_formula.html),
-[find_variables()](https://easystats.github.io/insight/reference/find_variables.html),
-[find_terms()](https://easystats.github.io/insight/reference/find_terms.html),
-[find_parameters()](https://easystats.github.io/insight/reference/find_parameters.html),
-[find_predictors()](https://easystats.github.io/insight/reference/find_predictors.html),
-[find_random()](https://easystats.github.io/insight/reference/find_random.html),
-[find_response()](https://easystats.github.io/insight/reference/find_response.html),
+[get\_data()](https://easystats.github.io/insight/reference/get_data.html),
+[get\_priors()](https://easystats.github.io/insight/reference/get_priors.html),
+[get\_variance()](https://easystats.github.io/insight/reference/get_variance.html),
+[get\_parameters()](https://easystats.github.io/insight/reference/get_parameters.html),
+[get\_predictors()](https://easystats.github.io/insight/reference/get_predictors.html),
+[get\_random()](https://easystats.github.io/insight/reference/get_random.html),
+[get\_response()](https://easystats.github.io/insight/reference/get_response.html),
+[find\_algorithm()](https://easystats.github.io/insight/reference/find_algorithm.html),
+[find\_formula()](https://easystats.github.io/insight/reference/find_formula.html),
+[find\_variables()](https://easystats.github.io/insight/reference/find_variables.html),
+[find\_terms()](https://easystats.github.io/insight/reference/find_terms.html),
+[find\_parameters()](https://easystats.github.io/insight/reference/find_parameters.html),
+[find\_predictors()](https://easystats.github.io/insight/reference/find_predictors.html),
+[find\_random()](https://easystats.github.io/insight/reference/find_random.html),
+[find\_response()](https://easystats.github.io/insight/reference/find_response.html),
 and
-[model_info()](https://easystats.github.io/insight/reference/model_info.html).
+[model\_info()](https://easystats.github.io/insight/reference/model_info.html).
 In all cases, users must supply at a minimum, the name of the model fit
 object. In several functions, there are additional arguments that allow
 for more targeted returns of model information. For example, the
@@ -283,7 +283,7 @@ email or also file an issue.
 
 ## List of Supported Models by Class
 
-Currently, 222 model classes are supported.
+Currently, 224 model classes are supported.
 
 ``` r
 supported_models()
@@ -369,40 +369,41 @@ supported_models()
 #> [159] "mvord"                   "negbinirr"              
 #> [161] "negbinmfx"               "ols"                    
 #> [163] "onesampb"                "orm"                    
-#> [165] "pgmm"                    "plm"                    
-#> [167] "PMCMR"                   "poissonirr"             
-#> [169] "poissonmfx"              "polr"                   
-#> [171] "probitmfx"               "psm"                    
-#> [173] "Rchoice"                 "ridgelm"                
-#> [175] "riskRegression"          "rjags"                  
-#> [177] "rlm"                     "rlmerMod"               
-#> [179] "RM"                      "rma"                    
-#> [181] "rma.uni"                 "robmixglm"              
-#> [183] "robtab"                  "rq"                     
-#> [185] "rqs"                     "rqss"                   
-#> [187] "rvar"                    "Sarlm"                  
-#> [189] "scam"                    "selection"              
-#> [191] "sem"                     "SemiParBIV"             
-#> [193] "semLm"                   "semLme"                 
-#> [195] "slm"                     "speedglm"               
-#> [197] "speedlm"                 "stanfit"                
-#> [199] "stanmvreg"               "stanreg"                
-#> [201] "summary.lm"              "survfit"                
-#> [203] "survreg"                 "svy_vglm"               
-#> [205] "svychisq"                "svyglm"                 
-#> [207] "svyolr"                  "t1way"                  
-#> [209] "tobit"                   "trimcibt"               
-#> [211] "truncreg"                "vgam"                   
-#> [213] "vglm"                    "wbgee"                  
-#> [215] "wblm"                    "wbm"                    
-#> [217] "wmcpAKP"                 "yuen"                   
-#> [219] "yuend"                   "zcpglm"                 
-#> [221] "zeroinfl"                "zerotrunc"
+#> [165] "pgmm"                    "phyloglm"               
+#> [167] "phylolm"                 "plm"                    
+#> [169] "PMCMR"                   "poissonirr"             
+#> [171] "poissonmfx"              "polr"                   
+#> [173] "probitmfx"               "psm"                    
+#> [175] "Rchoice"                 "ridgelm"                
+#> [177] "riskRegression"          "rjags"                  
+#> [179] "rlm"                     "rlmerMod"               
+#> [181] "RM"                      "rma"                    
+#> [183] "rma.uni"                 "robmixglm"              
+#> [185] "robtab"                  "rq"                     
+#> [187] "rqs"                     "rqss"                   
+#> [189] "rvar"                    "Sarlm"                  
+#> [191] "scam"                    "selection"              
+#> [193] "sem"                     "SemiParBIV"             
+#> [195] "semLm"                   "semLme"                 
+#> [197] "slm"                     "speedglm"               
+#> [199] "speedlm"                 "stanfit"                
+#> [201] "stanmvreg"               "stanreg"                
+#> [203] "summary.lm"              "survfit"                
+#> [205] "survreg"                 "svy_vglm"               
+#> [207] "svychisq"                "svyglm"                 
+#> [209] "svyolr"                  "t1way"                  
+#> [211] "tobit"                   "trimcibt"               
+#> [213] "truncreg"                "vgam"                   
+#> [215] "vglm"                    "wbgee"                  
+#> [217] "wblm"                    "wbm"                    
+#> [219] "wmcpAKP"                 "yuen"                   
+#> [221] "yuend"                   "zcpglm"                 
+#> [223] "zeroinfl"                "zerotrunc"
 ```
 
-- **Didn’t find a model?** [File an
-  issue](https://github.com/easystats/insight/issues) and request
-  additional model-support in *insight*!
+  - **Didn’t find a model?** [File an
+    issue](https://github.com/easystats/insight/issues) and request
+    additional model-support in *insight*\!
 
 ## Citation
 

From 333d5cde5c188d6277495c5f73191879d5fbabac Mon Sep 17 00:00:00 2001
From: Indrajeet Patil <patilindrajeet.science@gmail.com>
Date: Tue, 28 Mar 2023 10:06:37 +0200
Subject: [PATCH 08/98] Fix failing afex tests (#735)

* Check if afex tests are still failing

* Update test-mixed.R

* try scoping fix

* try making the formula global

* move afex tests to WIP folder

---------

Co-authored-by: Mattan S. Ben-Shachar <mattansb@msbstats.info>
---
 WIP/test-mixed.R            | 337 +++++++++++++++++++++++++++++++++++
 inst/WORDLIST               |   1 +
 tests/testthat/test-mixed.R | 345 ------------------------------------
 3 files changed, 338 insertions(+), 345 deletions(-)
 create mode 100644 WIP/test-mixed.R
 delete mode 100644 tests/testthat/test-mixed.R

diff --git a/WIP/test-mixed.R b/WIP/test-mixed.R
new file mode 100644
index 000000000..4595e22f3
--- /dev/null
+++ b/WIP/test-mixed.R
@@ -0,0 +1,337 @@
+# TODO: why the model fails to run
+# see https://github.com/easystats/insight/pull/735
+skip_if_not_or_load_if_installed("lme4")
+skip_if_not_or_load_if_installed("afex")
+
+data(sleepstudy, package = "lme4")
+df_sleepstudy <- sleepstudy
+
+set.seed(123)
+df_sleepstudy$mygrp <- sample(1:5, size = nrow(df_sleepstudy), replace = TRUE)
+df_sleepstudy$mysubgrp <- NA
+for (i in 1:5) {
+  filter_group <- df_sleepstudy$mygrp == i
+  df_sleepstudy$mysubgrp[filter_group] <-
+    sample(1:30, size = sum(filter_group), replace = TRUE)
+}
+
+m1_mixed <<- afex::mixed(Reaction ~ Days + (1 + Days | Subject), data = df_sleepstudy)
+m2_mixed <<- afex::mixed(Reaction ~ Days + (1 | mygrp / mysubgrp) + (1 | Subject), data = df_sleepstudy)
+
+test_that("model_info", {
+  expect_true(model_info(m1_mixed)$is_linear)
+  expect_true(model_info(m2_mixed)$is_linear)
+})
+
+test_that("find_predictors", {
+  expect_equal(
+    find_predictors(m1_mixed, effects = "all"),
+    list(conditional = "Days", random = "Subject")
+  )
+  expect_equal(
+    find_predictors(m1_mixed, effects = "all", flatten = TRUE),
+    c("Days", "Subject")
+  )
+  expect_equal(
+    find_predictors(m1_mixed, effects = "fixed"),
+    list(conditional = "Days")
+  )
+  expect_equal(
+    find_predictors(m1_mixed, effects = "fixed", flatten = TRUE),
+    "Days"
+  )
+  expect_equal(
+    find_predictors(m1_mixed, effects = "random"),
+    list(random = "Subject")
+  )
+  expect_equal(
+    find_predictors(m1_mixed, effects = "random", flatten = TRUE),
+    "Subject"
+  )
+  expect_equal(
+    find_predictors(m2_mixed, effects = "all"),
+    list(
+      conditional = "Days",
+      random = c("mysubgrp", "mygrp", "Subject")
+    )
+  )
+  expect_equal(
+    find_predictors(m2_mixed, effects = "all", flatten = TRUE),
+    c("Days", "mysubgrp", "mygrp", "Subject")
+  )
+  expect_equal(
+    find_predictors(m2_mixed, effects = "fixed"),
+    list(conditional = "Days")
+  )
+  expect_equal(find_predictors(m2_mixed, effects = "random"), list(random = c("mysubgrp", "mygrp", "Subject")))
+  expect_null(find_predictors(m2_mixed, effects = "all", component = "zi"))
+  expect_null(find_predictors(m2_mixed, effects = "fixed", component = "zi"))
+  expect_null(find_predictors(m2_mixed, effects = "random", component = "zi"))
+})
+
+test_that("find_random", {
+  expect_equal(find_random(m1_mixed), list(random = "Subject"))
+  expect_equal(find_random(m1_mixed, flatten = TRUE), "Subject")
+  expect_equal(find_random(m2_mixed), list(random = c("mysubgrp:mygrp", "mygrp", "Subject")))
+  expect_equal(find_random(m2_mixed, split_nested = TRUE), list(random = c("mysubgrp", "mygrp", "Subject")))
+  expect_equal(
+    find_random(m2_mixed, flatten = TRUE),
+    c("mysubgrp:mygrp", "mygrp", "Subject")
+  )
+  expect_equal(
+    find_random(m2_mixed, split_nested = TRUE, flatten = TRUE),
+    c("mysubgrp", "mygrp", "Subject")
+  )
+})
+
+test_that("find_response", {
+  expect_identical(find_response(m1_mixed), "Reaction")
+  expect_identical(find_response(m2_mixed), "Reaction")
+})
+
+test_that("get_response", {
+  expect_equal(get_response(m1_mixed), df_sleepstudy$Reaction)
+})
+
+test_that("link_inverse", {
+  expect_identical(link_inverse(m1_mixed)(0.2), 0.2)
+  expect_identical(link_inverse(m2_mixed)(0.2), 0.2)
+})
+
+test_that("get_data", {
+  expect_equal(colnames(get_data(m1_mixed)), c("Reaction", "Days", "Subject"))
+  expect_equal(colnames(get_data(m1_mixed, effects = "all")), c("Reaction", "Days", "Subject"))
+  expect_equal(colnames(get_data(m1_mixed, effects = "random")), "Subject")
+  expect_equal(
+    colnames(get_data(m2_mixed)),
+    c("Reaction", "Days", "mysubgrp", "mygrp", "Subject")
+  )
+  expect_equal(
+    colnames(get_data(m2_mixed, effects = "all")),
+    c("Reaction", "Days", "mysubgrp", "mygrp", "Subject")
+  )
+  expect_equal(colnames(get_data(m2_mixed, effects = "random")), c("mysubgrp", "mygrp", "Subject"))
+})
+
+test_that("get_df", {
+  expect_equal(
+    get_df(m1_mixed, type = "residual"),
+    Inf,
+    ignore_attr = TRUE
+  )
+  expect_equal(
+    get_df(m1_mixed, type = "normal"),
+    Inf,
+    ignore_attr = TRUE
+  )
+  expect_equal(
+    get_df(m1_mixed, type = "wald"),
+    Inf,
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1_mixed), 2)
+  expect_length(find_formula(m2_mixed), 2)
+  expect_equal(
+    find_formula(m1_mixed, component = "conditional"),
+    list(
+      conditional = as.formula("Reaction ~ Days"),
+      random = as.formula("~1 + Days | Subject")
+    ),
+    ignore_attr = TRUE
+  )
+  expect_equal(
+    find_formula(m2_mixed, component = "conditional"),
+    list(
+      conditional = as.formula("Reaction ~ Days"),
+      random = list(
+        as.formula("~1 | mysubgrp:mygrp"),
+        as.formula("~1 | mygrp"),
+        as.formula("~1 | Subject")
+      )
+    ),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_variables", {
+  expect_identical(
+    find_variables(m1_mixed),
+    list(
+      response = "Reaction",
+      conditional = "Days",
+      random = "Subject"
+    )
+  )
+  expect_identical(
+    find_variables(m1_mixed, flatten = TRUE),
+    c("Reaction", "Days", "Subject")
+  )
+  expect_identical(
+    find_variables(m2_mixed),
+    list(
+      response = "Reaction",
+      conditional = "Days",
+      random = c("mysubgrp", "mygrp", "Subject")
+    )
+  )
+  expect_identical(
+    find_variables(m2_mixed, flatten = TRUE),
+    c("Reaction", "Days", "mysubgrp", "mygrp", "Subject")
+  )
+})
+
+test_that("get_response", {
+  expect_identical(get_response(m1_mixed), df_sleepstudy$Reaction)
+})
+
+test_that("get_predictors", {
+  expect_identical(colnames(get_predictors(m1_mixed)), "Days")
+  expect_identical(colnames(get_predictors(m2_mixed)), "Days")
+})
+
+test_that("get_random", {
+  expect_identical(colnames(get_random(m1_mixed)), "Subject")
+  expect_identical(colnames(get_random(m2_mixed)), c("mysubgrp", "mygrp", "Subject"))
+})
+
+test_that("clean_names", {
+  expect_identical(clean_names(m1_mixed), c("Reaction", "Days", "Subject"))
+  expect_identical(
+    clean_names(m2_mixed),
+    c("Reaction", "Days", "mysubgrp", "mygrp", "Subject")
+  )
+})
+
+test_that("linkfun", {
+  expect_false(is.null(link_function(m1_mixed)))
+  expect_false(is.null(link_function(m2_mixed)))
+})
+
+test_that("find_parameters", {
+  expect_equal(
+    find_parameters(m1_mixed),
+    list(
+      conditional = c("(Intercept)", "Days"),
+      random = list(Subject = c("(Intercept)", "Days"))
+    )
+  )
+  expect_equal(nrow(get_parameters(m1_mixed)), 2)
+  expect_equal(get_parameters(m1_mixed)$Parameter, c("(Intercept)", "Days"))
+
+  expect_equal(
+    find_parameters(m2_mixed),
+    list(
+      conditional = c("(Intercept)", "Days"),
+      random = list(
+        `mysubgrp:mygrp` = "(Intercept)",
+        Subject = "(Intercept)",
+        mygrp = "(Intercept)"
+      )
+    )
+  )
+
+  expect_equal(nrow(get_parameters(m2_mixed)), 2)
+  expect_equal(get_parameters(m2_mixed)$Parameter, c("(Intercept)", "Days"))
+  expect_equal(
+    names(get_parameters(m2_mixed, effects = "random")),
+    c("mysubgrp:mygrp", "Subject", "mygrp")
+  )
+})
+
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1_mixed))
+  expect_false(is_multivariate(m2_mixed))
+})
+
+test_that("get_variance", {
+  expect_equal(
+    get_variance(m1_mixed),
+    list(
+      var.fixed = 908.9534,
+      var.random = 1698.084,
+      var.residual = 654.94,
+      var.distribution = 654.94,
+      var.dispersion = 0,
+      var.intercept = c(Subject = 612.1002),
+      var.slope = c(Subject.Days = 35.07171),
+      cor.slope_intercept = c(Subject = 0.06555124)
+    ),
+    tolerance = 1e-1
+  )
+
+  expect_equal(get_variance_fixed(m1_mixed),
+    c(var.fixed = 908.9534),
+    tolerance = 1e-1
+  )
+  expect_equal(get_variance_random(m1_mixed),
+    c(var.random = 1698.084),
+    tolerance = 1e-1
+  )
+  expect_equal(
+    get_variance_residual(m1_mixed),
+    c(var.residual = 654.94),
+    tolerance = 1e-1
+  )
+  expect_equal(
+    get_variance_distribution(m1_mixed),
+    c(var.distribution = 654.94),
+    tolerance = 1e-1
+  )
+  expect_equal(get_variance_dispersion(m1_mixed),
+    c(var.dispersion = 0),
+    tolerance = 1e-1
+  )
+
+  expect_equal(
+    get_variance_intercept(m1_mixed),
+    c(var.intercept.Subject = 612.1002),
+    tolerance = 1e-1
+  )
+  expect_equal(
+    get_variance_slope(m1_mixed),
+    c(var.slope.Subject.Days = 35.07171),
+    tolerance = 1e-1
+  )
+  expect_equal(
+    get_correlation_slope_intercept(m1_mixed),
+    c(cor.slope_intercept.Subject = 0.06555124),
+    tolerance = 1e-1
+  )
+
+
+  expect_warning(expect_equal(
+    get_variance(m2_mixed),
+    list(
+      var.fixed = 889.3301,
+      var.residual = 941.8135,
+      var.distribution = 941.8135,
+      var.dispersion = 0,
+      var.intercept = c(
+        `mysubgrp:mygrp` = 0,
+        Subject = 1357.4257,
+        mygrp = 24.4064
+      )
+    ),
+    tolerance = 1e-1,
+  ))
+})
+
+test_that("find_algorithm", {
+  expect_equal(
+    find_algorithm(m1_mixed),
+    list(algorithm = "REML", optimizer = "nloptwrap")
+  )
+})
+
+test_that("find_random_slopes", {
+  expect_equal(find_random_slopes(m1_mixed), list(random = "Days"))
+  expect_null(find_random_slopes(m2_mixed))
+})
+
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1_mixed), "t-statistic")
+  expect_identical(find_statistic(m2_mixed), "t-statistic")
+})
diff --git a/inst/WORDLIST b/inst/WORDLIST
index 3f38abfed..520bcd8d3 100644
--- a/inst/WORDLIST
+++ b/inst/WORDLIST
@@ -130,6 +130,7 @@ nd
 occurence
 optimizers
 patilindrajeets
+phylolm
 plm
 poisson
 pre
diff --git a/tests/testthat/test-mixed.R b/tests/testthat/test-mixed.R
deleted file mode 100644
index ad9a8d4cc..000000000
--- a/tests/testthat/test-mixed.R
+++ /dev/null
@@ -1,345 +0,0 @@
-.runThisTest <- Sys.getenv("RunAllinsightTests") == "yes"
-
-skip_if_not_or_load_if_installed("lme4")
-skip_if_not_or_load_if_installed("afex")
-
-# TODO: check why this is failing
-if (FALSE) {
-  data(sleepstudy)
-
-  set.seed(123)
-  sleepstudy$mygrp <- sample(1:5, size = nrow(sleepstudy), replace = TRUE)
-  sleepstudy$mysubgrp <- NA
-  for (i in 1:5) {
-    filter_group <- sleepstudy$mygrp == i
-    sleepstudy$mysubgrp[filter_group] <-
-      sample(1:30, size = sum(filter_group), replace = TRUE)
-  }
-
-  m1 <- mixed(Reaction ~ Days + (1 + Days | Subject),
-    data = sleepstudy
-  )
-
-  m2 <- mixed(Reaction ~ Days + (1 | mygrp / mysubgrp) + (1 | Subject),
-    data = sleepstudy
-  )
-
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_linear)
-    expect_true(model_info(m2)$is_linear)
-  })
-
-  test_that("find_predictors", {
-    expect_equal(
-      find_predictors(m1, effects = "all"),
-      list(conditional = "Days", random = "Subject")
-    )
-    expect_equal(
-      find_predictors(m1, effects = "all", flatten = TRUE),
-      c("Days", "Subject")
-    )
-    expect_equal(
-      find_predictors(m1, effects = "fixed"),
-      list(conditional = "Days")
-    )
-    expect_equal(
-      find_predictors(m1, effects = "fixed", flatten = TRUE),
-      "Days"
-    )
-    expect_equal(
-      find_predictors(m1, effects = "random"),
-      list(random = "Subject")
-    )
-    expect_equal(
-      find_predictors(m1, effects = "random", flatten = TRUE),
-      "Subject"
-    )
-    expect_equal(
-      find_predictors(m2, effects = "all"),
-      list(
-        conditional = "Days",
-        random = c("mysubgrp", "mygrp", "Subject")
-      )
-    )
-    expect_equal(
-      find_predictors(m2, effects = "all", flatten = TRUE),
-      c("Days", "mysubgrp", "mygrp", "Subject")
-    )
-    expect_equal(
-      find_predictors(m2, effects = "fixed"),
-      list(conditional = "Days")
-    )
-    expect_equal(find_predictors(m2, effects = "random"), list(random = c("mysubgrp", "mygrp", "Subject")))
-    expect_null(find_predictors(m2, effects = "all", component = "zi"))
-    expect_null(find_predictors(m2, effects = "fixed", component = "zi"))
-    expect_null(find_predictors(m2, effects = "random", component = "zi"))
-  })
-
-  test_that("find_random", {
-    expect_equal(find_random(m1), list(random = "Subject"))
-    expect_equal(find_random(m1, flatten = TRUE), "Subject")
-    expect_equal(find_random(m2), list(random = c("mysubgrp:mygrp", "mygrp", "Subject")))
-    expect_equal(find_random(m2, split_nested = TRUE), list(random = c("mysubgrp", "mygrp", "Subject")))
-    expect_equal(
-      find_random(m2, flatten = TRUE),
-      c("mysubgrp:mygrp", "mygrp", "Subject")
-    )
-    expect_equal(
-      find_random(m2, split_nested = TRUE, flatten = TRUE),
-      c("mysubgrp", "mygrp", "Subject")
-    )
-  })
-
-  test_that("find_response", {
-    expect_identical(find_response(m1), "Reaction")
-    expect_identical(find_response(m2), "Reaction")
-  })
-
-  test_that("get_response", {
-    expect_equal(get_response(m1), sleepstudy$Reaction)
-  })
-
-  test_that("link_inverse", {
-    expect_identical(link_inverse(m1)(0.2), 0.2)
-    expect_identical(link_inverse(m2)(0.2), 0.2)
-  })
-
-  test_that("get_data", {
-    expect_equal(colnames(get_data(m1)), c("Reaction", "Days", "Subject"))
-    expect_equal(colnames(get_data(m1, effects = "all")), c("Reaction", "Days", "Subject"))
-    expect_equal(colnames(get_data(m1, effects = "random")), "Subject")
-    expect_equal(
-      colnames(get_data(m2)),
-      c("Reaction", "Days", "mysubgrp", "mygrp", "Subject")
-    )
-    expect_equal(
-      colnames(get_data(m2, effects = "all")),
-      c("Reaction", "Days", "mysubgrp", "mygrp", "Subject")
-    )
-    expect_equal(colnames(get_data(m2, effects = "random")), c("mysubgrp", "mygrp", "Subject"))
-  })
-
-  test_that("get_df", {
-    expect_equal(
-      get_df(m1, type = "residual"),
-      Inf,
-      ignore_attr = TRUE
-    )
-    expect_equal(
-      get_df(m1, type = "normal"),
-      Inf,
-      ignore_attr = TRUE
-    )
-    expect_equal(
-      get_df(m1, type = "wald"),
-      Inf,
-      ignore_attr = TRUE
-    )
-  })
-
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 2)
-    expect_length(find_formula(m2), 2)
-    expect_equal(
-      find_formula(m1, component = "conditional"),
-      list(
-        conditional = as.formula("Reaction ~ Days"),
-        random = as.formula("~1 + Days | Subject")
-      ),
-      ignore_attr = TRUE
-    )
-    expect_equal(
-      find_formula(m2, component = "conditional"),
-      list(
-        conditional = as.formula("Reaction ~ Days"),
-        random = list(
-          as.formula("~1 | mysubgrp:mygrp"),
-          as.formula("~1 | mygrp"),
-          as.formula("~1 | Subject")
-        )
-      ),
-      ignore_attr = TRUE
-    )
-  })
-
-  test_that("find_variables", {
-    expect_identical(
-      find_variables(m1),
-      list(
-        response = "Reaction",
-        conditional = "Days",
-        random = "Subject"
-      )
-    )
-    expect_identical(
-      find_variables(m1, flatten = TRUE),
-      c("Reaction", "Days", "Subject")
-    )
-    expect_identical(
-      find_variables(m2),
-      list(
-        response = "Reaction",
-        conditional = "Days",
-        random = c("mysubgrp", "mygrp", "Subject")
-      )
-    )
-    expect_identical(
-      find_variables(m2, flatten = TRUE),
-      c("Reaction", "Days", "mysubgrp", "mygrp", "Subject")
-    )
-  })
-
-  test_that("get_response", {
-    expect_identical(get_response(m1), sleepstudy$Reaction)
-  })
-
-  test_that("get_predictors", {
-    expect_identical(colnames(get_predictors(m1)), "Days")
-    expect_identical(colnames(get_predictors(m2)), "Days")
-  })
-
-  test_that("get_random", {
-    expect_identical(colnames(get_random(m1)), "Subject")
-    expect_identical(colnames(get_random(m2)), c("mysubgrp", "mygrp", "Subject"))
-  })
-
-  test_that("clean_names", {
-    expect_identical(clean_names(m1), c("Reaction", "Days", "Subject"))
-    expect_identical(
-      clean_names(m2),
-      c("Reaction", "Days", "mysubgrp", "mygrp", "Subject")
-    )
-  })
-
-  test_that("linkfun", {
-    expect_false(is.null(link_function(m1)))
-    expect_false(is.null(link_function(m2)))
-  })
-
-  test_that("find_parameters", {
-    expect_equal(
-      find_parameters(m1),
-      list(
-        conditional = c("(Intercept)", "Days"),
-        random = list(Subject = c("(Intercept)", "Days"))
-      )
-    )
-    expect_equal(nrow(get_parameters(m1)), 2)
-    expect_equal(get_parameters(m1)$Parameter, c("(Intercept)", "Days"))
-
-    expect_equal(
-      find_parameters(m2),
-      list(
-        conditional = c("(Intercept)", "Days"),
-        random = list(
-          `mysubgrp:mygrp` = "(Intercept)",
-          Subject = "(Intercept)",
-          mygrp = "(Intercept)"
-        )
-      )
-    )
-
-    expect_equal(nrow(get_parameters(m2)), 2)
-    expect_equal(get_parameters(m2)$Parameter, c("(Intercept)", "Days"))
-    expect_equal(
-      names(get_parameters(m2, effects = "random")),
-      c("mysubgrp:mygrp", "Subject", "mygrp")
-    )
-  })
-
-  test_that("is_multivariate", {
-    expect_false(is_multivariate(m1))
-    expect_false(is_multivariate(m2))
-  })
-
-  test_that("get_variance", {
-    expect_equal(
-      get_variance(m1),
-      list(
-        var.fixed = 908.9534,
-        var.random = 1698.084,
-        var.residual = 654.94,
-        var.distribution = 654.94,
-        var.dispersion = 0,
-        var.intercept = c(Subject = 612.1002),
-        var.slope = c(Subject.Days = 35.07171),
-        cor.slope_intercept = c(Subject = 0.06555124)
-      ),
-      tolerance = 1e-1
-    )
-
-    expect_equal(get_variance_fixed(m1),
-      c(var.fixed = 908.9534),
-      tolerance = 1e-1
-    )
-    expect_equal(get_variance_random(m1),
-      c(var.random = 1698.084),
-      tolerance = 1e-1
-    )
-    expect_equal(
-      get_variance_residual(m1),
-      c(var.residual = 654.94),
-      tolerance = 1e-1
-    )
-    expect_equal(
-      get_variance_distribution(m1),
-      c(var.distribution = 654.94),
-      tolerance = 1e-1
-    )
-    expect_equal(get_variance_dispersion(m1),
-      c(var.dispersion = 0),
-      tolerance = 1e-1
-    )
-
-    expect_equal(
-      get_variance_intercept(m1),
-      c(var.intercept.Subject = 612.1002),
-      tolerance = 1e-1
-    )
-    expect_equal(
-      get_variance_slope(m1),
-      c(var.slope.Subject.Days = 35.07171),
-      tolerance = 1e-1
-    )
-    expect_equal(
-      get_correlation_slope_intercept(m1),
-      c(cor.slope_intercept.Subject = 0.06555124),
-      tolerance = 1e-1
-    )
-
-    if (.runThisTest || Sys.getenv("USER") == "travis") {
-      expect_warning(expect_equal(
-        get_variance(m2),
-        list(
-          var.fixed = 889.3301,
-          var.residual = 941.8135,
-          var.distribution = 941.8135,
-          var.dispersion = 0,
-          var.intercept = c(
-            `mysubgrp:mygrp` = 0,
-            Subject = 1357.4257,
-            mygrp = 24.4064
-          )
-        ),
-        tolerance = 1e-1,
-      ))
-    }
-  })
-
-  test_that("find_algorithm", {
-    expect_equal(
-      find_algorithm(m1),
-      list(algorithm = "REML", optimizer = "nloptwrap")
-    )
-  })
-
-  test_that("find_random_slopes", {
-    expect_equal(find_random_slopes(m1), list(random = "Days"))
-    expect_null(find_random_slopes(m2))
-  })
-
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "t-statistic")
-    expect_identical(find_statistic(m2), "t-statistic")
-  })
-}

From 583b7a4d0a98d649b944b5283f43bfdcb743fd4b Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Wed, 29 Mar 2023 08:31:51 +0200
Subject: [PATCH 09/98] only env

---
 R/get_data.R | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/R/get_data.R b/R/get_data.R
index 6f35859b1..b86e11548 100644
--- a/R/get_data.R
+++ b/R/get_data.R
@@ -2080,7 +2080,7 @@ get_data.mlogit <- function(x, source = "environment", verbose = TRUE, ...) {
 #' @export
 get_data.phylolm <- function(x, source = "environment", verbose = TRUE, ...) {
   # try to recover data from environment
-  .get_data_from_environment(x, source = source, verbose = verbose, ...)
+  .get_data_from_environment(x, source = "environment", verbose = verbose, ...)
 }
 
 #' @export

From c882feceef94b46869b793800dc34ab002a99f71 Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Wed, 29 Mar 2023 11:20:06 +0200
Subject: [PATCH 10/98] comment

---
 R/get_data.R | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/R/get_data.R b/R/get_data.R
index b86e11548..8ed0b8726 100644
--- a/R/get_data.R
+++ b/R/get_data.R
@@ -2079,7 +2079,11 @@ get_data.mlogit <- function(x, source = "environment", verbose = TRUE, ...) {
 
 #' @export
 get_data.phylolm <- function(x, source = "environment", verbose = TRUE, ...) {
-  # try to recover data from environment
+  # DO NOT TOUCH THE SOURCE ARGUMENT!
+  # phylo models have no model.frame() method, so we can only recover from
+  # environment. We still need the "source" argument, even if it's not used here,
+  #  to avoid the "multiple argument match" error for those instances, where
+  # `get_data()` is called # with `source = "frame"`.
   .get_data_from_environment(x, source = "environment", verbose = verbose, ...)
 }
 

From 28955f4f71a93dd0f0ad96df2fe6a3648e81ab8c Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Wed, 29 Mar 2023 16:49:09 +0200
Subject: [PATCH 11/98] do not error, so tests don't fail

---
 R/download_model.R | 20 +++++++++++++++++---
 1 file changed, 17 insertions(+), 3 deletions(-)

diff --git a/R/download_model.R b/R/download_model.R
index 047fa91cb..45c0565d6 100644
--- a/R/download_model.R
+++ b/R/download_model.R
@@ -37,10 +37,24 @@ download_model <- function(name, url = NULL) {
   temp_file <- tempfile()
   on.exit(unlink(temp_file))
 
-  request <- httr::GET(url)
-  httr::stop_for_status(request)
-  writeBin(httr::content(request, type = "raw"), temp_file)
+  result <- tryCatch(
+    {
+      request <- httr::GET(url)
+      httr::stop_for_status(request)
+    },
+    error = function(e) {
+      format_alert(
+        "Could not download model. Request failed with following error:",
+        e$message
+      )
+      NULL
+    }
+  )
+  if (is.null(result)) {
+    return(NULL)
+  }
 
+  writeBin(httr::content(request, type = "raw"), temp_file)
 
   x <- load(temp_file)
   model <- get(x)

From 04f0ecea597568acc91c03240e1d253fc88c17a8 Mon Sep 17 00:00:00 2001
From: Indrajeet Patil <patilindrajeet.science@gmail.com>
Date: Wed, 29 Mar 2023 18:43:11 +0200
Subject: [PATCH 12/98] Run examples conditional on internet access

https://github.com/easystats/easystats/issues/362
---
 DESCRIPTION             | 1 +
 R/clean_parameters.R    | 2 +-
 R/print_parameters.R    | 2 +-
 man/clean_parameters.Rd | 2 ++
 man/print_parameters.Rd | 2 ++
 5 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/DESCRIPTION b/DESCRIPTION
index 7b55606bc..5bdb866c8 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -93,6 +93,7 @@ Suggests:
     coxme,
     cplm,
     crch,
+    curl,
     datawizard,
     effectsize,
     emmeans,
diff --git a/R/clean_parameters.R b/R/clean_parameters.R
index 4fe8a74a1..1a63aa010 100644
--- a/R/clean_parameters.R
+++ b/R/clean_parameters.R
@@ -35,7 +35,7 @@
 #' models from \pkg{brms} or \pkg{rstanarm}, or for specific terms like smooth-
 #' or spline-terms).
 #'
-#' @examples
+#' @examplesIf require("curl", quietly = TRUE) && curl::has_internet()
 #' \dontrun{
 #' library(brms)
 #' model <- download_model("brms_zi_2")
diff --git a/R/print_parameters.R b/R/print_parameters.R
index 424d93539..dfbe24187 100644
--- a/R/print_parameters.R
+++ b/R/print_parameters.R
@@ -80,7 +80,7 @@
 #' component for a better overview. Further, parameter names are "cleaned", if
 #' necessary, also for a cleaner print. See also 'Examples'.
 #'
-#' @examples
+#' @examplesIf require("curl", quietly = TRUE) && curl::has_internet()
 #' \dontrun{
 #' library(bayestestR)
 #' model <- download_model("brms_zi_2")
diff --git a/man/clean_parameters.Rd b/man/clean_parameters.Rd
index 5c86ccfcd..5e1a08eb5 100644
--- a/man/clean_parameters.Rd
+++ b/man/clean_parameters.Rd
@@ -42,9 +42,11 @@ models from \pkg{brms} or \pkg{rstanarm}, or for specific terms like smooth-
 or spline-terms).
 }
 \examples{
+\dontshow{if (require("curl", quietly = TRUE) && curl::has_internet()) (if (getRversion() >= "3.4") withAutoprint else force)(\{ # examplesIf}
 \dontrun{
 library(brms)
 model <- download_model("brms_zi_2")
 clean_parameters(model)
 }
+\dontshow{\}) # examplesIf}
 }
diff --git a/man/print_parameters.Rd b/man/print_parameters.Rd
index e2cac0ce3..7250a3999 100644
--- a/man/print_parameters.Rd
+++ b/man/print_parameters.Rd
@@ -103,6 +103,7 @@ component for a better overview. Further, parameter names are "cleaned", if
 necessary, also for a cleaner print. See also 'Examples'.
 }
 \examples{
+\dontshow{if (require("curl", quietly = TRUE) && curl::has_internet()) (if (getRversion() >= "3.4") withAutoprint else force)(\{ # examplesIf}
 \dontrun{
 library(bayestestR)
 model <- download_model("brms_zi_2")
@@ -123,4 +124,5 @@ print_parameters(model, tmp)
 # different model components.
 x
 }
+\dontshow{\}) # examplesIf}
 }

From 03ae8f0fcaa8cb7ed294ad9121705e874190d6c8 Mon Sep 17 00:00:00 2001
From: Indrajeet Patil <patilindrajeet.science@gmail.com>
Date: Sat, 1 Apr 2023 14:15:33 +0200
Subject: [PATCH 13/98] Run all tests on CI/CD

https://github.com/easystats/easystats/issues/359
---
 WIP/test-PROreg.R                       |   4 +-
 tests/testthat.R                        |  32 +-
 tests/testthat/test-GLMMadaptive.R      |  13 +-
 tests/testthat/test-Gam2.R              |   4 +-
 tests/testthat/test-bigglm.R            |   4 +-
 tests/testthat/test-brms.R              |   4 +-
 tests/testthat/test-clmm.R              |  20 +-
 tests/testthat/test-feis.R              |  16 +-
 tests/testthat/test-find_random.R       |  16 +-
 tests/testthat/test-find_smooth.R       |  16 +-
 tests/testthat/test-format_table.R      |   4 +-
 tests/testthat/test-format_table_ci.R   |   4 +-
 tests/testthat/test-gam.R               |   4 +-
 tests/testthat/test-gamm.R              |   4 +-
 tests/testthat/test-gamm4.R             |  18 +-
 tests/testthat/test-gbm.R               |   4 +-
 tests/testthat/test-get_data.R          |   4 +-
 tests/testthat/test-get_deviance.R      |  49 +--
 tests/testthat/test-get_loglikelihood.R |  18 +-
 tests/testthat/test-get_variance.R      |  18 +-
 tests/testthat/test-glmmTMB.R           |  18 +-
 tests/testthat/test-lmer.R              |   6 +-
 tests/testthat/test-metaBMA.R           |   4 +-
 tests/testthat/test-model_data.R        |  10 +-
 tests/testthat/test-mvrstanarm.R        |   3 +-
 tests/testthat/test-negbin.R            | 328 ++++++++++----------
 tests/testthat/test-null_model.R        |  10 +-
 tests/testthat/test-panelr.R            |   4 +-
 tests/testthat/test-plm.R               |   4 +-
 tests/testthat/test-r3_4.R              |   4 +-
 tests/testthat/test-rlm.R               |   4 +-
 tests/testthat/test-rlmer.R             |   4 +-
 tests/testthat/test-rms.R               |   4 +-
 tests/testthat/test-rstanarm.R          |   3 +-
 tests/testthat/test-spatial.R           |   6 +-
 tests/testthat/test-tidymodels.R        |   4 +-
 tests/testthat/test-vgam.R              | 390 ++++++++++++------------
 37 files changed, 419 insertions(+), 643 deletions(-)

diff --git a/WIP/test-PROreg.R b/WIP/test-PROreg.R
index 3b30c9638..7775da706 100644
--- a/WIP/test-PROreg.R
+++ b/WIP/test-PROreg.R
@@ -1,6 +1,6 @@
-.runThisTest <- Sys.getenv("RunAllinsightTests") == "yes"
 
-if (.runThisTest && require("testthat") && require("insight") && require("PROreg")) {
+
+if ( require("PROreg")) {
   set.seed(123)
 
   # defining the parameters
diff --git a/tests/testthat.R b/tests/testthat.R
index a1eeb922a..bebf66201 100644
--- a/tests/testthat.R
+++ b/tests/testthat.R
@@ -1,34 +1,4 @@
-if (require("testthat")) {
+if (require("testthat", quietly = TRUE)) {
   library(insight)
-
-  is_dev_version <- length(strsplit(packageDescription("insight")$Version, "\\.")[[1]]) > 3
-
-  if (is_dev_version) {
-    Sys.setenv("RunAllinsightTests" = "yes")
-  } else {
-    Sys.setenv("RunAllinsightTests" = "no")
-  }
-  si <- Sys.info()
-
-  osx <- tryCatch(
-    {
-      if (!is.null(si["sysname"])) {
-        si["sysname"] == "Darwin" || grepl("^darwin", R.version$os)
-      } else {
-        FALSE
-      }
-    },
-    error = function(e) {
-      FALSE
-    }
-  )
-
-  # disable / enable if needed
-  if (.Platform$OS.type == "unix" && is_dev_version) {
-    Sys.setenv("RunAllinsightStanTests" = "yes")
-  } else {
-    Sys.setenv("RunAllinsightStanTests" = "no")
-  }
-
   test_check("insight")
 }
diff --git a/tests/testthat/test-GLMMadaptive.R b/tests/testthat/test-GLMMadaptive.R
index d723f76ee..377661df2 100644
--- a/tests/testthat/test-GLMMadaptive.R
+++ b/tests/testthat/test-GLMMadaptive.R
@@ -1,6 +1,4 @@
-.runThisTest <- Sys.getenv("RunAllinsightTests") == "yes"
-
-if (.runThisTest) {
+if (TRUE) {
   if (skip_if_not_or_load_if_installed("GLMMadaptive") && skip_if_not_or_load_if_installed("lme4")) {
     m <- download_model("GLMMadaptive_zi_2")
     m2 <- download_model("GLMMadaptive_zi_1")
@@ -341,13 +339,4 @@ if (.runThisTest) {
       )
     })
   }
-
-  # these run successfully for devtools::test_file() locally but fail on Travis
-  # not sure what's going on
-
-  # test_that("find_statistic", {
-  #   expect_identical(find_statistic(m1), "z-statistic")
-  #   expect_identical(find_statistic(m2), "z-statistic")
-  #   expect_identical(find_statistic(m3), "z-statistic")
-  # })
 }
diff --git a/tests/testthat/test-Gam2.R b/tests/testthat/test-Gam2.R
index f51401e8d..e533931a5 100644
--- a/tests/testthat/test-Gam2.R
+++ b/tests/testthat/test-Gam2.R
@@ -1,6 +1,4 @@
-.runThisTest <- Sys.getenv("RunAllinsightTests") == "yes"
-
-if (.runThisTest &&
+if (
 
 
   skip_if_not_or_load_if_installed("gam")) {
diff --git a/tests/testthat/test-bigglm.R b/tests/testthat/test-bigglm.R
index ebe321175..2101f2a67 100644
--- a/tests/testthat/test-bigglm.R
+++ b/tests/testthat/test-bigglm.R
@@ -1,6 +1,4 @@
-.runThisTest <- Sys.getenv("RunAllinsightTests") == "yes"
-
-if (.runThisTest && skip_if_not_or_load_if_installed("glmmTMB") && skip_if_not_or_load_if_installed("biglm")) {
+if (skip_if_not_or_load_if_installed("glmmTMB") && skip_if_not_or_load_if_installed("biglm")) {
   data(Salamanders)
   Salamanders$cover <- abs(Salamanders$cover)
 
diff --git a/tests/testthat/test-brms.R b/tests/testthat/test-brms.R
index 7794dd84c..28c58aa07 100644
--- a/tests/testthat/test-brms.R
+++ b/tests/testthat/test-brms.R
@@ -1,6 +1,4 @@
-.runThisTest <- Sys.getenv("RunAllinsightTests") == "yes"
-
-if (.runThisTest && skip_if_not_or_load_if_installed("brms")) {
+if (skip_if_not_or_load_if_installed("brms")) {
   # Model fitting -----------------------------------------------------------
 
   m1 <- suppressWarnings(insight::download_model("brms_mixed_6"))
diff --git a/tests/testthat/test-clmm.R b/tests/testthat/test-clmm.R
index 5525c16ae..d5e265922 100644
--- a/tests/testthat/test-clmm.R
+++ b/tests/testthat/test-clmm.R
@@ -1,20 +1,4 @@
-osx <- tryCatch(
-  {
-    si <- Sys.info()
-    if (!is.null(si["sysname"])) {
-      si["sysname"] == "Darwin" || grepl("^darwin", R.version$os)
-    } else {
-      FALSE
-    }
-  },
-  error = function(e) {
-    FALSE
-  }
-)
-
-.runThisTest <- Sys.getenv("RunAllinsightTests") == "yes"
-
-if (.runThisTest && skip_if_not_or_load_if_installed("lme4") && skip_if_not_or_load_if_installed("ordinal")) {
+if (skip_if_not_or_load_if_installed("lme4") && skip_if_not_or_load_if_installed("ordinal")) {
   data(wine, package = "ordinal")
   data(soup)
 
@@ -178,7 +162,7 @@ if (.runThisTest && skip_if_not_or_load_if_installed("lme4") && skip_if_not_or_l
     expect_false(is_multivariate(m2))
   })
 
-  if (getRversion() > "3.6.3" && !isTRUE(osx)) {
+  if (getRversion() > "3.6.3") {
     test_that("get_variance", {
       expect_equal(
         get_variance(m1),
diff --git a/tests/testthat/test-feis.R b/tests/testthat/test-feis.R
index 14e0fe0d8..404ceb675 100644
--- a/tests/testthat/test-feis.R
+++ b/tests/testthat/test-feis.R
@@ -1,18 +1,4 @@
-osx <- tryCatch(
-  {
-    si <- Sys.info()
-    if (!is.null(si["sysname"])) {
-      si["sysname"] == "Darwin" || grepl("^darwin", R.version$os)
-    } else {
-      FALSE
-    }
-  },
-  error = function(e) {
-    FALSE
-  }
-)
-
-if (!osx && skip_if_not_or_load_if_installed("plm") && skip_if_not_or_load_if_installed("feisr")) {
+if (skip_if_not_or_load_if_installed("plm") && skip_if_not_or_load_if_installed("feisr")) {
   data(mwp)
   m1 <- feis(
     lnw ~ marry + enrol + as.factor(yeargr) | exp + I(exp^2),
diff --git a/tests/testthat/test-find_random.R b/tests/testthat/test-find_random.R
index 19d75f2ea..5f603ab02 100644
--- a/tests/testthat/test-find_random.R
+++ b/tests/testthat/test-find_random.R
@@ -1,18 +1,4 @@
-osx <- tryCatch(
-  {
-    si <- Sys.info()
-    if (!is.null(si["sysname"])) {
-      si["sysname"] == "Darwin" || grepl("^darwin", R.version$os)
-    } else {
-      FALSE
-    }
-  },
-  error = function(e) {
-    FALSE
-  }
-)
-
-if (!osx && skip_if_not_or_load_if_installed("mgcv") && skip_if_not_or_load_if_installed("gamm4") && skip_if_not_or_load_if_installed("rstanarm")) {
+if (skip_if_not_or_load_if_installed("mgcv") && skip_if_not_or_load_if_installed("gamm4") && skip_if_not_or_load_if_installed("rstanarm")) {
   data <- iris
   data$g <- data$Species
   data$Xr <- data$Species
diff --git a/tests/testthat/test-find_smooth.R b/tests/testthat/test-find_smooth.R
index 072ef9896..30459ee80 100644
--- a/tests/testthat/test-find_smooth.R
+++ b/tests/testthat/test-find_smooth.R
@@ -1,18 +1,4 @@
-osx <- tryCatch(
-  {
-    si <- Sys.info()
-    if (!is.null(si["sysname"])) {
-      si["sysname"] == "Darwin" || grepl("^darwin", R.version$os)
-    } else {
-      FALSE
-    }
-  },
-  error = function(e) {
-    FALSE
-  }
-)
-
-if (skip_if_not_or_load_if_installed("mgcv") && skip_if_not_or_load_if_installed("gamm4") && skip_if_not_or_load_if_installed("rstanarm") && !osx) {
+if (skip_if_not_or_load_if_installed("mgcv") && skip_if_not_or_load_if_installed("gamm4") && skip_if_not_or_load_if_installed("rstanarm")) {
   set.seed(2) ## simulate some data...
   void <- capture.output(
     dat <- mgcv::gamSim(1, n = 400, dist = "normal", scale = 2)
diff --git a/tests/testthat/test-format_table.R b/tests/testthat/test-format_table.R
index ed0879a37..bf9756a05 100644
--- a/tests/testthat/test-format_table.R
+++ b/tests/testthat/test-format_table.R
@@ -1,5 +1,3 @@
-.runThisTest <- Sys.getenv("RunAllinsightTests") == "yes"
-
 win_os <- tryCatch(
   {
     si <- Sys.info()
@@ -16,7 +14,7 @@ win_os <- tryCatch(
 
 
 # test for bayesian models -----------------
-if (.runThisTest && win_os && skip_if_not_or_load_if_installed("bayestestR")) {
+if (win_os && skip_if_not_or_load_if_installed("bayestestR")) {
   m1 <- insight::download_model("stanreg_glm_1")
   set.seed(123)
   x <- suppressWarnings(as.data.frame(bayestestR::describe_posterior(m1, test = c("pd", "bf"))))
diff --git a/tests/testthat/test-format_table_ci.R b/tests/testthat/test-format_table_ci.R
index b16d634a3..fde322ab2 100644
--- a/tests/testthat/test-format_table_ci.R
+++ b/tests/testthat/test-format_table_ci.R
@@ -50,8 +50,8 @@ test_that("format_table with multiple si-levels", {
   expect_equal(colnames(ft), c("BF = 3 SI", "BF = 0.2 SI"))
 })
 
-.runThisTest <- Sys.getenv("RunAllinsightTests") == "yes"
-if (.runThisTest && skip_if_not_or_load_if_installed("bayestestR")) {
+
+if (skip_if_not_or_load_if_installed("bayestestR")) {
   set.seed(1234)
   test_that("format_table with multiple si-levels", {
     d <- bayestestR::distribution_normal(1000)
diff --git a/tests/testthat/test-gam.R b/tests/testthat/test-gam.R
index de8e49eb3..dcdc0568a 100644
--- a/tests/testthat/test-gam.R
+++ b/tests/testthat/test-gam.R
@@ -1,6 +1,4 @@
-.runThisTest <- Sys.getenv("RunAllinsightTests") == "yes"
-
-if (.runThisTest && skip_if_not_or_load_if_installed("mgcv") && skip_if_not_or_load_if_installed("httr")) {
+if (skip_if_not_or_load_if_installed("mgcv") && skip_if_not_or_load_if_installed("httr")) {
   set.seed(123)
   void <- capture.output(
     dat2 <<- mgcv::gamSim(1, n = 400, dist = "normal", scale = 2)
diff --git a/tests/testthat/test-gamm.R b/tests/testthat/test-gamm.R
index 83a9c5385..7c18e2123 100644
--- a/tests/testthat/test-gamm.R
+++ b/tests/testthat/test-gamm.R
@@ -1,6 +1,4 @@
-.runThisTest <- Sys.getenv("RunAllinsightTests") == "yes"
-
-if (.runThisTest) {
+if (TRUE) {
   unloadNamespace("gam")
   if (skip_if_not_or_load_if_installed("mgcv")) {
     set.seed(0)
diff --git a/tests/testthat/test-gamm4.R b/tests/testthat/test-gamm4.R
index 13ee09617..8b365cd18 100644
--- a/tests/testthat/test-gamm4.R
+++ b/tests/testthat/test-gamm4.R
@@ -1,22 +1,8 @@
-osx <- tryCatch(
-  {
-    si <- Sys.info()
-    if (!is.null(si["sysname"])) {
-      si["sysname"] == "Darwin" || grepl("^darwin", R.version$os)
-    } else {
-      FALSE
-    }
-  },
-  error = function(e) {
-    FALSE
-  }
-)
-
 unloadNamespace("gam")
 
-.runThisTest <- Sys.getenv("RunAllinsightTests") == "yes"
 
-if (.runThisTest && !osx && skip_if_not_or_load_if_installed("gamm4")) {
+
+if (skip_if_not_or_load_if_installed("gamm4")) {
   set.seed(0)
   void <- capture.output(dat <- gamSim(1, n = 400, scale = 2)) ## simulate 4 term additive truth
   dat$fac <- fac <- as.factor(sample(1:20, 400, replace = TRUE))
diff --git a/tests/testthat/test-gbm.R b/tests/testthat/test-gbm.R
index d018bc1d2..d84ca80e1 100644
--- a/tests/testthat/test-gbm.R
+++ b/tests/testthat/test-gbm.R
@@ -1,6 +1,4 @@
-.runThisTest <- Sys.getenv("RunAllinsightTests") == "yes"
-
-if (.runThisTest) {
+if (TRUE) {
   if (skip_if_not_or_load_if_installed("gbm")) {
     set.seed(102) # for reproducibility
     void <- capture.output(
diff --git a/tests/testthat/test-get_data.R b/tests/testthat/test-get_data.R
index a443a278e..d26221514 100644
--- a/tests/testthat/test-get_data.R
+++ b/tests/testthat/test-get_data.R
@@ -174,10 +174,10 @@ test_that("lm with poly and NA in response", {
 })
 
 
-.runThisTest <- Sys.getenv("RunAllinsightTests") == "yes"
+
 .runStanTest <- Sys.getenv("RunAllinsightStanTests") == "yes"
 
-if (.runThisTest) {
+if (TRUE) {
   data(iris)
   m <- lm(Sepal.Length ~ Sepal.Width, data = iris)
   out <- get_data(m)
diff --git a/tests/testthat/test-get_deviance.R b/tests/testthat/test-get_deviance.R
index 0a0ae074e..be1a37435 100644
--- a/tests/testthat/test-get_deviance.R
+++ b/tests/testthat/test-get_deviance.R
@@ -1,34 +1,15 @@
-osx <- tryCatch(
-  {
-    si <- Sys.info()
-    if (!is.null(si["sysname"])) {
-      si["sysname"] == "Darwin" || grepl("^darwin", R.version$os)
-    } else {
-      FALSE
-    }
-  },
-  error = function(e) {
-    FALSE
-  }
-)
-
-.runThisTest <- Sys.getenv("RunAllinsightTests") == "yes"
-.runStanTest <- Sys.getenv("RunAllinsightStanTests") == "yes"
-
-if (.runThisTest && .runStanTest && !osx) {
-  skip_if_not_or_load_if_installed("lme4")
-  skip_if_not_or_load_if_installed("rstanarm")
-  data(mtcars)
-
-  test_that("get_deviance - Bayesian lm", {
-    m1 <- lm(mpg ~ disp, data = mtcars)
-    m2 <- rstanarm::stan_glm(mpg ~ disp, data = mtcars, refresh = 0)
-    expect_equal(get_deviance(m1), get_deviance(m2, verbose = FALSE), tolerance = 1e-1)
-  })
-
-  test_that("get_deviance - Bayesian glm", {
-    m1 <- glm(vs ~ disp, data = mtcars, family = "binomial")
-    m2 <- rstanarm::stan_glm(vs ~ disp, data = mtcars, family = "binomial", refresh = 0)
-    expect_equal(get_deviance(m1), get_deviance(m2, verbose = FALSE), tolerance = 1e-1)
-  })
-}
+skip_if_not_or_load_if_installed("lme4")
+skip_if_not_or_load_if_installed("rstanarm")
+data(mtcars)
+
+test_that("get_deviance - Bayesian lm", {
+  m1 <- lm(mpg ~ disp, data = mtcars)
+  m2 <- rstanarm::stan_glm(mpg ~ disp, data = mtcars, refresh = 0)
+  expect_equal(get_deviance(m1), get_deviance(m2, verbose = FALSE), tolerance = 1e-1)
+})
+
+test_that("get_deviance - Bayesian glm", {
+  m1 <- glm(vs ~ disp, data = mtcars, family = "binomial")
+  m2 <- rstanarm::stan_glm(vs ~ disp, data = mtcars, family = "binomial", refresh = 0)
+  expect_equal(get_deviance(m1), get_deviance(m2, verbose = FALSE), tolerance = 1e-1)
+})
diff --git a/tests/testthat/test-get_loglikelihood.R b/tests/testthat/test-get_loglikelihood.R
index dd4ddb229..91bda3a30 100644
--- a/tests/testthat/test-get_loglikelihood.R
+++ b/tests/testthat/test-get_loglikelihood.R
@@ -1,20 +1,4 @@
-osx <- tryCatch(
-  {
-    si <- Sys.info()
-    if (!is.null(si["sysname"])) {
-      si["sysname"] == "Darwin" || grepl("^darwin", R.version$os)
-    } else {
-      FALSE
-    }
-  },
-  error = function(e) {
-    FALSE
-  }
-)
-
-.runThisTest <- Sys.getenv("RunAllinsightTests") == "yes"
-
-if (.runThisTest && !osx && skip_if_not_or_load_if_installed("nonnest2")) {
+if (skip_if_not_or_load_if_installed("nonnest2")) {
   data(iris)
   data(mtcars)
 
diff --git a/tests/testthat/test-get_variance.R b/tests/testthat/test-get_variance.R
index 028e7ff91..0a5abc46a 100644
--- a/tests/testthat/test-get_variance.R
+++ b/tests/testthat/test-get_variance.R
@@ -1,20 +1,4 @@
-osx <- tryCatch(
-  {
-    si <- Sys.info()
-    if (!is.null(si["sysname"])) {
-      si["sysname"] == "Darwin" || grepl("^darwin", R.version$os)
-    } else {
-      FALSE
-    }
-  },
-  error = function(e) {
-    FALSE
-  }
-)
-
-.runThisTest <- Sys.getenv("RunAllinsightTests") == "yes"
-
-if (!osx && .runThisTest && skip_if_not_or_load_if_installed("lme4")) {
+if (skip_if_not_or_load_if_installed("lme4")) {
   data("sleepstudy")
   data("Penicillin")
   set.seed(12345)
diff --git a/tests/testthat/test-glmmTMB.R b/tests/testthat/test-glmmTMB.R
index da7b66a0e..61fff0a1a 100644
--- a/tests/testthat/test-glmmTMB.R
+++ b/tests/testthat/test-glmmTMB.R
@@ -1,19 +1,5 @@
 skip_on_os("mac") # error: FreeADFunObject
 
-osx <- tryCatch(
-  {
-    si <- Sys.info()
-    if (!is.null(si["sysname"])) {
-      si["sysname"] == "Darwin" || startsWith(R.version$os, "darwin")
-    } else {
-      FALSE
-    }
-  },
-  error = function(e) {
-    FALSE
-  }
-)
-
 skip_if_not_or_load_if_installed("TMB")
 skip_if_not_or_load_if_installed("glmmTMB")
 
@@ -799,7 +785,7 @@ if (getRversion() >= "4.0.0") {
 
   test_that("find_random_slopes", {
     skip_on_cran()
-    skip_on_travis()
+
 
     expect_null(find_random_slopes(m6))
 
@@ -919,7 +905,7 @@ if (getRversion() >= "4.0.0") {
     )
   })
 
-  if (!osx && packageVersion("glmmTMB") > "1.1.4") {
+  if (packageVersion("glmmTMB") > "1.1.4") {
     test_that("get_predicted", {
       # response
       x <- get_predicted(m1, predict = "expectation", verbose = FALSE, include_random = TRUE)
diff --git a/tests/testthat/test-lmer.R b/tests/testthat/test-lmer.R
index 909775ffc..1062f5923 100644
--- a/tests/testthat/test-lmer.R
+++ b/tests/testthat/test-lmer.R
@@ -1,6 +1,4 @@
-.runThisTest <- Sys.getenv("RunAllinsightTests") == "yes"
-
-if (.runThisTest && skip_if_not_or_load_if_installed("lme4")) {
+if (skip_if_not_or_load_if_installed("lme4")) {
   data(sleepstudy)
   set.seed(123)
   sleepstudy$mygrp <- sample(1:5, size = 180, replace = TRUE)
@@ -388,7 +386,7 @@ if (.runThisTest && skip_if_not_or_load_if_installed("lme4")) {
       tolerance = 1e-1
     )
 
-    if (.runThisTest) {
+    if (TRUE) {
       expect_equal(
         suppressWarnings(get_variance(m2)),
         list(
diff --git a/tests/testthat/test-metaBMA.R b/tests/testthat/test-metaBMA.R
index 14f4bad04..e67b5a7df 100644
--- a/tests/testthat/test-metaBMA.R
+++ b/tests/testthat/test-metaBMA.R
@@ -1,6 +1,4 @@
-.runThisTest <- Sys.getenv("RunAllinsightTests") == "yes"
-
-if (.runThisTest && skip_if_not_or_load_if_installed("metaBMA")) {
+if (skip_if_not_or_load_if_installed("metaBMA")) {
   data(towels)
   set.seed(123)
   mf <- meta_fixed(logOR,
diff --git a/tests/testthat/test-model_data.R b/tests/testthat/test-model_data.R
index a9a471e1a..126e35841 100644
--- a/tests/testthat/test-model_data.R
+++ b/tests/testthat/test-model_data.R
@@ -1,10 +1,8 @@
-.runThisTest <- Sys.getenv("RunAllinsightTests") == "yes"
-
-if (.runThisTest &&
+if (
   skip_if_not_or_load_if_installed("splines") &&
-  skip_if_not_or_load_if_installed("TMB") &&
-  skip_if_not_or_load_if_installed("glmmTMB") &&
-  getRversion() >= "4.0.0") {
+    skip_if_not_or_load_if_installed("TMB") &&
+    skip_if_not_or_load_if_installed("glmmTMB") &&
+    getRversion() >= "4.0.0") {
   data(iris)
 
   m1 <- lm(Sepal.Length ~ Species + ns(Petal.Width), data = iris)
diff --git a/tests/testthat/test-mvrstanarm.R b/tests/testthat/test-mvrstanarm.R
index 079ff787d..b52b8a255 100644
--- a/tests/testthat/test-mvrstanarm.R
+++ b/tests/testthat/test-mvrstanarm.R
@@ -1,7 +1,6 @@
-.runThisTest <- Sys.getenv("RunAllinsightTests") == "yes"
 .runStanTest <- Sys.getenv("RunAllinsightStanTests") == "yes"
 
-if (.runThisTest && .runStanTest &&
+if (.runStanTest &&
   suppressWarnings(
     skip_if_not_or_load_if_installed("rstanarm")
   )) {
diff --git a/tests/testthat/test-negbin.R b/tests/testthat/test-negbin.R
index 37696f587..7f92abc75 100644
--- a/tests/testthat/test-negbin.R
+++ b/tests/testthat/test-negbin.R
@@ -1,176 +1,172 @@
-.runThisTest <- Sys.getenv("RunAllinsightTests") == "yes"
-
-if (.runThisTest && Sys.getenv("USER") != "travis") {
-  if (skip_if_not_or_load_if_installed("aod")) {
-    data(dja)
-    m1 <- suppressWarnings(
-      aod::negbin(y ~ group + offset(log(trisk)),
-        random = ~village,
-        data = dja
-      )
+if (skip_if_not_or_load_if_installed("aod")) {
+  data(dja)
+  m1 <- suppressWarnings(
+    aod::negbin(y ~ group + offset(log(trisk)),
+      random = ~village,
+      data = dja
     )
-
-    test_that("model_info", {
-      expect_true(model_info(m1)$is_negbin)
-      expect_true(model_info(m1)$is_mixed)
-      expect_false(model_info(m1)$is_linear)
-    })
-
-    test_that("find_predictors", {
-      expect_identical(find_predictors(m1), list(conditional = c("group", "trisk")))
-      expect_identical(find_predictors(m1, flatten = TRUE), c("group", "trisk"))
-      expect_identical(
-        find_predictors(m1, effects = "random"),
-        list(random = "village")
-      )
-      expect_identical(
-        find_predictors(m1, effects = "all"),
-        list(
-          conditional = c("group", "trisk"),
-          random = "village"
-        )
+  )
+
+  test_that("model_info", {
+    expect_true(model_info(m1)$is_negbin)
+    expect_true(model_info(m1)$is_mixed)
+    expect_false(model_info(m1)$is_linear)
+  })
+
+  test_that("find_predictors", {
+    expect_identical(find_predictors(m1), list(conditional = c("group", "trisk")))
+    expect_identical(find_predictors(m1, flatten = TRUE), c("group", "trisk"))
+    expect_identical(
+      find_predictors(m1, effects = "random"),
+      list(random = "village")
+    )
+    expect_identical(
+      find_predictors(m1, effects = "all"),
+      list(
+        conditional = c("group", "trisk"),
+        random = "village"
       )
-    })
+    )
+  })
 
-    test_that("get_df", {
-      expect_equal(
-        get_df(m1, type = "residual"),
-        df.residual(m1),
-        ignore_attr = TRUE
-      )
-      expect_equal(
-        get_df(m1, type = "normal"),
-        Inf,
-        ignore_attr = TRUE
-      )
-      expect_equal(
-        get_df(m1, type = "wald"),
-        Inf,
-        ignore_attr = TRUE
-      )
-    })
-
-    test_that("find_random", {
-      expect_identical(find_random(m1), list(random = "village"))
-    })
-
-    test_that("get_random", {
-      expect_equal(get_random(m1), dja[, "village", drop = FALSE], ignore_attr = TRUE)
-    })
-
-    test_that("find_response", {
-      expect_identical(find_response(m1), "y")
-      expect_identical(find_response(m1, combine = FALSE), "y")
-    })
-
-    test_that("get_response", {
-      expect_equal(get_response(m1), dja[, "y"])
-    })
-
-    test_that("get_predictors", {
-      expect_equal(colnames(get_predictors(m1)), c("group", "trisk"))
-    })
-
-    test_that("link_inverse", {
-      expect_equal(link_inverse(m1)(0.2), exp(0.2), tolerance = 1e-5)
-    })
-
-    test_that("link_function", {
-      expect_equal(link_function(m1)(0.2), log(0.2), tolerance = 1e-5)
-    })
-
-    test_that("get_data", {
-      expect_equal(nrow(get_data(m1, verbose = FALSE)), 75)
-      expect_equal(colnames(get_data(m1, verbose = FALSE)), c("y", "group", "trisk", "village"))
-    })
-
-    test_that("find_formula", {
-      expect_length(find_formula(m1), 2)
-      expect_equal(
-        find_formula(m1),
-        list(
-          conditional = as.formula("y ~ group + offset(log(trisk))"),
-          random = as.formula("~village")
-        ),
-        ignore_attr = TRUE
-      )
-    })
-
-    test_that("find_variables", {
-      expect_equal(
-        find_variables(m1),
-        list(
-          response = "y",
-          conditional = c("group", "trisk"),
-          random = "village"
-        )
-      )
-      expect_equal(
-        find_variables(m1, flatten = TRUE),
-        c("y", "group", "trisk", "village")
+  test_that("get_df", {
+    expect_equal(
+      get_df(m1, type = "residual"),
+      df.residual(m1),
+      ignore_attr = TRUE
+    )
+    expect_equal(
+      get_df(m1, type = "normal"),
+      Inf,
+      ignore_attr = TRUE
+    )
+    expect_equal(
+      get_df(m1, type = "wald"),
+      Inf,
+      ignore_attr = TRUE
+    )
+  })
+
+  test_that("find_random", {
+    expect_identical(find_random(m1), list(random = "village"))
+  })
+
+  test_that("get_random", {
+    expect_equal(get_random(m1), dja[, "village", drop = FALSE], ignore_attr = TRUE)
+  })
+
+  test_that("find_response", {
+    expect_identical(find_response(m1), "y")
+    expect_identical(find_response(m1, combine = FALSE), "y")
+  })
+
+  test_that("get_response", {
+    expect_equal(get_response(m1), dja[, "y"])
+  })
+
+  test_that("get_predictors", {
+    expect_equal(colnames(get_predictors(m1)), c("group", "trisk"))
+  })
+
+  test_that("link_inverse", {
+    expect_equal(link_inverse(m1)(0.2), exp(0.2), tolerance = 1e-5)
+  })
+
+  test_that("link_function", {
+    expect_equal(link_function(m1)(0.2), log(0.2), tolerance = 1e-5)
+  })
+
+  test_that("get_data", {
+    expect_equal(nrow(get_data(m1, verbose = FALSE)), 75)
+    expect_equal(colnames(get_data(m1, verbose = FALSE)), c("y", "group", "trisk", "village"))
+  })
+
+  test_that("find_formula", {
+    expect_length(find_formula(m1), 2)
+    expect_equal(
+      find_formula(m1),
+      list(
+        conditional = as.formula("y ~ group + offset(log(trisk))"),
+        random = as.formula("~village")
+      ),
+      ignore_attr = TRUE
+    )
+  })
+
+  test_that("find_variables", {
+    expect_equal(
+      find_variables(m1),
+      list(
+        response = "y",
+        conditional = c("group", "trisk"),
+        random = "village"
       )
-    })
-
-    test_that("n_obs", {
-      expect_equal(n_obs(m1), 75)
-    })
-
-    test_that("find_parameters", {
-      expect_equal(
-        find_parameters(m1),
-        list(
-          conditional = c("(Intercept)", "groupTREAT"),
-          random = c(
-            "phi.villageBAK",
-            "phi.villageBAM",
-            "phi.villageBAN",
-            "phi.villageBIJ",
-            "phi.villageBOU",
-            "phi.villageBYD",
-            "phi.villageDEM",
-            "phi.villageDIA",
-            "phi.villageHAM",
-            "phi.villageLAM",
-            "phi.villageLAY",
-            "phi.villageMAF",
-            "phi.villageMAH",
-            "phi.villageMAK",
-            "phi.villageMED",
-            "phi.villageNAB",
-            "phi.villageSAG",
-            "phi.villageSAM",
-            "phi.villageSOU"
-          )
+    )
+    expect_equal(
+      find_variables(m1, flatten = TRUE),
+      c("y", "group", "trisk", "village")
+    )
+  })
+
+  test_that("n_obs", {
+    expect_equal(n_obs(m1), 75)
+  })
+
+  test_that("find_parameters", {
+    expect_equal(
+      find_parameters(m1),
+      list(
+        conditional = c("(Intercept)", "groupTREAT"),
+        random = c(
+          "phi.villageBAK",
+          "phi.villageBAM",
+          "phi.villageBAN",
+          "phi.villageBIJ",
+          "phi.villageBOU",
+          "phi.villageBYD",
+          "phi.villageDEM",
+          "phi.villageDIA",
+          "phi.villageHAM",
+          "phi.villageLAM",
+          "phi.villageLAY",
+          "phi.villageMAF",
+          "phi.villageMAH",
+          "phi.villageMAK",
+          "phi.villageMED",
+          "phi.villageNAB",
+          "phi.villageSAG",
+          "phi.villageSAM",
+          "phi.villageSOU"
         )
       )
-      expect_equal(nrow(get_parameters(m1)), 2)
-      expect_equal(
-        get_parameters(m1)$Parameter,
-        c("(Intercept)", "groupTREAT")
-      )
-    })
-
-    test_that("is_multivariate", {
-      expect_false(is_multivariate(m1))
-    })
-
-    test_that("find_terms", {
-      expect_equal(
-        find_terms(m1),
-        list(
-          response = "y",
-          conditional = c("group", "offset(log(trisk))"),
-          random = "village"
-        )
+    )
+    expect_equal(nrow(get_parameters(m1)), 2)
+    expect_equal(
+      get_parameters(m1)$Parameter,
+      c("(Intercept)", "groupTREAT")
+    )
+  })
+
+  test_that("is_multivariate", {
+    expect_false(is_multivariate(m1))
+  })
+
+  test_that("find_terms", {
+    expect_equal(
+      find_terms(m1),
+      list(
+        response = "y",
+        conditional = c("group", "offset(log(trisk))"),
+        random = "village"
       )
-    })
+    )
+  })
 
-    test_that("find_algorithm", {
-      expect_equal(find_algorithm(m1), list(algorithm = "ML"))
-    })
+  test_that("find_algorithm", {
+    expect_equal(find_algorithm(m1), list(algorithm = "ML"))
+  })
 
-    test_that("find_statistic", {
-      expect_identical(find_statistic(m1), "z-statistic")
-    })
-  }
+  test_that("find_statistic", {
+    expect_identical(find_statistic(m1), "z-statistic")
+  })
 }
diff --git a/tests/testthat/test-null_model.R b/tests/testthat/test-null_model.R
index 92a1fdf18..a7b257588 100644
--- a/tests/testthat/test-null_model.R
+++ b/tests/testthat/test-null_model.R
@@ -1,10 +1,8 @@
-.runThisTest <- Sys.getenv("RunAllinsightTests") == "yes"
-
-if (.runThisTest &&
+if (
   skip_if_not_or_load_if_installed("glmmTMB") &&
-  skip_if_not_or_load_if_installed("lme4") &&
-  skip_if_not_or_load_if_installed("TMB") &&
-  getRversion() >= "4.0.0") {
+    skip_if_not_or_load_if_installed("lme4") &&
+    skip_if_not_or_load_if_installed("TMB") &&
+    getRversion() >= "4.0.0") {
   data(mtcars)
   m1 <- suppressWarnings(glmer.nb(mpg ~ disp + (1 | cyl) + offset(log(wt)), data = mtcars))
   m2 <- suppressWarnings(glmer.nb(mpg ~ disp + (1 | cyl), offset = log(wt), data = mtcars))
diff --git a/tests/testthat/test-panelr.R b/tests/testthat/test-panelr.R
index 24cf54eb6..c222400e7 100644
--- a/tests/testthat/test-panelr.R
+++ b/tests/testthat/test-panelr.R
@@ -262,8 +262,8 @@ if (skip_if_not_or_load_if_installed("panelr")) {
     expect_identical(find_statistic(m2), "t-statistic")
   })
 
-  .runThisTest <- Sys.getenv("RunAllinsightTests") == "yes"
-  if (.runThisTest) {
+
+  if (TRUE) {
     v <- get_variance(m1)
     expect_equal(v$var.intercept, c(id = 0.125306895731005), tolerance = 1e-4)
     expect_equal(v$var.fixed, 0.0273792999320531, tolerance = 1e-4)
diff --git a/tests/testthat/test-plm.R b/tests/testthat/test-plm.R
index af92ed32a..5266fadf7 100644
--- a/tests/testthat/test-plm.R
+++ b/tests/testthat/test-plm.R
@@ -1,6 +1,4 @@
-.runThisTest <- Sys.getenv("RunAllinsightTests") == "yes"
-
-if (.runThisTest && getRversion() > "3.5") {
+if (getRversion() > "3.5") {
   if (skip_if_not_or_load_if_installed("plm")) {
     data(Crime)
     m1 <- suppressWarnings(plm(lcrmrte ~ lprbarr + factor(year) | . - lprbarr + lmix, data = Crime, model = "random"))
diff --git a/tests/testthat/test-r3_4.R b/tests/testthat/test-r3_4.R
index 3f799866c..50af4351d 100644
--- a/tests/testthat/test-r3_4.R
+++ b/tests/testthat/test-r3_4.R
@@ -1,6 +1,4 @@
-.runThisTest <- Sys.getenv("RunAllinsightTests") == "yes"
-
-if (.runThisTest && skip_if_not_or_load_if_installed("insight")) {
+if (skip_if_not_or_load_if_installed("insight")) {
   data(mtcars)
   m <- glm(am ~ mpg, mtcars, family = binomial())
   test_that("find_random", {
diff --git a/tests/testthat/test-rlm.R b/tests/testthat/test-rlm.R
index d66848813..53b7f32c4 100644
--- a/tests/testthat/test-rlm.R
+++ b/tests/testthat/test-rlm.R
@@ -1,5 +1,3 @@
-.runThisTest <- Sys.getenv("RunAllinsightTests") == "yes"
-
 if (skip_if_not_or_load_if_installed("MASS")) {
   test_that("model.matrix.rlm accepts `data` argument", {
     mod <- MASS::rlm(mpg ~ hp + factor(cyl), mtcars)
@@ -11,7 +9,7 @@ if (skip_if_not_or_load_if_installed("MASS")) {
     expect_equal(dim(mm), c(6, 4))
   })
 
-  if (.runThisTest) {
+  if (TRUE) {
     test_that("predict.rlm", {
       mod <- MASS::rlm(mpg ~ hp + factor(cyl), mtcars)
       a <- get_predicted(mod)
diff --git a/tests/testthat/test-rlmer.R b/tests/testthat/test-rlmer.R
index 7636bb208..bf696b6f1 100644
--- a/tests/testthat/test-rlmer.R
+++ b/tests/testthat/test-rlmer.R
@@ -1,6 +1,4 @@
-.runThisTest <- Sys.getenv("RunAllinsightTests") == "yes"
-
-if (.runThisTest && skip_if_not_or_load_if_installed("robustlmm") && utils::packageVersion("robustlmm") >= "3.0.1" &&
+if (skip_if_not_or_load_if_installed("robustlmm") && utils::packageVersion("robustlmm") >= "3.0.1" &&
   skip_if_not_or_load_if_installed("lme4") && getRversion() >= "4.1.0") {
   data(sleepstudy)
 
diff --git a/tests/testthat/test-rms.R b/tests/testthat/test-rms.R
index 8368ea807..e3dc4f71a 100644
--- a/tests/testthat/test-rms.R
+++ b/tests/testthat/test-rms.R
@@ -1,6 +1,4 @@
-.runThisTest <- Sys.getenv("RunAllinsightTests") == "yes"
-
-if (.runThisTest && skip_if_not_or_load_if_installed("rms")) {
+if (skip_if_not_or_load_if_installed("rms")) {
   data(mtcars)
   m1 <- lrm(am ~ mpg + gear, data = mtcars)
 
diff --git a/tests/testthat/test-rstanarm.R b/tests/testthat/test-rstanarm.R
index 1e5eb4199..d0bf6e5b7 100644
--- a/tests/testthat/test-rstanarm.R
+++ b/tests/testthat/test-rstanarm.R
@@ -1,7 +1,6 @@
-.runThisTest <- Sys.getenv("RunAllinsightTests") == "yes"
 .runStanTest <- Sys.getenv("RunAllinsightStanTests") == "yes"
 
-if (.runThisTest && .runStanTest) {
+if (.runStanTest) {
   if (suppressWarnings(
     skip_if_not_or_load_if_installed("lme4") &&
       skip_if_not_or_load_if_installed("BayesFactor") &&
diff --git a/tests/testthat/test-spatial.R b/tests/testthat/test-spatial.R
index 8704362a7..26b14ee5a 100644
--- a/tests/testthat/test-spatial.R
+++ b/tests/testthat/test-spatial.R
@@ -1,6 +1,4 @@
-.runThisTest <- Sys.getenv("RunAllinsightTests") == "yes"
-
-if (.runThisTest) {
+if (TRUE) {
   skip_if_not_or_load_if_installed("glmmTMB")
   skip_if_not_or_load_if_installed("geoR")
   skip_if_not_or_load_if_installed("TMB")
@@ -156,7 +154,7 @@ if (.runThisTest) {
 
   test_that("find_random_slopes", {
     skip_on_cran()
-    skip_on_travis()
+
 
     expect_identical(
       find_random_slopes(m1),
diff --git a/tests/testthat/test-tidymodels.R b/tests/testthat/test-tidymodels.R
index ec4b96162..f2b8837a1 100644
--- a/tests/testthat/test-tidymodels.R
+++ b/tests/testthat/test-tidymodels.R
@@ -1,6 +1,4 @@
-.runThisTest <- Sys.getenv("RunAllinsightTests") == "yes"
-
-if (.runThisTest && skip_if_not_or_load_if_installed("parsnip")) {
+if (skip_if_not_or_load_if_installed("parsnip")) {
   data(mtcars)
 
   m <- parsnip::linear_reg()
diff --git a/tests/testthat/test-vgam.R b/tests/testthat/test-vgam.R
index 652454140..c6100a7ad 100644
--- a/tests/testthat/test-vgam.R
+++ b/tests/testthat/test-vgam.R
@@ -1,203 +1,199 @@
-.runThisTest <- Sys.getenv("RunAllinsightTests") == "yes"
-
-if (.runThisTest && Sys.getenv("USER") != "travis") {
-  if (skip_if_not_or_load_if_installed("VGAM")) {
-    data("hunua")
-    m1 <- download_model("vgam_1")
-    m2 <- download_model("vgam_2")
-
-    test_that("model_info", {
-      expect_true(model_info(m1)$is_binomial)
-      expect_true(model_info(m2)$is_binomial)
-      expect_false(model_info(m1)$is_bayesian)
-      expect_false(model_info(m2)$is_bayesian)
-    })
-
-    test_that("find_predictors", {
-      expect_identical(find_predictors(m1), list(conditional = c("vitluc", "altitude")))
-      expect_identical(
-        find_predictors(m1, flatten = TRUE),
-        c("vitluc", "altitude")
-      )
-      expect_null(find_predictors(m1, effects = "random"))
-      expect_identical(find_predictors(m2), list(conditional = c("vitluc", "altitude")))
-      expect_identical(
-        find_predictors(m2, flatten = TRUE),
-        c("vitluc", "altitude")
-      )
-      expect_null(find_predictors(m2, effects = "random"))
-    })
-
-    test_that("find_random", {
-      expect_null(find_random(m1))
-      expect_null(find_random(m2))
-    })
-
-    test_that("get_random", {
-      expect_warning(get_random(m1))
-      expect_warning(get_random(m2))
-    })
-
-    test_that("find_response", {
-      expect_identical(find_response(m1), "agaaus")
-      expect_identical(find_response(m2), "cbind(agaaus, kniexc)")
-      expect_identical(find_response(m2, combine = FALSE), c("agaaus", "kniexc"))
-    })
-
-    test_that("get_response", {
-      expect_equal(get_response(m1), hunua$agaaus)
-      expect_equal(
-        get_response(m2),
-        data.frame(agaaus = hunua$agaaus, kniexc = hunua$kniexc)
-      )
-    })
-
-    test_that("get_predictors", {
-      expect_equal(colnames(get_predictors(m1)), c("vitluc", "altitude"))
-      expect_equal(colnames(get_predictors(m2)), c("vitluc", "altitude"))
-    })
-
-    test_that("link_inverse", {
-      expect_equal(link_inverse(m1)(0.2), plogis(0.2), tolerance = 1e-5)
-      expect_equal(link_inverse(m2)(0.2), plogis(0.2), tolerance = 1e-5)
-    })
-
-    test_that("get_data", {
-      expect_equal(nrow(get_data(m1)), 392)
-      expect_equal(nrow(get_data(m2)), 392)
-      expect_equal(colnames(get_data(m1)), c("agaaus", "vitluc", "altitude"))
-      expect_equal(
-        colnames(get_data(m2)),
-        c("agaaus", "kniexc", "vitluc", "altitude")
-      )
-    })
-
-    test_that("find_formula", {
-      expect_length(find_formula(m1), 1)
-      expect_equal(
-        find_formula(m1),
-        list(conditional = as.formula("agaaus ~ vitluc + s(altitude, df = 2)")),
-        ignore_attr = TRUE
-      )
-      expect_length(find_formula(m2), 1)
-      expect_equal(
-        find_formula(m2),
-        list(
-          conditional = as.formula("cbind(agaaus, kniexc) ~ vitluc + s(altitude, df = c(2, 3))")
-        ),
-        ignore_attr = TRUE
-      )
-    })
-
-    test_that("find_terms", {
-      expect_equal(
-        find_terms(m1),
-        list(
-          response = "agaaus",
-          conditional = c("vitluc", "s(altitude, df = 2)")
-        )
-      )
-      expect_equal(
-        find_terms(m1, flatten = TRUE),
-        c("agaaus", "vitluc", "s(altitude, df = 2)")
-      )
-      expect_equal(
-        find_terms(m2),
-        list(
-          response = "cbind(agaaus, kniexc)",
-          conditional = c("vitluc", "s(altitude, df = c(2, 3))")
-        )
-      )
-      expect_equal(
-        find_terms(m2, flatten = TRUE),
-        c(
-          "cbind(agaaus, kniexc)",
-          "vitluc",
-          "s(altitude, df = c(2, 3))"
-        )
-      )
-    })
-
-    test_that("find_variables", {
-      expect_equal(
-        find_variables(m1),
-        list(
-          response = "agaaus",
-          conditional = c("vitluc", "altitude")
-        )
-      )
-      expect_equal(
-        find_variables(m1, flatten = TRUE),
-        c("agaaus", "vitluc", "altitude")
-      )
-      expect_equal(find_variables(m2), list(
-        response = c("agaaus", "kniexc"),
+if (skip_if_not_or_load_if_installed("VGAM")) {
+  data("hunua")
+  m1 <- download_model("vgam_1")
+  m2 <- download_model("vgam_2")
+
+  test_that("model_info", {
+    expect_true(model_info(m1)$is_binomial)
+    expect_true(model_info(m2)$is_binomial)
+    expect_false(model_info(m1)$is_bayesian)
+    expect_false(model_info(m2)$is_bayesian)
+  })
+
+  test_that("find_predictors", {
+    expect_identical(find_predictors(m1), list(conditional = c("vitluc", "altitude")))
+    expect_identical(
+      find_predictors(m1, flatten = TRUE),
+      c("vitluc", "altitude")
+    )
+    expect_null(find_predictors(m1, effects = "random"))
+    expect_identical(find_predictors(m2), list(conditional = c("vitluc", "altitude")))
+    expect_identical(
+      find_predictors(m2, flatten = TRUE),
+      c("vitluc", "altitude")
+    )
+    expect_null(find_predictors(m2, effects = "random"))
+  })
+
+  test_that("find_random", {
+    expect_null(find_random(m1))
+    expect_null(find_random(m2))
+  })
+
+  test_that("get_random", {
+    expect_warning(get_random(m1))
+    expect_warning(get_random(m2))
+  })
+
+  test_that("find_response", {
+    expect_identical(find_response(m1), "agaaus")
+    expect_identical(find_response(m2), "cbind(agaaus, kniexc)")
+    expect_identical(find_response(m2, combine = FALSE), c("agaaus", "kniexc"))
+  })
+
+  test_that("get_response", {
+    expect_equal(get_response(m1), hunua$agaaus)
+    expect_equal(
+      get_response(m2),
+      data.frame(agaaus = hunua$agaaus, kniexc = hunua$kniexc)
+    )
+  })
+
+  test_that("get_predictors", {
+    expect_equal(colnames(get_predictors(m1)), c("vitluc", "altitude"))
+    expect_equal(colnames(get_predictors(m2)), c("vitluc", "altitude"))
+  })
+
+  test_that("link_inverse", {
+    expect_equal(link_inverse(m1)(0.2), plogis(0.2), tolerance = 1e-5)
+    expect_equal(link_inverse(m2)(0.2), plogis(0.2), tolerance = 1e-5)
+  })
+
+  test_that("get_data", {
+    expect_equal(nrow(get_data(m1)), 392)
+    expect_equal(nrow(get_data(m2)), 392)
+    expect_equal(colnames(get_data(m1)), c("agaaus", "vitluc", "altitude"))
+    expect_equal(
+      colnames(get_data(m2)),
+      c("agaaus", "kniexc", "vitluc", "altitude")
+    )
+  })
+
+  test_that("find_formula", {
+    expect_length(find_formula(m1), 1)
+    expect_equal(
+      find_formula(m1),
+      list(conditional = as.formula("agaaus ~ vitluc + s(altitude, df = 2)")),
+      ignore_attr = TRUE
+    )
+    expect_length(find_formula(m2), 1)
+    expect_equal(
+      find_formula(m2),
+      list(
+        conditional = as.formula("cbind(agaaus, kniexc) ~ vitluc + s(altitude, df = c(2, 3))")
+      ),
+      ignore_attr = TRUE
+    )
+  })
+
+  test_that("find_terms", {
+    expect_equal(
+      find_terms(m1),
+      list(
+        response = "agaaus",
+        conditional = c("vitluc", "s(altitude, df = 2)")
+      )
+    )
+    expect_equal(
+      find_terms(m1, flatten = TRUE),
+      c("agaaus", "vitluc", "s(altitude, df = 2)")
+    )
+    expect_equal(
+      find_terms(m2),
+      list(
+        response = "cbind(agaaus, kniexc)",
+        conditional = c("vitluc", "s(altitude, df = c(2, 3))")
+      )
+    )
+    expect_equal(
+      find_terms(m2, flatten = TRUE),
+      c(
+        "cbind(agaaus, kniexc)",
+        "vitluc",
+        "s(altitude, df = c(2, 3))"
+      )
+    )
+  })
+
+  test_that("find_variables", {
+    expect_equal(
+      find_variables(m1),
+      list(
+        response = "agaaus",
         conditional = c("vitluc", "altitude")
-      ))
-      expect_equal(
-        find_variables(m2, flatten = TRUE),
-        c("agaaus", "kniexc", "vitluc", "altitude")
-      )
-    })
-
-    test_that("n_obs", {
-      expect_equal(n_obs(m1), 392)
-      expect_equal(n_obs(m2), 392)
-    })
-
-    test_that("linkfun", {
-      expect_false(is.null(link_function(m1)))
-      expect_false(is.null(link_function(m2)))
-    })
-
-    test_that("find_parameters", {
-      expect_equal(
-        find_parameters(m1),
-        list(
-          conditional = c("(Intercept)", "vitluc"),
-          smooth_terms = "s(altitude, df = 2)"
-        )
-      )
-      expect_equal(nrow(get_parameters(m1)), 3)
-      expect_equal(
-        get_parameters(m1)$Parameter,
-        c("(Intercept)", "vitluc", "s(altitude, df = 2)")
       )
-
-      expect_equal(
-        find_parameters(m2),
-        list(
-          conditional = c(
-            "(Intercept):1",
-            "(Intercept):2",
-            "vitluc:1",
-            "vitluc:2"
-          ),
-          smooth_terms = c("s(altitude, df = c(2, 3)):1", "s(altitude, df = c(2, 3)):2")
-        )
-      )
-      expect_equal(nrow(get_parameters(m2)), 6)
-      expect_equal(
-        get_parameters(m2)$Parameter,
-        c(
+    )
+    expect_equal(
+      find_variables(m1, flatten = TRUE),
+      c("agaaus", "vitluc", "altitude")
+    )
+    expect_equal(find_variables(m2), list(
+      response = c("agaaus", "kniexc"),
+      conditional = c("vitluc", "altitude")
+    ))
+    expect_equal(
+      find_variables(m2, flatten = TRUE),
+      c("agaaus", "kniexc", "vitluc", "altitude")
+    )
+  })
+
+  test_that("n_obs", {
+    expect_equal(n_obs(m1), 392)
+    expect_equal(n_obs(m2), 392)
+  })
+
+  test_that("linkfun", {
+    expect_false(is.null(link_function(m1)))
+    expect_false(is.null(link_function(m2)))
+  })
+
+  test_that("find_parameters", {
+    expect_equal(
+      find_parameters(m1),
+      list(
+        conditional = c("(Intercept)", "vitluc"),
+        smooth_terms = "s(altitude, df = 2)"
+      )
+    )
+    expect_equal(nrow(get_parameters(m1)), 3)
+    expect_equal(
+      get_parameters(m1)$Parameter,
+      c("(Intercept)", "vitluc", "s(altitude, df = 2)")
+    )
+
+    expect_equal(
+      find_parameters(m2),
+      list(
+        conditional = c(
           "(Intercept):1",
           "(Intercept):2",
           "vitluc:1",
-          "vitluc:2",
-          "s(altitude, df = c(2, 3)):1",
-          "s(altitude, df = c(2, 3)):2"
-        )
-      )
-    })
-
-    test_that("is_multivariate", {
-      expect_false(is_multivariate(m1))
-      expect_false(is_multivariate(m2))
-    })
-
-    test_that("find_statistic", {
-      expect_identical(find_statistic(m1), "chi-squared statistic")
-      expect_identical(find_statistic(m2), "chi-squared statistic")
-    })
-  }
+          "vitluc:2"
+        ),
+        smooth_terms = c("s(altitude, df = c(2, 3)):1", "s(altitude, df = c(2, 3)):2")
+      )
+    )
+    expect_equal(nrow(get_parameters(m2)), 6)
+    expect_equal(
+      get_parameters(m2)$Parameter,
+      c(
+        "(Intercept):1",
+        "(Intercept):2",
+        "vitluc:1",
+        "vitluc:2",
+        "s(altitude, df = c(2, 3)):1",
+        "s(altitude, df = c(2, 3)):2"
+      )
+    )
+  })
+
+  test_that("is_multivariate", {
+    expect_false(is_multivariate(m1))
+    expect_false(is_multivariate(m2))
+  })
+
+  test_that("find_statistic", {
+    expect_identical(find_statistic(m1), "chi-squared statistic")
+    expect_identical(find_statistic(m2), "chi-squared statistic")
+  })
 }

From 993a6422e2064adde6ec4900b97a199198e8a92f Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Mon, 3 Apr 2023 11:35:18 +0200
Subject: [PATCH 14/98] rename1

---
 R/{get_df_ml1.r => get_df_ml1-2.R}           | 4 +++-
 R/{get_df_residual.r => get_df_residual-2.R} | 0
 2 files changed, 3 insertions(+), 1 deletion(-)
 rename R/{get_df_ml1.r => get_df_ml1-2.R} (95%)
 rename R/{get_df_residual.r => get_df_residual-2.R} (100%)

diff --git a/R/get_df_ml1.r b/R/get_df_ml1-2.R
similarity index 95%
rename from R/get_df_ml1.r
rename to R/get_df_ml1-2.R
index 0f83bcb62..202a8d2f6 100644
--- a/R/get_df_ml1.r
+++ b/R/get_df_ml1-2.R
@@ -35,7 +35,9 @@
 
   out <- numeric(length = length(parameters))
   ## TODO number of items to replace is not a multiple of replacement length
-  suppressWarnings(out[which("(Intercept)" != parameters)] <- ddf[term_assignment])
+  suppressWarnings({
+    out[which("(Intercept)" != parameters)] <- ddf[term_assignment]
+  })
   if (has_intcp) out[which("(Intercept)" == parameters)] <- min(ddf)
 
   stats::setNames(out, parameters)
diff --git a/R/get_df_residual.r b/R/get_df_residual-2.R
similarity index 100%
rename from R/get_df_residual.r
rename to R/get_df_residual-2.R

From 1a3dea10aa37f1f7fccc58e6236165b25e2b6dda Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Mon, 3 Apr 2023 11:35:35 +0200
Subject: [PATCH 15/98] rename2

---
 R/{get_df_ml1-2.R => get_df_ml1.R}           | 0
 R/{get_df_residual-2.R => get_df_residual.R} | 0
 2 files changed, 0 insertions(+), 0 deletions(-)
 rename R/{get_df_ml1-2.R => get_df_ml1.R} (100%)
 rename R/{get_df_residual-2.R => get_df_residual.R} (100%)

diff --git a/R/get_df_ml1-2.R b/R/get_df_ml1.R
similarity index 100%
rename from R/get_df_ml1-2.R
rename to R/get_df_ml1.R
diff --git a/R/get_df_residual-2.R b/R/get_df_residual.R
similarity index 100%
rename from R/get_df_residual-2.R
rename to R/get_df_residual.R

From 5f6e954444d24affd69fe9bc75dc41104b051cc1 Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Wed, 5 Apr 2023 15:49:19 +0200
Subject: [PATCH 16/98] docs, news

---
 NEWS.md               | 7 +++++++
 R/download_model.R    | 3 ++-
 man/download_model.Rd | 3 ++-
 3 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index a3c23362e..b3b964173 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -4,6 +4,13 @@
 
 * The minimum needed R version has been bumped to `3.6`.
 
+* Tests for package *speedglm* were removed, because *speedglm* was archived on
+  CRAN.
+
+* `download_model()` no longer errors when a model object could not be downloaded,
+  but instead returns `NULL`. This prevents test failures, and allows to skip
+  tests when the return value of `download_model()` is `NULL`.
+
 ## General
 
 * Improved support for `mclogit` models (package *mclogit*).
diff --git a/R/download_model.R b/R/download_model.R
index 45c0565d6..68499c42d 100644
--- a/R/download_model.R
+++ b/R/download_model.R
@@ -11,7 +11,8 @@
 #'   changing. By default, models are downloaded from
 #'   `https://raw.github.com/easystats/circus/master/data/`.
 #'
-#' @return A model from the *circus*-repository.
+#' @return A model from the *circus*-repository, or `NULL` if model could
+#' not be downloaded (e.g., due to server problems).
 #'
 #' @details The code that generated the model is available at the
 #'   <https://easystats.github.io/circus/reference/index.html>.
diff --git a/man/download_model.Rd b/man/download_model.Rd
index 3d5ca7d8c..8198fb6f5 100644
--- a/man/download_model.Rd
+++ b/man/download_model.Rd
@@ -15,7 +15,8 @@ changing. By default, models are downloaded from
 \verb{https://raw.github.com/easystats/circus/master/data/}.}
 }
 \value{
-A model from the \emph{circus}-repository.
+A model from the \emph{circus}-repository, or \code{NULL} if model could
+not be downloaded (e.g., due to server problems).
 }
 \description{
 Downloads pre-compiled models from the \emph{circus}-repository.

From d9b46d8923535fb0c3263d3257cda1cdd7c07345 Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Wed, 5 Apr 2023 15:49:43 +0200
Subject: [PATCH 17/98] move speedglm to WIP

---
 DESCRIPTION                             | 3 +--
 {tests/testthat => WIP}/test-speedglm.R | 0
 {tests/testthat => WIP}/test-speedlm.R  | 0
 3 files changed, 1 insertion(+), 2 deletions(-)
 rename {tests/testthat => WIP}/test-speedglm.R (100%)
 rename {tests/testthat => WIP}/test-speedlm.R (100%)

diff --git a/DESCRIPTION b/DESCRIPTION
index 5bdb866c8..3eed2bd94 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -1,7 +1,7 @@
 Type: Package
 Package: insight
 Title: Easy Access to Model Information for Various Model Objects
-Version: 0.19.1.3
+Version: 0.19.1.4
 Authors@R: 
     c(person(given = "Daniel",
              family = "Lüdecke",
@@ -163,7 +163,6 @@ Suggests:
     rstantools,
     rstudioapi,
     sandwich,
-    speedglm,
     splines,
     statmod,
     survey,
diff --git a/tests/testthat/test-speedglm.R b/WIP/test-speedglm.R
similarity index 100%
rename from tests/testthat/test-speedglm.R
rename to WIP/test-speedglm.R
diff --git a/tests/testthat/test-speedlm.R b/WIP/test-speedlm.R
similarity index 100%
rename from tests/testthat/test-speedlm.R
rename to WIP/test-speedlm.R

From aa856017ce9f344d978774203bc9091cb9b1dbd4 Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Tue, 11 Apr 2023 14:01:37 +0200
Subject: [PATCH 18/98] lintr

---
 R/get_modelmatrix.R | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/R/get_modelmatrix.R b/R/get_modelmatrix.R
index 2639e61d9..ba7c44334 100644
--- a/R/get_modelmatrix.R
+++ b/R/get_modelmatrix.R
@@ -251,7 +251,7 @@ get_modelmatrix.BFBayesFactor <- function(x, ...) {
     return(out)
   }
 
-  maxlev <- max(sapply(fac, length))
+  maxlev <- max(lengths(fac))
   pad <- data[rep(1, maxlev), , drop = FALSE]
   for (n in names(fac)) {
     pad[[n]][seq_along(fac[[n]])] <- fac[[n]]

From 715fefc96452438a6dee3eadb43413f8bcc83d50 Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Tue, 11 Apr 2023 14:02:28 +0200
Subject: [PATCH 19/98] minor

---
 R/get_modelmatrix.R | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/R/get_modelmatrix.R b/R/get_modelmatrix.R
index ba7c44334..9d1150c02 100644
--- a/R/get_modelmatrix.R
+++ b/R/get_modelmatrix.R
@@ -251,7 +251,7 @@ get_modelmatrix.BFBayesFactor <- function(x, ...) {
     return(out)
   }
 
-  maxlev <- max(lengths(fac))
+  maxlev <- max(lengths(fac, use.names = FALSE))
   pad <- data[rep(1, maxlev), , drop = FALSE]
   for (n in names(fac)) {
     pad[[n]][seq_along(fac[[n]])] <- fac[[n]]

From 71a74f33683e704a9f66230570bdfb3424c39f84 Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Tue, 11 Apr 2023 17:13:59 +0200
Subject: [PATCH 20/98] support mipo for ordinal

---
 R/find_parameters.R | 2 +-
 R/find_terms.R      | 9 +++++++--
 R/get_parameters.R  | 9 +++++++--
 R/get_statistic.R   | 9 +++++++--
 4 files changed, 22 insertions(+), 7 deletions(-)

diff --git a/R/find_parameters.R b/R/find_parameters.R
index 8777794a9..8e4c07f0b 100644
--- a/R/find_parameters.R
+++ b/R/find_parameters.R
@@ -778,7 +778,7 @@ find_parameters.metaplus <- function(x, flatten = FALSE, ...) {
 
 #' @export
 find_parameters.mipo <- function(x, flatten = FALSE, ...) {
-  pars <- list(conditional = as.vector(summary(x)$term))
+  pars <- list(conditional = unique(as.vector(summary(x)$term)))
   pars$conditional <- text_remove_backticks(pars$conditional)
 
   if (flatten) {
diff --git a/R/find_terms.R b/R/find_terms.R
index 0df1d4018..b1e880a49 100644
--- a/R/find_terms.R
+++ b/R/find_terms.R
@@ -140,8 +140,13 @@ find_terms.bfsl <- function(x, flatten = FALSE, verbose = TRUE, ...) {
 
 
 #' @export
-find_terms.mipo <- function(x, ...) {
-  NULL
+find_terms.mipo <- function(x, flatten = FALSE, ...) {
+  l <- list(conditional = unique(as.vector(summary(x)$term)))
+  if (flatten) {
+    unique(unlist(l, use.names = FALSE))
+  } else {
+    l
+  }
 }
 
 
diff --git a/R/get_parameters.R b/R/get_parameters.R
index 2cfb843f3..46be4a6d0 100644
--- a/R/get_parameters.R
+++ b/R/get_parameters.R
@@ -293,11 +293,16 @@ get_parameters.riskRegression <- function(x, ...) {
 
 #' @export
 get_parameters.mipo <- function(x, ...) {
+  s <- summary(x)
   out <- data.frame(
-    Parameter = as.vector(summary(x)$term),
-    Estimate = as.vector(summary(x)$estimate),
+    Parameter = as.vector(s$term),
+    Estimate = as.vector(s$estimate),
     stringsAsFactors = FALSE
   )
+  # check for ordinal-alike models
+  if ("y.level" %in% colnames(s)) {
+    out$Response <- as.vector(s$y.level)
+  }
   text_remove_backticks(out)
 }
 
diff --git a/R/get_statistic.R b/R/get_statistic.R
index 9001e5525..6fc0ab128 100644
--- a/R/get_statistic.R
+++ b/R/get_statistic.R
@@ -1427,11 +1427,16 @@ get_statistic.lqm <- get_statistic.lqmm
 
 #' @export
 get_statistic.mipo <- function(x, ...) {
+  s <- summary(x)
   params <- data.frame(
-    Parameter = as.vector(summary(x)$term),
-    Statistic = as.vector(summary(x)$statistic),
+    Parameter = as.vector(s$term),
+    Statistic = as.vector(s$statistic),
     stringsAsFactors = FALSE
   )
+  # check for ordinal-alike models
+  if ("y.level" %in% colnames(s)) {
+    params$Response <- as.vector(s$y.level)
+  }
   out <- text_remove_backticks(params)
   attr(out, "statistic") <- find_statistic(x)
   out

From 2f98a0da04ac8d72874afd813b3e8abbaef5eb0f Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Tue, 11 Apr 2023 19:04:06 +0200
Subject: [PATCH 21/98] support mipo for ordinal (#752)

* support mipo for ordinal

* dev, news

* tests

* silence

* more silence
---
 DESCRIPTION                   |  2 +-
 NEWS.md                       |  3 ++-
 R/find_parameters.R           |  2 +-
 R/find_terms.R                |  9 +++++++--
 R/get_parameters.R            |  9 +++++++--
 R/get_statistic.R             |  9 +++++++--
 tests/testthat/_snaps/mipo.md | 26 ++++++++++++++++++++++++++
 tests/testthat/test-mipo.R    | 19 +++++++++++++++++++
 8 files changed, 70 insertions(+), 9 deletions(-)
 create mode 100644 tests/testthat/_snaps/mipo.md
 create mode 100644 tests/testthat/test-mipo.R

diff --git a/DESCRIPTION b/DESCRIPTION
index 3eed2bd94..cd5ad3db7 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -1,7 +1,7 @@
 Type: Package
 Package: insight
 Title: Easy Access to Model Information for Various Model Objects
-Version: 0.19.1.4
+Version: 0.19.1.5
 Authors@R: 
     c(person(given = "Daniel",
              family = "Lüdecke",
diff --git a/NEWS.md b/NEWS.md
index b3b964173..47a3b86b6 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -13,7 +13,8 @@
 
 ## General
 
-* Improved support for `mclogit` models (package *mclogit*).
+* Improved support for `mclogit` models (package *mclogit*) and `mipo` objects
+  (package *mice*) for models with ordinal or categorical response.
 
 ## New supported models
 
diff --git a/R/find_parameters.R b/R/find_parameters.R
index 8777794a9..8e4c07f0b 100644
--- a/R/find_parameters.R
+++ b/R/find_parameters.R
@@ -778,7 +778,7 @@ find_parameters.metaplus <- function(x, flatten = FALSE, ...) {
 
 #' @export
 find_parameters.mipo <- function(x, flatten = FALSE, ...) {
-  pars <- list(conditional = as.vector(summary(x)$term))
+  pars <- list(conditional = unique(as.vector(summary(x)$term)))
   pars$conditional <- text_remove_backticks(pars$conditional)
 
   if (flatten) {
diff --git a/R/find_terms.R b/R/find_terms.R
index 0df1d4018..b1e880a49 100644
--- a/R/find_terms.R
+++ b/R/find_terms.R
@@ -140,8 +140,13 @@ find_terms.bfsl <- function(x, flatten = FALSE, verbose = TRUE, ...) {
 
 
 #' @export
-find_terms.mipo <- function(x, ...) {
-  NULL
+find_terms.mipo <- function(x, flatten = FALSE, ...) {
+  l <- list(conditional = unique(as.vector(summary(x)$term)))
+  if (flatten) {
+    unique(unlist(l, use.names = FALSE))
+  } else {
+    l
+  }
 }
 
 
diff --git a/R/get_parameters.R b/R/get_parameters.R
index 2cfb843f3..46be4a6d0 100644
--- a/R/get_parameters.R
+++ b/R/get_parameters.R
@@ -293,11 +293,16 @@ get_parameters.riskRegression <- function(x, ...) {
 
 #' @export
 get_parameters.mipo <- function(x, ...) {
+  s <- summary(x)
   out <- data.frame(
-    Parameter = as.vector(summary(x)$term),
-    Estimate = as.vector(summary(x)$estimate),
+    Parameter = as.vector(s$term),
+    Estimate = as.vector(s$estimate),
     stringsAsFactors = FALSE
   )
+  # check for ordinal-alike models
+  if ("y.level" %in% colnames(s)) {
+    out$Response <- as.vector(s$y.level)
+  }
   text_remove_backticks(out)
 }
 
diff --git a/R/get_statistic.R b/R/get_statistic.R
index 9001e5525..6fc0ab128 100644
--- a/R/get_statistic.R
+++ b/R/get_statistic.R
@@ -1427,11 +1427,16 @@ get_statistic.lqm <- get_statistic.lqmm
 
 #' @export
 get_statistic.mipo <- function(x, ...) {
+  s <- summary(x)
   params <- data.frame(
-    Parameter = as.vector(summary(x)$term),
-    Statistic = as.vector(summary(x)$statistic),
+    Parameter = as.vector(s$term),
+    Statistic = as.vector(s$statistic),
     stringsAsFactors = FALSE
   )
+  # check for ordinal-alike models
+  if ("y.level" %in% colnames(s)) {
+    params$Response <- as.vector(s$y.level)
+  }
   out <- text_remove_backticks(params)
   attr(out, "statistic") <- find_statistic(x)
   out
diff --git a/tests/testthat/_snaps/mipo.md b/tests/testthat/_snaps/mipo.md
new file mode 100644
index 000000000..087d47452
--- /dev/null
+++ b/tests/testthat/_snaps/mipo.md
@@ -0,0 +1,26 @@
+# param
+
+    Code
+      get_parameters(pooled)
+    Output
+          Parameter    Estimate Response
+      1 (Intercept) -54.2937437        6
+      2        disp   0.2230706        6
+      3          hp   0.2029648        6
+      4 (Intercept) -92.8614823        8
+      5        disp   0.2577745        8
+      6          hp   0.4258580        8
+
+---
+
+    Code
+      get_statistic(pooled)
+    Output
+          Parameter  Statistic Response
+      1 (Intercept) -1.1576689        6
+      2        disp  0.5763162        6
+      3          hp  0.3571385        6
+      4 (Intercept) -1.3732007        8
+      5        disp  0.6402012        8
+      6          hp  0.6741937        8
+
diff --git a/tests/testthat/test-mipo.R b/tests/testthat/test-mipo.R
new file mode 100644
index 000000000..e151343c1
--- /dev/null
+++ b/tests/testthat/test-mipo.R
@@ -0,0 +1,19 @@
+skip_on_cran()
+skip_if_not_installed("mice")
+skip_if_not_installed("nnet")
+
+test_that("param", {
+  set.seed(1234)
+  d <- suppressWarnings(mice::ampute(mtcars)) ## Ampute mtcars and impute two data sets
+  imp <- suppressWarnings(mice::mice(d$amp, m = 2, printFlag = FALSE))
+  imp.l <- mice::complete(imp, action = "long")
+  model <- list() ## Fit and pool models
+  for (i in 1:2) capture.output({
+    model[[i]] <- nnet::multinom(cyl ~ disp + hp, data = imp.l, subset = .imp == i)
+  })
+  pooled <- mice::pool(model)
+
+  expect_snapshot(get_parameters(pooled))
+  expect_snapshot(get_statistic(pooled))
+  expect_identical(find_parameters(pooled), list(conditional = c("(Intercept)", "disp", "hp")))
+})

From 621f77f1e27d7e267d9ae4649ec9536b3fbac519 Mon Sep 17 00:00:00 2001
From: Etienne Bacher <52219252+etiennebacher@users.noreply.github.com>
Date: Wed, 12 Apr 2023 06:54:52 +0000
Subject: [PATCH 22/98] Test cleanup (#751)

* `skip_if_not_or_load_if_installed` -> `skip_if_not_installed`

* specify package in most of `data()` calls

* clean tests until "test-brms.R" (included)

* clean tests until "test-get_loglikelihood.R" (included)

* just to not trigger CI [skip ci]

* clean tests until "test-get_predicted.R" (included)

* clean tests until "test-has_intercept.R" (included) [skip ci]

* clean tests until "test-LORgee.R" [skip ci]

* clean tests until "test-model_info.R" [skip ci]

* clean tests until "test-response_data2.R" (included) [skip ci]

* clean tests until the end [skip ci]

* add `skip_if_offline()` where necessary [skip ci]

* fix a few errors and messages, trigger CI

* DESCRIPTION: add packages used in tests

* fix errors due to packages loading / unloading

* skip some tests if `logistf` is loaded because of namespace issues

* `quantreg` now needs `interp` to work

* last (?) errors

* spelling, styling

* small fix, add myself as ctb

* fix error on ubuntu

* check random test order

* Random order: skip some tests with `formula.tools` previously imported

* skip unnecessary conditionals

* make Etienne author

* also cover WIP tests

---------

Co-authored-by: Indrajeet Patil <patilindrajeet.science@gmail.com>
Co-authored-by: Daniel <mail@danielluedecke.de>
---
 .../workflows/check-random-test-order.yaml    |   12 +
 DESCRIPTION                                   |   12 +-
 WIP/test-mixed.R                              |    4 +-
 WIP/test-speedglm.R                           |  239 +-
 WIP/test-speedlm.R                            |  317 ++-
 inst/WORDLIST                                 |    1 +
 tests/testthat.R                              |    7 +-
 tests/testthat/_snaps/export_table.md         |   22 +
 tests/testthat/_snaps/format_table_ci.md      |   11 +
 tests/testthat/helper.R                       |    6 -
 tests/testthat/test-BayesFactorBF.R           |   42 +-
 tests/testthat/test-FE-formula.R              |    2 +-
 tests/testthat/test-GLMMadaptive.R            |  634 +++---
 tests/testthat/test-Gam2.R                    |  209 +-
 tests/testthat/test-LORgee.R                  |  266 +--
 tests/testthat/test-MCMCglmm.R                |   12 +-
 tests/testthat/test-afex_aov.R                |  322 +--
 tests/testthat/test-all_models_equal.R        |   35 +-
 tests/testthat/test-backticks.R               |    1 -
 tests/testthat/test-betabin.R                 |  250 +--
 tests/testthat/test-betareg.R                 |  327 ++-
 tests/testthat/test-bife.R                    |    3 +-
 tests/testthat/test-bigglm.R                  |  235 +-
 tests/testthat/test-blmer.R                   |  573 ++---
 tests/testthat/test-brms.R                    | 1655 +++++++-------
 tests/testthat/test-censReg.R                 |    6 +-
 tests/testthat/test-cgam.R                    |  112 +-
 tests/testthat/test-check_if_installed.R      |    3 +-
 tests/testthat/test-clm.R                     |  327 ++-
 tests/testthat/test-clm2.R                    |  242 +-
 tests/testthat/test-clmm.R                    |  363 +--
 tests/testthat/test-coxme.R                   |  399 ++--
 tests/testthat/test-coxph.R                   |   22 +-
 tests/testthat/test-cpglmm.R                  |  325 +--
 tests/testthat/test-crch.R                    |  224 +-
 tests/testthat/test-crq.R                     |  228 +-
 tests/testthat/test-data.frame.R              |    2 -
 tests/testthat/test-ellipses_info.R           |   72 +-
 tests/testthat/test-emmeans.R                 |   29 +-
 tests/testthat/test-epiR.R                    |    4 +-
 tests/testthat/test-export_table.R            |   15 +-
 tests/testthat/test-feis.R                    |  317 +--
 tests/testthat/test-felm.R                    |  332 +--
 tests/testthat/test-find_formula-data.R       |    7 +-
 .../testthat/test-find_predictor_nested_re.R  |   46 +-
 tests/testthat/test-find_predictors-strata.R  |   95 +-
 tests/testthat/test-find_random.R             |   63 +-
 tests/testthat/test-find_smooth.R             |   84 +-
 tests/testthat/test-find_terms.R              |   88 +-
 tests/testthat/test-find_transformation.R     |    1 -
 tests/testthat/test-find_weights.R            |   91 +-
 tests/testthat/test-fixest.R                  |   42 +-
 tests/testthat/test-format_table.R            |  109 +-
 tests/testthat/test-format_table_ci.R         |   25 +-
 tests/testthat/test-gam.R                     |  698 +++---
 tests/testthat/test-gamlss.R                  |  237 +-
 tests/testthat/test-gamm.R                    |  374 ++-
 tests/testthat/test-gamm4.R                   |  241 +-
 tests/testthat/test-gbm.R                     |  250 +--
 tests/testthat/test-gee.R                     |  224 +-
 tests/testthat/test-geeglm.R                  |  246 +-
 tests/testthat/test-get_auxiliary.R           |   46 +-
 tests/testthat/test-get_data.R                |  164 +-
 tests/testthat/test-get_datagrid.R            |  456 ++--
 tests/testthat/test-get_deviance.R            |    4 +-
 tests/testthat/test-get_loglikelihood.R       |  338 ++-
 tests/testthat/test-get_modelmatrix.R         |   12 +-
 tests/testthat/test-get_predicted-clm.R       |    6 +-
 tests/testthat/test-get_predicted-iv.R        |    8 +-
 tests/testthat/test-get_predicted.R           |  138 +-
 tests/testthat/test-get_priors.R              |   20 +-
 tests/testthat/test-get_residuals.R           |  247 +-
 tests/testthat/test-get_varcov.R              |   22 +-
 tests/testthat/test-get_variance.R            |  551 ++---
 tests/testthat/test-get_weights.R             |   70 +-
 tests/testthat/test-glm.R                     |  328 ++-
 tests/testthat/test-glm.nb.R                  |   43 +-
 tests/testthat/test-glmmTMB.R                 | 1790 ++++++++-------
 tests/testthat/test-glmrob_base.R             |  236 +-
 tests/testthat/test-gls.R                     |  266 +--
 tests/testthat/test-gmnl.R                    |  138 +-
 tests/testthat/test-has_intercept.R           |   48 +-
 tests/testthat/test-htest.R                   |    1 -
 tests/testthat/test-hurdle.R                  |  278 +--
 tests/testthat/test-is_converged.R            |   69 +-
 tests/testthat/test-is_nullmodel.R            |   31 +-
 tests/testthat/test-iv_robust.R               |  280 ++-
 tests/testthat/test-ivreg.R                   |  241 +-
 tests/testthat/test-ivreg_AER.R               |    9 +-
 tests/testthat/test-lm.R                      |    4 -
 tests/testthat/test-lm_robust.R               |  193 +-
 tests/testthat/test-lme.R                     |  471 ++--
 tests/testthat/test-lmer.R                    | 1036 +++++----
 tests/testthat/test-lmrob_base.R              |  185 +-
 tests/testthat/test-lmtest.R                  |   27 +-
 tests/testthat/test-logistf.R                 |  231 +-
 tests/testthat/test-logitr.R                  |    3 +-
 tests/testthat/test-marginaleffects.R         |    8 +-
 tests/testthat/test-mclogit.R                 |   27 +-
 tests/testthat/test-metaBMA.R                 |   54 +-
 tests/testthat/test-metafor.R                 |  101 +-
 tests/testthat/test-metaplus.R                |    6 +-
 tests/testthat/test-mhurdle.R                 |    7 +-
 tests/testthat/test-mipo.R                    |    8 +-
 tests/testthat/test-mlogit.R                  |  220 +-
 tests/testthat/test-mmrm.R                    |   14 +-
 tests/testthat/test-model_data.R              |   77 +-
 tests/testthat/test-model_info.R              |   52 +-
 tests/testthat/test-multinom.R                |  215 +-
 tests/testthat/test-mvrstanarm.R              | 1999 ++++++++---------
 tests/testthat/test-n_grouplevels.R           |   42 +-
 .../test-n_parameters_rank-deficiency.R       |    2 -
 tests/testthat/test-namespace.R               |  215 +-
 tests/testthat/test-negbin.R                  |  326 +--
 tests/testthat/test-nlmer.R                   |   34 +-
 tests/testthat/test-null_model.R              |   80 +-
 tests/testthat/test-offset.R                  |   70 +-
 tests/testthat/test-ols.R                     |  195 +-
 tests/testthat/test-panelr.R                  |  462 ++--
 tests/testthat/test-plm.R                     |  271 ++-
 tests/testthat/test-polr.R                    |  304 +--
 tests/testthat/test-proportion_response.R     |   46 +-
 tests/testthat/test-psm.R                     |  268 +--
 tests/testthat/test-r3_4.R                    |    9 +-
 tests/testthat/test-response_data2.R          |  206 +-
 tests/testthat/test-rlm.R                     |   46 +-
 tests/testthat/test-rlmer.R                   |  525 ++---
 tests/testthat/test-rms.R                     |  235 +-
 tests/testthat/test-rq.R                      |  225 +-
 tests/testthat/test-rqss.R                    |  201 +-
 tests/testthat/test-rstanarm.R                | 1045 ++++-----
 tests/testthat/test-spatial.R                 |  291 ++-
 tests/testthat/test-standardize_names.R       |    6 +-
 tests/testthat/test-survey.R                  |  150 +-
 tests/testthat/test-survfit.R                 |  130 +-
 tests/testthat/test-survreg.R                 |   10 +-
 tests/testthat/test-tidymodels.R              |  278 ++-
 tests/testthat/test-tobit.R                   |    2 +-
 tests/testthat/test-truncreg.R                |  119 +-
 tests/testthat/test-vgam.R                    |  390 ++--
 tests/testthat/test-vglm.R                    |  222 +-
 tests/testthat/test-zeroinfl.R                |   11 +-
 142 files changed, 14165 insertions(+), 14169 deletions(-)
 create mode 100644 .github/workflows/check-random-test-order.yaml
 create mode 100644 tests/testthat/_snaps/export_table.md
 create mode 100644 tests/testthat/_snaps/format_table_ci.md
 delete mode 100644 tests/testthat/helper.R

diff --git a/.github/workflows/check-random-test-order.yaml b/.github/workflows/check-random-test-order.yaml
new file mode 100644
index 000000000..1445a55b6
--- /dev/null
+++ b/.github/workflows/check-random-test-order.yaml
@@ -0,0 +1,12 @@
+# Run tests in random order
+on:
+  push:
+    branches: [main, master]
+  pull_request:
+    branches: [main, master]
+
+name: check-random-test-order
+
+jobs:
+  check-random-test-order:
+    uses: easystats/workflows/.github/workflows/check-random-test-order.yaml@main
diff --git a/DESCRIPTION b/DESCRIPTION
index cd5ad3db7..f1fbd2676 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -30,7 +30,7 @@ Authors@R:
              comment = c(ORCID = "0000-0002-4287-4801")),
       person(given = "Brenton M.",
              family = "Wiernik",
-             role = c("aut"),
+             role = c("aut", "ctb"),
              email = "brenton@wiernik.org",
              comment = c(ORCID = "0000-0001-9560-6336", Twitter = "@bmwiernik")),
       person(given = "Vincent", 
@@ -38,6 +38,11 @@ Authors@R:
              email = "vincent.arel-bundock@umontreal.ca", 
              role = c("aut", "ctb"),
              comment = c(ORCID = "0000-0003-2042-7063")),
+      person(given = "Etienne", 
+             family = "Bacher",
+             email = "etienne.bacher@protonmail.com", 
+             role = c("aut", "ctb"),
+             comment = c(ORCID = "0000-0002-9271-5075")),
       person(given = "Alex",
              family = "Hayes",
              role = c("rev"),
@@ -104,6 +109,7 @@ Suggests:
     fungible,
     gam,
     gamlss,
+    gamlss.data,
     gamm4,
     gbm,
     gee,
@@ -114,6 +120,7 @@ Suggests:
     gmnl,
     gt,
     httr,
+    interp,
     ivreg,
     JM,
     knitr,
@@ -133,6 +140,7 @@ Suggests:
     MCMCglmm,
     merTools,
     metaBMA,
+    metadat,
     metafor,
     metaplus,
     mgcv,
@@ -157,6 +165,7 @@ Suggests:
     quantreg,
     rmarkdown,
     rms,
+    rpart,
     robustbase,
     robustlmm,
     rstanarm (>= 2.21.1),
@@ -179,6 +188,7 @@ Language: en-US
 RoxygenNote: 7.2.3.9000
 Roxygen: list(markdown = TRUE)
 Config/testthat/edition: 3
+Config/testthat/parallel: true
 Config/Needs/website:
     rstudio/bslib,
     r-lib/pkgdown,
diff --git a/WIP/test-mixed.R b/WIP/test-mixed.R
index 4595e22f3..2bd7dabb4 100644
--- a/WIP/test-mixed.R
+++ b/WIP/test-mixed.R
@@ -1,7 +1,7 @@
 # TODO: why the model fails to run
 # see https://github.com/easystats/insight/pull/735
-skip_if_not_or_load_if_installed("lme4")
-skip_if_not_or_load_if_installed("afex")
+skip_if_not_installed("lme4")
+skip_if_not_installed("afex")
 
 data(sleepstudy, package = "lme4")
 df_sleepstudy <- sleepstudy
diff --git a/WIP/test-speedglm.R b/WIP/test-speedglm.R
index b736b3904..08dd805a5 100644
--- a/WIP/test-speedglm.R
+++ b/WIP/test-speedglm.R
@@ -1,125 +1,126 @@
-if (skip_if_not_or_load_if_installed("speedglm") && skip_if_not_or_load_if_installed("glmmTMB")) {
-  data(Salamanders)
-  Salamanders$cover <- abs(Salamanders$cover)
-
-  m1 <- speedglm(count ~ mined + log(cover) + sample,
-    family = poisson(),
-    data = Salamanders
+skip_if_not_installed("speedglm")
+skip_if_not_installed("glmmTMB")
+data(Salamanders, package = "glmmTMB")
+Salamanders$cover <- abs(Salamanders$cover)
+
+m1 <- speedglm(
+  count ~ mined + log(cover) + sample,
+  family = poisson(),
+  data = Salamanders
+)
+
+test_that("model_info", {
+  expect_true(model_info(m1)$is_poisson)
+  expect_true(model_info(m1)$is_count)
+  expect_false(model_info(m1)$is_negbin)
+  expect_false(model_info(m1)$is_binomial)
+  expect_false(model_info(m1)$is_linear)
+})
+
+test_that("find_predictors", {
+  expect_identical(find_predictors(m1), list(conditional = c("mined", "cover", "sample")))
+  expect_identical(
+    find_predictors(m1, flatten = TRUE),
+    c("mined", "cover", "sample")
   )
-
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_poisson)
-    expect_true(model_info(m1)$is_count)
-    expect_false(model_info(m1)$is_negbin)
-    expect_false(model_info(m1)$is_binomial)
-    expect_false(model_info(m1)$is_linear)
-  })
-
-  test_that("find_predictors", {
-    expect_identical(find_predictors(m1), list(conditional = c("mined", "cover", "sample")))
-    expect_identical(
-      find_predictors(m1, flatten = TRUE),
-      c("mined", "cover", "sample")
-    )
-    expect_null(find_predictors(m1, effects = "random"))
-  })
-
-  test_that("find_random", {
-    expect_null(find_random(m1))
-  })
-
-  test_that("get_random", {
-    expect_warning(get_random(m1))
-  })
-
-  test_that("find_response", {
-    expect_identical(find_response(m1), "count")
-  })
-
-  test_that("get_response", {
-    expect_identical(get_response(m1), Salamanders$count)
-  })
-
-  test_that("get_predictors", {
-    expect_identical(colnames(get_predictors(m1)), c("mined", "cover", "sample"))
-  })
-
-  test_that("link_inverse", {
-    expect_equal(link_inverse(m1)(0.2), exp(0.2), tolerance = 1e-5)
-  })
-
-  test_that("linkfun", {
-    expect_equal(link_function(m1)(0.2), log(0.2), tolerance = 1e-5)
-  })
-
-  test_that("get_data", {
-    expect_identical(nrow(get_data(m1)), 644L)
-    expect_identical(
-      colnames(get_data(m1)),
-      c("count", "mined", "cover", "sample")
-    )
-  })
-
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 1)
-    expect_equal(
-      find_formula(m1),
-      list(conditional = as.formula("count ~ mined + log(cover) + sample")),
-      ignore_attr = TRUE
-    )
-  })
-
-  test_that("find_variables", {
-    expect_identical(
-      find_variables(m1),
-      list(
-        response = "count",
-        conditional = c("mined", "cover", "sample")
-      )
-    )
-    expect_identical(
-      find_variables(m1, flatten = TRUE),
-      c("count", "mined", "cover", "sample")
-    )
-  })
-
-  test_that("n_obs", {
-    expect_identical(n_obs(m1), 644L)
-  })
-
-  test_that("find_parameters", {
-    expect_identical(
-      find_parameters(m1),
-      list(
-        conditional = c("(Intercept)", "minedno", "log(cover)", "sample")
-      )
+  expect_null(find_predictors(m1, effects = "random"))
+})
+
+test_that("find_random", {
+  expect_null(find_random(m1))
+})
+
+test_that("get_random", {
+  expect_warning(get_random(m1))
+})
+
+test_that("find_response", {
+  expect_identical(find_response(m1), "count")
+})
+
+test_that("get_response", {
+  expect_identical(get_response(m1), Salamanders$count)
+})
+
+test_that("get_predictors", {
+  expect_identical(colnames(get_predictors(m1)), c("mined", "cover", "sample"))
+})
+
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), exp(0.2), tolerance = 1e-5)
+})
+
+test_that("linkfun", {
+  expect_equal(link_function(m1)(0.2), log(0.2), tolerance = 1e-5)
+})
+
+test_that("get_data", {
+  expect_identical(nrow(get_data(m1)), 644L)
+  expect_identical(
+    colnames(get_data(m1)),
+    c("count", "mined", "cover", "sample")
+  )
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1), 1)
+  expect_equal(
+    find_formula(m1),
+    list(conditional = as.formula("count ~ mined + log(cover) + sample")),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_variables", {
+  expect_identical(
+    find_variables(m1),
+    list(
+      response = "count",
+      conditional = c("mined", "cover", "sample")
     )
-    expect_identical(nrow(get_parameters(m1)), 4L)
-    expect_identical(
-      get_parameters(m1)$Parameter,
-      c("(Intercept)", "minedno", "log(cover)", "sample")
+  )
+  expect_identical(
+    find_variables(m1, flatten = TRUE),
+    c("count", "mined", "cover", "sample")
+  )
+})
+
+test_that("n_obs", {
+  expect_identical(n_obs(m1), 644L)
+})
+
+test_that("find_parameters", {
+  expect_identical(
+    find_parameters(m1),
+    list(
+      conditional = c("(Intercept)", "minedno", "log(cover)", "sample")
     )
-  })
-
-  test_that("is_multivariate", {
-    expect_false(is_multivariate(m1))
-  })
-
-  test_that("find_terms", {
-    expect_identical(
-      find_terms(m1),
-      list(
-        response = "count",
-        conditional = c("mined", "log(cover)", "sample")
-      )
+  )
+  expect_identical(nrow(get_parameters(m1)), 4L)
+  expect_identical(
+    get_parameters(m1)$Parameter,
+    c("(Intercept)", "minedno", "log(cover)", "sample")
+  )
+})
+
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1))
+})
+
+test_that("find_terms", {
+  expect_identical(
+    find_terms(m1),
+    list(
+      response = "count",
+      conditional = c("mined", "log(cover)", "sample")
     )
-  })
+  )
+})
 
-  test_that("find_algorithm", {
-    expect_identical(find_algorithm(m1), list(algorithm = "eigen"))
-  })
+test_that("find_algorithm", {
+  expect_identical(find_algorithm(m1), list(algorithm = "eigen"))
+})
 
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "z-statistic")
-  })
-}
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "z-statistic")
+})
diff --git a/WIP/test-speedlm.R b/WIP/test-speedlm.R
index e404144b9..3b91dfb50 100644
--- a/WIP/test-speedlm.R
+++ b/WIP/test-speedlm.R
@@ -1,173 +1,172 @@
-if (skip_if_not_or_load_if_installed("speedglm")) {
-  data(iris)
-  data(mtcars)
-
-  m1 <- speedlm(Sepal.Length ~ Petal.Width + Species, data = iris)
-  m2 <-
-    speedlm(log(mpg) ~ log(hp) + cyl + I(cyl^2) + poly(wt, degree = 2, raw = TRUE),
-      data = mtcars
-    )
-
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_linear)
-  })
-
-  test_that("find_predictors", {
-    expect_identical(find_predictors(m1), list(conditional = c("Petal.Width", "Species")))
-    expect_identical(
-      find_predictors(m1, flatten = TRUE),
-      c("Petal.Width", "Species")
-    )
-    expect_null(find_predictors(m1, effects = "random"))
-  })
-
-  test_that("find_random", {
-    expect_null(find_random(m1))
-  })
-
-  test_that("get_random", {
-    expect_warning(get_random(m1))
-  })
-
-  test_that("find_response", {
-    expect_identical(find_response(m1), "Sepal.Length")
-  })
-
-  test_that("get_response", {
-    expect_equal(get_response(m1), iris$Sepal.Length)
-  })
-
-  test_that("get_predictors", {
-    expect_equal(colnames(get_predictors(m1)), c("Petal.Width", "Species"))
-  })
-
-  test_that("link_inverse", {
-    expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
-  })
-
-  test_that("linkfun", {
-    expect_equal(link_function(m1)(0.2), 0.2, tolerance = 1e-5)
-  })
-
-  test_that("get_data", {
-    expect_equal(nrow(get_data(m1)), 150)
-    expect_equal(
-      colnames(get_data(m1)),
-      c("Sepal.Length", "Petal.Width", "Species")
-    )
-    expect_equal(colnames(get_data(m2)), c("mpg", "hp", "cyl", "wt"))
-  })
-
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 1)
-    expect_equal(
-      find_formula(m1),
-      list(conditional = as.formula("Sepal.Length ~ Petal.Width + Species")),
-      ignore_attr = TRUE
-    )
-    expect_equal(
-      find_formula(m2),
-      list(
-        conditional = as.formula(
-          "log(mpg) ~ log(hp) + cyl + I(cyl^2) + poly(wt, degree = 2, raw = TRUE)"
-        )
-      ),
-      ignore_attr = TRUE
-    )
-  })
-
-  test_that("find_variables", {
-    expect_equal(
-      find_variables(m1),
-      list(
-        response = "Sepal.Length",
-        conditional = c("Petal.Width", "Species")
-      )
-    )
-    expect_equal(
-      find_variables(m1, flatten = TRUE),
-      c("Sepal.Length", "Petal.Width", "Species")
-    )
-    expect_equal(
-      find_variables(m2, flatten = TRUE),
-      c("mpg", "hp", "cyl", "wt")
-    )
-  })
-
-  test_that("n_obs", {
-    expect_equal(n_obs(m1), 150)
-    expect_equal(n_obs(m2), 32)
-  })
-
-  test_that("find_parameters", {
-    expect_equal(
-      find_parameters(m1),
-      list(
-        conditional = c(
-          "(Intercept)",
-          "Petal.Width",
-          "Speciesversicolor",
-          "Speciesvirginica"
-        )
-      )
-    )
-    expect_equal(
-      find_parameters(m2),
-      list(
-        conditional = c(
-          "(Intercept)",
-          "log(hp)",
-          "cyl",
-          "I(cyl^2)",
-          "poly(wt, degree = 2, raw = TRUE)1",
-          "poly(wt, degree = 2, raw = TRUE)2"
-        )
+skip_if_not_installed("speedglm")
+data(iris)
+data(mtcars)
+
+m1 <- speedlm(Sepal.Length ~ Petal.Width + Species, data = iris)
+m2 <-
+  speedlm(log(mpg) ~ log(hp) + cyl + I(cyl^2) + poly(wt, degree = 2, raw = TRUE),
+    data = mtcars
+  )
+
+test_that("model_info", {
+  expect_true(model_info(m1)$is_linear)
+})
+
+test_that("find_predictors", {
+  expect_identical(find_predictors(m1), list(conditional = c("Petal.Width", "Species")))
+  expect_identical(
+    find_predictors(m1, flatten = TRUE),
+    c("Petal.Width", "Species")
+  )
+  expect_null(find_predictors(m1, effects = "random"))
+})
+
+test_that("find_random", {
+  expect_null(find_random(m1))
+})
+
+test_that("get_random", {
+  expect_warning(get_random(m1))
+})
+
+test_that("find_response", {
+  expect_identical(find_response(m1), "Sepal.Length")
+})
+
+test_that("get_response", {
+  expect_equal(get_response(m1), iris$Sepal.Length)
+})
+
+test_that("get_predictors", {
+  expect_equal(colnames(get_predictors(m1)), c("Petal.Width", "Species"))
+})
+
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
+})
+
+test_that("linkfun", {
+  expect_equal(link_function(m1)(0.2), 0.2, tolerance = 1e-5)
+})
+
+test_that("get_data", {
+  expect_equal(nrow(get_data(m1)), 150)
+  expect_equal(
+    colnames(get_data(m1)),
+    c("Sepal.Length", "Petal.Width", "Species")
+  )
+  expect_equal(colnames(get_data(m2)), c("mpg", "hp", "cyl", "wt"))
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1), 1)
+  expect_equal(
+    find_formula(m1),
+    list(conditional = as.formula("Sepal.Length ~ Petal.Width + Species")),
+    ignore_attr = TRUE
+  )
+  expect_equal(
+    find_formula(m2),
+    list(
+      conditional = as.formula(
+        "log(mpg) ~ log(hp) + cyl + I(cyl^2) + poly(wt, degree = 2, raw = TRUE)"
       )
+    ),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_variables", {
+  expect_equal(
+    find_variables(m1),
+    list(
+      response = "Sepal.Length",
+      conditional = c("Petal.Width", "Species")
     )
-    expect_equal(nrow(get_parameters(m1)), 4)
-    expect_equal(
-      get_parameters(m1)$Parameter,
-      c(
+  )
+  expect_equal(
+    find_variables(m1, flatten = TRUE),
+    c("Sepal.Length", "Petal.Width", "Species")
+  )
+  expect_equal(
+    find_variables(m2, flatten = TRUE),
+    c("mpg", "hp", "cyl", "wt")
+  )
+})
+
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 150)
+  expect_equal(n_obs(m2), 32)
+})
+
+test_that("find_parameters", {
+  expect_equal(
+    find_parameters(m1),
+    list(
+      conditional = c(
         "(Intercept)",
         "Petal.Width",
         "Speciesversicolor",
         "Speciesvirginica"
       )
     )
-  })
-
-  test_that("is_multivariate", {
-    expect_false(is_multivariate(m1))
-  })
-
-  test_that("find_terms", {
-    expect_equal(
-      find_terms(m1),
-      list(
-        response = "Sepal.Length",
-        conditional = c("Petal.Width", "Species")
+  )
+  expect_equal(
+    find_parameters(m2),
+    list(
+      conditional = c(
+        "(Intercept)",
+        "log(hp)",
+        "cyl",
+        "I(cyl^2)",
+        "poly(wt, degree = 2, raw = TRUE)1",
+        "poly(wt, degree = 2, raw = TRUE)2"
       )
     )
-    expect_equal(
-      find_terms(m2),
-      list(
-        response = "log(mpg)",
-        conditional = c(
-          "log(hp)",
-          "cyl",
-          "I(cyl^2)",
-          "poly(wt, degree = 2, raw = TRUE)"
-        )
+  )
+  expect_equal(nrow(get_parameters(m1)), 4)
+  expect_equal(
+    get_parameters(m1)$Parameter,
+    c(
+      "(Intercept)",
+      "Petal.Width",
+      "Speciesversicolor",
+      "Speciesvirginica"
+    )
+  )
+})
+
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1))
+})
+
+test_that("find_terms", {
+  expect_equal(
+    find_terms(m1),
+    list(
+      response = "Sepal.Length",
+      conditional = c("Petal.Width", "Species")
+    )
+  )
+  expect_equal(
+    find_terms(m2),
+    list(
+      response = "log(mpg)",
+      conditional = c(
+        "log(hp)",
+        "cyl",
+        "I(cyl^2)",
+        "poly(wt, degree = 2, raw = TRUE)"
       )
     )
-  })
+  )
+})
 
-  test_that("find_algorithm", {
-    expect_equal(find_algorithm(m1), list(algorithm = "eigen"))
-  })
+test_that("find_algorithm", {
+  expect_equal(find_algorithm(m1), list(algorithm = "eigen"))
+})
 
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "t-statistic")
-    expect_identical(find_statistic(m2), "t-statistic")
-  })
-}
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "t-statistic")
+  expect_identical(find_statistic(m2), "t-statistic")
+})
diff --git a/inst/WORDLIST b/inst/WORDLIST
index 520bcd8d3..59fae093f 100644
--- a/inst/WORDLIST
+++ b/inst/WORDLIST
@@ -170,3 +170,4 @@ visualisation
 warmup
 warmups
 ’s
+speedglm
\ No newline at end of file
diff --git a/tests/testthat.R b/tests/testthat.R
index bebf66201..424834a1d 100644
--- a/tests/testthat.R
+++ b/tests/testthat.R
@@ -1,4 +1,3 @@
-if (require("testthat", quietly = TRUE)) {
-  library(insight)
-  test_check("insight")
-}
+library(testthat)
+library(insight)
+test_check("insight")
diff --git a/tests/testthat/_snaps/export_table.md b/tests/testthat/_snaps/export_table.md
new file mode 100644
index 000000000..fff6fa90f
--- /dev/null
+++ b/tests/testthat/_snaps/export_table.md
@@ -0,0 +1,22 @@
+# export_table
+
+    Code
+      export_table(d)
+    Output
+           a |     b
+      --------------
+        1.30 |    ab
+        2.00 |    cd
+      543.00 | abcde
+
+---
+
+    Code
+      export_table(d, sep = " ", header = "*", digits = 1)
+    Output
+          a     b
+      ***********
+        1.3    ab
+        2.0    cd
+      543.0 abcde
+
diff --git a/tests/testthat/_snaps/format_table_ci.md b/tests/testthat/_snaps/format_table_ci.md
new file mode 100644
index 000000000..1a85b009c
--- /dev/null
+++ b/tests/testthat/_snaps/format_table_ci.md
@@ -0,0 +1,11 @@
+# format_table with multiple si-levels
+
+    Code
+      x
+    Output
+      Highest Density Interval
+      
+      80% HDI       |       90% HDI
+      -----------------------------
+      [-1.28, 1.28] | [-1.65, 1.64]
+
diff --git a/tests/testthat/helper.R b/tests/testthat/helper.R
deleted file mode 100644
index fd4ff1e93..000000000
--- a/tests/testthat/helper.R
+++ /dev/null
@@ -1,6 +0,0 @@
-skip_if_not_or_load_if_installed <- function(package) {
-  testthat::skip_if_not_installed(package)
-  suppressMessages(suppressWarnings(suppressPackageStartupMessages(
-    require(package, warn.conflicts = FALSE, character.only = TRUE, quietly = TRUE)
-  )))
-}
diff --git a/tests/testthat/test-BayesFactorBF.R b/tests/testthat/test-BayesFactorBF.R
index 657d8af43..8835be04f 100644
--- a/tests/testthat/test-BayesFactorBF.R
+++ b/tests/testthat/test-BayesFactorBF.R
@@ -1,6 +1,6 @@
-skip_if_not_or_load_if_installed("BayesFactor")
+skip_if_not_installed("BayesFactor")
 
-x <- correlationBF(y = iris$Sepal.Length, x = iris$Sepal.Width)
+x <- BayesFactor::correlationBF(y = iris$Sepal.Length, x = iris$Sepal.Width)
 test_that("get_data", {
   expect_true(is.data.frame(get_data(x)))
 })
@@ -23,9 +23,9 @@ set.seed(123)
 x <- rnorm(1000, 0, 1)
 y <- rnorm(1000, 0, 1)
 
-t1 <- suppressMessages(ttestBF(x = x, mu = 60))
-t2 <- ttestBF(x = x, y = y)
-t2d <- suppressMessages(ttestBF(x = x, y = y, paired = TRUE, mu = 60))
+t1 <- suppressMessages(BayesFactor::ttestBF(x = x, mu = 60))
+t2 <- BayesFactor::ttestBF(x = x, y = y)
+t2d <- suppressMessages(BayesFactor::ttestBF(x = x, y = y, paired = TRUE, mu = 60))
 
 test_that("get_data", {
   expect_true(is.data.frame(get_data(t1)))
@@ -68,7 +68,7 @@ test_that("find_parameters", {
 
 t <- c(-0.15, 2.39, 2.42, 2.43)
 N <- c(100, 150, 97, 99)
-x <- meta.ttestBF(t = t, n1 = N, rscale = 1)
+x <- BayesFactor::meta.ttestBF(t = t, n1 = N, rscale = 1)
 test_that("get_data", {
   expect_true(is.data.frame(get_data(x)))
 })
@@ -84,7 +84,7 @@ test_that("get_parameters", {
 data(ToothGrowth)
 ToothGrowth$dose <- factor(ToothGrowth$dose)
 levels(ToothGrowth$dose) <- c("Low", "Medium", "High")
-x <- anovaBF(len ~ supp * dose, data = ToothGrowth, progress = FALSE)
+x <- BayesFactor::anovaBF(len ~ supp * dose, data = ToothGrowth, progress = FALSE)
 
 test_that("get_data", {
   expect_true(is.data.frame(get_data(x)))
@@ -120,8 +120,8 @@ test_that("clean_parameters", {
 })
 
 
-data(puzzles)
-x <- anovaBF(RT ~ shape * color + ID, data = puzzles, whichRandom = "ID", progress = FALSE)
+data(puzzles, package = "BayesFactor")
+x <- BayesFactor::anovaBF(RT ~ shape * color + ID, data = puzzles, whichRandom = "ID", progress = FALSE)
 
 test_that("get_data", {
   expect_true(is.data.frame(get_data(x)))
@@ -229,7 +229,7 @@ test_that("get_priors", {
 })
 
 
-x <- lmBF(len ~ supp + dose, data = ToothGrowth, progress = FALSE)
+x <- BayesFactor::lmBF(len ~ supp + dose, data = ToothGrowth, progress = FALSE)
 test_that("get_data", {
   expect_true(is.data.frame(get_data(x)))
 })
@@ -248,7 +248,7 @@ test_that("get_parameters", {
 
 
 
-x2 <- lmBF(len ~ supp + dose + supp:dose, data = ToothGrowth, progress = FALSE)
+x2 <- BayesFactor::lmBF(len ~ supp + dose + supp:dose, data = ToothGrowth, progress = FALSE)
 x <- x / x2
 test_that("get_data", {
   expect_true(is.data.frame(get_data(x)))
@@ -288,29 +288,29 @@ test_that("find_statistic", {
 
 
 
-corr_BF1 <- correlationBF(iris$Sepal.Length, iris$Sepal.Width, progress = FALSE)
-corr_BFk <- correlationBF(iris$Sepal.Length, iris$Sepal.Width,
+corr_BF1 <- BayesFactor::correlationBF(iris$Sepal.Length, iris$Sepal.Width, progress = FALSE)
+corr_BFk <- BayesFactor::correlationBF(iris$Sepal.Length, iris$Sepal.Width,
   progress = FALSE,
   nullInterval = c(-1, 0)
 )
 
-data(raceDolls)
-xtab_BF1 <- contingencyTableBF(raceDolls, sampleType = "indepMulti", fixedMargin = "cols", priorConcentration = 2)
+data(raceDolls, package = "BayesFactor")
+xtab_BF1 <- BayesFactor::contingencyTableBF(raceDolls, sampleType = "indepMulti", fixedMargin = "cols", priorConcentration = 2)
 
-ttest_BF1 <- ttestBF(sleep$extra[sleep$group == 1], sleep$extra[sleep$group == 2], progress = FALSE)
-ttest_BFk <- ttestBF(sleep$extra[sleep$group == 1], sleep$extra[sleep$group == 2],
+ttest_BF1 <- BayesFactor::ttestBF(sleep$extra[sleep$group == 1], sleep$extra[sleep$group == 2], progress = FALSE)
+ttest_BFk <- BayesFactor::ttestBF(sleep$extra[sleep$group == 1], sleep$extra[sleep$group == 2],
   progress = FALSE,
   nullInterval = c(-3, 0)
 )
 
-prop_BF1 <- proportionBF(y = 15, N = 25, p = 0.5, progress = FALSE)
-prop_BFk <- proportionBF(
+prop_BF1 <- BayesFactor::proportionBF(y = 15, N = 25, p = 0.5, progress = FALSE)
+prop_BFk <- BayesFactor::proportionBF(
   y = 15, N = 25, p = 0.5, progress = FALSE,
   nullInterval = c(0, 0.3)
 )
 
 
-lm_BFk <- generalTestBF(Sepal.Width ~ Sepal.Length + Species, data = iris, progress = FALSE)
+lm_BFk <- BayesFactor::generalTestBF(Sepal.Width ~ Sepal.Length + Species, data = iris, progress = FALSE)
 lm_BFd <- lm_BFk[3] / lm_BFk[2]
 lm_BF1 <- lm_BFk[2]
 
@@ -381,7 +381,7 @@ test_that("get_priors for t-test", {
 
 mtcars$cyl <- factor(mtcars$cyl)
 mtcars$gear <- factor(mtcars$gear)
-model <- lmBF(mpg ~ cyl + gear + cyl:gear, mtcars,
+model <- BayesFactor::lmBF(mpg ~ cyl + gear + cyl:gear, mtcars,
   progress = FALSE, whichRandom = c("gear", "cyl:gear")
 )
 
diff --git a/tests/testthat/test-FE-formula.R b/tests/testthat/test-FE-formula.R
index c1ebceafd..9ab4b2fec 100644
--- a/tests/testthat/test-FE-formula.R
+++ b/tests/testthat/test-FE-formula.R
@@ -1,4 +1,4 @@
-gfe <- insight:::.get_fixed_effects
+gfe <- .get_fixed_effects
 
 test_that(".get_fixed_effects", {
   f <- "am ~ disp:wt + (1|gear) + wt + (1+wt|carb)"
diff --git a/tests/testthat/test-GLMMadaptive.R b/tests/testthat/test-GLMMadaptive.R
index 377661df2..268b42235 100644
--- a/tests/testthat/test-GLMMadaptive.R
+++ b/tests/testthat/test-GLMMadaptive.R
@@ -1,342 +1,342 @@
-if (TRUE) {
-  if (skip_if_not_or_load_if_installed("GLMMadaptive") && skip_if_not_or_load_if_installed("lme4")) {
-    m <- download_model("GLMMadaptive_zi_2")
-    m2 <- download_model("GLMMadaptive_zi_1")
+skip_if_offline()
+skip_if_not_installed("GLMMadaptive")
+skip_if_not_installed("lme4")
 
-    data(cbpp)
-    tmp <<- cbpp
-    m3 <- GLMMadaptive::mixed_model(
-      cbind(incidence, size - incidence) ~ period,
-      random = ~ 1 | herd,
-      data = tmp,
-      family = binomial
-    )
+m <- download_model("GLMMadaptive_zi_2")
+m2 <- download_model("GLMMadaptive_zi_1")
 
-    test_that("model_info", {
-      expect_true(model_info(m)$is_zero_inflated)
-      expect_true(model_info(m)$is_count)
-      expect_true(model_info(m)$is_pois)
-      expect_false(model_info(m)$is_negbin)
-      expect_false(model_info(m)$is_linear)
-    })
+data(cbpp, package = "lme4")
+tmp <<- cbpp
+m3 <- GLMMadaptive::mixed_model(
+  cbind(incidence, size - incidence) ~ period,
+  random = ~ 1 | herd,
+  data = tmp,
+  family = binomial
+)
 
-    test_that("get_deviance + logLik", {
-      expect_equal(get_deviance(m3), 183.96674, tolerance = 1e-3)
-      expect_equal(get_loglikelihood(m3), logLik(m3), tolerance = 1e-3, ignore_attr = TRUE)
-      expect_equal(get_df(m3, type = "model"), 5)
-    })
+test_that("model_info", {
+  expect_true(model_info(m)$is_zero_inflated)
+  expect_true(model_info(m)$is_count)
+  expect_true(model_info(m)$is_pois)
+  expect_false(model_info(m)$is_negbin)
+  expect_false(model_info(m)$is_linear)
+})
 
-    test_that("get_df", {
-      expect_equal(
-        get_df(m3, type = "residual"),
-        51,
-        ignore_attr = TRUE
-      )
-      expect_equal(
-        get_df(m3, type = "normal"),
-        Inf,
-        ignore_attr = TRUE
-      )
-      expect_equal(
-        get_df(m3, type = "wald"),
-        Inf,
-        ignore_attr = TRUE
-      )
-    })
+test_that("get_deviance + logLik", {
+  expect_equal(get_deviance(m3), 183.96674, tolerance = 1e-3)
+  expect_equal(get_loglikelihood(m3), logLik(m3), tolerance = 1e-3, ignore_attr = TRUE)
+  expect_equal(get_df(m3, type = "model"), 5)
+})
 
-    test_that("n_parameters", {
-      expect_equal(n_parameters(m), 6)
-      expect_equal(n_parameters(m2), 6)
-      expect_equal(n_parameters(m, effects = "random"), 2)
-      expect_equal(n_parameters(m2, effects = "random"), 1)
-    })
+test_that("get_df", {
+  expect_equal(
+    get_df(m3, type = "residual"),
+    51,
+    ignore_attr = TRUE
+  )
+  expect_equal(
+    get_df(m3, type = "normal"),
+    Inf,
+    ignore_attr = TRUE
+  )
+  expect_equal(
+    get_df(m3, type = "wald"),
+    Inf,
+    ignore_attr = TRUE
+  )
+})
 
-    test_that("find_predictors", {
-      expect_identical(
-        find_predictors(m, effects = "fixed")$conditional,
-        c("child", "camper")
-      )
-      expect_identical(
-        find_predictors(m, effects = "fixed")$zero_inflated,
-        c("child", "livebait")
-      )
-      expect_identical(
-        find_predictors(m, effects = "all", flatten = TRUE),
-        c("child", "camper", "persons", "livebait")
-      )
-      expect_identical(
-        find_predictors(m, effects = "all")$zero_inflated_random,
-        c("persons")
-      )
-      expect_identical(find_predictors(m, effects = "random")$random, "persons")
-      expect_identical(
-        find_predictors(
-          m,
-          effects = "fixed",
-          component = "cond",
-          flatten = TRUE
-        ),
-        c("child", "camper")
-      )
-      expect_identical(
-        find_predictors(
-          m,
-          effects = "all",
-          component = "cond",
-          flatten = TRUE
-        ),
-        c("child", "camper", "persons")
-      )
-      expect_identical(
-        find_predictors(m, effects = "all", component = "cond")$conditional,
-        c("child", "camper")
-      )
+test_that("n_parameters", {
+  expect_equal(n_parameters(m), 6)
+  expect_equal(n_parameters(m2), 6)
+  expect_equal(n_parameters(m, effects = "random"), 2)
+  expect_equal(n_parameters(m2, effects = "random"), 1)
+})
 
-      expect_identical(
-        find_predictors(
-          m,
-          effects = "random",
-          component = "cond",
-          flatten = TRUE
-        ),
-        "persons"
-      )
-      expect_identical(
-        find_predictors(
-          m,
-          effects = "fixed",
-          component = "zi",
-          flatten = TRUE
-        ),
-        c("child", "livebait")
-      )
-      expect_identical(
-        find_predictors(
-          m,
-          effects = "all",
-          component = "zi",
-          flatten = TRUE
-        ),
-        c("child", "livebait", "persons")
-      )
-      expect_identical(
-        find_predictors(
-          m,
-          effects = "random",
-          component = "zi",
-          flatten = TRUE
-        ),
-        "persons"
-      )
-      expect_null(find_predictors(
-        m,
-        effects = "fixed",
-        component = "dispersion",
-        flatten = TRUE
-      ))
-      expect_null(find_predictors(
-        m,
-        effects = "all",
-        component = "dispersion",
-        flatten = TRUE
-      ))
-      expect_null(find_predictors(
-        m,
-        effects = "random",
-        component = "dispersion",
-        flatten = TRUE
-      ))
-    })
+test_that("find_predictors", {
+  expect_identical(
+    find_predictors(m, effects = "fixed")$conditional,
+    c("child", "camper")
+  )
+  expect_identical(
+    find_predictors(m, effects = "fixed")$zero_inflated,
+    c("child", "livebait")
+  )
+  expect_identical(
+    find_predictors(m, effects = "all", flatten = TRUE),
+    c("child", "camper", "persons", "livebait")
+  )
+  expect_identical(
+    find_predictors(m, effects = "all")$zero_inflated_random,
+    c("persons")
+  )
+  expect_identical(find_predictors(m, effects = "random")$random, "persons")
+  expect_identical(
+    find_predictors(
+      m,
+      effects = "fixed",
+      component = "cond",
+      flatten = TRUE
+    ),
+    c("child", "camper")
+  )
+  expect_identical(
+    find_predictors(
+      m,
+      effects = "all",
+      component = "cond",
+      flatten = TRUE
+    ),
+    c("child", "camper", "persons")
+  )
+  expect_identical(
+    find_predictors(m, effects = "all", component = "cond")$conditional,
+    c("child", "camper")
+  )
 
-    test_that("find_response", {
-      expect_identical(find_response(m), "count")
-    })
+  expect_identical(
+    find_predictors(
+      m,
+      effects = "random",
+      component = "cond",
+      flatten = TRUE
+    ),
+    "persons"
+  )
+  expect_identical(
+    find_predictors(
+      m,
+      effects = "fixed",
+      component = "zi",
+      flatten = TRUE
+    ),
+    c("child", "livebait")
+  )
+  expect_identical(
+    find_predictors(
+      m,
+      effects = "all",
+      component = "zi",
+      flatten = TRUE
+    ),
+    c("child", "livebait", "persons")
+  )
+  expect_identical(
+    find_predictors(
+      m,
+      effects = "random",
+      component = "zi",
+      flatten = TRUE
+    ),
+    "persons"
+  )
+  expect_null(find_predictors(
+    m,
+    effects = "fixed",
+    component = "dispersion",
+    flatten = TRUE
+  ))
+  expect_null(find_predictors(
+    m,
+    effects = "all",
+    component = "dispersion",
+    flatten = TRUE
+  ))
+  expect_null(find_predictors(
+    m,
+    effects = "random",
+    component = "dispersion",
+    flatten = TRUE
+  ))
+})
 
-    test_that("link_inverse", {
-      expect_identical(link_inverse(m)(0.2), exp(0.2))
-    })
+test_that("find_response", {
+  expect_identical(find_response(m), "count")
+})
 
-    test_that("clean_names", {
-      expect_identical(
-        clean_names(m),
-        c("count", "child", "camper", "persons", "livebait")
-      )
-    })
+test_that("link_inverse", {
+  expect_identical(link_inverse(m)(0.2), exp(0.2))
+})
 
-    test_that("find_formula", {
-      expect_length(find_formula(m), 4)
-      expect_identical(
-        names(find_formula(m)),
-        c(
-          "conditional",
-          "random",
-          "zero_inflated",
-          "zero_inflated_random"
-        ),
-        ignore_attr = TRUE
-      )
-    })
+test_that("clean_names", {
+  expect_identical(
+    clean_names(m),
+    c("count", "child", "camper", "persons", "livebait")
+  )
+})
 
-    test_that("find_random", {
-      expect_identical(
-        find_random(m),
-        list(random = "persons", zero_inflated_random = "persons")
-      )
-      expect_identical(find_random(m, flatten = TRUE), "persons")
-    })
+test_that("find_formula", {
+  expect_length(find_formula(m), 4)
+  expect_identical(
+    names(find_formula(m)),
+    c(
+      "conditional",
+      "random",
+      "zero_inflated",
+      "zero_inflated_random"
+    ),
+    ignore_attr = TRUE
+  )
+})
 
-    test_that("find_respone", {
-      expect_identical(find_response(m), "count")
-    })
+test_that("find_random", {
+  expect_identical(
+    find_random(m),
+    list(random = "persons", zero_inflated_random = "persons")
+  )
+  expect_identical(find_random(m, flatten = TRUE), "persons")
+})
 
-    test_that("find_terms", {
-      expect_identical(
-        find_terms(m),
-        list(
-          response = "count",
-          conditional = c("child", "camper"),
-          random = "persons",
-          zero_inflated = c("child", "livebait"),
-          zero_inflated_random = "persons"
-        )
-      )
-      expect_identical(
-        find_terms(m, flatten = TRUE),
-        c("count", "child", "camper", "persons", "livebait")
-      )
-    })
+test_that("find_respone", {
+  expect_identical(find_response(m), "count")
+})
 
-    test_that("get_response", {
-      expect_identical(get_response(m3), cbpp[, c("incidence", "size")])
-    })
+test_that("find_terms", {
+  expect_identical(
+    find_terms(m),
+    list(
+      response = "count",
+      conditional = c("child", "camper"),
+      random = "persons",
+      zero_inflated = c("child", "livebait"),
+      zero_inflated_random = "persons"
+    )
+  )
+  expect_identical(
+    find_terms(m, flatten = TRUE),
+    c("count", "child", "camper", "persons", "livebait")
+  )
+})
 
-    test_that("get_predictors", {
-      expect_identical(
-        colnames(get_predictors(m)),
-        c("child", "camper", "livebait")
-      )
-    })
+test_that("get_response", {
+  expect_identical(get_response(m3), cbpp[, c("incidence", "size")])
+})
 
-    test_that("get_random", {
-      expect_identical(colnames(get_random(m)), "persons")
-    })
+test_that("get_predictors", {
+  expect_identical(
+    colnames(get_predictors(m)),
+    c("child", "camper", "livebait")
+  )
+})
 
+test_that("get_random", {
+  expect_identical(colnames(get_random(m)), "persons")
+})
 
-    # data stems from model frame, since we downloaded models, so it's not
-    # in the environment. Thus, "get_data()" throws warning, and we therefore
-    # set verbose = FALSE
 
-    test_that("get_data", {
-      expect_identical(
-        sort(colnames(get_data(m, verbose = FALSE))),
-        sort(c("count", "child", "camper", "livebait", "persons"))
-      )
-      expect_identical(
-        colnames(get_data(m, effects = "fixed", verbose = FALSE)),
-        c("count", "child", "camper", "livebait")
-      )
-      expect_identical(colnames(get_data(m, effects = "random", verbose = FALSE)), "persons")
-      expect_identical(
-        sort(colnames(get_data(m, component = "zi", verbose = FALSE))),
-        sort(c("count", "child", "livebait", "persons"))
-      )
-      expect_identical(
-        sort(colnames(get_data(m, component = "zi", effects = "fixed", verbose = FALSE))),
-        sort(c("count", "child", "livebait"))
-      )
-      expect_identical(colnames(get_data(
-        m,
-        component = "zi", effects = "random", verbose = FALSE
-      )), "persons")
-      expect_identical(
-        colnames(get_data(m, component = "cond", verbose = FALSE)),
-        c("count", "child", "camper", "persons")
-      )
-      expect_identical(colnames(get_data(
-        m,
-        component = "cond", effects = "fixed", verbose = FALSE
-      )), c("count", "child", "camper"))
-      expect_identical(colnames(get_data(
-        m,
-        component = "cond", effects = "random", verbose = FALSE
-      )), "persons")
-      expect_identical(colnames(suppressWarnings(get_data(m, component = "dispersion"))), "count")
-      expect_null(suppressWarnings(get_data(m, component = "dispersion", effects = "random", verbose = FALSE)))
-      expect_identical(
-        colnames(get_data(m3)),
-        c("incidence", "size", "period", "herd")
-      )
-    })
+# data stems from model frame, since we downloaded models, so it's not
+# in the environment. Thus, "get_data()" throws warning, and we therefore
+# set verbose = FALSE
 
-    test_that("find_parameter", {
-      expect_equal(
-        find_parameters(m),
-        list(
-          conditional = c("(Intercept)", "child", "camper1"),
-          random = "(Intercept)",
-          zero_inflated = c("(Intercept)", "child", "livebait1"),
-          zero_inflated_random = "zi_(Intercept)"
-        )
-      )
-      expect_equal(
-        find_parameters(m2),
-        list(
-          conditional = c("(Intercept)", "child", "camper1"),
-          random = "(Intercept)",
-          zero_inflated = c("(Intercept)", "child", "livebait1")
-        )
-      )
-      expect_equal(
-        find_parameters(m3),
-        list(
-          conditional = c("(Intercept)", "period2", "period3", "period4"),
-          random = "(Intercept)"
-        )
-      )
+test_that("get_data", {
+  expect_identical(
+    sort(colnames(get_data(m, verbose = FALSE))),
+    sort(c("count", "child", "camper", "livebait", "persons"))
+  )
+  expect_identical(
+    colnames(get_data(m, effects = "fixed", verbose = FALSE)),
+    c("count", "child", "camper", "livebait")
+  )
+  expect_identical(colnames(get_data(m, effects = "random", verbose = FALSE)), "persons")
+  expect_identical(
+    sort(colnames(get_data(m, component = "zi", verbose = FALSE))),
+    sort(c("count", "child", "livebait", "persons"))
+  )
+  expect_identical(
+    sort(colnames(get_data(m, component = "zi", effects = "fixed", verbose = FALSE))),
+    sort(c("count", "child", "livebait"))
+  )
+  expect_identical(colnames(get_data(
+    m,
+    component = "zi", effects = "random", verbose = FALSE
+  )), "persons")
+  expect_identical(
+    colnames(get_data(m, component = "cond", verbose = FALSE)),
+    c("count", "child", "camper", "persons")
+  )
+  expect_identical(colnames(get_data(
+    m,
+    component = "cond", effects = "fixed", verbose = FALSE
+  )), c("count", "child", "camper"))
+  expect_identical(colnames(get_data(
+    m,
+    component = "cond", effects = "random", verbose = FALSE
+  )), "persons")
+  expect_identical(colnames(suppressWarnings(get_data(m, component = "dispersion"))), "count")
+  expect_null(suppressWarnings(get_data(m, component = "dispersion", effects = "random", verbose = FALSE)))
+  expect_identical(
+    colnames(get_data(m3)),
+    c("incidence", "size", "period", "herd")
+  )
+})
 
-      expect_equal(nrow(get_parameters(m)), 6)
-      expect_equal(
-        get_parameters(m, effects = "random"),
-        list(
-          random = c(-1.0715496, 1.4083630, 1.9129880, 0.2007521),
-          zero_inflated_random = c(-0.1676294, 0.5502481, 1.2592406, 0.9336591)
-        ),
-        tolerance = 1e-5
-      )
-      expect_equal(nrow(get_parameters(m2)), 6)
-      expect_equal(get_parameters(m2, effects = "random"),
-        list(random = c(
-          -1.3262364, -0.2048055, 1.3852572, 0.5282277
-        )),
-        tolerance = 1e-5
-      )
-      expect_equal(
-        get_parameters(m3)$Component,
-        c(
-          "conditional",
-          "conditional",
-          "conditional",
-          "conditional"
-        )
-      )
-      expect_error(get_parameters(m3, "zi"))
-    })
+test_that("find_parameter", {
+  expect_equal(
+    find_parameters(m),
+    list(
+      conditional = c("(Intercept)", "child", "camper1"),
+      random = "(Intercept)",
+      zero_inflated = c("(Intercept)", "child", "livebait1"),
+      zero_inflated_random = "zi_(Intercept)"
+    )
+  )
+  expect_equal(
+    find_parameters(m2),
+    list(
+      conditional = c("(Intercept)", "child", "camper1"),
+      random = "(Intercept)",
+      zero_inflated = c("(Intercept)", "child", "livebait1")
+    )
+  )
+  expect_equal(
+    find_parameters(m3),
+    list(
+      conditional = c("(Intercept)", "period2", "period3", "period4"),
+      random = "(Intercept)"
+    )
+  )
+
+  expect_equal(nrow(get_parameters(m)), 6)
+  expect_equal(
+    get_parameters(m, effects = "random"),
+    list(
+      random = c(-1.0715496, 1.4083630, 1.9129880, 0.2007521),
+      zero_inflated_random = c(-0.1676294, 0.5502481, 1.2592406, 0.9336591)
+    ),
+    tolerance = 1e-5
+  )
+  expect_equal(nrow(get_parameters(m2)), 6)
+  expect_equal(get_parameters(m2, effects = "random"),
+    list(random = c(
+      -1.3262364, -0.2048055, 1.3852572, 0.5282277
+    )),
+    tolerance = 1e-5
+  )
+  expect_equal(
+    get_parameters(m3)$Component,
+    c(
+      "conditional",
+      "conditional",
+      "conditional",
+      "conditional"
+    )
+  )
+  expect_error(get_parameters(m3, "zi"))
+})
 
-    test_that("linkfun", {
-      expect_false(is.null(link_function(m)))
-      expect_false(is.null(link_function(m2)))
-    })
+test_that("linkfun", {
+  expect_false(is.null(link_function(m)))
+  expect_false(is.null(link_function(m2)))
+})
 
-    test_that("is_multivariate", {
-      expect_false(is_multivariate(m))
-      expect_false(is_multivariate(m2))
-    })
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m))
+  expect_false(is_multivariate(m2))
+})
 
-    test_that("find_algorithm", {
-      expect_equal(
-        find_algorithm(m),
-        list(algorithm = "quasi-Newton", optimizer = "optim")
-      )
-    })
-  }
-}
+test_that("find_algorithm", {
+  expect_equal(
+    find_algorithm(m),
+    list(algorithm = "quasi-Newton", optimizer = "optim")
+  )
+})
diff --git a/tests/testthat/test-Gam2.R b/tests/testthat/test-Gam2.R
index e533931a5..34b4f93dd 100644
--- a/tests/testthat/test-Gam2.R
+++ b/tests/testthat/test-Gam2.R
@@ -1,108 +1,107 @@
-if (
-
-
-  skip_if_not_or_load_if_installed("gam")) {
-  data(kyphosis)
-  void <- capture.output(m1 <- gam::gam(
-    Kyphosis ~ s(Age, 4) + Number,
-    family = binomial,
-    data = kyphosis,
-    trace = TRUE
-  ))
-
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_binomial)
-    expect_false(model_info(m1)$is_linear)
-  })
-
-  test_that("find_predictors", {
-    expect_identical(find_predictors(m1), list(conditional = c("Age", "Number")))
-    expect_identical(find_predictors(m1, flatten = TRUE), c("Age", "Number"))
-    expect_null(find_predictors(m1, effects = "random"))
-  })
-
-  test_that("find_response", {
-    expect_identical(find_response(m1), "Kyphosis")
-  })
-
-  test_that("link_inverse", {
-    expect_equal(link_inverse(m1)(0.2), plogis(0.2), tolerance = 1e-5)
-  })
-
-  test_that("get_data", {
-    expect_equal(nrow(get_data(m1)), 81)
-    expect_equal(colnames(get_data(m1)), c("Kyphosis", "Age", "Number"))
-  })
-
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 1)
-    expect_equal(
-      find_formula(m1),
-      list(conditional = as.formula("Kyphosis ~ s(Age, 4) + Number")),
-      ignore_attr = TRUE
+skip_if_not_installed("gam")
+
+s <- gam::s
+
+data(kyphosis, package = "rpart")
+void <- capture.output(m1 <- gam::gam(
+  Kyphosis ~ s(Age, 4) + Number,
+  family = binomial,
+  data = kyphosis,
+  trace = TRUE
+))
+
+test_that("model_info", {
+  expect_true(model_info(m1)$is_binomial)
+  expect_false(model_info(m1)$is_linear)
+})
+
+test_that("find_predictors", {
+  expect_identical(find_predictors(m1), list(conditional = c("Age", "Number")))
+  expect_identical(find_predictors(m1, flatten = TRUE), c("Age", "Number"))
+  expect_null(find_predictors(m1, effects = "random"))
+})
+
+test_that("find_response", {
+  expect_identical(find_response(m1), "Kyphosis")
+})
+
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), plogis(0.2), tolerance = 1e-5)
+})
+
+test_that("get_data", {
+  expect_equal(nrow(get_data(m1)), 81)
+  expect_equal(colnames(get_data(m1)), c("Kyphosis", "Age", "Number"))
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1), 1)
+  expect_equal(
+    find_formula(m1),
+    list(conditional = as.formula("Kyphosis ~ s(Age, 4) + Number")),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_terms", {
+  expect_equal(
+    find_terms(m1),
+    list(
+      response = "Kyphosis",
+      conditional = c("s(Age, 4)", "Number")
     )
-  })
-
-  test_that("find_terms", {
-    expect_equal(
-      find_terms(m1),
-      list(
-        response = "Kyphosis",
-        conditional = c("s(Age, 4)", "Number")
-      )
+  )
+  expect_equal(
+    find_terms(m1, flatten = TRUE),
+    c("Kyphosis", "s(Age, 4)", "Number")
+  )
+})
+
+test_that("find_variables", {
+  expect_equal(
+    find_variables(m1),
+    list(
+      response = "Kyphosis",
+      conditional = c("Age", "Number")
     )
-    expect_equal(
-      find_terms(m1, flatten = TRUE),
-      c("Kyphosis", "s(Age, 4)", "Number")
+  )
+  expect_equal(
+    find_variables(m1, flatten = TRUE),
+    c("Kyphosis", "Age", "Number")
+  )
+})
+
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 81)
+})
+
+test_that("linkfun", {
+  expect_false(is.null(link_function(m1)))
+})
+
+test_that("find_parameters", {
+  expect_equal(
+    find_parameters(m1),
+    list(
+      conditional = c("(Intercept)", "Number"),
+      smooth_terms = "s(Age, 4)"
     )
-  })
-
-  test_that("find_variables", {
-    expect_equal(
-      find_variables(m1),
-      list(
-        response = "Kyphosis",
-        conditional = c("Age", "Number")
-      )
-    )
-    expect_equal(
-      find_variables(m1, flatten = TRUE),
-      c("Kyphosis", "Age", "Number")
-    )
-  })
-
-  test_that("n_obs", {
-    expect_equal(n_obs(m1), 81)
-  })
-
-  test_that("linkfun", {
-    expect_false(is.null(link_function(m1)))
-  })
-
-  test_that("find_parameters", {
-    expect_equal(
-      find_parameters(m1),
-      list(
-        conditional = c("(Intercept)", "Number"),
-        smooth_terms = "s(Age, 4)"
-      )
-    )
-    expect_equal(nrow(get_parameters(m1)), 3)
-    expect_equal(
-      get_parameters(m1)$Parameter,
-      c("(Intercept)", "Number", "s(Age, 4)")
-    )
-  })
-
-  test_that("is_multivariate", {
-    expect_false(is_multivariate(m1))
-  })
-
-  test_that("find_algorithm", {
-    expect_equal(find_algorithm(m1), list(algorithm = "IWLS"))
-  })
-
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "F-statistic")
-  })
-}
+  )
+  expect_equal(nrow(get_parameters(m1)), 3)
+  expect_equal(
+    get_parameters(m1)$Parameter,
+    c("(Intercept)", "Number", "s(Age, 4)")
+  )
+})
+
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1))
+})
+
+test_that("find_algorithm", {
+  expect_equal(find_algorithm(m1), list(algorithm = "IWLS"))
+})
+
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "F-statistic")
+})
diff --git a/tests/testthat/test-LORgee.R b/tests/testthat/test-LORgee.R
index f6d0d9e46..72debf5a1 100644
--- a/tests/testthat/test-LORgee.R
+++ b/tests/testthat/test-LORgee.R
@@ -1,135 +1,118 @@
-if (skip_if_not_or_load_if_installed("multgee")) {
-  data(arthritis)
-  m1 <- ordLORgee(
-    y ~ factor(time) + factor(trt) + factor(baseline),
-    data = arthritis,
-    id = id,
-    LORstr = "uniform",
-    repeated = time
+skip_if_not_installed("multgee")
+
+data(arthritis, package = "multgee")
+m1 <- multgee::ordLORgee(
+  y ~ factor(time) + factor(trt) + factor(baseline),
+  data = arthritis,
+  id = id,
+  LORstr = "uniform",
+  repeated = time
+)
+
+test_that("model_info", {
+  expect_true(model_info(m1)$is_ordinal)
+  expect_false(model_info(m1)$is_multinomial)
+  expect_true(model_info(m1)$is_logit)
+  expect_false(model_info(m1)$is_linear)
+})
+
+test_that("find_predictors", {
+  expect_identical(find_predictors(m1), list(conditional = c("time", "trt", "baseline")))
+  expect_identical(
+    find_predictors(m1, flatten = TRUE),
+    c("time", "trt", "baseline")
   )
+  expect_identical(find_predictors(m1, effects = "random"), list(random = "id"))
+  expect_identical(
+    find_predictors(m1, effects = "all", flatten = TRUE),
+    c("time", "trt", "baseline", "id")
+  )
+})
 
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_ordinal)
-    expect_false(model_info(m1)$is_multinomial)
-    expect_true(model_info(m1)$is_logit)
-    expect_false(model_info(m1)$is_linear)
-  })
-
-  test_that("find_predictors", {
-    expect_identical(find_predictors(m1), list(conditional = c("time", "trt", "baseline")))
-    expect_identical(
-      find_predictors(m1, flatten = TRUE),
-      c("time", "trt", "baseline")
-    )
-    expect_identical(find_predictors(m1, effects = "random"), list(random = "id"))
-    expect_identical(
-      find_predictors(m1, effects = "all", flatten = TRUE),
-      c("time", "trt", "baseline", "id")
-    )
-  })
-
-  test_that("find_response", {
-    expect_identical(find_response(m1), "y")
-  })
+test_that("find_response", {
+  expect_identical(find_response(m1), "y")
+})
 
-  test_that("get_response", {
-    expect_equal(get_response(m1), na.omit(arthritis)$y)
-  })
+test_that("get_response", {
+  expect_equal(get_response(m1), na.omit(arthritis)$y)
+})
 
-  test_that("find_random", {
-    expect_equal(find_random(m1), list(random = "id"))
-  })
+test_that("find_random", {
+  expect_equal(find_random(m1), list(random = "id"))
+})
 
-  test_that("get_random", {
-    expect_equal(get_random(m1), arthritis[, "id", drop = FALSE], ignore_attr = TRUE)
-  })
+test_that("get_random", {
+  expect_equal(get_random(m1), arthritis[, "id", drop = FALSE], ignore_attr = TRUE)
+})
 
-  test_that("get_predictors", {
-    expect_equal(get_predictors(m1), na.omit(arthritis)[, c("time", "trt", "baseline"), drop = FALSE])
-  })
+test_that("get_predictors", {
+  expect_equal(get_predictors(m1), na.omit(arthritis)[, c("time", "trt", "baseline"), drop = FALSE])
+})
 
-  test_that("link_inverse", {
-    expect_equal(link_inverse(m1)(0.2), plogis(0.2), tolerance = 1e-5)
-  })
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), plogis(0.2), tolerance = 1e-5)
+})
 
-  test_that("get_data", {
-    expect_equal(nrow(get_data(m1)), 888)
-    expect_equal(
-      colnames(get_data(m1)),
-      c("y", "time", "trt", "baseline", "id")
-    )
-  })
-
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 2)
-    expect_equal(
-      find_formula(m1),
-      list(
-        conditional = as.formula("y ~ factor(time) + factor(trt) + factor(baseline)"),
-        random = as.formula("~id")
-      ),
-      ignore_attr = TRUE
-    )
-  })
-
-  test_that("find_terms", {
-    expect_length(find_terms(m1), 3)
-    expect_equal(
-      find_terms(m1),
-      list(
-        response = "y",
-        conditional = c("factor(time)", "factor(trt)", "factor(baseline)"),
-        random = "id"
-      )
-    )
-  })
-
-  test_that("find_variables", {
-    expect_equal(
-      find_variables(m1),
-      list(
-        response = "y",
-        conditional = c("time", "trt", "baseline"),
-        random = "id"
-      )
-    )
-    expect_equal(
-      find_variables(m1, flatten = TRUE),
-      c("y", "time", "trt", "baseline", "id")
+test_that("get_data", {
+  expect_equal(nrow(get_data(m1)), 888)
+  expect_equal(
+    colnames(get_data(m1)),
+    c("y", "time", "trt", "baseline", "id")
+  )
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1), 2)
+  expect_equal(
+    find_formula(m1),
+    list(
+      conditional = as.formula("y ~ factor(time) + factor(trt) + factor(baseline)"),
+      random = as.formula("~id")
+    ),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_terms", {
+  expect_length(find_terms(m1), 3)
+  expect_equal(
+    find_terms(m1),
+    list(
+      response = "y",
+      conditional = c("factor(time)", "factor(trt)", "factor(baseline)"),
+      random = "id"
     )
-  })
-
-  test_that("n_obs", {
-    expect_equal(n_obs(m1), 888)
-  })
-
-  test_that("linkfun", {
-    expect_false(is.null(link_function(m1)))
-  })
-
-  test_that("find_parameters", {
-    expect_equal(
-      find_parameters(m1),
-      list(
-        conditional = c(
-          "beta10",
-          "beta20",
-          "beta30",
-          "beta40",
-          "factor(time)3",
-          "factor(time)5",
-          "factor(trt)2",
-          "factor(baseline)2",
-          "factor(baseline)3",
-          "factor(baseline)4",
-          "factor(baseline)5"
-        )
-      )
+  )
+})
+
+test_that("find_variables", {
+  expect_equal(
+    find_variables(m1),
+    list(
+      response = "y",
+      conditional = c("time", "trt", "baseline"),
+      random = "id"
     )
-    expect_equal(nrow(get_parameters(m1)), 11)
-    expect_equal(
-      get_parameters(m1)$Parameter,
-      c(
+  )
+  expect_equal(
+    find_variables(m1, flatten = TRUE),
+    c("y", "time", "trt", "baseline", "id")
+  )
+})
+
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 888)
+})
+
+test_that("linkfun", {
+  expect_false(is.null(link_function(m1)))
+})
+
+test_that("find_parameters", {
+  expect_equal(
+    find_parameters(m1),
+    list(
+      conditional = c(
         "beta10",
         "beta20",
         "beta30",
@@ -143,17 +126,34 @@ if (skip_if_not_or_load_if_installed("multgee")) {
         "factor(baseline)5"
       )
     )
-  })
+  )
+  expect_equal(nrow(get_parameters(m1)), 11)
+  expect_equal(
+    get_parameters(m1)$Parameter,
+    c(
+      "beta10",
+      "beta20",
+      "beta30",
+      "beta40",
+      "factor(time)3",
+      "factor(time)5",
+      "factor(trt)2",
+      "factor(baseline)2",
+      "factor(baseline)3",
+      "factor(baseline)4",
+      "factor(baseline)5"
+    )
+  )
+})
 
-  test_that("is_multivariate", {
-    expect_false(is_multivariate(m1))
-  })
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1))
+})
 
-  test_that("find_algorithm", {
-    expect_equal(find_algorithm(m1), list(algorithm = "Fisher's scoring ML"))
-  })
+test_that("find_algorithm", {
+  expect_equal(find_algorithm(m1), list(algorithm = "Fisher's scoring ML"))
+})
 
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "z-statistic")
-  })
-}
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "z-statistic")
+})
diff --git a/tests/testthat/test-MCMCglmm.R b/tests/testthat/test-MCMCglmm.R
index 83f572459..91c793d0c 100644
--- a/tests/testthat/test-MCMCglmm.R
+++ b/tests/testthat/test-MCMCglmm.R
@@ -1,8 +1,14 @@
 skip_on_os(c("mac", "linux"))
-skip_if_not_or_load_if_installed("MCMCglmm")
+skip_if_not_installed("MCMCglmm")
 
-data(PlodiaPO)
-mod_mcmcglmm <- MCMCglmm(
+# see https://github.com/georgheinze/logistf/pull/54
+skip_if(
+  "as.character.formula" %in% methods(as.character),
+  "Package `logistf` is loaded and breaks `MCMCglmm::MCMCglmm()`"
+)
+
+data(PlodiaPO, package = "MCMCglmm")
+mod_mcmcglmm <- MCMCglmm::MCMCglmm(
   PO ~ plate,
   random = ~FSfamily,
   data = PlodiaPO,
diff --git a/tests/testthat/test-afex_aov.R b/tests/testthat/test-afex_aov.R
index e5483a96e..33ac783e6 100644
--- a/tests/testthat/test-afex_aov.R
+++ b/tests/testthat/test-afex_aov.R
@@ -1,155 +1,167 @@
-if (skip_if_not_or_load_if_installed("afex")) {
-  data(obk.long, package = "afex")
-
-  obk.long$treatment <- as.character(obk.long$treatment)
-  obk.long$phase <- as.character(obk.long$phase)
-
-  Mc <- suppressWarnings(suppressMessages(
-    afex::aov_car(
-      value ~ treatment * gender + age + Error(id / (phase * hour)),
-      factorize = FALSE,
-      data = obk.long, include_aov = FALSE
-    )
-  ))
-
-  Mc2 <- suppressWarnings(suppressMessages(
-    afex::aov_car(
-      value ~ treatment * gender + exp(age) + Error(id / (phase * hour)),
-      factorize = FALSE,
-      data = obk.long, include_aov = FALSE
-    )
-  ))
-
-  M <- suppressWarnings(suppressMessages(
-    afex::aov_car(
-      value ~ treatment * gender + Error(id / (phase * hour)),
-      data = obk.long, include_aov = FALSE
-    )
-  ))
-
-  B <- suppressWarnings(suppressMessages(
-    afex::aov_car(
-      value ~ treatment * gender + Error(id),
-      data = obk.long, include_aov = FALSE
-    )
-  ))
-
-  W <- suppressWarnings(suppressMessages(
-    afex::aov_car(
-      value ~ Error(id / (phase * hour)),
-      data = obk.long, include_aov = FALSE
-    )
-  ))
-
-  mods <- list(Mc, Mc2, M, B, W)
-
-
-  test_that("afex_aov: afex", {
-    expect_identical(unique(unlist(sapply(mods, model_name))), "afex_aov")
-    expect_identical(unique(unlist(sapply(mods, find_algorithm))), "OLS")
-    expect_identical(unique(unlist(sapply(mods, find_statistic))), "F-statistic")
-
-    expect_null(unique(unlist(sapply(mods, find_offset))))
-    expect_null(unique(unlist(sapply(mods, find_random_slopes))))
-    expect_null(unique(unlist(sapply(mods, find_smooth))))
-    expect_null(unique(unlist(sapply(mods, find_weights))))
-    expect_null(unique(unlist(sapply(mods, get_call))))
-    expect_null(unique(unlist(sapply(mods, get_weights))))
-    expect_null(unique(unlist(suppressWarnings(sapply(mods, get_variance)))))
-
-    expect_true(unique(sapply(mods, all_models_equal)))
-    expect_true(unique(sapply(mods, has_intercept)))
-    expect_true(unique(sapply(mods, is_model)))
-    expect_true(unique(sapply(mods, is_model_supported)))
-    expect_false(unique(sapply(mods, is_gam_model)))
-    # expect_false(unique(sapply(mods, is_multivariate)))
-    expect_false(unique(sapply(mods, is_nullmodel)))
-
-    # expect_equal(get_family(Mc2), gaussian())
-    expect_equal(link_function(Mc2), gaussian()$linkfun)
-    expect_equal(link_inverse(Mc2), gaussian()$linkinv)
-  })
-
-  test_that("afex_aov: model values", {
-    expect_equal(suppressWarnings(sapply(mods, get_auxiliary)),
-      c(1.75262, 1.77497, 1.77038, 1.29973, 2.08001),
-      tolerance = 0.01
-    )
-    expect_equal(suppressWarnings(sapply(mods, get_df)),
-      c(134, 134, 149, 9, 224),
-      tolerance = 0.01
-    )
-    expect_equal(sapply(mods, get_loglikelihood),
-      c(-411.04, -414.088, -431.688, -22.295, -517.397),
-      tolerance = 0.01
-    )
-    expect_equal(suppressWarnings(sapply(mods, get_sigma)),
-      c(1.75262, 1.77497, 1.77038, 1.29973, 2.08001),
-      tolerance = 0.01
-    )
-    expect_equal(sapply(mods, n_obs),
-      c(240, 240, 240, 16, 240),
-      tolerance = 0.01
-    )
-    expect_equal(sapply(mods, n_parameters),
-      c(105, 105, 90, 6, 15),
-      tolerance = 0.01
-    )
-    expect_equal(sapply(mods, is_mixed_model),
-      c(TRUE, TRUE, TRUE, FALSE, TRUE),
-      tolerance = 0.01
-    )
-    expect_equal(sapply(mods, get_deviance),
-      c(411.603, 422.17, 467, 15.204, 969.125),
-      tolerance = 0.01
-    )
-  })
-
-  test_that("afex_aov: formula and parameters", {
-    # find_formula
-    expect_identical(
-      find_terms(Mc2),
-      list(
-        response = "value",
-        conditional = c("phase", "hour", "treatment", "gender", "exp(age)"),
-        error = "Error(id/(phase * hour))"
-      )
-    )
-    expect_length(find_interactions(Mc2)$conditional, 14)
-    expect_identical(
-      find_variables(Mc2),
-      list(
-        response = "value",
-        fixed = c("treatment", "gender", "age", "phase", "hour"),
-        random = "id"
-      )
-    )
-    expect_identical(
-      find_predictors(Mc2, effects = "all"),
-      list(
-        fixed = c("treatment", "gender", "age", "phase", "hour"),
-        random = "id"
-      )
-    )
-    expect_identical(
-      find_random(Mc2),
-      list(random = "id")
-    )
-    expect_identical(find_response(Mc2), "value")
-  })
-
-
-  test_that("afex_aov: formula and parameters", {
-    expect_identical(dim(get_data(Mc2)), c(240L, 7L))
-    expect_identical(dim(get_statistic(Mc2)), c(19L, 2L))
-
-    expect_identical(dim(get_modelmatrix(Mc2)), c(16L, 7L))
-    expect_length(find_parameters(Mc2), 15)
-    expect_length(get_intercept(Mc2), 15)
-    expect_identical(dim(get_parameters(Mc2)), as.integer(c(15 * 7, 3)))
-    expect_identical(dim(get_varcov(Mc2)), as.integer(c(15 * 7, 15 * 7)))
-
-    expect_length(get_predicted(Mc2), n_obs(Mc2))
-    expect_length(get_residuals(Mc2), n_obs(Mc2))
-  })
-}
+skip_if_not_installed("afex")
+
+data(obk.long, package = "afex")
+
+obk.long$treatment <- as.character(obk.long$treatment)
+obk.long$phase <- as.character(obk.long$phase)
+
+Mc <- suppressWarnings(suppressMessages(
+  afex::aov_car(
+    value ~ treatment * gender + age + Error(id / (phase * hour)),
+    factorize = FALSE,
+    data = obk.long, include_aov = FALSE
+  )
+))
+
+Mc2 <- suppressWarnings(suppressMessages(
+  afex::aov_car(
+    value ~ treatment * gender + exp(age) + Error(id / (phase * hour)),
+    factorize = FALSE,
+    data = obk.long, include_aov = FALSE
+  )
+))
+
+M <- suppressWarnings(suppressMessages(
+  afex::aov_car(
+    value ~ treatment * gender + Error(id / (phase * hour)),
+    data = obk.long, include_aov = FALSE
+  )
+))
+
+B <- suppressWarnings(suppressMessages(
+  afex::aov_car(
+    value ~ treatment * gender + Error(id),
+    data = obk.long, include_aov = FALSE
+  )
+))
+
+W <- suppressWarnings(suppressMessages(
+  afex::aov_car(
+    value ~ Error(id / (phase * hour)),
+    data = obk.long, include_aov = FALSE
+  )
+))
+
+mods <- list(Mc, Mc2, M, B, W)
+
+
+test_that("afex_aov: afex", {
+  # see https://github.com/georgheinze/logistf/pull/54
+  skip_if(
+    "as.character.formula" %in% methods(as.character),
+    "Some package uses `formula.tools::as.character.formula()` which breaks `find_formula()`."
+  )
+
+  expect_identical(unique(unlist(sapply(mods, model_name))), "afex_aov")
+  expect_identical(unique(unlist(sapply(mods, find_algorithm))), "OLS")
+  expect_identical(unique(unlist(sapply(mods, find_statistic))), "F-statistic")
+
+  expect_null(unique(unlist(sapply(mods, find_offset))))
+  expect_null(unique(unlist(sapply(mods, find_random_slopes))))
+  expect_null(unique(unlist(sapply(mods, find_smooth))))
+  expect_null(unique(unlist(sapply(mods, find_weights))))
+  expect_null(unique(unlist(sapply(mods, get_call))))
+  expect_null(unique(unlist(sapply(mods, get_weights))))
+  expect_null(unique(unlist(suppressWarnings(sapply(mods, get_variance)))))
+
+  expect_true(unique(sapply(mods, all_models_equal)))
+  expect_true(unique(sapply(mods, has_intercept)))
+  expect_true(unique(sapply(mods, is_model)))
+  expect_true(unique(sapply(mods, is_model_supported)))
+  expect_false(unique(sapply(mods, is_gam_model)))
+  # expect_false(unique(sapply(mods, is_multivariate)))
+  expect_false(unique(sapply(mods, is_nullmodel)))
+
+  # expect_equal(get_family(Mc2), gaussian())
+  expect_equal(link_function(Mc2), gaussian()$linkfun)
+  expect_equal(link_inverse(Mc2), gaussian()$linkinv)
+})
+
+test_that("afex_aov: model values", {
+  expect_equal(suppressWarnings(sapply(mods, get_auxiliary)),
+    c(1.75262, 1.77497, 1.77038, 1.29973, 2.08001),
+    tolerance = 0.01
+  )
+  expect_equal(suppressWarnings(sapply(mods, get_df)),
+    c(134, 134, 149, 9, 224),
+    tolerance = 0.01
+  )
+  expect_equal(sapply(mods, get_loglikelihood),
+    c(-411.04, -414.088, -431.688, -22.295, -517.397),
+    tolerance = 0.01
+  )
+  expect_equal(suppressWarnings(sapply(mods, get_sigma)),
+    c(1.75262, 1.77497, 1.77038, 1.29973, 2.08001),
+    tolerance = 0.01
+  )
+  expect_equal(sapply(mods, n_obs),
+    c(240, 240, 240, 16, 240),
+    tolerance = 0.01
+  )
+  expect_equal(sapply(mods, n_parameters),
+    c(105, 105, 90, 6, 15),
+    tolerance = 0.01
+  )
+  expect_equal(sapply(mods, is_mixed_model),
+    c(TRUE, TRUE, TRUE, FALSE, TRUE),
+    tolerance = 0.01
+  )
+  expect_equal(sapply(mods, get_deviance),
+    c(411.603, 422.17, 467, 15.204, 969.125),
+    tolerance = 0.01
+  )
+})
+
+test_that("afex_aov: formula and parameters", {
+  # see https://github.com/georgheinze/logistf/pull/54
+  skip_if(
+    "as.character.formula" %in% methods(as.character),
+    "Some package uses `formula.tools::as.character.formula()` which breaks `find_formula()`."
+  )
+
+  # find_formula
+  expect_identical(
+    find_terms(Mc2),
+    list(
+      response = "value",
+      conditional = c("phase", "hour", "treatment", "gender", "exp(age)"),
+      error = "Error(id/(phase * hour))"
+    )
+  )
+  expect_length(find_interactions(Mc2)$conditional, 14)
+  expect_identical(
+    find_variables(Mc2),
+    list(
+      response = "value",
+      fixed = c("treatment", "gender", "age", "phase", "hour"),
+      random = "id"
+    )
+  )
+  expect_identical(
+    find_predictors(Mc2, effects = "all"),
+    list(
+      fixed = c("treatment", "gender", "age", "phase", "hour"),
+      random = "id"
+    )
+  )
+  expect_identical(
+    find_random(Mc2),
+    list(random = "id")
+  )
+  expect_identical(find_response(Mc2), "value")
+})
+
+
+test_that("afex_aov: formula and parameters", {
+  expect_identical(dim(get_data(Mc2)), c(240L, 7L))
+  expect_identical(dim(get_statistic(Mc2)), c(19L, 2L))
+
+  expect_identical(dim(get_modelmatrix(Mc2)), c(16L, 7L))
+  expect_length(find_parameters(Mc2), 15)
+  expect_length(get_intercept(Mc2), 15)
+  expect_identical(dim(get_parameters(Mc2)), as.integer(c(15 * 7, 3)))
+  expect_identical(dim(get_varcov(Mc2)), as.integer(c(15 * 7, 15 * 7)))
+
+  expect_length(get_predicted(Mc2), n_obs(Mc2))
+  expect_length(get_residuals(Mc2), n_obs(Mc2))
+})
diff --git a/tests/testthat/test-all_models_equal.R b/tests/testthat/test-all_models_equal.R
index 7bdb26662..0c6b2f1e7 100644
--- a/tests/testthat/test-all_models_equal.R
+++ b/tests/testthat/test-all_models_equal.R
@@ -1,21 +1,20 @@
-if (skip_if_not_or_load_if_installed("lme4")) {
-  data(mtcars)
-  data(sleepstudy)
+skip_if_not_installed("lme4")
 
-  m1 <- lm(mpg ~ wt + cyl + vs, data = mtcars)
-  m2 <- lm(mpg ~ wt + cyl, data = mtcars)
-  m3 <- lmer(Reaction ~ Days + (1 | Subject), data = sleepstudy)
-  m4 <- glm(formula = vs ~ wt, family = binomial(), data = mtcars)
+data(sleepstudy, package = "lme4")
 
-  test_that("all_models_equal", {
-    expect_true(all_models_equal(m1, m2))
-    expect_false(all_models_equal(m1, m2, mtcars))
-    suppressMessages(expect_message(all_models_equal(m1, m2, mtcars, verbose = TRUE)))
-    expect_false(suppressMessages(all_models_equal(m1, m2, mtcars, verbose = TRUE)))
-    expect_false(all_models_equal(m1, m2, m3))
-    expect_message(expect_false(all_models_equal(m1, m4, m2, m3, verbose = TRUE)))
+m1 <- lm(mpg ~ wt + cyl + vs, data = mtcars)
+m2 <- lm(mpg ~ wt + cyl, data = mtcars)
+m3 <- lme4::lmer(Reaction ~ Days + (1 | Subject), data = sleepstudy)
+m4 <- glm(formula = vs ~ wt, family = binomial(), data = mtcars)
 
-    expect_true(is_model_supported(m1))
-    expect_false(is_model_supported(mtcars))
-  })
-}
+test_that("all_models_equal", {
+  expect_true(all_models_equal(m1, m2))
+  expect_false(all_models_equal(m1, m2, mtcars))
+  suppressMessages(expect_message(all_models_equal(m1, m2, mtcars, verbose = TRUE)))
+  expect_false(suppressMessages(all_models_equal(m1, m2, mtcars, verbose = TRUE)))
+  expect_false(all_models_equal(m1, m2, m3))
+  expect_message(expect_false(all_models_equal(m1, m4, m2, m3, verbose = TRUE)))
+
+  expect_true(is_model_supported(m1))
+  expect_false(is_model_supported(mtcars))
+})
diff --git a/tests/testthat/test-backticks.R b/tests/testthat/test-backticks.R
index c3c551a96..955c882ec 100644
--- a/tests/testthat/test-backticks.R
+++ b/tests/testthat/test-backticks.R
@@ -1,4 +1,3 @@
-data(iris)
 iris$`a m` <- iris$Species
 iris$`Sepal Width` <- iris$Sepal.Width
 dat <<- iris
diff --git a/tests/testthat/test-betabin.R b/tests/testthat/test-betabin.R
index ca2c45563..2fd14998a 100644
--- a/tests/testthat/test-betabin.R
+++ b/tests/testthat/test-betabin.R
@@ -1,132 +1,132 @@
-if (skip_if_not_or_load_if_installed("aod")) {
-  data(dja)
-  m1 <- suppressWarnings(betabin(cbind(y, n - y) ~ group * trisk, ~village, data = dja))
-
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_binomial)
-    expect_true(model_info(m1)$is_betabinomial)
-    expect_true(model_info(m1)$is_mixed)
-    expect_false(model_info(m1)$is_linear)
-  })
-
-  test_that("find_predictors", {
-    expect_identical(find_predictors(m1), list(conditional = c("group", "trisk")))
-    expect_identical(find_predictors(m1, flatten = TRUE), c("group", "trisk"))
-    expect_identical(find_predictors(m1, effects = "random"), list(random = "village"))
-    expect_identical(
-      find_predictors(m1, effects = "all"),
-      list(
-        conditional = c("group", "trisk"),
-        random = "village"
-      )
-    )
-  })
-
-  test_that("find_random", {
-    expect_identical(find_random(m1), list(random = "village"))
-  })
-
-  test_that("get_random", {
-    expect_equal(get_random(m1), dja[, "village", drop = FALSE], ignore_attr = TRUE)
-  })
-
-  test_that("get_varcov", {
-    expect_message(get_varcov(m1))
-    expect_equal(get_varcov(m1, pd_tolerance = NULL), vcov(m1), tolerance = 1e-3)
-  })
-
-  test_that("find_response", {
-    expect_identical(find_response(m1), "cbind(y, n - y)")
-    expect_identical(find_response(m1, combine = FALSE), c("y", "n"))
-  })
-
-  test_that("get_response", {
-    expect_equal(get_response(m1, verbose = FALSE), dja[, c("y", "n")])
-  })
-
-  test_that("get_predictors", {
-    expect_equal(colnames(get_predictors(m1)), c("group", "trisk"))
-  })
-
-  test_that("link_inverse", {
-    expect_equal(link_inverse(m1)(0.2), plogis(0.2), tolerance = 1e-5)
-  })
-
-  test_that("link_function", {
-    expect_equal(link_function(m1)(0.2), qlogis(0.2), tolerance = 1e-5)
-  })
-
-  test_that("get_data", {
-    expect_equal(nrow(get_data(m1, verbose = FALSE)), 75)
-    expect_equal(colnames(get_data(m1, verbose = FALSE)), c("y", "n", "group", "trisk", "village"))
-  })
-
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 2)
-    expect_equal(
-      find_formula(m1),
-      list(
-        conditional = as.formula("cbind(y, n - y) ~ group * trisk"),
-        random = as.formula("~village")
-      ),
-      ignore_attr = TRUE
+skip_if_not_installed("aod")
+
+data(dja, package = "aod")
+m1 <- suppressWarnings(aod::betabin(cbind(y, n - y) ~ group * trisk, ~village, data = dja))
+
+test_that("model_info", {
+  expect_true(model_info(m1)$is_binomial)
+  expect_true(model_info(m1)$is_betabinomial)
+  expect_true(model_info(m1)$is_mixed)
+  expect_false(model_info(m1)$is_linear)
+})
+
+test_that("find_predictors", {
+  expect_identical(find_predictors(m1), list(conditional = c("group", "trisk")))
+  expect_identical(find_predictors(m1, flatten = TRUE), c("group", "trisk"))
+  expect_identical(find_predictors(m1, effects = "random"), list(random = "village"))
+  expect_identical(
+    find_predictors(m1, effects = "all"),
+    list(
+      conditional = c("group", "trisk"),
+      random = "village"
     )
-  })
-
-  test_that("find_variables", {
-    expect_equal(
-      find_variables(m1),
-      list(
-        response = c("y", "n"),
-        conditional = c("group", "trisk"),
-        random = "village"
-      )
+  )
+})
+
+test_that("find_random", {
+  expect_identical(find_random(m1), list(random = "village"))
+})
+
+test_that("get_random", {
+  expect_equal(get_random(m1), dja[, "village", drop = FALSE], ignore_attr = TRUE)
+})
+
+test_that("get_varcov", {
+  expect_message(get_varcov(m1))
+  expect_equal(get_varcov(m1, pd_tolerance = NULL), aod::vcov(m1), tolerance = 1e-3)
+})
+
+test_that("find_response", {
+  expect_identical(find_response(m1), "cbind(y, n - y)")
+  expect_identical(find_response(m1, combine = FALSE), c("y", "n"))
+})
+
+test_that("get_response", {
+  expect_equal(get_response(m1, verbose = FALSE), dja[, c("y", "n")])
+})
+
+test_that("get_predictors", {
+  expect_equal(colnames(get_predictors(m1)), c("group", "trisk"))
+})
+
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), plogis(0.2), tolerance = 1e-5)
+})
+
+test_that("link_function", {
+  expect_equal(link_function(m1)(0.2), qlogis(0.2), tolerance = 1e-5)
+})
+
+test_that("get_data", {
+  expect_equal(nrow(get_data(m1, verbose = FALSE)), 75)
+  expect_equal(colnames(get_data(m1, verbose = FALSE)), c("y", "n", "group", "trisk", "village"))
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1), 2)
+  expect_equal(
+    find_formula(m1),
+    list(
+      conditional = as.formula("cbind(y, n - y) ~ group * trisk"),
+      random = as.formula("~village")
+    ),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_variables", {
+  expect_equal(
+    find_variables(m1),
+    list(
+      response = c("y", "n"),
+      conditional = c("group", "trisk"),
+      random = "village"
     )
-    expect_equal(find_variables(m1, flatten = TRUE), c("y", "n", "group", "trisk", "village"))
-  })
-
-  test_that("n_obs", {
-    expect_equal(n_obs(m1), 75)
-  })
-
-  test_that("find_parameters", {
-    expect_equal(
-      find_parameters(m1),
-      list(
-        conditional = c("(Intercept)", "groupTREAT", "trisk", "groupTREAT:trisk"),
-        random = c(
-          "phi.villageBAK", "phi.villageBAM", "phi.villageBAN",
-          "phi.villageBIJ", "phi.villageBOU", "phi.villageBYD", "phi.villageDEM",
-          "phi.villageDIA", "phi.villageHAM", "phi.villageLAM", "phi.villageLAY",
-          "phi.villageMAF", "phi.villageMAH", "phi.villageMAK", "phi.villageMED",
-          "phi.villageNAB", "phi.villageSAG", "phi.villageSAM", "phi.villageSOU"
-        )
+  )
+  expect_equal(find_variables(m1, flatten = TRUE), c("y", "n", "group", "trisk", "village"))
+})
+
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 75)
+})
+
+test_that("find_parameters", {
+  expect_equal(
+    find_parameters(m1),
+    list(
+      conditional = c("(Intercept)", "groupTREAT", "trisk", "groupTREAT:trisk"),
+      random = c(
+        "phi.villageBAK", "phi.villageBAM", "phi.villageBAN",
+        "phi.villageBIJ", "phi.villageBOU", "phi.villageBYD", "phi.villageDEM",
+        "phi.villageDIA", "phi.villageHAM", "phi.villageLAM", "phi.villageLAY",
+        "phi.villageMAF", "phi.villageMAH", "phi.villageMAK", "phi.villageMED",
+        "phi.villageNAB", "phi.villageSAG", "phi.villageSAM", "phi.villageSOU"
       )
     )
-    expect_equal(nrow(get_parameters(m1)), 4)
-    expect_equal(get_parameters(m1)$Parameter, c("(Intercept)", "groupTREAT", "trisk", "groupTREAT:trisk"))
-  })
-
-  test_that("is_multivariate", {
-    expect_false(is_multivariate(m1))
-  })
-
-  test_that("find_terms", {
-    expect_equal(
-      find_terms(m1),
-      list(
-        response = "cbind(y, n - y)",
-        conditional = c("group", "trisk"),
-        random = "village"
-      )
+  )
+  expect_equal(nrow(get_parameters(m1)), 4)
+  expect_equal(get_parameters(m1)$Parameter, c("(Intercept)", "groupTREAT", "trisk", "groupTREAT:trisk"))
+})
+
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1))
+})
+
+test_that("find_terms", {
+  expect_equal(
+    find_terms(m1),
+    list(
+      response = "cbind(y, n - y)",
+      conditional = c("group", "trisk"),
+      random = "village"
     )
-  })
+  )
+})
 
-  test_that("find_algorithm", {
-    expect_equal(find_algorithm(m1), list(algorithm = "ML"))
-  })
+test_that("find_algorithm", {
+  expect_equal(find_algorithm(m1), list(algorithm = "ML"))
+})
 
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "z-statistic")
-  })
-}
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "z-statistic")
+})
diff --git a/tests/testthat/test-betareg.R b/tests/testthat/test-betareg.R
index 2475ef14c..5ca09a06a 100644
--- a/tests/testthat/test-betareg.R
+++ b/tests/testthat/test-betareg.R
@@ -1,121 +1,102 @@
-if (
-
-  skip_if_not_or_load_if_installed("betareg")) {
-  data("GasolineYield")
-  data("FoodExpenditure")
-
-  m1 <- betareg(yield ~ batch + temp, data = GasolineYield)
-  m2 <- betareg(I(food / income) ~ income + persons, data = FoodExpenditure)
-
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_beta)
-    expect_false(model_info(m1)$is_linear)
-  })
-
-  test_that("find_predictors", {
-    expect_identical(find_predictors(m1), list(conditional = c("batch", "temp")))
-    expect_identical(find_predictors(m1, flatten = TRUE), c("batch", "temp"))
-    expect_null(find_predictors(m1, effects = "random"))
-  })
-
-  test_that("find_response", {
-    expect_identical(find_response(m1), "yield")
-    expect_identical(find_response(m2), "I(food/income)")
-    expect_identical(find_response(m2, combine = FALSE), c("food", "income"))
-  })
-
-  test_that("get_response", {
-    expect_equal(get_response(m1), GasolineYield$yield)
-    expect_equal(get_response(m2), FoodExpenditure[, c("food", "income")])
-  })
-
-  test_that("get_varcov", {
-    expect_equal(get_varcov(m1, component = "all"), vcov(m1), tolerance = 1e-3)
-    expect_equal(get_varcov(m1), vcov(m1)[-12, -12], tolerance = 1e-3)
-  })
-
-  test_that("link_inverse", {
-    expect_identical(link_inverse(m1)(0.2), plogis(0.2))
-  })
-
-  test_that("get_data", {
-    expect_equal(nrow(get_data(m1)), 32)
-    expect_equal(colnames(get_data(m1)), c("yield", "batch", "temp"))
-    expect_equal(nrow(get_data(m2)), 38)
-    expect_equal(
-      colnames(get_data(m2)),
-      c("food", "income", "persons")
+skip_if_not_installed("betareg")
+
+data("GasolineYield", package = "betareg")
+data("FoodExpenditure", package = "betareg")
+
+
+m1 <- betareg::betareg(yield ~ batch + temp, data = GasolineYield)
+m2 <- betareg::betareg(I(food / income) ~ income + persons, data = FoodExpenditure)
+
+test_that("model_info", {
+  expect_true(model_info(m1)$is_beta)
+  expect_false(model_info(m1)$is_linear)
+})
+
+test_that("find_predictors", {
+  expect_identical(find_predictors(m1), list(conditional = c("batch", "temp")))
+  expect_identical(find_predictors(m1, flatten = TRUE), c("batch", "temp"))
+  expect_null(find_predictors(m1, effects = "random"))
+})
+
+test_that("find_response", {
+  expect_identical(find_response(m1), "yield")
+  expect_identical(find_response(m2), "I(food/income)")
+  expect_identical(find_response(m2, combine = FALSE), c("food", "income"))
+})
+
+test_that("get_response", {
+  expect_equal(get_response(m1), GasolineYield$yield)
+  expect_equal(get_response(m2), FoodExpenditure[, c("food", "income")])
+})
+
+test_that("get_varcov", {
+  expect_equal(get_varcov(m1, component = "all"), vcov(m1), tolerance = 1e-3)
+  expect_equal(get_varcov(m1), vcov(m1)[-12, -12], tolerance = 1e-3)
+})
+
+test_that("link_inverse", {
+  expect_identical(link_inverse(m1)(0.2), plogis(0.2))
+})
+
+test_that("get_data", {
+  expect_equal(nrow(get_data(m1)), 32)
+  expect_equal(colnames(get_data(m1)), c("yield", "batch", "temp"))
+  expect_equal(nrow(get_data(m2)), 38)
+  expect_equal(
+    colnames(get_data(m2)),
+    c("food", "income", "persons")
+  )
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1), 1)
+  expect_equal(
+    find_formula(m1),
+    list(conditional = as.formula("yield ~ batch + temp")),
+    ignore_attr = TRUE
+  )
+  expect_equal(
+    find_formula(m2),
+    list(conditional = as.formula("I(food/income) ~ income + persons")),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_variables", {
+  expect_equal(
+    find_variables(m1),
+    list(
+      response = "yield",
+      conditional = c("batch", "temp")
     )
-  })
-
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 1)
-    expect_equal(
-      find_formula(m1),
-      list(conditional = as.formula("yield ~ batch + temp")),
-      ignore_attr = TRUE
-    )
-    expect_equal(
-      find_formula(m2),
-      list(conditional = as.formula("I(food/income) ~ income + persons")),
-      ignore_attr = TRUE
-    )
-  })
-
-  test_that("find_variables", {
-    expect_equal(
-      find_variables(m1),
-      list(
-        response = "yield",
-        conditional = c("batch", "temp")
-      )
-    )
-    expect_equal(
-      find_variables(m1, flatten = TRUE),
-      c("yield", "batch", "temp")
-    )
-    expect_equal(
-      find_variables(m2, flatten = TRUE),
-      c("food", "income", "persons")
-    )
-  })
-
-  test_that("n_obs", {
-    expect_equal(n_obs(m1), 32)
-  })
-
-  test_that("is_multivariate", {
-    expect_false(is_multivariate(m1))
-  })
-
-  test_that("linkfun", {
-    expect_false(is.null(link_function(m1)))
-  })
-
-  test_that("find_parameters", {
-    expect_equal(
-      find_parameters(m1),
-      list(
-        conditional = c(
-          "(Intercept)",
-          "batch1",
-          "batch2",
-          "batch3",
-          "batch4",
-          "batch5",
-          "batch6",
-          "batch7",
-          "batch8",
-          "batch9",
-          "temp"
-        ),
-        precision = "(phi)"
-      )
-    )
-    expect_equal(nrow(get_parameters(m1)), 12)
-    expect_equal(
-      get_parameters(m1)$Parameter,
-      c(
+  )
+  expect_equal(
+    find_variables(m1, flatten = TRUE),
+    c("yield", "batch", "temp")
+  )
+  expect_equal(
+    find_variables(m2, flatten = TRUE),
+    c("food", "income", "persons")
+  )
+})
+
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 32)
+})
+
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1))
+})
+
+test_that("linkfun", {
+  expect_false(is.null(link_function(m1)))
+})
+
+test_that("find_parameters", {
+  expect_equal(
+    find_parameters(m1),
+    list(
+      conditional = c(
         "(Intercept)",
         "batch1",
         "batch2",
@@ -126,52 +107,70 @@ if (
         "batch7",
         "batch8",
         "batch9",
-        "temp",
-        "(phi)"
-      )
+        "temp"
+      ),
+      precision = "(phi)"
+    )
+  )
+  expect_equal(nrow(get_parameters(m1)), 12)
+  expect_equal(
+    get_parameters(m1)$Parameter,
+    c(
+      "(Intercept)",
+      "batch1",
+      "batch2",
+      "batch3",
+      "batch4",
+      "batch5",
+      "batch6",
+      "batch7",
+      "batch8",
+      "batch9",
+      "temp",
+      "(phi)"
     )
-  })
-
-  test_that("find_terms", {
-    expect_equal(
-      find_terms(m2),
-      list(
-        response = "I(food/income)",
-        conditional = c("income", "persons")
-      )
+  )
+})
+
+test_that("find_terms", {
+  expect_equal(
+    find_terms(m2),
+    list(
+      response = "I(food/income)",
+      conditional = c("income", "persons")
     )
-  })
-
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "z-statistic")
-    expect_identical(find_statistic(m2), "z-statistic")
-  })
-
-  test_that("get_modelmatrix", {
-    mm <- get_modelmatrix(m1)
-    expect_true(is.matrix(mm))
-    expect_equal(dim(mm), c(32, 11))
-    mm <- get_modelmatrix(m1, data = head(GasolineYield))
-    expect_true(is.matrix(mm))
-    expect_equal(dim(mm), c(6, 11))
-  })
-
-  test_that("get_predicted", {
-    p <- suppressWarnings(get_predicted(m1))
-    expect_s3_class(p, "get_predicted")
-    expect_equal(length(p), 32)
-    p <- suppressWarnings(get_predicted(m1, data = head(GasolineYield)))
-    expect_s3_class(p, "get_predicted")
-    expect_equal(length(p), 6)
-
-    # delta method does not work, so we omit SE and issue warning
-    expect_warning(get_predicted(m2, predict = "expectation"))
-    expect_warning(get_predicted(m2, predict = "link"), NA)
-    p1 <- suppressWarnings(get_predicted(m2, predict = "expectation", ci = 0.95))
-    p2 <- get_predicted(m2, predict = "link", ci = 0.95)
-    p1 <- data.frame(p1)
-    p2 <- data.frame(p2)
-    expect_true(!"SE" %in% colnames(p1))
-    expect_true("SE" %in% colnames(p2))
-  })
-}
+  )
+})
+
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "z-statistic")
+  expect_identical(find_statistic(m2), "z-statistic")
+})
+
+test_that("get_modelmatrix", {
+  mm <- get_modelmatrix(m1)
+  expect_true(is.matrix(mm))
+  expect_equal(dim(mm), c(32, 11))
+  mm <- get_modelmatrix(m1, data = head(GasolineYield))
+  expect_true(is.matrix(mm))
+  expect_equal(dim(mm), c(6, 11))
+})
+
+test_that("get_predicted", {
+  p <- suppressWarnings(get_predicted(m1))
+  expect_s3_class(p, "get_predicted")
+  expect_equal(length(p), 32)
+  p <- suppressWarnings(get_predicted(m1, data = head(GasolineYield)))
+  expect_s3_class(p, "get_predicted")
+  expect_equal(length(p), 6)
+
+  # delta method does not work, so we omit SE and issue warning
+  expect_warning(get_predicted(m2, predict = "expectation"))
+  expect_warning(get_predicted(m2, predict = "link"), NA)
+  p1 <- suppressWarnings(get_predicted(m2, predict = "expectation", ci = 0.95))
+  p2 <- get_predicted(m2, predict = "link", ci = 0.95)
+  p1 <- data.frame(p1)
+  p2 <- data.frame(p2)
+  expect_true(!"SE" %in% colnames(p1))
+  expect_true("SE" %in% colnames(p2))
+})
diff --git a/tests/testthat/test-bife.R b/tests/testthat/test-bife.R
index 3fde7d6be..c8c545082 100644
--- a/tests/testthat/test-bife.R
+++ b/tests/testthat/test-bife.R
@@ -1,8 +1,7 @@
 skip_if_not_installed("bife")
-skip_if_not_or_load_if_installed("bife")
 
 dataset <- bife::psid
-mod <- bife(LFP ~ AGE + I(INCH / 1000) + KID1 + KID2 + KID3 | ID, data = dataset)
+mod <- bife::bife(LFP ~ AGE + I(INCH / 1000) + KID1 + KID2 + KID3 | ID, data = dataset)
 
 test_that("get_predicted", {
   # link
diff --git a/tests/testthat/test-bigglm.R b/tests/testthat/test-bigglm.R
index 2101f2a67..3f57fd055 100644
--- a/tests/testthat/test-bigglm.R
+++ b/tests/testthat/test-bigglm.R
@@ -1,132 +1,133 @@
-if (skip_if_not_or_load_if_installed("glmmTMB") && skip_if_not_or_load_if_installed("biglm")) {
-  data(Salamanders)
-  Salamanders$cover <- abs(Salamanders$cover)
-
-  m1 <- bigglm(count ~ mined + log(cover) + sample,
-    family = poisson(),
-    data = Salamanders
+skip_if_not_installed("glmmTMB")
+skip_if_not_installed("biglm")
+
+data(Salamanders, package = "glmmTMB")
+Salamanders$cover <- abs(Salamanders$cover)
+
+m1 <- biglm::bigglm(count ~ mined + log(cover) + sample,
+  family = poisson(),
+  data = Salamanders
+)
+
+test_that("model_info", {
+  expect_true(model_info(m1)$is_poisson)
+  expect_true(model_info(m1)$is_count)
+  expect_false(model_info(m1)$is_negbin)
+  expect_false(model_info(m1)$is_binomial)
+  expect_false(model_info(m1)$is_linear)
+})
+
+test_that("find_predictors", {
+  expect_identical(find_predictors(m1), list(conditional = c("mined", "cover", "sample")))
+  expect_identical(
+    find_predictors(m1, flatten = TRUE),
+    c("mined", "cover", "sample")
   )
+  expect_null(find_predictors(m1, effects = "random"))
+})
 
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_poisson)
-    expect_true(model_info(m1)$is_count)
-    expect_false(model_info(m1)$is_negbin)
-    expect_false(model_info(m1)$is_binomial)
-    expect_false(model_info(m1)$is_linear)
-  })
-
-  test_that("find_predictors", {
-    expect_identical(find_predictors(m1), list(conditional = c("mined", "cover", "sample")))
-    expect_identical(
-      find_predictors(m1, flatten = TRUE),
-      c("mined", "cover", "sample")
-    )
-    expect_null(find_predictors(m1, effects = "random"))
-  })
+test_that("find_random", {
+  expect_null(find_random(m1))
+})
 
-  test_that("find_random", {
-    expect_null(find_random(m1))
-  })
+test_that("get_random", {
+  expect_warning(get_random(m1))
+})
 
-  test_that("get_random", {
-    expect_warning(get_random(m1))
-  })
+test_that("get_varcov", {
+  expect_equal(vcov(m1), get_varcov(m1), tolerance = 1e-3)
+})
 
-  test_that("get_varcov", {
-    expect_equal(vcov(m1), get_varcov(m1), tolerance = 1e-3)
-  })
+test_that("find_response", {
+  expect_identical(find_response(m1), "count")
+})
 
-  test_that("find_response", {
-    expect_identical(find_response(m1), "count")
-  })
+test_that("get_response", {
+  expect_equal(get_response(m1), Salamanders$count)
+})
 
-  test_that("get_response", {
-    expect_equal(get_response(m1), Salamanders$count)
-  })
+test_that("get_predictors", {
+  expect_equal(
+    colnames(get_predictors(m1)),
+    c("mined", "cover", "sample")
+  )
+})
 
-  test_that("get_predictors", {
-    expect_equal(
-      colnames(get_predictors(m1)),
-      c("mined", "cover", "sample")
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), exp(0.2), tolerance = 1e-5)
+})
+
+test_that("get_data", {
+  expect_equal(nrow(get_data(m1)), 644)
+  expect_equal(
+    colnames(get_data(m1)),
+    c("count", "mined", "cover", "sample")
+  )
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1), 1)
+  expect_equal(
+    find_formula(m1),
+    list(conditional = as.formula("count ~ mined + log(cover) + sample")),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_variables", {
+  expect_equal(
+    find_variables(m1),
+    list(
+      response = "count",
+      conditional = c("mined", "cover", "sample")
     )
-  })
+  )
+  expect_equal(
+    find_variables(m1, flatten = TRUE),
+    c("count", "mined", "cover", "sample")
+  )
+})
 
-  test_that("link_inverse", {
-    expect_equal(link_inverse(m1)(0.2), exp(0.2), tolerance = 1e-5)
-  })
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 644)
+})
 
-  test_that("get_data", {
-    expect_equal(nrow(get_data(m1)), 644)
-    expect_equal(
-      colnames(get_data(m1)),
-      c("count", "mined", "cover", "sample")
-    )
-  })
-
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 1)
-    expect_equal(
-      find_formula(m1),
-      list(conditional = as.formula("count ~ mined + log(cover) + sample")),
-      ignore_attr = TRUE
-    )
-  })
-
-  test_that("find_variables", {
-    expect_equal(
-      find_variables(m1),
-      list(
-        response = "count",
-        conditional = c("mined", "cover", "sample")
-      )
-    )
-    expect_equal(
-      find_variables(m1, flatten = TRUE),
-      c("count", "mined", "cover", "sample")
-    )
-  })
-
-  test_that("n_obs", {
-    expect_equal(n_obs(m1), 644)
-  })
-
-  test_that("linkfun", {
-    expect_false(is.null(link_function(m1)))
-  })
-
-  test_that("find_parameters", {
-    expect_equal(
-      find_parameters(m1),
-      list(
-        conditional = c("(Intercept)", "minedno", "log(cover)", "sample")
-      )
-    )
-    expect_equal(nrow(get_parameters(m1)), 4)
-    expect_equal(
-      get_parameters(m1)$Parameter,
-      c("(Intercept)", "minedno", "log(cover)", "sample")
+test_that("linkfun", {
+  expect_false(is.null(link_function(m1)))
+})
+
+test_that("find_parameters", {
+  expect_equal(
+    find_parameters(m1),
+    list(
+      conditional = c("(Intercept)", "minedno", "log(cover)", "sample")
     )
-  })
-
-  test_that("is_multivariate", {
-    expect_false(is_multivariate(m1))
-  })
-
-  test_that("find_terms", {
-    expect_equal(
-      find_terms(m1),
-      list(
-        response = "count",
-        conditional = c("mined", "log(cover)", "sample")
-      )
+  )
+  expect_equal(nrow(get_parameters(m1)), 4)
+  expect_equal(
+    get_parameters(m1)$Parameter,
+    c("(Intercept)", "minedno", "log(cover)", "sample")
+  )
+})
+
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1))
+})
+
+test_that("find_terms", {
+  expect_equal(
+    find_terms(m1),
+    list(
+      response = "count",
+      conditional = c("mined", "log(cover)", "sample")
     )
-  })
+  )
+})
 
-  test_that("find_algorithm", {
-    expect_equal(find_algorithm(m1), list(algorithm = "ML"))
-  })
+test_that("find_algorithm", {
+  expect_equal(find_algorithm(m1), list(algorithm = "ML"))
+})
 
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "z-statistic")
-  })
-}
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "z-statistic")
+})
diff --git a/tests/testthat/test-blmer.R b/tests/testthat/test-blmer.R
index 3f83bfabc..6dcfa5aa6 100644
--- a/tests/testthat/test-blmer.R
+++ b/tests/testthat/test-blmer.R
@@ -1,323 +1,324 @@
-if (skip_if_not_or_load_if_installed("blme")) {
-  data(sleepstudy)
-  set.seed(123)
-  sleepstudy$mygrp <- sample(1:5, size = 180, replace = TRUE)
-  sleepstudy$mysubgrp <- NA
-  for (i in 1:5) {
-    filter_group <- sleepstudy$mygrp == i
-    sleepstudy$mysubgrp[filter_group] <-
-      sample(1:30, size = sum(filter_group), replace = TRUE)
-  }
+skip_if_not_installed("blme")
+skip_if_not_installed("lme4")
 
-  m1 <- blmer(Reaction ~ Days + (1 + Days | Subject),
-    data = sleepstudy,
-    cov.prior = NULL
-  )
+data(sleepstudy, package = "lme4")
+set.seed(123)
+sleepstudy$mygrp <- sample(1:5, size = 180, replace = TRUE)
+sleepstudy$mysubgrp <- NA
+for (i in 1:5) {
+  filter_group <- sleepstudy$mygrp == i
+  sleepstudy$mysubgrp[filter_group] <-
+    sample(1:30, size = sum(filter_group), replace = TRUE)
+}
 
-  m2 <- suppressWarnings(blmer(
-    Reaction ~ Days + (1 | mygrp / mysubgrp) + (1 | Subject),
-    data = sleepstudy,
-    cov.prior = wishart
-  ))
+m1 <- blme::blmer(Reaction ~ Days + (1 + Days | Subject),
+  data = sleepstudy,
+  cov.prior = NULL
+)
 
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_linear)
-    expect_true(model_info(m2)$is_linear)
-    expect_true(model_info(m1)$is_bayesian)
-  })
+m2 <- suppressWarnings(blme::blmer(
+  Reaction ~ Days + (1 | mygrp / mysubgrp) + (1 | Subject),
+  data = sleepstudy,
+  cov.prior = wishart
+))
 
-  test_that("get_varcov", {
-    expect_equal(as.matrix(vcov(m1)), get_varcov(m1), tolerance = 1e-3)
-  })
+test_that("model_info", {
+  expect_true(model_info(m1)$is_linear)
+  expect_true(model_info(m2)$is_linear)
+  expect_true(model_info(m1)$is_bayesian)
+})
 
-  test_that("find_predictors", {
-    expect_equal(
-      find_predictors(m1, effects = "all"),
-      list(conditional = "Days", random = "Subject")
-    )
-    expect_equal(
-      find_predictors(m1, effects = "all", flatten = TRUE),
-      c("Days", "Subject")
-    )
-    expect_equal(
-      find_predictors(m1, effects = "fixed"),
-      list(conditional = "Days")
-    )
-    expect_equal(
-      find_predictors(m1, effects = "fixed", flatten = TRUE),
-      "Days"
-    )
-    expect_equal(
-      find_predictors(m1, effects = "random"),
-      list(random = "Subject")
-    )
-    expect_equal(
-      find_predictors(m1, effects = "random", flatten = TRUE),
-      "Subject"
-    )
-    expect_equal(
-      find_predictors(m2, effects = "all"),
-      list(
-        conditional = "Days",
-        random = c("mysubgrp", "mygrp", "Subject")
-      )
-    )
-    expect_equal(
-      find_predictors(m2, effects = "all", flatten = TRUE),
-      c("Days", "mysubgrp", "mygrp", "Subject")
-    )
-    expect_equal(
-      find_predictors(m2, effects = "fixed"),
-      list(conditional = "Days")
-    )
-    expect_equal(find_predictors(m2, effects = "random"), list(random = c("mysubgrp", "mygrp", "Subject")))
-    expect_null(find_predictors(m2, effects = "all", component = "zi"))
-    expect_null(find_predictors(m2, effects = "fixed", component = "zi"))
-    expect_null(find_predictors(m2, effects = "random", component = "zi"))
-  })
+test_that("get_varcov", {
+  expect_equal(as.matrix(vcov(m1)), get_varcov(m1), tolerance = 1e-3)
+})
 
-  test_that("find_random", {
-    expect_equal(find_random(m1), list(random = "Subject"))
-    expect_equal(find_random(m1, flatten = TRUE), "Subject")
-    expect_equal(find_random(m2), list(random = c("mysubgrp:mygrp", "mygrp", "Subject")))
-    expect_equal(find_random(m2, split_nested = TRUE), list(random = c("mysubgrp", "mygrp", "Subject")))
-    expect_equal(
-      find_random(m2, flatten = TRUE),
-      c("mysubgrp:mygrp", "mygrp", "Subject")
-    )
-    expect_equal(
-      find_random(m2, split_nested = TRUE, flatten = TRUE),
-      c("mysubgrp", "mygrp", "Subject")
+test_that("find_predictors", {
+  expect_equal(
+    find_predictors(m1, effects = "all"),
+    list(conditional = "Days", random = "Subject")
+  )
+  expect_equal(
+    find_predictors(m1, effects = "all", flatten = TRUE),
+    c("Days", "Subject")
+  )
+  expect_equal(
+    find_predictors(m1, effects = "fixed"),
+    list(conditional = "Days")
+  )
+  expect_equal(
+    find_predictors(m1, effects = "fixed", flatten = TRUE),
+    "Days"
+  )
+  expect_equal(
+    find_predictors(m1, effects = "random"),
+    list(random = "Subject")
+  )
+  expect_equal(
+    find_predictors(m1, effects = "random", flatten = TRUE),
+    "Subject"
+  )
+  expect_equal(
+    find_predictors(m2, effects = "all"),
+    list(
+      conditional = "Days",
+      random = c("mysubgrp", "mygrp", "Subject")
     )
-  })
+  )
+  expect_equal(
+    find_predictors(m2, effects = "all", flatten = TRUE),
+    c("Days", "mysubgrp", "mygrp", "Subject")
+  )
+  expect_equal(
+    find_predictors(m2, effects = "fixed"),
+    list(conditional = "Days")
+  )
+  expect_equal(find_predictors(m2, effects = "random"), list(random = c("mysubgrp", "mygrp", "Subject")))
+  expect_null(find_predictors(m2, effects = "all", component = "zi"))
+  expect_null(find_predictors(m2, effects = "fixed", component = "zi"))
+  expect_null(find_predictors(m2, effects = "random", component = "zi"))
+})
 
-  test_that("find_response", {
-    expect_identical(find_response(m1), "Reaction")
-    expect_identical(find_response(m2), "Reaction")
-  })
+test_that("find_random", {
+  expect_equal(find_random(m1), list(random = "Subject"))
+  expect_equal(find_random(m1, flatten = TRUE), "Subject")
+  expect_equal(find_random(m2), list(random = c("mysubgrp:mygrp", "mygrp", "Subject")))
+  expect_equal(find_random(m2, split_nested = TRUE), list(random = c("mysubgrp", "mygrp", "Subject")))
+  expect_equal(
+    find_random(m2, flatten = TRUE),
+    c("mysubgrp:mygrp", "mygrp", "Subject")
+  )
+  expect_equal(
+    find_random(m2, split_nested = TRUE, flatten = TRUE),
+    c("mysubgrp", "mygrp", "Subject")
+  )
+})
 
-  test_that("get_response", {
-    expect_equal(get_response(m1), sleepstudy$Reaction)
-  })
+test_that("find_response", {
+  expect_identical(find_response(m1), "Reaction")
+  expect_identical(find_response(m2), "Reaction")
+})
 
-  test_that("link_inverse", {
-    expect_identical(link_inverse(m1)(0.2), 0.2)
-    expect_identical(link_inverse(m2)(0.2), 0.2)
-  })
+test_that("get_response", {
+  expect_equal(get_response(m1), sleepstudy$Reaction)
+})
 
-  test_that("get_data", {
-    expect_equal(colnames(get_data(m1)), c("Reaction", "Days", "Subject"))
-    expect_equal(colnames(get_data(m1, effects = "all")), c("Reaction", "Days", "Subject"))
-    expect_equal(colnames(get_data(m1, effects = "random")), "Subject")
-    expect_equal(
-      colnames(get_data(m2)),
-      c("Reaction", "Days", "mysubgrp", "mygrp", "Subject")
-    )
-    expect_equal(
-      colnames(get_data(m2, effects = "all")),
-      c("Reaction", "Days", "mysubgrp", "mygrp", "Subject")
-    )
-    expect_equal(colnames(get_data(m2, effects = "random")), c("mysubgrp", "mygrp", "Subject"))
-  })
+test_that("link_inverse", {
+  expect_identical(link_inverse(m1)(0.2), 0.2)
+  expect_identical(link_inverse(m2)(0.2), 0.2)
+})
 
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 2)
-    expect_length(find_formula(m2), 2)
-    expect_equal(
-      find_formula(m1, component = "conditional"),
-      list(
-        conditional = as.formula("Reaction ~ Days"),
-        random = as.formula("~1 + Days | Subject")
-      ),
-      ignore_attr = TRUE
-    )
-    expect_equal(
-      find_formula(m2, component = "conditional"),
-      list(
-        conditional = as.formula("Reaction ~ Days"),
-        random = list(
-          as.formula("~1 | mysubgrp:mygrp"),
-          as.formula("~1 | mygrp"),
-          as.formula("~1 | Subject")
-        )
-      ),
-      ignore_attr = TRUE
-    )
-  })
+test_that("get_data", {
+  expect_equal(colnames(get_data(m1)), c("Reaction", "Days", "Subject"))
+  expect_equal(colnames(get_data(m1, effects = "all")), c("Reaction", "Days", "Subject"))
+  expect_equal(colnames(get_data(m1, effects = "random")), "Subject")
+  expect_equal(
+    colnames(get_data(m2)),
+    c("Reaction", "Days", "mysubgrp", "mygrp", "Subject")
+  )
+  expect_equal(
+    colnames(get_data(m2, effects = "all")),
+    c("Reaction", "Days", "mysubgrp", "mygrp", "Subject")
+  )
+  expect_equal(colnames(get_data(m2, effects = "random")), c("mysubgrp", "mygrp", "Subject"))
+})
 
-  test_that("find_terms", {
-    expect_identical(
-      find_terms(m1),
-      list(
-        response = "Reaction",
-        conditional = "Days",
-        random = c("Days", "Subject")
-      )
-    )
-    expect_identical(
-      find_terms(m1, flatten = TRUE),
-      c("Reaction", "Days", "Subject")
-    )
-    expect_identical(
-      find_terms(m2),
-      list(
-        response = "Reaction",
-        conditional = "Days",
-        random = c("mysubgrp", "mygrp", "Subject")
+test_that("find_formula", {
+  expect_length(find_formula(m1), 2)
+  expect_length(find_formula(m2), 2)
+  expect_equal(
+    find_formula(m1, component = "conditional"),
+    list(
+      conditional = as.formula("Reaction ~ Days"),
+      random = as.formula("~1 + Days | Subject")
+    ),
+    ignore_attr = TRUE
+  )
+  expect_equal(
+    find_formula(m2, component = "conditional"),
+    list(
+      conditional = as.formula("Reaction ~ Days"),
+      random = list(
+        as.formula("~1 | mysubgrp:mygrp"),
+        as.formula("~1 | mygrp"),
+        as.formula("~1 | Subject")
       )
+    ),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_terms", {
+  expect_identical(
+    find_terms(m1),
+    list(
+      response = "Reaction",
+      conditional = "Days",
+      random = c("Days", "Subject")
     )
-    expect_identical(
-      find_terms(m2, flatten = TRUE),
-      c("Reaction", "Days", "mysubgrp", "mygrp", "Subject")
+  )
+  expect_identical(
+    find_terms(m1, flatten = TRUE),
+    c("Reaction", "Days", "Subject")
+  )
+  expect_identical(
+    find_terms(m2),
+    list(
+      response = "Reaction",
+      conditional = "Days",
+      random = c("mysubgrp", "mygrp", "Subject")
     )
-  })
+  )
+  expect_identical(
+    find_terms(m2, flatten = TRUE),
+    c("Reaction", "Days", "mysubgrp", "mygrp", "Subject")
+  )
+})
 
-  test_that("find_variables", {
-    expect_identical(
-      find_variables(m1),
-      list(
-        response = "Reaction",
-        conditional = "Days",
-        random = "Subject"
-      )
+test_that("find_variables", {
+  expect_identical(
+    find_variables(m1),
+    list(
+      response = "Reaction",
+      conditional = "Days",
+      random = "Subject"
     )
-  })
+  )
+})
 
-  test_that("get_response", {
-    expect_identical(get_response(m1), sleepstudy$Reaction)
-  })
+test_that("get_response", {
+  expect_identical(get_response(m1), sleepstudy$Reaction)
+})
 
-  test_that("get_predictors", {
-    expect_identical(colnames(get_predictors(m1)), "Days")
-    expect_identical(colnames(get_predictors(m2)), "Days")
-  })
+test_that("get_predictors", {
+  expect_identical(colnames(get_predictors(m1)), "Days")
+  expect_identical(colnames(get_predictors(m2)), "Days")
+})
 
-  test_that("get_random", {
-    expect_identical(colnames(get_random(m1)), "Subject")
-    expect_identical(colnames(get_random(m2)), c("mysubgrp", "mygrp", "Subject"))
-  })
+test_that("get_random", {
+  expect_identical(colnames(get_random(m1)), "Subject")
+  expect_identical(colnames(get_random(m2)), c("mysubgrp", "mygrp", "Subject"))
+})
 
-  test_that("clean_names", {
-    expect_identical(clean_names(m1), c("Reaction", "Days", "Subject"))
-    expect_identical(
-      clean_names(m2),
-      c("Reaction", "Days", "mysubgrp", "mygrp", "Subject")
-    )
-  })
+test_that("clean_names", {
+  expect_identical(clean_names(m1), c("Reaction", "Days", "Subject"))
+  expect_identical(
+    clean_names(m2),
+    c("Reaction", "Days", "mysubgrp", "mygrp", "Subject")
+  )
+})
 
-  test_that("linkfun", {
-    expect_false(is.null(link_function(m1)))
-    expect_false(is.null(link_function(m2)))
-  })
+test_that("linkfun", {
+  expect_false(is.null(link_function(m1)))
+  expect_false(is.null(link_function(m2)))
+})
 
-  test_that("find_parameters", {
-    expect_equal(
-      find_parameters(m1),
-      list(
-        conditional = c("(Intercept)", "Days"),
-        random = list(Subject = c("(Intercept)", "Days"))
-      )
+test_that("find_parameters", {
+  expect_equal(
+    find_parameters(m1),
+    list(
+      conditional = c("(Intercept)", "Days"),
+      random = list(Subject = c("(Intercept)", "Days"))
     )
-    expect_equal(nrow(get_parameters(m1)), 2)
-    expect_equal(get_parameters(m1)$Parameter, c("(Intercept)", "Days"))
+  )
+  expect_equal(nrow(get_parameters(m1)), 2)
+  expect_equal(get_parameters(m1)$Parameter, c("(Intercept)", "Days"))
 
-    expect_equal(
-      find_parameters(m2),
-      list(
-        conditional = c("(Intercept)", "Days"),
-        random = list(
-          `mysubgrp:mygrp` = "(Intercept)",
-          Subject = "(Intercept)",
-          mygrp = "(Intercept)"
-        )
+  expect_equal(
+    find_parameters(m2),
+    list(
+      conditional = c("(Intercept)", "Days"),
+      random = list(
+        `mysubgrp:mygrp` = "(Intercept)",
+        Subject = "(Intercept)",
+        mygrp = "(Intercept)"
       )
     )
+  )
 
-    expect_equal(nrow(get_parameters(m2)), 2)
-    expect_equal(get_parameters(m2)$Parameter, c("(Intercept)", "Days"))
-    expect_equal(
-      names(get_parameters(m2, effects = "random")),
-      c("mysubgrp:mygrp", "Subject", "mygrp")
-    )
-  })
+  expect_equal(nrow(get_parameters(m2)), 2)
+  expect_equal(get_parameters(m2)$Parameter, c("(Intercept)", "Days"))
+  expect_equal(
+    names(get_parameters(m2, effects = "random")),
+    c("mysubgrp:mygrp", "Subject", "mygrp")
+  )
+})
 
-  test_that("is_multivariate", {
-    expect_false(is_multivariate(m1))
-    expect_false(is_multivariate(m2))
-  })
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1))
+  expect_false(is_multivariate(m2))
+})
 
-  test_that("get_variance", {
-    skip_on_cran()
+test_that("get_variance", {
+  skip_on_cran()
 
-    expect_equal(
-      get_variance(m1),
-      list(
-        var.fixed = 908.9534,
-        var.random = 1698.084,
-        var.residual = 654.94,
-        var.distribution = 654.94,
-        var.dispersion = 0,
-        var.intercept = c(Subject = 612.1002),
-        var.slope = c(Subject.Days = 35.07171),
-        cor.slope_intercept = c(Subject = 0.06555124)
-      ),
-      tolerance = 1e-1
-    )
+  expect_equal(
+    get_variance(m1),
+    list(
+      var.fixed = 908.9534,
+      var.random = 1698.084,
+      var.residual = 654.94,
+      var.distribution = 654.94,
+      var.dispersion = 0,
+      var.intercept = c(Subject = 612.1002),
+      var.slope = c(Subject.Days = 35.07171),
+      cor.slope_intercept = c(Subject = 0.06555124)
+    ),
+    tolerance = 1e-1
+  )
 
-    expect_equal(get_variance_fixed(m1),
-      c(var.fixed = 908.9534),
-      tolerance = 1e-1
-    )
-    expect_equal(get_variance_random(m1),
-      c(var.random = 1698.084),
-      tolerance = 1e-1
-    )
-    expect_equal(
-      get_variance_residual(m1),
-      c(var.residual = 654.94),
-      tolerance = 1e-1
-    )
-    expect_equal(
-      get_variance_distribution(m1),
-      c(var.distribution = 654.94),
-      tolerance = 1e-1
-    )
-    expect_equal(get_variance_dispersion(m1),
-      c(var.dispersion = 0),
-      tolerance = 1e-1
-    )
+  expect_equal(get_variance_fixed(m1),
+    c(var.fixed = 908.9534),
+    tolerance = 1e-1
+  )
+  expect_equal(get_variance_random(m1),
+    c(var.random = 1698.084),
+    tolerance = 1e-1
+  )
+  expect_equal(
+    get_variance_residual(m1),
+    c(var.residual = 654.94),
+    tolerance = 1e-1
+  )
+  expect_equal(
+    get_variance_distribution(m1),
+    c(var.distribution = 654.94),
+    tolerance = 1e-1
+  )
+  expect_equal(get_variance_dispersion(m1),
+    c(var.dispersion = 0),
+    tolerance = 1e-1
+  )
 
-    expect_equal(
-      get_variance_intercept(m1),
-      c(var.intercept.Subject = 612.1002),
-      tolerance = 1e-1
-    )
-    expect_equal(
-      get_variance_slope(m1),
-      c(var.slope.Subject.Days = 35.07171),
-      tolerance = 1e-1
-    )
-    expect_equal(
-      get_correlation_slope_intercept(m1),
-      c(cor.slope_intercept.Subject = 0.06555124),
-      tolerance = 1e-1
-    )
-  })
+  expect_equal(
+    get_variance_intercept(m1),
+    c(var.intercept.Subject = 612.1002),
+    tolerance = 1e-1
+  )
+  expect_equal(
+    get_variance_slope(m1),
+    c(var.slope.Subject.Days = 35.07171),
+    tolerance = 1e-1
+  )
+  expect_equal(
+    get_correlation_slope_intercept(m1),
+    c(cor.slope_intercept.Subject = 0.06555124),
+    tolerance = 1e-1
+  )
+})
 
-  test_that("find_algorithm", {
-    expect_equal(
-      find_algorithm(m1),
-      list(algorithm = "REML", optimizer = "nloptwrap")
-    )
-  })
+test_that("find_algorithm", {
+  expect_equal(
+    find_algorithm(m1),
+    list(algorithm = "REML", optimizer = "nloptwrap")
+  )
+})
 
-  test_that("find_random_slopes", {
-    expect_equal(find_random_slopes(m1), list(random = "Days"))
-    expect_null(find_random_slopes(m2))
-  })
+test_that("find_random_slopes", {
+  expect_equal(find_random_slopes(m1), list(random = "Days"))
+  expect_null(find_random_slopes(m2))
+})
 
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "t-statistic")
-    expect_identical(find_statistic(m2), "t-statistic")
-  })
-}
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "t-statistic")
+  expect_identical(find_statistic(m2), "t-statistic")
+})
diff --git a/tests/testthat/test-brms.R b/tests/testthat/test-brms.R
index 28c58aa07..05aa589d3 100644
--- a/tests/testthat/test-brms.R
+++ b/tests/testthat/test-brms.R
@@ -1,864 +1,865 @@
-if (skip_if_not_or_load_if_installed("brms")) {
-  # Model fitting -----------------------------------------------------------
-
-  m1 <- suppressWarnings(insight::download_model("brms_mixed_6"))
-  m2 <- insight::download_model("brms_mv_4")
-  m3 <- insight::download_model("brms_2")
-  m4 <- insight::download_model("brms_zi_3")
-  m5 <- insight::download_model("brms_mv_5")
-  m6 <- insight::download_model("brms_corr_re1")
-  m7 <- suppressWarnings(insight::download_model("brms_mixed_8"))
-  m8 <- insight::download_model("brms_ordinal_1")
-
-  # Tests -------------------------------------------------------------------
-  test_that("get_predicted.brmsfit: ordinal dv", {
-    skip_if_not_installed("bayestestR")
-
-    pred1 <- get_predicted(m8, ci = 0.95)
-    pred2 <- get_predicted(m8, ci_method = "hdi", ci = 0.95)
-    expect_true(inherits(pred1, "get_predicted"))
-    expect_true(inherits(pred1, "data.frame"))
-    expect_true(all(c("Row", "Response") %in% colnames(pred1)))
-
-    # ci_method changes intervals but not se or predicted
-    pred1 <- data.frame(pred1)
-    pred2 <- data.frame(pred2)
-    expect_equal(pred1$Row, pred2$Row)
-    expect_equal(pred1$Response, pred2$Response)
-    expect_equal(pred1$Predicted, pred2$Predicted)
-    expect_equal(pred1$SE, pred2$SE)
-    expect_false(mean(pred1$CI_low == pred2$CI_low) > 0.1) # most CI bounds are different
-    expect_false(mean(pred1$CI_high == pred2$CI_high) > 0.1) # most CI bounds are different
-
-    # compare to manual predictions
-    pred3 <- get_predicted(m8, centrality_function = stats::median, ci = 0.95)
-    manual <- rstantools::posterior_epred(m8)
-    manual <- apply(manual[, , 1], 2, median)
-    expect_equal(pred3$Predicted[1:32], manual)
-    manual <- rstantools::posterior_epred(m8)
-    manual <- apply(manual[, , 1], 2, mean)
-    expect_equal(pred1$Predicted[1:32], manual)
-  })
-
-  test_that("find_statistic", {
-    expect_null(find_statistic(m1))
-    expect_null(find_statistic(m2))
-    expect_null(find_statistic(m3))
-    expect_null(find_statistic(m4))
-    expect_null(find_statistic(m5))
-  })
-
-  test_that("n_parameters", {
-    expect_equal(n_parameters(m1), 65)
-    expect_equal(n_parameters(m1, effects = "fixed"), 5)
-  })
-
-  test_that("model_info", {
-    expect_true(model_info(m3)$is_trial)
-    expect_true(model_info(m5)[[1]]$is_zero_inflated)
-    expect_true(model_info(m5)[[1]]$is_bayesian)
-  })
-
-  test_that("clean_names", {
-    expect_identical(
-      clean_names(m1),
-      c("count", "Age", "Base", "Trt", "patient")
-    )
-    expect_identical(
-      clean_names(m2),
-      c(
-        "Sepal.Length",
-        "Sepal.Width",
-        "Petal.Length",
-        "Species"
-      )
-    )
-    expect_identical(clean_names(m3), c("r", "n", "treat", "c2"))
-    expect_identical(
-      clean_names(m4),
-      c("count", "child", "camper", "persons")
-    )
-    expect_identical(
-      clean_names(m5),
-      c(
-        "count",
-        "count2",
-        "child",
-        "camper",
-        "persons",
-        "livebait"
-      )
-    )
-  })
-
-
-  test_that("find_predictors", {
-    expect_identical(find_predictors(m1), list(conditional = c("Age", "Base", "Trt")))
-    expect_identical(
-      find_predictors(m1, flatten = TRUE),
-      c("Age", "Base", "Trt")
-    )
-    expect_identical(
-      find_predictors(m1, effects = "all", component = "all"),
-      list(
-        conditional = c("Age", "Base", "Trt"),
-        random = "patient"
+skip_if_offline()
+skip_if_not_installed("brms")
+
+# Model fitting -----------------------------------------------------------
+
+m1 <- suppressWarnings(insight::download_model("brms_mixed_6"))
+m2 <- insight::download_model("brms_mv_4")
+m3 <- insight::download_model("brms_2")
+m4 <- insight::download_model("brms_zi_3")
+m5 <- insight::download_model("brms_mv_5")
+m6 <- insight::download_model("brms_corr_re1")
+m7 <- suppressWarnings(insight::download_model("brms_mixed_8"))
+m8 <- insight::download_model("brms_ordinal_1")
+
+# Tests -------------------------------------------------------------------
+test_that("get_predicted.brmsfit: ordinal dv", {
+  skip_if_not_installed("bayestestR")
+
+  pred1 <- get_predicted(m8, ci = 0.95)
+  pred2 <- get_predicted(m8, ci_method = "hdi", ci = 0.95)
+  expect_true(inherits(pred1, "get_predicted"))
+  expect_true(inherits(pred1, "data.frame"))
+  expect_true(all(c("Row", "Response") %in% colnames(pred1)))
+
+  # ci_method changes intervals but not se or predicted
+  pred1 <- data.frame(pred1)
+  pred2 <- data.frame(pred2)
+  expect_equal(pred1$Row, pred2$Row)
+  expect_equal(pred1$Response, pred2$Response)
+  expect_equal(pred1$Predicted, pred2$Predicted)
+  expect_equal(pred1$SE, pred2$SE)
+  expect_false(mean(pred1$CI_low == pred2$CI_low) > 0.1) # most CI bounds are different
+  expect_false(mean(pred1$CI_high == pred2$CI_high) > 0.1) # most CI bounds are different
+
+  # compare to manual predictions
+  pred3 <- get_predicted(m8, centrality_function = stats::median, ci = 0.95)
+  manual <- rstantools::posterior_epred(m8)
+  manual <- apply(manual[, , 1], 2, median)
+  expect_equal(pred3$Predicted[1:32], manual)
+  manual <- rstantools::posterior_epred(m8)
+  manual <- apply(manual[, , 1], 2, mean)
+  expect_equal(pred1$Predicted[1:32], manual)
+})
+
+test_that("find_statistic", {
+  expect_null(find_statistic(m1))
+  expect_null(find_statistic(m2))
+  expect_null(find_statistic(m3))
+  expect_null(find_statistic(m4))
+  expect_null(find_statistic(m5))
+})
+
+test_that("n_parameters", {
+  expect_equal(n_parameters(m1), 65)
+  expect_equal(n_parameters(m1, effects = "fixed"), 5)
+})
+
+test_that("model_info", {
+  expect_true(model_info(m3)$is_trial)
+  expect_true(model_info(m5)[[1]]$is_zero_inflated)
+  expect_true(model_info(m5)[[1]]$is_bayesian)
+})
+
+test_that("clean_names", {
+  expect_identical(
+    clean_names(m1),
+    c("count", "Age", "Base", "Trt", "patient")
+  )
+  expect_identical(
+    clean_names(m2),
+    c(
+      "Sepal.Length",
+      "Sepal.Width",
+      "Petal.Length",
+      "Species"
+    )
+  )
+  expect_identical(clean_names(m3), c("r", "n", "treat", "c2"))
+  expect_identical(
+    clean_names(m4),
+    c("count", "child", "camper", "persons")
+  )
+  expect_identical(
+    clean_names(m5),
+    c(
+      "count",
+      "count2",
+      "child",
+      "camper",
+      "persons",
+      "livebait"
+    )
+  )
+})
+
+
+test_that("find_predictors", {
+  expect_identical(find_predictors(m1), list(conditional = c("Age", "Base", "Trt")))
+  expect_identical(
+    find_predictors(m1, flatten = TRUE),
+    c("Age", "Base", "Trt")
+  )
+  expect_identical(
+    find_predictors(m1, effects = "all", component = "all"),
+    list(
+      conditional = c("Age", "Base", "Trt"),
+      random = "patient"
+    )
+  )
+  expect_identical(
+    find_predictors(
+      m1,
+      effects = "all",
+      component = "all",
+      flatten = TRUE
+    ),
+    c("Age", "Base", "Trt", "patient")
+  )
+
+  expect_identical(
+    find_predictors(m2),
+    list(
+      SepalLength = list(conditional = c(
+        "Petal.Length", "Sepal.Width", "Species"
+      )),
+      SepalWidth = list(conditional = "Species")
+    )
+  )
+
+  expect_identical(
+    find_predictors(m2, flatten = TRUE),
+    c("Petal.Length", "Sepal.Width", "Species")
+  )
+  expect_identical(find_predictors(m3), list(conditional = c("treat", "c2")))
+  expect_identical(
+    find_predictors(m4),
+    list(
+      conditional = c("child", "camper"),
+      zero_inflated = c("child", "camper")
+    )
+  )
+  expect_identical(
+    find_predictors(m4, effects = "random"),
+    list(random = "persons", zero_inflated_random = "persons")
+  )
+  expect_identical(find_predictors(m4, flatten = TRUE), c("child", "camper"))
+
+  expect_identical(
+    find_predictors(m5),
+    list(
+      count = list(
+        conditional = c("child", "camper"),
+        zero_inflated = "camper"
+      ),
+      count2 = list(
+        conditional = c("child", "livebait"),
+        zero_inflated = "child"
       )
     )
-    expect_identical(
-      find_predictors(
-        m1,
-        effects = "all",
-        component = "all",
-        flatten = TRUE
+  )
+})
+
+test_that("find_response", {
+  expect_equal(find_response(m1, combine = TRUE), "count")
+  expect_equal(
+    find_response(m2, combine = TRUE),
+    c(SepalLength = "Sepal.Length", SepalWidth = "Sepal.Width")
+  )
+  expect_equal(find_response(m3, combine = TRUE), c("r", "n"))
+  expect_equal(find_response(m1, combine = FALSE), "count")
+  expect_equal(
+    find_response(m2, combine = FALSE),
+    c(SepalLength = "Sepal.Length", SepalWidth = "Sepal.Width")
+  )
+  expect_equal(find_response(m3, combine = FALSE), c("r", "n"))
+  expect_equal(find_response(m4, combine = FALSE), "count")
+  expect_equal(
+    find_response(m5, combine = TRUE),
+    c(count = "count", count2 = "count2")
+  )
+})
+
+test_that("get_response", {
+  expect_length(get_response(m1), 236)
+  expect_equal(ncol(get_response(m2)), 2)
+  expect_equal(
+    colnames(get_response(m2)),
+    c("Sepal.Length", "Sepal.Width")
+  )
+  expect_equal(ncol(get_response(m3)), 2)
+  expect_equal(colnames(get_response(m3)), c("r", "n"))
+  expect_length(get_response(m4), 250)
+  expect_equal(colnames(get_response(m5)), c("count", "count2"))
+})
+
+test_that("find_variables", {
+  expect_identical(
+    find_variables(m1),
+    list(
+      response = "count",
+      conditional = c("Age", "Base", "Trt"),
+      random = "patient"
+    )
+  )
+  expect_identical(
+    find_variables(m6),
+    list(
+      response = "y",
+      conditional = "x",
+      random = "id",
+      sigma = "x",
+      sigma_random = "id"
+    )
+  )
+  expect_identical(
+    find_variables(m1, effects = "fixed"),
+    list(
+      response = "count",
+      conditional = c("Age", "Base", "Trt")
+    )
+  )
+  expect_null(find_variables(m1, component = "zi"))
+
+  expect_identical(
+    find_variables(m2),
+    list(
+      response = c(SepalLength = "Sepal.Length", SepalWidth = "Sepal.Width"),
+      SepalLength = list(conditional = c(
+        "Petal.Length", "Sepal.Width", "Species"
+      )),
+      SepalWidth = list(conditional = "Species")
+    )
+  )
+
+  expect_identical(
+    find_variables(m2, flatten = TRUE),
+    c(
+      "Sepal.Length",
+      "Sepal.Width",
+      "Petal.Length",
+      "Species"
+    )
+  )
+  expect_identical(find_variables(m3), list(
+    response = c("r", "n"),
+    conditional = c("treat", "c2")
+  ))
+
+  expect_identical(
+    find_variables(m4),
+    list(
+      response = "count",
+      conditional = c("child", "camper"),
+      random = "persons",
+      zero_inflated = c("child", "camper"),
+      zero_inflated_random = "persons"
+    )
+  )
+
+  expect_identical(
+    find_variables(m4, flatten = TRUE),
+    c("count", "child", "camper", "persons")
+  )
+})
+
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 236)
+  expect_equal(n_obs(m2), 150)
+  expect_equal(n_obs(m3), 10)
+  expect_equal(n_obs(m4), 250)
+  expect_equal(n_obs(m5), 250)
+})
+
+
+test_that("find_random", {
+  expect_equal(find_random(m5), list(
+    count = list(
+      random = "persons",
+      zero_inflated_random = "persons"
+    ),
+    count2 = list(
+      random = "persons",
+      zero_inflated_random = "persons"
+    )
+  ))
+  expect_equal(find_random(m5, flatten = TRUE), "persons")
+  expect_equal(find_random(m6, flatten = TRUE), "id")
+})
+
+
+test_that("get_random", {
+  zinb <- get_data(m4)
+  expect_equal(get_random(m4), zinb[, "persons", drop = FALSE])
+})
+
+
+test_that("get_data", {
+  d <- get_data(m6)
+  expect_equal(nrow(d), 200)
+  expect_equal(ncol(d), 3)
+})
+
+
+test_that("find_paramaters", {
+  expect_equal(
+    find_parameters(m1),
+    list(
+      conditional = c(
+        "b_Intercept",
+        "b_Age",
+        "b_Base",
+        "b_Trt1",
+        "b_Base:Trt1"
       ),
-      c("Age", "Base", "Trt", "patient")
+      random = c(sprintf("r_patient[%i,Intercept]", 1:59), "sd_patient__Intercept")
     )
+  )
 
-    expect_identical(
-      find_predictors(m2),
+  expect_equal(
+    find_parameters(m2),
+    structure(
       list(
-        SepalLength = list(conditional = c(
-          "Petal.Length", "Sepal.Width", "Species"
-        )),
-        SepalWidth = list(conditional = "Species")
-      )
+        SepalLength = list(
+          conditional = c(
+            "b_SepalLength_Intercept",
+            "b_SepalLength_Petal.Length",
+            "b_SepalLength_Sepal.Width",
+            "b_SepalLength_Speciesversicolor",
+            "b_SepalLength_Speciesvirginica"
+          ),
+          sigma = "sigma_SepalLength"
+        ),
+        SepalWidth = list(
+          conditional = c(
+            "b_SepalWidth_Intercept",
+            "b_SepalWidth_Speciesversicolor",
+            "b_SepalWidth_Speciesvirginica"
+          ),
+          sigma = "sigma_SepalWidth"
+        )
+      ),
+      "is_mv" = "1"
     )
+  )
 
-    expect_identical(
-      find_predictors(m2, flatten = TRUE),
-      c("Petal.Length", "Sepal.Width", "Species")
+  expect_equal(
+    find_parameters(m4),
+    list(
+      conditional = c("b_Intercept", "b_child", "b_camper"),
+      random = c(sprintf("r_persons[%i,Intercept]", 1:4), "sd_persons__Intercept"),
+      zero_inflated = c("b_zi_Intercept", "b_zi_child", "b_zi_camper"),
+      zero_inflated_random = c(sprintf("r_persons__zi[%i,Intercept]", 1:4), "sd_persons__zi_Intercept")
     )
-    expect_identical(find_predictors(m3), list(conditional = c("treat", "c2")))
-    expect_identical(
-      find_predictors(m4),
-      list(
-        conditional = c("child", "camper"),
-        zero_inflated = c("child", "camper")
-      )
-    )
-    expect_identical(
-      find_predictors(m4, effects = "random"),
-      list(random = "persons", zero_inflated_random = "persons")
-    )
-    expect_identical(find_predictors(m4, flatten = TRUE), c("child", "camper"))
+  )
 
-    expect_identical(
-      find_predictors(m5),
+  expect_equal(
+    find_parameters(m5, effects = "all"),
+    structure(
       list(
         count = list(
-          conditional = c("child", "camper"),
-          zero_inflated = "camper"
+          conditional = c("b_count_Intercept", "b_count_child", "b_count_camper"),
+          random = c(sprintf("r_persons__count[%i,Intercept]", 1:4), "sd_persons__count_Intercept"),
+          zero_inflated = c("b_zi_count_Intercept", "b_zi_count_camper"),
+          zero_inflated_random = c(sprintf("r_persons__zi_count[%i,Intercept]", 1:4), "sd_persons__zi_count_Intercept")
         ),
         count2 = list(
-          conditional = c("child", "livebait"),
-          zero_inflated = "child"
+          conditional = c(
+            "b_count2_Intercept",
+            "b_count2_child",
+            "b_count2_livebait"
+          ),
+          random = c(sprintf("r_persons__count2[%i,Intercept]", 1:4), "sd_persons__count2_Intercept"),
+          zero_inflated = c("b_zi_count2_Intercept", "b_zi_count2_child"),
+          zero_inflated_random = c(sprintf("r_persons__zi_count2[%i,Intercept]", 1:4), "sd_persons__zi_count2_Intercept")
         )
+      ),
+      "is_mv" = "1"
+    )
+  )
+})
+
+test_that("find_paramaters", {
+  expect_equal(
+    colnames(get_parameters(m4)),
+    c(
+      "b_Intercept",
+      "b_child",
+      "b_camper",
+      "b_zi_Intercept",
+      "b_zi_child",
+      "b_zi_camper"
+    )
+  )
+  expect_equal(
+    colnames(get_parameters(m4, component = "zi")),
+    c("b_zi_Intercept", "b_zi_child", "b_zi_camper")
+  )
+  expect_equal(
+    colnames(get_parameters(m4, effects = "all")),
+    c(
+      "b_Intercept", "b_child", "b_camper", "r_persons[1,Intercept]",
+      "r_persons[2,Intercept]", "r_persons[3,Intercept]", "r_persons[4,Intercept]",
+      "sd_persons__Intercept", "b_zi_Intercept", "b_zi_child", "b_zi_camper",
+      "r_persons__zi[1,Intercept]", "r_persons__zi[2,Intercept]", "r_persons__zi[3,Intercept]",
+      "r_persons__zi[4,Intercept]", "sd_persons__zi_Intercept"
+    )
+  )
+  expect_equal(
+    colnames(get_parameters(m4, effects = "random", component = "conditional")),
+    c(
+      "r_persons[1,Intercept]", "r_persons[2,Intercept]", "r_persons[3,Intercept]",
+      "r_persons[4,Intercept]", "sd_persons__Intercept"
+    )
+  )
+  expect_equal(
+    colnames(get_parameters(m5, effects = "random", component = "conditional")),
+    c(
+      "r_persons__count[1,Intercept]", "r_persons__count[2,Intercept]",
+      "r_persons__count[3,Intercept]", "r_persons__count[4,Intercept]",
+      "sd_persons__count_Intercept", "r_persons__count2[1,Intercept]",
+      "r_persons__count2[2,Intercept]", "r_persons__count2[3,Intercept]",
+      "r_persons__count2[4,Intercept]", "sd_persons__count2_Intercept"
+    )
+  )
+
+  expect_equal(
+    colnames(get_parameters(m5, effects = "all", component = "all")),
+    c(
+      "b_count_Intercept", "b_count_child", "b_count_camper", "r_persons__count[1,Intercept]",
+      "r_persons__count[2,Intercept]", "r_persons__count[3,Intercept]",
+      "r_persons__count[4,Intercept]", "sd_persons__count_Intercept",
+      "b_zi_count_Intercept", "b_zi_count_camper", "r_persons__zi_count[1,Intercept]",
+      "r_persons__zi_count[2,Intercept]", "r_persons__zi_count[3,Intercept]",
+      "r_persons__zi_count[4,Intercept]", "sd_persons__zi_count_Intercept",
+      "b_count2_Intercept", "b_count2_child", "b_count2_livebait",
+      "r_persons__count2[1,Intercept]", "r_persons__count2[2,Intercept]",
+      "r_persons__count2[3,Intercept]", "r_persons__count2[4,Intercept]",
+      "sd_persons__count2_Intercept", "b_zi_count2_Intercept", "b_zi_count2_child",
+      "r_persons__zi_count2[1,Intercept]", "r_persons__zi_count2[2,Intercept]",
+      "r_persons__zi_count2[3,Intercept]", "r_persons__zi_count2[4,Intercept]",
+      "sd_persons__zi_count2_Intercept"
+    )
+  )
+})
+
+test_that("linkfun", {
+  expect_false(is.null(link_function(m1)))
+  expect_length(link_function(m2), 2)
+  expect_false(is.null(link_function(m3)))
+  expect_false(is.null(link_function(m4)))
+  expect_length(link_function(m5), 2)
+})
+
+test_that("linkinv", {
+  expect_false(is.null(link_inverse(m1)))
+  expect_length(link_inverse(m2), 2)
+  expect_false(is.null(link_inverse(m3)))
+  expect_false(is.null(link_inverse(m4)))
+  expect_length(link_inverse(m2), 2)
+})
+
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1))
+  expect_true(is_multivariate(m2))
+  expect_false(is_multivariate(m3))
+  expect_false(is_multivariate(m4))
+  expect_true(is_multivariate(m5))
+})
+
+test_that("find_terms", {
+  expect_equal(
+    find_terms(m2),
+    list(
+      SepalLength = list(
+        response = "Sepal.Length",
+        conditional = c("Petal.Length", "Sepal.Width", "Species")
+      ),
+      SepalWidth = list(
+        response = "Sepal.Width",
+        conditional = "Species"
       )
     )
-  })
-
-  test_that("find_response", {
-    expect_equal(find_response(m1, combine = TRUE), "count")
-    expect_equal(
-      find_response(m2, combine = TRUE),
-      c(SepalLength = "Sepal.Length", SepalWidth = "Sepal.Width")
-    )
-    expect_equal(find_response(m3, combine = TRUE), c("r", "n"))
-    expect_equal(find_response(m1, combine = FALSE), "count")
-    expect_equal(
-      find_response(m2, combine = FALSE),
-      c(SepalLength = "Sepal.Length", SepalWidth = "Sepal.Width")
-    )
-    expect_equal(find_response(m3, combine = FALSE), c("r", "n"))
-    expect_equal(find_response(m4, combine = FALSE), "count")
-    expect_equal(
-      find_response(m5, combine = TRUE),
-      c(count = "count", count2 = "count2")
-    )
-  })
-
-  test_that("get_response", {
-    expect_length(get_response(m1), 236)
-    expect_equal(ncol(get_response(m2)), 2)
-    expect_equal(
-      colnames(get_response(m2)),
-      c("Sepal.Length", "Sepal.Width")
-    )
-    expect_equal(ncol(get_response(m3)), 2)
-    expect_equal(colnames(get_response(m3)), c("r", "n"))
-    expect_length(get_response(m4), 250)
-    expect_equal(colnames(get_response(m5)), c("count", "count2"))
-  })
-
-  test_that("find_variables", {
-    expect_identical(
-      find_variables(m1),
-      list(
-        response = "count",
-        conditional = c("Age", "Base", "Trt"),
-        random = "patient"
-      )
-    )
-    expect_identical(
-      find_variables(m6),
-      list(
-        response = "y",
-        conditional = "x",
-        random = "id",
-        sigma = "x",
-        sigma_random = "id"
-      )
-    )
-    expect_identical(
-      find_variables(m1, effects = "fixed"),
-      list(
-        response = "count",
-        conditional = c("Age", "Base", "Trt")
-      )
-    )
-    expect_null(find_variables(m1, component = "zi"))
-
-    expect_identical(
-      find_variables(m2),
-      list(
-        response = c(SepalLength = "Sepal.Length", SepalWidth = "Sepal.Width"),
-        SepalLength = list(conditional = c(
-          "Petal.Length", "Sepal.Width", "Species"
-        )),
-        SepalWidth = list(conditional = "Species")
-      )
-    )
-
-    expect_identical(
-      find_variables(m2, flatten = TRUE),
-      c(
-        "Sepal.Length",
-        "Sepal.Width",
-        "Petal.Length",
-        "Species"
-      )
-    )
-    expect_identical(find_variables(m3), list(
-      response = c("r", "n"),
-      conditional = c("treat", "c2")
-    ))
-
-    expect_identical(
-      find_variables(m4),
-      list(
-        response = "count",
-        conditional = c("child", "camper"),
-        random = "persons",
-        zero_inflated = c("child", "camper"),
-        zero_inflated_random = "persons"
-      )
-    )
-
-    expect_identical(
-      find_variables(m4, flatten = TRUE),
-      c("count", "child", "camper", "persons")
-    )
-  })
-
-  test_that("n_obs", {
-    expect_equal(n_obs(m1), 236)
-    expect_equal(n_obs(m2), 150)
-    expect_equal(n_obs(m3), 10)
-    expect_equal(n_obs(m4), 250)
-    expect_equal(n_obs(m5), 250)
-  })
-
-
-  test_that("find_random", {
-    expect_equal(find_random(m5), list(
-      count = list(
-        random = "persons",
-        zero_inflated_random = "persons"
+  )
+})
+
+test_that("find_algorithm", {
+  expect_equal(
+    find_algorithm(m1),
+    list(
+      algorithm = "sampling",
+      chains = 1,
+      iterations = 500,
+      warmup = 250
+    )
+  )
+})
+
+
+test_that("get_priors", {
+  expect_equal(
+    get_priors(m7),
+    data.frame(
+      Parameter = c(
+        "b_Intercept", "b_Age", "b_Base", "b_Trt1", "b_Base:Trt1",
+        "sd_patient__Intercept", "sd_patient__Age",
+        "cor_patient__Intercept__Age"
       ),
-      count2 = list(
-        random = "persons",
-        zero_inflated_random = "persons"
+      Distribution = c(
+        "student_t", "student_t", "student_t",
+        "student_t", "student_t", "cauchy", "cauchy", "lkj"
+      ),
+      Location = c(1.4, 0, 0, 0, 0, NA, NA, 1),
+      Scale = c(2.5, 10, 10, 10, 10, NA, NA, NA),
+      df = c(3, 5, 5, 5, 5, NA, NA, NA),
+      stringsAsFactors = FALSE
+    ),
+    ignore_attr = TRUE
+  )
+  expect_equal(
+    get_priors(m3),
+    data.frame(
+      Parameter = c("b_Intercept", "b_treat1", "b_c2", "b_treat1:c2"),
+      Distribution = c("student_t", "uniform", "uniform", "uniform"),
+      Location = c(0, NA, NA, NA),
+      Scale = c(2.5, NA, NA, NA),
+      df = c(3, NA, NA, NA),
+      stringsAsFactors = FALSE
+    ),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("Issue #645", {
+  # apparently BH is required to fit these brms models
+  skip_if_not_installed("BH")
+  # sink() writing permission fail on some Windows CI machines
+  skip_on_os("windows")
+
+  void <- suppressMessages(suppressWarnings(capture.output(
+    mod <- brms::brm(
+      silent = 2,
+      data = mtcars,
+      family = brms::cumulative(probit),
+      formula = brms::bf(
+        cyl ~ 1 + mpg + drat + gearnl,
+        gearnl ~ 0 + (1 | gear),
+        nl = TRUE
       )
-    ))
-    expect_equal(find_random(m5, flatten = TRUE), "persons")
-    expect_equal(find_random(m6, flatten = TRUE), "id")
-  })
-
-
-  test_that("get_random", {
-    zinb <- get_data(m4)
-    expect_equal(get_random(m4), zinb[, "persons", drop = FALSE])
-  })
-
-
-  test_that("get_data", {
-    d <- get_data(m6)
-    expect_equal(nrow(d), 200)
-    expect_equal(ncol(d), 3)
-  })
+    )
+  )))
 
+  p <- find_predictors(mod, flatten = TRUE)
+  d <- get_data(mod)
+  expect_true("gear" %in% p)
+  expect_true("gear" %in% colnames(d))
+})
 
-  test_that("find_paramaters", {
-    expect_equal(
-      find_parameters(m1),
+test_that("clean_parameters", {
+  expect_equal(
+    clean_parameters(m4),
+    structure(
       list(
-        conditional = c(
+        Parameter = c(
           "b_Intercept",
-          "b_Age",
-          "b_Base",
-          "b_Trt1",
-          "b_Base:Trt1"
+          "b_child",
+          "b_camper",
+          "r_persons[1,Intercept]",
+          "r_persons[2,Intercept]",
+          "r_persons[3,Intercept]",
+          "r_persons[4,Intercept]",
+          "sd_persons__Intercept",
+          "b_zi_Intercept",
+          "b_zi_child",
+          "b_zi_camper",
+          "r_persons__zi[1,Intercept]",
+          "r_persons__zi[2,Intercept]",
+          "r_persons__zi[3,Intercept]",
+          "r_persons__zi[4,Intercept]",
+          "sd_persons__zi_Intercept"
         ),
-        random = c(sprintf("r_patient[%i,Intercept]", 1:59), "sd_patient__Intercept")
-      )
-    )
-
-    expect_equal(
-      find_parameters(m2),
-      structure(
-        list(
-          SepalLength = list(
-            conditional = c(
-              "b_SepalLength_Intercept",
-              "b_SepalLength_Petal.Length",
-              "b_SepalLength_Sepal.Width",
-              "b_SepalLength_Speciesversicolor",
-              "b_SepalLength_Speciesvirginica"
-            ),
-            sigma = "sigma_SepalLength"
-          ),
-          SepalWidth = list(
-            conditional = c(
-              "b_SepalWidth_Intercept",
-              "b_SepalWidth_Speciesversicolor",
-              "b_SepalWidth_Speciesvirginica"
-            ),
-            sigma = "sigma_SepalWidth"
-          )
+        Effects = c(
+          "fixed",
+          "fixed",
+          "fixed",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "fixed",
+          "fixed",
+          "fixed",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random"
         ),
-        "is_mv" = "1"
-      )
-    )
-
-    expect_equal(
-      find_parameters(m4),
-      list(
-        conditional = c("b_Intercept", "b_child", "b_camper"),
-        random = c(sprintf("r_persons[%i,Intercept]", 1:4), "sd_persons__Intercept"),
-        zero_inflated = c("b_zi_Intercept", "b_zi_child", "b_zi_camper"),
-        zero_inflated_random = c(sprintf("r_persons__zi[%i,Intercept]", 1:4), "sd_persons__zi_Intercept")
-      )
-    )
-
-    expect_equal(
-      find_parameters(m5, effects = "all"),
-      structure(
-        list(
-          count = list(
-            conditional = c("b_count_Intercept", "b_count_child", "b_count_camper"),
-            random = c(sprintf("r_persons__count[%i,Intercept]", 1:4), "sd_persons__count_Intercept"),
-            zero_inflated = c("b_zi_count_Intercept", "b_zi_count_camper"),
-            zero_inflated_random = c(sprintf("r_persons__zi_count[%i,Intercept]", 1:4), "sd_persons__zi_count_Intercept")
-          ),
-          count2 = list(
-            conditional = c(
-              "b_count2_Intercept",
-              "b_count2_child",
-              "b_count2_livebait"
-            ),
-            random = c(sprintf("r_persons__count2[%i,Intercept]", 1:4), "sd_persons__count2_Intercept"),
-            zero_inflated = c("b_zi_count2_Intercept", "b_zi_count2_child"),
-            zero_inflated_random = c(sprintf("r_persons__zi_count2[%i,Intercept]", 1:4), "sd_persons__zi_count2_Intercept")
-          )
+        Component = c(
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "zero_inflated",
+          "zero_inflated",
+          "zero_inflated",
+          "zero_inflated",
+          "zero_inflated",
+          "zero_inflated",
+          "zero_inflated",
+          "zero_inflated"
         ),
-        "is_mv" = "1"
-      )
-    )
-  })
-
-  test_that("find_paramaters", {
-    expect_equal(
-      colnames(get_parameters(m4)),
-      c(
-        "b_Intercept",
-        "b_child",
-        "b_camper",
-        "b_zi_Intercept",
-        "b_zi_child",
-        "b_zi_camper"
-      )
-    )
-    expect_equal(
-      colnames(get_parameters(m4, component = "zi")),
-      c("b_zi_Intercept", "b_zi_child", "b_zi_camper")
-    )
-    expect_equal(
-      colnames(get_parameters(m4, effects = "all")),
-      c(
-        "b_Intercept", "b_child", "b_camper", "r_persons[1,Intercept]",
-        "r_persons[2,Intercept]", "r_persons[3,Intercept]", "r_persons[4,Intercept]",
-        "sd_persons__Intercept", "b_zi_Intercept", "b_zi_child", "b_zi_camper",
-        "r_persons__zi[1,Intercept]", "r_persons__zi[2,Intercept]", "r_persons__zi[3,Intercept]",
-        "r_persons__zi[4,Intercept]", "sd_persons__zi_Intercept"
-      )
-    )
-    expect_equal(
-      colnames(get_parameters(m4, effects = "random", component = "conditional")),
-      c(
-        "r_persons[1,Intercept]", "r_persons[2,Intercept]", "r_persons[3,Intercept]",
-        "r_persons[4,Intercept]", "sd_persons__Intercept"
-      )
-    )
-    expect_equal(
-      colnames(get_parameters(m5, effects = "random", component = "conditional")),
-      c(
-        "r_persons__count[1,Intercept]", "r_persons__count[2,Intercept]",
-        "r_persons__count[3,Intercept]", "r_persons__count[4,Intercept]",
-        "sd_persons__count_Intercept", "r_persons__count2[1,Intercept]",
-        "r_persons__count2[2,Intercept]", "r_persons__count2[3,Intercept]",
-        "r_persons__count2[4,Intercept]", "sd_persons__count2_Intercept"
-      )
-    )
-
-    expect_equal(
-      colnames(get_parameters(m5, effects = "all", component = "all")),
-      c(
-        "b_count_Intercept", "b_count_child", "b_count_camper", "r_persons__count[1,Intercept]",
-        "r_persons__count[2,Intercept]", "r_persons__count[3,Intercept]",
-        "r_persons__count[4,Intercept]", "sd_persons__count_Intercept",
-        "b_zi_count_Intercept", "b_zi_count_camper", "r_persons__zi_count[1,Intercept]",
-        "r_persons__zi_count[2,Intercept]", "r_persons__zi_count[3,Intercept]",
-        "r_persons__zi_count[4,Intercept]", "sd_persons__zi_count_Intercept",
-        "b_count2_Intercept", "b_count2_child", "b_count2_livebait",
-        "r_persons__count2[1,Intercept]", "r_persons__count2[2,Intercept]",
-        "r_persons__count2[3,Intercept]", "r_persons__count2[4,Intercept]",
-        "sd_persons__count2_Intercept", "b_zi_count2_Intercept", "b_zi_count2_child",
-        "r_persons__zi_count2[1,Intercept]", "r_persons__zi_count2[2,Intercept]",
-        "r_persons__zi_count2[3,Intercept]", "r_persons__zi_count2[4,Intercept]",
-        "sd_persons__zi_count2_Intercept"
-      )
-    )
-  })
-
-  test_that("linkfun", {
-    expect_false(is.null(link_function(m1)))
-    expect_length(link_function(m2), 2)
-    expect_false(is.null(link_function(m3)))
-    expect_false(is.null(link_function(m4)))
-    expect_length(link_function(m5), 2)
-  })
-
-  test_that("linkinv", {
-    expect_false(is.null(link_inverse(m1)))
-    expect_length(link_inverse(m2), 2)
-    expect_false(is.null(link_inverse(m3)))
-    expect_false(is.null(link_inverse(m4)))
-    expect_length(link_inverse(m2), 2)
-  })
-
-  test_that("is_multivariate", {
-    expect_false(is_multivariate(m1))
-    expect_true(is_multivariate(m2))
-    expect_false(is_multivariate(m3))
-    expect_false(is_multivariate(m4))
-    expect_true(is_multivariate(m5))
-  })
-
-  test_that("find_terms", {
-    expect_equal(
-      find_terms(m2),
-      list(
-        SepalLength = list(
-          response = "Sepal.Length",
-          conditional = c("Petal.Length", "Sepal.Width", "Species")
+        Group = c(
+          "",
+          "",
+          "",
+          "Intercept: persons",
+          "Intercept: persons",
+          "Intercept: persons",
+          "Intercept: persons",
+          "SD/Cor: persons",
+          "",
+          "",
+          "",
+          "Intercept: persons",
+          "Intercept: persons",
+          "Intercept: persons",
+          "Intercept: persons",
+          "SD/Cor: persons"
         ),
-        SepalWidth = list(
-          response = "Sepal.Width",
-          conditional = "Species"
+        Cleaned_Parameter = c(
+          "(Intercept)",
+          "child",
+          "camper",
+          "persons.1",
+          "persons.2",
+          "persons.3",
+          "persons.4",
+          "(Intercept)",
+          "(Intercept)",
+          "child",
+          "camper",
+          "persons.1",
+          "persons.2",
+          "persons.3",
+          "persons.4",
+          "(Intercept)"
         )
+      ),
+      class = c("clean_parameters", "data.frame"),
+      row.names = c(
+        NA,
+        -16L
       )
-    )
-  })
+    ),
+    ignore_attr = TRUE
+  )
 
-  test_that("find_algorithm", {
-    expect_equal(
-      find_algorithm(m1),
+  expect_equal(
+    clean_parameters(m5),
+    structure(
       list(
-        algorithm = "sampling",
-        chains = 1,
-        iterations = 500,
-        warmup = 250
-      )
-    )
-  })
-
-
-  test_that("get_priors", {
-    expect_equal(
-      get_priors(m7),
-      data.frame(
         Parameter = c(
-          "b_Intercept", "b_Age", "b_Base", "b_Trt1", "b_Base:Trt1",
-          "sd_patient__Intercept", "sd_patient__Age",
-          "cor_patient__Intercept__Age"
+          "b_count_Intercept",
+          "b_count_child",
+          "b_count_camper",
+          "b_count2_Intercept",
+          "b_count2_child",
+          "b_count2_livebait",
+          "r_persons__count[1,Intercept]",
+          "r_persons__count[2,Intercept]",
+          "r_persons__count[3,Intercept]",
+          "r_persons__count[4,Intercept]",
+          "sd_persons__count_Intercept",
+          "r_persons__count2[1,Intercept]",
+          "r_persons__count2[2,Intercept]",
+          "r_persons__count2[3,Intercept]",
+          "r_persons__count2[4,Intercept]",
+          "sd_persons__count2_Intercept",
+          "b_zi_count_Intercept",
+          "b_zi_count_camper",
+          "b_zi_count2_Intercept",
+          "b_zi_count2_child",
+          "r_persons__zi_count[1,Intercept]",
+          "r_persons__zi_count[2,Intercept]",
+          "r_persons__zi_count[3,Intercept]",
+          "r_persons__zi_count[4,Intercept]",
+          "sd_persons__zi_count_Intercept",
+          "r_persons__zi_count2[1,Intercept]",
+          "r_persons__zi_count2[2,Intercept]",
+          "r_persons__zi_count2[3,Intercept]",
+          "r_persons__zi_count2[4,Intercept]",
+          "sd_persons__zi_count2_Intercept"
         ),
-        Distribution = c(
-          "student_t", "student_t", "student_t",
-          "student_t", "student_t", "cauchy", "cauchy", "lkj"
+        Effects = c(
+          "fixed",
+          "fixed",
+          "fixed",
+          "fixed",
+          "fixed",
+          "fixed",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "fixed",
+          "fixed",
+          "fixed",
+          "fixed",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random"
         ),
-        Location = c(1.4, 0, 0, 0, 0, NA, NA, 1),
-        Scale = c(2.5, 10, 10, 10, 10, NA, NA, NA),
-        df = c(3, 5, 5, 5, 5, NA, NA, NA),
-        stringsAsFactors = FALSE
-      ),
-      ignore_attr = TRUE
-    )
-    expect_equal(
-      get_priors(m3),
-      data.frame(
-        Parameter = c("b_Intercept", "b_treat1", "b_c2", "b_treat1:c2"),
-        Distribution = c("student_t", "uniform", "uniform", "uniform"),
-        Location = c(0, NA, NA, NA),
-        Scale = c(2.5, NA, NA, NA),
-        df = c(3, NA, NA, NA),
-        stringsAsFactors = FALSE
-      ),
-      ignore_attr = TRUE
-    )
-  })
-
-  test_that("Issue #645", {
-    # apparently BH is required to fit these brms models
-    skip_if_not_installed("BH")
-    # sink() writing permission fail on some Windows CI machines
-    skip_on_os("windows")
-
-    void <- suppressMessages(suppressWarnings(capture.output(
-      mod <- brm(
-        silent = 2,
-        data = mtcars,
-        family = cumulative(probit),
-        formula = bf(
-          cyl ~ 1 + mpg + drat + gearnl,
-          gearnl ~ 0 + (1 | gear),
-          nl = TRUE
-        )
-      )
-    )))
-
-    p <- find_predictors(mod, flatten = TRUE)
-    d <- get_data(mod)
-    expect_true("gear" %in% p)
-    expect_true("gear" %in% colnames(d))
-  })
-
-  test_that("clean_parameters", {
-    expect_equal(
-      clean_parameters(m4),
-      structure(
-        list(
-          Parameter = c(
-            "b_Intercept",
-            "b_child",
-            "b_camper",
-            "r_persons[1,Intercept]",
-            "r_persons[2,Intercept]",
-            "r_persons[3,Intercept]",
-            "r_persons[4,Intercept]",
-            "sd_persons__Intercept",
-            "b_zi_Intercept",
-            "b_zi_child",
-            "b_zi_camper",
-            "r_persons__zi[1,Intercept]",
-            "r_persons__zi[2,Intercept]",
-            "r_persons__zi[3,Intercept]",
-            "r_persons__zi[4,Intercept]",
-            "sd_persons__zi_Intercept"
-          ),
-          Effects = c(
-            "fixed",
-            "fixed",
-            "fixed",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "fixed",
-            "fixed",
-            "fixed",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random"
-          ),
-          Component = c(
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "zero_inflated",
-            "zero_inflated",
-            "zero_inflated",
-            "zero_inflated",
-            "zero_inflated",
-            "zero_inflated",
-            "zero_inflated",
-            "zero_inflated"
-          ),
-          Group = c(
-            "",
-            "",
-            "",
-            "Intercept: persons",
-            "Intercept: persons",
-            "Intercept: persons",
-            "Intercept: persons",
-            "SD/Cor: persons",
-            "",
-            "",
-            "",
-            "Intercept: persons",
-            "Intercept: persons",
-            "Intercept: persons",
-            "Intercept: persons",
-            "SD/Cor: persons"
-          ),
-          Cleaned_Parameter = c(
-            "(Intercept)",
-            "child",
-            "camper",
-            "persons.1",
-            "persons.2",
-            "persons.3",
-            "persons.4",
-            "(Intercept)",
-            "(Intercept)",
-            "child",
-            "camper",
-            "persons.1",
-            "persons.2",
-            "persons.3",
-            "persons.4",
-            "(Intercept)"
-          )
+        Component = c(
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "zero_inflated",
+          "zero_inflated",
+          "zero_inflated",
+          "zero_inflated",
+          "zero_inflated",
+          "zero_inflated",
+          "zero_inflated",
+          "zero_inflated",
+          "zero_inflated",
+          "zero_inflated",
+          "zero_inflated",
+          "zero_inflated",
+          "zero_inflated",
+          "zero_inflated"
         ),
-        class = c("clean_parameters", "data.frame"),
-        row.names = c(
-          NA,
-          -16L
-        )
-      ),
-      ignore_attr = TRUE
-    )
-
-    expect_equal(
-      clean_parameters(m5),
-      structure(
-        list(
-          Parameter = c(
-            "b_count_Intercept",
-            "b_count_child",
-            "b_count_camper",
-            "b_count2_Intercept",
-            "b_count2_child",
-            "b_count2_livebait",
-            "r_persons__count[1,Intercept]",
-            "r_persons__count[2,Intercept]",
-            "r_persons__count[3,Intercept]",
-            "r_persons__count[4,Intercept]",
-            "sd_persons__count_Intercept",
-            "r_persons__count2[1,Intercept]",
-            "r_persons__count2[2,Intercept]",
-            "r_persons__count2[3,Intercept]",
-            "r_persons__count2[4,Intercept]",
-            "sd_persons__count2_Intercept",
-            "b_zi_count_Intercept",
-            "b_zi_count_camper",
-            "b_zi_count2_Intercept",
-            "b_zi_count2_child",
-            "r_persons__zi_count[1,Intercept]",
-            "r_persons__zi_count[2,Intercept]",
-            "r_persons__zi_count[3,Intercept]",
-            "r_persons__zi_count[4,Intercept]",
-            "sd_persons__zi_count_Intercept",
-            "r_persons__zi_count2[1,Intercept]",
-            "r_persons__zi_count2[2,Intercept]",
-            "r_persons__zi_count2[3,Intercept]",
-            "r_persons__zi_count2[4,Intercept]",
-            "sd_persons__zi_count2_Intercept"
-          ),
-          Effects = c(
-            "fixed",
-            "fixed",
-            "fixed",
-            "fixed",
-            "fixed",
-            "fixed",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "fixed",
-            "fixed",
-            "fixed",
-            "fixed",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random"
-          ),
-          Component = c(
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "zero_inflated",
-            "zero_inflated",
-            "zero_inflated",
-            "zero_inflated",
-            "zero_inflated",
-            "zero_inflated",
-            "zero_inflated",
-            "zero_inflated",
-            "zero_inflated",
-            "zero_inflated",
-            "zero_inflated",
-            "zero_inflated",
-            "zero_inflated",
-            "zero_inflated"
-          ),
-          Group = c(
-            "",
-            "",
-            "",
-            "",
-            "",
-            "",
-            "Intercept: persons",
-            "Intercept: persons",
-            "Intercept: persons",
-            "Intercept: persons",
-            "SD/Cor: persons",
-            "Intercept: persons2",
-            "Intercept: persons2",
-            "Intercept: persons2",
-            "Intercept: persons2",
-            "SD/Cor: persons",
-            "",
-            "",
-            "",
-            "",
-            "Intercept: persons",
-            "Intercept: persons",
-            "Intercept: persons",
-            "Intercept: persons",
-            "SD/Cor: persons",
-            "Intercept: persons2",
-            "Intercept: persons2",
-            "Intercept: persons2",
-            "Intercept: persons2",
-            "SD/Cor: persons"
-          ),
-          Response = c(
-            "count",
-            "count",
-            "count",
-            "count2",
-            "count2",
-            "count2",
-            "count",
-            "count",
-            "count",
-            "count",
-            "count",
-            "count2",
-            "count2",
-            "count2",
-            "count2",
-            "count2",
-            "count",
-            "count",
-            "count2",
-            "count2",
-            "count",
-            "count",
-            "count",
-            "count",
-            "count",
-            "count2",
-            "count2",
-            "count2",
-            "count2",
-            "count2"
-          ),
-          Cleaned_Parameter = c(
-            "(Intercept)",
-            "child",
-            "camper",
-            "(Intercept)",
-            "child",
-            "livebait",
-            "persons.1",
-            "persons.2",
-            "persons.3",
-            "persons.4",
-            "count_Intercept",
-            "persons2.1",
-            "persons2.2",
-            "persons2.3",
-            "persons2.4",
-            "count2_Intercept",
-            "(Intercept)",
-            "camper",
-            "(Intercept)",
-            "child",
-            "persons.1",
-            "persons.2",
-            "persons.3",
-            "persons.4",
-            "zi_count_Intercept",
-            "persons2.1",
-            "persons2.2",
-            "persons2.3",
-            "persons2.4",
-            "zi_count2_Intercept"
-          )
+        Group = c(
+          "",
+          "",
+          "",
+          "",
+          "",
+          "",
+          "Intercept: persons",
+          "Intercept: persons",
+          "Intercept: persons",
+          "Intercept: persons",
+          "SD/Cor: persons",
+          "Intercept: persons2",
+          "Intercept: persons2",
+          "Intercept: persons2",
+          "Intercept: persons2",
+          "SD/Cor: persons",
+          "",
+          "",
+          "",
+          "",
+          "Intercept: persons",
+          "Intercept: persons",
+          "Intercept: persons",
+          "Intercept: persons",
+          "SD/Cor: persons",
+          "Intercept: persons2",
+          "Intercept: persons2",
+          "Intercept: persons2",
+          "Intercept: persons2",
+          "SD/Cor: persons"
+        ),
+        Response = c(
+          "count",
+          "count",
+          "count",
+          "count2",
+          "count2",
+          "count2",
+          "count",
+          "count",
+          "count",
+          "count",
+          "count",
+          "count2",
+          "count2",
+          "count2",
+          "count2",
+          "count2",
+          "count",
+          "count",
+          "count2",
+          "count2",
+          "count",
+          "count",
+          "count",
+          "count",
+          "count",
+          "count2",
+          "count2",
+          "count2",
+          "count2",
+          "count2"
         ),
-        class = c("clean_parameters", "data.frame"),
-        row.names = c(NA, -30L)
+        Cleaned_Parameter = c(
+          "(Intercept)",
+          "child",
+          "camper",
+          "(Intercept)",
+          "child",
+          "livebait",
+          "persons.1",
+          "persons.2",
+          "persons.3",
+          "persons.4",
+          "count_Intercept",
+          "persons2.1",
+          "persons2.2",
+          "persons2.3",
+          "persons2.4",
+          "count2_Intercept",
+          "(Intercept)",
+          "camper",
+          "(Intercept)",
+          "child",
+          "persons.1",
+          "persons.2",
+          "persons.3",
+          "persons.4",
+          "zi_count_Intercept",
+          "persons2.1",
+          "persons2.2",
+          "persons2.3",
+          "persons2.4",
+          "zi_count2_Intercept"
+        )
       ),
-      ignore_attr = TRUE
-    )
-  })
-}
+      class = c("clean_parameters", "data.frame"),
+      row.names = c(NA, -30L)
+    ),
+    ignore_attr = TRUE
+  )
+})
diff --git a/tests/testthat/test-censReg.R b/tests/testthat/test-censReg.R
index 3e12dd1d8..569650943 100644
--- a/tests/testthat/test-censReg.R
+++ b/tests/testthat/test-censReg.R
@@ -1,9 +1,9 @@
-skip_if_not_or_load_if_installed("censReg")
-skip_if_not_or_load_if_installed("AER")
+skip_if_not_installed("censReg")
+skip_if_not_installed("AER")
 
 data("Affairs", package = "AER")
 
-m1 <- censReg(
+m1 <- censReg::censReg(
   affairs ~ age + yearsmarried + religiousness + occupation + rating,
   data = Affairs
 )
diff --git a/tests/testthat/test-cgam.R b/tests/testthat/test-cgam.R
index de862c7ac..8f67f879a 100644
--- a/tests/testthat/test-cgam.R
+++ b/tests/testthat/test-cgam.R
@@ -1,66 +1,68 @@
-if (skip_if_not_or_load_if_installed("cgam") && getRversion() >= "4.0.0") {
-  data(cubic, package = "cgam")
-  m <- cgam(y ~ incr.conv(x), data = cubic)
+skip_if_not_installed("cgam")
+skip_if_not(getRversion() >= "4.0.0")
 
-  mi <- insight::model_info(m)
-  test_that("model_info", {
-    expect_false(mi$is_binomial)
-    expect_true(mi$is_linear)
-    expect_false(mi$is_censored)
-  })
+data(cubic, package = "cgam")
+incr.conv <- cgam::incr.conv
+m <- cgam::cgam(y ~ incr.conv(x), data = cubic)
 
-  test_that("n_obs", {
-    expect_equal(n_obs(m), 50)
-  })
+mi <- insight::model_info(m)
+test_that("model_info", {
+  expect_false(mi$is_binomial)
+  expect_true(mi$is_linear)
+  expect_false(mi$is_censored)
+})
 
-  test_that("find_formula", {
-    expect_length(find_formula(m), 1)
-    expect_equal(
-      find_formula(m),
-      list(conditional = as.formula("y ~ incr.conv(x)")),
-      ignore_attr = TRUE
-    )
-  })
+test_that("n_obs", {
+  expect_equal(n_obs(m), 50)
+})
 
-  test_that("find_terms", {
-    expect_equal(find_terms(m), list(
-      response = "y",
-      conditional = "incr.conv(x)"
-    ))
-    expect_equal(
-      find_terms(m, flatten = TRUE),
-      c("y", "incr.conv(x)")
-    )
-  })
+test_that("find_formula", {
+  expect_length(find_formula(m), 1)
+  expect_equal(
+    find_formula(m),
+    list(conditional = as.formula("y ~ incr.conv(x)")),
+    ignore_attr = TRUE
+  )
+})
 
-  test_that("get_data", {
-    expect_equal(nrow(get_data(m)), 50)
-    expect_equal(colnames(get_data(m)), c("y", "x"))
-  })
+test_that("find_terms", {
+  expect_equal(find_terms(m), list(
+    response = "y",
+    conditional = "incr.conv(x)"
+  ))
+  expect_equal(
+    find_terms(m, flatten = TRUE),
+    c("y", "incr.conv(x)")
+  )
+})
 
-  test_that("get_response", {
-    expect_equal(get_response(m), cubic$y)
-  })
+test_that("get_data", {
+  expect_equal(nrow(get_data(m)), 50)
+  expect_equal(colnames(get_data(m)), c("y", "x"))
+})
 
-  test_that("is_multivariate", {
-    expect_false(is_multivariate(m))
-  })
+test_that("get_response", {
+  expect_equal(get_response(m), cubic$y)
+})
 
-  test_that("is_model", {
-    expect_true(is_model(m))
-  })
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m))
+})
 
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m), "t-statistic")
-  })
+test_that("is_model", {
+  expect_true(is_model(m))
+})
 
-  test_that("get_df", {
-    expect_equal(get_df(m), 39.5, tolerance = 1e-3)
-    expect_equal(get_df(m, type = "wald"), 39.5, tolerance = 1e-3)
-    expect_equal(get_df(m, type = "model"), 2, tolerance = 1e-3)
-  })
+test_that("find_statistic", {
+  expect_identical(find_statistic(m), "t-statistic")
+})
 
-  test_that("get_sigma", {
-    expect_equal(get_sigma(m), 2.159464, tolerance = 1e-3, ignore_attr = TRUE)
-  })
-}
+test_that("get_df", {
+  expect_equal(get_df(m), 39.5, tolerance = 1e-3)
+  expect_equal(get_df(m, type = "wald"), 39.5, tolerance = 1e-3)
+  expect_equal(get_df(m, type = "model"), 2, tolerance = 1e-3)
+})
+
+test_that("get_sigma", {
+  expect_equal(get_sigma(m), 2.159464, tolerance = 1e-3, ignore_attr = TRUE)
+})
diff --git a/tests/testthat/test-check_if_installed.R b/tests/testthat/test-check_if_installed.R
index 75dd92937..bc4391eb1 100644
--- a/tests/testthat/test-check_if_installed.R
+++ b/tests/testthat/test-check_if_installed.R
@@ -1,4 +1,5 @@
-test_that("export_table", {
+test_that("check_if_installed", {
+  skip_if(interactive())
   # mimic package name if cat were to walk on a keyboard
   expect_error(check_if_installed("xklfueofi8eur3rnfalfb"))
 })
diff --git a/tests/testthat/test-clm.R b/tests/testthat/test-clm.R
index 5fb193e6c..aa9fd0a42 100644
--- a/tests/testthat/test-clm.R
+++ b/tests/testthat/test-clm.R
@@ -1,132 +1,117 @@
-if (skip_if_not_or_load_if_installed("ordinal")) {
-  data(wine, package = "ordinal")
-  m1 <- clm(rating ~ temp * contact, data = wine)
-
-  data(mtcars)
-  m2 <- suppressWarnings(clm( # nominal + scale effects
-    cyl ~ wt,
-    scale = ~vs, nominal = ~hp,
-    data = transform(mtcars, cyl = factor(cyl))
-  ))
-
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_ordinal)
-    expect_false(model_info(m1)$is_multinomial)
-    expect_false(model_info(m1)$is_linear)
-  })
-
-  test_that("find_predictors", {
-    expect_identical(find_predictors(m1), list(conditional = c("temp", "contact")))
-    expect_identical(find_predictors(m1, flatten = TRUE), c("temp", "contact"))
-    expect_null(find_predictors(m1, effects = "random"))
-    expect_identical(
-      find_predictors(m2),
-      list(conditional = "wt", scale = "vs", nominal = "hp")
-    )
-  })
-
-  test_that("find_random", {
-    expect_null(find_random(m1))
-  })
-
-  test_that("get_random", {
-    expect_warning(get_random(m1))
-  })
-
-  test_that("find_response", {
-    expect_identical(find_response(m1), "rating")
-  })
-
-  test_that("get_response", {
-    expect_equal(get_response(m1), wine$rating, tolerance = 1e-5)
-  })
-
-  test_that("get_predictors", {
-    expect_identical(colnames(get_predictors(m1)), c("temp", "contact"))
-  })
-
-  test_that("link_inverse", {
-    expect_equal(link_inverse(m1)(0.2), plogis(0.2), tolerance = 1e-5)
-  })
-
-  test_that("get_data", {
-    expect_identical(nrow(get_data(m1)), 72L)
-    expect_identical(colnames(get_data(m1)), c("rating", "temp", "contact"))
-    expect_identical(colnames(get_data(m2)), c("cyl", "wt", "vs", "hp"))
-  })
-
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 1)
-    expect_equal(
-      find_formula(m1),
-      list(conditional = as.formula("rating ~ temp * contact")),
-      ignore_attr = TRUE
-    )
-    expect_equal(
-      find_formula(m2),
-      list(
-        conditional = as.formula("cyl ~ wt"),
-        scale = as.formula("~vs"),
-        nominal = as.formula("~hp")
-      ),
-      ignore_attr = TRUE
-    )
-  })
-
-  test_that("find_variables", {
-    expect_identical(
-      find_variables(m2),
-      list(response = "cyl", conditional = "wt", scale = "vs", nominal = "hp")
-    )
-  })
-
-  test_that("find_terms", {
-    expect_equal(
-      find_terms(m1),
-      list(
-        response = "rating",
-        conditional = c("temp", "contact")
-      ),
-      ignore_attr = TRUE
-    )
-    expect_identical(
-      find_terms(m1, flatten = TRUE),
-      c("rating", "temp", "contact")
-    )
-    expect_identical(
-      find_terms(m2),
-      list(response = "cyl", conditional = "wt", scale = "vs", nominal = "hp")
-    )
-  })
-
-  test_that("n_obs", {
-    expect_equal(n_obs(m1), 72) # nolint
-  })
-
-  test_that("linkfun", {
-    expect_false(is.null(link_function(m1)))
-  })
-
-  test_that("find_parameters", {
-    expect_equal(
-      find_parameters(m1),
-      list(
-        conditional = c(
-          "1|2",
-          "2|3",
-          "3|4",
-          "4|5",
-          "tempwarm",
-          "contactyes",
-          "tempwarm:contactyes"
-        )
-      ),
-      ignore_attr = TRUE
-    )
-    expect_identical(nrow(get_parameters(m1)), 7L)
-    expect_identical(
-      get_parameters(m1)$Parameter,
-      c(
+skip_if_not_installed("ordinal")
+
+data(wine, package = "ordinal")
+m1 <- ordinal::clm(rating ~ temp * contact, data = wine)
+
+m2 <- suppressWarnings(ordinal::clm( # nominal + scale effects
+  cyl ~ wt,
+  scale = ~vs, nominal = ~hp,
+  data = transform(mtcars, cyl = factor(cyl))
+))
+
+test_that("model_info", {
+  expect_true(model_info(m1)$is_ordinal)
+  expect_false(model_info(m1)$is_multinomial)
+  expect_false(model_info(m1)$is_linear)
+})
+
+test_that("find_predictors", {
+  expect_identical(find_predictors(m1), list(conditional = c("temp", "contact")))
+  expect_identical(find_predictors(m1, flatten = TRUE), c("temp", "contact"))
+  expect_null(find_predictors(m1, effects = "random"))
+  expect_identical(
+    find_predictors(m2),
+    list(conditional = "wt", scale = "vs", nominal = "hp")
+  )
+})
+
+test_that("find_random", {
+  expect_null(find_random(m1))
+})
+
+test_that("get_random", {
+  expect_warning(get_random(m1))
+})
+
+test_that("find_response", {
+  expect_identical(find_response(m1), "rating")
+})
+
+test_that("get_response", {
+  expect_equal(get_response(m1), wine$rating, tolerance = 1e-5)
+})
+
+test_that("get_predictors", {
+  expect_identical(colnames(get_predictors(m1)), c("temp", "contact"))
+})
+
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), plogis(0.2), tolerance = 1e-5)
+})
+
+test_that("get_data", {
+  expect_identical(nrow(get_data(m1)), 72L)
+  expect_identical(colnames(get_data(m1)), c("rating", "temp", "contact"))
+  expect_identical(colnames(get_data(m2)), c("cyl", "wt", "vs", "hp"))
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1), 1)
+  expect_equal(
+    find_formula(m1),
+    list(conditional = as.formula("rating ~ temp * contact")),
+    ignore_attr = TRUE
+  )
+  expect_equal(
+    find_formula(m2),
+    list(
+      conditional = as.formula("cyl ~ wt"),
+      scale = as.formula("~vs"),
+      nominal = as.formula("~hp")
+    ),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_variables", {
+  expect_identical(
+    find_variables(m2),
+    list(response = "cyl", conditional = "wt", scale = "vs", nominal = "hp")
+  )
+})
+
+test_that("find_terms", {
+  expect_equal(
+    find_terms(m1),
+    list(
+      response = "rating",
+      conditional = c("temp", "contact")
+    ),
+    ignore_attr = TRUE
+  )
+  expect_identical(
+    find_terms(m1, flatten = TRUE),
+    c("rating", "temp", "contact")
+  )
+  expect_identical(
+    find_terms(m2),
+    list(response = "cyl", conditional = "wt", scale = "vs", nominal = "hp")
+  )
+})
+
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 72) # nolint
+})
+
+test_that("linkfun", {
+  expect_false(is.null(link_function(m1)))
+})
+
+test_that("find_parameters", {
+  expect_equal(
+    find_parameters(m1),
+    list(
+      conditional = c(
         "1|2",
         "2|3",
         "3|4",
@@ -135,39 +120,53 @@ if (skip_if_not_or_load_if_installed("ordinal")) {
         "contactyes",
         "tempwarm:contactyes"
       )
+    ),
+    ignore_attr = TRUE
+  )
+  expect_identical(nrow(get_parameters(m1)), 7L)
+  expect_identical(
+    get_parameters(m1)$Parameter,
+    c(
+      "1|2",
+      "2|3",
+      "3|4",
+      "4|5",
+      "tempwarm",
+      "contactyes",
+      "tempwarm:contactyes"
     )
-  })
-
-  test_that("is_multivariate", {
-    expect_false(is_multivariate(m1))
-  })
-
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "z-statistic")
-  })
-
-  test_that("get_predicted", {
-    nd <- wine
-    nd$rating <- NULL
-    x <- as.data.frame(get_predicted(m1))
-    y <- as.data.frame(get_predicted(m1, predict = NULL, type = "prob"))
-    z <- predict(m1, type = "prob", newdata = nd, se.fit = TRUE)
-    expect_true(all(c("Row", "Response", "Predicted", "SE") %in% colnames(x)))
-    expect_equal(x, y, tolerance = 1e-5)
-    for (i in 1:5) {
-      expect_equal(x$Predicted[x$Response == i], unname(z$fit[, i]), ignore_attr = FALSE)
-      expect_equal(x$SE[x$Response == i], unname(z$se.fit[, i]), ignore_attr = FALSE)
-    }
-    x <- as.data.frame(get_predicted(m1, predict = "classification"))
-    y <- as.data.frame(get_predicted(m1, predict = NULL, type = "class"))
-    z <- predict(m1, type = "class", newdata = nd)
-    expect_equal(x, y, tolerance = 1e-5)
-    expect_equal(as.character(x$Predicted), as.character(z$fit), ignore_attr = FALSE)
-
-    # we use a hack to handle in-formula factors
-    tmp <- wine
-    tmp$rating <- as.numeric(tmp$rating)
-    tmp <- clm(factor(rating) ~ temp * contact, data = tmp)
-    expect_s3_class(get_predicted(tmp), "get_predicted")
-  })
-}
+  )
+})
+
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1))
+})
+
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "z-statistic")
+})
+
+test_that("get_predicted", {
+  nd <- wine
+  nd$rating <- NULL
+  x <- as.data.frame(get_predicted(m1))
+  y <- as.data.frame(get_predicted(m1, predict = NULL, type = "prob"))
+  z <- predict(m1, type = "prob", newdata = nd, se.fit = TRUE)
+  expect_true(all(c("Row", "Response", "Predicted", "SE") %in% colnames(x)))
+  expect_equal(x, y, tolerance = 1e-5)
+  for (i in 1:5) {
+    expect_equal(x$Predicted[x$Response == i], unname(z$fit[, i]), ignore_attr = FALSE)
+    expect_equal(x$SE[x$Response == i], unname(z$se.fit[, i]), ignore_attr = FALSE)
+  }
+  x <- as.data.frame(get_predicted(m1, predict = "classification"))
+  y <- as.data.frame(get_predicted(m1, predict = NULL, type = "class"))
+  z <- predict(m1, type = "class", newdata = nd)
+  expect_equal(x, y, tolerance = 1e-5)
+  expect_equal(as.character(x$Predicted), as.character(z$fit), ignore_attr = FALSE)
+
+  # we use a hack to handle in-formula factors
+  tmp <- wine
+  tmp$rating <- as.numeric(tmp$rating)
+  tmp <- ordinal::clm(factor(rating) ~ temp * contact, data = tmp)
+  expect_s3_class(get_predicted(tmp), "get_predicted")
+})
diff --git a/tests/testthat/test-clm2.R b/tests/testthat/test-clm2.R
index a879725f7..3ffe52216 100644
--- a/tests/testthat/test-clm2.R
+++ b/tests/testthat/test-clm2.R
@@ -1,117 +1,101 @@
-if (
-
-  skip_if_not_or_load_if_installed("ordinal") &&
-    skip_if_not_or_load_if_installed("MASS")) {
-  data(housing, package = "MASS")
-  m1 <- clm2(Sat ~ Infl + Type + Cont, weights = Freq, data = housing)
-
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_ordinal)
-    expect_false(model_info(m1)$is_multinomial)
-    expect_false(model_info(m1)$is_linear)
-  })
-
-  test_that("find_predictors", {
-    expect_identical(find_predictors(m1), list(conditional = c("Infl", "Type", "Cont")))
-    expect_identical(
-      find_predictors(m1, flatten = TRUE),
-      c("Infl", "Type", "Cont")
-    )
-    expect_null(find_predictors(m1, effects = "random"))
-  })
-
-  test_that("find_random", {
-    expect_null(find_random(m1))
-  })
-
-  test_that("get_random", {
-    expect_warning(get_random(m1))
-  })
-
-  test_that("find_response", {
-    expect_identical(find_response(m1), "Sat")
-  })
-
-  test_that("get_response", {
-    expect_equal(get_response(m1), housing$Sat)
-  })
-
-  test_that("get_predictors", {
-    expect_equal(colnames(get_predictors(m1)), c("Infl", "Type", "Cont"))
-  })
-
-  test_that("link_inverse", {
-    expect_equal(link_inverse(m1)(0.2), plogis(0.2), tolerance = 1e-5)
-  })
-
-  test_that("find_weights", {
-    expect_equal(find_weights(m1), "Freq")
-  })
-
-  test_that("get_weights", {
-    expect_equal(get_weights(m1), housing$Freq)
-  })
-
-  test_that("get_data", {
-    expect_equal(nrow(get_data(m1)), 72)
-    expect_equal(
-      colnames(get_data(m1)),
-      c("Sat", "Infl", "Type", "Cont", "Freq")
-    )
-  })
-
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 1)
-    expect_equal(
-      find_formula(m1),
-      list(conditional = as.formula("Sat ~ Infl + Type + Cont")),
-      ignore_attr = TRUE
-    )
-  })
-
-  test_that("find_terms", {
-    expect_equal(find_terms(m1), list(
-      response = "Sat",
-      conditional = c("Infl", "Type", "Cont")
-    ))
-    expect_equal(
-      find_terms(m1, flatten = TRUE),
-      c("Sat", "Infl", "Type", "Cont")
-    )
-  })
-
-  test_that("n_obs", {
-    expect_equal(n_obs(m1), 1681)
-  })
-
-  test_that("linkfun", {
-    expect_false(is.null(link_function(m1)))
-  })
-
-  test_that("linkinv", {
-    expect_false(is.null(link_inverse(m1)))
-  })
-
-  test_that("find_parameters", {
-    expect_equal(
-      find_parameters(m1),
-      list(
-        conditional = c(
-          "Low|Medium",
-          "Medium|High",
-          "InflMedium",
-          "InflHigh",
-          "TypeApartment",
-          "TypeAtrium",
-          "TypeTerrace",
-          "ContHigh"
-        )
-      )
-    )
-    expect_equal(nrow(get_parameters(m1)), 8)
-    expect_equal(
-      get_parameters(m1)$Parameter,
-      c(
+skip_if_not_installed("ordinal")
+skip_if_not_installed("MASS")
+
+data(housing, package = "MASS")
+m1 <- ordinal::clm2(Sat ~ Infl + Type + Cont, weights = Freq, data = housing)
+
+test_that("model_info", {
+  expect_true(model_info(m1)$is_ordinal)
+  expect_false(model_info(m1)$is_multinomial)
+  expect_false(model_info(m1)$is_linear)
+})
+
+test_that("find_predictors", {
+  expect_identical(find_predictors(m1), list(conditional = c("Infl", "Type", "Cont")))
+  expect_identical(
+    find_predictors(m1, flatten = TRUE),
+    c("Infl", "Type", "Cont")
+  )
+  expect_null(find_predictors(m1, effects = "random"))
+})
+
+test_that("find_random", {
+  expect_null(find_random(m1))
+})
+
+test_that("get_random", {
+  expect_warning(get_random(m1))
+})
+
+test_that("find_response", {
+  expect_identical(find_response(m1), "Sat")
+})
+
+test_that("get_response", {
+  expect_equal(get_response(m1), housing$Sat)
+})
+
+test_that("get_predictors", {
+  expect_equal(colnames(get_predictors(m1)), c("Infl", "Type", "Cont"))
+})
+
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), plogis(0.2), tolerance = 1e-5)
+})
+
+test_that("find_weights", {
+  expect_equal(find_weights(m1), "Freq")
+})
+
+test_that("get_weights", {
+  expect_equal(get_weights(m1), housing$Freq)
+})
+
+test_that("get_data", {
+  expect_equal(nrow(get_data(m1)), 72)
+  expect_equal(
+    colnames(get_data(m1)),
+    c("Sat", "Infl", "Type", "Cont", "Freq")
+  )
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1), 1)
+  expect_equal(
+    find_formula(m1),
+    list(conditional = as.formula("Sat ~ Infl + Type + Cont")),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_terms", {
+  expect_equal(find_terms(m1), list(
+    response = "Sat",
+    conditional = c("Infl", "Type", "Cont")
+  ))
+  expect_equal(
+    find_terms(m1, flatten = TRUE),
+    c("Sat", "Infl", "Type", "Cont")
+  )
+})
+
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 1681)
+})
+
+test_that("linkfun", {
+  expect_false(is.null(link_function(m1)))
+})
+
+test_that("linkinv", {
+  expect_false(is.null(link_inverse(m1)))
+})
+
+test_that("find_parameters", {
+  expect_equal(
+    find_parameters(m1),
+    list(
+      conditional = c(
         "Low|Medium",
         "Medium|High",
         "InflMedium",
@@ -122,13 +106,27 @@ if (
         "ContHigh"
       )
     )
-  })
+  )
+  expect_equal(nrow(get_parameters(m1)), 8)
+  expect_equal(
+    get_parameters(m1)$Parameter,
+    c(
+      "Low|Medium",
+      "Medium|High",
+      "InflMedium",
+      "InflHigh",
+      "TypeApartment",
+      "TypeAtrium",
+      "TypeTerrace",
+      "ContHigh"
+    )
+  )
+})
 
-  test_that("is_multivariate", {
-    expect_false(is_multivariate(m1))
-  })
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1))
+})
 
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "z-statistic")
-  })
-}
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "z-statistic")
+})
diff --git a/tests/testthat/test-clmm.R b/tests/testthat/test-clmm.R
index d5e265922..27b29d0e8 100644
--- a/tests/testthat/test-clmm.R
+++ b/tests/testthat/test-clmm.R
@@ -1,198 +1,199 @@
-if (skip_if_not_or_load_if_installed("lme4") && skip_if_not_or_load_if_installed("ordinal")) {
-  data(wine, package = "ordinal")
-  data(soup)
-
-  m1 <- clmm(rating ~ temp + contact + (1 | judge), data = wine)
-  m2 <- clmm(SURENESS ~ PROD + (1 | RESP) + (1 | RESP:PROD),
-    data = soup,
-    link = "probit",
-    threshold = "equidistant"
+skip_if_not_installed("lme4")
+skip_if_not_installed("ordinal")
+
+data(wine, package = "ordinal")
+data(soup, package = "ordinal")
+
+m1 <- ordinal::clmm(rating ~ temp + contact + (1 | judge), data = wine)
+m2 <- ordinal::clmm(SURENESS ~ PROD + (1 | RESP) + (1 | RESP:PROD),
+  data = soup,
+  link = "probit",
+  threshold = "equidistant"
+)
+
+test_that("model_info", {
+  expect_true(model_info(m1)$is_ordinal)
+  expect_true(model_info(m2)$is_ordinal)
+  expect_true(model_info(m1)$is_logit)
+  expect_true(model_info(m2)$is_probit)
+  expect_false(model_info(m1)$is_multinomial)
+  expect_false(model_info(m1)$is_linear)
+})
+
+test_that("find_predictors", {
+  expect_identical(find_predictors(m1), list(conditional = c("temp", "contact")))
+  expect_identical(
+    find_predictors(m1, effects = "all"),
+    list(
+      conditional = c("temp", "contact"),
+      random = "judge"
+    )
   )
-
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_ordinal)
-    expect_true(model_info(m2)$is_ordinal)
-    expect_true(model_info(m1)$is_logit)
-    expect_true(model_info(m2)$is_probit)
-    expect_false(model_info(m1)$is_multinomial)
-    expect_false(model_info(m1)$is_linear)
-  })
-
-  test_that("find_predictors", {
-    expect_identical(find_predictors(m1), list(conditional = c("temp", "contact")))
-    expect_identical(
-      find_predictors(m1, effects = "all"),
-      list(
-        conditional = c("temp", "contact"),
-        random = "judge"
-      )
+  expect_identical(
+    find_predictors(m1, effects = "all", flatten = TRUE),
+    c("temp", "contact", "judge")
+  )
+  expect_identical(find_predictors(m2), list(conditional = "PROD"))
+  expect_identical(
+    find_predictors(m2, effects = "all"),
+    list(
+      conditional = "PROD",
+      random = c("RESP", "PROD")
     )
-    expect_identical(
-      find_predictors(m1, effects = "all", flatten = TRUE),
-      c("temp", "contact", "judge")
+  )
+  expect_identical(
+    find_predictors(m2, effects = "all", flatten = TRUE),
+    c("PROD", "RESP")
+  )
+})
+
+test_that("find_random", {
+  expect_equal(find_random(m1), list(random = "judge"))
+  expect_equal(find_random(m2), list(random = c("RESP", "RESP:PROD")))
+  expect_equal(find_random(m2, split_nested = TRUE), list(random = c("RESP", "PROD")))
+})
+
+test_that("get_random", {
+  expect_equal(get_random(m1), wine[, "judge", drop = FALSE], ignore_attr = TRUE)
+  expect_equal(get_random(m2), soup[, c("RESP", "PROD"), drop = FALSE], ignore_attr = TRUE)
+})
+
+test_that("find_response", {
+  expect_identical(find_response(m1), "rating")
+  expect_identical(find_response(m2), "SURENESS")
+})
+
+test_that("get_response", {
+  expect_equal(get_response(m1), wine$rating)
+  expect_equal(get_response(m2), soup$SURENESS)
+})
+
+test_that("get_predictors", {
+  expect_equal(colnames(get_predictors(m1)), c("temp", "contact"))
+  expect_equal(colnames(get_predictors(m2)), "PROD")
+})
+
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), plogis(0.2), tolerance = 1e-5)
+  expect_equal(link_inverse(m2)(0.2), pnorm(0.2), tolerance = 1e-5)
+})
+
+test_that("get_data", {
+  expect_equal(nrow(get_data(m1)), 72)
+  expect_equal(
+    colnames(get_data(m1)),
+    c("rating", "temp", "contact", "judge")
+  )
+  expect_equal(nrow(get_data(m2)), 1847)
+  expect_equal(colnames(get_data(m2)), c("SURENESS", "PROD", "RESP"))
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1), 2)
+  expect_equal(
+    find_formula(m1),
+    list(
+      conditional = as.formula("rating ~ temp + contact"),
+      random = as.formula("~1 | judge")
+    ),
+    ignore_attr = TRUE
+  )
+  expect_length(find_formula(m2), 2)
+  expect_equal(
+    find_formula(m2),
+    list(
+      conditional = as.formula("SURENESS ~ PROD"),
+      random = list(as.formula("~1 | RESP"), as.formula("~1 | RESP:PROD"))
+    ),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_terms", {
+  expect_equal(
+    find_terms(m1),
+    list(
+      response = "rating",
+      conditional = c("temp", "contact"),
+      random = "judge"
     )
-    expect_identical(find_predictors(m2), list(conditional = "PROD"))
-    expect_identical(
-      find_predictors(m2, effects = "all"),
-      list(
-        conditional = "PROD",
-        random = c("RESP", "PROD")
-      )
+  )
+  expect_equal(
+    find_terms(m1, flatten = TRUE),
+    c("rating", "temp", "contact", "judge")
+  )
+  expect_equal(
+    find_terms(m2),
+    list(
+      response = "SURENESS",
+      conditional = "PROD",
+      random = c("RESP", "PROD")
     )
-    expect_identical(
-      find_predictors(m2, effects = "all", flatten = TRUE),
-      c("PROD", "RESP")
+  )
+  expect_equal(
+    find_terms(m2, flatten = TRUE),
+    c("SURENESS", "PROD", "RESP")
+  )
+})
+
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 72)
+  expect_equal(n_obs(m2), 1847)
+})
+
+test_that("linkfun", {
+  expect_false(is.null(link_function(m1)))
+  expect_false(is.null(link_function(m2)))
+})
+
+test_that("find_parameters", {
+  expect_equal(
+    find_parameters(m1),
+    list(
+      conditional = c("1|2", "2|3", "3|4", "4|5", "tempwarm", "contactyes")
     )
-  })
-
-  test_that("find_random", {
-    expect_equal(find_random(m1), list(random = "judge"))
-    expect_equal(find_random(m2), list(random = c("RESP", "RESP:PROD")))
-    expect_equal(find_random(m2, split_nested = TRUE), list(random = c("RESP", "PROD")))
-  })
-
-  test_that("get_random", {
-    expect_equal(get_random(m1), wine[, "judge", drop = FALSE], ignore_attr = TRUE)
-    expect_equal(get_random(m2), soup[, c("RESP", "PROD"), drop = FALSE], ignore_attr = TRUE)
-  })
-
-  test_that("find_response", {
-    expect_identical(find_response(m1), "rating")
-    expect_identical(find_response(m2), "SURENESS")
-  })
-
-  test_that("get_response", {
-    expect_equal(get_response(m1), wine$rating)
-    expect_equal(get_response(m2), soup$SURENESS)
-  })
-
-  test_that("get_predictors", {
-    expect_equal(colnames(get_predictors(m1)), c("temp", "contact"))
-    expect_equal(colnames(get_predictors(m2)), "PROD")
-  })
-
-  test_that("link_inverse", {
-    expect_equal(link_inverse(m1)(0.2), plogis(0.2), tolerance = 1e-5)
-    expect_equal(link_inverse(m2)(0.2), pnorm(0.2), tolerance = 1e-5)
-  })
+  )
+  expect_equal(
+    find_parameters(m2),
+    list(conditional = c("threshold.1", "spacing", "PRODTest"))
+  )
+})
 
-  test_that("get_data", {
-    expect_equal(nrow(get_data(m1)), 72)
-    expect_equal(
-      colnames(get_data(m1)),
-      c("rating", "temp", "contact", "judge")
-    )
-    expect_equal(nrow(get_data(m2)), 1847)
-    expect_equal(colnames(get_data(m2)), c("SURENESS", "PROD", "RESP"))
-  })
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1))
+  expect_false(is_multivariate(m2))
+})
 
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 2)
+if (getRversion() > "3.6.3") {
+  test_that("get_variance", {
     expect_equal(
-      find_formula(m1),
+      get_variance(m1),
       list(
-        conditional = as.formula("rating ~ temp + contact"),
-        random = as.formula("~1 | judge")
+        var.fixed = 3.23207765938872,
+        var.random = 1.27946088209319,
+        var.residual = 3.28986813369645,
+        var.distribution = 3.28986813369645,
+        var.dispersion = 0,
+        var.intercept = c(judge = 1.27946088209319)
       ),
-      ignore_attr = TRUE
+      tolerance = 1e-4
     )
-    expect_length(find_formula(m2), 2)
     expect_equal(
-      find_formula(m2),
+      get_variance(m2),
       list(
-        conditional = as.formula("SURENESS ~ PROD"),
-        random = list(as.formula("~1 | RESP"), as.formula("~1 | RESP:PROD"))
+        var.fixed = 0.132313576370902,
+        var.random = 0.193186321588604,
+        var.residual = 1,
+        var.distribution = 1,
+        var.dispersion = 0,
+        var.intercept = c(`RESP:PROD` = 0.148265480396059, RESP = 0.0449208411925493)
       ),
-      ignore_attr = TRUE
-    )
-  })
-
-  test_that("find_terms", {
-    expect_equal(
-      find_terms(m1),
-      list(
-        response = "rating",
-        conditional = c("temp", "contact"),
-        random = "judge"
-      )
-    )
-    expect_equal(
-      find_terms(m1, flatten = TRUE),
-      c("rating", "temp", "contact", "judge")
-    )
-    expect_equal(
-      find_terms(m2),
-      list(
-        response = "SURENESS",
-        conditional = "PROD",
-        random = c("RESP", "PROD")
-      )
-    )
-    expect_equal(
-      find_terms(m2, flatten = TRUE),
-      c("SURENESS", "PROD", "RESP")
+      tolerance = 1e-4
     )
   })
-
-  test_that("n_obs", {
-    expect_equal(n_obs(m1), 72)
-    expect_equal(n_obs(m2), 1847)
-  })
-
-  test_that("linkfun", {
-    expect_false(is.null(link_function(m1)))
-    expect_false(is.null(link_function(m2)))
-  })
-
-  test_that("find_parameters", {
-    expect_equal(
-      find_parameters(m1),
-      list(
-        conditional = c("1|2", "2|3", "3|4", "4|5", "tempwarm", "contactyes")
-      )
-    )
-    expect_equal(
-      find_parameters(m2),
-      list(conditional = c("threshold.1", "spacing", "PRODTest"))
-    )
-  })
-
-  test_that("is_multivariate", {
-    expect_false(is_multivariate(m1))
-    expect_false(is_multivariate(m2))
-  })
-
-  if (getRversion() > "3.6.3") {
-    test_that("get_variance", {
-      expect_equal(
-        get_variance(m1),
-        list(
-          var.fixed = 3.23207765938872,
-          var.random = 1.27946088209319,
-          var.residual = 3.28986813369645,
-          var.distribution = 3.28986813369645,
-          var.dispersion = 0,
-          var.intercept = c(judge = 1.27946088209319)
-        ),
-        tolerance = 1e-4
-      )
-      expect_equal(
-        get_variance(m2),
-        list(
-          var.fixed = 0.132313576370902,
-          var.random = 0.193186321588604,
-          var.residual = 1,
-          var.distribution = 1,
-          var.dispersion = 0,
-          var.intercept = c(`RESP:PROD` = 0.148265480396059, RESP = 0.0449208411925493)
-        ),
-        tolerance = 1e-4
-      )
-    })
-  }
-
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "z-statistic")
-    expect_identical(find_statistic(m2), "z-statistic")
-  })
 }
+
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "z-statistic")
+  expect_identical(find_statistic(m2), "z-statistic")
+})
diff --git a/tests/testthat/test-coxme.R b/tests/testthat/test-coxme.R
index b2997d6d5..5d71b6a7a 100644
--- a/tests/testthat/test-coxme.R
+++ b/tests/testthat/test-coxme.R
@@ -1,199 +1,200 @@
-if (
-
-  skip_if_not_or_load_if_installed("survival") &&
-    skip_if_not_or_load_if_installed("lme4") &&
-    skip_if_not_or_load_if_installed("nlme") &&
-    skip_if_not_or_load_if_installed("bdsmatrix") &&
-    skip_if_not_or_load_if_installed("coxme")) {
-  set.seed(1234)
-  lung$inst2 <- sample(1:10, size = nrow(lung), replace = TRUE)
-  lung <- subset(lung, subset = ph.ecog %in% 0:2)
-  lung$ph.ecog <- factor(lung$ph.ecog, labels = c("good", "ok", "limited"))
-
-  d <<- lung
-
-  m1 <- coxme(Surv(time, status) ~ ph.ecog + age + (1 | inst), d)
-  m2 <- coxme(Surv(time, status) ~ ph.ecog + age + (1 | inst) + (1 | inst2), d)
-
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_logit)
-    expect_false(model_info(m1)$is_linear)
-  })
-
-  test_that("find_predictors", {
-    expect_identical(find_predictors(m1), list(conditional = c("ph.ecog", "age")))
-    expect_identical(
-      find_predictors(m1, effects = "random"),
-      list(random = "inst")
-    )
-    expect_identical(find_predictors(m2), list(conditional = c("ph.ecog", "age")))
-    expect_identical(find_predictors(m2, effects = "random"), list(random = c("inst", "inst2")))
-  })
-
-  test_that("find_response", {
-    expect_identical(find_response(m1), "Surv(time, status)")
-    expect_identical(find_response(m1, combine = FALSE), c("time", "status"))
-  })
-
-  test_that("link_inverse", {
-    expect_equal(link_inverse(m1)(0.2), plogis(0.2), tolerance = 1e-5)
-    expect_equal(link_inverse(m2)(0.2), plogis(0.2), tolerance = 1e-5)
-  })
-
-  test_that("get_data", {
-    expect_equal(nrow(get_data(m1)), 225)
-    expect_equal(
-      colnames(get_data(m1)),
-      c(
-        "time",
-        "status",
-        "ph.ecog",
-        "age",
-        "inst"
-      )
-    )
-    expect_equal(
-      colnames(get_data(m2)),
-      c(
-        "time",
-        "status",
-        "ph.ecog",
-        "age",
-        "inst",
-        "inst2"
-      )
-    )
-  })
-
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 2)
-    expect_equal(
-      find_formula(m1),
-      list(
-        conditional = as.formula("Surv(time, status) ~ ph.ecog + age"),
-        random = as.formula("~1 | inst")
-      ),
-      ignore_attr = TRUE
-    )
-
-    expect_length(find_formula(m2), 2)
-    expect_equal(
-      find_formula(m2),
-      list(
-        conditional = as.formula("Surv(time, status) ~ ph.ecog + age"),
-        random = list(as.formula("~1 | inst"), as.formula("~1 | inst2"))
-      ),
-      ignore_attr = TRUE
-    )
-  })
-
-  test_that("find_terms", {
-    expect_equal(
-      find_terms(m1),
-      list(
-        response = "Surv(time, status)",
-        conditional = c("ph.ecog", "age"),
-        random = "inst"
-      )
-    )
-    expect_equal(
-      find_terms(m1, flatten = TRUE),
-      c("Surv(time, status)", "ph.ecog", "age", "inst")
-    )
-    expect_equal(
-      find_terms(m2),
-      list(
-        response = "Surv(time, status)",
-        conditional = c("ph.ecog", "age"),
-        random = c("inst", "inst2")
-      )
-    )
-    expect_equal(
-      find_terms(m2, flatten = TRUE),
-      c("Surv(time, status)", "ph.ecog", "age", "inst", "inst2")
-    )
-  })
-
-  test_that("find_variables", {
-    expect_equal(
-      find_variables(m1),
-      list(
-        response = c("time", "status"),
-        conditional = c("ph.ecog", "age"),
-        random = "inst"
-      )
-    )
-    expect_equal(
-      find_variables(m1, flatten = TRUE),
-      c("time", "status", "ph.ecog", "age", "inst")
-    )
-    expect_equal(
-      find_variables(m2),
-      list(
-        response = c("time", "status"),
-        conditional = c("ph.ecog", "age"),
-        random = c("inst", "inst2")
-      )
-    )
-    expect_equal(
-      find_variables(m2, flatten = TRUE),
-      c("time", "status", "ph.ecog", "age", "inst", "inst2")
-    )
-  })
-
-  test_that("n_obs", {
-    expect_equal(n_obs(m1), 225)
-    expect_equal(n_obs(m2), 225)
-  })
-
-  test_that("get_response", {
-    expect_equal(colnames(get_response(m1)), c("time", "status"))
-    expect_equal(nrow(get_response(m1)), 225)
-    expect_equal(colnames(get_response(m1)), c("time", "status"))
-    expect_equal(nrow(get_response(m2)), 225)
-  })
-
-  test_that("linkfun", {
-    expect_false(is.null(link_function(m1)))
-    expect_false(is.null(link_function(m2)))
-  })
-
-  test_that("is_multivariate", {
-    expect_false(is_multivariate(m1))
-  })
-
-  test_that("find_parameters", {
-    expect_equal(
-      find_parameters(m1),
-      list(
-        conditional = c("ph.ecogok", "ph.ecoglimited", "age"),
-        random = "inst"
-      )
-    )
-    expect_equal(
-      find_parameters(m2),
-      list(
-        conditional = c("ph.ecogok", "ph.ecoglimited", "age"),
-        random = c("inst", "inst2")
-      )
-    )
-    expect_equal(nrow(get_parameters(m1)), 3)
-    expect_equal(
-      get_parameters(m1)$Parameter,
-      c("ph.ecogok", "ph.ecoglimited", "age")
-    )
-
-    expect_equal(nrow(get_parameters(m2)), 3)
-    expect_equal(
-      get_parameters(m2)$Parameter,
-      c("ph.ecogok", "ph.ecoglimited", "age")
-    )
-
-    expect_length(get_parameters(m2, effects = "random"), 2)
-  })
-
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "z-statistic")
-    expect_identical(find_statistic(m2), "z-statistic")
-  })
-}
+skip_if_not_installed("survival")
+skip_if_not_installed("lme4")
+skip_if_not_installed("nlme")
+skip_if_not_installed("bdsmatrix")
+skip_if_not_installed("coxme")
+
+lung <- survival::lung
+Surv <- survival::Surv
+
+set.seed(1234)
+lung$inst2 <- sample(1:10, size = nrow(lung), replace = TRUE)
+lung <- subset(lung, subset = ph.ecog %in% 0:2)
+lung$ph.ecog <- factor(lung$ph.ecog, labels = c("good", "ok", "limited"))
+
+d <<- lung
+
+m1 <- coxme::coxme(Surv(time, status) ~ ph.ecog + age + (1 | inst), d)
+m2 <- coxme::coxme(Surv(time, status) ~ ph.ecog + age + (1 | inst) + (1 | inst2), d)
+
+test_that("model_info", {
+  expect_true(model_info(m1)$is_logit)
+  expect_false(model_info(m1)$is_linear)
+})
+
+test_that("find_predictors", {
+  expect_identical(find_predictors(m1), list(conditional = c("ph.ecog", "age")))
+  expect_identical(
+    find_predictors(m1, effects = "random"),
+    list(random = "inst")
+  )
+  expect_identical(find_predictors(m2), list(conditional = c("ph.ecog", "age")))
+  expect_identical(find_predictors(m2, effects = "random"), list(random = c("inst", "inst2")))
+})
+
+test_that("find_response", {
+  expect_identical(find_response(m1), "Surv(time, status)")
+  expect_identical(find_response(m1, combine = FALSE), c("time", "status"))
+})
+
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), plogis(0.2), tolerance = 1e-5)
+  expect_equal(link_inverse(m2)(0.2), plogis(0.2), tolerance = 1e-5)
+})
+
+test_that("get_data", {
+  expect_equal(nrow(get_data(m1)), 225)
+  expect_equal(
+    colnames(get_data(m1)),
+    c(
+      "time",
+      "status",
+      "ph.ecog",
+      "age",
+      "inst"
+    )
+  )
+  expect_equal(
+    colnames(get_data(m2)),
+    c(
+      "time",
+      "status",
+      "ph.ecog",
+      "age",
+      "inst",
+      "inst2"
+    )
+  )
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1), 2)
+  expect_equal(
+    find_formula(m1),
+    list(
+      conditional = as.formula("Surv(time, status) ~ ph.ecog + age"),
+      random = as.formula("~1 | inst")
+    ),
+    ignore_attr = TRUE
+  )
+
+  expect_length(find_formula(m2), 2)
+  expect_equal(
+    find_formula(m2),
+    list(
+      conditional = as.formula("Surv(time, status) ~ ph.ecog + age"),
+      random = list(as.formula("~1 | inst"), as.formula("~1 | inst2"))
+    ),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_terms", {
+  expect_equal(
+    find_terms(m1),
+    list(
+      response = "Surv(time, status)",
+      conditional = c("ph.ecog", "age"),
+      random = "inst"
+    )
+  )
+  expect_equal(
+    find_terms(m1, flatten = TRUE),
+    c("Surv(time, status)", "ph.ecog", "age", "inst")
+  )
+  expect_equal(
+    find_terms(m2),
+    list(
+      response = "Surv(time, status)",
+      conditional = c("ph.ecog", "age"),
+      random = c("inst", "inst2")
+    )
+  )
+  expect_equal(
+    find_terms(m2, flatten = TRUE),
+    c("Surv(time, status)", "ph.ecog", "age", "inst", "inst2")
+  )
+})
+
+test_that("find_variables", {
+  expect_equal(
+    find_variables(m1),
+    list(
+      response = c("time", "status"),
+      conditional = c("ph.ecog", "age"),
+      random = "inst"
+    )
+  )
+  expect_equal(
+    find_variables(m1, flatten = TRUE),
+    c("time", "status", "ph.ecog", "age", "inst")
+  )
+  expect_equal(
+    find_variables(m2),
+    list(
+      response = c("time", "status"),
+      conditional = c("ph.ecog", "age"),
+      random = c("inst", "inst2")
+    )
+  )
+  expect_equal(
+    find_variables(m2, flatten = TRUE),
+    c("time", "status", "ph.ecog", "age", "inst", "inst2")
+  )
+})
+
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 225)
+  expect_equal(n_obs(m2), 225)
+})
+
+test_that("get_response", {
+  expect_equal(colnames(get_response(m1)), c("time", "status"))
+  expect_equal(nrow(get_response(m1)), 225)
+  expect_equal(colnames(get_response(m1)), c("time", "status"))
+  expect_equal(nrow(get_response(m2)), 225)
+})
+
+test_that("linkfun", {
+  expect_false(is.null(link_function(m1)))
+  expect_false(is.null(link_function(m2)))
+})
+
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1))
+})
+
+test_that("find_parameters", {
+  expect_equal(
+    find_parameters(m1),
+    list(
+      conditional = c("ph.ecogok", "ph.ecoglimited", "age"),
+      random = "inst"
+    )
+  )
+  expect_equal(
+    find_parameters(m2),
+    list(
+      conditional = c("ph.ecogok", "ph.ecoglimited", "age"),
+      random = c("inst", "inst2")
+    )
+  )
+  expect_equal(nrow(get_parameters(m1)), 3)
+  expect_equal(
+    get_parameters(m1)$Parameter,
+    c("ph.ecogok", "ph.ecoglimited", "age")
+  )
+
+  expect_equal(nrow(get_parameters(m2)), 3)
+  expect_equal(
+    get_parameters(m2)$Parameter,
+    c("ph.ecogok", "ph.ecoglimited", "age")
+  )
+
+  expect_length(get_parameters(m2, effects = "random"), 2)
+})
+
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "z-statistic")
+  expect_identical(find_statistic(m2), "z-statistic")
+})
diff --git a/tests/testthat/test-coxph.R b/tests/testthat/test-coxph.R
index 0c1942562..2539e195b 100644
--- a/tests/testthat/test-coxph.R
+++ b/tests/testthat/test-coxph.R
@@ -1,12 +1,16 @@
-skip_if_not_or_load_if_installed("survival")
-skip_if_not_or_load_if_installed("insight")
-skip_if_not_or_load_if_installed("JM")
+skip_if_not_installed("survival")
+skip_if_not_installed("insight")
+skip_if_not_installed("JM")
 
 lung <- subset(survival::lung, subset = ph.ecog %in% 0:2)
 lung$sex <- factor(lung$sex, labels = c("male", "female"))
 lung$ph.ecog <- factor(lung$ph.ecog, labels = c("good", "ok", "limited"))
 
-m1 <- coxph(Surv(time, status) ~ sex + age + ph.ecog, data = lung)
+Surv <- survival::Surv
+strata <- survival::strata
+bladder <- survival::bladder
+
+m1 <- survival::coxph(Surv(time, status) ~ sex + age + ph.ecog, data = lung)
 
 
 test_that("model_info", {
@@ -44,7 +48,7 @@ test_that("get_data: regression test for previous bug", {
     x = c(0, 2, 1, 1, 1, 0, 0),
     sex = c(0, 0, 0, 0, 1, 1, 1)
   )
-  mod <- coxph(Surv(time, status) ~ x + strata(sex),
+  mod <- survival::coxph(Surv(time, status) ~ x + strata(sex),
     data = dat_regression_test,
     ties = "breslow"
   )
@@ -133,7 +137,7 @@ test_that("find_statistic", {
 
 test_that("JM", {
   data("aids", package = "JM")
-  m <- coxph(Surv(start, stop, event) ~ CD4, data = aids)
+  m <- survival::coxph(Surv(start, stop, event) ~ CD4, data = aids)
   d <- get_data(m)
   expect_equal(dim(d), c(1405, 4))
   expect_equal(colnames(d), c("start", "stop", "event", "CD4"))
@@ -141,9 +145,9 @@ test_that("JM", {
 })
 
 test_that("get_statistic", {
-  skip_if_not_or_load_if_installed("survival")
+  skip_if_not_installed("survival")
   bladder1 <- bladder[bladder$enum < 5, ]
-  mod <- coxph(
+  mod <- survival::coxph(
     Surv(stop, event) ~ (rx + size + number) * strata(enum),
     cluster = id, bladder1, robust = TRUE
   )
@@ -153,7 +157,7 @@ test_that("get_statistic", {
 
   lung <- survival::lung
   mod <- survival::coxph(
-    formula = Surv(time, status) ~ age + sex + frailty(inst),
+    formula = Surv(time, status) ~ age + sex + survival::frailty(inst),
     data = lung
   )
   z1 <- get_statistic(mod)$Statistic
diff --git a/tests/testthat/test-cpglmm.R b/tests/testthat/test-cpglmm.R
index a04e7fe5a..988ba5a99 100644
--- a/tests/testthat/test-cpglmm.R
+++ b/tests/testthat/test-cpglmm.R
@@ -1,164 +1,167 @@
-if (
-
-  skip_if_not_or_load_if_installed("cplm")) {
-  data("FineRoot")
-  m1 <- cpglmm(RLD ~ Stock + Spacing + (1 | Plant), data = FineRoot)
-
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_count)
-    expect_false(model_info(m1)$is_linear)
-  })
-
-  test_that("find_predictors", {
-    expect_equal(
-      find_predictors(m1, effects = "all"),
-      list(conditional = c("Stock", "Spacing"), random = "Plant")
-    )
-    expect_equal(
-      find_predictors(m1, effects = "all", flatten = TRUE),
-      c("Stock", "Spacing", "Plant")
-    )
-    expect_equal(
-      find_predictors(m1, effects = "fixed"),
-      list(conditional = c("Stock", "Spacing"))
-    )
-    expect_equal(
-      find_predictors(m1, effects = "fixed", flatten = TRUE),
-      c("Stock", "Spacing")
-    )
-    expect_equal(
-      find_predictors(m1, effects = "random"),
-      list(random = "Plant")
-    )
-    expect_equal(
-      find_predictors(m1, effects = "random", flatten = TRUE),
-      "Plant"
-    )
-  })
-
-  test_that("find_random", {
-    expect_equal(find_random(m1), list(random = "Plant"))
-    expect_equal(find_random(m1, flatten = TRUE), "Plant")
-  })
-
-  test_that("find_response", {
-    expect_identical(find_response(m1), "RLD")
-  })
-
-  test_that("get_response", {
-    expect_equal(get_response(m1), FineRoot$RLD)
-  })
-
-
-  test_that("get_data", {
-    expect_equal(colnames(get_data(m1)), c("RLD", "Stock", "Spacing", "Plant"))
-    expect_equal(colnames(get_data(m1, effects = "all")), c("RLD", "Stock", "Spacing", "Plant"))
-    expect_equal(colnames(get_data(m1, effects = "random")), "Plant")
-  })
-
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 2)
-    expect_equal(
-      find_formula(m1, component = "conditional"),
-      list(
-        conditional = as.formula("RLD ~ Stock + Spacing"),
-        random = as.formula("~1 | Plant")
-      ),
-      ignore_attr = TRUE
-    )
-  })
-
-  test_that("find_terms", {
-    expect_identical(
-      find_terms(m1),
-      list(
-        response = "RLD",
-        conditional = c("Stock", "Spacing"),
-        random = "Plant"
-      )
-    )
-    expect_identical(
-      find_terms(m1, flatten = TRUE),
-      c("RLD", "Stock", "Spacing", "Plant")
-    )
-  })
-
-
-  test_that("link_function", {
-    expect_equal(link_function(m1)(0.2), log(0.2), tolerance = 1e-3)
-  })
-
-  test_that("link_inverse", {
-    expect_equal(link_inverse(m1)(0.2), exp(0.2), tolerance = 1e-3)
-  })
-
-
-  test_that("find_variables", {
-    expect_identical(
-      find_variables(m1),
-      list(
-        response = "RLD",
-        conditional = c("Stock", "Spacing"),
-        random = "Plant"
-      )
+skip_if_not_installed("cplm")
+
+# cplm::cpglmm doesn't work
+suppressPackageStartupMessages(library(cplm))
+
+data("FineRoot", package = "cplm")
+m1 <- cpglmm(RLD ~ Stock + Spacing + (1 | Plant), data = FineRoot)
+
+test_that("model_info", {
+  expect_true(model_info(m1)$is_count)
+  expect_false(model_info(m1)$is_linear)
+})
+
+test_that("find_predictors", {
+  expect_equal(
+    find_predictors(m1, effects = "all"),
+    list(conditional = c("Stock", "Spacing"), random = "Plant")
+  )
+  expect_equal(
+    find_predictors(m1, effects = "all", flatten = TRUE),
+    c("Stock", "Spacing", "Plant")
+  )
+  expect_equal(
+    find_predictors(m1, effects = "fixed"),
+    list(conditional = c("Stock", "Spacing"))
+  )
+  expect_equal(
+    find_predictors(m1, effects = "fixed", flatten = TRUE),
+    c("Stock", "Spacing")
+  )
+  expect_equal(
+    find_predictors(m1, effects = "random"),
+    list(random = "Plant")
+  )
+  expect_equal(
+    find_predictors(m1, effects = "random", flatten = TRUE),
+    "Plant"
+  )
+})
+
+test_that("find_random", {
+  expect_equal(find_random(m1), list(random = "Plant"))
+  expect_equal(find_random(m1, flatten = TRUE), "Plant")
+})
+
+test_that("find_response", {
+  expect_identical(find_response(m1), "RLD")
+})
+
+test_that("get_response", {
+  expect_equal(get_response(m1), FineRoot$RLD)
+})
+
+
+test_that("get_data", {
+  expect_equal(colnames(get_data(m1)), c("RLD", "Stock", "Spacing", "Plant"))
+  expect_equal(colnames(get_data(m1, effects = "all")), c("RLD", "Stock", "Spacing", "Plant"))
+  expect_equal(colnames(get_data(m1, effects = "random")), "Plant")
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1), 2)
+  expect_equal(
+    find_formula(m1, component = "conditional"),
+    list(
+      conditional = as.formula("RLD ~ Stock + Spacing"),
+      random = as.formula("~1 | Plant")
+    ),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_terms", {
+  expect_identical(
+    find_terms(m1),
+    list(
+      response = "RLD",
+      conditional = c("Stock", "Spacing"),
+      random = "Plant"
     )
-    expect_identical(
-      find_variables(m1, flatten = TRUE),
-      c("RLD", "Stock", "Spacing", "Plant")
+  )
+  expect_identical(
+    find_terms(m1, flatten = TRUE),
+    c("RLD", "Stock", "Spacing", "Plant")
+  )
+})
+
+
+test_that("link_function", {
+  expect_equal(link_function(m1)(0.2), log(0.2), tolerance = 1e-3)
+})
+
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), exp(0.2), tolerance = 1e-3)
+})
+
+
+test_that("find_variables", {
+  expect_identical(
+    find_variables(m1),
+    list(
+      response = "RLD",
+      conditional = c("Stock", "Spacing"),
+      random = "Plant"
     )
-  })
-
-  test_that("get_predictors", {
-    expect_identical(colnames(get_predictors(m1)), c("Stock", "Spacing"))
-  })
-
-  test_that("get_random", {
-    expect_identical(colnames(get_random(m1)), "Plant")
-  })
-
-  test_that("clean_names", {
-    expect_identical(clean_names(m1), c("RLD", "Stock", "Spacing", "Plant"))
-  })
-
-  test_that("find_parameters", {
-    expect_equal(
-      find_parameters(m1),
-      list(
-        conditional = c("(Intercept)", "StockMM106", "StockMark", "Spacing5x3"),
-        random = list(Plant = c("(Intercept)"))
-      )
+  )
+  expect_identical(
+    find_variables(m1, flatten = TRUE),
+    c("RLD", "Stock", "Spacing", "Plant")
+  )
+})
+
+test_that("get_predictors", {
+  expect_identical(colnames(get_predictors(m1)), c("Stock", "Spacing"))
+})
+
+test_that("get_random", {
+  expect_identical(colnames(get_random(m1)), "Plant")
+})
+
+test_that("clean_names", {
+  expect_identical(clean_names(m1), c("RLD", "Stock", "Spacing", "Plant"))
+})
+
+test_that("find_parameters", {
+  expect_equal(
+    find_parameters(m1),
+    list(
+      conditional = c("(Intercept)", "StockMM106", "StockMark", "Spacing5x3"),
+      random = list(Plant = c("(Intercept)"))
     )
-    expect_equal(nrow(get_parameters(m1)), 4)
-    expect_equal(get_parameters(m1)$Parameter, c("(Intercept)", "StockMM106", "StockMark", "Spacing5x3"))
-  })
-
-  test_that("is_multivariate", {
-    expect_false(is_multivariate(m1))
-  })
-
-  if (getRversion() > "3.6.3" && !.Platform$OS.type == "windows" && !.Platform$r_arch == "i386") {
-    test_that("get_variance", {
-      skip_on_cran()
-      expect_equal(
-        suppressWarnings(get_variance(m1)),
-        list(
-          var.fixed = 0.1687617,
-          var.random = 0.0002706301,
-          var.residual = 2.763129,
-          var.distribution = 2.763129,
-          var.dispersion = 0,
-          var.intercept = c(Plant = 0.0002706301)
-        ),
-        tolerance = 1e-3
-      )
-    })
-  }
-
-  test_that("find_random_slopes", {
-    expect_null(find_random_slopes(m1))
-  })
-
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "t-statistic")
-  })
-}
+  )
+  expect_equal(nrow(get_parameters(m1)), 4)
+  expect_equal(get_parameters(m1)$Parameter, c("(Intercept)", "StockMM106", "StockMark", "Spacing5x3"))
+})
+
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1))
+})
+
+test_that("get_variance", {
+  skip_if_not(getRversion() > "3.6.3")
+  skip_on_os("windows", arch = "i386")
+  skip_on_cran()
+  expect_equal(
+    suppressWarnings(get_variance(m1)),
+    list(
+      var.fixed = 0.1687617,
+      var.random = 0.0002706301,
+      var.residual = 2.763129,
+      var.distribution = 2.763129,
+      var.dispersion = 0,
+      var.intercept = c(Plant = 0.0002706301)
+    ),
+    tolerance = 1e-3
+  )
+})
+
+test_that("find_random_slopes", {
+  expect_null(find_random_slopes(m1))
+})
+
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "t-statistic")
+})
+
+unloadNamespace("cplm")
diff --git a/tests/testthat/test-crch.R b/tests/testthat/test-crch.R
index 194f16ff9..e554afbbc 100644
--- a/tests/testthat/test-crch.R
+++ b/tests/testthat/test-crch.R
@@ -1,116 +1,114 @@
-if (
-
-  skip_if_not_or_load_if_installed("crch")) {
-  data("RainIbk")
-  RainIbk$sqrtensmean <<- apply(sqrt(RainIbk[, grep("^rainfc", names(RainIbk))]), 1, mean)
-  RainIbk$sqrtenssd <<- apply(sqrt(RainIbk[, grep("^rainfc", names(RainIbk))]), 1, sd)
-
-  m1 <- crch(sqrt(rain) ~ sqrtensmean, data = RainIbk, dist = "gaussian")
-
-  test_that("model_info", {
-    expect_false(model_info(m1)$is_linear)
-    expect_true(model_info(m1)$is_censored)
-  })
-
-  test_that("find_predictors", {
-    expect_identical(find_predictors(m1), list(conditional = c("sqrtensmean")))
-    expect_identical(find_predictors(m1, flatten = TRUE), c("sqrtensmean"))
-    expect_null(find_predictors(m1, effects = "random"))
-  })
-
-  test_that("find_random", {
-    expect_null(find_random(m1))
-  })
-
-  test_that("get_random", {
-    expect_warning(get_random(m1))
-  })
-
-  test_that("find_response", {
-    expect_identical(find_response(m1), "rain")
-  })
-
-  test_that("get_response", {
-    expect_equal(get_response(m1), RainIbk$rain)
-  })
-
-  test_that("get_predictors", {
-    expect_equal(colnames(get_predictors(m1)), c("sqrtensmean"))
-  })
-
-  test_that("link_inverse", {
-    expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
-  })
-
-  test_that("get_data", {
-    expect_equal(nrow(get_data(m1)), 4971)
-    expect_equal(colnames(get_data(m1)), c("rain", "sqrtensmean"))
-  })
-
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 1)
-    expect_equal(
-      find_formula(m1),
-      list(conditional = as.formula("sqrt(rain) ~ sqrtensmean")),
-      ignore_attr = TRUE
+skip_if_not_installed("crch")
+
+data("RainIbk", package = "crch")
+RainIbk$sqrtensmean <<- apply(sqrt(RainIbk[, grep("^rainfc", names(RainIbk))]), 1, mean)
+RainIbk$sqrtenssd <<- apply(sqrt(RainIbk[, grep("^rainfc", names(RainIbk))]), 1, sd)
+
+m1 <- crch::crch(sqrt(rain) ~ sqrtensmean, data = RainIbk, dist = "gaussian")
+
+test_that("model_info", {
+  expect_false(model_info(m1)$is_linear)
+  expect_true(model_info(m1)$is_censored)
+})
+
+test_that("find_predictors", {
+  expect_identical(find_predictors(m1), list(conditional = c("sqrtensmean")))
+  expect_identical(find_predictors(m1, flatten = TRUE), c("sqrtensmean"))
+  expect_null(find_predictors(m1, effects = "random"))
+})
+
+test_that("find_random", {
+  expect_null(find_random(m1))
+})
+
+test_that("get_random", {
+  expect_warning(get_random(m1))
+})
+
+test_that("find_response", {
+  expect_identical(find_response(m1), "rain")
+})
+
+test_that("get_response", {
+  expect_equal(get_response(m1), RainIbk$rain)
+})
+
+test_that("get_predictors", {
+  expect_equal(colnames(get_predictors(m1)), c("sqrtensmean"))
+})
+
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
+})
+
+test_that("get_data", {
+  expect_equal(nrow(get_data(m1)), 4971)
+  expect_equal(colnames(get_data(m1)), c("rain", "sqrtensmean"))
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1), 1)
+  expect_equal(
+    find_formula(m1),
+    list(conditional = as.formula("sqrt(rain) ~ sqrtensmean")),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_terms", {
+  expect_equal(
+    find_terms(m1),
+    list(
+      response = "sqrt(rain)",
+      conditional = c("sqrtensmean")
     )
-  })
-
-  test_that("find_terms", {
-    expect_equal(
-      find_terms(m1),
-      list(
-        response = "sqrt(rain)",
-        conditional = c("sqrtensmean")
-      )
+  )
+  expect_equal(
+    find_terms(m1, flatten = TRUE),
+    c("sqrt(rain)", "sqrtensmean")
+  )
+})
+
+test_that("find_variables", {
+  expect_equal(
+    find_variables(m1),
+    list(
+      response = "rain",
+      conditional = c("sqrtensmean")
     )
-    expect_equal(
-      find_terms(m1, flatten = TRUE),
-      c("sqrt(rain)", "sqrtensmean")
+  )
+  expect_equal(
+    find_variables(m1, flatten = TRUE),
+    c("rain", "sqrtensmean")
+  )
+})
+
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 4971)
+})
+
+test_that("linkfun", {
+  expect_false(is.null(link_function(m1)))
+})
+
+test_that("find_parameters", {
+  expect_equal(
+    find_parameters(m1),
+    list(
+      conditional = c("(Intercept)", "sqrtensmean", "(scale)_(Intercept)")
     )
-  })
-
-  test_that("find_variables", {
-    expect_equal(
-      find_variables(m1),
-      list(
-        response = "rain",
-        conditional = c("sqrtensmean")
-      )
-    )
-    expect_equal(
-      find_variables(m1, flatten = TRUE),
-      c("rain", "sqrtensmean")
-    )
-  })
-
-  test_that("n_obs", {
-    expect_equal(n_obs(m1), 4971)
-  })
-
-  test_that("linkfun", {
-    expect_false(is.null(link_function(m1)))
-  })
-
-  test_that("find_parameters", {
-    expect_equal(
-      find_parameters(m1),
-      list(
-        conditional = c("(Intercept)", "sqrtensmean", "(scale)_(Intercept)")
-      )
-    )
-    expect_equal(nrow(get_parameters(m1)), 3)
-    expect_equal(
-      get_parameters(m1)$Parameter,
-      c("(Intercept)", "sqrtensmean", "(scale)_(Intercept)")
-    )
-  })
-
-  test_that("is_multivariate", {
-    expect_false(is_multivariate(m1))
-  })
-
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "z-statistic")
-  })
-}
+  )
+  expect_equal(nrow(get_parameters(m1)), 3)
+  expect_equal(
+    get_parameters(m1)$Parameter,
+    c("(Intercept)", "sqrtensmean", "(scale)_(Intercept)")
+  )
+})
+
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1))
+})
+
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "z-statistic")
+})
diff --git a/tests/testthat/test-crq.R b/tests/testthat/test-crq.R
index 1a10125e9..f6b78a0ff 100644
--- a/tests/testthat/test-crq.R
+++ b/tests/testthat/test-crq.R
@@ -1,115 +1,115 @@
-if (skip_if_not_or_load_if_installed("quantreg")) {
-  set.seed(123)
-  n <- 200
-  x <- rnorm(n)
-  y <- 5 + x + rnorm(n)
-  c <- 4 + x + rnorm(n)
-  d <- (y > c)
-
-  dat <<- data.frame(y, x, c, d)
-
-  # model
-  m1 <- crq(survival::Surv(pmax(y, c), d, type = "left") ~ x, method = "Portnoy", data = dat)
-
-  test_that("model_info", {
-    expect_false(model_info(m1)$is_linear)
-    expect_true(model_info(m1)$is_censored)
-  })
-
-  test_that("find_predictors", {
-    expect_identical(
-      find_predictors(m1),
-      list(conditional = "x")
+skip_if_not_installed("quantreg")
+skip_if_not_installed("survival")
+
+set.seed(123)
+n <- 200
+x <- rnorm(n)
+y <- 5 + x + rnorm(n)
+c <- 4 + x + rnorm(n)
+d <- (y > c)
+
+dat <<- data.frame(y, x, c, d)
+
+# model
+m1 <- quantreg::crq(survival::Surv(pmax(y, c), d, type = "left") ~ x, method = "Portnoy", data = dat)
+
+test_that("model_info", {
+  expect_false(model_info(m1)$is_linear)
+  expect_true(model_info(m1)$is_censored)
+})
+
+test_that("find_predictors", {
+  expect_identical(
+    find_predictors(m1),
+    list(conditional = "x")
+  )
+})
+
+test_that("find_random", {
+  expect_null(find_random(m1))
+})
+
+
+test_that("find_response", {
+  expect_identical(find_response(m1), "survival::Surv(pmax(y, c), d, type = \"left\")")
+})
+
+test_that("get_predictors", {
+  expect_equal(colnames(get_predictors(m1)), "x")
+})
+
+test_that("get_data", {
+  expect_equal(nrow(get_data(m1)), 200)
+  expect_equal(
+    colnames(get_data(m1)),
+    c("y", "c", "d", "x")
+  )
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1), 1)
+  expect_equal(
+    find_formula(m1),
+    list(conditional = as.formula("survival::Surv(pmax(y, c), d, type = \"left\") ~ x")),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_terms", {
+  expect_equal(
+    find_terms(m1),
+    list(
+      response = "Surv(pmax(y, c), d, type = \"left\")",
+      conditional = "x"
     )
-  })
-
-  test_that("find_random", {
-    expect_null(find_random(m1))
-  })
-
-
-  test_that("find_response", {
-    expect_identical(find_response(m1), "survival::Surv(pmax(y, c), d, type = \"left\")")
-  })
-
-  test_that("get_predictors", {
-    expect_equal(colnames(get_predictors(m1)), "x")
-  })
-
-  test_that("get_data", {
-    expect_equal(nrow(get_data(m1)), 200)
-    expect_equal(
-      colnames(get_data(m1)),
-      c("y", "c", "d", "x")
-    )
-  })
-
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 1)
-    expect_equal(
-      find_formula(m1),
-      list(conditional = as.formula("survival::Surv(pmax(y, c), d, type = \"left\") ~ x")),
-      ignore_attr = TRUE
-    )
-  })
-
-  test_that("find_terms", {
-    expect_equal(
-      find_terms(m1),
-      list(
-        response = "Surv(pmax(y, c), d, type = \"left\")",
-        conditional = "x"
-      )
-    )
-    expect_equal(
-      find_terms(m1, flatten = TRUE),
-      c("Surv(pmax(y, c), d, type = \"left\")", "x")
-    )
-  })
-
-  test_that("n_obs", {
-    expect_equal(n_obs(m1), 200)
-  })
-
-  test_that("link_function", {
-    expect_equal(link_function(m1)(0.2), 0.2, tolerance = 1e-5)
-  })
-
-  test_that("link_inverse", {
-    expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
-  })
-
-  test_that("find_parameters", {
-    expect_equal(
-      find_parameters(m1),
-      list(conditional = c("(Intercept)", "x"))
-    )
-    expect_equal(nrow(get_parameters(m1)), 8)
-    expect_equal(
-      get_parameters(m1)$Parameter,
-      c("(Intercept)", "x", "(Intercept)", "x", "(Intercept)", "x", "(Intercept)", "x")
-    )
-    expect_equal(
-      get_parameters(m1)$Component,
-      c("tau (0.2)", "tau (0.2)", "tau (0.4)", "tau (0.4)", "tau (0.6)", "tau (0.6)", "tau (0.8)", "tau (0.8)")
-    )
-  })
-
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "t-statistic")
-  })
-
-  if (getRversion() >= "3.6.0") {
-    test_that("get_statistic", {
-      expect_equal(
-        get_statistic(m1)$Parameter,
-        c("(Intercept)", "x", "(Intercept)", "x", "(Intercept)", "x", "(Intercept)", "x")
-      )
-      expect_equal(
-        get_statistic(m1)$Statistic,
-        c(67.64633, 5.88482, 56.8453, 10.05249, 76.86565, 9.78366, 53.05556, 12.83912),
-        tolerance = 1e-3
-      )
-    })
-  }
-}
+  )
+  expect_equal(
+    find_terms(m1, flatten = TRUE),
+    c("Surv(pmax(y, c), d, type = \"left\")", "x")
+  )
+})
+
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 200)
+})
+
+test_that("link_function", {
+  expect_equal(link_function(m1)(0.2), 0.2, tolerance = 1e-5)
+})
+
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
+})
+
+test_that("find_parameters", {
+  expect_equal(
+    find_parameters(m1),
+    list(conditional = c("(Intercept)", "x"))
+  )
+  expect_equal(nrow(get_parameters(m1)), 8)
+  expect_equal(
+    get_parameters(m1)$Parameter,
+    c("(Intercept)", "x", "(Intercept)", "x", "(Intercept)", "x", "(Intercept)", "x")
+  )
+  expect_equal(
+    get_parameters(m1)$Component,
+    c("tau (0.2)", "tau (0.2)", "tau (0.4)", "tau (0.4)", "tau (0.6)", "tau (0.6)", "tau (0.8)", "tau (0.8)")
+  )
+})
+
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "t-statistic")
+})
+
+
+test_that("get_statistic", {
+  expect_equal(
+    get_statistic(m1)$Parameter,
+    c("(Intercept)", "x", "(Intercept)", "x", "(Intercept)", "x", "(Intercept)", "x")
+  )
+  expect_equal(
+    get_statistic(m1)$Statistic,
+    c(67.64633, 5.88482, 56.8453, 10.05249, 76.86565, 9.78366, 53.05556, 12.83912),
+    tolerance = 1e-3
+  )
+})
diff --git a/tests/testthat/test-data.frame.R b/tests/testthat/test-data.frame.R
index 6c6ba9851..36ee96cca 100644
--- a/tests/testthat/test-data.frame.R
+++ b/tests/testthat/test-data.frame.R
@@ -1,5 +1,3 @@
-data(iris)
-
 test_that("find_parameters", {
   expect_error(find_parameters(iris))
 })
diff --git a/tests/testthat/test-ellipses_info.R b/tests/testthat/test-ellipses_info.R
index e99dc2756..1a13cd744 100644
--- a/tests/testthat/test-ellipses_info.R
+++ b/tests/testthat/test-ellipses_info.R
@@ -1,5 +1,3 @@
-data(iris)
-
 m1 <- lm(Sepal.Length ~ Petal.Width + Species, data = iris)
 m2 <- lm(Sepal.Length ~ Species, data = iris)
 m3 <- lm(Sepal.Length ~ Species, data = iris)
@@ -69,38 +67,38 @@ test_that("ellipses_info, binomial", {
   expect_false(any(attributes(info)$is_linear))
 })
 
-if (skip_if_not_or_load_if_installed("lme4")) {
-  data(sleepstudy)
-  m1 <- lmer(Reaction ~ Days + (1 | Subject), data = sleepstudy)
-  m2 <- suppressMessages(lmer(Reaction ~ Days + (1 | Subject) + (1 | Days), data = sleepstudy))
-
-  info <- ellipsis_info(m1, m2, verbose = FALSE)
-  test_that("ellipses_info, random effects", {
-    expect_true(attributes(info)$same_fixef)
-    expect_false(attributes(info)$same_ranef)
-    expect_true(attributes(info)$re_nested)
-    expect_true(attributes(info)$all_mixed_models)
-    expect_true(attributes(info)$re_nested_increasing)
-    expect_false(attributes(info)$re_nested_decreasing)
-  })
-
-  info <- ellipsis_info(m2, m1, verbose = FALSE)
-  test_that("ellipses_info, random effects", {
-    expect_true(attributes(info)$re_nested)
-    expect_false(attributes(info)$re_nested_increasing)
-    expect_true(attributes(info)$re_nested_decreasing)
-  })
-
-  m1 <- lmer(Reaction ~ Days + (1 | Subject), data = sleepstudy)
-  m2 <- lmer(Reaction ~ 1 + (1 | Subject), data = sleepstudy)
-
-  info <- ellipsis_info(m1, m2)
-  test_that("ellipses_info, random effects", {
-    expect_false(attributes(info)$same_fixef)
-    expect_true(attributes(info)$same_ranef)
-    expect_true(attributes(info)$re_nested)
-    expect_true(attributes(info)$all_mixed_models)
-    expect_true(attributes(info)$re_nested_increasing)
-    expect_true(attributes(info)$re_nested_decreasing)
-  })
-}
+skip_if_not_installed("lme4")
+
+data(sleepstudy, package = "lme4")
+m1 <- lme4::lmer(Reaction ~ Days + (1 | Subject), data = sleepstudy)
+m2 <- suppressMessages(lme4::lmer(Reaction ~ Days + (1 | Subject) + (1 | Days), data = sleepstudy))
+
+info <- ellipsis_info(m1, m2, verbose = FALSE)
+test_that("ellipses_info, random effects", {
+  expect_true(attributes(info)$same_fixef)
+  expect_false(attributes(info)$same_ranef)
+  expect_true(attributes(info)$re_nested)
+  expect_true(attributes(info)$all_mixed_models)
+  expect_true(attributes(info)$re_nested_increasing)
+  expect_false(attributes(info)$re_nested_decreasing)
+})
+
+info <- ellipsis_info(m2, m1, verbose = FALSE)
+test_that("ellipses_info, random effects", {
+  expect_true(attributes(info)$re_nested)
+  expect_false(attributes(info)$re_nested_increasing)
+  expect_true(attributes(info)$re_nested_decreasing)
+})
+
+m1 <- lme4::lmer(Reaction ~ Days + (1 | Subject), data = sleepstudy)
+m2 <- lme4::lmer(Reaction ~ 1 + (1 | Subject), data = sleepstudy)
+
+info <- ellipsis_info(m1, m2)
+test_that("ellipses_info, random effects", {
+  expect_false(attributes(info)$same_fixef)
+  expect_true(attributes(info)$same_ranef)
+  expect_true(attributes(info)$re_nested)
+  expect_true(attributes(info)$all_mixed_models)
+  expect_true(attributes(info)$re_nested_increasing)
+  expect_true(attributes(info)$re_nested_decreasing)
+})
diff --git a/tests/testthat/test-emmeans.R b/tests/testthat/test-emmeans.R
index b17a22abc..e14c5b0eb 100644
--- a/tests/testthat/test-emmeans.R
+++ b/tests/testthat/test-emmeans.R
@@ -21,24 +21,23 @@
 # [ FAIL 2 | WARN 0 | SKIP 25 | PASS 3366 ]
 
 skip_if(getRversion() > "4.2.2")
+skip_if_not_installed("emmeans")
 
-if (skip_if_not_or_load_if_installed("emmeans")) {
-  test_that("emmeans", {
-    m <- glm(am ~ factor(cyl),
-      family = binomial(), data = mtcars
-    )
+test_that("emmeans", {
+  m <- glm(am ~ factor(cyl),
+    family = binomial(), data = mtcars
+  )
 
-    EList <- emmeans::emmeans(m, pairwise ~ cyl, type = "resp")
+  EList <- emmeans::emmeans(m, pairwise ~ cyl, type = "resp")
 
-    E <- emmeans::emmeans(m, ~cyl, type = "resp")
+  E <- emmeans::emmeans(m, ~cyl, type = "resp")
 
-    C <- emmeans::contrast(E, method = "pairwise")
+  C <- emmeans::contrast(E, method = "pairwise")
 
-    expect_identical(find_statistic(EList), "z-statistic")
-    expect_equal(get_statistic(EList)$Statistic, c(1.449, -0.377, -2.346, 1.243, 2.717, 1.393), tolerance = 0.001)
-    expect_equal(get_statistic(EList)$Statistic[1:3], get_statistic(E)$Statistic, tolerance = 0.001)
-    expect_equal(get_statistic(EList)$Statistic[4:6], get_statistic(C)$Statistic, tolerance = 0.001)
+  expect_identical(find_statistic(EList), "z-statistic")
+  expect_equal(get_statistic(EList)$Statistic, c(1.449, -0.377, -2.346, 1.243, 2.717, 1.393), tolerance = 0.001)
+  expect_equal(get_statistic(EList)$Statistic[1:3], get_statistic(E)$Statistic, tolerance = 0.001)
+  expect_equal(get_statistic(EList)$Statistic[4:6], get_statistic(C)$Statistic, tolerance = 0.001)
 
-    expect_equal(get_parameters(EList)$Estimate, c(0.727, 0.429, 0.143, 3.556, 16, 4.5), tolerance = 0.001)
-  })
-}
+  expect_equal(get_parameters(EList)$Estimate, c(0.727, 0.429, 0.143, 3.556, 16, 4.5), tolerance = 0.001)
+})
diff --git a/tests/testthat/test-epiR.R b/tests/testthat/test-epiR.R
index 51867f46e..45070ec9e 100644
--- a/tests/testthat/test-epiR.R
+++ b/tests/testthat/test-epiR.R
@@ -1,6 +1,6 @@
 skip_on_os("mac")
 skip_if_not(packageVersion("base") >= "4.2.0")
-skip_if_not_or_load_if_installed("epiR")
+skip_if_not_installed("epiR")
 
 
 dat <- matrix(c(13, 2163, 5, 3349), nrow = 2, byrow = TRUE)
@@ -8,7 +8,7 @@ rownames(dat) <- c("DF+", "DF-")
 colnames(dat) <- c("FUS+", "FUS-")
 
 # model
-m <- epi.2by2(
+m <- epiR::epi.2by2(
   dat = as.table(dat),
   method = "cohort.count",
   conf.level = 0.95,
diff --git a/tests/testthat/test-export_table.R b/tests/testthat/test-export_table.R
index c8715bd45..bbd67420d 100644
--- a/tests/testthat/test-export_table.R
+++ b/tests/testthat/test-export_table.R
@@ -1,21 +1,16 @@
 d <- data.frame(a = c(1.3, 2, 543), b = c("ab", "cd", "abcde"), stringsAsFactors = FALSE)
 
 test_that("export_table", {
-  out <- capture.output(cat(export_table(d)))
-  expect_equal(out, c(
-    "     a |     b", "--------------", "  1.30 |    ab",
-    "  2.00 |    cd", "543.00 | abcde"
-  ))
+  expect_snapshot(export_table(d))
 })
 
 test_that("export_table", {
-  out <- capture.output(cat(export_table(d, sep = " ", header = "*", digits = 1)))
-  expect_equal(out, c(
-    "    a     b", "***********", "  1.3    ab",
-    "  2.0    cd", "543.0 abcde"
-  ))
+  expect_snapshot(export_table(d, sep = " ", header = "*", digits = 1))
 })
 
+
+# snapshots have a very messy output for format = "md"
+
 test_that("export_table", {
   out <- export_table(d, format = "md")
   expect_equal(out, structure(
diff --git a/tests/testthat/test-feis.R b/tests/testthat/test-feis.R
index 404ceb675..a16a5e657 100644
--- a/tests/testthat/test-feis.R
+++ b/tests/testthat/test-feis.R
@@ -1,166 +1,155 @@
-if (skip_if_not_or_load_if_installed("plm") && skip_if_not_or_load_if_installed("feisr")) {
-  data(mwp)
-  m1 <- feis(
-    lnw ~ marry + enrol + as.factor(yeargr) | exp + I(exp^2),
-    data = mwp,
-    id = "id",
-    robust = TRUE
+skip_if_not_installed("plm")
+skip_if_not_installed("feisr")
+
+data(mwp, package = "feisr")
+m1 <- feisr::feis(
+  lnw ~ marry + enrol + as.factor(yeargr) | exp + I(exp^2),
+  data = mwp,
+  id = "id",
+  robust = TRUE
+)
+
+test_that("model_info", {
+  expect_true(model_info(m1)$is_linear)
+})
+
+m_tmp <- m1
+m_tmp$vcov_arg <- "Normal standard errors"
+test_that("get_varcov", {
+  expect_equal(vcov(m_tmp, scale = TRUE), get_varcov(m1), tolerance = 1e-3)
+})
+
+test_that("find_predictors", {
+  expect_identical(find_predictors(m1), list(
+    conditional = c("marry", "enrol", "yeargr"),
+    slopes = "exp"
+  ))
+  expect_identical(find_predictors(m1, effects = "random"), list(random = "id"))
+  expect_identical(
+    find_predictors(m1, effects = "all", flatten = TRUE),
+    c("marry", "enrol", "yeargr", "exp", "id")
   )
+})
 
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_linear)
-  })
+test_that("find_random", {
+  expect_identical(find_random(m1), list(random = "id"))
+})
 
-  m_tmp <- m1
-  m_tmp$vcov_arg <- "Normal standard errors"
-  test_that("get_varcov", {
-    expect_equal(vcov(m_tmp, scale = TRUE), get_varcov(m1), tolerance = 1e-3)
-  })
+test_that("get_random", {
+  expect_identical(colnames(get_random(m1)), "id")
+})
 
-  test_that("find_predictors", {
-    expect_identical(find_predictors(m1), list(
-      conditional = c("marry", "enrol", "yeargr"),
-      slopes = "exp"
-    ))
-    expect_identical(find_predictors(m1, effects = "random"), list(random = "id"))
-    expect_identical(
-      find_predictors(m1, effects = "all", flatten = TRUE),
-      c("marry", "enrol", "yeargr", "exp", "id")
-    )
-  })
+test_that("find_response", {
+  expect_identical(find_response(m1), "lnw")
+})
 
-  test_that("find_random", {
-    expect_identical(find_random(m1), list(random = "id"))
-  })
+test_that("get_response", {
+  expect_equal(get_response(m1), mwp$lnw)
+})
 
-  test_that("get_random", {
-    expect_identical(colnames(get_random(m1)), "id")
-  })
+test_that("get_predictors", {
+  expect_equal(
+    colnames(get_predictors(m1)),
+    c("marry", "enrol", "yeargr", "exp")
+  )
+})
 
-  test_that("find_response", {
-    expect_identical(find_response(m1), "lnw")
-  })
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
+})
 
-  test_that("get_response", {
-    expect_equal(get_response(m1), mwp$lnw)
-  })
+test_that("get_data", {
+  expect_equal(nrow(get_data(m1)), 3100)
+  expect_equal(
+    colnames(get_data(m1)),
+    c("lnw", "marry", "enrol", "yeargr", "exp", "id")
+  )
+})
 
-  test_that("get_predictors", {
-    expect_equal(
-      colnames(get_predictors(m1)),
-      c("marry", "enrol", "yeargr", "exp")
+test_that("get_df", {
+  expect_equal(
+    get_df(m1, type = "residual"),
+    df.residual(m1),
+    ignore_attr = TRUE
+  )
+  expect_equal(
+    get_df(m1, type = "normal"),
+    Inf,
+    ignore_attr = TRUE
+  )
+  expect_equal(
+    get_df(m1, type = "wald"),
+    2290,
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1), 3)
+  expect_equal(
+    find_formula(m1),
+    list(
+      conditional = as.formula("lnw ~ marry + enrol + as.factor(yeargr)"),
+      slopes = as.formula("~exp + I(exp^2)"),
+      random = as.formula("~id")
+    ),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_terms", {
+  expect_equal(
+    find_terms(m1),
+    list(
+      response = "lnw",
+      conditional = c("marry", "enrol", "as.factor(yeargr)"),
+      slopes = c("exp", "I(exp^2)"),
+      random = "id"
     )
-  })
-
-  test_that("link_inverse", {
-    expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
-  })
-
-  test_that("get_data", {
-    expect_equal(nrow(get_data(m1)), 3100)
-    expect_equal(
-      colnames(get_data(m1)),
-      c("lnw", "marry", "enrol", "yeargr", "exp", "id")
+  )
+  expect_equal(
+    find_terms(m1, flatten = TRUE),
+    c(
+      "lnw",
+      "marry",
+      "enrol",
+      "as.factor(yeargr)",
+      "exp",
+      "I(exp^2)",
+      "id"
     )
-  })
+  )
+})
 
-  test_that("get_df", {
-    expect_equal(
-      get_df(m1, type = "residual"),
-      df.residual(m1),
-      ignore_attr = TRUE
-    )
-    expect_equal(
-      get_df(m1, type = "normal"),
-      Inf,
-      ignore_attr = TRUE
-    )
-    expect_equal(
-      get_df(m1, type = "wald"),
-      2290,
-      ignore_attr = TRUE
-    )
-  })
-
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 3)
-    expect_equal(
-      find_formula(m1),
-      list(
-        conditional = as.formula("lnw ~ marry + enrol + as.factor(yeargr)"),
-        slopes = as.formula("~exp + I(exp^2)"),
-        random = as.formula("~id")
-      ),
-      ignore_attr = TRUE
-    )
-  })
-
-  test_that("find_terms", {
-    expect_equal(
-      find_terms(m1),
-      list(
-        response = "lnw",
-        conditional = c("marry", "enrol", "as.factor(yeargr)"),
-        slopes = c("exp", "I(exp^2)"),
-        random = "id"
-      )
-    )
-    expect_equal(
-      find_terms(m1, flatten = TRUE),
-      c(
-        "lnw",
-        "marry",
-        "enrol",
-        "as.factor(yeargr)",
-        "exp",
-        "I(exp^2)",
-        "id"
-      )
-    )
-  })
-
-  test_that("find_variables", {
-    expect_equal(
-      find_variables(m1),
-      list(
-        response = "lnw",
-        conditional = c("marry", "enrol", "yeargr"),
-        slopes = "exp",
-        random = "id"
-      )
-    )
-    expect_equal(
-      find_variables(m1, flatten = TRUE),
-      c("lnw", "marry", "enrol", "yeargr", "exp", "id")
-    )
-  })
-
-  test_that("n_obs", {
-    expect_equal(n_obs(m1), 3100)
-  })
-
-  test_that("linkfun", {
-    expect_false(is.null(link_function(m1)))
-  })
-
-  test_that("find_parameters", {
-    expect_equal(
-      find_parameters(m1),
-      list(
-        conditional = c(
-          "marry",
-          "enrol",
-          "as.factor(yeargr)2",
-          "as.factor(yeargr)3",
-          "as.factor(yeargr)4",
-          "as.factor(yeargr)5"
-        )
-      )
+test_that("find_variables", {
+  expect_equal(
+    find_variables(m1),
+    list(
+      response = "lnw",
+      conditional = c("marry", "enrol", "yeargr"),
+      slopes = "exp",
+      random = "id"
     )
-    expect_equal(nrow(get_parameters(m1)), 6)
-    expect_equal(
-      get_parameters(m1)$Parameter,
-      c(
+  )
+  expect_equal(
+    find_variables(m1, flatten = TRUE),
+    c("lnw", "marry", "enrol", "yeargr", "exp", "id")
+  )
+})
+
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 3100)
+})
+
+test_that("linkfun", {
+  expect_false(is.null(link_function(m1)))
+})
+
+test_that("find_parameters", {
+  expect_equal(
+    find_parameters(m1),
+    list(
+      conditional = c(
         "marry",
         "enrol",
         "as.factor(yeargr)2",
@@ -169,13 +158,25 @@ if (skip_if_not_or_load_if_installed("plm") && skip_if_not_or_load_if_installed(
         "as.factor(yeargr)5"
       )
     )
-  })
+  )
+  expect_equal(nrow(get_parameters(m1)), 6)
+  expect_equal(
+    get_parameters(m1)$Parameter,
+    c(
+      "marry",
+      "enrol",
+      "as.factor(yeargr)2",
+      "as.factor(yeargr)3",
+      "as.factor(yeargr)4",
+      "as.factor(yeargr)5"
+    )
+  )
+})
 
-  test_that("is_multivariate", {
-    expect_false(is_multivariate(m1))
-  })
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1))
+})
 
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "t-statistic")
-  })
-}
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "t-statistic")
+})
diff --git a/tests/testthat/test-felm.R b/tests/testthat/test-felm.R
index 6c6f67a8b..f67c57072 100644
--- a/tests/testthat/test-felm.R
+++ b/tests/testthat/test-felm.R
@@ -1,169 +1,169 @@
-if (skip_if_not_or_load_if_installed("lfe")) {
-  x <- rnorm(1000)
-  x2 <- rnorm(length(x))
-  id <- factor(sample(20, length(x), replace = TRUE))
-  firm <- factor(sample(13, length(x), replace = TRUE))
-  id.eff <- rnorm(nlevels(id))
-  firm.eff <- rnorm(nlevels(firm))
-  u <- rnorm(length(x))
-  y <- x + 0.5 * x2 + id.eff[id] + firm.eff[firm] + u
-
-  x3 <- rnorm(length(x))
-  x4 <- sample(12, length(x), replace = TRUE)
-
-  Q <- 0.3 * x3 + x + 0.2 * x2 + id.eff[id] + 0.3 * log(x4) - 0.3 * y + rnorm(length(x), sd = 0.3)
-  W <- 0.7 * x3 - 2 * x + 0.1 * x2 - 0.7 * id.eff[id] + 0.8 * cos(x4) - 0.2 * y + rnorm(length(x), sd = 0.6)
-
-  # add them to the outcome
-  y <- y + Q + W
-  dat <<- data.frame(y, x, x2, x3, x4, id, firm, Q, W)
-
-  m1 <- felm(y ~ x + x2 | id + firm | (Q | W ~ x3 + factor(x4)), data = dat)
-
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_linear)
-  })
-
-  test_that("find_predictors", {
-    expect_identical(
-      find_predictors(m1),
-      list(
-        conditional = c("x", "x2"),
-        instruments = c("Q", "W", "x3", "x4")
-      )
+skip_if_not_installed("lfe")
+
+x <- rnorm(1000)
+x2 <- rnorm(length(x))
+id <- factor(sample(20, length(x), replace = TRUE))
+firm <- factor(sample(13, length(x), replace = TRUE))
+id.eff <- rnorm(nlevels(id))
+firm.eff <- rnorm(nlevels(firm))
+u <- rnorm(length(x))
+y <- x + 0.5 * x2 + id.eff[id] + firm.eff[firm] + u
+
+x3 <- rnorm(length(x))
+x4 <- sample(12, length(x), replace = TRUE)
+
+Q <- 0.3 * x3 + x + 0.2 * x2 + id.eff[id] + 0.3 * log(x4) - 0.3 * y + rnorm(length(x), sd = 0.3)
+W <- 0.7 * x3 - 2 * x + 0.1 * x2 - 0.7 * id.eff[id] + 0.8 * cos(x4) - 0.2 * y + rnorm(length(x), sd = 0.6)
+
+# add them to the outcome
+y <- y + Q + W
+dat <<- data.frame(y, x, x2, x3, x4, id, firm, Q, W)
+
+m1 <- lfe::felm(y ~ x + x2 | id + firm | (Q | W ~ x3 + factor(x4)), data = dat)
+
+test_that("model_info", {
+  expect_true(model_info(m1)$is_linear)
+})
+
+test_that("find_predictors", {
+  expect_identical(
+    find_predictors(m1),
+    list(
+      conditional = c("x", "x2"),
+      instruments = c("Q", "W", "x3", "x4")
     )
-    expect_identical(find_predictors(m1, effects = "random"), list(random = c("id", "firm")))
-    expect_identical(
-      find_predictors(m1, effects = "all", flatten = TRUE),
-      c("x", "x2", "id", "firm", "Q", "W", "x3", "x4")
+  )
+  expect_identical(find_predictors(m1, effects = "random"), list(random = c("id", "firm")))
+  expect_identical(
+    find_predictors(m1, effects = "all", flatten = TRUE),
+    c("x", "x2", "id", "firm", "Q", "W", "x3", "x4")
+  )
+})
+
+test_that("find_random", {
+  expect_identical(find_random(m1), list(random = c("id", "firm")))
+})
+
+test_that("get_random", {
+  expect_identical(colnames(get_random(m1)), c("id", "firm"))
+})
+
+test_that("find_response", {
+  expect_identical(find_response(m1), "y")
+})
+
+test_that("get_response", {
+  expect_equal(get_response(m1), dat$y)
+})
+
+test_that("get_predictors", {
+  expect_equal(
+    colnames(get_predictors(m1)),
+    c("x", "x2", "Q", "W", "x3", "x4")
+  )
+})
+
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
+})
+
+test_that("get_data", {
+  expect_equal(nrow(get_data(m1)), 1000)
+  expect_equal(
+    colnames(get_data(m1)),
+    c("y", "x", "x2", "id", "firm", "Q", "W", "x3", "x4")
+  )
+})
+
+test_that("get_df", {
+  expect_equal(
+    get_df(m1, type = "residual"),
+    df.residual(m1),
+    ignore_attr = TRUE
+  )
+  expect_equal(
+    get_df(m1, type = "normal"),
+    Inf,
+    ignore_attr = TRUE
+  )
+  expect_equal(
+    get_df(m1, type = "wald"),
+    964,
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1), 3)
+  expect_equal(
+    find_formula(m1),
+    list(
+      conditional = as.formula("y ~ x + x2"),
+      random = as.formula("~id + firm"),
+      instruments = as.formula("~(Q | W ~ x3 + factor(x4))")
+    ),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_terms", {
+  expect_equal(
+    find_terms(m1),
+    list(
+      response = "y",
+      conditional = c("x", "x2"),
+      random = c("id", "firm"),
+      instruments = c("(Q", "W  x3", "factor(x4))")
     )
-  })
-
-  test_that("find_random", {
-    expect_identical(find_random(m1), list(random = c("id", "firm")))
-  })
-
-  test_that("get_random", {
-    expect_identical(colnames(get_random(m1)), c("id", "firm"))
-  })
-
-  test_that("find_response", {
-    expect_identical(find_response(m1), "y")
-  })
-
-  test_that("get_response", {
-    expect_equal(get_response(m1), dat$y)
-  })
-
-  test_that("get_predictors", {
-    expect_equal(
-      colnames(get_predictors(m1)),
-      c("x", "x2", "Q", "W", "x3", "x4")
-    )
-  })
-
-  test_that("link_inverse", {
-    expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
-  })
-
-  test_that("get_data", {
-    expect_equal(nrow(get_data(m1)), 1000)
-    expect_equal(
-      colnames(get_data(m1)),
-      c("y", "x", "x2", "id", "firm", "Q", "W", "x3", "x4")
-    )
-  })
-
-  test_that("get_df", {
-    expect_equal(
-      get_df(m1, type = "residual"),
-      df.residual(m1),
-      ignore_attr = TRUE
-    )
-    expect_equal(
-      get_df(m1, type = "normal"),
-      Inf,
-      ignore_attr = TRUE
-    )
-    expect_equal(
-      get_df(m1, type = "wald"),
-      964,
-      ignore_attr = TRUE
-    )
-  })
-
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 3)
-    expect_equal(
-      find_formula(m1),
-      list(
-        conditional = as.formula("y ~ x + x2"),
-        random = as.formula("~id + firm"),
-        instruments = as.formula("~(Q | W ~ x3 + factor(x4))")
-      ),
-      ignore_attr = TRUE
+  )
+  expect_equal(
+    find_terms(m1, flatten = TRUE),
+    c("y", "x", "x2", "id", "firm", "(Q", "W  x3", "factor(x4))")
+  )
+})
+
+
+test_that("find_variables", {
+  expect_equal(
+    find_variables(m1),
+    list(
+      response = "y",
+      conditional = c("x", "x2"),
+      random = c("id", "firm"),
+      instruments = c("Q", "W", "x3", "x4")
     )
-  })
-
-  test_that("find_terms", {
-    expect_equal(
-      find_terms(m1),
-      list(
-        response = "y",
-        conditional = c("x", "x2"),
-        random = c("id", "firm"),
-        instruments = c("(Q", "W  x3", "factor(x4))")
-      )
-    )
-    expect_equal(
-      find_terms(m1, flatten = TRUE),
-      c("y", "x", "x2", "id", "firm", "(Q", "W  x3", "factor(x4))")
-    )
-  })
-
-
-  test_that("find_variables", {
-    expect_equal(
-      find_variables(m1),
-      list(
-        response = "y",
-        conditional = c("x", "x2"),
-        random = c("id", "firm"),
-        instruments = c("Q", "W", "x3", "x4")
-      )
-    )
-    expect_equal(
-      find_variables(m1, flatten = TRUE),
-      c("y", "x", "x2", "id", "firm", "Q", "W", "x3", "x4")
-    )
-  })
-
-
-  test_that("n_obs", {
-    expect_equal(n_obs(m1), 1000)
-  })
-
-  test_that("linkfun", {
-    expect_false(is.null(link_function(m1)))
-  })
-
-  test_that("find_parameters", {
-    expect_equal(
-      find_parameters(m1),
-      list(conditional = c("x", "x2", "Q(fit)", "W(fit)"))
-    )
-    expect_equal(nrow(get_parameters(m1)), 4)
-    expect_equal(
-      get_parameters(m1)$Parameter,
-      c("x", "x2", "Q(fit)", "W(fit)")
-    )
-  })
-
-  test_that("is_multivariate", {
-    expect_false(is_multivariate(m1))
-  })
-
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "t-statistic")
-  })
-}
+  )
+  expect_equal(
+    find_variables(m1, flatten = TRUE),
+    c("y", "x", "x2", "id", "firm", "Q", "W", "x3", "x4")
+  )
+})
+
+
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 1000)
+})
+
+test_that("linkfun", {
+  expect_false(is.null(link_function(m1)))
+})
+
+test_that("find_parameters", {
+  expect_equal(
+    find_parameters(m1),
+    list(conditional = c("x", "x2", "Q(fit)", "W(fit)"))
+  )
+  expect_equal(nrow(get_parameters(m1)), 4)
+  expect_equal(
+    get_parameters(m1)$Parameter,
+    c("x", "x2", "Q(fit)", "W(fit)")
+  )
+})
+
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1))
+})
+
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "t-statistic")
+})
diff --git a/tests/testthat/test-find_formula-data.R b/tests/testthat/test-find_formula-data.R
index 0281bc10e..d468c579c 100644
--- a/tests/testthat/test-find_formula-data.R
+++ b/tests/testthat/test-find_formula-data.R
@@ -1,4 +1,9 @@
-data(mtcars)
+# see https://github.com/georgheinze/logistf/pull/54
+skip_if(
+  "as.character.formula" %in% methods(as.character),
+  "Some package uses `formula.tools::as.character.formula()` which breaks `find_formula()`."
+)
+
 d <- mtcars
 m1 <- lm(mtcars$mpg ~ mtcars$hp * mtcars$cyl + poly(mtcars$drat, 2) / mtcars$disp)
 m2 <- lm(mtcars$mpg ~ d$hp * mtcars$cyl + poly(mtcars$drat, 2) / mtcars$disp)
diff --git a/tests/testthat/test-find_predictor_nested_re.R b/tests/testthat/test-find_predictor_nested_re.R
index 062abda80..97cfcf18b 100644
--- a/tests/testthat/test-find_predictor_nested_re.R
+++ b/tests/testthat/test-find_predictor_nested_re.R
@@ -1,25 +1,25 @@
-if (skip_if_not_or_load_if_installed("lme4")) {
-  set.seed(1984)
-  dat <- data.frame(
-    y = rnorm(1000 * 5, sd = 1 - 0.20),
-    time = rep(1:10, 100 * 5),
-    g1 = sort(rep(1:100, 10 * 5)),
-    g2 = sort(rep(1:10, 100 * 5))
+skip_if_not_installed("lme4")
+
+set.seed(1984)
+dat <- data.frame(
+  y = rnorm(1000 * 5, sd = 1 - 0.20),
+  time = rep(1:10, 100 * 5),
+  g1 = sort(rep(1:100, 10 * 5)),
+  g2 = sort(rep(1:10, 100 * 5))
+)
+dat$g0 <- paste(dat$time, dat$g1)
+dat$time1 <- dat$time - 8
+dat$post <- 0
+dat$post[dat$time >= 8] <- 1
+m <- suppressWarnings(suppressMessages(
+  lme4::lmer(y ~ post + time1 + (1 | g2 / g1 / g0) + (post + time1 - 1 | g2),
+    data = dat
   )
-  dat$g0 <- paste(dat$time, dat$g1)
-  dat$time1 <- dat$time - 8
-  dat$post <- 0
-  dat$post[dat$time >= 8] <- 1
-  m <- suppressWarnings(suppressMessages(
-    lmer(y ~ post + time1 + (1 | g2 / g1 / g0) + (post + time1 - 1 | g2),
-      data = dat
-    )
-  ))
+))
 
-  test_that("clean_names", {
-    expect_equal(
-      find_predictors(m, effects = "all"),
-      list(conditional = c("post", "time1"), random = c("g0", "g1", "g2"))
-    )
-  })
-}
+test_that("clean_names", {
+  expect_equal(
+    find_predictors(m, effects = "all"),
+    list(conditional = c("post", "time1"), random = c("g0", "g1", "g2"))
+  )
+})
diff --git a/tests/testthat/test-find_predictors-strata.R b/tests/testthat/test-find_predictors-strata.R
index 643fe8418..44e7bd86b 100644
--- a/tests/testthat/test-find_predictors-strata.R
+++ b/tests/testthat/test-find_predictors-strata.R
@@ -1,46 +1,49 @@
-if (skip_if_not_or_load_if_installed("survival")) {
-  f1 <- as.formula("Surv(time, status) ~ strata(sex) * x + x2")
-  f2 <- as.formula("Surv(time, status) ~ x * strata(sex) * x2")
-  f3 <- as.formula("Surv(time, status) ~ x + x2 * strata(sex)")
-  f4 <- as.formula("Surv(time, status) ~ strata(sex) + x + x2")
-  f5 <- as.formula("Surv(time, status) ~ x * strata(sex) + x2")
-  f6 <- as.formula("Surv(time, status) ~ x + x2 + strata(sex)")
-
-  dat <- list(
-    time = c(4, 3, 1, 1, 2, 2, 3),
-    status = c(1, 1, 1, 0, 1, 1, 0),
-    x = c(0, 2, 1, 1, 1, 0, 0),
-    x2 = c(0, 2, 1, 0, 1, 1, 0),
-    sex = c(0, 0, 0, 0, 1, 1, 1)
-  )
-
-  test_that("find_predictors strata1", {
-    mod <- suppressWarnings(coxph(f1, data = dat, ties = "breslow"))
-    expect_equal(find_predictors(mod), list(conditional = c("x", "x2"), strata = "sex"))
-  })
-
-  test_that("find_predictors strata2", {
-    mod <- suppressWarnings(coxph(f2, data = dat, ties = "breslow"))
-    expect_equal(find_predictors(mod), list(conditional = c("x", "x2"), strata = "sex"))
-  })
-
-  test_that("find_predictors strata3", {
-    mod <- suppressWarnings(coxph(f3, data = dat, ties = "breslow"))
-    expect_equal(find_predictors(mod), list(conditional = c("x", "x2"), strata = "sex"))
-  })
-
-  test_that("find_predictors strata4", {
-    mod <- suppressWarnings(coxph(f4, data = dat, ties = "breslow"))
-    expect_equal(find_predictors(mod), list(conditional = c("x", "x2"), strata = "sex"))
-  })
-
-  test_that("find_predictors strata5", {
-    mod <- suppressWarnings(coxph(f5, data = dat, ties = "breslow"))
-    expect_equal(find_predictors(mod), list(conditional = c("x", "x2"), strata = "sex"))
-  })
-
-  test_that("find_predictors strata6", {
-    mod <- suppressWarnings(coxph(f6, data = dat, ties = "breslow"))
-    expect_equal(find_predictors(mod), list(conditional = c("x", "x2"), strata = "sex"))
-  })
-}
+skip_if_not_installed("survival")
+
+Surv <- survival::Surv
+strata <- survival::strata
+
+f1 <- as.formula("Surv(time, status) ~ strata(sex) * x + x2")
+f2 <- as.formula("Surv(time, status) ~ x * strata(sex) * x2")
+f3 <- as.formula("Surv(time, status) ~ x + x2 * strata(sex)")
+f4 <- as.formula("Surv(time, status) ~ strata(sex) + x + x2")
+f5 <- as.formula("Surv(time, status) ~ x * strata(sex) + x2")
+f6 <- as.formula("Surv(time, status) ~ x + x2 + strata(sex)")
+
+dat <- list(
+  time = c(4, 3, 1, 1, 2, 2, 3),
+  status = c(1, 1, 1, 0, 1, 1, 0),
+  x = c(0, 2, 1, 1, 1, 0, 0),
+  x2 = c(0, 2, 1, 0, 1, 1, 0),
+  sex = c(0, 0, 0, 0, 1, 1, 1)
+)
+
+test_that("find_predictors strata1", {
+  mod <- suppressWarnings(survival::coxph(f1, data = dat, ties = "breslow"))
+  expect_equal(find_predictors(mod), list(conditional = c("x", "x2"), strata = "sex"))
+})
+
+test_that("find_predictors strata2", {
+  mod <- suppressWarnings(survival::coxph(f2, data = dat, ties = "breslow"))
+  expect_equal(find_predictors(mod), list(conditional = c("x", "x2"), strata = "sex"))
+})
+
+test_that("find_predictors strata3", {
+  mod <- suppressWarnings(survival::coxph(f3, data = dat, ties = "breslow"))
+  expect_equal(find_predictors(mod), list(conditional = c("x", "x2"), strata = "sex"))
+})
+
+test_that("find_predictors strata4", {
+  mod <- suppressWarnings(survival::coxph(f4, data = dat, ties = "breslow"))
+  expect_equal(find_predictors(mod), list(conditional = c("x", "x2"), strata = "sex"))
+})
+
+test_that("find_predictors strata5", {
+  mod <- suppressWarnings(survival::coxph(f5, data = dat, ties = "breslow"))
+  expect_equal(find_predictors(mod), list(conditional = c("x", "x2"), strata = "sex"))
+})
+
+test_that("find_predictors strata6", {
+  mod <- suppressWarnings(survival::coxph(f6, data = dat, ties = "breslow"))
+  expect_equal(find_predictors(mod), list(conditional = c("x", "x2"), strata = "sex"))
+})
diff --git a/tests/testthat/test-find_random.R b/tests/testthat/test-find_random.R
index 5f603ab02..384cd4c10 100644
--- a/tests/testthat/test-find_random.R
+++ b/tests/testthat/test-find_random.R
@@ -1,39 +1,38 @@
-if (skip_if_not_or_load_if_installed("mgcv") && skip_if_not_or_load_if_installed("gamm4") && skip_if_not_or_load_if_installed("rstanarm")) {
-  data <- iris
-  data$g <- data$Species
-  data$Xr <- data$Species
+skip_if_not_installed("mgcv")
+skip_if_not_installed("gamm4")
+skip_if_not_installed("rstanarm")
 
+data <- iris
+data$g <- data$Species
+data$Xr <- data$Species
 
-  test_that("find_random - mgcv::gamm", {
-    model <- mgcv::gamm(Petal.Length ~ Petal.Width + s(Sepal.Length), random = list(Species = ~1), data = iris)
-    expect_equal(insight::find_random(model, flatten = TRUE), "Species")
 
-    model <- mgcv::gamm(Petal.Length ~ Petal.Width + s(Sepal.Length), random = list(g = ~1), data = data)
-    expect_equal(insight::find_random(model, flatten = TRUE), "g")
-  })
+test_that("find_random - mgcv::gamm", {
+  model <- mgcv::gamm(Petal.Length ~ Petal.Width + s(Sepal.Length), random = list(Species = ~1), data = iris)
+  expect_equal(insight::find_random(model, flatten = TRUE), "Species")
 
+  model <- mgcv::gamm(Petal.Length ~ Petal.Width + s(Sepal.Length), random = list(g = ~1), data = data)
+  expect_equal(insight::find_random(model, flatten = TRUE), "g")
+})
 
-  test_that("find_random - gamm4::gamm4", {
-    model <- gamm4::gamm4(Petal.Length ~ Petal.Width + s(Sepal.Length), random = ~ (1 | Species), data = iris)
-    expect_equal(insight::find_random(model, flatten = TRUE), "Species")
+test_that("find_random - gamm4::gamm4", {
+  model <- gamm4::gamm4(Petal.Length ~ Petal.Width + s(Sepal.Length), random = ~ (1 | Species), data = iris)
+  expect_equal(insight::find_random(model, flatten = TRUE), "Species")
 
-    model <- gamm4::gamm4(Petal.Length ~ Petal.Width + s(Sepal.Length), random = ~ (1 | Xr), data = data)
-    expect_equal(insight::find_random(model, flatten = TRUE), "Xr")
-  })
+  model <- gamm4::gamm4(Petal.Length ~ Petal.Width + s(Sepal.Length), random = ~ (1 | Xr), data = data)
+  expect_equal(insight::find_random(model, flatten = TRUE), "Xr")
+})
 
-  .runStanTest <- Sys.getenv("RunAllinsightStanTests") == "yes"
-  if (.runStanTest) {
-    test_that("find_random - rstanarm::gamm4", {
-      model <-
-        suppressWarnings(rstanarm::stan_gamm4(
-          Petal.Length ~ Petal.Width + s(Sepal.Length),
-          random = ~ (1 | Species),
-          data = iris,
-          iter = 100,
-          chains = 1,
-          refresh = 0
-        ))
-      expect_equal(insight::find_random(model, flatten = TRUE), "Species")
-    })
-  }
-}
+test_that("find_random - rstanarm::gamm4", {
+  skip_on_cran()
+  model <-
+    suppressWarnings(rstanarm::stan_gamm4(
+      Petal.Length ~ Petal.Width + s(Sepal.Length),
+      random = ~ (1 | Species),
+      data = iris,
+      iter = 100,
+      chains = 1,
+      refresh = 0
+    ))
+  expect_equal(insight::find_random(model, flatten = TRUE), "Species")
+})
diff --git a/tests/testthat/test-find_smooth.R b/tests/testthat/test-find_smooth.R
index 30459ee80..53ab31c81 100644
--- a/tests/testthat/test-find_smooth.R
+++ b/tests/testthat/test-find_smooth.R
@@ -1,48 +1,48 @@
-if (skip_if_not_or_load_if_installed("mgcv") && skip_if_not_or_load_if_installed("gamm4") && skip_if_not_or_load_if_installed("rstanarm")) {
-  set.seed(2) ## simulate some data...
-  void <- capture.output(
-    dat <- mgcv::gamSim(1, n = 400, dist = "normal", scale = 2)
-  )
+skip_if_not_installed("mgcv")
+skip_if_not_installed("gamm4")
+skip_if_not_installed("rstanarm")
 
-  bt <- mgcv::gam(y ~ te(x0, x1, k = 7) + s(x2) + s(x3),
-    data = dat,
-    method = "REML"
-  )
+set.seed(2) ## simulate some data...
+void <- capture.output(
+  dat <- mgcv::gamSim(1, n = 400, dist = "normal", scale = 2)
+)
 
-  test_that("find_smooth - gam", {
-    expect_equal(find_smooth(bt), list(smooth_terms = c("te(x0, x1, k = 7)", "s(x2)", "s(x3)")))
-    expect_equal(find_smooth(bt, flatten = TRUE), c("te(x0, x1, k = 7)", "s(x2)", "s(x3)"))
-  })
+bt <- mgcv::gam(y ~ te(x0, x1, k = 7) + s(x2) + s(x3),
+  data = dat,
+  method = "REML"
+)
 
-  test_that("find_smooth - mgcv::gamm", {
-    model <- mgcv::gamm(Petal.Length ~ Petal.Width + s(Sepal.Length), random = list(Species = ~1), data = iris)
-    expect_equal(find_smooth(model, flatten = TRUE), "s(Sepal.Length)")
-  })
+test_that("find_smooth - gam", {
+  expect_equal(find_smooth(bt), list(smooth_terms = c("te(x0, x1, k = 7)", "s(x2)", "s(x3)")))
+  expect_equal(find_smooth(bt, flatten = TRUE), c("te(x0, x1, k = 7)", "s(x2)", "s(x3)"))
+})
 
-  test_that("find_smooth - gamm4", {
-    model <- gamm4::gamm4(Petal.Length ~ Petal.Width + s(Sepal.Length), random = ~ (1 | Species), data = iris)
-    expect_equal(find_smooth(model, flatten = TRUE), "s(Sepal.Length)")
-  })
+test_that("find_smooth - mgcv::gamm", {
+  model <- mgcv::gamm(Petal.Length ~ Petal.Width + s(Sepal.Length), random = list(Species = ~1), data = iris)
+  expect_equal(find_smooth(model, flatten = TRUE), "s(Sepal.Length)")
+})
 
-  .runStanTest <- Sys.getenv("RunAllinsightStanTests") == "yes"
-  if (.runStanTest) {
-    test_that("find_smooth - stan_gamm4", {
-      model <- suppressWarnings(
-        rstanarm::stan_gamm4(
-          Petal.Length ~ Petal.Width + s(Sepal.Length),
-          random = ~ (1 | Species),
-          data = iris,
-          iter = 100,
-          chains = 1,
-          refresh = 0
-        )
-      )
-      expect_equal(find_smooth(model, flatten = TRUE), "s(Sepal.Length)")
-    })
-  }
+test_that("find_smooth - gamm4", {
+  model <- gamm4::gamm4(Petal.Length ~ Petal.Width + s(Sepal.Length), random = ~ (1 | Species), data = iris)
+  expect_equal(find_smooth(model, flatten = TRUE), "s(Sepal.Length)")
+})
+
+test_that("find_smooth - stan_gamm4", {
+  skip_on_cran()
+  model <- suppressWarnings(
+    rstanarm::stan_gamm4(
+      Petal.Length ~ Petal.Width + s(Sepal.Length),
+      random = ~ (1 | Species),
+      data = iris,
+      iter = 100,
+      chains = 1,
+      refresh = 0
+    )
+  )
+  expect_equal(find_smooth(model, flatten = TRUE), "s(Sepal.Length)")
+})
 
-  # test_that("find_smooth - brms", {
-  #   model <- brms::brm(Petal.Length ~ Petal.Width + s(Sepal.Length) + (1|Species), data = iris, iter=100, chains=1, refresh=0)
-  #   expect_equal(find_smooth(model, flatten = TRUE), "s(Sepal.Length)")
-  # })
-}
+# test_that("find_smooth - brms", {
+#   model <- brms::brm(Petal.Length ~ Petal.Width + s(Sepal.Length) + (1|Species), data = iris, iter=100, chains=1, refresh=0)
+#   expect_equal(find_smooth(model, flatten = TRUE), "s(Sepal.Length)")
+# })
diff --git a/tests/testthat/test-find_terms.R b/tests/testthat/test-find_terms.R
index aa25e7b82..76ef25f2e 100644
--- a/tests/testthat/test-find_terms.R
+++ b/tests/testthat/test-find_terms.R
@@ -1,49 +1,49 @@
-if (skip_if_not_or_load_if_installed("lme4")) {
-  test_that("find_terms", {
-    m <- lm(Sepal.Length ~ -1 + Petal.Width + Species, data = iris)
-    expect_equal(
-      find_terms(m),
-      list(response = "Sepal.Length", conditional = c("Petal.Width", "Species", "-1"))
-    )
-    expect_false(has_intercept(m))
-  })
+skip_if_not_installed("lme4")
 
-  test_that("find_terms", {
-    m <- lm(Sepal.Length ~ 0 + Petal.Width + Species, data = iris)
-    expect_equal(
-      find_terms(m),
-      list(response = "Sepal.Length", conditional = c("0", "Petal.Width", "Species"))
-    )
-    expect_false(has_intercept(m))
-  })
+test_that("find_terms", {
+  m <- lm(Sepal.Length ~ -1 + Petal.Width + Species, data = iris)
+  expect_equal(
+    find_terms(m),
+    list(response = "Sepal.Length", conditional = c("Petal.Width", "Species", "-1"))
+  )
+  expect_false(has_intercept(m))
+})
 
-  test_that("find_terms", {
-    m <- lm(Sepal.Length ~ Petal.Width + Species - 1, data = iris)
-    expect_equal(
-      find_terms(m),
-      list(response = "Sepal.Length", conditional = c("Petal.Width", "Species", "-1"))
-    )
-    expect_false(has_intercept(m))
-  })
+test_that("find_terms", {
+  m <- lm(Sepal.Length ~ 0 + Petal.Width + Species, data = iris)
+  expect_equal(
+    find_terms(m),
+    list(response = "Sepal.Length", conditional = c("0", "Petal.Width", "Species"))
+  )
+  expect_false(has_intercept(m))
+})
 
-  set.seed(1984)
-  dat <- data.frame(
-    y = rnorm(100 * 5, sd = 1 - 0.20),
-    time = rep(1:10, 10 * 5),
-    g1 = sort(rep(1:100, 5)),
-    g2 = sort(rep(1:10, 10 * 5))
+test_that("find_terms", {
+  m <- lm(Sepal.Length ~ Petal.Width + Species - 1, data = iris)
+  expect_equal(
+    find_terms(m),
+    list(response = "Sepal.Length", conditional = c("Petal.Width", "Species", "-1"))
   )
-  dat$g0 <- paste(dat$time, dat$g1)
-  dat$time1 <- dat$time - 8
-  dat$post <- 0
-  dat$post[dat$time >= 8] <- 1
-  m <- suppressMessages(lmer(y ~ post + time1 + (post + time1 - 1 | g2), data = dat))
+  expect_false(has_intercept(m))
+})
 
-  test_that("find_terms", {
-    expect_equal(
-      find_terms(m),
-      list(response = "y", conditional = c("post", "time1"), random = c("post", "time1", "g2"))
-    )
-    expect_true(has_intercept(m))
-  })
-}
+set.seed(1984)
+dat <- data.frame(
+  y = rnorm(100 * 5, sd = 1 - 0.20),
+  time = rep(1:10, 10 * 5),
+  g1 = sort(rep(1:100, 5)),
+  g2 = sort(rep(1:10, 10 * 5))
+)
+dat$g0 <- paste(dat$time, dat$g1)
+dat$time1 <- dat$time - 8
+dat$post <- 0
+dat$post[dat$time >= 8] <- 1
+m <- suppressMessages(lme4::lmer(y ~ post + time1 + (post + time1 - 1 | g2), data = dat))
+
+test_that("find_terms", {
+  expect_equal(
+    find_terms(m),
+    list(response = "y", conditional = c("post", "time1"), random = c("post", "time1", "g2"))
+  )
+  expect_true(has_intercept(m))
+})
diff --git a/tests/testthat/test-find_transformation.R b/tests/testthat/test-find_transformation.R
index e09831c99..452720b9c 100644
--- a/tests/testthat/test-find_transformation.R
+++ b/tests/testthat/test-find_transformation.R
@@ -44,7 +44,6 @@ test_that("find_transformation - unknown", {
 })
 
 test_that("find_transformation - strange bayestestR example", {
-  data(mtcars)
   mod <- lm(log(mpg) ~ gear + hp, data = mtcars)
   expect_identical(find_transformation(mod), "log")
 })
diff --git a/tests/testthat/test-find_weights.R b/tests/testthat/test-find_weights.R
index 95dc5f054..495e95b70 100644
--- a/tests/testthat/test-find_weights.R
+++ b/tests/testthat/test-find_weights.R
@@ -1,46 +1,45 @@
-if (skip_if_not_or_load_if_installed("lme4")) {
-  test_that("find_weights", {
-    data(mtcars)
-    mtcars$weight <- rnorm(nrow(mtcars), 1, 0.3)
-    m <- lm(mpg ~ wt + cyl + vs, data = mtcars, weights = weight)
-    expect_identical(find_weights(m), "weight")
-  })
-  test_that("find_weights", {
-    data(iris)
-    iris$wgt <- rnorm(nrow(iris), 1, 0.3)
-    m <- lmer(Sepal.Width ~ Sepal.Length + (1 | Species), data = iris, weights = wgt)
-    expect_identical(find_weights(m), "wgt")
-  })
-}
-
-
-if (skip_if_not_or_load_if_installed("nlme")) {
-  data(Orthodont)
-  Orthodont$w <- abs(rnorm(nrow(Orthodont)))
-
-  m1 <- lme(
-    distance ~ age,
-    data = Orthodont,
-    random = ~ 1 | Subject,
-    weights = varIdent(form = ~ 1 | Sex)
-  )
-
-  m2 <- lme(
-    distance ~ age,
-    data = Orthodont,
-    random = ~ 1 | Subject
-  )
-
-  m3 <- lme(
-    distance ~ age,
-    data = Orthodont,
-    random = ~ 1 | Subject,
-    weights = ~w
-  )
-
-  test_that("find_weights", {
-    expect_identical(find_weights(m1), "Sex")
-    expect_null(find_weights(m2))
-    expect_identical(find_weights(m3), "w")
-  })
-}
+skip_if_not_installed("lme4")
+
+test_that("find_weights", {
+  mtcars$weight <- rnorm(nrow(mtcars), 1, 0.3)
+  m <- lm(mpg ~ wt + cyl + vs, data = mtcars, weights = weight)
+  expect_identical(find_weights(m), "weight")
+})
+
+test_that("find_weights", {
+  iris$wgt <- rnorm(nrow(iris), 1, 0.3)
+  m <- lme4::lmer(Sepal.Width ~ Sepal.Length + (1 | Species), data = iris, weights = wgt)
+  expect_identical(find_weights(m), "wgt")
+})
+
+
+skip_if_not_installed("nlme")
+
+data(Orthodont, package = "nlme")
+Orthodont$w <- abs(rnorm(nrow(Orthodont)))
+
+m1 <- nlme::lme(
+  distance ~ age,
+  data = Orthodont,
+  random = ~ 1 | Subject,
+  weights = nlme::varIdent(form = ~ 1 | Sex)
+)
+
+m2 <- nlme::lme(
+  distance ~ age,
+  data = Orthodont,
+  random = ~ 1 | Subject
+)
+
+m3 <- nlme::lme(
+  distance ~ age,
+  data = Orthodont,
+  random = ~ 1 | Subject,
+  weights = ~w
+)
+
+test_that("find_weights", {
+  expect_identical(find_weights(m1), "Sex")
+  expect_null(find_weights(m2))
+  expect_identical(find_weights(m3), "w")
+})
diff --git a/tests/testthat/test-fixest.R b/tests/testthat/test-fixest.R
index e0d411ca0..9b6af082a 100644
--- a/tests/testthat/test-fixest.R
+++ b/tests/testthat/test-fixest.R
@@ -1,23 +1,23 @@
 skip_on_os("mac")
 skip_if(getRversion() < "3.6.0")
 skip_if_not_installed("fixest")
-skip_if_not_or_load_if_installed("fixest")
+skip_if_not_installed("fixest")
 
 # avoid warnings
 fixest::setFixest_nthreads(1)
 
-data(trade)
-m1 <- femlm(Euros ~ log(dist_km) | Origin + Destination + Product, data = trade)
-m2 <- femlm(log1p(Euros) ~ log(dist_km) | Origin + Destination + Product, data = trade, family = "gaussian")
-m3 <- feglm(Euros ~ log(dist_km) | Origin + Destination + Product, data = trade, family = "poisson")
-m4 <- feols(
+data(trade, package = "fixest")
+m1 <- fixest::femlm(Euros ~ log(dist_km) | Origin + Destination + Product, data = trade)
+m2 <- fixest::femlm(log1p(Euros) ~ log(dist_km) | Origin + Destination + Product, data = trade, family = "gaussian")
+m3 <- fixest::feglm(Euros ~ log(dist_km) | Origin + Destination + Product, data = trade, family = "poisson")
+m4 <- fixest::feols(
   Sepal.Width ~ Petal.Length | Species | Sepal.Length ~ Petal.Width,
   data = iris
 )
 
 
 test_that("robust variance-covariance", {
-  mod <- feols(mpg ~ hp + drat | cyl, data = mtcars)
+  mod <- fixest::feols(mpg ~ hp + drat | cyl, data = mtcars)
   # default is clustered
   expect_equal(
     sqrt(diag(vcov(mod))),
@@ -42,9 +42,9 @@ test_that("robust variance-covariance", {
 
 
 test_that("offset", {
-  tmp <- feols(mpg ~ hp, offset = ~ log(qsec), data = mtcars)
+  tmp <- fixest::feols(mpg ~ hp, offset = ~ log(qsec), data = mtcars)
   expect_identical(find_offset(tmp), "qsec")
-  tmp <- feols(mpg ~ hp, offset = ~qsec, data = mtcars)
+  tmp <- fixest::feols(mpg ~ hp, offset = ~qsec, data = mtcars)
   expect_identical(find_offset(tmp), "qsec")
 })
 
@@ -145,14 +145,14 @@ test_that("get_data", {
   expect_length(tmp, nrow(iris))
 })
 
-if (skip_if_not_or_load_if_installed("parameters")) {
-  test_that("get_df", {
-    expect_equal(get_df(m1, type = "residual"), 38290, ignore_attr = TRUE)
-    expect_equal(get_df(m1, type = "normal"), Inf, ignore_attr = TRUE)
-    ## TODO: check if statistic is z or t for this model
-    expect_equal(get_df(m1, type = "wald"), 14, ignore_attr = TRUE)
-  })
-}
+skip_if_not_installed("parameters")
+test_that("get_df", {
+  expect_equal(get_df(m1, type = "residual"), 38290, ignore_attr = TRUE)
+  expect_equal(get_df(m1, type = "normal"), Inf, ignore_attr = TRUE)
+  ## TODO: check if statistic is z or t for this model
+  expect_equal(get_df(m1, type = "wald"), 14, ignore_attr = TRUE)
+})
+
 
 test_that("find_formula", {
   expect_length(find_formula(m1), 2)
@@ -286,7 +286,7 @@ test_that("get_data works when model data has name of  reserved words", {
   ## NOTE check back every now and then and see if tests still work
   skip("works interactively")
   rep <- data.frame(Y = runif(100) > 0.5, X = rnorm(100))
-  m <- feglm(Y ~ X, data = rep, family = binomial)
+  m <- fixest::feglm(Y ~ X, data = rep, family = binomial)
   out <- get_data(m)
   expect_s3_class(out, "data.frame")
   expect_equal(
@@ -308,7 +308,7 @@ test_that("get_data works when model data has name of  reserved words", {
 
 
 test_that("find_variables with interaction", {
-  mod <- suppressMessages(feols(mpg ~ 0 | carb | vs:cyl ~ am:cyl, data = mtcars))
+  mod <- suppressMessages(fixest::feols(mpg ~ 0 | carb | vs:cyl ~ am:cyl, data = mtcars))
   expect_equal(
     find_variables(mod),
     list(
@@ -319,7 +319,7 @@ test_that("find_variables with interaction", {
   )
 
   # used to produce a warning
-  mod <- feols(mpg ~ 0 | carb | vs:cyl ~ am:cyl, data = mtcars)
+  mod <- fixest::feols(mpg ~ 0 | carb | vs:cyl ~ am:cyl, data = mtcars)
   expect_warning(find_variables(mod), NA)
 })
 
@@ -328,7 +328,7 @@ test_that("find_predictors with i(f1, i.f2) interaction", {
   aq <- airquality
   aq$week <- aq$Day %/% 7 + 1
 
-  mod <- feols(Ozone ~ i(Month, i.week), aq, notes = FALSE)
+  mod <- fixest::feols(Ozone ~ i(Month, i.week), aq, notes = FALSE)
   expect_equal(
     find_predictors(mod),
     list(
diff --git a/tests/testthat/test-format_table.R b/tests/testthat/test-format_table.R
index bf9756a05..2ab0866a0 100644
--- a/tests/testthat/test-format_table.R
+++ b/tests/testthat/test-format_table.R
@@ -1,71 +1,58 @@
-win_os <- tryCatch(
-  {
-    si <- Sys.info()
-    if (!is.null(si["sysname"])) {
-      si["sysname"] == "Windows" || grepl("^mingw", R.version$os)
-    } else {
-      FALSE
-    }
-  },
-  error = function(e) {
-    TRUE
-  }
-)
-
+skip_if_offline()
+skip_on_os(c("mac", "linux", "solaris"))
+skip_if_not_installed("bayestestR")
 
 # test for bayesian models -----------------
-if (win_os && skip_if_not_or_load_if_installed("bayestestR")) {
-  m1 <- insight::download_model("stanreg_glm_1")
-  set.seed(123)
-  x <- suppressWarnings(as.data.frame(bayestestR::describe_posterior(m1, test = c("pd", "bf"))))
-
-  test_that("format_table with stars bayes", {
-    out <- format_table(x)
-    expect_equal(colnames(out), c("Parameter", "Median", "95% CI", "pd", "Rhat", "ESS", "BF"))
-    expect_equal(out$BF, c("62.73", "114.21"))
-    expect_equal(out$pd, c("99.98%", "100%"))
-
-    out <- format_table(x, stars = TRUE)
-    expect_equal(colnames(out), c("Parameter", "Median", "95% CI", "pd", "Rhat", "ESS", "BF"))
-    expect_equal(out$BF, c("62.73***", "114.21***"))
-    expect_equal(out$pd, c("99.98%***", "100%***"))
-
-    out <- format_table(x, stars = c("pd", "BF"))
-    expect_equal(colnames(out), c("Parameter", "Median", "95% CI", "pd", "Rhat", "ESS", "BF"))
-    expect_equal(out$BF, c("62.73***", "114.21***"))
-    expect_equal(out$pd, c("99.98%***", "100%***"))
-
-    out <- format_table(x, stars = "pd")
-    expect_equal(colnames(out), c("Parameter", "Median", "95% CI", "pd", "Rhat", "ESS", "BF"))
-    expect_equal(out$BF, c("62.73", "114.21"))
-    expect_equal(out$pd, c("99.98%***", "100%***"))
+m1 <- insight::download_model("stanreg_glm_1")
+set.seed(123)
+x <- suppressWarnings(as.data.frame(bayestestR::describe_posterior(m1, test = c("pd", "bf"))))
+
+test_that("format_table with stars bayes", {
+  out <- format_table(x)
+  expect_equal(colnames(out), c("Parameter", "Median", "95% CI", "pd", "Rhat", "ESS", "BF"))
+  expect_equal(out$BF, c("62.73", "114.21"))
+  expect_equal(out$pd, c("99.98%", "100%"))
+
+  out <- format_table(x, stars = TRUE)
+  expect_equal(colnames(out), c("Parameter", "Median", "95% CI", "pd", "Rhat", "ESS", "BF"))
+  expect_equal(out$BF, c("62.73***", "114.21***"))
+  expect_equal(out$pd, c("99.98%***", "100%***"))
+
+  out <- format_table(x, stars = c("pd", "BF"))
+  expect_equal(colnames(out), c("Parameter", "Median", "95% CI", "pd", "Rhat", "ESS", "BF"))
+  expect_equal(out$BF, c("62.73***", "114.21***"))
+  expect_equal(out$pd, c("99.98%***", "100%***"))
+
+  out <- format_table(x, stars = "pd")
+  expect_equal(colnames(out), c("Parameter", "Median", "95% CI", "pd", "Rhat", "ESS", "BF"))
+  expect_equal(out$BF, c("62.73", "114.21"))
+  expect_equal(out$pd, c("99.98%***", "100%***"))
+
+  out <- format_table(x, stars = "BF")
+  expect_equal(colnames(out), c("Parameter", "Median", "95% CI", "pd", "Rhat", "ESS", "BF"))
+  expect_equal(out$BF, c("62.73***", "114.21***"))
+  expect_equal(out$pd, c("99.98%", "100%"))
+})
 
-    out <- format_table(x, stars = "BF")
-    expect_equal(colnames(out), c("Parameter", "Median", "95% CI", "pd", "Rhat", "ESS", "BF"))
-    expect_equal(out$BF, c("62.73***", "114.21***"))
-    expect_equal(out$pd, c("99.98%", "100%"))
-  })
-}
 
 # test for freq models -----------------
-if (skip_if_not_or_load_if_installed("parameters")) {
-  x <- as.data.frame(model_parameters(lm(Sepal.Length ~ Species + Sepal.Width, data = iris)))
+skip_if_not_installed("parameters")
+x <- as.data.frame(parameters::model_parameters(lm(Sepal.Length ~ Species + Sepal.Width, data = iris)))
 
-  test_that("format_table with stars freq", {
-    out <- format_table(x)
-    expect_equal(colnames(out), c("Parameter", "Coefficient", "SE", "95% CI", "t(146)", "p"))
-    expect_equal(out$p, c("< .001", "< .001", "< .001", "< .001"))
+test_that("format_table with stars freq", {
+  out <- format_table(x)
+  expect_equal(colnames(out), c("Parameter", "Coefficient", "SE", "95% CI", "t(146)", "p"))
+  expect_equal(out$p, c("< .001", "< .001", "< .001", "< .001"))
 
-    out <- format_table(x, stars = TRUE)
-    expect_equal(out$p, c("< .001***", "< .001***", "< .001***", "< .001***"))
+  out <- format_table(x, stars = TRUE)
+  expect_equal(out$p, c("< .001***", "< .001***", "< .001***", "< .001***"))
 
-    out <- format_table(x, stars = c("pd", "BF"))
-    expect_equal(out$p, c("< .001", "< .001", "< .001", "< .001"))
+  out <- format_table(x, stars = c("pd", "BF"))
+  expect_equal(out$p, c("< .001", "< .001", "< .001", "< .001"))
 
-    out <- format_table(x, stars = "pd")
-    expect_equal(out$p, c("< .001", "< .001", "< .001", "< .001"))
+  out <- format_table(x, stars = "pd")
+  expect_equal(out$p, c("< .001", "< .001", "< .001", "< .001"))
 
-    out <- format_table(x, stars = c("BF", "p"))
-    expect_equal(out$p, c("< .001***", "< .001***", "< .001***", "< .001***"))
-  })
-}
+  out <- format_table(x, stars = c("BF", "p"))
+  expect_equal(out$p, c("< .001***", "< .001***", "< .001***", "< .001***"))
+})
diff --git a/tests/testthat/test-format_table_ci.R b/tests/testthat/test-format_table_ci.R
index fde322ab2..d8267cbb6 100644
--- a/tests/testthat/test-format_table_ci.R
+++ b/tests/testthat/test-format_table_ci.R
@@ -51,21 +51,10 @@ test_that("format_table with multiple si-levels", {
 })
 
 
-if (skip_if_not_or_load_if_installed("bayestestR")) {
-  set.seed(1234)
-  test_that("format_table with multiple si-levels", {
-    d <- bayestestR::distribution_normal(1000)
-    x <- bayestestR::hdi(d, ci = c(0.80, 0.90))
-    out <- capture.output(print(x))
-    expect_equal(
-      out,
-      c(
-        "Highest Density Interval",
-        "",
-        "80% HDI       |       90% HDI",
-        "-----------------------------",
-        "[-1.28, 1.28] | [-1.65, 1.64]"
-      )
-    )
-  })
-}
+skip_if_not_installed("bayestestR")
+set.seed(1234)
+test_that("format_table with multiple si-levels", {
+  d <- bayestestR::distribution_normal(1000)
+  x <- bayestestR::hdi(d, ci = c(0.80, 0.90))
+  expect_snapshot(x)
+})
diff --git a/tests/testthat/test-gam.R b/tests/testthat/test-gam.R
index dcdc0568a..ccb5de444 100644
--- a/tests/testthat/test-gam.R
+++ b/tests/testthat/test-gam.R
@@ -1,365 +1,367 @@
-if (skip_if_not_or_load_if_installed("mgcv") && skip_if_not_or_load_if_installed("httr")) {
-  set.seed(123)
-  void <- capture.output(
-    dat2 <<- mgcv::gamSim(1, n = 400, dist = "normal", scale = 2)
+skip_if_offline()
+skip_if_not_installed("mgcv")
+skip_if_not_installed("httr")
+
+set.seed(123)
+void <- capture.output(
+  dat2 <<- mgcv::gamSim(1, n = 400, dist = "normal", scale = 2)
+)
+
+# data for model m3
+V <- matrix(c(2, 1, 1, 2), 2, 2)
+f0 <- function(x) 2 * sin(pi * x)
+f1 <- function(x) exp(2 * x)
+f2 <- function(x) 0.2 * x^11 * (10 * (1 - x))^6 + 10 * (10 * x)^3 * (1 - x)^10
+n <- 300
+x0 <- runif(n)
+x1 <- runif(n)
+x2 <- runif(n)
+x3 <- runif(n)
+y <- matrix(0, n, 2)
+for (i in 1:n) {
+  mu <- c(f0(x0[i]) + f1(x1[i]), f2(x2[i]))
+  y[i, ] <- mgcv::rmvn(1, mu, V)
+}
+dat <<- data.frame(y0 = y[, 1], y1 = y[, 2], x0 = x0, x1 = x1, x2 = x2, x3 = x3)
+
+m1 <- mgcv::gam(y ~ s(x0) + s(x1) + s(x2) + s(x3), data = dat2)
+m2 <- download_model("gam_zi_1")
+m3 <- download_model("gam_mv_1")
+
+test_that("model_info", {
+  expect_true(model_info(m1)$is_linear)
+  expect_true(model_info(m2)$is_count)
+  expect_true(model_info(m3)$is_multivariate)
+})
+
+test_that("n_parameters", {
+  expect_equal(n_parameters(m1), 5)
+  expect_equal(n_parameters(m1, component = "conditional"), 1)
+})
+
+test_that("clean_names", {
+  expect_equal(clean_names(m1), c("y", "x0", "x1", "x2", "x3"))
+  expect_equal(clean_names(m2), c("y", "x2", "x3", "x0", "x1"))
+  expect_equal(clean_names(m3), c("y0", "y1", "x0", "x1", "x2", "x3"))
+})
+
+test_that("get_df", {
+  expect_equal(
+    get_df(m1, type = "residual"),
+    df.residual(m1),
+    ignore_attr = TRUE
   )
+  expect_equal(
+    get_df(m1, type = "normal"),
+    Inf,
+    ignore_attr = TRUE
+  )
+  expect_equal(
+    get_df(m1, type = "wald"),
+    383.0491,
+    ignore_attr = TRUE,
+    tolerance = 1e-3
+  )
+})
 
-  # data for model m3
-  V <- matrix(c(2, 1, 1, 2), 2, 2)
-  f0 <- function(x) 2 * sin(pi * x)
-  f1 <- function(x) exp(2 * x)
-  f2 <- function(x) 0.2 * x^11 * (10 * (1 - x))^6 + 10 * (10 * x)^3 * (1 - x)^10
-  n <- 300
-  x0 <- runif(n)
-  x1 <- runif(n)
-  x2 <- runif(n)
-  x3 <- runif(n)
-  y <- matrix(0, n, 2)
-  for (i in 1:n) {
-    mu <- c(f0(x0[i]) + f1(x1[i]), f2(x2[i]))
-    y[i, ] <- rmvn(1, mu, V)
-  }
-  dat <<- data.frame(y0 = y[, 1], y1 = y[, 2], x0 = x0, x1 = x1, x2 = x2, x3 = x3)
-
-  m1 <- mgcv::gam(y ~ s(x0) + s(x1) + s(x2) + s(x3), data = dat2)
-  m2 <- download_model("gam_zi_1")
-  m3 <- download_model("gam_mv_1")
-
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_linear)
-    expect_true(model_info(m2)$is_count)
-    expect_true(model_info(m3)$is_multivariate)
-  })
-
-  test_that("n_parameters", {
-    expect_equal(n_parameters(m1), 5)
-    expect_equal(n_parameters(m1, component = "conditional"), 1)
-  })
-
-  test_that("clean_names", {
-    expect_equal(clean_names(m1), c("y", "x0", "x1", "x2", "x3"))
-    expect_equal(clean_names(m2), c("y", "x2", "x3", "x0", "x1"))
-    expect_equal(clean_names(m3), c("y0", "y1", "x0", "x1", "x2", "x3"))
-  })
-
-  test_that("get_df", {
-    expect_equal(
-      get_df(m1, type = "residual"),
-      df.residual(m1),
-      ignore_attr = TRUE
-    )
-    expect_equal(
-      get_df(m1, type = "normal"),
-      Inf,
-      ignore_attr = TRUE
-    )
-    expect_equal(
-      get_df(m1, type = "wald"),
-      383.0491,
-      ignore_attr = TRUE,
-      tolerance = 1e-3
-    )
-  })
-
-  test_that("find_predictors", {
-    expect_identical(find_predictors(m1), list(conditional = c("x0", "x1", "x2", "x3")))
-    expect_identical(
-      find_predictors(m1, flatten = TRUE),
-      c("x0", "x1", "x2", "x3")
-    )
-    expect_null(find_predictors(m1, effects = "random"))
-
-    expect_identical(find_predictors(m2), list(conditional = c("x2", "x3"), zero_inflated = c("x0", "x1")))
-    expect_identical(find_predictors(m2, flatten = TRUE), c("x2", "x3", "x0", "x1"))
-    expect_null(find_predictors(m2, effects = "random"))
-
-    expect_identical(find_predictors(m3), list(y0 = list(conditional = c("x0", "x1")), y1 = list(conditional = c("x2", "x3"))))
-    expect_identical(find_predictors(m3, flatten = TRUE), c("x0", "x1", "x2", "x3"))
-    expect_null(find_predictors(m3, effects = "random"))
-  })
-
-  test_that("find_response", {
-    expect_identical(find_response(m1), "y")
-    expect_identical(find_response(m2), "y")
-    expect_identical(find_response(m3), c(y0 = "y0", y1 = "y1"))
-  })
-
-  test_that("find_smooth", {
-    expect_identical(find_smooth(m1), list(smooth_terms = c("s(x0)", "s(x1)", "s(x2)", "s(x3)")))
-  })
-
-  test_that("get_call", {
-    expect_identical(deparse(get_call(m1)), "mgcv::gam(formula = y ~ s(x0) + s(x1) + s(x2) + s(x3), data = dat2)")
-  })
-
-  test_that("get_response", {
-    expect_equal(get_response(m1), dat2$y, ignore_attr = TRUE)
-    expect_length(get_response(m2), 500)
-    expect_identical(ncol(get_response(m3)), 2L)
-  })
-
-  test_that("link_inverse", {
-    expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
-    expect_equal(link_inverse(m2)(0.2), 0.2, tolerance = 1e-5)
-    expect_equal(link_inverse(m3)(0.2), 0.2, tolerance = 1e-5)
-  })
-
-  test_that("get_data", {
-    expect_identical(nrow(get_data(m1, verbose = FALSE)), 400L)
-    expect_identical(colnames(get_data(m1, verbose = FALSE)), c("y", "x0", "x1", "x2", "x3"))
-    expect_identical(nrow(get_data(m2, verbose = FALSE)), 500L)
-    expect_identical(colnames(get_data(m2, verbose = FALSE)), c("y", "x2", "x3", "x0", "x1"))
-    expect_identical(nrow(get_data(m3, verbose = FALSE)), 300L)
-
-    # extract data from environment allows us to keep additional variables
-    miris <- mgcv::gam(Sepal.Length ~ s(Sepal.Width), data = iris)
-    tmp <- get_data(miris, additional_variables = TRUE)
-    expect_true("Petal.Width" %in% colnames(tmp))
-  })
-
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 1)
-    expect_equal(
-      find_formula(m1),
-      list(conditional = as.formula("y ~ s(x0) + s(x1) + s(x2) + s(x3)")),
-      ignore_attr = TRUE
-    )
-    expect_length(find_formula(m2), 2)
-    expect_equal(
-      find_formula(m2),
+test_that("find_predictors", {
+  expect_identical(find_predictors(m1), list(conditional = c("x0", "x1", "x2", "x3")))
+  expect_identical(
+    find_predictors(m1, flatten = TRUE),
+    c("x0", "x1", "x2", "x3")
+  )
+  expect_null(find_predictors(m1, effects = "random"))
+
+  expect_identical(find_predictors(m2), list(conditional = c("x2", "x3"), zero_inflated = c("x0", "x1")))
+  expect_identical(find_predictors(m2, flatten = TRUE), c("x2", "x3", "x0", "x1"))
+  expect_null(find_predictors(m2, effects = "random"))
+
+  expect_identical(find_predictors(m3), list(y0 = list(conditional = c("x0", "x1")), y1 = list(conditional = c("x2", "x3"))))
+  expect_identical(find_predictors(m3, flatten = TRUE), c("x0", "x1", "x2", "x3"))
+  expect_null(find_predictors(m3, effects = "random"))
+})
+
+test_that("find_response", {
+  expect_identical(find_response(m1), "y")
+  expect_identical(find_response(m2), "y")
+  expect_identical(find_response(m3), c(y0 = "y0", y1 = "y1"))
+})
+
+test_that("find_smooth", {
+  expect_identical(find_smooth(m1), list(smooth_terms = c("s(x0)", "s(x1)", "s(x2)", "s(x3)")))
+})
+
+test_that("get_call", {
+  expect_identical(deparse(get_call(m1)), "mgcv::gam(formula = y ~ s(x0) + s(x1) + s(x2) + s(x3), data = dat2)")
+})
+
+test_that("get_response", {
+  expect_equal(get_response(m1), dat2$y, ignore_attr = TRUE)
+  expect_length(get_response(m2), 500)
+  expect_identical(ncol(get_response(m3)), 2L)
+})
+
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
+  expect_equal(link_inverse(m2)(0.2), 0.2, tolerance = 1e-5)
+  expect_equal(link_inverse(m3)(0.2), 0.2, tolerance = 1e-5)
+})
+
+test_that("get_data", {
+  expect_identical(nrow(get_data(m1, verbose = FALSE)), 400L)
+  expect_identical(colnames(get_data(m1, verbose = FALSE)), c("y", "x0", "x1", "x2", "x3"))
+  expect_identical(nrow(get_data(m2, verbose = FALSE)), 500L)
+  expect_identical(colnames(get_data(m2, verbose = FALSE)), c("y", "x2", "x3", "x0", "x1"))
+  expect_identical(nrow(get_data(m3, verbose = FALSE)), 300L)
+
+  # extract data from environment allows us to keep additional variables
+  miris <- mgcv::gam(Sepal.Length ~ s(Sepal.Width), data = iris)
+  tmp <- get_data(miris, additional_variables = TRUE)
+  expect_true("Petal.Width" %in% colnames(tmp))
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1), 1)
+  expect_equal(
+    find_formula(m1),
+    list(conditional = as.formula("y ~ s(x0) + s(x1) + s(x2) + s(x3)")),
+    ignore_attr = TRUE
+  )
+  expect_length(find_formula(m2), 2)
+  expect_equal(
+    find_formula(m2),
+    list(
+      conditional = as.formula("y ~ s(x2) + s(x3)"),
+      zero_inflated = as.formula("~s(x0) + s(x1)")
+    ),
+    ignore_attr = TRUE
+  )
+  expect_length(find_formula(m3), 2)
+  expect_equal(
+    find_formula(m3),
+    structure(
       list(
-        conditional = as.formula("y ~ s(x2) + s(x3)"),
-        zero_inflated = as.formula("~s(x0) + s(x1)")
+        y0 = list(conditional = as.formula("y0 ~ s(x0) + s(x1)")),
+        y1 = list(conditional = as.formula("y1 ~ s(x2) + s(x3)"))
       ),
-      ignore_attr = TRUE
+      is_mv = "1"
+    ),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_variables", {
+  expect_identical(find_variables(m1), list(response = "y", conditional = c("x0", "x1", "x2", "x3")))
+  expect_identical(find_variables(m1, flatten = TRUE), c("y", "x0", "x1", "x2", "x3"))
+  expect_identical(find_variables(m2), list(response = "y", conditional = c("x2", "x3"), zero_inflated = c("x0", "x1")))
+  expect_identical(find_variables(m2, flatten = TRUE), c("y", "x2", "x3", "x0", "x1"))
+  expect_identical(find_variables(m3), list(response = c(y0 = "y0", y1 = "y1"), y0 = list(conditional = c("x0", "x1")), y1 = list(conditional = c("x2", "x3"))))
+  expect_identical(find_variables(m3, flatten = TRUE), c("y0", "y1", "x0", "x1", "x2", "x3"))
+})
+
+test_that("n_obs", {
+  expect_identical(n_obs(m1), 400L)
+  expect_identical(n_obs(m2), 500L)
+  expect_identical(n_obs(m3), 300L)
+})
+
+test_that("linkfun", {
+  expect_false(is.null(link_function(m1)))
+})
+
+test_that("find_parameters", {
+  expect_identical(
+    find_parameters(m1),
+    list(
+      conditional = "(Intercept)",
+      smooth_terms = c("s(x0)", "s(x1)", "s(x2)", "s(x3)")
     )
-    expect_length(find_formula(m3), 2)
-    expect_equal(
-      find_formula(m3),
-      structure(
-        list(
-          y0 = list(conditional = as.formula("y0 ~ s(x0) + s(x1)")),
-          y1 = list(conditional = as.formula("y1 ~ s(x2) + s(x3)"))
-        ),
-        is_mv = "1"
-      ),
-      ignore_attr = TRUE
+  )
+  expect_identical(nrow(get_parameters(m1)), 5L)
+  expect_identical(
+    get_parameters(m1)$Parameter,
+    c("(Intercept)", "s(x0)", "s(x1)", "s(x2)", "s(x3)")
+  )
+  expect_identical(nrow(get_parameters(m1, "smooth_terms")), 4L)
+
+  expect_identical(
+    find_parameters(m2),
+    list(
+      conditional = c("(Intercept)", "(Intercept).1"),
+      smooth_terms = c("s(x2)", "s(x3)", "s.1(x0)", "s.1(x1)")
     )
-  })
-
-  test_that("find_variables", {
-    expect_identical(find_variables(m1), list(response = "y", conditional = c("x0", "x1", "x2", "x3")))
-    expect_identical(find_variables(m1, flatten = TRUE), c("y", "x0", "x1", "x2", "x3"))
-    expect_identical(find_variables(m2), list(response = "y", conditional = c("x2", "x3"), zero_inflated = c("x0", "x1")))
-    expect_identical(find_variables(m2, flatten = TRUE), c("y", "x2", "x3", "x0", "x1"))
-    expect_identical(find_variables(m3), list(response = c(y0 = "y0", y1 = "y1"), y0 = list(conditional = c("x0", "x1")), y1 = list(conditional = c("x2", "x3"))))
-    expect_identical(find_variables(m3, flatten = TRUE), c("y0", "y1", "x0", "x1", "x2", "x3"))
-  })
-
-  test_that("n_obs", {
-    expect_identical(n_obs(m1), 400L)
-    expect_identical(n_obs(m2), 500L)
-    expect_identical(n_obs(m3), 300L)
-  })
-
-  test_that("linkfun", {
-    expect_false(is.null(link_function(m1)))
-  })
-
-  test_that("find_parameters", {
-    expect_identical(
-      find_parameters(m1),
-      list(
-        conditional = "(Intercept)",
-        smooth_terms = c("s(x0)", "s(x1)", "s(x2)", "s(x3)")
-      )
+  )
+})
+
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1))
+  expect_false(is_multivariate(m2))
+  expect_true(is_multivariate(m3))
+})
+
+test_that("find_terms", {
+  expect_identical(
+    find_terms(m1),
+    list(
+      response = "y",
+      conditional = c("s(x0)", "s(x1)", "s(x2)", "s(x3)")
     )
-    expect_identical(nrow(get_parameters(m1)), 5L)
-    expect_identical(
-      get_parameters(m1)$Parameter,
-      c("(Intercept)", "s(x0)", "s(x1)", "s(x2)", "s(x3)")
+  )
+  expect_identical(
+    find_terms(m2),
+    list(
+      response = "y",
+      conditional = c("s(x2)", "s(x3)"),
+      zero_inflated = c("s(x0)", "s(x1)")
     )
-    expect_identical(nrow(get_parameters(m1, "smooth_terms")), 4L)
-
-    expect_identical(
-      find_parameters(m2),
-      list(
-        conditional = c("(Intercept)", "(Intercept).1"),
-        smooth_terms = c("s(x2)", "s(x3)", "s.1(x0)", "s.1(x1)")
-      )
+  )
+  expect_identical(
+    find_terms(m3),
+    list(
+      y0 = list(response = "y0", conditional = c("s(x0)", "s(x1)")),
+      y1 = list(response = "y1", conditional = c("s(x2)", "s(x3)"))
     )
-  })
+  )
+})
 
-  test_that("is_multivariate", {
-    expect_false(is_multivariate(m1))
-    expect_false(is_multivariate(m2))
-    expect_true(is_multivariate(m3))
-  })
+test_that("find_algorithm", {
+  expect_identical(
+    find_algorithm(m1),
+    list(algorithm = "GCV", optimizer = "magic")
+  )
+})
 
-  test_that("find_terms", {
-    expect_identical(
-      find_terms(m1),
-      list(
-        response = "y",
-        conditional = c("s(x0)", "s(x1)", "s(x2)", "s(x3)")
-      )
-    )
-    expect_identical(
-      find_terms(m2),
-      list(
-        response = "y",
-        conditional = c("s(x2)", "s(x3)"),
-        zero_inflated = c("s(x0)", "s(x1)")
-      )
-    )
-    expect_identical(
-      find_terms(m3),
-      list(
-        y0 = list(response = "y0", conditional = c("s(x0)", "s(x1)")),
-        y1 = list(response = "y1", conditional = c("s(x2)", "s(x3)"))
-      )
-    )
-  })
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "t-statistic")
+})
 
-  test_that("find_algorithm", {
-    expect_identical(
-      find_algorithm(m1),
-      list(algorithm = "GCV", optimizer = "magic")
-    )
-  })
-
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "t-statistic")
-  })
-
-  test_that("get_parameters works for gams without smooth or smooth only", {
-    set.seed(123)
-    dat <- gamSim(1, n = 400, dist = "normal", scale = 2)
-    b <- gam(y ~ s(x0) + s(x1) - 1, data = dat)
-    out <- get_parameters(b)
-    expect_equal(out$Estimate, c(1.501, 1.2384), tolerance = 1e-3)
-    expect_identical(out$Parameter, c("s(x0)", "s(x1)"))
-
-    out <- get_statistic(b)
-    expect_equal(out$Statistic, c(0.5319, 14.2444), tolerance = 1e-3)
-    expect_identical(out$Parameter, c("s(x0)", "s(x1)"))
-
-    out <- get_parameters(b, component = "conditional")
-    expect_null(out)
-
-    out <- get_parameters(b, component = "smooth_terms")
-    expect_equal(out$Estimate, c(1.501, 1.2384), tolerance = 1e-3)
-    expect_identical(out$Parameter, c("s(x0)", "s(x1)"))
-
-    b <- gam(y ~ x0 + x1, data = dat)
-    out <- get_parameters(b)
-    expect_equal(out$Estimate, c(4.5481, 0.4386, 6.4379), tolerance = 1e-3)
-    expect_identical(out$Parameter, c("(Intercept)", "x0", "x1"))
-
-    out <- get_statistic(b)
-    expect_equal(out$Statistic, c(9.9086, 0.7234, 10.9056), tolerance = 1e-3)
-    expect_identical(out$Parameter, c("(Intercept)", "x0", "x1"))
-
-    out <- get_parameters(b, component = "conditional")
-    expect_equal(out$Estimate, c(4.5481, 0.4386, 6.4379), tolerance = 1e-3)
-    expect_identical(out$Parameter, c("(Intercept)", "x0", "x1"))
-
-    out <- get_parameters(b, component = "smooth_terms")
-    expect_null(out)
-  })
-
-
-
-  test_that("get_predicted", {
-    # dat3 <- head(dat, 30)
-    # tmp <- mgcv::gam(y ~ s(x0) + s(x1), data = dat3)
-    # pred <- get_predicted(tmp, verbose = FALSE, ci = 0.95)
-    # expect_s3_class(pred, "get_predicted")
-    # expect_equal(
-    #   as.vector(pred),
-    #   c(
-    #     11.99341, 5.58098, 10.89252, 7.10335, 5.94836, 6.5724, 8.5054,
-    #     5.47147, 5.9343, 8.27001, 5.71199, 9.94999, 5.69979, 6.63532,
-    #     6.00475, 5.58633, 11.54848, 6.1083, 6.6151, 5.37164, 6.86236,
-    #     7.80726, 7.38088, 5.70664, 10.60654, 7.62847, 5.8596, 6.06744,
-    #     5.81571, 10.4606
-    #   ),
-    #   tolerance = 1e-3
-    # )
-
-    # x <- get_predicted(tmp, predict = NULL, type = "link", ci = 0.95)
-    # y <- get_predicted(tmp, predict = "link", ci = 0.95)
-    # z <- predict(tmp, type = "link", se.fit = TRUE)
-    # expect_equal(x, y)
-    # expect_equal(x, z$fit, ignore_attr = TRUE)
-    # expect_equal(as.data.frame(x)$SE, z$se.fit, ignore_attr = TRUE)
-
-    # x <- get_predicted(tmp, predict = NULL, type = "response", verbose = FALSE, ci = 0.95)
-    # y <- get_predicted(tmp, predict = "expectation", ci = 0.95)
-    # z <- predict(tmp, type = "response", se.fit = TRUE)
-    # expect_equal(x, y, ignore_attr = TRUE)
-    # expect_equal(x, z$fit, ignore_attr = TRUE)
-    # expect_equal(as.data.frame(x)$SE, z$se.fit, ignore_attr = TRUE)
-
-    # poisson
-    void <- capture.output(
-      dat <<- gamSim(1, n = 400, dist = "poisson", scale = 0.25)
-    )
-    b4 <- gam(
-      y ~ s(x0) + s(x1) + s(x2) + s(x3),
-      family = poisson,
-      data = dat,
-      method = "GACV.Cp",
-      scale = -1
-    )
-    d <- get_datagrid(b4, at = "x1")
-    p1 <- get_predicted(b4, data = d, predict = "expectation", ci = 0.95)
-    p2 <- predict(b4, newdata = d, type = "response")
-    expect_equal(as.vector(p1), as.vector(p2), tolerance = 1e-4, ignore_attr = TRUE)
+test_that("get_parameters works for gams without smooth or smooth only", {
+  set.seed(123)
+  dat <- mgcv::gamSim(1, n = 400, dist = "normal", scale = 2, verbose = FALSE)
+  b <- mgcv::gam(y ~ s(x0) + s(x1) - 1, data = dat)
+  out <- get_parameters(b)
+  expect_equal(out$Estimate, c(1.501, 1.2384), tolerance = 1e-3)
+  expect_identical(out$Parameter, c("s(x0)", "s(x1)"))
+
+  out <- get_statistic(b)
+  expect_equal(out$Statistic, c(0.5319, 14.2444), tolerance = 1e-3)
+  expect_identical(out$Parameter, c("s(x0)", "s(x1)"))
+
+  out <- get_parameters(b, component = "conditional")
+  expect_null(out)
+
+  out <- get_parameters(b, component = "smooth_terms")
+  expect_equal(out$Estimate, c(1.501, 1.2384), tolerance = 1e-3)
+  expect_identical(out$Parameter, c("s(x0)", "s(x1)"))
+
+  b <- mgcv::gam(y ~ x0 + x1, data = dat)
+  out <- get_parameters(b)
+  expect_equal(out$Estimate, c(4.5481, 0.4386, 6.4379), tolerance = 1e-3)
+  expect_identical(out$Parameter, c("(Intercept)", "x0", "x1"))
+
+  out <- get_statistic(b)
+  expect_equal(out$Statistic, c(9.9086, 0.7234, 10.9056), tolerance = 1e-3)
+  expect_identical(out$Parameter, c("(Intercept)", "x0", "x1"))
+
+  out <- get_parameters(b, component = "conditional")
+  expect_equal(out$Estimate, c(4.5481, 0.4386, 6.4379), tolerance = 1e-3)
+  expect_identical(out$Parameter, c("(Intercept)", "x0", "x1"))
+
+  out <- get_parameters(b, component = "smooth_terms")
+  expect_null(out)
+})
+
+
+
+test_that("get_predicted", {
+  # dat3 <- head(dat, 30)
+  # tmp <- mgcv::gam(y ~ s(x0) + s(x1), data = dat3)
+  # pred <- get_predicted(tmp, verbose = FALSE, ci = 0.95)
+  # expect_s3_class(pred, "get_predicted")
+  # expect_equal(
+  #   as.vector(pred),
+  #   c(
+  #     11.99341, 5.58098, 10.89252, 7.10335, 5.94836, 6.5724, 8.5054,
+  #     5.47147, 5.9343, 8.27001, 5.71199, 9.94999, 5.69979, 6.63532,
+  #     6.00475, 5.58633, 11.54848, 6.1083, 6.6151, 5.37164, 6.86236,
+  #     7.80726, 7.38088, 5.70664, 10.60654, 7.62847, 5.8596, 6.06744,
+  #     5.81571, 10.4606
+  #   ),
+  #   tolerance = 1e-3
+  # )
+
+  # x <- get_predicted(tmp, predict = NULL, type = "link", ci = 0.95)
+  # y <- get_predicted(tmp, predict = "link", ci = 0.95)
+  # z <- predict(tmp, type = "link", se.fit = TRUE)
+  # expect_equal(x, y)
+  # expect_equal(x, z$fit, ignore_attr = TRUE)
+  # expect_equal(as.data.frame(x)$SE, z$se.fit, ignore_attr = TRUE)
+
+  # x <- get_predicted(tmp, predict = NULL, type = "response", verbose = FALSE, ci = 0.95)
+  # y <- get_predicted(tmp, predict = "expectation", ci = 0.95)
+  # z <- predict(tmp, type = "response", se.fit = TRUE)
+  # expect_equal(x, y, ignore_attr = TRUE)
+  # expect_equal(x, z$fit, ignore_attr = TRUE)
+  # expect_equal(as.data.frame(x)$SE, z$se.fit, ignore_attr = TRUE)
+
+  # poisson
+  void <- capture.output(
+    dat <<- mgcv::gamSim(1, n = 400, dist = "poisson", scale = 0.25)
+  )
+  b4 <- mgcv::gam(
+    y ~ s(x0) + s(x1) + s(x2) + s(x3),
+    family = poisson,
+    data = dat,
+    method = "GACV.Cp",
+    scale = -1
+  )
+  d <- get_datagrid(b4, at = "x1")
+  p1 <- get_predicted(b4, data = d, predict = "expectation", ci = 0.95)
+  p2 <- predict(b4, newdata = d, type = "response")
+  expect_equal(as.vector(p1), as.vector(p2), tolerance = 1e-4, ignore_attr = TRUE)
 
-    p1 <- get_predicted(b4, data = d, predict = "link", ci = 0.95)
-    p2 <- predict(b4, newdata = d, type = "link")
-    expect_equal(as.vector(p1), as.vector(p2), tolerance = 1e-4, ignore_attr = TRUE)
+  p1 <- get_predicted(b4, data = d, predict = "link", ci = 0.95)
+  p2 <- predict(b4, newdata = d, type = "link")
+  expect_equal(as.vector(p1), as.vector(p2), tolerance = 1e-4, ignore_attr = TRUE)
 
-    p1 <- get_predicted(b4, data = d, type = "link", predict = NULL, ci = 0.95)
-    p2 <- predict(b4, newdata = d, type = "link")
-    expect_equal(as.vector(p1), as.vector(p2), tolerance = 1e-4, ignore_attr = TRUE)
+  p1 <- get_predicted(b4, data = d, type = "link", predict = NULL, ci = 0.95)
+  p2 <- predict(b4, newdata = d, type = "link")
+  expect_equal(as.vector(p1), as.vector(p2), tolerance = 1e-4, ignore_attr = TRUE)
 
-    p1 <- get_predicted(b4, data = d, type = "response", predict = NULL, ci = 0.95)
-    p2 <- predict(b4, newdata = d, type = "response")
-    expect_equal(as.vector(p1), as.vector(p2), tolerance = 1e-4, ignore_attr = TRUE)
+  p1 <- get_predicted(b4, data = d, type = "response", predict = NULL, ci = 0.95)
+  p2 <- predict(b4, newdata = d, type = "response")
+  expect_equal(as.vector(p1), as.vector(p2), tolerance = 1e-4, ignore_attr = TRUE)
 
-    void <- capture.output(
-      dat <<- gamSim(1, n = 400, dist = "poisson", scale = 0.25)
-    )
-    b4 <- gam(
-      y ~ s(x0) + s(x1) + s(x2) + s(x3),
-      family = poisson,
-      data = dat,
-      method = "GACV.Cp",
-      scale = -1
-    )
+  void <- capture.output(
+    dat <<- mgcv::gamSim(1, n = 400, dist = "poisson", scale = 0.25)
+  )
+  b4 <- mgcv::gam(
+    y ~ s(x0) + s(x1) + s(x2) + s(x3),
+    family = poisson,
+    data = dat,
+    method = "GACV.Cp",
+    scale = -1
+  )
 
-    # exclude argument should be pushed through ...
-    p1 <- predict(b4, type = "response", exclude = "s(x1)")
-    p2 <- get_predicted(b4, predict = "expectation", exclude = "s(x1)", ci = 0.95)
-    expect_equal(as.vector(p1), as.vector(p2), tolerance = 1e-4, ignore_attr = TRUE)
-    p1 <- predict(b4, type = "link", exclude = "s(x1)")
-    p2 <- get_predicted(b4, predict = "link", exclude = "s(x1)", ci = 0.95)
-    expect_equal(as.vector(p1), as.vector(p2), tolerance = 1e-4, ignore_attr = TRUE)
-  })
-
-
-  test_that("stats::predict.Gam matches get_predicted.Gam", {
-    skip_if_not_or_load_if_installed("gam")
-    data(kyphosis, package = "gam")
-    tmp <<- kyphosis
-    mod <- gam::gam(Kyphosis ~ gam::s(Age, 4) + Number, family = binomial, data = tmp)
-    p1 <- get_predicted(mod, predict = "link")
-    p2 <- predict(mod, type = "link")
-    expect_equal(as.vector(p1), p2, ignore_attr = TRUE)
-    p1 <- get_predicted(mod, predict = "expectation")
-    p2 <- predict(mod, type = "response")
-    expect_equal(as.vector(p1), p2, ignore_attr = TRUE)
-  })
-}
+  # exclude argument should be pushed through ...
+  p1 <- predict(b4, type = "response", exclude = "s(x1)")
+  p2 <- get_predicted(b4, predict = "expectation", exclude = "s(x1)", ci = 0.95)
+  expect_equal(as.vector(p1), as.vector(p2), tolerance = 1e-4, ignore_attr = TRUE)
+  p1 <- predict(b4, type = "link", exclude = "s(x1)")
+  p2 <- get_predicted(b4, predict = "link", exclude = "s(x1)", ci = 0.95)
+  expect_equal(as.vector(p1), as.vector(p2), tolerance = 1e-4, ignore_attr = TRUE)
+})
+
+
+test_that("stats::predict.Gam matches get_predicted.Gam", {
+  skip_if_not_installed("gam")
+  data(kyphosis, package = "gam")
+  tmp <<- kyphosis
+  mod <- gam::gam(Kyphosis ~ gam::s(Age, 4) + Number, family = binomial, data = tmp)
+  p1 <- get_predicted(mod, predict = "link")
+  p2 <- predict(mod, type = "link")
+  expect_equal(as.vector(p1), p2, ignore_attr = TRUE)
+  p1 <- get_predicted(mod, predict = "expectation")
+  p2 <- predict(mod, type = "response")
+  expect_equal(as.vector(p1), p2, ignore_attr = TRUE)
+})
diff --git a/tests/testthat/test-gamlss.R b/tests/testthat/test-gamlss.R
index 3ef5a75a6..fcf2effb9 100644
--- a/tests/testthat/test-gamlss.R
+++ b/tests/testthat/test-gamlss.R
@@ -1,124 +1,127 @@
-if (skip_if_not_or_load_if_installed("gamlss")) {
-  data(abdom)
-  void <- capture.output(
-    m1 <-
-      gamlss(
-        y ~ pb(x),
-        sigma.formula = ~ pb(x),
-        family = BCT,
-        data = abdom,
-        method = mixed(1, 20)
-      )
-  )
-
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_linear)
-  })
-
-  test_that("find_predictors", {
-    expect_identical(find_predictors(m1), list(conditional = "x", sigma = "x"))
-    expect_identical(find_predictors(m1, flatten = TRUE), "x")
-    expect_null(find_predictors(m1, effects = "random"))
-  })
-
-  test_that("find_random", {
-    expect_null(find_random(m1))
-  })
-
-  test_that("get_random", {
-    expect_warning(get_random(m1))
-  })
-
-  test_that("find_response", {
-    expect_identical(find_response(m1), "y")
-  })
-
-  test_that("get_response", {
-    expect_equal(get_response(m1), abdom$y)
-  })
-
-  test_that("get_predictors", {
-    expect_equal(colnames(get_predictors(m1)), "x")
-  })
-
-  test_that("get_data", {
-    expect_equal(nrow(get_data(m1)), 610)
-    expect_equal(colnames(get_data(m1)), c("y", "x"))
-  })
-
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 4)
-    expect_equal(
-      find_formula(m1),
-      list(
-        conditional = as.formula("y ~ pb(x)"),
-        sigma = as.formula("~pb(x)"),
-        nu = as.formula("~1"),
-        tau = as.formula("~1")
-      ),
-      ignore_attr = TRUE
+skip_if_not_installed("gamlss")
+skip_if_not_installed("gamlss.data")
+
+pb <- gamlss::pb
+
+data(abdom, package = "gamlss.data")
+void <- capture.output(
+  m1 <-
+    gamlss::gamlss(
+      y ~ pb(x),
+      sigma.formula = ~ pb(x),
+      family = "BCT",
+      data = abdom,
+      method = mixed(1, 20)
     )
-  })
-
-  test_that("find_variables", {
-    expect_equal(
-      find_variables(m1),
-      list(
-        response = "y",
-        conditional = "x",
-        sigma = "x"
-      )
+)
+
+test_that("model_info", {
+  expect_true(model_info(m1)$is_linear)
+})
+
+test_that("find_predictors", {
+  expect_identical(find_predictors(m1), list(conditional = "x", sigma = "x"))
+  expect_identical(find_predictors(m1, flatten = TRUE), "x")
+  expect_null(find_predictors(m1, effects = "random"))
+})
+
+test_that("find_random", {
+  expect_null(find_random(m1))
+})
+
+test_that("get_random", {
+  expect_warning(get_random(m1))
+})
+
+test_that("find_response", {
+  expect_identical(find_response(m1), "y")
+})
+
+test_that("get_response", {
+  expect_equal(get_response(m1), abdom$y)
+})
+
+test_that("get_predictors", {
+  expect_equal(colnames(get_predictors(m1)), "x")
+})
+
+test_that("get_data", {
+  expect_equal(nrow(get_data(m1)), 610)
+  expect_equal(colnames(get_data(m1)), c("y", "x"))
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1), 4)
+  expect_equal(
+    find_formula(m1),
+    list(
+      conditional = as.formula("y ~ pb(x)"),
+      sigma = as.formula("~pb(x)"),
+      nu = as.formula("~1"),
+      tau = as.formula("~1")
+    ),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_variables", {
+  expect_equal(
+    find_variables(m1),
+    list(
+      response = "y",
+      conditional = "x",
+      sigma = "x"
     )
-    expect_equal(find_variables(m1, flatten = TRUE), c("y", "x"))
-  })
-
-  test_that("find_terms", {
-    expect_equal(
-      find_terms(m1),
-      list(
-        response = "y",
-        conditional = "pb(x)",
-        sigma = "pb(x)",
-        nu = "1",
-        tau = "1"
-      )
+  )
+  expect_equal(find_variables(m1, flatten = TRUE), c("y", "x"))
+})
+
+test_that("find_terms", {
+  expect_equal(
+    find_terms(m1),
+    list(
+      response = "y",
+      conditional = "pb(x)",
+      sigma = "pb(x)",
+      nu = "1",
+      tau = "1"
     )
-  })
-
-  test_that("n_obs", {
-    expect_equal(n_obs(m1), 610)
-  })
-
-  test_that("link_function", {
-    expect_equal(link_function(m1)(0.2), 0.2, tolerance = 1e-5)
-  })
-
-  test_that("link_inverse", {
-    expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
-  })
-
-  test_that("find_parameters", {
-    expect_equal(
-      find_parameters(m1),
-      list(
-        conditional = c("(Intercept)", "pb(x)"),
-        sigma = c("(Intercept)", "pb(x)"),
-        nu = "(Intercept)",
-        tau = "(Intercept)"
-      )
+  )
+})
+
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 610)
+})
+
+test_that("link_function", {
+  expect_equal(link_function(m1)(0.2), 0.2, tolerance = 1e-5)
+})
+
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
+})
+
+test_that("find_parameters", {
+  expect_equal(
+    find_parameters(m1),
+    list(
+      conditional = c("(Intercept)", "pb(x)"),
+      sigma = c("(Intercept)", "pb(x)"),
+      nu = "(Intercept)",
+      tau = "(Intercept)"
     )
-    expect_equal(nrow(get_parameters(m1)), 6)
-  })
+  )
+  expect_equal(nrow(get_parameters(m1)), 6)
+})
 
-  test_that("is_multivariate", {
-    expect_false(is_multivariate(m1))
-  })
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1))
+})
 
-  test_that("find_algorithm", {
-    expect_equal(find_algorithm(m1), list(algorithm = "mixed"))
-  })
+test_that("find_algorithm", {
+  expect_equal(find_algorithm(m1), list(algorithm = "mixed"))
+})
 
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "t-statistic")
-  })
-}
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "t-statistic")
+})
diff --git a/tests/testthat/test-gamm.R b/tests/testthat/test-gamm.R
index 7c18e2123..6acbd812e 100644
--- a/tests/testthat/test-gamm.R
+++ b/tests/testthat/test-gamm.R
@@ -1,192 +1,190 @@
-if (TRUE) {
-  unloadNamespace("gam")
-  if (skip_if_not_or_load_if_installed("mgcv")) {
-    set.seed(0)
-    void <- capture.output(dat <- gamSim(6, n = 200, scale = 0.2, dist = "poisson"))
-    m1 <-
-      gamm(
-        y ~ s(x0) + s(x1) + s(x2),
-        family = poisson,
-        data = dat,
-        random = list(fac = ~1),
-        verbosePQL = FALSE
-      )
-
-    test_that("model_info", {
-      expect_true(model_info(m1)$is_poisson)
-      expect_false(model_info(m1)$is_linear)
-    })
-
-    test_that("clean_names", {
-      expect_equal(clean_names(m1), c("y", "x0", "x1", "x2", "fac"))
-    })
-
-    test_that("find_predictors", {
-      expect_identical(find_predictors(m1), list(conditional = c("x0", "x1", "x2")))
-      expect_identical(
-        find_predictors(m1, effects = "all"),
-        list(
-          conditional = c("x0", "x1", "x2"),
-          random = "fac"
-        )
-      )
-      expect_identical(find_predictors(m1, flatten = TRUE), c("x0", "x1", "x2"))
-      expect_identical(find_predictors(m1, effects = "random"), list(random = "fac"))
-    })
-
-    test_that("find_response", {
-      expect_identical(find_response(m1), "y")
-    })
-
-    test_that("get_response", {
-      expect_equal(get_response(m1), dat$y)
-    })
-
-    test_that("link_inverse", {
-      expect_equal(link_inverse(m1)(0.2), exp(0.2), tolerance = 1e-5)
-    })
-
-    test_that("get_data", {
-      expect_equal(nrow(get_data(m1)), 200)
-      expect_equal(colnames(get_data(m1)), c("y", "x0", "x1", "x2", "fac", "g", "g.0", "g.1", "y.0", "Xr.V1", "Xr.V2", "Xr.V3", "Xr.V4", "Xr.V5", "Xr.V6", "Xr.V7", "Xr.V8", "Xr.0.V1", "Xr.0.V2", "Xr.0.V3", "Xr.0.V4", "Xr.0.V5", "Xr.0.V6", "Xr.0.V7", "Xr.0.V8", "Xr.1.V1", "Xr.1.V2", "Xr.1.V3", "Xr.1.V4", "Xr.1.V5", "Xr.1.V6", "Xr.1.V7", "Xr.1.V8", "X.(Intercept)", "X.s(x0)Fx1", "X.s(x1)Fx1", "X.s(x2)Fx1"))
-    })
-
-    test_that("find_formula", {
-      expect_length(find_formula(m1), 2)
-      expect_equal(
-        find_formula(m1),
-        list(
-          conditional = as.formula("y ~ s(x0) + s(x1) + s(x2)"),
-          random = as.formula("~1 | fac")
-        ),
-        ignore_attr = TRUE
-      )
-    })
-
-    test_that("find_terms", {
-      expect_equal(find_terms(m1), list(response = "y", conditional = c("s(x0)", "s(x1)", "s(x2)"), random = "fac"))
-      expect_equal(find_terms(m1, flatten = TRUE), c("y", "s(x0)", "s(x1)", "s(x2)", "fac"))
-    })
-
-    test_that("find_variables", {
-      expect_equal(find_variables(m1), list(response = "y", conditional = c("x0", "x1", "x2"), random = "fac"))
-      expect_equal(find_variables(m1, flatten = TRUE), c("y", "x0", "x1", "x2", "fac"))
-    })
-
-    test_that("n_obs", {
-      expect_equal(n_obs(m1), 200)
-    })
-
-    test_that("linkfun", {
-      expect_false(is.null(link_function(m1)))
-    })
-
-    test_that("find_parameters", {
-      expect_equal(
-        find_parameters(m1),
-        list(
-          conditional = "(Intercept)",
-          smooth_terms = c("s(x0)", "s(x1)", "s(x2)")
-        )
-      )
-      expect_equal(nrow(get_parameters(m1)), 4)
-      expect_equal(get_parameters(m1)$Parameter, c("(Intercept)", "s(x0)", "s(x1)", "s(x2)"))
-    })
-
-    test_that("is_multivariate", {
-      expect_false(is_multivariate(m1))
-    })
-
-
-
-    # test formula random effects -----------------------
-
-    n <- 200
-    sig <- 2
-    set.seed(0)
-    n.g <- 10
-    n <- n.g * 10 * 4
-    void <- capture.output(dat <- gamSim(1, n = n, scale = 2))
-    f <- dat$f
-    ## simulate nested random effects....
-    fa <- as.factor(rep(1:10, rep(4 * n.g, 10)))
-    ra <- rep(rnorm(10), rep(4 * n.g, 10))
-    fb <- as.factor(rep(rep(1:4, rep(n.g, 4)), 10))
-    rb <- rep(rnorm(4), rep(n.g, 4))
-    for (i in 1:9) {
-      rb <- c(rb, rep(rnorm(4), rep(n.g, 4)))
-    }
-    ## simulate auto-correlated errors within groups
-    e <- array(0, 0)
-    for (i in 1:40) {
-      eg <- rnorm(n.g, 0, sig)
-      for (j in 2:n.g) {
-        eg[j] <- eg[j - 1] * 0.6 + eg[j]
-      }
-      e <- c(e, eg)
-    }
-    dat$y <- f + ra + rb + e
-    dat$fa <- fa
-    dat$fb <- fb
-
-    ## fit model ....
-    m1 <- gamm(
-      y ~ s(x0, bs = "cr") + s(x1, bs = "cr"),
-      data = dat,
-      random = list(fa = ~1, fb = ~1),
-      correlation = corAR1()
+skip_if_not_installed("mgcv")
+skip_if_not_installed("nlme")
+
+set.seed(0)
+void <- capture.output(dat <- mgcv::gamSim(6, n = 200, scale = 0.2, dist = "poisson"))
+m1 <-
+  mgcv::gamm(
+    y ~ s(x0) + s(x1) + s(x2),
+    family = poisson,
+    data = dat,
+    random = list(fac = ~1),
+    verbosePQL = FALSE
+  )
+
+test_that("model_info", {
+  expect_true(model_info(m1)$is_poisson)
+  expect_false(model_info(m1)$is_linear)
+})
+
+test_that("clean_names", {
+  expect_equal(clean_names(m1), c("y", "x0", "x1", "x2", "fac"))
+})
+
+test_that("find_predictors", {
+  expect_identical(find_predictors(m1), list(conditional = c("x0", "x1", "x2")))
+  expect_identical(
+    find_predictors(m1, effects = "all"),
+    list(
+      conditional = c("x0", "x1", "x2"),
+      random = "fac"
     )
-
-    set.seed(0)
-
-    void <- capture.output(
-      dat <- gamSim(6, n = 200, scale = 0.2, dist = "poisson")
-    )
-
-    m2 <- gamm(
-      y ~ s(x0) + s(x1) + s(x2),
-      family = poisson,
-      data = dat,
-      verbosePQL = FALSE
+  )
+  expect_identical(find_predictors(m1, flatten = TRUE), c("x0", "x1", "x2"))
+  expect_identical(find_predictors(m1, effects = "random"), list(random = "fac"))
+})
+
+test_that("find_response", {
+  expect_identical(find_response(m1), "y")
+})
+
+test_that("get_response", {
+  expect_equal(get_response(m1), dat$y)
+})
+
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), exp(0.2), tolerance = 1e-5)
+})
+
+test_that("get_data", {
+  expect_equal(nrow(get_data(m1)), 200)
+  expect_equal(colnames(get_data(m1)), c("y", "x0", "x1", "x2", "fac", "g", "g.0", "g.1", "y.0", "Xr.V1", "Xr.V2", "Xr.V3", "Xr.V4", "Xr.V5", "Xr.V6", "Xr.V7", "Xr.V8", "Xr.0.V1", "Xr.0.V2", "Xr.0.V3", "Xr.0.V4", "Xr.0.V5", "Xr.0.V6", "Xr.0.V7", "Xr.0.V8", "Xr.1.V1", "Xr.1.V2", "Xr.1.V3", "Xr.1.V4", "Xr.1.V5", "Xr.1.V6", "Xr.1.V7", "Xr.1.V8", "X.(Intercept)", "X.s(x0)Fx1", "X.s(x1)Fx1", "X.s(x2)Fx1"))
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1), 2)
+  expect_equal(
+    find_formula(m1),
+    list(
+      conditional = as.formula("y ~ s(x0) + s(x1) + s(x2)"),
+      random = as.formula("~1 | fac")
+    ),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_terms", {
+  expect_equal(find_terms(m1), list(response = "y", conditional = c("s(x0)", "s(x1)", "s(x2)"), random = "fac"))
+  expect_equal(find_terms(m1, flatten = TRUE), c("y", "s(x0)", "s(x1)", "s(x2)", "fac"))
+})
+
+test_that("find_variables", {
+  expect_equal(find_variables(m1), list(response = "y", conditional = c("x0", "x1", "x2"), random = "fac"))
+  expect_equal(find_variables(m1, flatten = TRUE), c("y", "x0", "x1", "x2", "fac"))
+})
+
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 200)
+})
+
+test_that("linkfun", {
+  expect_false(is.null(link_function(m1)))
+})
+
+test_that("find_parameters", {
+  expect_equal(
+    find_parameters(m1),
+    list(
+      conditional = "(Intercept)",
+      smooth_terms = c("s(x0)", "s(x1)", "s(x2)")
     )
-
-    dat$g <- dat$fac
-    m3 <- gamm(
-      y ~ s(x0) + s(x1) + s(x2),
-      family = poisson,
-      data = dat,
-      random = list(g = ~1),
-      verbosePQL = FALSE
-    )
-
-    test_that("find_formula-gamm-1", {
-      expect_equal(
-        find_formula(m1),
-        list(
-          conditional = as.formula("y ~ s(x0, bs = \"cr\") + s(x1, bs = \"cr\")"),
-          random = list(as.formula("~1 | fa"), as.formula("~1 | fb"))
-        ),
-        ignore_attr = TRUE
-      )
-    })
-
-    test_that("find_formula-gamm-2", {
-      expect_equal(
-        find_formula(m2),
-        list(conditional = as.formula("y ~ s(x0) + s(x1) + s(x2)")),
-        ignore_attr = TRUE
-      )
-    })
-
-    test_that("find_formula-gamm-3", {
-      expect_equal(
-        find_formula(m3),
-        list(
-          conditional = as.formula("y ~ s(x0) + s(x1) + s(x2)"),
-          random = as.formula("~1 | g")
-        ),
-        ignore_attr = TRUE
-      )
-    })
+  )
+  expect_equal(nrow(get_parameters(m1)), 4)
+  expect_equal(get_parameters(m1)$Parameter, c("(Intercept)", "s(x0)", "s(x1)", "s(x2)"))
+})
+
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1))
+})
+
+
+
+# test formula random effects -----------------------
+
+n <- 200
+sig <- 2
+set.seed(0)
+n.g <- 10
+n <- n.g * 10 * 4
+void <- capture.output(dat <- mgcv::gamSim(1, n = n, scale = 2))
+f <- dat$f
+## simulate nested random effects....
+fa <- as.factor(rep(1:10, rep(4 * n.g, 10)))
+ra <- rep(rnorm(10), rep(4 * n.g, 10))
+fb <- as.factor(rep(rep(1:4, rep(n.g, 4)), 10))
+rb <- rep(rnorm(4), rep(n.g, 4))
+for (i in 1:9) {
+  rb <- c(rb, rep(rnorm(4), rep(n.g, 4)))
+}
+## simulate auto-correlated errors within groups
+e <- array(0, 0)
+for (i in 1:40) {
+  eg <- rnorm(n.g, 0, sig)
+  for (j in 2:n.g) {
+    eg[j] <- eg[j - 1] * 0.6 + eg[j]
   }
+  e <- c(e, eg)
 }
+dat$y <- f + ra + rb + e
+dat$fa <- fa
+dat$fb <- fb
+
+## fit model ....
+m1 <- mgcv::gamm(
+  y ~ s(x0, bs = "cr") + s(x1, bs = "cr"),
+  data = dat,
+  random = list(fa = ~1, fb = ~1),
+  correlation = nlme::corAR1()
+)
+
+set.seed(0)
+
+void <- capture.output(
+  dat <- mgcv::gamSim(6, n = 200, scale = 0.2, dist = "poisson")
+)
+
+m2 <- mgcv::gamm(
+  y ~ s(x0) + s(x1) + s(x2),
+  family = poisson,
+  data = dat,
+  verbosePQL = FALSE
+)
+
+dat$g <- dat$fac
+m3 <- mgcv::gamm(
+  y ~ s(x0) + s(x1) + s(x2),
+  family = poisson,
+  data = dat,
+  random = list(g = ~1),
+  verbosePQL = FALSE
+)
+
+test_that("find_formula-gamm-1", {
+  expect_equal(
+    find_formula(m1),
+    list(
+      conditional = as.formula("y ~ s(x0, bs = \"cr\") + s(x1, bs = \"cr\")"),
+      random = list(as.formula("~1 | fa"), as.formula("~1 | fb"))
+    ),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_formula-gamm-2", {
+  expect_equal(
+    find_formula(m2),
+    list(conditional = as.formula("y ~ s(x0) + s(x1) + s(x2)")),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_formula-gamm-3", {
+  expect_equal(
+    find_formula(m3),
+    list(
+      conditional = as.formula("y ~ s(x0) + s(x1) + s(x2)"),
+      random = as.formula("~1 | g")
+    ),
+    ignore_attr = TRUE
+  )
+})
diff --git a/tests/testthat/test-gamm4.R b/tests/testthat/test-gamm4.R
index 8b365cd18..37a43a0e4 100644
--- a/tests/testthat/test-gamm4.R
+++ b/tests/testthat/test-gamm4.R
@@ -1,126 +1,123 @@
-unloadNamespace("gam")
-
-
-
-if (skip_if_not_or_load_if_installed("gamm4")) {
-  set.seed(0)
-  void <- capture.output(dat <- gamSim(1, n = 400, scale = 2)) ## simulate 4 term additive truth
-  dat$fac <- fac <- as.factor(sample(1:20, 400, replace = TRUE))
-  dat$y <- dat$y + model.matrix(~ fac - 1) %*% rnorm(20) * 0.5
-
-  m1 <- gamm4(y ~ s(x0) + x1 + s(x2),
-    data = dat,
-    random = ~ (1 | fac)
-  )
-
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_linear)
-  })
-
-  test_that("clean_names", {
-    expect_equal(clean_names(m1), c("y", "x0", "x1", "x2", "fac"))
-  })
-
-  test_that("find_predictors", {
-    expect_identical(find_predictors(m1), list(conditional = c("x0", "x1", "x2")))
-    expect_identical(find_predictors(m1, flatten = TRUE), c("x0", "x1", "x2"))
-    expect_identical(find_predictors(m1, effects = "random"), list(random = "fac"))
-  })
-
-  test_that("find_response", {
-    expect_identical(find_response(m1), "y")
-  })
-
-  test_that("get_response", {
-    expect_equal(get_response(m1), unname(dat$y[, 1]))
-  })
-
-  test_that("link_inverse", {
-    expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
-  })
-
-  test_that("get_data", {
-    expect_equal(nrow(get_data(m1)), 400)
-    expect_equal(
-      colnames(get_data(m1)),
-      c(
-        "y",
-        "x1",
-        "x0",
-        "x2",
-        "fac",
-        "y.0",
-        "Xr",
-        "Xr.0",
-        "X.(Intercept)",
-        "X.x1",
-        "X.s(x0)Fx1",
-        "X.s(x2)Fx1"
-      )
-    )
-  })
-
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 2)
-    expect_equal(
-      find_formula(m1),
-      list(
-        conditional = as.formula("y ~ s(x0) + x1 + s(x2)"),
-        random = as.formula("~1 | fac")
-      ),
-      ignore_attr = TRUE
+skip_if_not_installed("gamm4")
+skip_if_not_installed("mgcv")
+
+set.seed(0)
+void <- capture.output(dat <- mgcv::gamSim(1, n = 400, scale = 2)) ## simulate 4 term additive truth
+dat$fac <- fac <- as.factor(sample(1:20, 400, replace = TRUE))
+dat$y <- dat$y + model.matrix(~ fac - 1) %*% rnorm(20) * 0.5
+
+m1 <- gamm4::gamm4(y ~ s(x0) + x1 + s(x2),
+  data = dat,
+  random = ~ (1 | fac)
+)
+
+test_that("model_info", {
+  expect_true(model_info(m1)$is_linear)
+})
+
+test_that("clean_names", {
+  expect_equal(clean_names(m1), c("y", "x0", "x1", "x2", "fac"))
+})
+
+test_that("find_predictors", {
+  expect_identical(find_predictors(m1), list(conditional = c("x0", "x1", "x2")))
+  expect_identical(find_predictors(m1, flatten = TRUE), c("x0", "x1", "x2"))
+  expect_identical(find_predictors(m1, effects = "random"), list(random = "fac"))
+})
+
+test_that("find_response", {
+  expect_identical(find_response(m1), "y")
+})
+
+test_that("get_response", {
+  expect_equal(get_response(m1), unname(dat$y[, 1]))
+})
+
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
+})
+
+test_that("get_data", {
+  expect_equal(nrow(get_data(m1)), 400)
+  expect_equal(
+    colnames(get_data(m1)),
+    c(
+      "y",
+      "x1",
+      "x0",
+      "x2",
+      "fac",
+      "y.0",
+      "Xr",
+      "Xr.0",
+      "X.(Intercept)",
+      "X.x1",
+      "X.s(x0)Fx1",
+      "X.s(x2)Fx1"
     )
-  })
-
-  test_that("find_terms", {
-    expect_equal(find_terms(m1), list(
-      response = "y",
-      conditional = c("s(x0)", "x1", "s(x2)"),
-      random = "fac"
-    ))
-    expect_equal(
-      find_terms(m1, flatten = TRUE),
-      c("y", "s(x0)", "x1", "s(x2)", "fac")
-    )
-  })
-
-  test_that("find_variables", {
-    expect_equal(find_variables(m1), list(
-      response = "y",
-      conditional = c("x0", "x1", "x2"),
-      random = "fac"
-    ))
-    expect_equal(find_variables(m1, flatten = TRUE), c("y", "x0", "x1", "x2", "fac"))
-  })
-
-  test_that("n_obs", {
-    expect_equal(n_obs(m1), 400)
-  })
-
-  test_that("linkfun", {
-    expect_false(is.null(link_function(m1)))
-  })
-
-  test_that("find_parameters", {
-    expect_equal(
-      find_parameters(m1),
-      list(
-        conditional = c("(Intercept)", "x1"),
-        smooth_terms = c("s(x0)", "s(x2)")
-      )
-    )
-    expect_equal(nrow(get_parameters(m1)), 4)
-    expect_equal(
-      get_parameters(m1)$Parameter,
-      c("(Intercept)", "x1", "s(x0)", "s(x2)")
+  )
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1), 2)
+  expect_equal(
+    find_formula(m1),
+    list(
+      conditional = as.formula("y ~ s(x0) + x1 + s(x2)"),
+      random = as.formula("~1 | fac")
+    ),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_terms", {
+  expect_equal(find_terms(m1), list(
+    response = "y",
+    conditional = c("s(x0)", "x1", "s(x2)"),
+    random = "fac"
+  ))
+  expect_equal(
+    find_terms(m1, flatten = TRUE),
+    c("y", "s(x0)", "x1", "s(x2)", "fac")
+  )
+})
+
+test_that("find_variables", {
+  expect_equal(find_variables(m1), list(
+    response = "y",
+    conditional = c("x0", "x1", "x2"),
+    random = "fac"
+  ))
+  expect_equal(find_variables(m1, flatten = TRUE), c("y", "x0", "x1", "x2", "fac"))
+})
+
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 400)
+})
+
+test_that("linkfun", {
+  expect_false(is.null(link_function(m1)))
+})
+
+test_that("find_parameters", {
+  expect_equal(
+    find_parameters(m1),
+    list(
+      conditional = c("(Intercept)", "x1"),
+      smooth_terms = c("s(x0)", "s(x2)")
     )
-  })
+  )
+  expect_equal(nrow(get_parameters(m1)), 4)
+  expect_equal(
+    get_parameters(m1)$Parameter,
+    c("(Intercept)", "x1", "s(x0)", "s(x2)")
+  )
+})
 
-  test_that("is_multivariate", {
-    expect_false(is_multivariate(m1))
-  })
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1))
+})
 
-  test_that("find_statistic", {
-    expect_null(find_statistic(m1))
-  })
-}
+test_that("find_statistic", {
+  expect_null(find_statistic(m1))
+})
diff --git a/tests/testthat/test-gbm.R b/tests/testthat/test-gbm.R
index d84ca80e1..32659b840 100644
--- a/tests/testthat/test-gbm.R
+++ b/tests/testthat/test-gbm.R
@@ -1,127 +1,127 @@
-if (TRUE) {
-  if (skip_if_not_or_load_if_installed("gbm")) {
-    set.seed(102) # for reproducibility
-    void <- capture.output(
-      m1 <- gbm(
-        mpg ~ gear + cyl + wt,
-        data = mtcars,
-        var.monotone = c(0, 0, 0),
-        distribution = "gaussian",
-        shrinkage = 0.1,
-        interaction.depth = 1,
-        bag.fraction = 0.5,
-        train.fraction = 0.5,
-        n.minobsinnode = 1,
-        cv.folds = 3,
-        keep.data = TRUE,
-        verbose = FALSE,
-        n.cores = 1
-      )
+skip_if_not_installed("gbm")
+
+set.seed(102) # for reproducibility
+invisible(capture.output(
+  suppressPackageStartupMessages({
+    m1 <- gbm::gbm(
+      mpg ~ gear + cyl + wt,
+      data = mtcars,
+      var.monotone = c(0, 0, 0),
+      distribution = "gaussian",
+      shrinkage = 0.1,
+      interaction.depth = 1,
+      bag.fraction = 0.5,
+      train.fraction = 0.5,
+      n.minobsinnode = 1,
+      cv.folds = 3,
+      keep.data = TRUE,
+      verbose = FALSE,
+      n.cores = 1
     )
+  })
+))
+
+test_that("model_info", {
+  expect_true(model_info(m1)$is_linear)
+  expect_false(model_info(m1)$is_binomial)
+})
+
+test_that("find_predictors", {
+  expect_identical(find_predictors(m1), list(conditional = c("gear", "cyl", "wt")))
+  expect_identical(
+    find_predictors(m1, flatten = TRUE),
+    c("gear", "cyl", "wt")
+  )
+  expect_null(find_predictors(m1, effects = "random"))
+})
+
+test_that("find_random", {
+  expect_null(find_random(m1))
+})
+
+test_that("get_random", {
+  expect_warning(get_random(m1))
+})
+
+test_that("find_response", {
+  expect_identical(find_response(m1), "mpg")
+})
+
+test_that("get_response", {
+  expect_equal(get_response(m1), mtcars$mpg)
+})
+
+test_that("get_predictors", {
+  expect_equal(colnames(get_predictors(m1)), c("gear", "cyl", "wt"))
+})
+
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
+})
+
+test_that("get_data", {
+  expect_equal(nrow(get_data(m1)), 32)
+  expect_equal(colnames(get_data(m1)), c("mpg", "gear", "cyl", "wt"))
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1), 1)
+  expect_equal(
+    find_formula(m1),
+    list(conditional = as.formula("mpg ~ gear + cyl + wt")),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_variables", {
+  expect_equal(
+    find_variables(m1),
+    list(
+      response = "mpg",
+      conditional = c("gear", "cyl", "wt")
+    )
+  )
+  expect_equal(
+    find_variables(m1, flatten = TRUE),
+    c("mpg", "gear", "cyl", "wt")
+  )
+})
+
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 32)
+})
+
+test_that("linkfun", {
+  expect_false(is.null(link_function(m1)))
+})
+
+test_that("find_parameters", {
+  expect_equal(
+    find_parameters(m1),
+    list(conditional = c("wt", "cyl", "gear"))
+  )
+  expect_equal(nrow(get_parameters(m1)), 3)
+  expect_equal(get_parameters(m1)$Parameter, c("wt", "cyl", "gear"))
+})
+
+test_that("find_terms", {
+  expect_equal(
+    find_terms(m1),
+    list(
+      response = "mpg",
+      conditional = c("gear", "cyl", "wt")
+    )
+  )
+})
+
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1))
+})
+
+test_that("find_algorithm", {
+  expect_warning(expect_null(find_algorithm(m1)))
+})
 
-    test_that("model_info", {
-      expect_true(model_info(m1)$is_linear)
-      expect_false(model_info(m1)$is_binomial)
-    })
-
-    test_that("find_predictors", {
-      expect_identical(find_predictors(m1), list(conditional = c("gear", "cyl", "wt")))
-      expect_identical(
-        find_predictors(m1, flatten = TRUE),
-        c("gear", "cyl", "wt")
-      )
-      expect_null(find_predictors(m1, effects = "random"))
-    })
-
-    test_that("find_random", {
-      expect_null(find_random(m1))
-    })
-
-    test_that("get_random", {
-      expect_warning(get_random(m1))
-    })
-
-    test_that("find_response", {
-      expect_identical(find_response(m1), "mpg")
-    })
-
-    test_that("get_response", {
-      expect_equal(get_response(m1), mtcars$mpg)
-    })
-
-    test_that("get_predictors", {
-      expect_equal(colnames(get_predictors(m1)), c("gear", "cyl", "wt"))
-    })
-
-    test_that("link_inverse", {
-      expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
-    })
-
-    test_that("get_data", {
-      expect_equal(nrow(get_data(m1)), 32)
-      expect_equal(colnames(get_data(m1)), c("mpg", "gear", "cyl", "wt"))
-    })
-
-    test_that("find_formula", {
-      expect_length(find_formula(m1), 1)
-      expect_equal(
-        find_formula(m1),
-        list(conditional = as.formula("mpg ~ gear + cyl + wt")),
-        ignore_attr = TRUE
-      )
-    })
-
-    test_that("find_variables", {
-      expect_equal(
-        find_variables(m1),
-        list(
-          response = "mpg",
-          conditional = c("gear", "cyl", "wt")
-        )
-      )
-      expect_equal(
-        find_variables(m1, flatten = TRUE),
-        c("mpg", "gear", "cyl", "wt")
-      )
-    })
-
-    test_that("n_obs", {
-      expect_equal(n_obs(m1), 32)
-    })
-
-    test_that("linkfun", {
-      expect_false(is.null(link_function(m1)))
-    })
-
-    test_that("find_parameters", {
-      expect_equal(
-        find_parameters(m1),
-        list(conditional = c("wt", "cyl", "gear"))
-      )
-      expect_equal(nrow(get_parameters(m1)), 3)
-      expect_equal(get_parameters(m1)$Parameter, c("wt", "cyl", "gear"))
-    })
-
-    test_that("find_terms", {
-      expect_equal(
-        find_terms(m1),
-        list(
-          response = "mpg",
-          conditional = c("gear", "cyl", "wt")
-        )
-      )
-    })
-
-    test_that("is_multivariate", {
-      expect_false(is_multivariate(m1))
-    })
-
-    test_that("find_algorithm", {
-      expect_warning(expect_null(find_algorithm(m1)))
-    })
-
-    test_that("find_statistic", {
-      expect_null(find_statistic(m1))
-    })
-  }
-}
+test_that("find_statistic", {
+  expect_null(find_statistic(m1))
+})
diff --git a/tests/testthat/test-gee.R b/tests/testthat/test-gee.R
index 002655729..723d7ae53 100644
--- a/tests/testthat/test-gee.R
+++ b/tests/testthat/test-gee.R
@@ -1,113 +1,113 @@
-if (skip_if_not_or_load_if_installed("gee")) {
-  data(warpbreaks)
-  void <- capture.output(suppressMessages(
-    m1 <- gee(breaks ~ tension, id = wool, data = warpbreaks)
-  ))
-
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_linear)
-  })
-
-  test_that("find_predictors", {
-    expect_identical(find_predictors(m1), list(conditional = "tension"))
-    expect_identical(find_predictors(m1, flatten = TRUE), "tension")
-    expect_identical(
-      find_predictors(m1, effects = "random"),
-      list(random = "wool")
+skip_if_not_installed("gee")
+
+data(warpbreaks)
+void <- capture.output(suppressMessages(
+  m1 <- gee::gee(breaks ~ tension, id = wool, data = warpbreaks)
+))
+
+test_that("model_info", {
+  expect_true(model_info(m1)$is_linear)
+})
+
+test_that("find_predictors", {
+  expect_identical(find_predictors(m1), list(conditional = "tension"))
+  expect_identical(find_predictors(m1, flatten = TRUE), "tension")
+  expect_identical(
+    find_predictors(m1, effects = "random"),
+    list(random = "wool")
+  )
+  expect_identical(
+    find_predictors(m1, effects = "all", flatten = TRUE),
+    c("tension", "wool")
+  )
+})
+
+test_that("find_response", {
+  expect_identical(find_response(m1), "breaks")
+})
+
+test_that("get_response", {
+  expect_equal(get_response(m1), warpbreaks$breaks)
+})
+
+test_that("find_random", {
+  expect_equal(find_random(m1), list(random = "wool"))
+})
+
+test_that("get_random", {
+  expect_equal(get_random(m1), warpbreaks[, "wool", drop = FALSE], ignore_attr = TRUE)
+})
+
+test_that("get_predictors", {
+  expect_equal(get_predictors(m1), warpbreaks[, "tension", drop = FALSE])
+})
+
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
+})
+
+test_that("get_data", {
+  expect_equal(nrow(get_data(m1)), 54)
+  expect_equal(colnames(get_data(m1)), c("breaks", "tension", "wool"))
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1), 2)
+  expect_equal(
+    find_formula(m1),
+    list(
+      conditional = as.formula("breaks ~ tension"),
+      random = as.formula("~wool")
+    ),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_terms", {
+  expect_equal(
+    find_terms(m1),
+    list(
+      response = "breaks",
+      conditional = "tension",
+      random = "wool"
     )
-    expect_identical(
-      find_predictors(m1, effects = "all", flatten = TRUE),
-      c("tension", "wool")
-    )
-  })
-
-  test_that("find_response", {
-    expect_identical(find_response(m1), "breaks")
-  })
-
-  test_that("get_response", {
-    expect_equal(get_response(m1), warpbreaks$breaks)
-  })
-
-  test_that("find_random", {
-    expect_equal(find_random(m1), list(random = "wool"))
-  })
-
-  test_that("get_random", {
-    expect_equal(get_random(m1), warpbreaks[, "wool", drop = FALSE], ignore_attr = TRUE)
-  })
-
-  test_that("get_predictors", {
-    expect_equal(get_predictors(m1), warpbreaks[, "tension", drop = FALSE])
-  })
-
-  test_that("link_inverse", {
-    expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
-  })
-
-  test_that("get_data", {
-    expect_equal(nrow(get_data(m1)), 54)
-    expect_equal(colnames(get_data(m1)), c("breaks", "tension", "wool"))
-  })
-
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 2)
-    expect_equal(
-      find_formula(m1),
-      list(
-        conditional = as.formula("breaks ~ tension"),
-        random = as.formula("~wool")
-      ),
-      ignore_attr = TRUE
-    )
-  })
-
-  test_that("find_terms", {
-    expect_equal(
-      find_terms(m1),
-      list(
-        response = "breaks",
-        conditional = "tension",
-        random = "wool"
-      )
-    )
-    expect_equal(
-      find_terms(m1, flatten = TRUE),
-      c("breaks", "tension", "wool")
-    )
-  })
-
-  test_that("n_obs", {
-    expect_equal(n_obs(m1), 54)
-  })
-
-  test_that("linkfun", {
-    expect_false(is.null(link_function(m1)))
-  })
-
-  test_that("find_parameters", {
-    expect_equal(
-      find_parameters(m1),
-      list(conditional = c(
-        "(Intercept)", "tensionM", "tensionH"
-      ))
-    )
-    expect_equal(nrow(get_parameters(m1)), 3)
-    expect_equal(
-      get_parameters(m1)$Parameter,
-      c("(Intercept)", "tensionM", "tensionH")
-    )
-  })
-
-  test_that("is_multivariate", {
-    expect_false(is_multivariate(m1))
-  })
-
-  test_that("find_algorithm", {
-    expect_equal(find_algorithm(m1), list(algorithm = "ML"))
-  })
-
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "z-statistic")
-  })
-}
+  )
+  expect_equal(
+    find_terms(m1, flatten = TRUE),
+    c("breaks", "tension", "wool")
+  )
+})
+
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 54)
+})
+
+test_that("linkfun", {
+  expect_false(is.null(link_function(m1)))
+})
+
+test_that("find_parameters", {
+  expect_equal(
+    find_parameters(m1),
+    list(conditional = c(
+      "(Intercept)", "tensionM", "tensionH"
+    ))
+  )
+  expect_equal(nrow(get_parameters(m1)), 3)
+  expect_equal(
+    get_parameters(m1)$Parameter,
+    c("(Intercept)", "tensionM", "tensionH")
+  )
+})
+
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1))
+})
+
+test_that("find_algorithm", {
+  expect_equal(find_algorithm(m1), list(algorithm = "ML"))
+})
+
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "z-statistic")
+})
diff --git a/tests/testthat/test-geeglm.R b/tests/testthat/test-geeglm.R
index aa76978f1..1671384c3 100644
--- a/tests/testthat/test-geeglm.R
+++ b/tests/testthat/test-geeglm.R
@@ -1,124 +1,124 @@
-if (skip_if_not_or_load_if_installed("geepack")) {
-  data(warpbreaks)
-  m1 <-
-    geeglm(
-      breaks ~ tension,
-      id = wool,
-      data = warpbreaks,
-      family = poisson,
-      corstr = "ar1"
+skip_if_not_installed("geepack")
+
+data(warpbreaks)
+m1 <-
+  geepack::geeglm(
+    breaks ~ tension,
+    id = wool,
+    data = warpbreaks,
+    family = poisson,
+    corstr = "ar1"
+  )
+
+test_that("model_info", {
+  expect_true(model_info(m1)$is_count)
+  expect_false(model_info(m1)$is_linear)
+})
+
+test_that("find_predictors", {
+  expect_identical(find_predictors(m1), list(conditional = "tension"))
+  expect_identical(find_predictors(m1, flatten = TRUE), "tension")
+  expect_identical(
+    find_predictors(m1, effects = "random"),
+    list(random = "wool")
+  )
+  expect_identical(
+    find_predictors(m1, effects = "all", flatten = TRUE),
+    c("tension", "wool")
+  )
+})
+
+test_that("find_response", {
+  expect_identical(find_response(m1), "breaks")
+})
+
+test_that("get_varcov", {
+  out <- get_varcov(m1)
+  expect_equal(colnames(out), names(coef(m1)))
+})
+
+test_that("get_response", {
+  expect_equal(get_response(m1), warpbreaks$breaks)
+})
+
+test_that("find_random", {
+  expect_equal(find_random(m1), list(random = "wool"))
+})
+
+test_that("get_random", {
+  expect_equal(get_random(m1), warpbreaks[, "wool", drop = FALSE], ignore_attr = TRUE)
+})
+
+test_that("get_predictors", {
+  expect_equal(get_predictors(m1), warpbreaks[, "tension", drop = FALSE])
+})
+
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), exp(0.2), tolerance = 1e-5)
+})
+
+test_that("get_data", {
+  expect_equal(nrow(get_data(m1)), 54)
+  expect_equal(colnames(get_data(m1)), c("breaks", "tension", "wool"))
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1), 2)
+  expect_equal(
+    find_formula(m1),
+    list(
+      conditional = as.formula("breaks ~ tension"),
+      random = as.formula("~wool")
+    ),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_terms", {
+  expect_equal(
+    find_terms(m1),
+    list(
+      response = "breaks",
+      conditional = "tension",
+      random = "wool"
     )
-
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_count)
-    expect_false(model_info(m1)$is_linear)
-  })
-
-  test_that("find_predictors", {
-    expect_identical(find_predictors(m1), list(conditional = "tension"))
-    expect_identical(find_predictors(m1, flatten = TRUE), "tension")
-    expect_identical(
-      find_predictors(m1, effects = "random"),
-      list(random = "wool")
-    )
-    expect_identical(
-      find_predictors(m1, effects = "all", flatten = TRUE),
-      c("tension", "wool")
-    )
-  })
-
-  test_that("find_response", {
-    expect_identical(find_response(m1), "breaks")
-  })
-
-  test_that("get_varcov", {
-    out <- get_varcov(m1)
-    expect_equal(colnames(out), names(coef(m1)))
-  })
-
-  test_that("get_response", {
-    expect_equal(get_response(m1), warpbreaks$breaks)
-  })
-
-  test_that("find_random", {
-    expect_equal(find_random(m1), list(random = "wool"))
-  })
-
-  test_that("get_random", {
-    expect_equal(get_random(m1), warpbreaks[, "wool", drop = FALSE], ignore_attr = TRUE)
-  })
-
-  test_that("get_predictors", {
-    expect_equal(get_predictors(m1), warpbreaks[, "tension", drop = FALSE])
-  })
-
-  test_that("link_inverse", {
-    expect_equal(link_inverse(m1)(0.2), exp(0.2), tolerance = 1e-5)
-  })
-
-  test_that("get_data", {
-    expect_equal(nrow(get_data(m1)), 54)
-    expect_equal(colnames(get_data(m1)), c("breaks", "tension", "wool"))
-  })
-
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 2)
-    expect_equal(
-      find_formula(m1),
-      list(
-        conditional = as.formula("breaks ~ tension"),
-        random = as.formula("~wool")
-      ),
-      ignore_attr = TRUE
-    )
-  })
-
-  test_that("find_terms", {
-    expect_equal(
-      find_terms(m1),
-      list(
-        response = "breaks",
-        conditional = "tension",
-        random = "wool"
-      )
-    )
-    expect_equal(
-      find_terms(m1, flatten = TRUE),
-      c("breaks", "tension", "wool")
-    )
-  })
-
-  test_that("n_obs", {
-    expect_equal(n_obs(m1), 54)
-  })
-
-  test_that("linkfun", {
-    expect_false(is.null(link_function(m1)))
-  })
-
-  test_that("find_parameters", {
-    expect_equal(
-      find_parameters(m1),
-      list(conditional = c(
-        "(Intercept)", "tensionM", "tensionH"
-      ))
-    )
-    expect_equal(nrow(get_parameters(m1)), 3)
-    expect_equal(
-      get_parameters(m1)$Parameter,
-      c("(Intercept)", "tensionM", "tensionH")
-    )
-  })
-
-  test_that("is_multivariate", {
-    expect_false(is_multivariate(m1))
-  })
-
-  test_that("find_algorithm", {
-    expect_equal(find_algorithm(m1), list(algorithm = "ML"))
-  })
-
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "chi-squared statistic")
-  })
-}
+  )
+  expect_equal(
+    find_terms(m1, flatten = TRUE),
+    c("breaks", "tension", "wool")
+  )
+})
+
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 54)
+})
+
+test_that("linkfun", {
+  expect_false(is.null(link_function(m1)))
+})
+
+test_that("find_parameters", {
+  expect_equal(
+    find_parameters(m1),
+    list(conditional = c(
+      "(Intercept)", "tensionM", "tensionH"
+    ))
+  )
+  expect_equal(nrow(get_parameters(m1)), 3)
+  expect_equal(
+    get_parameters(m1)$Parameter,
+    c("(Intercept)", "tensionM", "tensionH")
+  )
+})
+
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1))
+})
+
+test_that("find_algorithm", {
+  expect_equal(find_algorithm(m1), list(algorithm = "ML"))
+})
+
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "chi-squared statistic")
+})
diff --git a/tests/testthat/test-get_auxiliary.R b/tests/testthat/test-get_auxiliary.R
index 08ee2c3a0..901c617a6 100644
--- a/tests/testthat/test-get_auxiliary.R
+++ b/tests/testthat/test-get_auxiliary.R
@@ -1,25 +1,25 @@
-if (skip_if_not_or_load_if_installed("MASS")) {
-  data(quine)
-  clotting <- data.frame(
-    u = c(5, 10, 15, 20, 30, 40, 60, 80, 100),
-    lot1 = c(118, 58, 42, 35, 27, 25, 21, 19, 18),
-    lot2 = c(69, 35, 26, 21, 18, 16, 13, 12, 12)
-  )
-  set.seed(123)
-  m1 <- glm(lot1 ~ log(u), data = clotting, family = Gamma())
+skip_if_not_installed("MASS")
 
-  d <- data.frame(
-    counts = c(18, 17, 15, 20, 10, 20, 25, 13, 12),
-    outcome = gl(3, 1, 9),
-    treatment = gl(3, 3)
-  )
-  set.seed(123)
-  m2 <- glm(counts ~ outcome + treatment, data = d, family = poisson())
-  m3 <- glm.nb(Days ~ Sex / (Age + Eth * Lrn), data = quine)
+data(quine, package = "MASS")
+clotting <- data.frame(
+  u = c(5, 10, 15, 20, 30, 40, 60, 80, 100),
+  lot1 = c(118, 58, 42, 35, 27, 25, 21, 19, 18),
+  lot2 = c(69, 35, 26, 21, 18, 16, 13, 12, 12)
+)
+set.seed(123)
+m1 <- glm(lot1 ~ log(u), data = clotting, family = Gamma())
 
-  test_that("get_dispersion", {
-    expect_equal(get_auxiliary(m1, type = "dispersion"), summary(m1)$dispersion, tolerance = 1e-3, ignore_attr = TRUE)
-    expect_equal(get_auxiliary(m2, type = "dispersion"), 1)
-    expect_equal(get_auxiliary(m3, type = "dispersion"), 1)
-  })
-}
+d <- data.frame(
+  counts = c(18, 17, 15, 20, 10, 20, 25, 13, 12),
+  outcome = gl(3, 1, 9),
+  treatment = gl(3, 3)
+)
+set.seed(123)
+m2 <- glm(counts ~ outcome + treatment, data = d, family = poisson())
+m3 <- MASS::glm.nb(Days ~ Sex / (Age + Eth * Lrn), data = quine)
+
+test_that("get_dispersion", {
+  expect_equal(get_auxiliary(m1, type = "dispersion"), summary(m1)$dispersion, tolerance = 1e-3, ignore_attr = TRUE)
+  expect_equal(get_auxiliary(m2, type = "dispersion"), 1)
+  expect_equal(get_auxiliary(m3, type = "dispersion"), 1)
+})
diff --git a/tests/testthat/test-get_data.R b/tests/testthat/test-get_data.R
index d26221514..efe9ec967 100644
--- a/tests/testthat/test-get_data.R
+++ b/tests/testthat/test-get_data.R
@@ -1,12 +1,12 @@
 skip_on_os("mac")
 
 test_that("lme", {
-  skip_if_not_or_load_if_installed("nlme")
+  skip_if_not_installed("nlme")
   data("Orthodont", package = "nlme")
-  m <- lme( # a model of variance only
+  m <- nlme::lme( # a model of variance only
     distance ~ 1,
     data = Orthodont, # grand mean
-    weights = varConstPower(form = ~ age | Sex)
+    weights = nlme::varConstPower(form = ~ age | Sex)
   )
   expect_identical(dim(get_data(m, source = "mf")), c(108L, 3L))
   expect_identical(colnames(get_data(m, source = "mf")), c("distance", "age", "Sex"))
@@ -14,11 +14,11 @@ test_that("lme", {
 
 
 test_that("lme4", {
-  skip_if_not_or_load_if_installed("lme4")
+  skip_if_not_installed("lme4")
   data("cbpp", package = "lme4")
   set.seed(123)
   cbpp$cont <- rnorm(nrow(cbpp))
-  m <- glmer(cbind(incidence, size - incidence) ~ poly(cont, 2) + (1 | herd),
+  m <- lme4::glmer(cbind(incidence, size - incidence) ~ poly(cont, 2) + (1 | herd),
     data = cbpp, family = binomial
   )
   expect_s3_class(get_data(m), "data.frame")
@@ -53,8 +53,8 @@ test_that("lm", {
 
 
 test_that("get_data lavaan", {
-  skip_if_not_or_load_if_installed("lavaan")
-  data(PoliticalDemocracy)
+  skip_if_not_installed("lavaan")
+  data(PoliticalDemocracy, package = "lavaan")
   model <- "
     # latent variable definitions
       ind60 =~ x1 + x2 + x3
@@ -72,7 +72,7 @@ test_that("get_data lavaan", {
       y4 ~~ y8
       y6 ~~ y8
   "
-  m <- sem(model, data = PoliticalDemocracy)
+  m <- lavaan::sem(model, data = PoliticalDemocracy)
   expect_s3_class(get_data(m, verbose = FALSE), "data.frame")
   expect_equal(head(get_data(m, verbose = FALSE)), head(PoliticalDemocracy), ignore_attr = TRUE, tolerance = 1e-3)
 })
@@ -115,7 +115,6 @@ test_that("lm with transformations", {
 
 
 test_that("lm with poly and NA in response", {
-  data(iris)
   d <- iris
   d[1:25, "Sepal.Length"] <- NA
   d2 <<- d
@@ -127,10 +126,10 @@ test_that("lm with poly and NA in response", {
 test_that("mgcv", {
   ## NOTE check back every now and then and see if tests still work
   skip("works interactively")
-  skip_if_not_or_load_if_installed("mgcv")
+  skip_if_not_installed("mgcv")
   d <- iris
   d$NewFac <- rep(c(1, 2), length.out = 150)
-  model <- gam(Sepal.Length ~ s(Petal.Length, by = interaction(Species, NewFac)), data = d)
+  model <- mgcv::gam(Sepal.Length ~ s(Petal.Length, by = interaction(Species, NewFac)), data = d)
   expect_equal(
     head(insight::get_data(model)),
     head(d[c("Sepal.Length", "Petal.Length", "Species", "NewFac")]),
@@ -174,80 +173,6 @@ test_that("lm with poly and NA in response", {
 })
 
 
-
-.runStanTest <- Sys.getenv("RunAllinsightStanTests") == "yes"
-
-if (TRUE) {
-  data(iris)
-  m <- lm(Sepal.Length ~ Sepal.Width, data = iris)
-  out <- get_data(m)
-  test_that("subsets", {
-    expect_identical(colnames(out), c("Sepal.Length", "Sepal.Width"))
-    expect_identical(nrow(out), 150L)
-  })
-
-  m <- lm(Sepal.Length ~ Sepal.Width, data = iris, subset = Species == "versicolor")
-  out <- get_data(m)
-  test_that("subsets", {
-    expect_identical(colnames(out), c("Sepal.Length", "Sepal.Width", "Species"))
-    expect_identical(nrow(out), 50L)
-  })
-
-  # d <- iris
-  # m <- lm(Petal.Length ~ poly(Sepal.Length), data = d)
-  # d <<- mtcars
-  # expect_warning(expect_warning(out <- get_data(m)))
-  # expect_equal(colnames(out), c("Petal.Length", "Sepal.Length"))
-
-  test_that("log", {
-    data(iris)
-    m <- lm(log(Sepal.Length) ~ sqrt(Sepal.Width), data = iris)
-    out <- get_data(m)
-    expect_equal(out, iris[c("Sepal.Length", "Sepal.Width")], ignore_attr = TRUE)
-  })
-
-  test_that("log II", {
-    m <- lm(log(Sepal.Length) ~ scale(Sepal.Width), data = iris)
-    out <- get_data(m)
-    expect_equal(out, iris[c("Sepal.Length", "Sepal.Width")], ignore_attr = TRUE)
-  })
-
-
-  test_that("workaround bug in estimatr", {
-    skip_if_not_or_load_if_installed("ivreg")
-    skip_if_not_or_load_if_installed("estimatr")
-    data("CigaretteDemand")
-    m <- estimatr::iv_robust(
-      log(packs) ~ log(rprice) + log(rincome) | salestax + log(rincome),
-      data = CigaretteDemand
-    )
-    out <- get_data(m)
-    expect_equal(
-      head(out$packs),
-      c(101.08543, 111.04297, 71.95417, 56.85931, 82.58292, 79.47219),
-      tolerance = 1e-3
-    )
-    expect_equal(
-      colnames(out),
-      c("packs", "rprice", "rincome", "salestax"),
-      tolerance = 1e-3
-    )
-  })
-
-
-  test_that("get_data colnames", {
-    skip_if_not(.runStanTest)
-    skip_if_not(packageVersion("base") >= "4.0.0")
-    skip_if_not_or_load_if_installed("brms")
-    m <- suppressWarnings(brms::brm(mpg ~ hp + mo(cyl), data = mtcars, refresh = 0, iter = 200, chains = 1))
-    out <- get_data(m)
-    expect_type(out$cyl, "double")
-    expect_true(all(colnames(out) %in% c("mpg", "hp", "cyl")))
-    out <- get_data(m, additional_variables = TRUE)
-    expect_true("qsec" %in% colnames(out))
-  })
-}
-
 mod <- lm(mpg ~ as.logical(am) + factor(cyl) + as.factor(gear), mtcars)
 out <- get_data(mod)
 test_that("logicals", {
@@ -341,3 +266,72 @@ test_that("get_data() log transform", {
     ignore_attr = TRUE
   )
 })
+
+skip_on_cran()
+
+m <- lm(Sepal.Length ~ Sepal.Width, data = iris)
+out <- get_data(m)
+test_that("subsets", {
+  expect_identical(colnames(out), c("Sepal.Length", "Sepal.Width"))
+  expect_identical(nrow(out), 150L)
+})
+
+m <- lm(Sepal.Length ~ Sepal.Width, data = iris, subset = Species == "versicolor")
+out <- get_data(m)
+test_that("subsets", {
+  expect_identical(colnames(out), c("Sepal.Length", "Sepal.Width", "Species"))
+  expect_identical(nrow(out), 50L)
+})
+
+# d <- iris
+# m <- lm(Petal.Length ~ poly(Sepal.Length), data = d)
+# d <<- mtcars
+# expect_warning(expect_warning(out <- get_data(m)))
+# expect_equal(colnames(out), c("Petal.Length", "Sepal.Length"))
+
+test_that("log", {
+  m <- lm(log(Sepal.Length) ~ sqrt(Sepal.Width), data = iris)
+  out <- get_data(m)
+  expect_equal(out, iris[c("Sepal.Length", "Sepal.Width")], ignore_attr = TRUE)
+})
+
+test_that("log II", {
+  m <- lm(log(Sepal.Length) ~ scale(Sepal.Width), data = iris)
+  out <- get_data(m)
+  expect_equal(out, iris[c("Sepal.Length", "Sepal.Width")], ignore_attr = TRUE)
+})
+
+
+test_that("workaround bug in estimatr", {
+  skip_if_not_installed("ivreg")
+  skip_if_not_installed("estimatr")
+  data("CigaretteDemand", package = "ivreg")
+  m <- estimatr::iv_robust(
+    log(packs) ~ log(rprice) + log(rincome) | salestax + log(rincome),
+    data = CigaretteDemand
+  )
+  out <- get_data(m)
+  expect_equal(
+    head(out$packs),
+    c(101.08543, 111.04297, 71.95417, 56.85931, 82.58292, 79.47219),
+    tolerance = 1e-3
+  )
+  expect_equal(
+    colnames(out),
+    c("packs", "rprice", "rincome", "salestax"),
+    tolerance = 1e-3
+  )
+})
+
+
+test_that("get_data colnames", {
+  skip_on_os("windows")
+  skip_if_not(getRversion() >= "4.0.0")
+  skip_if_not_installed("brms")
+  m <- suppressMessages(suppressWarnings(brms::brm(mpg ~ hp + mo(cyl), data = mtcars, refresh = 0, iter = 200, chains = 1)))
+  out <- get_data(m)
+  expect_type(out$cyl, "double")
+  expect_true(all(colnames(out) %in% c("mpg", "hp", "cyl")))
+  out <- get_data(m, additional_variables = TRUE)
+  expect_true("qsec" %in% colnames(out))
+})
diff --git a/tests/testthat/test-get_datagrid.R b/tests/testthat/test-get_datagrid.R
index 8f07120f4..941bd6e3f 100644
--- a/tests/testthat/test-get_datagrid.R
+++ b/tests/testthat/test-get_datagrid.R
@@ -1,211 +1,219 @@
-if (getRversion() >= "4.0.0") {
-  m1 <- lm(hp ~ ordered(cyl), data = mtcars)
-  m2 <- lm(hp ~ as.ordered(cyl), data = mtcars)
-  m3 <- lm(hp ~ as.factor(cyl), data = mtcars)
-  m4 <- lm(hp ~ factor(cyl), data = mtcars)
-
-  test_that("get_datagrid - data from models", {
-    expect_equal(get_datagrid(m1)$cyl, c(4, 6, 8))
-    expect_equal(get_datagrid(m2)$cyl, c(4, 6, 8))
-    expect_equal(get_datagrid(m3)$cyl, c(4, 6, 8))
-    expect_equal(get_datagrid(m4)$cyl, c(4, 6, 8))
-  })
-
-  # get_datagrid() preserves all factor levels #695
-  test_that("get_datagrid - preserve factor levels #695", {
-    dat <<- transform(mtcars, cyl = factor(cyl))
-    mod <- lm(mpg ~ cyl + am + hp, data = dat)
-    grid <- get_datagrid(mod, at = "hp")
-    expect_identical(levels(grid$cyl), c("4", "6", "8"))
-  })
-
-  m <- lm(Sepal.Width ~ Petal.Length + Petal.Width + Species, data = iris)
-  # adjusted for works
-  test_that("get_datagrid - adjusted for works", {
-    dg <- insight::get_datagrid(m, "Species")
-    expect_identical(attributes(dg)$adjusted_for, c("Petal.Length", "Petal.Width"))
-  })
-
-  # bracket tokens
-  test_that("get_datagrid - terciles, quartiles, mean-sd", {
-    dg <- insight::get_datagrid(m, "Petal.Width = [quartiles]")
-    expect_equal(dg$Petal.Width, unname(quantile(iris$Petal.Width)), tolerance = 1e-4)
-    expect_identical(attributes(dg)$adjusted_for, c("Petal.Length", "Species"))
-
-    dg <- insight::get_datagrid(m, "Petal.Width = [meansd]")
-    .center <- mean(iris$Petal.Width)
-    .spread <- sd(iris$Petal.Width)
-    expect_equal(dg$Petal.Width, .center + c(-1, 0, 1) * .spread, tolerance = 1e-4)
-    expect_identical(attributes(dg)$adjusted_for, c("Petal.Length", "Species"))
-
-    dg <- insight::get_datagrid(m, "Petal.Width = [terciles]")
-    expect_equal(dg$Petal.Width, unname(quantile(iris$Petal.Width, probs = (1:2) / 3)), tolerance = 1e-4)
-    expect_identical(attributes(dg)$adjusted_for, c("Petal.Length", "Species"))
-  })
-
-  # bracket tokens
-  test_that("get_datagrid - range = grid", {
-    dg <- insight::get_datagrid(m, "Petal.Width", range = "grid")
-    expect_equal(
-      dg$Petal.Width,
-      c(
-        `-4 SD` = -1.8496, `-3 SD` = -1.0874, `-2 SD` = -0.3251, `-1 SD` = 0.4371,
-        Mean = 1.1993, `+1 SD` = 1.9616, `+2 SD` = 2.7238, `+3 SD` = 3.486,
-        `+4 SD` = 4.2483, `+5 SD` = 5.0105
-      ),
-      tolerance = 1e-3
-    )
-    expect_identical(attributes(dg)$adjusted_for, c("Petal.Length", "Species"))
-
-    m <- lm(Sepal.Width ~ Petal.Length + Petal.Width * Species, data = iris)
-    dg <- insight::get_datagrid(m, c("Species", "Petal.Width"), range = "grid", preserve_range = FALSE)
-    expect_equal(
-      dg$Petal.Width,
-      c(
-        `-1 SD` = 0.4371, Mean = 1.1993, `+1 SD` = 1.9616, `-1 SD` = 0.4371, # nolint
-        Mean = 1.1993, `+1 SD` = 1.9616, `-1 SD` = 0.4371, Mean = 1.1993, # nolint
-        `+1 SD` = 1.9616 # nolint
-      ),
-      tolerance = 1e-3
-    )
-    expect_identical(attributes(dg)$adjusted_for, "Petal.Length")
-  })
-
-  # order of columns
-  test_that("get_datagrid - column order", {
-    m <- lm(Sepal.Width ~ Petal.Length + Petal.Width * Species, data = iris)
-    dg <- insight::get_datagrid(m, c("Petal.Width", "Species"))
-    expect_identical(colnames(dg), c("Petal.Width", "Species", "Petal.Length"))
-    dg <- insight::get_datagrid(m, c("Species", "Petal.Width"))
-    expect_identical(colnames(dg), c("Species", "Petal.Width", "Petal.Length"))
-  })
-
-
-  # list-argument
-  test_that("get_datagrid - list-argument", {
-    at <- list(Sepal.Length = c(3, 5), Species = c("versicolor", "virginica"))
-    dg1 <- get_datagrid(iris, at = at)
-    at <- c("Sepal.Length = c(3, 5)", "Species = c('versicolor', 'virginica')")
-    dg2 <- get_datagrid(iris, at = at)
-
-    expect_equal(dg1, dg2, tolerance = 1e-4)
-  })
-}
-
-
-if (skip_if_not_or_load_if_installed("bayestestR") && getRversion() >= "4.0.0") {
-  test_that("get_datagrid - data", {
-    # Factors
-    expect_length(get_datagrid(iris$Species), 3)
-    expect_length(get_datagrid(c("A", "A", "B")), 2)
-    expect_length(get_datagrid(x = iris$Species, at = "c('versicolor')"), 1)
-    expect_length(get_datagrid(iris$Species, at = "A = c('versicolor')"), 1)
-    expect_length(get_datagrid(c("A", "A", "B"), at = "dupa = 'A'"), 1)
-    expect_length(get_datagrid(iris$Species, at = "['versicolor', 'virginica']"), 2)
-    expect_length(get_datagrid(iris$Species, at = "[versicolor, virginica]"), 2)
-
-    # Numerics
-    expect_length(get_datagrid(x = iris$Sepal.Length), 10)
-    expect_length(get_datagrid(x = iris$Sepal.Length, length = 5), 5)
-    expect_length(get_datagrid(x = iris$Sepal.Length, length = NA), length(unique(iris$Sepal.Length)))
-    expect_equal(min(get_datagrid(x = iris$Sepal.Length, range = "iqr")), as.numeric(quantile(iris$Sepal.Length, 0.025)))
-    expect_equal(min(get_datagrid(x = iris$Sepal.Length, range = "hdi")), as.numeric(bayestestR::hdi(iris$Sepal.Length, ci = 0.95, verbose = FALSE))[2])
-    expect_equal(min(get_datagrid(x = iris$Sepal.Length, range = "eti")), as.numeric(bayestestR::eti(iris$Sepal.Length, ci = 0.95, verbose = FALSE))[2])
-    expect_length(get_datagrid(iris$Sepal.Length, at = "c(1, 3, 4)"), 3)
-    expect_length(get_datagrid(iris$Sepal.Length, at = "A = c(1, 3, 4)"), 3)
-    expect_length(get_datagrid(iris$Sepal.Length, at = "[1, 3, 4]"), 3)
-    expect_length(get_datagrid(iris$Sepal.Length, at = "[1, 4]"), 10)
-    expect_length(get_datagrid(iris$Sepal.Length, range = "sd", length = 10), 10)
-    expect_equal(as.numeric(get_datagrid(iris$Sepal.Length, range = "sd", length = 3)[2]), mean(iris$Sepal.Length))
-    expect_equal(as.numeric(get_datagrid(iris$Sepal.Length, range = "mad", length = 4)[2]), median(iris$Sepal.Length))
-
-    # Dataframes
-    expect_equal(nrow(get_datagrid(iris, length = 2)), 48)
-    expect_equal(nrow(get_datagrid(iris, at = "Species", length = 2, numerics = 0)), 3)
-    expect_equal(nrow(get_datagrid(iris, at = "Sepal.Length", length = 3)), 3)
-    expect_equal(dim(get_datagrid(iris, at = 1:2, length = 3)), c(9, 5))
-    expect_equal(dim(get_datagrid(iris, at = 1:2, length = c(3, 2))), c(6, 5))
-    expect_equal(dim(get_datagrid(iris, at = 1:2, length = c(NA, 2))), c(70, 5))
-    expect_equal(dim(get_datagrid(iris, at = c("Sepal.Length = c(1, 2)"), length = NA)), c(2, 5))
-    expect_error(get_datagrid(iris, at = 1:2, length = c(3, 2, 4)))
-    expect_error(get_datagrid(iris, at = 1:2, length = "yes"))
-    expect_equal(as.numeric(get_datagrid(iris, at = 1:2, range = c("range", "mad"), length = c(2, 3))[4, "Sepal.Width"]), median(iris$Sepal.Width))
-
-
-    expect_equal(nrow(get_datagrid(data.frame(
-      X = c("A", "A", "B"),
-      Y = c(1, 5, 2)
-    ), at = "Y", factors = "mode", length = 5)), 5)
-
-    expect_equal(nrow(get_datagrid(iris, at = c("Sepal.Length = 3", "Species"))), 3)
-    expect_equal(nrow(get_datagrid(iris, at = c("Sepal.Length = c(3, 1)", "Species = 'setosa'"))), 2)
-
-    x1 <- get_datagrid(iris, at = c("Species", "Sepal.Length"), length = 30, preserve_range = TRUE)
-    expect_identical(dim(x1), c(55L, 5L))
-    x2 <- get_datagrid(iris[c("Species", "Sepal.Length")], length = 30, preserve_range = TRUE)
-    expect_identical(dim(x2), c(55L, 2L))
-  })
-}
-
-
-
-if (skip_if_not_or_load_if_installed("gamm4") && getRversion() >= "4.0.0" && skip_if_not_or_load_if_installed("glmmTMB") && skip_if_not_or_load_if_installed("mgcv") && skip_if_not_or_load_if_installed("rstanarm") && skip_if_not_or_load_if_installed("TMB")) {
-  test_that("get_datagrid - models", {
-    # GLM
-    mod <- glm(Petal.Length ~ Petal.Width * Sepal.Length, data = iris)
-    expect_equal(dim(get_datagrid(mod)), c(100, 2))
-
-    mod <- glm(Petal.Length ~ Petal.Width * Species, data = iris)
-    expect_equal(dim(get_datagrid(mod)), c(10, 2))
-
-
-    # LMER4
-    mod <- lme4::lmer(Petal.Length ~ Petal.Width + (1 | Species), data = iris)
-    expect_equal(dim(get_datagrid(mod, include_random = TRUE)), c(10, 2))
-    expect_equal(unique(get_datagrid(mod, include_random = FALSE)$Species), 0)
-
-    # GLMMTMB
-    skip_on_os("mac") # error: FreeADFunObject
-    mod <- suppressWarnings(glmmTMB::glmmTMB(Petal.Length ~ Petal.Width + (1 | Species), data = iris))
-    expect_equal(dim(get_datagrid(mod, include_random = TRUE)), c(10, 2))
-    expect_equal(unique(get_datagrid(mod, include_random = FALSE)$Species), NA)
-
-    # MGCV
-    mod <- mgcv::gam(Petal.Length ~ Petal.Width + s(Sepal.Length), data = iris)
-    expect_equal(dim(get_datagrid(mod, include_random = TRUE)), c(100, 2))
-    expect_equal(dim(get_datagrid(mod, include_smooth = FALSE)), c(10, 1))
-    expect_equal(dim(get_datagrid(mod, include_smooth = "fixed")), c(10, 2))
-
-    mod <- mgcv::gamm(Petal.Length ~ Petal.Width + s(Sepal.Length), random = list(Species = ~1), data = iris)
-    expect_equal(dim(get_datagrid(mod, include_random = TRUE)), c(63, 3))
-    expect_equal(dim(get_datagrid(mod, include_random = FALSE, include_smooth = FALSE)), c(10, 1))
-
-    # GAMM4
-    mod <- gamm4::gamm4(Petal.Length ~ Petal.Width + s(Sepal.Length), random = ~ (1 | Species), data = iris)
-    expect_equal(dim(get_datagrid(mod, include_random = TRUE)), c(63, 3))
-    expect_equal(dim(get_datagrid(mod, include_random = FALSE, include_smooth = "fixed")), c(10, 2))
-    expect_equal(dim(get_datagrid(mod, include_random = FALSE, include_smooth = FALSE)), c(10, 1))
-
-    # MGCV, splines with variables, see #678
-    data(mtcars)
-    mod <- mgcv::gam(mpg ~ s(wt, k = 3), data = mtcars)
-    out1 <- insight::get_datagrid(mod)
-    k <- 3
-    mod <- mgcv::gam(mpg ~ s(wt, k = k), data = mtcars)
-    out2 <- insight::get_datagrid(mod)
-    expect_equal(out1, out2, ignore_attr = TRUE, tolerance = 1e-4)
-
-
-    # STAN_GAMM4
-    mod <- suppressWarnings(rstanarm::stan_gamm4(Petal.Length ~ Petal.Width + s(Sepal.Length), random = ~ (1 | Species), data = iris, iter = 100, chains = 2, refresh = 0))
-    expect_identical(dim(get_datagrid(mod, include_random = TRUE)), as.integer(c(63, 3)))
-    expect_identical(dim(get_datagrid(mod, include_random = FALSE, include_smooth = "fixed")), as.integer(c(10, 2)))
-    expect_identical(dim(get_datagrid(mod, include_random = FALSE, include_smooth = FALSE)), as.integer(c(10, 1)))
-  })
-
-
-  # test if factor levels as reference / non-focal terms works
+skip_if_not(getRversion() >= "4.0.0")
+
+m1 <- lm(hp ~ ordered(cyl), data = mtcars)
+m2 <- lm(hp ~ as.ordered(cyl), data = mtcars)
+m3 <- lm(hp ~ as.factor(cyl), data = mtcars)
+m4 <- lm(hp ~ factor(cyl), data = mtcars)
+
+test_that("get_datagrid - data from models", {
+  expect_equal(get_datagrid(m1)$cyl, c(4, 6, 8))
+  expect_equal(get_datagrid(m2)$cyl, c(4, 6, 8))
+  expect_equal(get_datagrid(m3)$cyl, c(4, 6, 8))
+  expect_equal(get_datagrid(m4)$cyl, c(4, 6, 8))
+})
+
+# get_datagrid() preserves all factor levels #695
+test_that("get_datagrid - preserve factor levels #695", {
+  dat <<- transform(mtcars, cyl = factor(cyl))
+  mod <- lm(mpg ~ cyl + am + hp, data = dat)
+  grid <- get_datagrid(mod, at = "hp")
+  expect_identical(levels(grid$cyl), c("4", "6", "8"))
+})
+
+m <- lm(Sepal.Width ~ Petal.Length + Petal.Width + Species, data = iris)
+# adjusted for works
+test_that("get_datagrid - adjusted for works", {
+  dg <- insight::get_datagrid(m, "Species")
+  expect_identical(attributes(dg)$adjusted_for, c("Petal.Length", "Petal.Width"))
+})
+
+# bracket tokens
+test_that("get_datagrid - terciles, quartiles, mean-sd", {
+  dg <- insight::get_datagrid(m, "Petal.Width = [quartiles]")
+  expect_equal(dg$Petal.Width, unname(quantile(iris$Petal.Width)), tolerance = 1e-4)
+  expect_identical(attributes(dg)$adjusted_for, c("Petal.Length", "Species"))
+
+  dg <- insight::get_datagrid(m, "Petal.Width = [meansd]")
+  .center <- mean(iris$Petal.Width)
+  .spread <- sd(iris$Petal.Width)
+  expect_equal(dg$Petal.Width, .center + c(-1, 0, 1) * .spread, tolerance = 1e-4)
+  expect_identical(attributes(dg)$adjusted_for, c("Petal.Length", "Species"))
+
+  dg <- insight::get_datagrid(m, "Petal.Width = [terciles]")
+  expect_equal(dg$Petal.Width, unname(quantile(iris$Petal.Width, probs = (1:2) / 3)), tolerance = 1e-4)
+  expect_identical(attributes(dg)$adjusted_for, c("Petal.Length", "Species"))
+})
+
+# bracket tokens
+test_that("get_datagrid - range = grid", {
+  dg <- insight::get_datagrid(m, "Petal.Width", range = "grid")
+  expect_equal(
+    dg$Petal.Width,
+    c(
+      `-4 SD` = -1.8496, `-3 SD` = -1.0874, `-2 SD` = -0.3251, `-1 SD` = 0.4371,
+      Mean = 1.1993, `+1 SD` = 1.9616, `+2 SD` = 2.7238, `+3 SD` = 3.486,
+      `+4 SD` = 4.2483, `+5 SD` = 5.0105
+    ),
+    tolerance = 1e-3
+  )
+  expect_identical(attributes(dg)$adjusted_for, c("Petal.Length", "Species"))
 
+  m <- lm(Sepal.Width ~ Petal.Length + Petal.Width * Species, data = iris)
+  dg <- insight::get_datagrid(m, c("Species", "Petal.Width"), range = "grid", preserve_range = FALSE)
+  expect_equal(
+    dg$Petal.Width,
+    c(
+      `-1 SD` = 0.4371, Mean = 1.1993, `+1 SD` = 1.9616, `-1 SD` = 0.4371, # nolint
+      Mean = 1.1993, `+1 SD` = 1.9616, `-1 SD` = 0.4371, Mean = 1.1993, # nolint
+      `+1 SD` = 1.9616 # nolint
+    ),
+    tolerance = 1e-3
+  )
+  expect_identical(attributes(dg)$adjusted_for, "Petal.Length")
+})
+
+# order of columns
+test_that("get_datagrid - column order", {
+  m <- lm(Sepal.Width ~ Petal.Length + Petal.Width * Species, data = iris)
+  dg <- insight::get_datagrid(m, c("Petal.Width", "Species"))
+  expect_identical(colnames(dg), c("Petal.Width", "Species", "Petal.Length"))
+  dg <- insight::get_datagrid(m, c("Species", "Petal.Width"))
+  expect_identical(colnames(dg), c("Species", "Petal.Width", "Petal.Length"))
+})
+
+
+# list-argument
+test_that("get_datagrid - list-argument", {
+  at <- list(Sepal.Length = c(3, 5), Species = c("versicolor", "virginica"))
+  dg1 <- get_datagrid(iris, at = at)
+  at <- c("Sepal.Length = c(3, 5)", "Species = c('versicolor', 'virginica')")
+  dg2 <- get_datagrid(iris, at = at)
+
+  expect_equal(dg1, dg2, tolerance = 1e-4)
+})
+
+
+test_that("get_datagrid - data", {
+  skip_if_not_installed("bayestestR")
+
+  # Factors
+  expect_length(get_datagrid(iris$Species), 3)
+  expect_length(get_datagrid(c("A", "A", "B")), 2)
+  expect_length(get_datagrid(x = iris$Species, at = "c('versicolor')"), 1)
+  expect_length(get_datagrid(iris$Species, at = "A = c('versicolor')"), 1)
+  expect_length(get_datagrid(c("A", "A", "B"), at = "dupa = 'A'"), 1)
+  expect_length(get_datagrid(iris$Species, at = "['versicolor', 'virginica']"), 2)
+  expect_length(get_datagrid(iris$Species, at = "[versicolor, virginica]"), 2)
+
+  # Numerics
+  expect_length(get_datagrid(x = iris$Sepal.Length), 10)
+  expect_length(get_datagrid(x = iris$Sepal.Length, length = 5), 5)
+  expect_length(get_datagrid(x = iris$Sepal.Length, length = NA), length(unique(iris$Sepal.Length)))
+  expect_equal(min(get_datagrid(x = iris$Sepal.Length, range = "iqr")), as.numeric(quantile(iris$Sepal.Length, 0.025)))
+  expect_equal(min(get_datagrid(x = iris$Sepal.Length, range = "hdi")), as.numeric(bayestestR::hdi(iris$Sepal.Length, ci = 0.95, verbose = FALSE))[2])
+  expect_equal(min(get_datagrid(x = iris$Sepal.Length, range = "eti")), as.numeric(bayestestR::eti(iris$Sepal.Length, ci = 0.95, verbose = FALSE))[2])
+  expect_length(get_datagrid(iris$Sepal.Length, at = "c(1, 3, 4)"), 3)
+  expect_length(get_datagrid(iris$Sepal.Length, at = "A = c(1, 3, 4)"), 3)
+  expect_length(get_datagrid(iris$Sepal.Length, at = "[1, 3, 4]"), 3)
+  expect_length(get_datagrid(iris$Sepal.Length, at = "[1, 4]"), 10)
+  expect_length(get_datagrid(iris$Sepal.Length, range = "sd", length = 10), 10)
+  expect_equal(as.numeric(get_datagrid(iris$Sepal.Length, range = "sd", length = 3)[2]), mean(iris$Sepal.Length))
+  expect_equal(as.numeric(get_datagrid(iris$Sepal.Length, range = "mad", length = 4)[2]), median(iris$Sepal.Length))
+
+  # Dataframes
+  expect_equal(nrow(get_datagrid(iris, length = 2)), 48)
+  expect_equal(nrow(get_datagrid(iris, at = "Species", length = 2, numerics = 0)), 3)
+  expect_equal(nrow(get_datagrid(iris, at = "Sepal.Length", length = 3)), 3)
+  expect_equal(dim(get_datagrid(iris, at = 1:2, length = 3)), c(9, 5))
+  expect_equal(dim(get_datagrid(iris, at = 1:2, length = c(3, 2))), c(6, 5))
+  expect_equal(dim(get_datagrid(iris, at = 1:2, length = c(NA, 2))), c(70, 5))
+  expect_equal(dim(get_datagrid(iris, at = c("Sepal.Length = c(1, 2)"), length = NA)), c(2, 5))
+  expect_error(get_datagrid(iris, at = 1:2, length = c(3, 2, 4)))
+  expect_error(get_datagrid(iris, at = 1:2, length = "yes"))
+  expect_equal(as.numeric(get_datagrid(iris, at = 1:2, range = c("range", "mad"), length = c(2, 3))[4, "Sepal.Width"]), median(iris$Sepal.Width))
+
+
+  expect_equal(nrow(get_datagrid(data.frame(
+    X = c("A", "A", "B"),
+    Y = c(1, 5, 2)
+  ), at = "Y", factors = "mode", length = 5)), 5)
+
+  expect_equal(nrow(get_datagrid(iris, at = c("Sepal.Length = 3", "Species"))), 3)
+  expect_equal(nrow(get_datagrid(iris, at = c("Sepal.Length = c(3, 1)", "Species = 'setosa'"))), 2)
+
+  x1 <- get_datagrid(iris, at = c("Species", "Sepal.Length"), length = 30, preserve_range = TRUE)
+  expect_identical(dim(x1), c(55L, 5L))
+  x2 <- get_datagrid(iris[c("Species", "Sepal.Length")], length = 30, preserve_range = TRUE)
+  expect_identical(dim(x2), c(55L, 2L))
+})
+
+
+test_that("get_datagrid - models", {
+  # see https://github.com/georgheinze/logistf/pull/54
+  skip_if(
+    "as.character.formula" %in% methods(as.character),
+    "Some package uses `formula.tools::as.character.formula()` which breaks `find_formula()`."
+  )
+
+  skip_if_not_installed("gamm4")
+  skip_if_not_installed("glmmTMB")
+  skip_if_not_installed("mgcv")
+  skip_if_not_installed("rstanarm")
+  skip_if_not_installed("TMB")
+  # GLM
+  mod <- glm(Petal.Length ~ Petal.Width * Sepal.Length, data = iris)
+  expect_equal(dim(get_datagrid(mod)), c(100, 2))
+
+  mod <- glm(Petal.Length ~ Petal.Width * Species, data = iris)
+  expect_equal(dim(get_datagrid(mod)), c(10, 2))
+
+
+  # LMER4
+  mod <- lme4::lmer(Petal.Length ~ Petal.Width + (1 | Species), data = iris)
+  expect_equal(dim(get_datagrid(mod, include_random = TRUE)), c(10, 2))
+  expect_equal(unique(get_datagrid(mod, include_random = FALSE)$Species), 0)
+
+  # GLMMTMB
+  skip_on_os("mac") # error: FreeADFunObject
+  mod <- suppressWarnings(glmmTMB::glmmTMB(Petal.Length ~ Petal.Width + (1 | Species), data = iris))
+  expect_equal(dim(get_datagrid(mod, include_random = TRUE)), c(10, 2))
+  expect_equal(unique(get_datagrid(mod, include_random = FALSE)$Species), NA)
+
+  # MGCV
+  mod <- mgcv::gam(Petal.Length ~ Petal.Width + s(Sepal.Length), data = iris)
+  expect_equal(dim(get_datagrid(mod, include_random = TRUE)), c(100, 2))
+  expect_equal(dim(get_datagrid(mod, include_smooth = FALSE)), c(10, 1))
+  expect_equal(dim(get_datagrid(mod, include_smooth = "fixed")), c(10, 2))
+
+  mod <- mgcv::gamm(Petal.Length ~ Petal.Width + s(Sepal.Length), random = list(Species = ~1), data = iris)
+  expect_equal(dim(get_datagrid(mod, include_random = TRUE)), c(63, 3))
+  expect_equal(dim(get_datagrid(mod, include_random = FALSE, include_smooth = FALSE)), c(10, 1))
+
+  # GAMM4
+  mod <- gamm4::gamm4(Petal.Length ~ Petal.Width + s(Sepal.Length), random = ~ (1 | Species), data = iris)
+  expect_equal(dim(get_datagrid(mod, include_random = TRUE)), c(63, 3))
+  expect_equal(dim(get_datagrid(mod, include_random = FALSE, include_smooth = "fixed")), c(10, 2))
+  expect_equal(dim(get_datagrid(mod, include_random = FALSE, include_smooth = FALSE)), c(10, 1))
+
+  # MGCV, splines with variables, see #678
+
+  mod <- mgcv::gam(mpg ~ s(wt, k = 3), data = mtcars)
+  out1 <- insight::get_datagrid(mod)
+  k <- 3
+  mod <- mgcv::gam(mpg ~ s(wt, k = k), data = mtcars)
+  out2 <- insight::get_datagrid(mod)
+  expect_equal(out1, out2, ignore_attr = TRUE, tolerance = 1e-4)
+
+
+  # STAN_GAMM4
+  mod <- suppressWarnings(rstanarm::stan_gamm4(Petal.Length ~ Petal.Width + s(Sepal.Length), random = ~ (1 | Species), data = iris, iter = 100, chains = 2, refresh = 0))
+  expect_identical(dim(get_datagrid(mod, include_random = TRUE)), as.integer(c(63, 3)))
+  expect_identical(dim(get_datagrid(mod, include_random = FALSE, include_smooth = "fixed")), as.integer(c(10, 2)))
+  expect_identical(dim(get_datagrid(mod, include_random = FALSE, include_smooth = FALSE)), as.integer(c(10, 1)))
+})
+
+
+test_that("factor levels as reference / non-focal terms works", {
   d <- structure(list(
     lfp = structure(c(
       2L, 2L, 2L, 2L, 2L, 2L, 2L,
@@ -282,25 +290,25 @@ if (skip_if_not_or_load_if_installed("gamm4") && getRversion() >= "4.0.0" && ski
     colnames(out),
     c("(Intercept)", "k618", "wcyes", "hcyes", "inc")
   )
-}
+})
+
 
-if (skip_if_not_or_load_if_installed("nlme") && getRversion() >= "4.0.0") {
+
+test_that("get_datagrid - multiple weight variables", {
+  skip_if_not_installed("nlme")
   data("Orthodont", package = "nlme")
-  m <- lme( # a model of variance only
+  m <- nlme::lme( # a model of variance only
     distance ~ 1,
     data = Orthodont, # grand mean
-    weights = varConstPower(form = ~ age | Sex)
+    weights = nlme::varConstPower(form = ~ age | Sex)
   )
-
-  test_that("get_datagrid - multiple weight variables", {
-    out <- get_datagrid(m, include_response = TRUE)
-    expect_equal(
-      out$distance,
-      c(
-        16.5, 18.16667, 19.83333, 21.5, 23.16667, 24.83333, 26.5, 28.16667,
-        29.83333, 31.5
-      ),
-      tolerance = 1e-3
-    )
-  })
-}
+  out <- get_datagrid(m, include_response = TRUE)
+  expect_equal(
+    out$distance,
+    c(
+      16.5, 18.16667, 19.83333, 21.5, 23.16667, 24.83333, 26.5, 28.16667,
+      29.83333, 31.5
+    ),
+    tolerance = 1e-3
+  )
+})
diff --git a/tests/testthat/test-get_deviance.R b/tests/testthat/test-get_deviance.R
index be1a37435..a720e3aa1 100644
--- a/tests/testthat/test-get_deviance.R
+++ b/tests/testthat/test-get_deviance.R
@@ -1,6 +1,4 @@
-skip_if_not_or_load_if_installed("lme4")
-skip_if_not_or_load_if_installed("rstanarm")
-data(mtcars)
+skip_if_not_installed("rstanarm")
 
 test_that("get_deviance - Bayesian lm", {
   m1 <- lm(mpg ~ disp, data = mtcars)
diff --git a/tests/testthat/test-get_loglikelihood.R b/tests/testthat/test-get_loglikelihood.R
index 91bda3a30..e51b223e7 100644
--- a/tests/testthat/test-get_loglikelihood.R
+++ b/tests/testthat/test-get_loglikelihood.R
@@ -1,173 +1,165 @@
-if (skip_if_not_or_load_if_installed("nonnest2")) {
-  data(iris)
-  data(mtcars)
-
-  test_that("get_loglikelihood - lm", {
-    x <- lm(Sepal.Length ~ Petal.Width + Species, data = iris)
-    ll <- loglikelihood(x, estimator = "ML")
-    ll2 <- stats::logLik(x)
-    expect_equal(as.numeric(ll), as.numeric(ll2))
-    expect_equal(attributes(ll)$df, attributes(ll2)$df)
-    expect_equal(sum(attributes(ll)$per_obs - nonnest2::llcont(x)), 0)
-
-    # REML
-    ll <- loglikelihood(x, estimator = "REML")
-    ll2 <- stats::logLik(x, REML = TRUE)
-    expect_equal(as.numeric(ll), as.numeric(ll2))
-
-    # With weights
-    x <- lm(Sepal.Length ~ Petal.Width + Species, data = iris, weights = Petal.Length)
-    ll <- loglikelihood(x, estimator = "ML")
-    ll2 <- stats::logLik(x)
-    expect_equal(as.numeric(ll), as.numeric(ll2))
-
-    # log-response
-    x <- lm(mpg ~ wt, data = mtcars)
-    expect_equal(as.numeric(get_loglikelihood(x)), -80.01471, tolerance = 1e-3)
-
-    x <- lm(log(mpg) ~ wt, data = mtcars)
-    expect_equal(as.numeric(get_loglikelihood(x)), 19.42433, tolerance = 1e-3)
-    expect_equal(as.numeric(get_loglikelihood(x, check_response = TRUE)), -75.21614, tolerance = 1e-3)
-
-    set.seed(123)
-    mtcars$wg <- abs(rnorm(nrow(mtcars), mean = 1))
-    x <- lm(mpg ~ wt, weights = wg, data = mtcars)
-    expect_equal(as.numeric(get_loglikelihood(x)), -82.03376, tolerance = 1e-3)
-
-    x <- lm(log(mpg) ~ wt, weights = wg, data = mtcars)
-    expect_equal(as.numeric(get_loglikelihood(x)), 18.4205, tolerance = 1e-3)
-    expect_equal(as.numeric(get_loglikelihood(x, check_response = TRUE)), -75.58669, tolerance = 1e-3)
-
-
-    # sqrt-response
-    x <- lm(sqrt(mpg) ~ wt, data = mtcars)
-    expect_equal(as.numeric(get_loglikelihood(x)), -7.395031, tolerance = 1e-3)
-    expect_equal(as.numeric(get_loglikelihood(x, check_response = TRUE)), -76.89597, tolerance = 1e-3)
-  })
-
-  test_that("get_loglikelihood - glm", {
-    x <- glm(vs ~ mpg * disp, data = mtcars, family = "binomial")
-    ll <- loglikelihood(x)
-    ll2 <- stats::logLik(x)
-    expect_equal(as.numeric(ll), as.numeric(ll2))
-    expect_equal(attributes(ll)$df, attributes(ll2)$df)
-    expect_equal(sum(attributes(ll)$per_obs - nonnest2::llcont(x)), 0)
-
-    x <- glm(cbind(cyl, gear) ~ mpg, data = mtcars, weights = disp, family = binomial)
-    ll <- loglikelihood(x)
-    ll2 <- stats::logLik(x)
-    expect_equal(as.numeric(ll), as.numeric(ll2))
-    expect_equal(attributes(ll)$df, attributes(ll2)$df)
-    # Nonnest2 seems to be giving diffenrent results,
-    # which sums doesn't add up to base R's result... so commenting off
-    # expect_equal(sum(attributes(ll)$per_obs - nonnest2::llcont(x)), 0)
-  })
-
-  test_that("get_loglikelihood - (g)lmer", {
-    if (skip_if_not_or_load_if_installed("lme4")) {
-      x <- lme4::lmer(Sepal.Length ~ Sepal.Width + (1 | Species), data = iris)
-
-      # REML
-      ll <- loglikelihood(x, estimator = "REML")
-      ll2 <- stats::logLik(x)
-      expect_equal(as.numeric(ll), as.numeric(ll2))
-      expect_equal(attributes(ll)$df, attributes(ll2)$df)
-
-      # ML
-      ll <- loglikelihood(x, estimator = "ML")
-      ll2 <- stats::logLik(x, REML = FALSE)
-      expect_equal(as.numeric(ll), as.numeric(ll2))
-
-      # default
-      ll <- loglikelihood(x)
-      ll2 <- stats::logLik(x)
-      expect_equal(as.numeric(ll), as.numeric(ll2))
-      expect_equal(attributes(ll)$df, attributes(ll2)$df)
-
-      x <- lme4::glmer(vs ~ mpg + (1 | cyl), data = mtcars, family = "binomial")
-      ll <- loglikelihood(x, estimator = "REML") # no REML for glmer
-      ll2 <- stats::logLik(x)
-      expect_equal(as.numeric(ll), as.numeric(ll2))
-      expect_equal(attributes(ll)$df, attributes(ll2)$df)
-
-      ll <- loglikelihood(x, estimator = "ML")
-      ll2 <- stats::logLik(x, REML = FALSE)
-      expect_equal(as.numeric(ll), as.numeric(ll2))
-
-      model <- download_model("lmerMod_1")
-      expect_equal(get_loglikelihood(model, estimator = "REML"), logLik(model, REML = TRUE), tolerance = 0.01, ignore_attr = TRUE)
-      expect_equal(get_loglikelihood(model, estimator = "ML"), logLik(model, REML = FALSE), tolerance = 0.01, ignore_attr = TRUE)
-
-      model <- download_model("merMod_1")
-      expect_equal(get_loglikelihood(model, estimator = "REML"), logLik(model, REML = FALSE), tolerance = 0.01, ignore_attr = TRUE)
-      expect_equal(get_loglikelihood(model, estimator = "ML"), logLik(model, REML = FALSE), tolerance = 0.01, ignore_attr = TRUE)
-    }
-  })
-
-  test_that("get_loglikelihood - stanreg", {
-    .runStanTest <- Sys.getenv("RunAllinsightStanTests") == "yes"
-    if (skip_if_not_or_load_if_installed("rstanarm") && .runStanTest) {
-      x <- rstanarm::stan_glm(Sepal.Length ~ Petal.Width, data = iris, refresh = 0)
-      ref <- lm(Sepal.Length ~ Petal.Width, data = iris)
-      ll <- loglikelihood(x)
-      ll2 <- loglikelihood(ref)
-      expect_equal(as.numeric(ll), as.numeric(ll2), tolerance = 2)
-      expect_equal(mean(abs(attributes(ll)$per_obs - attributes(ll2)$per_obs)), 0, tolerance = 0.1)
-    }
-  })
-
-  test_that("get_loglikelihood - ivreg", {
-    skip_if_not_or_load_if_installed("ivreg")
-    data("CigaretteDemand", package = "ivreg")
-    x <- ivreg::ivreg(log(packs) ~ log(rprice) + log(rincome) | salestax + log(rincome), data = CigaretteDemand)
-
-    ll <- loglikelihood(x)
-    expect_equal(as.numeric(ll), 13.26255, tolerance = 1e-3)
-  })
-
-  test_that("get_loglikelihood - plm", {
-    if (skip_if_not_or_load_if_installed("plm")) {
-      data("Produc", package = "plm")
-      x <- suppressWarnings(
-        plm::plm(log(gsp) ~ log(pcap) + log(pc) + log(emp) + unemp,
-          data = Produc, index = c("state", "year")
-        )
-      )
-
-      ll <- loglikelihood(x)
-      expect_equal(as.numeric(ll), 1534.532, tolerance = 1e-3)
-    }
-  })
-
-  if (skip_if_not_or_load_if_installed("estimatr")) {
-    test_that("get_loglikelihood - iv_robust", {
-      data(mtcars)
-      x <- estimatr::iv_robust(mpg ~ gear + cyl | carb + wt, data = mtcars)
-
-      ll <- loglikelihood(x)
-      expect_equal(as.numeric(ll), -84.60057, tolerance = 1e-3)
-    })
-  }
-
-  if (skip_if_not_or_load_if_installed("mgcv")) {
-    test_that("get_loglikelihood - mgcv", {
-      x <- mgcv::gam(Sepal.Length ~ s(Petal.Width), data = iris)
-      ll <- insight::get_loglikelihood(x)
-      ll2 <- stats::logLik(x)
-      expect_equal(as.numeric(ll), -96.26613, tolerance = 1e-3)
-      # TODO: I'm not sure why this differes :/
-      # expect_equal(as.numeric(ll), as.numeric(ll2))
-
-      x <- mgcv::gamm(Sepal.Length ~ s(Petal.Width), random = list("Species" = ~1), data = iris)
-      # Which one to get?
-    })
-  }
-  if (skip_if_not_or_load_if_installed("gamm4")) {
-    test_that("get_loglikelihood - gamm4", {
-      x <- gamm4::gamm4(Sepal.Length ~ s(Petal.Width), data = iris)
-      ll <- insight::get_loglikelihood(x)
-      # It works, but it's quite diferent from the mgcv result
-      expect_equal(as.numeric(ll), -101.1107, tolerance = 1e-3)
-    })
-  }
-}
+skip_if_not_installed("nonnest2")
+
+test_that("get_loglikelihood - lm", {
+  x <- lm(Sepal.Length ~ Petal.Width + Species, data = iris)
+  ll <- loglikelihood(x, estimator = "ML")
+  ll2 <- stats::logLik(x)
+  expect_equal(as.numeric(ll), as.numeric(ll2))
+  expect_equal(attributes(ll)$df, attributes(ll2)$df)
+  expect_equal(sum(attributes(ll)$per_obs - nonnest2::llcont(x)), 0)
+
+  # REML
+  ll <- loglikelihood(x, estimator = "REML")
+  ll2 <- stats::logLik(x, REML = TRUE)
+  expect_equal(as.numeric(ll), as.numeric(ll2))
+
+  # With weights
+  x <- lm(Sepal.Length ~ Petal.Width + Species, data = iris, weights = Petal.Length)
+  ll <- loglikelihood(x, estimator = "ML")
+  ll2 <- stats::logLik(x)
+  expect_equal(as.numeric(ll), as.numeric(ll2))
+
+  # log-response
+  x <- lm(mpg ~ wt, data = mtcars)
+  expect_equal(as.numeric(get_loglikelihood(x)), -80.01471, tolerance = 1e-3)
+
+  x <- lm(log(mpg) ~ wt, data = mtcars)
+  expect_equal(as.numeric(get_loglikelihood(x)), 19.42433, tolerance = 1e-3)
+  expect_equal(as.numeric(get_loglikelihood(x, check_response = TRUE)), -75.21614, tolerance = 1e-3)
+
+  set.seed(123)
+  mtcars$wg <- abs(rnorm(nrow(mtcars), mean = 1))
+  x <- lm(mpg ~ wt, weights = wg, data = mtcars)
+  expect_equal(as.numeric(get_loglikelihood(x)), -82.03376, tolerance = 1e-3)
+
+  x <- lm(log(mpg) ~ wt, weights = wg, data = mtcars)
+  expect_equal(as.numeric(get_loglikelihood(x)), 18.4205, tolerance = 1e-3)
+  expect_equal(as.numeric(get_loglikelihood(x, check_response = TRUE)), -75.58669, tolerance = 1e-3)
+
+
+  # sqrt-response
+  x <- lm(sqrt(mpg) ~ wt, data = mtcars)
+  expect_equal(as.numeric(get_loglikelihood(x)), -7.395031, tolerance = 1e-3)
+  expect_equal(as.numeric(get_loglikelihood(x, check_response = TRUE)), -76.89597, tolerance = 1e-3)
+})
+
+test_that("get_loglikelihood - glm", {
+  x <- glm(vs ~ mpg * disp, data = mtcars, family = "binomial")
+  ll <- loglikelihood(x)
+  ll2 <- stats::logLik(x)
+  expect_equal(as.numeric(ll), as.numeric(ll2))
+  expect_equal(attributes(ll)$df, attributes(ll2)$df)
+  expect_equal(sum(attributes(ll)$per_obs - nonnest2::llcont(x)), 0)
+
+  x <- glm(cbind(cyl, gear) ~ mpg, data = mtcars, weights = disp, family = binomial)
+  ll <- loglikelihood(x)
+  ll2 <- stats::logLik(x)
+  expect_equal(as.numeric(ll), as.numeric(ll2))
+  expect_equal(attributes(ll)$df, attributes(ll2)$df)
+  # Nonnest2 seems to be giving diffenrent results,
+  # which sums doesn't add up to base R's result... so commenting off
+  # expect_equal(sum(attributes(ll)$per_obs - nonnest2::llcont(x)), 0)
+})
+
+test_that("get_loglikelihood - (g)lmer", {
+  skip_if_offline()
+  skip_if_not_installed("lme4")
+  x <- lme4::lmer(Sepal.Length ~ Sepal.Width + (1 | Species), data = iris)
+
+  # REML
+  ll <- loglikelihood(x, estimator = "REML")
+  ll2 <- stats::logLik(x)
+  expect_equal(as.numeric(ll), as.numeric(ll2))
+  expect_equal(attributes(ll)$df, attributes(ll2)$df)
+
+  # ML
+  ll <- loglikelihood(x, estimator = "ML")
+  ll2 <- stats::logLik(x, REML = FALSE)
+  expect_equal(as.numeric(ll), as.numeric(ll2))
+
+  # default
+  ll <- loglikelihood(x)
+  ll2 <- stats::logLik(x)
+  expect_equal(as.numeric(ll), as.numeric(ll2))
+  expect_equal(attributes(ll)$df, attributes(ll2)$df)
+
+  x <- lme4::glmer(vs ~ mpg + (1 | cyl), data = mtcars, family = "binomial")
+  ll <- loglikelihood(x, estimator = "REML") # no REML for glmer
+  ll2 <- stats::logLik(x)
+  expect_equal(as.numeric(ll), as.numeric(ll2))
+  expect_equal(attributes(ll)$df, attributes(ll2)$df)
+
+  ll <- loglikelihood(x, estimator = "ML")
+  ll2 <- stats::logLik(x, REML = FALSE)
+  expect_equal(as.numeric(ll), as.numeric(ll2))
+
+  model <- download_model("lmerMod_1")
+  expect_equal(get_loglikelihood(model, estimator = "REML"), logLik(model, REML = TRUE), tolerance = 0.01, ignore_attr = TRUE)
+  expect_equal(get_loglikelihood(model, estimator = "ML"), logLik(model, REML = FALSE), tolerance = 0.01, ignore_attr = TRUE)
+
+  model <- download_model("merMod_1")
+  expect_equal(get_loglikelihood(model, estimator = "REML"), logLik(model, REML = FALSE), tolerance = 0.01, ignore_attr = TRUE)
+  expect_equal(get_loglikelihood(model, estimator = "ML"), logLik(model, REML = FALSE), tolerance = 0.01, ignore_attr = TRUE)
+})
+
+test_that("get_loglikelihood - stanreg ", {
+  skip_on_cran()
+  skip_if_not_installed("rstanarm")
+  x <- rstanarm::stan_glm(Sepal.Length ~ Petal.Width, data = iris, refresh = 0)
+  ref <- lm(Sepal.Length ~ Petal.Width, data = iris)
+  ll <- loglikelihood(x)
+  ll2 <- loglikelihood(ref)
+  expect_equal(as.numeric(ll), as.numeric(ll2), tolerance = 2)
+  expect_equal(mean(abs(attributes(ll)$per_obs - attributes(ll2)$per_obs)), 0, tolerance = 0.1)
+})
+
+test_that("get_loglikelihood - ivreg", {
+  skip_if_not_installed("ivreg")
+  data("CigaretteDemand", package = "ivreg")
+  x <- ivreg::ivreg(log(packs) ~ log(rprice) + log(rincome) | salestax + log(rincome), data = CigaretteDemand)
+
+  ll <- loglikelihood(x)
+  expect_equal(as.numeric(ll), 13.26255, tolerance = 1e-3)
+})
+
+test_that("get_loglikelihood - plm", {
+  skip_if_not_installed("plm")
+  data("Produc", package = "plm")
+  x <- suppressWarnings(
+    plm::plm(log(gsp) ~ log(pcap) + log(pc) + log(emp) + unemp,
+      data = Produc, index = c("state", "year")
+    )
+  )
+
+  ll <- loglikelihood(x)
+  expect_equal(as.numeric(ll), 1534.532, tolerance = 1e-3)
+})
+
+test_that("get_loglikelihood - iv_robust", {
+  skip_if_not_installed("estimatr")
+  x <- estimatr::iv_robust(mpg ~ gear + cyl | carb + wt, data = mtcars)
+
+  ll <- loglikelihood(x)
+  expect_equal(as.numeric(ll), -84.60057, tolerance = 1e-3)
+})
+
+test_that("get_loglikelihood - mgcv", {
+  skip_if_not_installed("mgcv")
+  x <- mgcv::gam(Sepal.Length ~ s(Petal.Width), data = iris)
+  ll <- insight::get_loglikelihood(x)
+  ll2 <- stats::logLik(x)
+  expect_equal(as.numeric(ll), -96.26613, tolerance = 1e-3)
+  # TODO: I'm not sure why this differes :/
+  # expect_equal(as.numeric(ll), as.numeric(ll2))
+
+  x <- mgcv::gamm(Sepal.Length ~ s(Petal.Width), random = list("Species" = ~1), data = iris)
+  # Which one to get?
+})
+
+test_that("get_loglikelihood - gamm4", {
+  skip_if_not_installed("gamm4")
+  x <- gamm4::gamm4(Sepal.Length ~ s(Petal.Width), data = iris)
+  ll <- insight::get_loglikelihood(x)
+  # It works, but it's quite diferent from the mgcv result
+  expect_equal(as.numeric(ll), -101.1107, tolerance = 1e-3)
+})
diff --git a/tests/testthat/test-get_modelmatrix.R b/tests/testthat/test-get_modelmatrix.R
index 5f82c6425..b3c514c4b 100644
--- a/tests/testthat/test-get_modelmatrix.R
+++ b/tests/testthat/test-get_modelmatrix.R
@@ -35,11 +35,11 @@ test_that("Issue #612: factor padding", {
 # =========================================================================
 
 test_that("get_modelmatrix - iv_robust", {
-  skip_if_not_or_load_if_installed("ivreg")
-  skip_if_not_or_load_if_installed("estimatr")
+  skip_if_not_installed("ivreg")
+  skip_if_not_installed("estimatr")
   data(Kmenta, package = "ivreg")
 
-  x <- iv_robust(Q ~ P + D | D + F + A, se_type = "stata", data = Kmenta)
+  x <- estimatr::iv_robust(Q ~ P + D | D + F + A, se_type = "stata", data = Kmenta)
 
   out1 <- get_modelmatrix(x)
   out2 <- model.matrix(terms(x), data = Kmenta)
@@ -58,7 +58,7 @@ test_that("get_modelmatrix - iv_robust", {
 
 test_that("get_modelmatrix - ivreg", {
   skip_if(getRversion() < "4.2.0")
-  skip_if_not_or_load_if_installed("ivreg")
+  skip_if_not_installed("ivreg")
   data(Kmenta, package = "ivreg")
 
   set.seed(15)
@@ -80,7 +80,7 @@ test_that("get_modelmatrix - ivreg", {
 # ====================================================================
 
 test_that("get_modelmatrix - lm_robust", {
-  skip_if_not_or_load_if_installed("estimatr")
+  skip_if_not_installed("estimatr")
 
   set.seed(15)
   N <- 1:40
@@ -91,7 +91,7 @@ test_that("get_modelmatrix - lm_robust", {
     z = rbinom(N, 1, prob = 0.4)
   )
 
-  x <- lm_robust(y ~ x + z, data = dat)
+  x <- estimatr::lm_robust(y ~ x + z, data = dat)
 
   out1 <- get_modelmatrix(x)
   out2 <- model.matrix(x, data = dat)
diff --git a/tests/testthat/test-get_predicted-clm.R b/tests/testthat/test-get_predicted-clm.R
index 2fc480c71..15edd32bf 100644
--- a/tests/testthat/test-get_predicted-clm.R
+++ b/tests/testthat/test-get_predicted-clm.R
@@ -1,11 +1,9 @@
-pkgs <- c("testthat", "insight", "ordinal")
-invisible(sapply(pkgs, skip_if_not_or_load_if_installed))
-
 test_that("get_predicted.default - ordinal - match CI", {
+  skip_if_not_installed("ordinal")
   skip_if(getRversion() < "4.2.0")
 
   data(wine, package = "ordinal")
-  m <- clm(rating ~ temp * contact, data = wine)
+  m <- ordinal::clm(rating ~ temp * contact, data = wine)
   dg <- get_datagrid(m, "temp", verbose = FALSE)
 
   out <- get_predicted(m, ci = 0.95, data = dg, verbose = FALSE)
diff --git a/tests/testthat/test-get_predicted-iv.R b/tests/testthat/test-get_predicted-iv.R
index d44a6d27e..2dc35ee85 100644
--- a/tests/testthat/test-get_predicted-iv.R
+++ b/tests/testthat/test-get_predicted-iv.R
@@ -1,5 +1,5 @@
-pkgs <- c("insight", "estimatr", "ivreg")
-invisible(sapply(pkgs, skip_if_not_or_load_if_installed))
+skip_if_not_installed("estimatr")
+skip_if_not_installed("ivreg")
 
 
 # iv_robust --------------------------------------------------------------
@@ -7,7 +7,7 @@ invisible(sapply(pkgs, skip_if_not_or_load_if_installed))
 
 test_that("get_predicted.default - iv_robust", {
   data(Kmenta, package = "ivreg")
-  x <- iv_robust(Q ~ P + D | D + F + A, se_type = "stata", data = Kmenta)
+  x <- estimatr::iv_robust(Q ~ P + D | D + F + A, se_type = "stata", data = Kmenta)
 
   out <- get_predicted(x)
   expect_equal(
@@ -47,7 +47,7 @@ test_that("get_predicted.default - iv_robust", {
 
 test_that("get_predicted.default - ivreg", {
   data(Kmenta, package = "ivreg")
-  x <- ivreg(Q ~ P + D | D + F + A, data = Kmenta)
+  x <- ivreg::ivreg(Q ~ P + D | D + F + A, data = Kmenta)
 
   out <- get_predicted(x)
   expect_equal(
diff --git a/tests/testthat/test-get_predicted.R b/tests/testthat/test-get_predicted.R
index 5da6db70a..3a5d788d7 100644
--- a/tests/testthat/test-get_predicted.R
+++ b/tests/testthat/test-get_predicted.R
@@ -1,31 +1,11 @@
 skip_on_os(os = "mac")
-
-is_dev_version <- length(strsplit(packageDescription("insight")$Version, "\\.")[[1]]) > 3
-run_stan <- .Platform$OS.type == "unix" && is_dev_version
-
-pkgs <- c(
-  "lme4",
-  "brms",
-  "glmmTMB",
-  "pscl",
-  "mgcv",
-  "gamm4",
-  "merTools",
-  "emmeans",
-  "bayestestR",
-  "mclust",
-  "rstanarm",
-  "rstantools",
-  "psych"
-)
-suppressPackageStartupMessages(sapply(pkgs, skip_if_not_or_load_if_installed))
-
+skip_on_cran()
 
 # LM and GLM --------------------------------------------------------------
 # =========================================================================
 
 test_that("get_predicted - lm", {
-  skip_if(isFALSE(run_stan))
+  skip_on_cran()
   skip_if_not_installed("rstanarm")
 
   x <- lm(mpg ~ cyl + hp, data = mtcars)
@@ -50,7 +30,7 @@ test_that("get_predicted - lm", {
   expect_equal(max(abs(as.data.frame(ref$fit)$lwr - rez$CI_low)), 0, tolerance = 1e-10)
 
   # Prediction
-  ref <- predict(x, newdata = insight::get_data(x), se.fit = TRUE, interval = "prediction")
+  ref <- predict(x, newdata = get_data(x), se.fit = TRUE, interval = "prediction")
   rez <- as.data.frame(get_predicted(x, predict = "prediction", ci = 0.95))
   expect_equal(nrow(rez), 32)
   expect_equal(max(abs(as.data.frame(ref$fit)$fit - rez$Predicted)), 0, tolerance = 1e-10)
@@ -58,7 +38,7 @@ test_that("get_predicted - lm", {
 
   # Bootstrap
   set.seed(333)
-  ref <- predict(x, newdata = insight::get_data(x), se.fit = TRUE, interval = "confidence")
+  ref <- predict(x, newdata = get_data(x), se.fit = TRUE, interval = "confidence")
   rez <- get_predicted(x, iterations = 600, ci = 0.95)
   expect_equal(length(rez), 32)
   expect_null(nrow(rez))
@@ -80,7 +60,7 @@ test_that("get_predicted - lm", {
 
 
 test_that("get_predicted - glm", {
-  skip_if(isFALSE(run_stan))
+  skip_on_cran()
   skip_if_not_installed("rstanarm")
 
   x <- glm(vs ~ wt, data = mtcars, family = "binomial")
@@ -105,7 +85,7 @@ test_that("get_predicted - glm", {
   expect_equal(nrow(rez), 32)
   expect_equal(max(abs(ref$fit - rez$Predicted)), 0, tolerance = 1e-4)
   expect_equal(max(abs(ref$se.fit - rez$SE)), 0, tolerance = 1e-4)
-  ref <- as.data.frame(suppressWarnings(insight::link_inverse(x)(predict.lm(x, interval = "confidence"))))
+  ref <- as.data.frame(suppressWarnings(link_inverse(x)(predict.lm(x, interval = "confidence"))))
   expect_equal(max(abs(ref$lwr - rez$CI_low)), 0, tolerance = 1e-2)
 
   ref <- predict(x, se.fit = TRUE, type = "link")
@@ -134,7 +114,7 @@ test_that("get_predicted - glm", {
 
 test_that("get_predicted - lm (log)", {
   x <- lm(mpg ~ log(hp), data = mtcars)
-  rez <- insight::get_predicted(x)
+  rez <- get_predicted(x)
   expect_equal(length(rez), 32)
 
   expect_equal(max(abs(rez - stats::fitted(x))), 0)
@@ -147,12 +127,12 @@ test_that("get_predicted - lm (log)", {
 
 
 test_that("robust vcov", {
-  skip_if_not_or_load_if_installed("sandwich")
+  skip_if_not_installed("sandwich")
   mod <- lm(mpg ~ hp, data = mtcars)
-  se0 <- insight:::get_predicted_se(mod)
-  se1 <- suppressWarnings(insight:::get_predicted_se(mod, vcov_estimation = "HC"))
-  se2 <- suppressWarnings(insight:::get_predicted_se(mod, vcov_estimation = "HC", vcov_type = "HC3"))
-  se3 <- insight:::get_predicted_se(mod, vcov = "HC", vcov_args = list(type = "HC3"))
+  se0 <- get_predicted_se(mod)
+  se1 <- suppressWarnings(get_predicted_se(mod, vcov_estimation = "HC"))
+  se2 <- suppressWarnings(get_predicted_se(mod, vcov_estimation = "HC", vcov_type = "HC3"))
+  se3 <- get_predicted_se(mod, vcov = "HC", vcov_args = list(type = "HC3"))
   expect_true(all(se0 != se1))
   expect_true(all(se1 == se2))
   expect_true(all(se1 == se3))
@@ -165,23 +145,23 @@ test_that("robust vcov", {
   ignore_attr = TRUE
   )
   # various user inputs
-  se1 <- suppressWarnings(insight:::get_predicted_se(mod, vcov_estimation = "HC", vcov_type = "HC2"))
-  se2 <- insight:::get_predicted_se(mod, vcov = "HC2")
-  se3 <- insight:::get_predicted_se(mod, vcov = "vcovHC", vcov_args = list(type = "HC2"))
-  se4 <- insight:::get_predicted_se(mod, vcov = sandwich::vcovHC, vcov_args = list(type = "HC2"))
+  se1 <- suppressWarnings(get_predicted_se(mod, vcov_estimation = "HC", vcov_type = "HC2"))
+  se2 <- get_predicted_se(mod, vcov = "HC2")
+  se3 <- get_predicted_se(mod, vcov = "vcovHC", vcov_args = list(type = "HC2"))
+  se4 <- get_predicted_se(mod, vcov = sandwich::vcovHC, vcov_args = list(type = "HC2"))
   expect_true(all(se1 == se2))
   expect_true(all(se1 == se3))
   expect_true(all(se1 == se4))
-  se1 <- insight:::get_predicted_se(mod, vcov = "HC1")
-  se2 <- insight:::get_predicted_se(mod, vcov = sandwich::vcovHC, vcov_args = list(type = "HC1"))
+  se1 <- get_predicted_se(mod, vcov = "HC1")
+  se2 <- get_predicted_se(mod, vcov = sandwich::vcovHC, vcov_args = list(type = "HC1"))
   expect_true(all(se1 == se2))
 })
 
 
 
 test_that("MASS::rlm", {
-  skip_if_not_or_load_if_installed("MASS")
-  mod <- rlm(mpg ~ hp + am, data = mtcars)
+  skip_if_not_installed("MASS")
+  mod <- MASS::rlm(mpg ~ hp + am, data = mtcars)
   p <- get_predicted.default(mod)
   expect_s3_class(p, "get_predicted")
   p <- data.frame(p)
@@ -194,10 +174,16 @@ test_that("MASS::rlm", {
 # =========================================================================
 
 test_that("get_predicted - lmerMod", {
+  skip_if_not_installed("glmmTMB")
   skip_if_not_installed("lme4")
   skip_if_not_installed("merTools")
   skip_if_not_installed("rstanarm")
-  skip_if(isFALSE(run_stan))
+  skip_on_cran()
+
+  suppressPackageStartupMessages({
+    library(rstanarm)
+  })
+
   x <- lme4::lmer(mpg ~ am + (1 | cyl), data = mtcars)
 
   # Link vs. relation
@@ -226,7 +212,7 @@ test_that("get_predicted - lmerMod", {
   # expect_equal(mean(as.data.frame(rez)$CI_low - rez_emmeans$lower.PL), 0, tolerance = 0.5)
 
   # Compare with glmmTMB
-  ref <- insight::get_predicted(glmmTMB::glmmTMB(mpg ~ am + (1 | cyl), data = mtcars), predict = "expectation", ci = 0.95)
+  ref <- get_predicted(glmmTMB::glmmTMB(mpg ~ am + (1 | cyl), data = mtcars), predict = "expectation", ci = 0.95)
   expect_equal(mean(abs(rezrela - ref)), 0, tolerance = 0.1) # A bit high
   # expect_equal(mean(abs(as.data.frame(rezrela)$SE - as.data.frame(ref)$SE)), 0, tolerance = 1e-5)
   # expect_equal(mean(abs(as.data.frame(rezrela)$CI_low - as.data.frame(ref)$CI_low)), 0, tolerance = 1e-5)
@@ -238,7 +224,7 @@ test_that("get_predicted - lmerMod", {
       refresh = 0, iter = 1000, seed = 333
     )
   )
-  rez_stan <- insight::get_predicted(xref, predict = "expectation", ci = 0.95)
+  rez_stan <- get_predicted(xref, predict = "expectation", ci = 0.95)
   expect_equal(mean(abs(rezrela - rez_stan)), 0, tolerance = 0.1)
   # Different indeed
   # expect_equal(mean(as.data.frame(rezrela)$CI_low - as.data.frame(rez_stan)$CI_low), 0, tolerance = 0.5)
@@ -247,7 +233,8 @@ test_that("get_predicted - lmerMod", {
 
 test_that("get_predicted - glmer with matrix response", {
   skip_if_not_installed("lme4")
-  model <- glmer(
+  data(cbpp, package = "lme4")
+  model <- lme4::glmer(
     cbind(incidence, size - incidence) ~ period + (1 | herd),
     data = cbpp, family = binomial
   )
@@ -261,7 +248,7 @@ test_that("get_predicted - glmer with matrix response", {
 test_that("get_predicted - lmerMod (log)", {
   skip_if_not_installed("lme4")
   x <- lme4::lmer(mpg ~ am + log(hp) + (1 | cyl), data = mtcars)
-  rez <- insight::get_predicted(x)
+  rez <- get_predicted(x)
   expect_equal(length(rez), 32)
 
   expect_equal(max(abs(rez - stats::fitted(x))), 0)
@@ -269,7 +256,7 @@ test_that("get_predicted - lmerMod (log)", {
   expect_equal(nrow(as.data.frame(rez)), 32)
 
   # No random
-  rez2 <- insight::get_predicted(x, newdata = mtcars[c("am", "hp")], verbose = FALSE)
+  rez2 <- get_predicted(x, newdata = mtcars[c("am", "hp")], verbose = FALSE)
   expect_true(!all(is.na(as.data.frame(rez2))))
 })
 
@@ -290,7 +277,7 @@ test_that("get_predicted - merMod", {
 
   # Compare with glmmTMB
   xref <- glmmTMB::glmmTMB(vs ~ am + (1 | cyl), data = mtcars, family = "binomial")
-  rez_ref <- insight::get_predicted(xref, predict = "expectation", ci = 0.95)
+  rez_ref <- get_predicted(xref, predict = "expectation", ci = 0.95)
   expect_equal(max(abs(rezrela - rez_ref)), 0, tolerance = 1e-5)
   expect_equal(mean(abs(as.data.frame(rezrela)$SE - as.data.frame(rez_ref)$SE)), 0, tolerance = 0.2)
 })
@@ -324,17 +311,17 @@ test_that("get_predicted - glmmTMB", {
   expect_equal(nrow(as.data.frame(rez)), 32)
 
   # No random
-  rez <- insight::get_predicted(x, newdata = mtcars[c("am")], verbose = FALSE, ci = 0.95)
+  rez <- get_predicted(x, newdata = mtcars[c("am")], verbose = FALSE, ci = 0.95)
   expect_true(!all(is.na(as.data.frame(rez))))
   x <- glmmTMB::glmmTMB(Petal.Length ~ Petal.Width + (1 | Species), data = iris)
-  rez <- insight::get_predicted(x, data = data.frame(Petal.Width = c(0, 1, 2)), verbose = FALSE)
+  rez <- get_predicted(x, data = data.frame(Petal.Width = c(0, 1, 2)), verbose = FALSE)
   expect_equal(length(rez), 3)
 
   # vs. Bayesian
   # x <- glmmTMB::glmmTMB(mpg ~ am + (1 | cyl), data = mtcars)
-  # rez <- summary(insight::get_predicted(x))
+  # rez <- summary(get_predicted(x))
   # xref <- rstanarm::stan_lmer(mpg ~ am + (1 | cyl), data = mtcars, refresh = 0, iter = 1000, seed = 333)
-  # rezbayes <- summary(insight::get_predicted(xref))
+  # rezbayes <- summary(get_predicted(xref))
   # expect_equal(mean(abs(rez$Predicted - rezbayes$Predicted)), 0, tolerance = 0.1)
   # expect_equal(mean(abs(rez$CI_low - rezbayes$CI_low)), 0, tolerance = 0.2)
 })
@@ -345,14 +332,14 @@ test_that("get_predicted - glmmTMB", {
 test_that("get_predicted - mgcv::gam and gamm", {
   skip_if_not_installed("mgcv")
   x <- mgcv::gam(mpg ~ am + s(wt), data = mtcars)
-  expect_equal(length(insight::get_predicted(x, ci = 0.95)), 32)
-  rez <- insight::get_predicted(x, data = data.frame(am = c(0, 0, 1), wt = c(2, 3, 4)), ci = 0.95)
+  expect_equal(length(get_predicted(x, ci = 0.95)), 32)
+  rez <- get_predicted(x, data = data.frame(am = c(0, 0, 1), wt = c(2, 3, 4)), ci = 0.95)
   expect_equal(length(rez), 3)
 
   # No smooth
-  rez <- insight::get_predicted(x, data = data.frame(am = c(0, 0, 1)), ci = 0.95)
+  rez <- get_predicted(x, data = data.frame(am = c(0, 0, 1)), ci = 0.95)
   expect_equal(length(rez), 3)
-  rez2 <- insight::get_predicted(x, data = data.frame(am = c(0, 0, 1), wt = c(2, 3, 4)), ci = 0.95, include_smooth = FALSE)
+  rez2 <- get_predicted(x, data = data.frame(am = c(0, 0, 1), wt = c(2, 3, 4)), ci = 0.95, include_smooth = FALSE)
   expect_equal(max(abs(as.numeric(rez - rez2))), 0, tolerance = 1e-4)
   expect_equal(length(unique(attributes(rez)$data$wt)), 1)
 
@@ -363,7 +350,7 @@ test_that("get_predicted - mgcv::gam and gamm", {
 
   # Binomial
   x <- mgcv::gam(vs ~ am + s(wt), data = mtcars, family = "binomial")
-  rez <- insight::get_predicted(x, ci = 0.95)
+  rez <- get_predicted(x, ci = 0.95)
   expect_equal(length(rez), 32)
 
   expect_equal(max(abs(rez - stats::fitted(x))), 0)
@@ -372,7 +359,7 @@ test_that("get_predicted - mgcv::gam and gamm", {
 
   # GAMM
   x <- mgcv::gamm(vs ~ am + s(wt), random = list(cyl = ~1), data = mtcars, family = "binomial", verbosePQL = FALSE)
-  rez <- insight::get_predicted(x, ci = 0.95)
+  rez <- get_predicted(x, ci = 0.95)
   expect_equal(length(rez), 32)
   expect_equal(max(abs(rez - x$gam$fitted.values)), 0)
   expect_equal(max(abs(rez - stats::predict(x$gam, type = "response"))), 0)
@@ -385,9 +372,13 @@ test_that("get_predicted - mgcv::gam and gamm", {
 
 
 test_that("get_predicted - rstanarm", {
-  skip_if(isFALSE(run_stan))
+  skip_on_cran()
   skip_if_not_installed("rstanarm")
 
+  suppressPackageStartupMessages({
+    library(rstanarm)
+  })
+
   # LM
   x <- rstanarm::stan_glm(mpg ~ cyl + hp, data = mtcars, refresh = 0, seed = 333)
   rezlink <- summary(get_predicted(x, predict = "link", ci = 0.95))
@@ -433,10 +424,9 @@ test_that("get_predicted - rstanarm", {
 # =========================================================================
 
 test_that("get_predicted - FA / PCA", {
-  suppressMessages({
-    skip_if_not_installed("fungible")
-    skip_if_not_installed("psych")
-  })
+  skip_if_not_installed("fungible")
+  skip_if_not_installed("psych")
+
   # PCA
   x <- get_predicted(psych::principal(mtcars, 3))
   expect_equal(dim(x), c(32, 3))
@@ -557,11 +547,11 @@ test_that("bugfix: used to fail with matrix variables", {
 })
 
 test_that("brms: `type` in ellipsis used to produce the wrong intervals", {
-  skip_if(isFALSE(run_stan))
-  skip_if_not_or_load_if_installed("brms")
+  skip_on_cran()
+  skip_if_not_installed("brms")
   void <- capture.output(
-    suppressMessages(mod <- brm(am ~ hp + mpg,
-      family = bernoulli, data = mtcars,
+    suppressMessages(mod <- brms::brm(am ~ hp + mpg,
+      family = brms::bernoulli, data = mtcars,
       chains = 2, iter = 1000, seed = 1024, silent = 2
     ))
   )
@@ -575,13 +565,13 @@ test_that("brms: `type` in ellipsis used to produce the wrong intervals", {
   data <- mtcars
   data$cyl <- as.character(data$cyl)
   void <- capture.output(
-    suppressMessages(suppressWarnings(model <- brm(cyl ~ mpg * vs + (1 | carb),
+    suppressMessages(suppressWarnings(model <- brms::brm(cyl ~ mpg * vs + (1 | carb),
       data = data,
       iter = 1000,
       seed = 1024,
       algorithm = "meanfield",
       refresh = 0,
-      family = categorical(link = "logit", refcat = "4")
+      family = brms::categorical(link = "logit", refcat = "4")
     )))
   )
   x <- as.data.frame(get_predicted(model, ci = 0.95))
@@ -596,15 +586,15 @@ test_that("zero-inflation stuff works", {
   skip_if_not_installed("glmmTMB")
   skip_if_not_installed("pscl")
 
-  data("fish")
-  m1 <- glmmTMB(
+  data(fish)
+  m1 <- glmmTMB::glmmTMB(
     count ~ child + camper,
     ziformula = ~ child + camper,
     data = fish,
     family = poisson()
   )
 
-  m2 <- zeroinfl(
+  m2 <- pscl::zeroinfl(
     count ~ child + camper | child + camper,
     data = fish,
     dist = "poisson"
@@ -622,14 +612,14 @@ test_that("zero-inflation stuff works", {
   expect_equal(p2, p4, tolerance = 1e-1, ignore_attr = TRUE)
   expect_equal(p3, p4, tolerance = 1e-1, ignore_attr = TRUE)
 
-  m1 <- glmmTMB(
+  m1 <- glmmTMB::glmmTMB(
     count ~ child + camper,
     ziformula = ~ child + camper,
     data = fish,
-    family = truncated_poisson()
+    family = glmmTMB::truncated_poisson()
   )
 
-  m2 <- hurdle(
+  m2 <- pscl::hurdle(
     count ~ child + camper | child + camper,
     data = fish,
     dist = "poisson"
diff --git a/tests/testthat/test-get_priors.R b/tests/testthat/test-get_priors.R
index bb2a3ac34..56115b6b6 100644
--- a/tests/testthat/test-get_priors.R
+++ b/tests/testthat/test-get_priors.R
@@ -1,18 +1,14 @@
-skip_on_os(os = "mac")
+test_that("get_priors", {
+  skip_on_os(os = "mac")
+  skip_on_cran()
+  skip_if_not_installed("brms")
 
-is_dev_version <- length(strsplit(packageDescription("insight")$Version, "\\.")[[1]]) > 3
-run_stan <- .Platform$OS.type == "unix" && is_dev_version
-
-if (run_stan && skip_if_not_or_load_if_installed("brms")) {
-  data(mtcars)
   set.seed(123)
 
   model <- suppressMessages(brms::brm(mpg ~ wt, data = mtcars, seed = 1, refresh = 0))
   priors <- insight::get_priors(model)
 
-  test_that("get_priors", {
-    expect_equal(priors$Location, c(19.2, NA, 0), tolerance = 1e-3)
-    expect_equal(priors$Distribution, c("student_t", "uniform", "student_t"))
-    expect_equal(priors$Parameter, c("b_Intercept", "b_wt", "sigma"))
-  })
-}
+  expect_equal(priors$Location, c(19.2, NA, 0), tolerance = 1e-3)
+  expect_equal(priors$Distribution, c("student_t", "uniform", "student_t"))
+  expect_equal(priors$Parameter, c("b_Intercept", "b_wt", "sigma"))
+})
diff --git a/tests/testthat/test-get_residuals.R b/tests/testthat/test-get_residuals.R
index a44e06227..ead4d11b5 100644
--- a/tests/testthat/test-get_residuals.R
+++ b/tests/testthat/test-get_residuals.R
@@ -1,129 +1,128 @@
-if (skip_if_not_or_load_if_installed("lme4")) {
-  data(mtcars)
-  data(sleepstudy)
-  data(cbpp)
-  set.seed(123)
-  mtcars$w <- abs(rnorm(nrow(mtcars), mean = 1, 0.3))
-  sleepstudy$w <- abs(rnorm(nrow(sleepstudy), mean = 1, 0.3))
-  cbpp$w <- abs(rnorm(nrow(cbpp), mean = 1, 0.3))
+skip_if_not_installed("lme4")
 
-  test_that("get_residuals - lm", {
-    m <- lm(am ~ cyl, weights = w, data = mtcars)
-    expect_equal(
-      as.vector(get_residuals(m, weighted = FALSE)),
-      as.vector(residuals(m))
-    )
-    expect_equal(
-      as.vector(get_residuals(m, weighted = FALSE, type = "deviance")),
-      as.vector(residuals(m, type = "deviance"))
-    )
-    expect_equal(
-      get_weights(m),
-      weights(m)
-    )
-    expect_equal(
-      as.vector(get_residuals(m)),
-      as.vector(residuals(m))
-    )
-    expect_equal(
-      as.vector(get_deviance(m)),
-      as.vector(deviance(m))
-    )
-    expect_equal(
-      get_residuals(m, weighted = TRUE),
-      as.vector(weighted.residuals(m))
-    )
-  })
+data(sleepstudy, package = "lme4")
+data(cbpp, package = "lme4")
+set.seed(123)
+mtcars$w <- abs(rnorm(nrow(mtcars), mean = 1, 0.3))
+sleepstudy$w <- abs(rnorm(nrow(sleepstudy), mean = 1, 0.3))
+cbpp$w <- abs(rnorm(nrow(cbpp), mean = 1, 0.3))
 
-  test_that("get_residuals - glm", {
-    m <- suppressWarnings(glm(am ~ cyl, weights = w, data = mtcars, family = binomial))
-    expect_equal(
-      as.vector(get_residuals(m, weighted = FALSE, type = "response")),
-      as.vector(residuals(m, type = "response"))
-    )
-    expect_equal(
-      as.vector(get_residuals(m, weighted = FALSE)),
-      as.vector(residuals(m))
-    )
-    expect_equal(
-      get_weights(m),
-      weights(m)
-    )
-    expect_equal(
-      as.vector(get_residuals(m)),
-      as.vector(residuals(m))
-    )
-    expect_equal(
-      as.vector(get_deviance(m)),
-      as.vector(deviance(m))
-    )
-    expect_equal(
-      get_residuals(m, weighted = TRUE),
-      as.vector(weighted.residuals(m))
-    )
-  })
+test_that("get_residuals - lm", {
+  m <- lm(am ~ cyl, weights = w, data = mtcars)
+  expect_equal(
+    as.vector(get_residuals(m, weighted = FALSE)),
+    as.vector(residuals(m))
+  )
+  expect_equal(
+    as.vector(get_residuals(m, weighted = FALSE, type = "deviance")),
+    as.vector(residuals(m, type = "deviance"))
+  )
+  expect_equal(
+    get_weights(m),
+    weights(m)
+  )
+  expect_equal(
+    as.vector(get_residuals(m)),
+    as.vector(residuals(m))
+  )
+  expect_equal(
+    as.vector(get_deviance(m)),
+    as.vector(deviance(m))
+  )
+  expect_equal(
+    get_residuals(m, weighted = TRUE),
+    as.vector(weighted.residuals(m))
+  )
+})
 
-  test_that("get_residuals - lmer", {
-    m <- lmer(Reaction ~ Days + (Days | Subject), weights = w, data = sleepstudy)
-    expect_equal(
-      as.vector(get_residuals(m, weighted = FALSE)),
-      as.vector(residuals(m))
-    )
-    expect_equal(
-      as.vector(get_residuals(m, weighted = FALSE, type = "deviance")),
-      as.vector(residuals(m, type = "deviance"))
-    )
-    expect_equal(
-      get_weights(m),
-      weights(m)
-    )
-    expect_equal(
-      as.vector(get_residuals(m)),
-      as.vector(residuals(m))
-    )
-    expect_equal(
-      as.vector(get_deviance(m)),
-      as.vector(deviance(m, REML = FALSE))
-    )
-    expect_equal(
-      get_residuals(m, weighted = TRUE),
-      as.vector(weighted.residuals(m))
-    )
-  })
+test_that("get_residuals - glm", {
+  m <- suppressWarnings(glm(am ~ cyl, weights = w, data = mtcars, family = binomial))
+  expect_equal(
+    as.vector(get_residuals(m, weighted = FALSE, type = "response")),
+    as.vector(residuals(m, type = "response"))
+  )
+  expect_equal(
+    as.vector(get_residuals(m, weighted = FALSE)),
+    as.vector(residuals(m))
+  )
+  expect_equal(
+    get_weights(m),
+    weights(m)
+  )
+  expect_equal(
+    as.vector(get_residuals(m)),
+    as.vector(residuals(m))
+  )
+  expect_equal(
+    as.vector(get_deviance(m)),
+    as.vector(deviance(m))
+  )
+  expect_equal(
+    get_residuals(m, weighted = TRUE),
+    as.vector(weighted.residuals(m))
+  )
+})
 
-  test_that("get_residuals - glmer", {
-    m <- glmer(
-      cbind(incidence, size - incidence) ~ period + (1 | herd),
-      weights = w,
-      data = cbpp,
-      family = binomial,
-      nAGQ = 0
-    )
+test_that("get_residuals - lmer", {
+  m <- lme4::lmer(Reaction ~ Days + (Days | Subject), weights = w, data = sleepstudy)
+  expect_equal(
+    as.vector(get_residuals(m, weighted = FALSE)),
+    as.vector(residuals(m))
+  )
+  expect_equal(
+    as.vector(get_residuals(m, weighted = FALSE, type = "deviance")),
+    as.vector(residuals(m, type = "deviance"))
+  )
+  expect_equal(
+    get_weights(m),
+    weights(m)
+  )
+  expect_equal(
+    as.vector(get_residuals(m)),
+    as.vector(residuals(m))
+  )
+  expect_equal(
+    as.vector(get_deviance(m)),
+    as.vector(deviance(m, REML = FALSE))
+  )
+  expect_equal(
+    get_residuals(m, weighted = TRUE),
+    as.vector(weighted.residuals(m))
+  )
+})
 
-    expect_equal(
-      as.vector(get_residuals(m, weighted = FALSE, type = "response")),
-      as.vector(residuals(m, type = "response"))
-    )
-    expect_equal(
-      as.vector(get_residuals(m, weighted = FALSE)),
-      as.vector(residuals(m))
-    )
-    expect_equal(
-      get_weights(m),
-      weights(m)
-    )
-    expect_equal(
-      as.vector(get_residuals(m)),
-      as.vector(residuals(m))
-    )
-    expect_equal(
-      as.vector(get_deviance(m)),
-      177.4023,
-      tolerance = 1e-3
-    )
-    expect_equal(
-      get_residuals(m, weighted = TRUE),
-      as.vector(weighted.residuals(m))
-    )
-  })
-}
+test_that("get_residuals - glmer", {
+  m <- lme4::glmer(
+    cbind(incidence, size - incidence) ~ period + (1 | herd),
+    weights = w,
+    data = cbpp,
+    family = binomial,
+    nAGQ = 0
+  )
+
+  expect_equal(
+    as.vector(get_residuals(m, weighted = FALSE, type = "response")),
+    as.vector(residuals(m, type = "response"))
+  )
+  expect_equal(
+    as.vector(get_residuals(m, weighted = FALSE)),
+    as.vector(residuals(m))
+  )
+  expect_equal(
+    get_weights(m),
+    weights(m)
+  )
+  expect_equal(
+    as.vector(get_residuals(m)),
+    as.vector(residuals(m))
+  )
+  expect_equal(
+    as.vector(get_deviance(m)),
+    177.4023,
+    tolerance = 1e-3
+  )
+  expect_equal(
+    get_residuals(m, weighted = TRUE),
+    as.vector(weighted.residuals(m))
+  )
+})
diff --git a/tests/testthat/test-get_varcov.R b/tests/testthat/test-get_varcov.R
index d136e2f64..c5d8f631d 100644
--- a/tests/testthat/test-get_varcov.R
+++ b/tests/testthat/test-get_varcov.R
@@ -1,9 +1,9 @@
-skip_if_not_or_load_if_installed("sandwich")
-suppressPackageStartupMessages(skip_if_not_or_load_if_installed("clubSandwich"))
+skip_if_not_installed("sandwich")
+skip_if_not_installed("clubSandwich")
 
 test_that("informative error in get_varcov.default", {
-  skip_if_not_or_load_if_installed("lme4")
-  mod <- lmer(mpg ~ hp + (1 | cyl), data = mtcars)
+  skip_if_not_installed("lme4")
+  mod <- lme4::lmer(mpg ~ hp + (1 | cyl), data = mtcars)
   # sandwich: not supported
   expect_error(get_varcov(mod, vcov = "HC2"))
   # clubSandwich: supported
@@ -18,21 +18,21 @@ test_that("lm: sandwich", {
   mod <- lm(mpg ~ hp * wt, data = mtcars)
   expect_equal(
     get_varcov(mod, vcov = "HC1"),
-    vcovHC(mod, type = "HC1"),
+    sandwich::vcovHC(mod, type = "HC1"),
     ignore_attr = TRUE
   )
   expect_equal(
     get_varcov(mod, vcov = "HC4"),
-    vcovHC(mod, type = "HC4"),
+    sandwich::vcovHC(mod, type = "HC4"),
     ignore_attr = TRUE
   )
   expect_equal(
     get_varcov(mod, vcov = "HC", vcov_args = list(type = "HC4")),
-    vcovHC(mod, type = "HC4"),
+    sandwich::vcovHC(mod, type = "HC4"),
     ignore_attr = TRUE
   )
-  expect_equal(get_varcov(mod, vcov = vcovOPG),
-    vcovOPG(mod),
+  expect_equal(get_varcov(mod, vcov = sandwich::vcovOPG),
+    sandwich::vcovOPG(mod),
     tolerance = 1e-5
   )
 })
@@ -60,9 +60,9 @@ test_that("mlm: sandwich", {
 
 
 test_that("warning: not yet supported", {
-  skip_if_not_or_load_if_installed("pscl")
+  skip_if_not_installed("pscl")
   data("bioChemists", package = "pscl")
-  mod <- hurdle(art ~ phd + fem | ment, data = bioChemists, dist = "negbin")
+  mod <- pscl::hurdle(art ~ phd + fem | ment, data = bioChemists, dist = "negbin")
   expect_error(get_varcov(mod, vcov = "HC3"), regexp = "supported by one or")
 })
 
diff --git a/tests/testthat/test-get_variance.R b/tests/testthat/test-get_variance.R
index 0a5abc46a..c9e745943 100644
--- a/tests/testthat/test-get_variance.R
+++ b/tests/testthat/test-get_variance.R
@@ -1,281 +1,286 @@
-if (skip_if_not_or_load_if_installed("lme4")) {
-  data("sleepstudy")
-  data("Penicillin")
-  set.seed(12345)
-  sleepstudy$grp <- sample(1:5, size = 180, replace = TRUE)
-  sleepstudy$subgrp <- NA
-  for (i in 1:5) {
-    filter_group <- sleepstudy$grp == i
-    sleepstudy$subgrp[filter_group] <-
-      sample(1:30, size = sum(filter_group), replace = TRUE)
-  }
-
-  study_data <<- sleepstudy
-
-  fm1 <- lmer(Reaction ~ Days + (Days | Subject), study_data)
-  fm2 <- lmer(Reaction ~ Days + (Days || Subject), study_data)
-  fm3 <- lmer(
+skip_if_not_installed("lme4")
+
+data(sleepstudy, package = "lme4")
+data("Penicillin", package = "lme4")
+set.seed(12345)
+sleepstudy$grp <- sample(1:5, size = 180, replace = TRUE)
+sleepstudy$subgrp <- NA
+for (i in 1:5) {
+  filter_group <- sleepstudy$grp == i
+  sleepstudy$subgrp[filter_group] <-
+    sample(1:30, size = sum(filter_group), replace = TRUE)
+}
+
+study_data <<- sleepstudy
+
+suppressMessages({
+  fm1 <- lme4::lmer(Reaction ~ Days + (Days | Subject), study_data)
+  fm2 <- lme4::lmer(Reaction ~ Days + (Days || Subject), study_data)
+  fm3 <- lme4::lmer(
     Reaction ~ Days + (1 + Days || grp / subgrp) + (1 + Days | Subject),
     data = study_data
   )
-  fm4 <- lmer(Reaction ~ Days + (1 | Subject), study_data)
-  fm5 <- lmer(
+  fm4 <- lme4::lmer(Reaction ~ Days + (1 | Subject), study_data)
+  fm5 <- lme4::lmer(
     Reaction ~ Days + (1 | grp / subgrp) + (1 | Subject),
     data = study_data
   )
-  fm6 <- lmer(diameter ~ 0 + sample + (1 | plate), data = Penicillin)
-
-  v1 <- suppressWarnings(get_variance(fm1))
-  v2 <- suppressWarnings(get_variance(fm2))
-  v3 <- suppressWarnings(get_variance(fm3))
-  v4 <- suppressWarnings(get_variance(fm4))
-  v5 <- suppressWarnings(get_variance(fm5))
-  v6 <- suppressWarnings(get_variance(fm6))
-
-  test_that("get_variance-1", {
-    expect_equal(v1$var.intercept,
-      c(Subject = 612.10016),
-      tolerance = 1e-2
-    )
-    expect_equal(v1$var.slope,
-      c(Subject.Days = 35.07171),
-      tolerance = 1e-2
-    )
-  })
-
-  test_that("get_variance-2", {
-    expect_equal(v2$var.intercept,
-      c(Subject = 627.56905),
-      tolerance = 1e-2
-    )
-    expect_equal(v2$var.slope,
-      c(Subject.Days = 35.85838),
-      tolerance = 1e-2
-    )
-  })
-
-  test_that("get_variance-3", {
-    expect_equal(v3$var.intercept,
-      c(subgrp.grp.1 = 0, Subject = 662.52047, grp.1 = 0),
-      tolerance = 1e-2
-    )
-    expect_equal(v3$var.slope,
-      c(Subject.Days = 34.25771, subgrp.grp.Days = 7.88485, grp.Days = 0),
-      tolerance = 1e-2
-    )
-  })
-
-  test_that("get_variance-4", {
-    expect_equal(v4$var.intercept,
-      c(Subject = 1378.17851),
-      tolerance = 1e-2
-    )
-    expect_null(v4$var.slope)
-  })
-
-  test_that("get_variance-5", {
-    expect_equal(v5$var.intercept,
-      c(`subgrp:grp` = 38.76069, Subject = 1377.50569, grp = 3.32031),
-      tolerance = 1e-2
-    )
-    expect_null(v5$var.slope)
-  })
-
-  test_that("get_variance-6", {
-    expect_equal(v6$var.intercept, c(plate = 0.71691), tolerance = 1e-2)
-    expect_equal(v6$var.random, 0.71691, tolerance = 1e-2)
-    expect_null(v6$var.slope)
-  })
-
-
-  # further examples
-
-  model <- lmer(Reaction ~ Days + (1 + Days || Subject), data = sleepstudy)
-  vmodel <- get_variance(model)
-
-  test_that("get_variance-7", {
-    expect_equal(
-      vmodel,
-      list(
-        var.fixed = 908.95336, var.random = 627.56905, var.residual = 653.5835,
-        var.distribution = 653.5835, var.dispersion = 0, var.intercept = c(Subject = 627.56905),
-        var.slope = c(Subject.Days = 35.85838)
-      ),
-      tolerance = 1e-2
-    )
-  })
-
-  model <- lmer(Reaction ~ Days + (0 + Days || Subject), data = study_data)
-  vmodel <- get_variance(model)
-
-  test_that("get_variance-8", {
-    expect_equal(
-      vmodel,
-      list(
-        var.fixed = 908.95336, var.random = 1502.179, var.residual = 842.02962,
-        var.distribution = 842.02962, var.dispersion = 0, var.slope = c(Subject.Days = 52.70804)
-      ),
-      tolerance = 1e-2
-    )
-  })
-
-
-  # categorical rnd slope
-
-  data("sleepstudy")
-  sleepstudy$Days2 <- cut(sleepstudy$Days, breaks = c(-1, 3, 6, 10))
-  study_data2 <<- sleepstudy
-
-  model <- lmer(Reaction ~ Days2 + (1 + Days2 | Subject), data = study_data2)
-  vmodel <- get_variance(model)
-
-  test_that("get_variance-9", {
-    expect_equal(
-      vmodel,
-      list(
-        var.fixed = 807.085453556748, var.random = 1711.44396436951,
-        var.residual = 748.811071562908, var.distribution = 748.811071562908,
-        var.dispersion = 0, var.intercept = c(Subject = 663.280418978822),
-        var.slope = c(`Subject.Days2(3,6]` = 882.364188919403, `Subject.Days2(6,10]` = 1415.70768194576),
-        cor.slope_intercept = structure(c(0.361173061386374, 0.331878499015884), dim = 2:1, dimnames = list(c("Days2(3,6]", "Days2(6,10]"), "Subject")),
-        cor.slopes = c(`Subject.Days2(3,6]-Days2(6,10]` = 0.847444720096841)
-      ),
-      tolerance = 1e-2
-    )
-  })
-
-  model <- suppressWarnings(lmer(Reaction ~ Days2 + (1 + Days2 || Subject), data = study_data2))
-  vmodel <- suppressWarnings(get_variance(model))
-
-  test_that("get_variance-10", {
-    expect_equal(
-      vmodel,
-      list(
-        var.fixed = 807.08545355676, var.residual = 740.875581179784,
-        var.distribution = 740.875581179784, var.dispersion = 0,
-        var.intercept = c(Subject = 738.635155172211),
-        var.slope = c(
-          `Subject.Days2(-1,3]` = 0, `Subject.Days2(3,6]` = 994.015865559888,
-          `Subject.Days2(6,10]` = 1545.72576115283
-        ),
-        cor.slopes = c(`Subject.1.Days2(3,6]-Days2(6,10]` = 0.859480774219098)
-      ),
-      tolerance = 1e-2
-    )
-  })
-
-  model <- lmer(Reaction ~ Days2 + (0 + Days2 | Subject), data = study_data2)
-  vmodel <- get_variance(model)
-
-  test_that("get_variance-11", {
-    expect_equal(
-      vmodel,
-      list(
-        var.fixed = 807.085453556794, var.random = 1446.13555108848,
-        var.residual = 748.813858500395, var.distribution = 748.813858500395,
-        var.dispersion = 0, var.slope = c(
-          `Subject.Days2(-1,3]` = 663.27445659023,
-          `Subject.Days2(3,6]` = 2098.24691538121, `Subject.Days2(6,10]` = 2722.20492158038
-        ), cor.slopes = c(
-          `Subject.Days2(-1,3]-Days2(3,6]` = 0.796453122321232,
-          `Subject.Days2(-1,3]-Days2(6,10]` = 0.732956077304911, `Subject.Days2(3,6]-Days2(6,10]` = 0.924018087860575
-        )
-      ),
-      tolerance = 1e-2
-    )
-  })
-
-  model <- lmer(Reaction ~ Days2 + (0 + Days2 || Subject), data = study_data2)
-  vmodel <- get_variance(model)
-
-  test_that("get_variance-12", {
-    expect_equal(
-      vmodel,
-      list(
-        var.fixed = 807.085453556794, var.random = 1446.13555108848,
-        var.residual = 748.813858500395, var.distribution = 748.813858500395,
-        var.dispersion = 0, var.slope = c(
-          `Subject.Days2(-1,3]` = 663.27445659023,
-          `Subject.Days2(3,6]` = 2098.24691538121, `Subject.Days2(6,10]` = 2722.20492158038
-        ), cor.slopes = c(
-          `Subject.Days2(-1,3]-Days2(3,6]` = 0.796453122321232,
-          `Subject.Days2(-1,3]-Days2(6,10]` = 0.732956077304911, `Subject.Days2(3,6]-Days2(6,10]` = 0.924018087860575
-        )
-      ),
-      tolerance = 1e-2
-    )
-  })
-
-
-  # test random slope correlation for categorical random slope
-
-  data(cake)
-  m <- lmer(angle ~ temperature + (temperature | recipe), data = cake)
-
-  test_that("get_variance-cat_random_slope", {
-    vc <- suppressWarnings(get_variance(m))
-    expect_equal(
-      vc$cor.slopes,
-      c(
-        `recipe.temperature.L-temperature.C` = 0.99999964, `recipe.temperature.Q-temperature.C` = 0.99999931,
-        `recipe.temperature.L-temperature.Q` = 0.99999941, `recipe.temperature.L-temperature^4` = 0.99999961,
-        `recipe.temperature.Q-temperature^4` = 0.99999912, `recipe.temperature.C-temperature^4` = 0.99999996,
-        `recipe.temperature.L-temperature^5` = -0.99999977, `recipe.temperature.Q-temperature^5` = -0.99999849,
-        `recipe.temperature.C-temperature^5` = -0.99999936, `recipe.temperature^4-temperature^5` = -0.99999941
-      ),
-      tolerance = 1e-3
-    )
-  })
-
-  data("sleepstudy")
-  set.seed(123)
-  sleepstudy$Months <- sample(1:4, nrow(sleepstudy), TRUE)
-  study_data3 <<- sleepstudy
-
-  m2 <- lmer(Reaction ~ Days + (0 + Days | Subject), data = study_data3)
-  m5 <- lmer(Reaction ~ Days + (0 + Days + Months | Subject), data = study_data3)
-
-  test_that("random effects CIs, simple slope", {
-    vc <- suppressWarnings(get_variance(m2))
-    expect_equal(
-      names(vc),
-      c(
-        "var.fixed", "var.random", "var.residual", "var.distribution",
-        "var.dispersion", "var.slope"
+  fm6 <- lme4::lmer(diameter ~ 0 + sample + (1 | plate), data = Penicillin)
+})
+
+v1 <- suppressWarnings(get_variance(fm1))
+v2 <- suppressWarnings(get_variance(fm2))
+v3 <- suppressWarnings(get_variance(fm3))
+v4 <- suppressWarnings(get_variance(fm4))
+v5 <- suppressWarnings(get_variance(fm5))
+v6 <- suppressWarnings(get_variance(fm6))
+
+test_that("get_variance-1", {
+  expect_equal(v1$var.intercept,
+    c(Subject = 612.10016),
+    tolerance = 1e-2
+  )
+  expect_equal(v1$var.slope,
+    c(Subject.Days = 35.07171),
+    tolerance = 1e-2
+  )
+})
+
+test_that("get_variance-2", {
+  expect_equal(v2$var.intercept,
+    c(Subject = 627.56905),
+    tolerance = 1e-2
+  )
+  expect_equal(v2$var.slope,
+    c(Subject.Days = 35.85838),
+    tolerance = 1e-2
+  )
+})
+
+test_that("get_variance-3", {
+  expect_equal(v3$var.intercept,
+    c(subgrp.grp.1 = 0, Subject = 662.52047, grp.1 = 0),
+    tolerance = 1e-2
+  )
+  expect_equal(v3$var.slope,
+    c(Subject.Days = 34.25771, subgrp.grp.Days = 7.88485, grp.Days = 0),
+    tolerance = 1e-2
+  )
+})
+
+test_that("get_variance-4", {
+  expect_equal(v4$var.intercept,
+    c(Subject = 1378.17851),
+    tolerance = 1e-2
+  )
+  expect_null(v4$var.slope)
+})
+
+test_that("get_variance-5", {
+  expect_equal(v5$var.intercept,
+    c(`subgrp:grp` = 38.76069, Subject = 1377.50569, grp = 3.32031),
+    tolerance = 1e-2
+  )
+  expect_null(v5$var.slope)
+})
+
+test_that("get_variance-6", {
+  expect_equal(v6$var.intercept, c(plate = 0.71691), tolerance = 1e-2)
+  expect_equal(v6$var.random, 0.71691, tolerance = 1e-2)
+  expect_null(v6$var.slope)
+})
+
+
+# further examples
+
+model <- lme4::lmer(Reaction ~ Days + (1 + Days || Subject), data = sleepstudy)
+vmodel <- get_variance(model)
+
+test_that("get_variance-7", {
+  expect_equal(
+    vmodel,
+    list(
+      var.fixed = 908.95336, var.random = 627.56905, var.residual = 653.5835,
+      var.distribution = 653.5835, var.dispersion = 0, var.intercept = c(Subject = 627.56905),
+      var.slope = c(Subject.Days = 35.85838)
+    ),
+    tolerance = 1e-2
+  )
+})
+
+model <- lme4::lmer(Reaction ~ Days + (0 + Days || Subject), data = study_data)
+vmodel <- get_variance(model)
+
+test_that("get_variance-8", {
+  expect_equal(
+    vmodel,
+    list(
+      var.fixed = 908.95336, var.random = 1502.179, var.residual = 842.02962,
+      var.distribution = 842.02962, var.dispersion = 0, var.slope = c(Subject.Days = 52.70804)
+    ),
+    tolerance = 1e-2
+  )
+})
+
+
+# categorical rnd slope
+
+data(sleepstudy, package = "lme4")
+sleepstudy$Days2 <- cut(sleepstudy$Days, breaks = c(-1, 3, 6, 10))
+study_data2 <<- sleepstudy
+
+model <- lme4::lmer(Reaction ~ Days2 + (1 + Days2 | Subject), data = study_data2)
+vmodel <- get_variance(model)
+
+test_that("get_variance-9", {
+  expect_equal(
+    vmodel,
+    list(
+      var.fixed = 807.085453556748, var.random = 1711.44396436951,
+      var.residual = 748.811071562908, var.distribution = 748.811071562908,
+      var.dispersion = 0, var.intercept = c(Subject = 663.280418978822),
+      var.slope = c(`Subject.Days2(3,6]` = 882.364188919403, `Subject.Days2(6,10]` = 1415.70768194576),
+      cor.slope_intercept = structure(c(0.361173061386374, 0.331878499015884), dim = 2:1, dimnames = list(c("Days2(3,6]", "Days2(6,10]"), "Subject")),
+      cor.slopes = c(`Subject.Days2(3,6]-Days2(6,10]` = 0.847444720096841)
+    ),
+    tolerance = 1e-2
+  )
+})
+
+model <- suppressMessages(lme4::lmer(Reaction ~ Days2 + (1 + Days2 || Subject), data = study_data2))
+vmodel <- suppressWarnings(get_variance(model))
+
+test_that("get_variance-10", {
+  expect_equal(
+    vmodel,
+    list(
+      var.fixed = 807.08545355676, var.residual = 740.875581179784,
+      var.distribution = 740.875581179784, var.dispersion = 0,
+      var.intercept = c(Subject = 738.635155172211),
+      var.slope = c(
+        `Subject.Days2(-1,3]` = 0, `Subject.Days2(3,6]` = 994.015865559888,
+        `Subject.Days2(6,10]` = 1545.72576115283
       ),
-      tolerance = 1e-3,
-      ignore_attr = TRUE
-    )
-  })
-
-  test_that("random effects CIs, simple slope", {
-    vc <- suppressWarnings(get_variance(m5))
-    expect_equal(
-      vc,
-      list(
-        var.fixed = 921.929610133035, var.random = 1068.04697608476,
-        var.residual = 764.479364064599, var.distribution = 764.479364064599,
-        var.dispersion = 0, var.slope = c(
-          Subject.Days = 37.4753324942022,
-          Subject.Months = 27.6430649522841
-        ),
-        cor.slopes = c(`Subject.Days-Months` = 0.455625778436967)
+      cor.slopes = c(`Subject.1.Days2(3,6]-Days2(6,10]` = 0.859480774219098)
+    ),
+    tolerance = 1e-2
+  )
+})
+
+model <- lme4::lmer(Reaction ~ Days2 + (0 + Days2 | Subject), data = study_data2)
+vmodel <- get_variance(model)
+
+test_that("get_variance-11", {
+  expect_equal(
+    vmodel,
+    list(
+      var.fixed = 807.085453556794, var.random = 1446.13555108848,
+      var.residual = 748.813858500395, var.distribution = 748.813858500395,
+      var.dispersion = 0, var.slope = c(
+        `Subject.Days2(-1,3]` = 663.27445659023,
+        `Subject.Days2(3,6]` = 2098.24691538121, `Subject.Days2(6,10]` = 2722.20492158038
+      ), cor.slopes = c(
+        `Subject.Days2(-1,3]-Days2(3,6]` = 0.796453122321232,
+        `Subject.Days2(-1,3]-Days2(6,10]` = 0.732956077304911, `Subject.Days2(3,6]-Days2(6,10]` = 0.924018087860575
+      )
+    ),
+    tolerance = 1e-2
+  )
+})
+
+model <- lme4::lmer(Reaction ~ Days2 + (0 + Days2 || Subject), data = study_data2)
+vmodel <- get_variance(model)
+
+test_that("get_variance-12", {
+  expect_equal(
+    vmodel,
+    list(
+      var.fixed = 807.085453556794, var.random = 1446.13555108848,
+      var.residual = 748.813858500395, var.distribution = 748.813858500395,
+      var.dispersion = 0, var.slope = c(
+        `Subject.Days2(-1,3]` = 663.27445659023,
+        `Subject.Days2(3,6]` = 2098.24691538121, `Subject.Days2(6,10]` = 2722.20492158038
+      ), cor.slopes = c(
+        `Subject.Days2(-1,3]-Days2(3,6]` = 0.796453122321232,
+        `Subject.Days2(-1,3]-Days2(6,10]` = 0.732956077304911, `Subject.Days2(3,6]-Days2(6,10]` = 0.924018087860575
+      )
+    ),
+    tolerance = 1e-2
+  )
+})
+
+
+# test random slope correlation for categorical random slope
+
+data(cake, package = "lme4")
+suppressMessages({
+  m <- lme4::lmer(angle ~ temperature + (temperature | recipe), data = cake)
+})
+test_that("get_variance-cat_random_slope", {
+  vc <- suppressWarnings(get_variance(m))
+  expect_equal(
+    vc$cor.slopes,
+    c(
+      `recipe.temperature.L-temperature.C` = 0.99999964, `recipe.temperature.Q-temperature.C` = 0.99999931,
+      `recipe.temperature.L-temperature.Q` = 0.99999941, `recipe.temperature.L-temperature^4` = 0.99999961,
+      `recipe.temperature.Q-temperature^4` = 0.99999912, `recipe.temperature.C-temperature^4` = 0.99999996,
+      `recipe.temperature.L-temperature^5` = -0.99999977, `recipe.temperature.Q-temperature^5` = -0.99999849,
+      `recipe.temperature.C-temperature^5` = -0.99999936, `recipe.temperature^4-temperature^5` = -0.99999941
+    ),
+    tolerance = 1e-3
+  )
+})
+
+data(sleepstudy, package = "lme4")
+set.seed(123)
+sleepstudy$Months <- sample(1:4, nrow(sleepstudy), TRUE)
+study_data3 <<- sleepstudy
+
+m2 <- lme4::lmer(Reaction ~ Days + (0 + Days | Subject), data = study_data3)
+m5 <- lme4::lmer(Reaction ~ Days + (0 + Days + Months | Subject), data = study_data3)
+
+test_that("random effects CIs, simple slope", {
+  vc <- suppressWarnings(get_variance(m2))
+  expect_equal(
+    names(vc),
+    c(
+      "var.fixed", "var.random", "var.residual", "var.distribution",
+      "var.dispersion", "var.slope"
+    ),
+    tolerance = 1e-3,
+    ignore_attr = TRUE
+  )
+})
+
+test_that("random effects CIs, simple slope", {
+  vc <- suppressWarnings(get_variance(m5))
+  expect_equal(
+    vc,
+    list(
+      var.fixed = 921.929610133035, var.random = 1068.04697608476,
+      var.residual = 764.479364064599, var.distribution = 764.479364064599,
+      var.dispersion = 0, var.slope = c(
+        Subject.Days = 37.4753324942022,
+        Subject.Months = 27.6430649522841
       ),
-      tolerance = 1e-3,
-      ignore_attr = TRUE
-    )
-  })
-
-  data(cake)
-  m <- lmer(angle ~ poly(temp, 2) + (poly(temp, 2) | replicate) + (1 | recipe), data = cake)
-
-  test_that("random effects CIs, poly slope", {
-    vc <- suppressWarnings(get_variance(m))
-    expect_equal(
-      vc$cor.slopes,
-      c(`replicate.poly(temp, 2)1-poly(temp, 2)2` = 0.940016422944175),
-      tolerance = 1e-3,
-      ignore_attr = TRUE
-    )
-  })
-}
+      cor.slopes = c(`Subject.Days-Months` = 0.455625778436967)
+    ),
+    tolerance = 1e-3,
+    ignore_attr = TRUE
+  )
+})
+
+data(cake, package = "lme4")
+suppressMessages({
+  m <- lme4::lmer(angle ~ poly(temp, 2) + (poly(temp, 2) | replicate) + (1 | recipe), data = cake)
+})
+
+test_that("random effects CIs, poly slope", {
+  vc <- suppressWarnings(get_variance(m))
+  expect_equal(
+    vc$cor.slopes,
+    c(`replicate.poly(temp, 2)1-poly(temp, 2)2` = 0.940016422944175),
+    tolerance = 1e-3,
+    ignore_attr = TRUE
+  )
+})
diff --git a/tests/testthat/test-get_weights.R b/tests/testthat/test-get_weights.R
index fdda17b6c..e7b8cf4c3 100644
--- a/tests/testthat/test-get_weights.R
+++ b/tests/testthat/test-get_weights.R
@@ -1,43 +1,41 @@
-if (skip_if_not_or_load_if_installed("lme4")) {
-  data(mtcars)
-  m1 <- lmer(mpg ~ am + (1 | cyl), data = mtcars)
-  m2 <- lm(mpg ~ am, data = mtcars)
+skip_if_not_installed("lme4")
 
-  test_that("get_weights", {
-    expect_null(get_weights(m1))
-    expect_null(get_weights(m2))
-  })
+m1 <- lme4::lmer(mpg ~ am + (1 | cyl), data = mtcars)
+m2 <- lm(mpg ~ am, data = mtcars)
 
-  set.seed(123)
-  mtcars$w <- abs(rnorm(nrow(mtcars), sd = 0.5))
+test_that("get_weights", {
+  expect_null(get_weights(m1))
+  expect_null(get_weights(m2))
+})
 
-  m1 <- lmer(mpg ~ am + (1 | cyl), data = mtcars, weights = w)
-  m2 <- lm(mpg ~ am, data = mtcars, weights = w)
+set.seed(123)
+mtcars$w <- abs(rnorm(nrow(mtcars), sd = 0.5))
 
-  test_that("get_weights", {
-    expect_equal(
-      get_weights(m1),
-      mtcars$w,
-      tolerance = 1e-2
-    )
-    expect_equal(
-      get_weights(m2),
-      mtcars$w,
-      tolerance = 1e-2
-    )
-  })
-}
+m1 <- lme4::lmer(mpg ~ am + (1 | cyl), data = mtcars, weights = w)
+m2 <- lm(mpg ~ am, data = mtcars, weights = w)
 
-if (skip_if_not_or_load_if_installed("nlme")) {
-  data("Orthodont", package = "nlme")
-  m <- lme( # a model of variance only
-    distance ~ 1,
-    data = Orthodont, # grand mean
-    weights = varConstPower(form = ~ age | Sex)
+test_that("get_weights", {
+  expect_equal(
+    get_weights(m1),
+    mtcars$w,
+    tolerance = 1e-2
   )
+  expect_equal(
+    get_weights(m2),
+    mtcars$w,
+    tolerance = 1e-2
+  )
+})
+
+skip_if_not_installed("nlme")
+data("Orthodont", package = "nlme")
+m <- nlme::lme( # a model of variance only
+  distance ~ 1,
+  data = nlme::Orthodont, # grand mean
+  weights = nlme::varConstPower(form = ~ age | Sex)
+)
 
-  out <- get_weights(m)
-  test_that("get_weights nlme", {
-    expect_identical(colnames(out), c("age", "Sex"))
-  })
-}
+out <- get_weights(m)
+test_that("get_weights nlme", {
+  expect_identical(colnames(out), c("age", "Sex"))
+})
diff --git a/tests/testthat/test-glm.R b/tests/testthat/test-glm.R
index f32a74566..279e2b6ab 100644
--- a/tests/testthat/test-glm.R
+++ b/tests/testthat/test-glm.R
@@ -1,173 +1,171 @@
-if (
+skip_if_not_installed("glmmTMB")
+
+data(Salamanders, package = "glmmTMB")
+Salamanders$cover <- abs(Salamanders$cover)
+dat <<- Salamanders
+
+m1 <- glm(count ~ mined + log(cover) + sample,
+  family = poisson,
+  data = dat
+)
+
+test_that("model_info", {
+  expect_true(model_info(m1)$is_poisson)
+  expect_true(model_info(m1)$is_count)
+  expect_false(model_info(m1)$is_negbin)
+  expect_false(model_info(m1)$is_binomial)
+  expect_false(model_info(m1)$is_linear)
+})
+
+test_that("loglik", {
+  expect_equal(get_loglikelihood(m1), logLik(m1), ignore_attr = TRUE)
+})
+
+test_that("get_df", {
+  expect_equal(get_df(m1), df.residual(m1), ignore_attr = TRUE)
+  expect_equal(get_df(m1, type = "model"), attr(logLik(m1), "df"), ignore_attr = TRUE)
+})
+
+test_that("get_df", {
+  expect_equal(
+    get_df(m1, type = "residual"),
+    df.residual(m1),
+    ignore_attr = TRUE
+  )
+  expect_equal(
+    get_df(m1, type = "normal"),
+    Inf,
+    ignore_attr = TRUE
+  )
+  expect_equal(
+    get_df(m1, type = "wald"),
+    Inf,
+    ignore_attr = TRUE
+  )
+})
 
-  skip_if_not_or_load_if_installed("glmmTMB")) {
-  data(Salamanders)
-  Salamanders$cover <- abs(Salamanders$cover)
-  dat <<- Salamanders
 
-  m1 <- glm(count ~ mined + log(cover) + sample,
-    family = poisson,
-    data = dat
+test_that("find_predictors", {
+  expect_identical(find_predictors(m1), list(conditional = c("mined", "cover", "sample")))
+  expect_identical(
+    find_predictors(m1, flatten = TRUE),
+    c("mined", "cover", "sample")
   )
-
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_poisson)
-    expect_true(model_info(m1)$is_count)
-    expect_false(model_info(m1)$is_negbin)
-    expect_false(model_info(m1)$is_binomial)
-    expect_false(model_info(m1)$is_linear)
-  })
-
-  test_that("loglik", {
-    expect_equal(get_loglikelihood(m1), logLik(m1), ignore_attr = TRUE)
-  })
-
-  test_that("get_df", {
-    expect_equal(get_df(m1), df.residual(m1), ignore_attr = TRUE)
-    expect_equal(get_df(m1, type = "model"), attr(logLik(m1), "df"), ignore_attr = TRUE)
-  })
-
-  test_that("get_df", {
-    expect_equal(
-      get_df(m1, type = "residual"),
-      df.residual(m1),
-      ignore_attr = TRUE
-    )
-    expect_equal(
-      get_df(m1, type = "normal"),
-      Inf,
-      ignore_attr = TRUE
-    )
-    expect_equal(
-      get_df(m1, type = "wald"),
-      Inf,
-      ignore_attr = TRUE
+  expect_null(find_predictors(m1, effects = "random"))
+})
+
+test_that("find_random", {
+  expect_null(find_random(m1))
+})
+
+test_that("get_random", {
+  expect_warning(get_random(m1))
+})
+
+test_that("find_response", {
+  expect_identical(find_response(m1), "count")
+})
+
+test_that("get_response", {
+  expect_identical(get_response(m1), Salamanders$count)
+})
+
+test_that("get_predictors", {
+  expect_identical(colnames(get_predictors(m1)), c("mined", "cover", "sample"))
+})
+
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), exp(0.2), tolerance = 1e-5)
+})
+
+test_that("linkfun", {
+  expect_equal(link_function(m1)(0.2), -1.609438, tolerance = 1e-4)
+})
+
+test_that("get_data", {
+  expect_identical(nrow(get_data(m1)), 644L)
+  expect_identical(
+    colnames(get_data(m1)),
+    c("count", "mined", "cover", "sample")
+  )
+})
+
+test_that("get_call", {
+  expect_identical(class(get_call(m1)), "call")
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1), 1)
+  expect_equal(
+    find_formula(m1),
+    list(conditional = as.formula("count ~ mined + log(cover) + sample")),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_variables", {
+  expect_identical(
+    find_variables(m1),
+    list(
+      response = "count",
+      conditional = c("mined", "cover", "sample")
     )
-  })
+  )
+  expect_identical(
+    find_variables(m1, flatten = TRUE),
+    c("count", "mined", "cover", "sample")
+  )
+})
 
+test_that("n_obs", {
+  expect_identical(n_obs(m1), 644L)
+})
 
-  test_that("find_predictors", {
-    expect_identical(find_predictors(m1), list(conditional = c("mined", "cover", "sample")))
-    expect_identical(
-      find_predictors(m1, flatten = TRUE),
-      c("mined", "cover", "sample")
-    )
-    expect_null(find_predictors(m1, effects = "random"))
-  })
-
-  test_that("find_random", {
-    expect_null(find_random(m1))
-  })
-
-  test_that("get_random", {
-    expect_warning(get_random(m1))
-  })
-
-  test_that("find_response", {
-    expect_identical(find_response(m1), "count")
-  })
-
-  test_that("get_response", {
-    expect_identical(get_response(m1), Salamanders$count)
-  })
-
-  test_that("get_predictors", {
-    expect_identical(colnames(get_predictors(m1)), c("mined", "cover", "sample"))
-  })
-
-  test_that("link_inverse", {
-    expect_equal(link_inverse(m1)(0.2), exp(0.2), tolerance = 1e-5)
-  })
-
-  test_that("linkfun", {
-    expect_equal(link_function(m1)(0.2), -1.609438, tolerance = 1e-4)
-  })
-
-  test_that("get_data", {
-    expect_identical(nrow(get_data(m1)), 644L)
-    expect_identical(
-      colnames(get_data(m1)),
-      c("count", "mined", "cover", "sample")
+test_that("find_parameters", {
+  expect_identical(
+    find_parameters(m1),
+    list(
+      conditional = c("(Intercept)", "minedno", "log(cover)", "sample")
     )
-  })
-
-  test_that("get_call", {
-    expect_identical(class(get_call(m1)), "call")
-  })
-
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 1)
-    expect_equal(
-      find_formula(m1),
-      list(conditional = as.formula("count ~ mined + log(cover) + sample")),
-      ignore_attr = TRUE
-    )
-  })
-
-  test_that("find_variables", {
-    expect_identical(
-      find_variables(m1),
-      list(
-        response = "count",
-        conditional = c("mined", "cover", "sample")
-      )
-    )
-    expect_identical(
-      find_variables(m1, flatten = TRUE),
-      c("count", "mined", "cover", "sample")
-    )
-  })
-
-  test_that("n_obs", {
-    expect_identical(n_obs(m1), 644L)
-  })
-
-  test_that("find_parameters", {
-    expect_identical(
-      find_parameters(m1),
-      list(
-        conditional = c("(Intercept)", "minedno", "log(cover)", "sample")
-      )
-    )
-    expect_identical(nrow(get_parameters(m1)), 4L)
-    expect_identical(
-      get_parameters(m1)$Parameter,
-      c("(Intercept)", "minedno", "log(cover)", "sample")
-    )
-  })
-
-  test_that("is_multivariate", {
-    expect_false(is_multivariate(m1))
-  })
-
-  test_that("find_terms", {
-    expect_identical(
-      find_terms(m1),
-      list(
-        response = "count",
-        conditional = c("mined", "log(cover)", "sample")
-      )
-    )
-  })
-
-  test_that("find_algorithm", {
-    expect_identical(find_algorithm(m1), list(algorithm = "ML"))
-  })
-
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "z-statistic")
-  })
-
-  test_that("get_statistic", {
-    expect_equal(
-      get_statistic(m1)$Statistic,
-      c(
-        -10.7066515607315,
-        18.1533878215937,
-        -1.68918157150882,
-        2.23541768590273
-      ),
-      tolerance = 1e-4
+  )
+  expect_identical(nrow(get_parameters(m1)), 4L)
+  expect_identical(
+    get_parameters(m1)$Parameter,
+    c("(Intercept)", "minedno", "log(cover)", "sample")
+  )
+})
+
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1))
+})
+
+test_that("find_terms", {
+  expect_identical(
+    find_terms(m1),
+    list(
+      response = "count",
+      conditional = c("mined", "log(cover)", "sample")
     )
-  })
-}
+  )
+})
+
+test_that("find_algorithm", {
+  expect_identical(find_algorithm(m1), list(algorithm = "ML"))
+})
+
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "z-statistic")
+})
+
+test_that("get_statistic", {
+  expect_equal(
+    get_statistic(m1)$Statistic,
+    c(
+      -10.7066515607315,
+      18.1533878215937,
+      -1.68918157150882,
+      2.23541768590273
+    ),
+    tolerance = 1e-4
+  )
+})
diff --git a/tests/testthat/test-glm.nb.R b/tests/testthat/test-glm.nb.R
index c72797e81..dac6cd30b 100644
--- a/tests/testthat/test-glm.nb.R
+++ b/tests/testthat/test-glm.nb.R
@@ -1,23 +1,22 @@
-if (skip_if_not_or_load_if_installed("MASS")) {
-  data(quine)
-  set.seed(123)
-  m1 <- glm.nb(Days ~ Sex / (Age + Eth * Lrn), data = quine)
+skip_if_not_installed("MASS")
+data(quine, package = "MASS")
+set.seed(123)
+m1 <- MASS::glm.nb(Days ~ Sex / (Age + Eth * Lrn), data = quine)
 
-  test_that("get_df", {
-    expect_equal(
-      get_df(m1, type = "residual"),
-      df.residual(m1),
-      ignore_attr = TRUE
-    )
-    expect_equal(
-      get_df(m1, type = "normal"),
-      Inf,
-      ignore_attr = TRUE
-    )
-    expect_equal(
-      get_df(m1, type = "wald"),
-      Inf,
-      ignore_attr = TRUE
-    )
-  })
-}
+test_that("get_df", {
+  expect_equal(
+    get_df(m1, type = "residual"),
+    df.residual(m1),
+    ignore_attr = TRUE
+  )
+  expect_equal(
+    get_df(m1, type = "normal"),
+    Inf,
+    ignore_attr = TRUE
+  )
+  expect_equal(
+    get_df(m1, type = "wald"),
+    Inf,
+    ignore_attr = TRUE
+  )
+})
diff --git a/tests/testthat/test-glmmTMB.R b/tests/testthat/test-glmmTMB.R
index 61fff0a1a..7d13937f1 100644
--- a/tests/testthat/test-glmmTMB.R
+++ b/tests/testthat/test-glmmTMB.R
@@ -1,954 +1,952 @@
 skip_on_os("mac") # error: FreeADFunObject
-
-skip_if_not_or_load_if_installed("TMB")
-skip_if_not_or_load_if_installed("glmmTMB")
-
-if (getRversion() >= "4.0.0") {
-  # fish <- read.csv("https://stats.idre.ucla.edu/stat/data/fish.csv")
-  # fish$nofish <- as.factor(fish$nofish)
-  # fish$livebait <- as.factor(fish$livebait)
-  # fish$camper <- as.factor(fish$camper)
-
-  data("fish")
-  m1 <- glmmTMB(
-    count ~ child + camper + (1 | persons),
-    ziformula = ~ child + camper + (1 | persons),
-    data = fish,
-    family = truncated_poisson()
+skip_if_not(getRversion() >= "4.0.0")
+skip_if_not_installed("TMB")
+skip_if_not_installed("glmmTMB")
+
+# fish <- read.csv("https://stats.idre.ucla.edu/stat/data/fish.csv")
+# fish$nofish <- as.factor(fish$nofish)
+# fish$livebait <- as.factor(fish$livebait)
+# fish$camper <- as.factor(fish$camper)
+
+data("fish")
+m1 <- glmmTMB::glmmTMB(
+  count ~ child + camper + (1 | persons),
+  ziformula = ~ child + camper + (1 | persons),
+  data = fish,
+  family = glmmTMB::truncated_poisson()
+)
+
+m2 <- glmmTMB::glmmTMB(
+  count ~ child + camper + (1 | persons),
+  data = fish,
+  family = poisson()
+)
+
+m3 <- glmmTMB::glmmTMB(
+  count ~ child + camper + (1 | persons),
+  ziformula = ~ child + livebait + (1 | persons),
+  data = fish,
+  family = poisson()
+)
+
+m4 <- glmmTMB::glmmTMB(
+  count ~ child + camper + (1 | persons),
+  ziformula = ~ child + livebait + (1 | ID),
+  dispformula = ~xb,
+  data = fish,
+  family = glmmTMB::truncated_poisson()
+)
+
+m7 <- suppressWarnings(glmmTMB::glmmTMB(
+  count ~ child + camper + (1 + xb | persons),
+  ziformula = ~ child + livebait + (1 + zg + nofish | ID),
+  dispformula = ~xb,
+  data = fish,
+  family = glmmTMB::truncated_poisson()
+))
+
+data(Salamanders, package = "glmmTMB")
+m5 <- glmmTMB::glmmTMB(
+  count ~ mined + (1 | site),
+  ziformula = ~mined,
+  family = poisson,
+  data = Salamanders
+)
+
+m6 <-
+  glmmTMB::glmmTMB(count ~ 1,
+    ziformula = ~1,
+    family = poisson(),
+    data = Salamanders
   )
 
-  m2 <- glmmTMB(
-    count ~ child + camper + (1 | persons),
-    data = fish,
-    family = poisson()
+test_that("find_weights", {
+  expect_null(find_weights(m2))
+})
+
+test_that("get_weights", {
+  expect_null(get_weights(m2))
+})
+
+test_that("get_deviance + logLik", {
+  expect_equal(get_deviance(m2), 1697.449311, tolerance = 1e-3)
+  expect_equal(get_loglikelihood(m2), logLik(m2), tolerance = 1e-3, ignore_attr = TRUE)
+  expect_identical(get_df(m2, type = "model"), 4L)
+})
+
+test_that("get_df", {
+  expect_equal(
+    get_df(m2, type = "residual"),
+    df.residual(m2),
+    ignore_attr = TRUE
   )
-
-  m3 <- glmmTMB(
-    count ~ child + camper + (1 | persons),
-    ziformula = ~ child + livebait + (1 | persons),
-    data = fish,
-    family = poisson()
+  expect_equal(
+    get_df(m2, type = "normal"),
+    Inf,
+    ignore_attr = TRUE
   )
-
-  m4 <- glmmTMB(
-    count ~ child + camper + (1 | persons),
-    ziformula = ~ child + livebait + (1 | ID),
-    dispformula = ~xb,
-    data = fish,
-    family = truncated_poisson()
+  expect_equal(
+    get_df(m2, type = "wald"),
+    Inf,
+    ignore_attr = TRUE
   )
-
-  m7 <- suppressWarnings(glmmTMB(
-    count ~ child + camper + (1 + xb | persons),
-    ziformula = ~ child + livebait + (1 + zg + nofish | ID),
-    dispformula = ~xb,
-    data = fish,
-    family = truncated_poisson()
-  ))
-
-  data(Salamanders)
-  m5 <- glmmTMB(
-    count ~ mined + (1 | site),
-    ziformula = ~mined,
-    family = poisson,
-    data = Salamanders
+  expect_equal(
+    get_df(m2, type = "ml1"),
+    c(`(Intercept)` = 247, child = 247, camper1 = 247),
+    ignore_attr = TRUE
   )
-
-  m6 <-
-    glmmTMB(count ~ 1,
-      ziformula = ~1,
-      family = poisson(),
-      data = Salamanders
-    )
-
-  test_that("find_weights", {
-    expect_null(find_weights(m2))
-  })
-
-  test_that("get_weights", {
-    expect_null(get_weights(m2))
-  })
-
-  test_that("get_deviance + logLik", {
-    expect_equal(get_deviance(m2), 1697.449311, tolerance = 1e-3)
-    expect_equal(get_loglikelihood(m2), logLik(m2), tolerance = 1e-3, ignore_attr = TRUE)
-    expect_identical(get_df(m2, type = "model"), 4L)
-  })
-
-  test_that("get_df", {
-    expect_equal(
-      get_df(m2, type = "residual"),
-      df.residual(m2),
-      ignore_attr = TRUE
-    )
-    expect_equal(
-      get_df(m2, type = "normal"),
-      Inf,
-      ignore_attr = TRUE
-    )
-    expect_equal(
-      get_df(m2, type = "wald"),
-      Inf,
-      ignore_attr = TRUE
-    )
-    expect_equal(
-      get_df(m2, type = "ml1"),
-      c(`(Intercept)` = 247, child = 247, camper1 = 247),
-      ignore_attr = TRUE
-    )
-  })
-
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_zero_inflated)
-    expect_false(model_info(m2)$is_zero_inflated)
-    expect_true(model_info(m3)$is_count)
-    expect_true(model_info(m3)$is_pois)
-    expect_false(model_info(m3)$is_negbin)
-    expect_true(model_info(m6)$is_count)
-    expect_false(model_info(m1)$is_linear)
-  })
-
-  test_that("clean_names", {
-    expect_identical(clean_names(m1), c("count", "child", "camper", "persons"))
-    expect_identical(clean_names(m2), c("count", "child", "camper", "persons"))
-    expect_identical(
-      clean_names(m3),
-      c("count", "child", "camper", "persons", "livebait")
-    )
-    expect_identical(
-      clean_names(m4),
-      c(
-        "count",
-        "child",
-        "camper",
-        "persons",
-        "livebait",
-        "ID",
-        "xb"
-      )
-    )
-    expect_identical(clean_names(m6), "count")
-  })
-
-  test_that("find_predictors", {
-    expect_identical(
-      find_predictors(m1, effects = "all"),
-      list(
-        conditional = c("child", "camper"),
-        random = "persons",
-        zero_inflated = c("child", "camper"),
-        zero_inflated_random = "persons"
-      )
-    )
-    expect_identical(
-      find_predictors(m1, effects = "all", flatten = TRUE),
-      c("child", "camper", "persons")
-    )
-    expect_identical(
-      find_predictors(m1, effects = "random"),
-      list(random = "persons", zero_inflated_random = "persons")
-    )
-    expect_identical(
-      find_predictors(m1, effects = "random", flatten = TRUE),
-      "persons"
-    )
-    expect_identical(
-      find_predictors(m1, effects = "random", component = "conditional"),
-      list(random = "persons")
+})
+
+test_that("model_info", {
+  expect_true(model_info(m1)$is_zero_inflated)
+  expect_false(model_info(m2)$is_zero_inflated)
+  expect_true(model_info(m3)$is_count)
+  expect_true(model_info(m3)$is_pois)
+  expect_false(model_info(m3)$is_negbin)
+  expect_true(model_info(m6)$is_count)
+  expect_false(model_info(m1)$is_linear)
+})
+
+test_that("clean_names", {
+  expect_identical(clean_names(m1), c("count", "child", "camper", "persons"))
+  expect_identical(clean_names(m2), c("count", "child", "camper", "persons"))
+  expect_identical(
+    clean_names(m3),
+    c("count", "child", "camper", "persons", "livebait")
+  )
+  expect_identical(
+    clean_names(m4),
+    c(
+      "count",
+      "child",
+      "camper",
+      "persons",
+      "livebait",
+      "ID",
+      "xb"
     )
-    expect_identical(
-      find_predictors(
-        m1,
-        effects = "random",
-        component = "conditional",
-        flatten = TRUE
-      ),
-      "persons"
+  )
+  expect_identical(clean_names(m6), "count")
+})
+
+test_that("find_predictors", {
+  expect_identical(
+    find_predictors(m1, effects = "all"),
+    list(
+      conditional = c("child", "camper"),
+      random = "persons",
+      zero_inflated = c("child", "camper"),
+      zero_inflated_random = "persons"
     )
-    expect_identical(
-      find_predictors(m1),
-      list(
-        conditional = c("child", "camper"),
-        zero_inflated = c("child", "camper")
-      )
+  )
+  expect_identical(
+    find_predictors(m1, effects = "all", flatten = TRUE),
+    c("child", "camper", "persons")
+  )
+  expect_identical(
+    find_predictors(m1, effects = "random"),
+    list(random = "persons", zero_inflated_random = "persons")
+  )
+  expect_identical(
+    find_predictors(m1, effects = "random", flatten = TRUE),
+    "persons"
+  )
+  expect_identical(
+    find_predictors(m1, effects = "random", component = "conditional"),
+    list(random = "persons")
+  )
+  expect_identical(
+    find_predictors(
+      m1,
+      effects = "random",
+      component = "conditional",
+      flatten = TRUE
+    ),
+    "persons"
+  )
+  expect_identical(
+    find_predictors(m1),
+    list(
+      conditional = c("child", "camper"),
+      zero_inflated = c("child", "camper")
     )
-    expect_identical(find_predictors(m1, flatten = TRUE), c("child", "camper"))
+  )
+  expect_identical(find_predictors(m1, flatten = TRUE), c("child", "camper"))
 
-    expect_identical(
-      find_predictors(m2, effects = "all"),
-      list(
-        conditional = c("child", "camper"),
-        random = "persons"
-      )
-    )
-    expect_identical(
-      find_predictors(m2, effects = "all", flatten = TRUE),
-      c("child", "camper", "persons")
-    )
-    expect_identical(
-      find_predictors(m2, effects = "random"),
-      list(random = "persons")
-    )
-    expect_identical(
-      find_predictors(m2, effects = "random", flatten = TRUE),
-      "persons"
-    )
-    expect_identical(find_predictors(m2), list(conditional = c("child", "camper")))
-
-    expect_null(find_predictors(m6))
-  })
-
-  test_that("find_response", {
-    expect_identical(find_response(m1), "count")
-    expect_identical(find_response(m2), "count")
-    expect_identical(find_response(m6), "count")
-  })
-
-  test_that("link_inverse", {
-    expect_identical(link_inverse(m1)(0.2), exp(0.2))
-    expect_identical(link_inverse(m2)(0.2), exp(0.2))
-  })
-
-  test_that("get_data", {
-    expect_identical(
-      colnames(get_data(m1)),
-      c("count", "child", "camper", "persons")
-    )
-    expect_identical(
-      colnames(get_data(m1, effects = "all")),
-      c("count", "child", "camper", "persons")
-    )
-    expect_identical(colnames(get_data(m1, effects = "random")), "persons")
-    expect_identical(
-      colnames(get_data(m2)),
-      c("count", "child", "camper", "persons")
-    )
-    expect_identical(
-      colnames(get_data(m2, effects = "all")),
-      c("count", "child", "camper", "persons")
-    )
-    expect_identical(colnames(get_data(m2, effects = "random", verbose = FALSE)), "persons")
-    get_data(m3)
-    expect_identical(colnames(get_data(m6, verbose = FALSE)), "count")
-    expect_null(get_data(m6, effects = "random", verbose = FALSE))
-  })
-
-  test_that("find_predictors", {
-    expect_identical(
-      find_predictors(m3, effects = "fixed", component = "conditional"),
-      list(conditional = c("child", "camper"))
-    )
-    expect_identical(
-      find_predictors(
-        m3,
-        effects = "fixed",
-        component = "conditional",
-        flatten = TRUE
-      ),
-      c("child", "camper")
-    )
-    expect_identical(
-      find_predictors(m3, effects = "fixed", component = "zero_inflated"),
-      list(zero_inflated = c("child", "livebait"))
-    )
-    expect_identical(
-      find_predictors(
-        m3,
-        effects = "fixed",
-        component = "zero_inflated",
-        flatten = TRUE
-      ),
-      c("child", "livebait")
-    )
-    expect_identical(
-      find_predictors(m3, effects = "all", component = "conditional"),
-      list(
-        conditional = c("child", "camper"),
-        random = "persons"
-      )
-    )
-    expect_identical(
-      find_predictors(
-        m3,
-        effects = "all",
-        component = "conditional",
-        flatten = TRUE
-      ),
-      c("child", "camper", "persons")
+  expect_identical(
+    find_predictors(m2, effects = "all"),
+    list(
+      conditional = c("child", "camper"),
+      random = "persons"
     )
-    expect_identical(
-      find_predictors(m3, effects = "all", component = "zero_inflated"),
-      list(
-        zero_inflated = c("child", "livebait"),
-        zero_inflated_random = "persons"
-      )
-    )
-    expect_identical(
-      find_predictors(
-        m3,
-        effects = "all",
-        component = "zero_inflated",
-        flatten = TRUE
-      ),
-      c("child", "livebait", "persons")
-    )
-    expect_identical(
-      find_predictors(m3, effects = "random", component = "conditional"),
-      list(random = "persons")
-    )
-    expect_identical(
-      find_predictors(
-        m3,
-        effects = "random",
-        component = "conditional",
-        flatten = TRUE
-      ),
-      "persons"
-    )
-    expect_identical(
-      find_predictors(m3, effects = "random", component = "zero_inflated"),
-      list(zero_inflated_random = "persons")
+  )
+  expect_identical(
+    find_predictors(m2, effects = "all", flatten = TRUE),
+    c("child", "camper", "persons")
+  )
+  expect_identical(
+    find_predictors(m2, effects = "random"),
+    list(random = "persons")
+  )
+  expect_identical(
+    find_predictors(m2, effects = "random", flatten = TRUE),
+    "persons"
+  )
+  expect_identical(find_predictors(m2), list(conditional = c("child", "camper")))
+
+  expect_null(find_predictors(m6))
+})
+
+test_that("find_response", {
+  expect_identical(find_response(m1), "count")
+  expect_identical(find_response(m2), "count")
+  expect_identical(find_response(m6), "count")
+})
+
+test_that("link_inverse", {
+  expect_identical(link_inverse(m1)(0.2), exp(0.2))
+  expect_identical(link_inverse(m2)(0.2), exp(0.2))
+})
+
+test_that("get_data", {
+  expect_identical(
+    colnames(get_data(m1)),
+    c("count", "child", "camper", "persons")
+  )
+  expect_identical(
+    colnames(get_data(m1, effects = "all")),
+    c("count", "child", "camper", "persons")
+  )
+  expect_identical(colnames(get_data(m1, effects = "random")), "persons")
+  expect_identical(
+    colnames(get_data(m2)),
+    c("count", "child", "camper", "persons")
+  )
+  expect_identical(
+    colnames(get_data(m2, effects = "all")),
+    c("count", "child", "camper", "persons")
+  )
+  expect_identical(colnames(get_data(m2, effects = "random", verbose = FALSE)), "persons")
+  get_data(m3)
+  expect_identical(colnames(get_data(m6, verbose = FALSE)), "count")
+  expect_null(get_data(m6, effects = "random", verbose = FALSE))
+})
+
+test_that("find_predictors", {
+  expect_identical(
+    find_predictors(m3, effects = "fixed", component = "conditional"),
+    list(conditional = c("child", "camper"))
+  )
+  expect_identical(
+    find_predictors(
+      m3,
+      effects = "fixed",
+      component = "conditional",
+      flatten = TRUE
+    ),
+    c("child", "camper")
+  )
+  expect_identical(
+    find_predictors(m3, effects = "fixed", component = "zero_inflated"),
+    list(zero_inflated = c("child", "livebait"))
+  )
+  expect_identical(
+    find_predictors(
+      m3,
+      effects = "fixed",
+      component = "zero_inflated",
+      flatten = TRUE
+    ),
+    c("child", "livebait")
+  )
+  expect_identical(
+    find_predictors(m3, effects = "all", component = "conditional"),
+    list(
+      conditional = c("child", "camper"),
+      random = "persons"
     )
-    expect_identical(
-      find_predictors(
-        m3,
-        effects = "random",
-        component = "zero_inflated",
-        flatten = TRUE
-      ),
-      "persons"
+  )
+  expect_identical(
+    find_predictors(
+      m3,
+      effects = "all",
+      component = "conditional",
+      flatten = TRUE
+    ),
+    c("child", "camper", "persons")
+  )
+  expect_identical(
+    find_predictors(m3, effects = "all", component = "zero_inflated"),
+    list(
+      zero_inflated = c("child", "livebait"),
+      zero_inflated_random = "persons"
     )
+  )
+  expect_identical(
+    find_predictors(
+      m3,
+      effects = "all",
+      component = "zero_inflated",
+      flatten = TRUE
+    ),
+    c("child", "livebait", "persons")
+  )
+  expect_identical(
+    find_predictors(m3, effects = "random", component = "conditional"),
+    list(random = "persons")
+  )
+  expect_identical(
+    find_predictors(
+      m3,
+      effects = "random",
+      component = "conditional",
+      flatten = TRUE
+    ),
+    "persons"
+  )
+  expect_identical(
+    find_predictors(m3, effects = "random", component = "zero_inflated"),
+    list(zero_inflated_random = "persons")
+  )
+  expect_identical(
+    find_predictors(
+      m3,
+      effects = "random",
+      component = "zero_inflated",
+      flatten = TRUE
+    ),
+    "persons"
+  )
 
-    expect_identical(
-      find_predictors(m3, effects = "fixed", component = "all"),
-      list(
-        conditional = c("child", "camper"),
-        zero_inflated = c("child", "livebait")
-      )
-    )
-    expect_identical(
-      find_predictors(
-        m3,
-        effects = "fixed",
-        component = "all",
-        flatten = TRUE
-      ),
-      c("child", "camper", "livebait")
-    )
-    expect_identical(
-      find_predictors(m3, effects = "all", component = "all"),
-      list(
-        conditional = c("child", "camper"),
-        random = "persons",
-        zero_inflated = c("child", "livebait"),
-        zero_inflated_random = "persons"
-      )
-    )
-    expect_identical(
-      find_predictors(
-        m3,
-        effects = "all",
-        component = "all",
-        flatten = TRUE
-      ),
-      c("child", "camper", "persons", "livebait")
+  expect_identical(
+    find_predictors(m3, effects = "fixed", component = "all"),
+    list(
+      conditional = c("child", "camper"),
+      zero_inflated = c("child", "livebait")
     )
-    expect_identical(
-      find_predictors(m3, effects = "random", component = "all"),
-      list(random = "persons", zero_inflated_random = "persons")
-    )
-    expect_identical(
-      find_predictors(
-        m3,
-        effects = "random",
-        component = "all",
-        flatten = TRUE
-      ),
-      "persons"
+  )
+  expect_identical(
+    find_predictors(
+      m3,
+      effects = "fixed",
+      component = "all",
+      flatten = TRUE
+    ),
+    c("child", "camper", "livebait")
+  )
+  expect_identical(
+    find_predictors(m3, effects = "all", component = "all"),
+    list(
+      conditional = c("child", "camper"),
+      random = "persons",
+      zero_inflated = c("child", "livebait"),
+      zero_inflated_random = "persons"
     )
-
-    expect_null(find_predictors(
-      m6,
+  )
+  expect_identical(
+    find_predictors(
+      m3,
+      effects = "all",
+      component = "all",
+      flatten = TRUE
+    ),
+    c("child", "camper", "persons", "livebait")
+  )
+  expect_identical(
+    find_predictors(m3, effects = "random", component = "all"),
+    list(random = "persons", zero_inflated_random = "persons")
+  )
+  expect_identical(
+    find_predictors(
+      m3,
       effects = "random",
       component = "all",
       flatten = TRUE
-    ))
-  })
+    ),
+    "persons"
+  )
 
-  test_that("find_formula", {
-    expect_length(find_formula(m4), 5)
-    expect_equal(
-      find_formula(m4),
-      list(
-        conditional = as.formula("count ~ child + camper"),
-        random = as.formula("~1 | persons"),
-        zero_inflated = as.formula("~child + livebait"),
-        zero_inflated_random = as.formula("~1 | ID"),
-        dispersion = as.formula("~xb")
-      ),
-      ignore_attr = TRUE
-    )
-    expect_equal(find_formula(m6), list(conditional = as.formula("count ~ 1")), ignore_attr = TRUE)
-  })
+  expect_null(find_predictors(
+    m6,
+    effects = "random",
+    component = "all",
+    flatten = TRUE
+  ))
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m4), 5)
+  expect_equal(
+    find_formula(m4),
+    list(
+      conditional = as.formula("count ~ child + camper"),
+      random = as.formula("~1 | persons"),
+      zero_inflated = as.formula("~child + livebait"),
+      zero_inflated_random = as.formula("~1 | ID"),
+      dispersion = as.formula("~xb")
+    ),
+    ignore_attr = TRUE
+  )
+  expect_equal(find_formula(m6), list(conditional = as.formula("count ~ 1")), ignore_attr = TRUE)
+})
 
-  test_that("find_predictors", {
-    expect_identical(
-      find_predictors(m4),
-      list(
-        conditional = c("child", "camper"),
-        zero_inflated = c("child", "livebait"),
-        dispersion = "xb"
-      )
-    )
-    expect_identical(
-      find_predictors(m4, flatten = TRUE),
-      c("child", "camper", "livebait", "xb")
-    )
-    expect_identical(
-      find_predictors(m4, effects = "random"),
-      list(random = "persons", zero_inflated_random = "ID")
-    )
-    expect_identical(
-      find_predictors(m4, effects = "all", flatten = TRUE),
-      c("child", "camper", "persons", "livebait", "ID", "xb")
-    )
-    expect_identical(
-      find_predictors(m4, effects = "all"),
-      list(
-        conditional = c("child", "camper"),
-        random = "persons",
-        zero_inflated = c("child", "livebait"),
-        zero_inflated_random = "ID",
-        dispersion = "xb"
-      )
-    )
-    expect_identical(
-      find_predictors(m4, component = "conditional", flatten = TRUE),
-      c("child", "camper")
-    )
-    expect_identical(
-      find_predictors(m4, component = "conditional", flatten = FALSE),
-      list(conditional = c("child", "camper"))
-    )
-    expect_identical(
-      find_predictors(m4, effects = "random", component = "conditional"),
-      list(random = "persons")
-    )
-    expect_identical(
-      find_predictors(m4, effects = "all", component = "conditional"),
-      list(
-        conditional = c("child", "camper"),
-        random = "persons"
-      )
+test_that("find_predictors", {
+  expect_identical(
+    find_predictors(m4),
+    list(
+      conditional = c("child", "camper"),
+      zero_inflated = c("child", "livebait"),
+      dispersion = "xb"
     )
-    expect_identical(
-      find_predictors(m4, component = "zero_inflated"),
-      list(zero_inflated = c("child", "livebait"))
-    )
-    expect_identical(
-      find_predictors(m4, effects = "random", component = "zero_inflated"),
-      list(zero_inflated_random = "ID")
+  )
+  expect_identical(
+    find_predictors(m4, flatten = TRUE),
+    c("child", "camper", "livebait", "xb")
+  )
+  expect_identical(
+    find_predictors(m4, effects = "random"),
+    list(random = "persons", zero_inflated_random = "ID")
+  )
+  expect_identical(
+    find_predictors(m4, effects = "all", flatten = TRUE),
+    c("child", "camper", "persons", "livebait", "ID", "xb")
+  )
+  expect_identical(
+    find_predictors(m4, effects = "all"),
+    list(
+      conditional = c("child", "camper"),
+      random = "persons",
+      zero_inflated = c("child", "livebait"),
+      zero_inflated_random = "ID",
+      dispersion = "xb"
     )
-    expect_identical(
-      find_predictors(
-        m4,
-        effects = "all",
-        component = "zero_inflated",
-        flatten = TRUE
-      ),
-      c("child", "livebait", "ID")
+  )
+  expect_identical(
+    find_predictors(m4, component = "conditional", flatten = TRUE),
+    c("child", "camper")
+  )
+  expect_identical(
+    find_predictors(m4, component = "conditional", flatten = FALSE),
+    list(conditional = c("child", "camper"))
+  )
+  expect_identical(
+    find_predictors(m4, effects = "random", component = "conditional"),
+    list(random = "persons")
+  )
+  expect_identical(
+    find_predictors(m4, effects = "all", component = "conditional"),
+    list(
+      conditional = c("child", "camper"),
+      random = "persons"
     )
-    expect_identical(
-      find_predictors(m4, component = "dispersion"),
-      list(dispersion = "xb")
+  )
+  expect_identical(
+    find_predictors(m4, component = "zero_inflated"),
+    list(zero_inflated = c("child", "livebait"))
+  )
+  expect_identical(
+    find_predictors(m4, effects = "random", component = "zero_inflated"),
+    list(zero_inflated_random = "ID")
+  )
+  expect_identical(
+    find_predictors(
+      m4,
+      effects = "all",
+      component = "zero_inflated",
+      flatten = TRUE
+    ),
+    c("child", "livebait", "ID")
+  )
+  expect_identical(
+    find_predictors(m4, component = "dispersion"),
+    list(dispersion = "xb")
+  )
+  expect_identical(
+    find_predictors(m4, component = "dispersion", flatten = TRUE),
+    "xb"
+  )
+  expect_null(find_predictors(m4, effects = "random", component = "dispersion"))
+  expect_identical(
+    find_predictors(m4, effects = "all", component = "dispersion"),
+    list(dispersion = "xb")
+  )
+  expect_identical(
+    find_predictors(
+      m4,
+      effects = "all",
+      component = "dispersion",
+      flatten = TRUE
+    ),
+    "xb"
+  )
+})
+
+test_that("find_random", {
+  expect_identical(
+    find_random(m4),
+    list(random = "persons", zero_inflated_random = "ID")
+  )
+  expect_identical(find_random(m4, flatten = TRUE), c("persons", "ID"))
+  expect_null(find_random(m6, flatten = TRUE))
+})
+
+test_that("find_respone", {
+  expect_identical(find_response(m4), "count")
+  expect_identical(find_response(m6), "count")
+})
+
+test_that("find_terms", {
+  expect_identical(
+    find_terms(m4),
+    list(
+      response = "count",
+      conditional = c("child", "camper"),
+      random = "persons",
+      zero_inflated = c("child", "livebait"),
+      zero_inflated_random = "ID",
+      dispersion = "xb"
     )
-    expect_identical(
-      find_predictors(m4, component = "dispersion", flatten = TRUE),
+  )
+  expect_identical(
+    find_terms(m4, flatten = TRUE),
+    c(
+      "count",
+      "child",
+      "camper",
+      "persons",
+      "livebait",
+      "ID",
       "xb"
     )
-    expect_null(find_predictors(m4, effects = "random", component = "dispersion"))
-    expect_identical(
-      find_predictors(m4, effects = "all", component = "dispersion"),
-      list(dispersion = "xb")
+  )
+  expect_identical(find_terms(m6), list(response = "count", conditional = "1"))
+  expect_identical(find_terms(m6, flatten = TRUE), c("count", "1"))
+})
+
+test_that("find_variables", {
+  expect_identical(
+    find_variables(m4),
+    list(
+      response = "count",
+      conditional = c("child", "camper"),
+      random = "persons",
+      zero_inflated = c("child", "livebait"),
+      zero_inflated_random = "ID",
+      dispersion = "xb"
     )
-    expect_identical(
-      find_predictors(
-        m4,
-        effects = "all",
-        component = "dispersion",
-        flatten = TRUE
-      ),
+  )
+  expect_identical(
+    find_variables(m4, flatten = TRUE),
+    c(
+      "count",
+      "child",
+      "camper",
+      "persons",
+      "livebait",
+      "ID",
       "xb"
     )
-  })
-
-  test_that("find_random", {
-    expect_identical(
-      find_random(m4),
-      list(random = "persons", zero_inflated_random = "ID")
-    )
-    expect_identical(find_random(m4, flatten = TRUE), c("persons", "ID"))
-    expect_null(find_random(m6, flatten = TRUE))
-  })
-
-  test_that("find_respone", {
-    expect_identical(find_response(m4), "count")
-    expect_identical(find_response(m6), "count")
-  })
-
-  test_that("find_terms", {
-    expect_identical(
-      find_terms(m4),
-      list(
-        response = "count",
-        conditional = c("child", "camper"),
-        random = "persons",
-        zero_inflated = c("child", "livebait"),
-        zero_inflated_random = "ID",
-        dispersion = "xb"
-      )
-    )
-    expect_identical(
-      find_terms(m4, flatten = TRUE),
-      c(
-        "count",
-        "child",
-        "camper",
-        "persons",
-        "livebait",
-        "ID",
-        "xb"
-      )
-    )
-    expect_identical(find_terms(m6), list(response = "count", conditional = "1"))
-    expect_identical(find_terms(m6, flatten = TRUE), c("count", "1"))
-  })
-
-  test_that("find_variables", {
-    expect_identical(
-      find_variables(m4),
-      list(
-        response = "count",
-        conditional = c("child", "camper"),
-        random = "persons",
-        zero_inflated = c("child", "livebait"),
-        zero_inflated_random = "ID",
-        dispersion = "xb"
-      )
-    )
-    expect_identical(
-      find_variables(m4, flatten = TRUE),
-      c(
-        "count",
-        "child",
-        "camper",
-        "persons",
-        "livebait",
-        "ID",
-        "xb"
-      )
-    )
-    expect_identical(find_variables(m6), list(response = "count"))
-    expect_identical(find_variables(m6, flatten = TRUE), "count")
-  })
-
-  test_that("get_response", {
-    expect_identical(get_response(m4), fish$count)
-    expect_identical(get_response(m6), Salamanders$count)
-  })
-
-  test_that("get_predictors", {
-    expect_identical(
-      colnames(get_predictors(m4)),
-      c("child", "camper", "livebait", "xb")
-    )
-    expect_null(get_predictors(m6, verbose = FALSE))
-  })
-
-  test_that("get_random", {
-    expect_identical(colnames(get_random(m4)), c("persons", "ID"))
-    expect_warning(expect_null(get_random(m6)))
-  })
-
-  test_that("get_data", {
-    expect_identical(
-      colnames(get_data(m4)),
-      c(
-        "count",
-        "child",
-        "camper",
-        "persons",
-        "livebait",
-        "ID",
-        "xb"
-      )
-    )
-    expect_identical(
-      colnames(get_data(m4, effects = "fixed")),
-      c("count", "child", "camper", "livebait", "xb")
-    )
-    expect_identical(colnames(get_data(m4, effects = "random")), c("persons", "ID"))
-    expect_identical(colnames(get_data(m4, component = "zi")), c("child", "livebait", "ID", "count"))
-    expect_identical(colnames(get_data(
-      m4,
-      component = "zi", effects = "fixed"
-    )), c("child", "livebait", "count"))
-    expect_identical(colnames(get_data(
-      m4,
-      component = "zi", effects = "random"
-    )), "ID")
-    expect_identical(
-      colnames(get_data(m4, component = "cond")),
-      c("count", "child", "camper", "persons")
+  )
+  expect_identical(find_variables(m6), list(response = "count"))
+  expect_identical(find_variables(m6, flatten = TRUE), "count")
+})
+
+test_that("get_response", {
+  expect_identical(get_response(m4), fish$count)
+  expect_identical(get_response(m6), Salamanders$count)
+})
+
+test_that("get_predictors", {
+  expect_identical(
+    colnames(get_predictors(m4)),
+    c("child", "camper", "livebait", "xb")
+  )
+  expect_null(get_predictors(m6, verbose = FALSE))
+})
+
+test_that("get_random", {
+  expect_identical(colnames(get_random(m4)), c("persons", "ID"))
+  expect_warning(expect_null(get_random(m6)))
+})
+
+test_that("get_data", {
+  expect_identical(
+    colnames(get_data(m4)),
+    c(
+      "count",
+      "child",
+      "camper",
+      "persons",
+      "livebait",
+      "ID",
+      "xb"
     )
-    expect_identical(colnames(get_data(
-      m4,
-      component = "cond", effects = "fixed"
-    )), c("count", "child", "camper"))
-    expect_identical(colnames(get_data(
-      m4,
-      component = "cond", effects = "random"
-    )), "persons")
-    expect_identical(colnames(get_data(m4, component = "disp")), c("xb", "count"))
-    expect_identical(colnames(get_data(
-      m4,
-      component = "disp", effects = "fixed"
-    )), c("xb", "count"))
-    expect_null(get_data(m4, component = "disp", effects = "random", verbose = FALSE))
-  })
-
-  test_that("find_paramaters", {
-    expect_identical(
-      find_parameters(m4),
-      list(
-        conditional = c("(Intercept)", "child", "camper1"),
-        random = list(persons = "(Intercept)"),
-        zero_inflated = c("(Intercept)", "child", "livebait1"),
-        zero_inflated_random = list(ID = "(Intercept)")
-      )
+  )
+  expect_identical(
+    colnames(get_data(m4, effects = "fixed")),
+    c("count", "child", "camper", "livebait", "xb")
+  )
+  expect_identical(colnames(get_data(m4, effects = "random")), c("persons", "ID"))
+  expect_identical(colnames(get_data(m4, component = "zi")), c("child", "livebait", "ID", "count"))
+  expect_identical(colnames(get_data(
+    m4,
+    component = "zi", effects = "fixed"
+  )), c("child", "livebait", "count"))
+  expect_identical(colnames(get_data(
+    m4,
+    component = "zi", effects = "random"
+  )), "ID")
+  expect_identical(
+    colnames(get_data(m4, component = "cond")),
+    c("count", "child", "camper", "persons")
+  )
+  expect_identical(colnames(get_data(
+    m4,
+    component = "cond", effects = "fixed"
+  )), c("count", "child", "camper"))
+  expect_identical(colnames(get_data(
+    m4,
+    component = "cond", effects = "random"
+  )), "persons")
+  expect_identical(colnames(get_data(m4, component = "disp")), c("xb", "count"))
+  expect_identical(colnames(get_data(
+    m4,
+    component = "disp", effects = "fixed"
+  )), c("xb", "count"))
+  expect_null(get_data(m4, component = "disp", effects = "random", verbose = FALSE))
+})
+
+test_that("find_paramaters", {
+  expect_identical(
+    find_parameters(m4),
+    list(
+      conditional = c("(Intercept)", "child", "camper1"),
+      random = list(persons = "(Intercept)"),
+      zero_inflated = c("(Intercept)", "child", "livebait1"),
+      zero_inflated_random = list(ID = "(Intercept)")
     )
+  )
 
-    expect_identical(
-      find_parameters(m4, flatten = TRUE),
-      c("(Intercept)", "child", "camper1", "livebait1")
-    )
-    expect_identical(
-      find_parameters(m6),
-      list(
-        conditional = "(Intercept)",
-        zero_inflated = "(Intercept)"
-      )
+  expect_identical(
+    find_parameters(m4, flatten = TRUE),
+    c("(Intercept)", "child", "camper1", "livebait1")
+  )
+  expect_identical(
+    find_parameters(m6),
+    list(
+      conditional = "(Intercept)",
+      zero_inflated = "(Intercept)"
     )
+  )
 
-    expect_identical(
-      find_parameters(m3),
-      list(
-        conditional = c("(Intercept)", "child", "camper1"),
-        random = list(persons = "(Intercept)"),
-        zero_inflated = c("(Intercept)", "child", "livebait1"),
-        zero_inflated_random = list(persons = "(Intercept)")
-      )
+  expect_identical(
+    find_parameters(m3),
+    list(
+      conditional = c("(Intercept)", "child", "camper1"),
+      random = list(persons = "(Intercept)"),
+      zero_inflated = c("(Intercept)", "child", "livebait1"),
+      zero_inflated_random = list(persons = "(Intercept)")
     )
+  )
 
-    expect_identical(
-      find_parameters(m3),
-      list(
-        conditional = c("(Intercept)", "child", "camper1"),
-        random = list(persons = "(Intercept)"),
-        zero_inflated = c("(Intercept)", "child", "livebait1"),
-        zero_inflated_random = list(persons = "(Intercept)")
-      )
+  expect_identical(
+    find_parameters(m3),
+    list(
+      conditional = c("(Intercept)", "child", "camper1"),
+      random = list(persons = "(Intercept)"),
+      zero_inflated = c("(Intercept)", "child", "livebait1"),
+      zero_inflated_random = list(persons = "(Intercept)")
     )
+  )
 
-    expect_identical(
-      find_parameters(m3, effects = "fixed"),
-      list(
-        conditional = c("(Intercept)", "child", "camper1"),
-        zero_inflated = c("(Intercept)", "child", "livebait1")
-      )
+  expect_identical(
+    find_parameters(m3, effects = "fixed"),
+    list(
+      conditional = c("(Intercept)", "child", "camper1"),
+      zero_inflated = c("(Intercept)", "child", "livebait1")
     )
+  )
 
-    expect_identical(
-      find_parameters(m3, effects = "random", component = "zi"),
-      list(zero_inflated_random = list(persons = "(Intercept)"))
-    )
+  expect_identical(
+    find_parameters(m3, effects = "random", component = "zi"),
+    list(zero_inflated_random = list(persons = "(Intercept)"))
+  )
 
-    expect_identical(
-      find_parameters(
-        m3,
-        effects = "fixed",
-        component = "zi",
-        flatten = TRUE
-      ),
-      c("(Intercept)", "child", "livebait1")
-    )
-  })
+  expect_identical(
+    find_parameters(
+      m3,
+      effects = "fixed",
+      component = "zi",
+      flatten = TRUE
+    ),
+    c("(Intercept)", "child", "livebait1")
+  )
+})
 
 
-  test_that("get_paramaters", {
-    expect_identical(nrow(get_parameters(m4)), 6L)
-    expect_identical(
-      colnames(get_parameters(m4)),
-      c("Parameter", "Estimate", "Component")
-    )
-    expect_identical(
-      get_parameters(m4)$Parameter,
-      c(
-        "(Intercept)",
-        "child",
-        "camper1",
-        "(Intercept)",
-        "child",
-        "livebait1"
-      )
-    )
-    expect_identical(
-      get_parameters(m4)$Component,
-      c(
-        "conditional",
-        "conditional",
-        "conditional",
-        "zero_inflated",
-        "zero_inflated",
-        "zero_inflated"
-      )
+test_that("get_paramaters", {
+  expect_identical(nrow(get_parameters(m4)), 6L)
+  expect_identical(
+    colnames(get_parameters(m4)),
+    c("Parameter", "Estimate", "Component")
+  )
+  expect_identical(
+    get_parameters(m4)$Parameter,
+    c(
+      "(Intercept)",
+      "child",
+      "camper1",
+      "(Intercept)",
+      "child",
+      "livebait1"
     )
-    expect_identical(
-      get_parameters(m6)$Parameter,
-      c("(Intercept)", "(Intercept)")
+  )
+  expect_identical(
+    get_parameters(m4)$Component,
+    c(
+      "conditional",
+      "conditional",
+      "conditional",
+      "zero_inflated",
+      "zero_inflated",
+      "zero_inflated"
     )
+  )
+  expect_identical(
+    get_parameters(m6)$Parameter,
+    c("(Intercept)", "(Intercept)")
+  )
 
-    expect_identical(
-      get_parameters(m2)$Parameter,
-      c("(Intercept)", "child", "camper1")
-    )
+  expect_identical(
+    get_parameters(m2)$Parameter,
+    c("(Intercept)", "child", "camper1")
+  )
 
-    expect_identical(
-      get_parameters(m2, component = "all")$Parameter,
-      c("(Intercept)", "child", "camper1")
-    )
+  expect_identical(
+    get_parameters(m2, component = "all")$Parameter,
+    c("(Intercept)", "child", "camper1")
+  )
 
-    expect_null(get_parameters(m2, component = "zi"))
-  })
-
-  test_that("linkfun", {
-    expect_false(is.null(link_function(m1)))
-    expect_false(is.null(link_function(m2)))
-    expect_false(is.null(link_function(m3)))
-    expect_false(is.null(link_function(m4)))
-  })
-
-  test_that("is_multivariate", {
-    expect_false(is_multivariate(m1))
-    expect_false(is_multivariate(m2))
-    expect_false(is_multivariate(m3))
-    expect_false(is_multivariate(m4))
-  })
-
-  data("Salamanders")
-  mpred <- glmmTMB(
-    count ~ mined + (1 | site),
-    zi = ~mined,
-    family = poisson, data = Salamanders
-  )
-
-  test_that("get_predicted with new levels", {
-    pr <- get_predicted(mpred, data = head(Salamanders), allow.new.levels = TRUE)
-    expect_equal(as.vector(pr), c(0.252, 0.39207, 0.21119, 2.20128, 2.39424, 2.28901), tolerance = 1e-3)
-  })
-
-  # test_that("get_variance", {
-  #
-  #   expect_warning(expect_equal(get_variance(m5), list(
-  #     var.fixed = 0.32588694431268194762,
-  #     var.random = 0.07842738279575413307,
-  #     var.residual = 0.41218000030914692111,
-  #     var.distribution = 0.41218000030914692111,
-  #     var.dispersion = 0,
-  #     var.intercept = c(site = 0.07842738279575474369)
-  #   ),
-  #   tolerance = 1e-3))
-  #
-  #   expect_warning(expect_equal(get_variance_fixed(m1), c(var.fixed = 1.09712435712435052437), tolerance = 1e-3))
-  #   expect_warning(expect_equal(get_variance_random(m1), c(var.random = 0.86712737445492238386), tolerance = 1e-3))
-  #   expect_warning(expect_equal(get_variance_residual(m1), c(var.residual = 0.02634500773355940087 ), tolerance = 1e-3))
-  #   expect_warning(expect_equal(get_variance_distribution(m1), c(var.distribution = 0.02634500773355940087 ), tolerance = 1e-3))
-  #   expect_warning(expect_equal(get_variance_dispersion(m1), c(var.dispersion = 0), tolerance = 1e-3))
-  # })
-
-  test_that("find_algorithm", {
-    expect_identical(
-      find_algorithm(m1),
-      list(algorithm = "ML", optimizer = "nlminb")
-    )
-  })
+  expect_null(get_parameters(m2, component = "zi"))
+})
+
+test_that("linkfun", {
+  expect_false(is.null(link_function(m1)))
+  expect_false(is.null(link_function(m2)))
+  expect_false(is.null(link_function(m3)))
+  expect_false(is.null(link_function(m4)))
+})
+
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1))
+  expect_false(is_multivariate(m2))
+  expect_false(is_multivariate(m3))
+  expect_false(is_multivariate(m4))
+})
+
+data(Salamanders, package = "glmmTMB")
+mpred <- glmmTMB::glmmTMB(
+  count ~ mined + (1 | site),
+  zi = ~mined,
+  family = poisson, data = Salamanders
+)
+
+test_that("get_predicted with new levels", {
+  pr <- get_predicted(mpred, data = head(Salamanders), allow.new.levels = TRUE)
+  expect_equal(as.vector(pr), c(0.252, 0.39207, 0.21119, 2.20128, 2.39424, 2.28901), tolerance = 1e-3)
+})
+
+# test_that("get_variance", {
+#
+#   expect_warning(expect_equal(get_variance(m5), list(
+#     var.fixed = 0.32588694431268194762,
+#     var.random = 0.07842738279575413307,
+#     var.residual = 0.41218000030914692111,
+#     var.distribution = 0.41218000030914692111,
+#     var.dispersion = 0,
+#     var.intercept = c(site = 0.07842738279575474369)
+#   ),
+#   tolerance = 1e-3))
+#
+#   expect_warning(expect_equal(get_variance_fixed(m1), c(var.fixed = 1.09712435712435052437), tolerance = 1e-3))
+#   expect_warning(expect_equal(get_variance_random(m1), c(var.random = 0.86712737445492238386), tolerance = 1e-3))
+#   expect_warning(expect_equal(get_variance_residual(m1), c(var.residual = 0.02634500773355940087 ), tolerance = 1e-3))
+#   expect_warning(expect_equal(get_variance_distribution(m1), c(var.distribution = 0.02634500773355940087 ), tolerance = 1e-3))
+#   expect_warning(expect_equal(get_variance_dispersion(m1), c(var.dispersion = 0), tolerance = 1e-3))
+# })
+
+test_that("find_algorithm", {
+  expect_identical(
+    find_algorithm(m1),
+    list(algorithm = "ML", optimizer = "nlminb")
+  )
+})
 
-  test_that("find_random_slopes", {
-    skip_on_cran()
+test_that("find_random_slopes", {
+  skip_on_cran()
 
 
-    expect_null(find_random_slopes(m6))
+  expect_null(find_random_slopes(m6))
 
-    expect_identical(
-      find_random_slopes(m7),
-      list(
-        random = "xb",
-        zero_inflated_random = c("zg", "nofish")
-      )
+  expect_identical(
+    find_random_slopes(m7),
+    list(
+      random = "xb",
+      zero_inflated_random = c("zg", "nofish")
     )
-  })
-
-  test_that("clean_parameters", {
-    expect_identical(
-      clean_parameters(m1),
-      structure(
-        list(
-          Parameter = c(
-            "(Intercept)",
-            "child",
-            "camper1",
-            "(Intercept)",
-            "(Intercept)",
-            "child",
-            "camper1",
-            "(Intercept)"
-          ),
-          Effects = c(
-            "fixed",
-            "fixed",
-            "fixed",
-            "random",
-            "fixed",
-            "fixed",
-            "fixed",
-            "random"
-          ),
-          Component = c(
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "zero_inflated",
-            "zero_inflated",
-            "zero_inflated",
-            "zero_inflated"
-          ),
-          Group = c("", "", "", "persons", "", "", "", "persons"),
-          Cleaned_Parameter = c(
-            "(Intercept)",
-            "child",
-            "camper1",
-            "(Intercept)",
-            "(Intercept)",
-            "child",
-            "camper1",
-            "(Intercept)"
-          )
+  )
+})
+
+test_that("clean_parameters", {
+  expect_identical(
+    clean_parameters(m1),
+    structure(
+      list(
+        Parameter = c(
+          "(Intercept)",
+          "child",
+          "camper1",
+          "(Intercept)",
+          "(Intercept)",
+          "child",
+          "camper1",
+          "(Intercept)"
         ),
-        class = c("clean_parameters", "data.frame"),
-        row.names = c(NA, -8L)
-      )
-    )
-  })
-
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "z-statistic")
-    expect_identical(find_statistic(m2), "z-statistic")
-    expect_identical(find_statistic(m3), "z-statistic")
-    expect_identical(find_statistic(m4), "z-statistic")
-    expect_identical(find_statistic(m5), "z-statistic")
-    expect_identical(find_statistic(m6), "z-statistic")
-    expect_identical(find_statistic(m7), "z-statistic")
-  })
-
-
-  # dispersion model, example from ?glmmTMB
-  sim1 <- function(nfac = 40, nt = 100, facsd = 0.1, tsd = 0.15, mu = 0, residsd = 1) {
-    dat <- expand.grid(fac = factor(letters[1:nfac]), t = 1:nt)
-    n <- nrow(dat)
-    dat$REfac <- rnorm(nfac, sd = facsd)[dat$fac]
-    dat$REt <- rnorm(nt, sd = tsd)[dat$t]
-    dat$x <- rnorm(n, mean = mu, sd = residsd) + dat$REfac + dat$REt
-    dat
-  }
-  set.seed(101)
-  d1 <- sim1(mu = 100, residsd = 10)
-  d2 <- sim1(mu = 200, residsd = 5)
-  d1$sd <- "ten"
-  d2$sd <- "five"
-  dat <- rbind(d1, d2)
-  m0 <- glmmTMB(x ~ sd + (1 | t), dispformula = ~sd, data = dat)
-
-  test_that("get_paramaters", {
-    expect_identical(nrow(get_parameters(m0)), 4L)
-    expect_identical(
-      colnames(get_parameters(m0)),
-      c("Parameter", "Estimate", "Component")
-    )
-    expect_identical(
-      get_parameters(m0)$Parameter,
-      c(
-        "(Intercept)",
-        "sdten",
-        "(Intercept)",
-        "sdten"
-      )
-    )
-    expect_equal(
-      get_parameters(m0)$Estimate,
-      c(200.03431, -99.71491, 3.20287, 1.38648),
-      tolerance = 1e-3
-    )
-    expect_identical(
-      get_parameters(m0)$Component,
-      c("conditional", "conditional", "dispersion", "dispersion")
+        Effects = c(
+          "fixed",
+          "fixed",
+          "fixed",
+          "random",
+          "fixed",
+          "fixed",
+          "fixed",
+          "random"
+        ),
+        Component = c(
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "zero_inflated",
+          "zero_inflated",
+          "zero_inflated",
+          "zero_inflated"
+        ),
+        Group = c("", "", "", "persons", "", "", "", "persons"),
+        Cleaned_Parameter = c(
+          "(Intercept)",
+          "child",
+          "camper1",
+          "(Intercept)",
+          "(Intercept)",
+          "child",
+          "camper1",
+          "(Intercept)"
+        )
+      ),
+      class = c("clean_parameters", "data.frame"),
+      row.names = c(NA, -8L)
     )
-  })
-
-  if (packageVersion("glmmTMB") > "1.1.4") {
-    test_that("get_predicted", {
-      # response
-      x <- get_predicted(m1, predict = "expectation", verbose = FALSE, include_random = TRUE)
-      y <- get_predicted(m1, predict = "response", include_random = TRUE)
-      z <- predict(m1, type = "response")
-      expect_equal(x, y, ignore_attr = TRUE)
-      expect_equal(x, z, ignore_attr = TRUE)
-      expect_equal(y, z, ignore_attr = TRUE)
-      get_predicted(m1, predict = NULL, type = "response")
-
-      # should be the same, when include_random = "default"
-      x <- get_predicted(m1, predict = "expectation", verbose = FALSE)
-      y <- get_predicted(m1, predict = "response")
-      z <- predict(m1, type = "response")
-      expect_equal(x, y, ignore_attr = TRUE)
-      expect_equal(x, z, ignore_attr = TRUE)
-      expect_equal(y, z, ignore_attr = TRUE)
-
-
-      # link
-      x <- get_predicted(m1, predict = "link", include_random = TRUE)
-      y <- get_predicted(m1, predict = NULL, type = "link", include_random = TRUE)
-      z <- predict(m1, type = "link")
-      expect_equal(x, y, ignore_attr = TRUE)
-      expect_equal(y, z, ignore_attr = TRUE)
-      expect_equal(x, z, ignore_attr = TRUE)
-
-      # unsupported: zprob
-      x <- suppressWarnings(get_predicted(m1, predict = "zprob", include_random = TRUE))
-      y <- get_predicted(m1, predict = NULL, type = "zprob", include_random = TRUE)
-      z <- predict(m1, type = "zprob")
-      expect_identical(x, y)
-      expect_equal(x, z, ignore_attr = TRUE)
-
-      ## TODO
-
-      # not official supported raise warning
-      # expect_warning(get_predicted(m1, predict = "zprob"))
-      # expect_warning(get_predicted(m1, predict = "zprob", verbose = FALSE), NA)
-      # the second warning is raised for zero-inflation models only. remove when
-      # the zprob correction is implemented
-      expect_warning(get_predicted(m1, predict = "prediction"))
-      expect_warning(get_predicted(m1, predict = "classification"))
-    })
-  }
+  )
+})
+
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "z-statistic")
+  expect_identical(find_statistic(m2), "z-statistic")
+  expect_identical(find_statistic(m3), "z-statistic")
+  expect_identical(find_statistic(m4), "z-statistic")
+  expect_identical(find_statistic(m5), "z-statistic")
+  expect_identical(find_statistic(m6), "z-statistic")
+  expect_identical(find_statistic(m7), "z-statistic")
+})
+
+
+# dispersion model, example from ?glmmTMB
+sim1 <- function(nfac = 40, nt = 100, facsd = 0.1, tsd = 0.15, mu = 0, residsd = 1) {
+  dat <- expand.grid(fac = factor(letters[1:nfac]), t = 1:nt)
+  n <- nrow(dat)
+  dat$REfac <- rnorm(nfac, sd = facsd)[dat$fac]
+  dat$REt <- rnorm(nt, sd = tsd)[dat$t]
+  dat$x <- rnorm(n, mean = mu, sd = residsd) + dat$REfac + dat$REt
+  dat
 }
+set.seed(101)
+d1 <- sim1(mu = 100, residsd = 10)
+d2 <- sim1(mu = 200, residsd = 5)
+d1$sd <- "ten"
+d2$sd <- "five"
+dat <- rbind(d1, d2)
+m0 <- glmmTMB::glmmTMB(x ~ sd + (1 | t), dispformula = ~sd, data = dat)
+
+test_that("get_paramaters", {
+  expect_identical(nrow(get_parameters(m0)), 4L)
+  expect_identical(
+    colnames(get_parameters(m0)),
+    c("Parameter", "Estimate", "Component")
+  )
+  expect_identical(
+    get_parameters(m0)$Parameter,
+    c(
+      "(Intercept)",
+      "sdten",
+      "(Intercept)",
+      "sdten"
+    )
+  )
+  expect_equal(
+    get_parameters(m0)$Estimate,
+    c(200.03431, -99.71491, 3.20287, 1.38648),
+    tolerance = 1e-3
+  )
+  expect_identical(
+    get_parameters(m0)$Component,
+    c("conditional", "conditional", "dispersion", "dispersion")
+  )
+})
+
+skip_if_not(packageVersion("glmmTMB") > "1.1.4")
+
+test_that("get_predicted", {
+  # response
+  x <- get_predicted(m1, predict = "expectation", verbose = FALSE, include_random = TRUE)
+  y <- get_predicted(m1, predict = "response", include_random = TRUE)
+  z <- predict(m1, type = "response")
+  expect_equal(x, y, ignore_attr = TRUE)
+  expect_equal(x, z, ignore_attr = TRUE)
+  expect_equal(y, z, ignore_attr = TRUE)
+  get_predicted(m1, predict = NULL, type = "response")
+
+  # should be the same, when include_random = "default"
+  x <- get_predicted(m1, predict = "expectation", verbose = FALSE)
+  y <- get_predicted(m1, predict = "response")
+  z <- predict(m1, type = "response")
+  expect_equal(x, y, ignore_attr = TRUE)
+  expect_equal(x, z, ignore_attr = TRUE)
+  expect_equal(y, z, ignore_attr = TRUE)
+
+
+  # link
+  x <- get_predicted(m1, predict = "link", include_random = TRUE)
+  y <- get_predicted(m1, predict = NULL, type = "link", include_random = TRUE)
+  z <- predict(m1, type = "link")
+  expect_equal(x, y, ignore_attr = TRUE)
+  expect_equal(y, z, ignore_attr = TRUE)
+  expect_equal(x, z, ignore_attr = TRUE)
+
+  # unsupported: zprob
+  x <- suppressWarnings(get_predicted(m1, predict = "zprob", include_random = TRUE))
+  y <- get_predicted(m1, predict = NULL, type = "zprob", include_random = TRUE)
+  z <- predict(m1, type = "zprob")
+  expect_identical(x, y)
+  expect_equal(x, z, ignore_attr = TRUE)
+
+  ## TODO
+
+  # not official supported raise warning
+  # expect_warning(get_predicted(m1, predict = "zprob"))
+  # expect_warning(get_predicted(m1, predict = "zprob", verbose = FALSE), NA)
+  # the second warning is raised for zero-inflation models only. remove when
+  # the zprob correction is implemented
+  expect_warning(get_predicted(m1, predict = "prediction"))
+  expect_warning(get_predicted(m1, predict = "classification"))
+})
diff --git a/tests/testthat/test-glmrob_base.R b/tests/testthat/test-glmrob_base.R
index 909020ed1..915250eed 100644
--- a/tests/testthat/test-glmrob_base.R
+++ b/tests/testthat/test-glmrob_base.R
@@ -1,126 +1,126 @@
-if (skip_if_not_or_load_if_installed("robustbase")) {
-  data(carrots)
-
-  m1 <- glmrob(
-    cbind(success, total - success) ~ logdose + block,
-    family = binomial,
-    data = carrots,
-    method = "Mqle",
-    control = glmrobMqle.control(tcc = 1.2)
+skip_if_not_installed("robustbase")
+
+data(carrots, package = "robustbase")
+
+m1 <- robustbase::glmrob(
+  cbind(success, total - success) ~ logdose + block,
+  family = binomial,
+  data = carrots,
+  method = "Mqle",
+  control = robustbase::glmrobMqle.control(tcc = 1.2)
+)
+
+test_that("model_info", {
+  expect_true(model_info(m1)$is_binomial)
+  expect_false(model_info(m1)$is_linear)
+})
+
+test_that("find_predictors", {
+  expect_identical(find_predictors(m1), list(conditional = c("logdose", "block")))
+  expect_identical(find_predictors(m1, flatten = TRUE), c("logdose", "block"))
+  expect_null(find_predictors(m1, effects = "random"))
+})
+
+test_that("find_random", {
+  expect_null(find_random(m1))
+})
+
+test_that("get_random", {
+  expect_warning(get_random(m1))
+})
+
+test_that("find_response", {
+  expect_identical(find_response(m1), "cbind(success, total - success)")
+  expect_identical(find_response(m1, combine = FALSE), c("success", "total"))
+})
+
+test_that("get_response", {
+  expect_equal(get_response(m1), carrots[, c("success", "total")])
+})
+
+test_that("get_predictors", {
+  expect_equal(colnames(get_predictors(m1)), c("logdose", "block"))
+})
+
+test_that("get_data", {
+  expect_equal(nrow(get_data(m1)), 24)
+  expect_equal(
+    colnames(get_data(m1)),
+    c("success", "total", "logdose", "block")
   )
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1), 1)
+  expect_equal(
+    find_formula(m1),
+    list(
+      conditional = as.formula("cbind(success, total - success) ~ logdose + block")
+    ),
+    ignore_attr = TRUE
+  )
+})
 
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_binomial)
-    expect_false(model_info(m1)$is_linear)
-  })
-
-  test_that("find_predictors", {
-    expect_identical(find_predictors(m1), list(conditional = c("logdose", "block")))
-    expect_identical(find_predictors(m1, flatten = TRUE), c("logdose", "block"))
-    expect_null(find_predictors(m1, effects = "random"))
-  })
-
-  test_that("find_random", {
-    expect_null(find_random(m1))
-  })
-
-  test_that("get_random", {
-    expect_warning(get_random(m1))
-  })
-
-  test_that("find_response", {
-    expect_identical(find_response(m1), "cbind(success, total - success)")
-    expect_identical(find_response(m1, combine = FALSE), c("success", "total"))
-  })
-
-  test_that("get_response", {
-    expect_equal(get_response(m1), carrots[, c("success", "total")])
-  })
-
-  test_that("get_predictors", {
-    expect_equal(colnames(get_predictors(m1)), c("logdose", "block"))
-  })
-
-  test_that("get_data", {
-    expect_equal(nrow(get_data(m1)), 24)
-    expect_equal(
-      colnames(get_data(m1)),
-      c("success", "total", "logdose", "block")
-    )
-  })
-
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 1)
-    expect_equal(
-      find_formula(m1),
-      list(
-        conditional = as.formula("cbind(success, total - success) ~ logdose + block")
-      ),
-      ignore_attr = TRUE
-    )
-  })
-
-  test_that("find_terms", {
-    expect_equal(
-      find_terms(m1),
-      list(
-        response = "cbind(success, total - success)",
-        conditional = c("logdose", "block")
-      )
-    )
-    expect_equal(
-      find_terms(m1, flatten = TRUE),
-      c("cbind(success, total - success)", "logdose", "block")
-    )
-  })
-
-  test_that("find_variables", {
-    expect_equal(find_variables(m1), list(
-      response = c("success", "total"),
+test_that("find_terms", {
+  expect_equal(
+    find_terms(m1),
+    list(
+      response = "cbind(success, total - success)",
       conditional = c("logdose", "block")
-    ))
-    expect_equal(
-      find_variables(m1, flatten = TRUE),
-      c("success", "total", "logdose", "block")
     )
-  })
-
-  test_that("n_obs", {
-    expect_equal(n_obs(m1), 24)
-    expect_equal(n_obs(m1, disaggregate = TRUE), 900)
-  })
-
-  test_that("link_function", {
-    expect_equal(link_function(m1)(0.2), qlogis(0.2), tolerance = 1e-5)
-  })
-
-  test_that("link_inverse", {
-    expect_equal(link_inverse(m1)(0.2), plogis(0.2), tolerance = 1e-5)
-  })
-
-  test_that("find_parameters", {
-    expect_equal(
-      find_parameters(m1),
-      list(
-        conditional = c("(Intercept)", "logdose", "blockB2", "blockB3")
-      )
-    )
-    expect_equal(nrow(get_parameters(m1)), 4)
-    expect_equal(
-      get_parameters(m1)$Parameter,
-      c("(Intercept)", "logdose", "blockB2", "blockB3")
+  )
+  expect_equal(
+    find_terms(m1, flatten = TRUE),
+    c("cbind(success, total - success)", "logdose", "block")
+  )
+})
+
+test_that("find_variables", {
+  expect_equal(find_variables(m1), list(
+    response = c("success", "total"),
+    conditional = c("logdose", "block")
+  ))
+  expect_equal(
+    find_variables(m1, flatten = TRUE),
+    c("success", "total", "logdose", "block")
+  )
+})
+
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 24)
+  expect_equal(n_obs(m1, disaggregate = TRUE), 900)
+})
+
+test_that("link_function", {
+  expect_equal(link_function(m1)(0.2), qlogis(0.2), tolerance = 1e-5)
+})
+
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), plogis(0.2), tolerance = 1e-5)
+})
+
+test_that("find_parameters", {
+  expect_equal(
+    find_parameters(m1),
+    list(
+      conditional = c("(Intercept)", "logdose", "blockB2", "blockB3")
     )
-  })
+  )
+  expect_equal(nrow(get_parameters(m1)), 4)
+  expect_equal(
+    get_parameters(m1)$Parameter,
+    c("(Intercept)", "logdose", "blockB2", "blockB3")
+  )
+})
 
-  test_that("is_multivariate", {
-    expect_false(is_multivariate(m1))
-  })
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1))
+})
 
-  test_that("find_algorithm", {
-    expect_equal(find_algorithm(m1), list(algorithm = "Mqle"))
-  })
+test_that("find_algorithm", {
+  expect_equal(find_algorithm(m1), list(algorithm = "Mqle"))
+})
 
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "z-statistic")
-  })
-}
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "z-statistic")
+})
diff --git a/tests/testthat/test-gls.R b/tests/testthat/test-gls.R
index 98e1bf81a..628af680a 100644
--- a/tests/testthat/test-gls.R
+++ b/tests/testthat/test-gls.R
@@ -1,142 +1,142 @@
-if (skip_if_not_or_load_if_installed("nlme")) {
-  data(Ovary)
-  m1 <- gls(follicles ~ sin(2 * pi * Time) + cos(2 * pi * Time),
-    Ovary,
-    correlation = corAR1(form = ~ 1 | Mare)
+skip_if_not_installed("nlme")
+
+data(Ovary, package = "nlme")
+m1 <- nlme::gls(follicles ~ sin(2 * pi * Time) + cos(2 * pi * Time),
+  Ovary,
+  correlation = nlme::corAR1(form = ~ 1 | Mare)
+)
+
+cr <<- nlme::corAR1(form = ~ 1 | Mare)
+m2 <- nlme::gls(follicles ~ sin(2 * pi * Time) + cos(2 * pi * Time), Ovary,
+  correlation = cr
+)
+
+set.seed(123)
+d <- Ovary
+d$x1 <- runif(nrow(d))
+d$x2 <- sample(1:10, size = nrow(d), replace = TRUE)
+m3 <- nlme::gls(follicles ~ Time + x1 + x2,
+  d,
+  correlation = nlme::corAR1(form = ~ 1 | Mare)
+)
+
+test_that("model_info", {
+  expect_true(model_info(m1)$is_linear)
+})
+
+test_that("find_predictors", {
+  expect_identical(
+    find_predictors(m1),
+    list(conditional = "Time", correlation = "Mare")
   )
-
-  cr <<- corAR1(form = ~ 1 | Mare)
-  m2 <- gls(follicles ~ sin(2 * pi * Time) + cos(2 * pi * Time), Ovary,
-    correlation = cr
+  expect_identical(find_predictors(m1, flatten = TRUE), c("Time", "Mare"))
+  expect_null(find_predictors(m1, effects = "random"))
+})
+
+test_that("find_response", {
+  expect_identical(find_response(m1), "follicles")
+})
+
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
+})
+
+test_that("get_data", {
+  expect_equal(nrow(get_data(m1)), 308)
+  expect_equal(colnames(get_data(m1)), c("follicles", "Time", "Mare"))
+})
+
+test_that("get_df", {
+  expect_equal(get_df(m1, type = "residual"), 305, ignore_attr = TRUE)
+  expect_equal(get_df(m1, type = "normal"), Inf, ignore_attr = TRUE)
+  expect_equal(get_df(m1, type = "wald"), 305, ignore_attr = TRUE)
+  expect_equal(get_df(m3, type = "residual"), 304, ignore_attr = TRUE)
+  expect_equal(get_df(m3, type = "normal"), Inf, ignore_attr = TRUE)
+  expect_equal(get_df(m3, type = "wald"), 304, ignore_attr = TRUE)
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1), 2)
+  expect_equal(
+    find_formula(m1),
+    list(
+      conditional = as.formula("follicles ~ sin(2 * pi * Time) + cos(2 * pi * Time)"),
+      correlation = as.formula("~1 | Mare")
+    ),
+    ignore_attr = TRUE
   )
-
-  set.seed(123)
-  d <- Ovary
-  d$x1 <- runif(nrow(d))
-  d$x2 <- sample(1:10, size = nrow(d), replace = TRUE)
-  m3 <- gls(follicles ~ Time + x1 + x2,
-    d,
-    correlation = corAR1(form = ~ 1 | Mare)
+  expect_equal(
+    find_formula(m2),
+    list(
+      conditional = as.formula("follicles ~ sin(2 * pi * Time) + cos(2 * pi * Time)"),
+      correlation = as.formula("~1 | Mare")
+    ),
+    ignore_attr = TRUE
   )
-
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_linear)
-  })
-
-  test_that("find_predictors", {
-    expect_identical(
-      find_predictors(m1),
-      list(conditional = "Time", correlation = "Mare")
-    )
-    expect_identical(find_predictors(m1, flatten = TRUE), c("Time", "Mare"))
-    expect_null(find_predictors(m1, effects = "random"))
-  })
-
-  test_that("find_response", {
-    expect_identical(find_response(m1), "follicles")
-  })
-
-  test_that("link_inverse", {
-    expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
-  })
-
-  test_that("get_data", {
-    expect_equal(nrow(get_data(m1)), 308)
-    expect_equal(colnames(get_data(m1)), c("follicles", "Time", "Mare"))
-  })
-
-  test_that("get_df", {
-    expect_equal(get_df(m1, type = "residual"), 305, ignore_attr = TRUE)
-    expect_equal(get_df(m1, type = "normal"), Inf, ignore_attr = TRUE)
-    expect_equal(get_df(m1, type = "wald"), 305, ignore_attr = TRUE)
-    expect_equal(get_df(m3, type = "residual"), 304, ignore_attr = TRUE)
-    expect_equal(get_df(m3, type = "normal"), Inf, ignore_attr = TRUE)
-    expect_equal(get_df(m3, type = "wald"), 304, ignore_attr = TRUE)
-  })
-
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 2)
-    expect_equal(
-      find_formula(m1),
-      list(
-        conditional = as.formula("follicles ~ sin(2 * pi * Time) + cos(2 * pi * Time)"),
-        correlation = as.formula("~1 | Mare")
-      ),
-      ignore_attr = TRUE
-    )
-    expect_equal(
-      find_formula(m2),
-      list(
-        conditional = as.formula("follicles ~ sin(2 * pi * Time) + cos(2 * pi * Time)"),
-        correlation = as.formula("~1 | Mare")
-      ),
-      ignore_attr = TRUE
-    )
-  })
-
-  test_that("find_terms", {
-    expect_equal(
-      find_terms(m1),
-      list(
-        response = "follicles",
-        conditional = c("sin(2 * pi * Time)", "cos(2 * pi * Time)"),
-        correlation = c("1", "Mare")
-      )
-    )
-    expect_equal(
-      find_terms(m1, flatten = TRUE),
-      c(
-        "follicles",
-        "sin(2 * pi * Time)",
-        "cos(2 * pi * Time)",
-        "1",
-        "Mare"
-      )
-    )
-  })
-
-  test_that("find_variables", {
-    expect_equal(
-      find_variables(m1),
-      list(
-        response = "follicles",
-        conditional = "Time",
-        correlation = "Mare"
-      )
+})
+
+test_that("find_terms", {
+  expect_equal(
+    find_terms(m1),
+    list(
+      response = "follicles",
+      conditional = c("sin(2 * pi * Time)", "cos(2 * pi * Time)"),
+      correlation = c("1", "Mare")
     )
-    expect_equal(
-      find_variables(m1, flatten = TRUE),
-      c("follicles", "Time", "Mare")
+  )
+  expect_equal(
+    find_terms(m1, flatten = TRUE),
+    c(
+      "follicles",
+      "sin(2 * pi * Time)",
+      "cos(2 * pi * Time)",
+      "1",
+      "Mare"
     )
-  })
-
-  test_that("n_obs", {
-    expect_equal(n_obs(m1), 308)
-  })
-
-  test_that("linkfun", {
-    expect_false(is.null(link_function(m1)))
-  })
-
-  test_that("find_parameters", {
-    expect_equal(
-      find_parameters(m1),
-      list(
-        conditional = c("(Intercept)", "sin(2 * pi * Time)", "cos(2 * pi * Time)")
-      )
+  )
+})
+
+test_that("find_variables", {
+  expect_equal(
+    find_variables(m1),
+    list(
+      response = "follicles",
+      conditional = "Time",
+      correlation = "Mare"
     )
-    expect_equal(nrow(get_parameters(m1)), 3)
-    expect_equal(
-      get_parameters(m1)$Parameter,
-      c("(Intercept)", "sin(2 * pi * Time)", "cos(2 * pi * Time)")
+  )
+  expect_equal(
+    find_variables(m1, flatten = TRUE),
+    c("follicles", "Time", "Mare")
+  )
+})
+
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 308)
+})
+
+test_that("linkfun", {
+  expect_false(is.null(link_function(m1)))
+})
+
+test_that("find_parameters", {
+  expect_equal(
+    find_parameters(m1),
+    list(
+      conditional = c("(Intercept)", "sin(2 * pi * Time)", "cos(2 * pi * Time)")
     )
-  })
+  )
+  expect_equal(nrow(get_parameters(m1)), 3)
+  expect_equal(
+    get_parameters(m1)$Parameter,
+    c("(Intercept)", "sin(2 * pi * Time)", "cos(2 * pi * Time)")
+  )
+})
 
-  test_that("is_multivariate", {
-    expect_false(is_multivariate(m1))
-  })
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1))
+})
 
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "t-statistic")
-  })
-}
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "t-statistic")
+})
diff --git a/tests/testthat/test-gmnl.R b/tests/testthat/test-gmnl.R
index 10a9f5a3c..ef7f968f3 100644
--- a/tests/testthat/test-gmnl.R
+++ b/tests/testthat/test-gmnl.R
@@ -1,86 +1,84 @@
-if (
+skip_if_not_installed("gmnl")
+skip_if_not_installed("mlogit")
+skip_if_not_installed("MASS")
 
-  skip_if_not_or_load_if_installed("gmnl") &&
-    skip_if_not_or_load_if_installed("mlogit") &&
-    skip_if_not_or_load_if_installed("MASS")) {
-  data(housing, package = "MASS")
+data(housing, package = "MASS")
 
-  dat <<- mlogit.data(housing, choice = "Sat", shape = "wide")
-  void <- capture.output(
-    m1 <- gmnl(Sat ~ Infl + Type + Cont | 1,
-      data = dat,
-      model = "smnl",
-      R = 100
-    )
+dat <<- mlogit::mlogit.data(housing, choice = "Sat", shape = "wide")
+void <- capture.output(
+  m1 <- gmnl::gmnl(Sat ~ Infl + Type + Cont | 1,
+    data = dat,
+    model = "smnl",
+    R = 100
   )
+)
 
-  test_that("model_info", {
-    expect_false(model_info(m1)$is_ordinal)
-    expect_true(model_info(m1)$is_multinomial)
-  })
+test_that("model_info", {
+  expect_false(model_info(m1)$is_ordinal)
+  expect_true(model_info(m1)$is_multinomial)
+})
 
-  test_that("find_predictors", {
-    expect_identical(find_predictors(m1), list(conditional = c("Infl", "Type", "Cont")))
-    expect_identical(
-      find_predictors(m1, flatten = TRUE),
-      c("Infl", "Type", "Cont")
-    )
-    expect_null(find_predictors(m1, effects = "random"))
-  })
+test_that("find_predictors", {
+  expect_identical(find_predictors(m1), list(conditional = c("Infl", "Type", "Cont")))
+  expect_identical(
+    find_predictors(m1, flatten = TRUE),
+    c("Infl", "Type", "Cont")
+  )
+  expect_null(find_predictors(m1, effects = "random"))
+})
 
-  test_that("find_response", {
-    expect_identical(find_response(m1), "Sat")
-  })
+test_that("find_response", {
+  expect_identical(find_response(m1), "Sat")
+})
 
-  test_that("link_inverse", {
-    expect_equal(link_inverse(m1)(0.2), plogis(0.2), tolerance = 1e-5)
-  })
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), plogis(0.2), tolerance = 1e-5)
+})
 
-  test_that("get_data", {
-    expect_equal(nrow(get_data(m1, verbose = FALSE)), 216)
-    expect_equal(colnames(get_data(m1, verbose = FALSE)), c("Sat", "Infl", "Type", "Cont"))
-  })
+test_that("get_data", {
+  expect_equal(nrow(get_data(m1, verbose = FALSE)), 216)
+  expect_equal(colnames(get_data(m1, verbose = FALSE)), c("Sat", "Infl", "Type", "Cont"))
+})
 
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 1)
-  })
+test_that("find_formula", {
+  expect_length(find_formula(m1), 1)
+})
 
-  test_that("find_terms", {
-    expect_equal(find_terms(m1), list(
-      response = "Sat",
-      conditional = c("Infl", "Type", "Cont", "1")
-    ))
-    expect_equal(
-      find_terms(m1, flatten = TRUE),
-      c("Sat", "Infl", "Type", "Cont", "1")
-    )
-  })
+test_that("find_terms", {
+  expect_equal(find_terms(m1), list(
+    response = "Sat",
+    conditional = c("Infl", "Type", "Cont", "1")
+  ))
+  expect_equal(
+    find_terms(m1, flatten = TRUE),
+    c("Sat", "Infl", "Type", "Cont", "1")
+  )
+})
 
-  test_that("n_obs", {
-    expect_equal(n_obs(m1), 72)
-  })
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 72)
+})
 
-  test_that("find_variables", {
-    expect_equal(find_variables(m1), list(
-      response = "Sat",
-      conditional = c("Infl", "Type", "Cont")
-    ))
-    expect_equal(
-      find_variables(m1, flatten = TRUE),
-      c("Sat", "Infl", "Type", "Cont")
-    )
-  })
+test_that("find_variables", {
+  expect_equal(find_variables(m1), list(
+    response = "Sat",
+    conditional = c("Infl", "Type", "Cont")
+  ))
+  expect_equal(
+    find_variables(m1, flatten = TRUE),
+    c("Sat", "Infl", "Type", "Cont")
+  )
+})
 
 
-  test_that("linkfun", {
-    expect_false(is.null(link_function(m1)))
-  })
+test_that("linkfun", {
+  expect_false(is.null(link_function(m1)))
+})
 
-  test_that("is_multivariate", {
-    expect_false(is_multivariate(m1))
-  })
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1))
+})
 
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "z-statistic")
-  })
-}
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "z-statistic")
+})
diff --git a/tests/testthat/test-has_intercept.R b/tests/testthat/test-has_intercept.R
index ff1836bb1..6053275cc 100644
--- a/tests/testthat/test-has_intercept.R
+++ b/tests/testthat/test-has_intercept.R
@@ -1,28 +1,26 @@
-if (skip_if_not_or_load_if_installed("lme4")) {
-  data(mtcars)
-  data(sleepstudy)
-  data(iris)
+skip_if_not_installed("lme4")
 
-  m1 <- lm(mpg ~ 0 + gear, data = mtcars)
-  m2 <- lm(mpg ~ gear, data = mtcars)
-  m3 <- suppressWarnings(lmer(Reaction ~ 0 + Days + (Days | Subject), data = sleepstudy))
-  m4 <- lmer(Reaction ~ Days + (Days | Subject), data = sleepstudy)
-  m5 <- suppressWarnings(lmer(Reaction ~ 0 + (Days | Subject), data = sleepstudy))
+data(sleepstudy, package = "lme4")
 
-  m6 <- lm(Sepal.Length ~ 0 + Petal.Width + Species, data = iris)
-  m7 <- lm(Sepal.Length ~ -1 + Petal.Width + Species, data = iris)
-  m8 <- lm(Sepal.Length ~ Petal.Width + Species, data = iris)
-  m9 <- lm(Sepal.Length ~ Petal.Width + Species + 1, data = iris)
+m1 <- lm(mpg ~ 0 + gear, data = mtcars)
+m2 <- lm(mpg ~ gear, data = mtcars)
+m3 <- suppressWarnings(lme4::lmer(Reaction ~ 0 + Days + (Days | Subject), data = sleepstudy))
+m4 <- lme4::lmer(Reaction ~ Days + (Days | Subject), data = sleepstudy)
+m5 <- suppressWarnings(lme4::lmer(Reaction ~ 0 + (Days | Subject), data = sleepstudy))
 
-  test_that("has_intercept", {
-    expect_true(has_intercept(m2))
-    expect_false(has_intercept(m1))
-    expect_true(has_intercept(m4))
-    expect_false(has_intercept(m3))
-    expect_false(has_intercept(m5))
-    expect_false(has_intercept(m6))
-    expect_false(has_intercept(m7))
-    expect_true(has_intercept(m8))
-    expect_true(has_intercept(m9))
-  })
-}
+m6 <- lm(Sepal.Length ~ 0 + Petal.Width + Species, data = iris)
+m7 <- lm(Sepal.Length ~ -1 + Petal.Width + Species, data = iris)
+m8 <- lm(Sepal.Length ~ Petal.Width + Species, data = iris)
+m9 <- lm(Sepal.Length ~ Petal.Width + Species + 1, data = iris)
+
+test_that("has_intercept", {
+  expect_true(has_intercept(m2))
+  expect_false(has_intercept(m1))
+  expect_true(has_intercept(m4))
+  expect_false(has_intercept(m3))
+  expect_false(has_intercept(m5))
+  expect_false(has_intercept(m6))
+  expect_false(has_intercept(m7))
+  expect_true(has_intercept(m8))
+  expect_true(has_intercept(m9))
+})
diff --git a/tests/testthat/test-htest.R b/tests/testthat/test-htest.R
index 109f6f1fe..fd1c529ce 100644
--- a/tests/testthat/test-htest.R
+++ b/tests/testthat/test-htest.R
@@ -40,7 +40,6 @@ test_that("get_data.t-test, one-sample", {
 
 # Two sample
 test_that("get_data.t-test, two-sample", {
-  data(mtcars)
   tt3 <- t.test(mtcars$mpg ~ mtcars$am)
   tt4 <- t.test(mtcars$mpg[mtcars$am == 0], mtcars$mpg[mtcars$am == 1])
   expect_identical(colnames(get_data(tt3)), c("x", "y"))
diff --git a/tests/testthat/test-hurdle.R b/tests/testthat/test-hurdle.R
index 45e76e9e4..2a39a29b5 100644
--- a/tests/testthat/test-hurdle.R
+++ b/tests/testthat/test-hurdle.R
@@ -1,149 +1,149 @@
-if (skip_if_not_or_load_if_installed("pscl")) {
-  data("bioChemists")
-
-  m1 <- hurdle(art ~ fem + mar + kid5 + ment | kid5 + phd, data = bioChemists)
-
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_poisson)
-    expect_true(model_info(m1)$is_zero_inflated)
-    expect_false(model_info(m1)$is_linear)
-  })
-
-  test_that("find_predictors", {
-    expect_identical(
-      find_predictors(m1),
-      list(
-        conditional = c("fem", "mar", "kid5", "ment"),
-        zero_inflated = c("kid5", "phd")
-      )
-    )
-    expect_identical(
-      find_predictors(m1, flatten = TRUE),
-      c("fem", "mar", "kid5", "ment", "phd")
-    )
-    expect_null(find_predictors(m1, effects = "random"))
-  })
-
-  test_that("find_response", {
-    expect_identical(find_response(m1), "art")
-  })
-
-  test_that("get_response", {
-    expect_equal(get_response(m1), bioChemists$art)
-  })
-
-  test_that("link_inverse", {
-    expect_equal(link_inverse(m1)(0.2), exp(0.2), tolerance = 1e-5)
-  })
-
-  test_that("get_data", {
-    expect_equal(nrow(get_data(m1)), 915)
-    expect_equal(
-      colnames(get_data(m1)),
-      c("art", "fem", "mar", "kid5", "ment", "phd")
-    )
-  })
+skip_if_not_installed("pscl")
 
-  test_that("get_df", {
-    expect_equal(
-      get_df(m1, type = "residual"),
-      df.residual(m1),
-      ignore_attr = TRUE
-    )
-    expect_equal(
-      get_df(m1, type = "normal"),
-      Inf,
-      ignore_attr = TRUE
-    )
-    expect_equal(
-      get_df(m1, type = "wald"),
-      Inf,
-      ignore_attr = TRUE
-    )
-  })
-
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 2)
-    expect_equal(
-      find_formula(m1),
-      list(
-        conditional = as.formula("art ~ fem + mar + kid5 + ment"),
-        zero_inflated = as.formula("~kid5 + phd")
-      ),
-      ignore_attr = TRUE
-    )
-  })
-
-  test_that("find_variables", {
-    expect_equal(
-      find_variables(m1),
-      list(
-        response = "art",
-        conditional = c("fem", "mar", "kid5", "ment"),
-        zero_inflated = c("kid5", "phd")
-      )
-    )
-    expect_equal(
-      find_variables(m1, flatten = TRUE),
-      c("art", "fem", "mar", "kid5", "ment", "phd")
+data(bioChemists, package = "pscl")
+
+m1 <- pscl::hurdle(art ~ fem + mar + kid5 + ment | kid5 + phd, data = bioChemists)
+
+test_that("model_info", {
+  expect_true(model_info(m1)$is_poisson)
+  expect_true(model_info(m1)$is_zero_inflated)
+  expect_false(model_info(m1)$is_linear)
+})
+
+test_that("find_predictors", {
+  expect_identical(
+    find_predictors(m1),
+    list(
+      conditional = c("fem", "mar", "kid5", "ment"),
+      zero_inflated = c("kid5", "phd")
     )
-  })
-
-  test_that("n_obs", {
-    expect_equal(n_obs(m1), 915)
-  })
-
-  test_that("linkfun", {
-    expect_false(is.null(link_function(m1)))
-  })
-
-  test_that("find_parameters", {
-    expect_equal(
-      find_parameters(m1),
-      list(
-        conditional = c(
-          "count_(Intercept)",
-          "count_femWomen",
-          "count_marMarried",
-          "count_kid5",
-          "count_ment"
-        ),
-        zero_inflated = c("zero_(Intercept)", "zero_kid5", "zero_phd")
-      )
+  )
+  expect_identical(
+    find_predictors(m1, flatten = TRUE),
+    c("fem", "mar", "kid5", "ment", "phd")
+  )
+  expect_null(find_predictors(m1, effects = "random"))
+})
+
+test_that("find_response", {
+  expect_identical(find_response(m1), "art")
+})
+
+test_that("get_response", {
+  expect_equal(get_response(m1), bioChemists$art)
+})
+
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), exp(0.2), tolerance = 1e-5)
+})
+
+test_that("get_data", {
+  expect_equal(nrow(get_data(m1)), 915)
+  expect_equal(
+    colnames(get_data(m1)),
+    c("art", "fem", "mar", "kid5", "ment", "phd")
+  )
+})
+
+test_that("get_df", {
+  expect_equal(
+    get_df(m1, type = "residual"),
+    df.residual(m1),
+    ignore_attr = TRUE
+  )
+  expect_equal(
+    get_df(m1, type = "normal"),
+    Inf,
+    ignore_attr = TRUE
+  )
+  expect_equal(
+    get_df(m1, type = "wald"),
+    Inf,
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1), 2)
+  expect_equal(
+    find_formula(m1),
+    list(
+      conditional = as.formula("art ~ fem + mar + kid5 + ment"),
+      zero_inflated = as.formula("~kid5 + phd")
+    ),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_variables", {
+  expect_equal(
+    find_variables(m1),
+    list(
+      response = "art",
+      conditional = c("fem", "mar", "kid5", "ment"),
+      zero_inflated = c("kid5", "phd")
     )
-    expect_equal(nrow(get_parameters(m1)), 8)
-    expect_equal(nrow(get_parameters(m1, component = "zi")), 3)
-    expect_equal(
-      get_parameters(m1)$Parameter,
-      c(
+  )
+  expect_equal(
+    find_variables(m1, flatten = TRUE),
+    c("art", "fem", "mar", "kid5", "ment", "phd")
+  )
+})
+
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 915)
+})
+
+test_that("linkfun", {
+  expect_false(is.null(link_function(m1)))
+})
+
+test_that("find_parameters", {
+  expect_equal(
+    find_parameters(m1),
+    list(
+      conditional = c(
         "count_(Intercept)",
         "count_femWomen",
         "count_marMarried",
         "count_kid5",
-        "count_ment",
-        "zero_(Intercept)",
-        "zero_kid5",
-        "zero_phd"
-      )
+        "count_ment"
+      ),
+      zero_inflated = c("zero_(Intercept)", "zero_kid5", "zero_phd")
+    )
+  )
+  expect_equal(nrow(get_parameters(m1)), 8)
+  expect_equal(nrow(get_parameters(m1, component = "zi")), 3)
+  expect_equal(
+    get_parameters(m1)$Parameter,
+    c(
+      "count_(Intercept)",
+      "count_femWomen",
+      "count_marMarried",
+      "count_kid5",
+      "count_ment",
+      "zero_(Intercept)",
+      "zero_kid5",
+      "zero_phd"
     )
-  })
-
-  test_that("is_multivariate", {
-    expect_false(is_multivariate(m1))
-  })
-
-  test_that("find_terms", {
-    expect_equal(
-      find_terms(m1),
-      list(
-        response = "art",
-        conditional = c("fem", "mar", "kid5", "ment"),
-        zero_inflated = c("kid5", "phd")
-      )
+  )
+})
+
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1))
+})
+
+test_that("find_terms", {
+  expect_equal(
+    find_terms(m1),
+    list(
+      response = "art",
+      conditional = c("fem", "mar", "kid5", "ment"),
+      zero_inflated = c("kid5", "phd")
     )
-  })
+  )
+})
 
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "z-statistic")
-  })
-}
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "z-statistic")
+})
diff --git a/tests/testthat/test-is_converged.R b/tests/testthat/test-is_converged.R
index b67ee321a..316c500fc 100644
--- a/tests/testthat/test-is_converged.R
+++ b/tests/testthat/test-is_converged.R
@@ -1,33 +1,36 @@
-if (skip_if_not_or_load_if_installed("lme4") && getRversion() >= "4.0.0") {
-  data(cbpp)
-  data(sleepstudy)
-  set.seed(1)
-  cbpp$x <- rnorm(nrow(cbpp))
-  cbpp$x2 <- runif(nrow(cbpp))
-
-  model <- suppressMessages(suppressWarnings(glmer(
-    cbind(incidence, size - incidence) ~ period + x + x2 + (1 + x | herd),
-    data = cbpp,
-    family = binomial()
-  )))
-
-  test_that("is_converged", {
-    expect_true(is_converged(model))
-    expect_equal(is_converged(model), structure(TRUE, gradient = 0.000280307452338331), tolerance = 1e-3)
-  })
-
-  model <- lmer(Reaction ~ Days + (1 + Days | Subject), data = sleepstudy)
-
-  test_that("is_converged", {
-    expect_true(is_converged(model))
-  })
-
-
-  skip_on_os("mac") # error: FreeADFunObject
-  if (skip_if_not_or_load_if_installed("glmmTMB") && skip_if_not_or_load_if_installed("TMB")) {
-    model <- glmmTMB(Reaction ~ Days + (1 + Days | Subject), data = sleepstudy)
-    test_that("is_converged, glmmTMB", {
-      expect_true(is_converged(model))
-    })
-  }
-}
+skip_if_not_installed("lme4")
+skip_if_not(getRversion() >= "4.0.0")
+
+data(cbpp, package = "lme4")
+data(sleepstudy, package = "lme4")
+set.seed(1)
+cbpp$x <- rnorm(nrow(cbpp))
+cbpp$x2 <- runif(nrow(cbpp))
+
+model <- suppressMessages(suppressWarnings(lme4::glmer(
+  cbind(incidence, size - incidence) ~ period + x + x2 + (1 + x | herd),
+  data = cbpp,
+  family = binomial()
+)))
+
+test_that("is_converged", {
+  expect_true(is_converged(model))
+  expect_equal(is_converged(model), structure(TRUE, gradient = 0.000280307452338331), tolerance = 1e-3)
+})
+
+model <- lme4::lmer(Reaction ~ Days + (1 + Days | Subject), data = sleepstudy)
+
+test_that("is_converged", {
+  expect_true(is_converged(model))
+})
+
+
+skip_on_os("mac") # error: FreeADFunObject
+skip_if_not_installed("glmmTMB")
+skip_if_not_installed("TMB")
+
+data(sleepstudy, package = "lme4")
+model <- glmmTMB::glmmTMB(Reaction ~ Days + (1 + Days | Subject), data = sleepstudy)
+test_that("is_converged, glmmTMB", {
+  expect_true(is_converged(model))
+})
diff --git a/tests/testthat/test-is_nullmodel.R b/tests/testthat/test-is_nullmodel.R
index 814452de9..2f7456248 100644
--- a/tests/testthat/test-is_nullmodel.R
+++ b/tests/testthat/test-is_nullmodel.R
@@ -1,18 +1,17 @@
-if (skip_if_not_or_load_if_installed("lme4")) {
-  data(mtcars)
-  data(sleepstudy)
+skip_if_not_installed("lme4")
 
-  m1 <- lm(mpg ~ 1, data = mtcars)
-  m2 <- lm(mpg ~ gear, data = mtcars)
-  m3 <- lmer(Reaction ~ 1 + (Days | Subject), data = sleepstudy)
-  m4 <- lmer(Reaction ~ Days + (Days | Subject), data = sleepstudy)
-  m5 <- suppressWarnings(lmer(Reaction ~ 0 + (Days | Subject), data = sleepstudy))
+data(sleepstudy, package = "lme4")
 
-  test_that("is_nullmodel", {
-    expect_true(is_nullmodel(m1))
-    expect_false(is_nullmodel(m2))
-    expect_true(is_nullmodel(m3))
-    expect_false(is_nullmodel(m4))
-    expect_true(is_nullmodel(m5))
-  })
-}
+m1 <- lm(mpg ~ 1, data = mtcars)
+m2 <- lm(mpg ~ gear, data = mtcars)
+m3 <- lme4::lmer(Reaction ~ 1 + (Days | Subject), data = sleepstudy)
+m4 <- lme4::lmer(Reaction ~ Days + (Days | Subject), data = sleepstudy)
+m5 <- suppressWarnings(lme4::lmer(Reaction ~ 0 + (Days | Subject), data = sleepstudy))
+
+test_that("is_nullmodel", {
+  expect_true(is_nullmodel(m1))
+  expect_false(is_nullmodel(m2))
+  expect_true(is_nullmodel(m3))
+  expect_false(is_nullmodel(m4))
+  expect_true(is_nullmodel(m5))
+})
diff --git a/tests/testthat/test-iv_robust.R b/tests/testthat/test-iv_robust.R
index b351e8d98..4dff44a91 100644
--- a/tests/testthat/test-iv_robust.R
+++ b/tests/testthat/test-iv_robust.R
@@ -1,146 +1,144 @@
-if (skip_if_not_or_load_if_installed("estimatr")) {
-  data(mtcars)
-  m1 <- iv_robust(mpg ~ gear + cyl | carb + wt, data = mtcars)
-
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_linear)
-  })
-
-  test_that("find_predictors", {
-    expect_identical(
-      find_predictors(m1),
-      list(
-        conditional = c("gear", "cyl"),
-        instruments = c("carb", "wt")
-      )
-    )
-    expect_identical(
-      find_predictors(m1, component = "instruments"),
-      list(instruments = c("carb", "wt"))
-    )
-    expect_identical(
-      find_predictors(m1, flatten = TRUE),
-      c("gear", "cyl", "carb", "wt")
-    )
-    expect_null(find_predictors(m1, effects = "random"))
-  })
-
-  test_that("find_random", {
-    expect_null(find_random(m1))
-  })
-
-  test_that("get_random", {
-    expect_warning(get_random(m1))
-  })
-
-  test_that("find_response", {
-    expect_identical(find_response(m1), "mpg")
-  })
-
-  test_that("get_response", {
-    expect_equal(get_response(m1), mtcars$mpg)
-  })
-
-  test_that("get_predictors", {
-    expect_equal(colnames(get_predictors(m1)), c("gear", "cyl", "carb", "wt"))
-  })
-
-  test_that("get_data", {
-    expect_equal(nrow(get_data(m1)), 32)
-    expect_equal(
-      colnames(get_data(m1)),
-      c("mpg", "gear", "cyl", "carb", "wt")
-    )
-  })
-
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 2)
-    expect_equal(
-      find_formula(m1),
-      list(
-        conditional = as.formula("mpg ~ gear + cyl"),
-        instruments = as.formula("~carb + wt")
-      ),
-      ignore_attr = TRUE
-    )
-  })
-
-  test_that("find_terms", {
-    expect_equal(
-      find_terms(m1),
-      list(
-        response = "mpg",
-        conditional = c("gear", "cyl"),
-        instruments = c("carb", "wt")
-      )
-    )
-    expect_equal(
-      find_terms(m1, flatten = TRUE),
-      c("mpg", "gear", "cyl", "carb", "wt")
-    )
-  })
-
-  test_that("n_obs", {
-    expect_equal(n_obs(m1), 32)
-  })
-
-  test_that("link_function", {
-    expect_equal(link_function(m1)(0.2), 0.2, tolerance = 1e-5)
-  })
+skip_if_not_installed("estimatr")
 
-  test_that("link_inverse", {
-    expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
-  })
+m1 <- estimatr::iv_robust(mpg ~ gear + cyl | carb + wt, data = mtcars)
 
-  test_that("find_parameters", {
-    expect_equal(
-      find_parameters(m1),
-      list(conditional = c("(Intercept)", "gear", "cyl"))
-    )
-    expect_equal(nrow(get_parameters(m1)), 3)
-    expect_equal(
-      get_parameters(m1)$Parameter,
-      c("(Intercept)", "gear", "cyl")
-    )
-  })
-
-  test_that("is_multivariate", {
-    expect_false(is_multivariate(m1))
-  })
-
-  test_that("find_algorithm", {
-    expect_warning(expect_null(find_algorithm(m1)))
-  })
-
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "t-statistic")
-  })
+test_that("model_info", {
+  expect_true(model_info(m1)$is_linear)
+})
 
-  if (skip_if_not_or_load_if_installed("ivreg")) {
-    data("CigaretteDemand", package = "ivreg")
-    m2 <- iv_robust(
-      log(packs) ~ log(rprice) + log(rincome) | salestax + log(rincome),
-      data = CigaretteDemand
+test_that("find_predictors", {
+  expect_identical(
+    find_predictors(m1),
+    list(
+      conditional = c("gear", "cyl"),
+      instruments = c("carb", "wt")
     )
-    m3 <- iv_robust(
-      packs ~ log(rprice) + log(rincome) | salestax + log(rincome),
-      data = CigaretteDemand
+  )
+  expect_identical(
+    find_predictors(m1, component = "instruments"),
+    list(instruments = c("carb", "wt"))
+  )
+  expect_identical(
+    find_predictors(m1, flatten = TRUE),
+    c("gear", "cyl", "carb", "wt")
+  )
+  expect_null(find_predictors(m1, effects = "random"))
+})
+
+test_that("find_random", {
+  expect_null(find_random(m1))
+})
+
+test_that("get_random", {
+  expect_warning(get_random(m1))
+})
+
+test_that("find_response", {
+  expect_identical(find_response(m1), "mpg")
+})
+
+test_that("get_response", {
+  expect_equal(get_response(m1), mtcars$mpg)
+})
+
+test_that("get_predictors", {
+  expect_equal(colnames(get_predictors(m1)), c("gear", "cyl", "carb", "wt"))
+})
+
+test_that("get_data", {
+  expect_equal(nrow(get_data(m1)), 32)
+  expect_equal(
+    colnames(get_data(m1)),
+    c("mpg", "gear", "cyl", "carb", "wt")
+  )
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1), 2)
+  expect_equal(
+    find_formula(m1),
+    list(
+      conditional = as.formula("mpg ~ gear + cyl"),
+      instruments = as.formula("~carb + wt")
+    ),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_terms", {
+  expect_equal(
+    find_terms(m1),
+    list(
+      response = "mpg",
+      conditional = c("gear", "cyl"),
+      instruments = c("carb", "wt")
     )
-
-    m4 <- lm_robust(
-      log(packs) ~ log(rprice) + log(rincome) | salestax + log(rincome),
-      data = CigaretteDemand
-    )
-    m5 <- lm_robust(
-      packs ~ log(rprice) + log(rincome) | salestax + log(rincome),
-      data = CigaretteDemand
-    )
-
-    test_that("get_loglikelihood", {
-      expect_equal(as.numeric(get_loglikelihood(m2)), -286.56173, tolerance = 1e-3)
-      expect_equal(as.numeric(get_loglikelihood(m3)), -206.39546, tolerance = 1e-3)
-      expect_equal(as.numeric(get_loglikelihood(m4)), -286.55949, tolerance = 1e-3)
-      expect_equal(as.numeric(get_loglikelihood(m5)), -205.63306, tolerance = 1e-3)
-    })
-  }
-}
+  )
+  expect_equal(
+    find_terms(m1, flatten = TRUE),
+    c("mpg", "gear", "cyl", "carb", "wt")
+  )
+})
+
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 32)
+})
+
+test_that("link_function", {
+  expect_equal(link_function(m1)(0.2), 0.2, tolerance = 1e-5)
+})
+
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
+})
+
+test_that("find_parameters", {
+  expect_equal(
+    find_parameters(m1),
+    list(conditional = c("(Intercept)", "gear", "cyl"))
+  )
+  expect_equal(nrow(get_parameters(m1)), 3)
+  expect_equal(
+    get_parameters(m1)$Parameter,
+    c("(Intercept)", "gear", "cyl")
+  )
+})
+
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1))
+})
+
+test_that("find_algorithm", {
+  expect_warning(expect_null(find_algorithm(m1)))
+})
+
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "t-statistic")
+})
+
+skip_if_not_installed("ivreg")
+data("CigaretteDemand", package = "ivreg")
+m2 <- estimatr::iv_robust(
+  log(packs) ~ log(rprice) + log(rincome) | salestax + log(rincome),
+  data = CigaretteDemand
+)
+m3 <- estimatr::iv_robust(
+  packs ~ log(rprice) + log(rincome) | salestax + log(rincome),
+  data = CigaretteDemand
+)
+
+m4 <- estimatr::lm_robust(
+  log(packs) ~ log(rprice) + log(rincome) | salestax + log(rincome),
+  data = CigaretteDemand
+)
+m5 <- estimatr::lm_robust(
+  packs ~ log(rprice) + log(rincome) | salestax + log(rincome),
+  data = CigaretteDemand
+)
+
+test_that("get_loglikelihood", {
+  expect_equal(as.numeric(get_loglikelihood(m2)), -286.56173, tolerance = 1e-3)
+  expect_equal(as.numeric(get_loglikelihood(m3)), -206.39546, tolerance = 1e-3)
+  expect_equal(as.numeric(get_loglikelihood(m4)), -286.55949, tolerance = 1e-3)
+  expect_equal(as.numeric(get_loglikelihood(m5)), -205.63306, tolerance = 1e-3)
+})
diff --git a/tests/testthat/test-ivreg.R b/tests/testthat/test-ivreg.R
index 84acce137..93e605f76 100644
--- a/tests/testthat/test-ivreg.R
+++ b/tests/testthat/test-ivreg.R
@@ -1,133 +1,134 @@
-if (skip_if_not_or_load_if_installed("ivreg")) {
-  data("CigaretteDemand")
-  m1 <- ivreg::ivreg(log(packs) ~ log(rprice) + log(rincome) | salestax + log(rincome),
-    data = CigaretteDemand
-  )
+skip_if_not_installed("ivreg")
 
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_linear)
-  })
-
-  test_that("find_predictors", {
-    expect_identical(
-      find_predictors(m1),
-      list(
-        conditional = c("rprice", "rincome"),
-        instruments = c("salestax", "rincome")
-      )
-    )
-    expect_identical(
-      find_predictors(m1, flatten = TRUE),
-      c("rprice", "rincome", "salestax")
+data("CigaretteDemand", package = "ivreg")
+
+m1 <- ivreg::ivreg(log(packs) ~ log(rprice) + log(rincome) | salestax + log(rincome),
+  data = CigaretteDemand
+)
+
+test_that("model_info", {
+  expect_true(model_info(m1)$is_linear)
+})
+
+test_that("find_predictors", {
+  expect_identical(
+    find_predictors(m1),
+    list(
+      conditional = c("rprice", "rincome"),
+      instruments = c("salestax", "rincome")
     )
-    expect_null(find_predictors(m1, effects = "random"))
-  })
+  )
+  expect_identical(
+    find_predictors(m1, flatten = TRUE),
+    c("rprice", "rincome", "salestax")
+  )
+  expect_null(find_predictors(m1, effects = "random"))
+})
 
-  test_that("find_random", {
-    expect_null(find_random(m1))
-  })
+test_that("find_random", {
+  expect_null(find_random(m1))
+})
 
-  test_that("get_random", {
-    expect_warning(get_random(m1))
-  })
+test_that("get_random", {
+  expect_warning(get_random(m1))
+})
 
-  test_that("find_response", {
-    expect_identical(find_response(m1), "packs")
-  })
+test_that("find_response", {
+  expect_identical(find_response(m1), "packs")
+})
 
-  test_that("get_response", {
-    expect_equal(get_response(m1), CigaretteDemand$packs)
-  })
+test_that("get_response", {
+  expect_equal(get_response(m1), CigaretteDemand$packs)
+})
 
-  test_that("get_predictors", {
-    expect_equal(
-      colnames(get_predictors(m1)),
-      c("rprice", "rincome", "salestax")
-    )
-  })
+test_that("get_predictors", {
+  expect_equal(
+    colnames(get_predictors(m1)),
+    c("rprice", "rincome", "salestax")
+  )
+})
 
-  test_that("link_inverse", {
-    expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
-  })
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
+})
 
-  test_that("get_data", {
-    expect_equal(nrow(get_data(m1)), 48)
-    expect_equal(
-      colnames(get_data(m1)),
-      c("packs", "rprice", "rincome", "salestax")
-    )
-  })
-
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 2)
-    expect_equal(
-      find_formula(m1),
-      list(
-        conditional = as.formula("log(packs) ~ log(rprice) + log(rincome)"),
-        instruments = as.formula("~salestax + log(rincome)")
-      ),
-      ignore_attr = TRUE
-    )
-  })
-
-  test_that("find_variables", {
-    expect_equal(
-      find_variables(m1),
-      list(
-        response = "packs",
-        conditional = c("rprice", "rincome"),
-        instruments = c("salestax", "rincome")
-      )
-    )
-    expect_equal(
-      find_variables(m1, flatten = TRUE),
-      c("packs", "rprice", "rincome", "salestax")
-    )
-  })
-
-  test_that("n_obs", {
-    expect_equal(n_obs(m1), 48)
-  })
-
-  test_that("linkfun", {
-    expect_false(is.null(link_function(m1)))
-  })
-
-  test_that("find_parameters", {
-    expect_equal(
-      find_parameters(m1),
-      list(
-        conditional = c("(Intercept)", "log(rprice)", "log(rincome)")
-      )
-    )
-    expect_equal(nrow(get_parameters(m1)), 3)
-    expect_equal(
-      get_parameters(m1)$Parameter,
-      c("(Intercept)", "log(rprice)", "log(rincome)")
+test_that("get_data", {
+  expect_equal(nrow(get_data(m1)), 48)
+  expect_equal(
+    colnames(get_data(m1)),
+    c("packs", "rprice", "rincome", "salestax")
+  )
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1), 2)
+  expect_equal(
+    find_formula(m1),
+    list(
+      conditional = as.formula("log(packs) ~ log(rprice) + log(rincome)"),
+      instruments = as.formula("~salestax + log(rincome)")
+    ),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_variables", {
+  expect_equal(
+    find_variables(m1),
+    list(
+      response = "packs",
+      conditional = c("rprice", "rincome"),
+      instruments = c("salestax", "rincome")
     )
-  })
-
-  test_that("is_multivariate", {
-    expect_false(is_multivariate(m1))
-  })
-
-  test_that("find_terms", {
-    expect_equal(
-      find_terms(m1),
-      list(
-        response = "log(packs)",
-        conditional = c("log(rprice)", "log(rincome)"),
-        instruments = c("salestax", "log(rincome)")
-      )
+  )
+  expect_equal(
+    find_variables(m1, flatten = TRUE),
+    c("packs", "rprice", "rincome", "salestax")
+  )
+})
+
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 48)
+})
+
+test_that("linkfun", {
+  expect_false(is.null(link_function(m1)))
+})
+
+test_that("find_parameters", {
+  expect_equal(
+    find_parameters(m1),
+    list(
+      conditional = c("(Intercept)", "log(rprice)", "log(rincome)")
     )
-    expect_equal(nrow(get_parameters(m1)), 3)
-    expect_equal(
-      get_parameters(m1)$Parameter,
-      c("(Intercept)", "log(rprice)", "log(rincome)")
+  )
+  expect_equal(nrow(get_parameters(m1)), 3)
+  expect_equal(
+    get_parameters(m1)$Parameter,
+    c("(Intercept)", "log(rprice)", "log(rincome)")
+  )
+})
+
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1))
+})
+
+test_that("find_terms", {
+  expect_equal(
+    find_terms(m1),
+    list(
+      response = "log(packs)",
+      conditional = c("log(rprice)", "log(rincome)"),
+      instruments = c("salestax", "log(rincome)")
     )
-  })
+  )
+  expect_equal(nrow(get_parameters(m1)), 3)
+  expect_equal(
+    get_parameters(m1)$Parameter,
+    c("(Intercept)", "log(rprice)", "log(rincome)")
+  )
+})
 
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "t-statistic")
-  })
-}
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "t-statistic")
+})
diff --git a/tests/testthat/test-ivreg_AER.R b/tests/testthat/test-ivreg_AER.R
index 6962f26e9..53b5fbcee 100644
--- a/tests/testthat/test-ivreg_AER.R
+++ b/tests/testthat/test-ivreg_AER.R
@@ -1,6 +1,6 @@
-skip_if_not_or_load_if_installed("AER")
+skip_if_not_installed("AER")
 
-data(CigarettesSW)
+data(CigarettesSW, package = "AER")
 CigarettesSW$rprice <- with(CigarettesSW, price / cpi)
 CigarettesSW$rincome <- with(CigarettesSW, income / population / cpi)
 CigarettesSW$tdiff <- with(CigarettesSW, (taxs - tax) / cpi)
@@ -139,8 +139,3 @@ test_that("find_terms", {
 test_that("find_statistic", {
   expect_identical(find_statistic(mod_aer_ivreg), "t-statistic")
 })
-
-# to avoid `Registered S3 methods overwritten by 'ivreg'` messages
-if (isNamespaceLoaded("AER")) {
-  unloadNamespace("AER")
-}
diff --git a/tests/testthat/test-lm.R b/tests/testthat/test-lm.R
index fefcb3574..98a1980e1 100644
--- a/tests/testthat/test-lm.R
+++ b/tests/testthat/test-lm.R
@@ -1,6 +1,3 @@
-data(iris)
-data(mtcars)
-
 m1 <- lm(Sepal.Length ~ Petal.Width + Species, data = iris)
 m2 <- lm(log(mpg) ~ log(hp) + cyl + I(cyl^2) + poly(wt, degree = 2, raw = TRUE),
   data = mtcars
@@ -290,7 +287,6 @@ test_that("find_statistic", {
 })
 
 test_that("find_statistic", {
-  data("mtcars")
   m <- lm(cbind(mpg, hp) ~ cyl + drat, data = mtcars)
   expect_message(
     get_predicted(m),
diff --git a/tests/testthat/test-lm_robust.R b/tests/testthat/test-lm_robust.R
index a7070111d..ea0f1faef 100644
--- a/tests/testthat/test-lm_robust.R
+++ b/tests/testthat/test-lm_robust.R
@@ -1,101 +1,98 @@
-if (
-
-  skip_if_not_or_load_if_installed("estimatr")) {
-  data(mtcars)
-  m1 <- lm_robust(mpg ~ gear + wt + cyl, data = mtcars)
-
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_linear)
-  })
-
-  test_that("find_predictors", {
-    expect_identical(find_predictors(m1), list(conditional = c("gear", "wt", "cyl")))
-    expect_identical(find_predictors(m1, flatten = TRUE), c("gear", "wt", "cyl"))
-    expect_null(find_predictors(m1, effects = "random"))
-  })
-
-  test_that("find_random", {
-    expect_null(find_random(m1))
-  })
-
-  test_that("get_random", {
-    expect_warning(get_random(m1))
-  })
-
-  test_that("find_response", {
-    expect_identical(find_response(m1), "mpg")
-  })
-
-  test_that("get_response", {
-    expect_equal(get_response(m1), mtcars$mpg)
-  })
-
-  test_that("get_predictors", {
-    expect_equal(colnames(get_predictors(m1)), c("gear", "wt", "cyl"))
-  })
-
-  test_that("link_inverse", {
-    expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
-  })
-
-  test_that("get_data", {
-    expect_equal(nrow(get_data(m1)), 32)
-    expect_equal(colnames(get_data(m1)), c("mpg", "gear", "wt", "cyl"))
-  })
-
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 1)
-    expect_equal(
-      find_formula(m1),
-      list(conditional = as.formula("mpg ~ gear + wt + cyl")),
-      ignore_attr = TRUE
-    )
-  })
-
-  test_that("find_terms", {
-    expect_equal(find_terms(m1), list(
-      response = "mpg",
-      conditional = c("gear", "wt", "cyl")
-    ))
-    expect_equal(find_terms(m1, flatten = TRUE), c("mpg", "gear", "wt", "cyl"))
-  })
-
-  test_that("n_obs", {
-    expect_equal(n_obs(m1), 32)
-  })
-
-  test_that("link_function", {
-    expect_equal(link_function(m1)(0.2), 0.2, tolerance = 1e-5)
-  })
-
-  test_that("link_inverse", {
-    expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
-  })
-
-  test_that("find_parameters", {
-    expect_equal(
-      find_parameters(m1),
-      list(conditional = c("(Intercept)", "gear", "wt", "cyl"))
-    )
-    expect_equal(nrow(get_parameters(m1)), 4)
-    expect_equal(
-      get_parameters(m1)$Parameter,
-      c("(Intercept)", "gear", "wt", "cyl")
-    )
-  })
-
-  test_that("is_multivariate", {
-    expect_false(is_multivariate(m1))
-  })
-
-  test_that("find_algorithm", {
-    expect_warning(expect_null(find_algorithm(m1)))
-  })
-
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "t-statistic")
-  })
-}
+skip_if_not_installed("estimatr")
+
+m1 <- estimatr::lm_robust(mpg ~ gear + wt + cyl, data = mtcars)
+
+test_that("model_info", {
+  expect_true(model_info(m1)$is_linear)
+})
+
+test_that("find_predictors", {
+  expect_identical(find_predictors(m1), list(conditional = c("gear", "wt", "cyl")))
+  expect_identical(find_predictors(m1, flatten = TRUE), c("gear", "wt", "cyl"))
+  expect_null(find_predictors(m1, effects = "random"))
+})
+
+test_that("find_random", {
+  expect_null(find_random(m1))
+})
+
+test_that("get_random", {
+  expect_warning(get_random(m1))
+})
+
+test_that("find_response", {
+  expect_identical(find_response(m1), "mpg")
+})
+
+test_that("get_response", {
+  expect_equal(get_response(m1), mtcars$mpg)
+})
+
+test_that("get_predictors", {
+  expect_equal(colnames(get_predictors(m1)), c("gear", "wt", "cyl"))
+})
+
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
+})
+
+test_that("get_data", {
+  expect_equal(nrow(get_data(m1)), 32)
+  expect_equal(colnames(get_data(m1)), c("mpg", "gear", "wt", "cyl"))
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1), 1)
+  expect_equal(
+    find_formula(m1),
+    list(conditional = as.formula("mpg ~ gear + wt + cyl")),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_terms", {
+  expect_equal(find_terms(m1), list(
+    response = "mpg",
+    conditional = c("gear", "wt", "cyl")
+  ))
+  expect_equal(find_terms(m1, flatten = TRUE), c("mpg", "gear", "wt", "cyl"))
+})
+
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 32)
+})
+
+test_that("link_function", {
+  expect_equal(link_function(m1)(0.2), 0.2, tolerance = 1e-5)
+})
+
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
+})
+
+test_that("find_parameters", {
+  expect_equal(
+    find_parameters(m1),
+    list(conditional = c("(Intercept)", "gear", "wt", "cyl"))
+  )
+  expect_equal(nrow(get_parameters(m1)), 4)
+  expect_equal(
+    get_parameters(m1)$Parameter,
+    c("(Intercept)", "gear", "wt", "cyl")
+  )
+})
+
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1))
+})
+
+test_that("find_algorithm", {
+  expect_warning(expect_null(find_algorithm(m1)))
+})
+
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "t-statistic")
+})
 
 
 test_that("multivariate", {
diff --git a/tests/testthat/test-lme.R b/tests/testthat/test-lme.R
index 124c008ba..2dd2129f9 100644
--- a/tests/testthat/test-lme.R
+++ b/tests/testthat/test-lme.R
@@ -1,249 +1,252 @@
-if (skip_if_not_or_load_if_installed("nlme") && skip_if_not_or_load_if_installed("lme4")) {
-  data("sleepstudy")
-  data(Orthodont)
-  m1 <- lme(Reaction ~ Days,
-    random = ~ 1 + Days | Subject,
-    data = sleepstudy
-  )
+skip_if_not_installed("nlme")
+skip_if_not_installed("lme4")
+
+data(sleepstudy, package = "lme4")
+data(Orthodont, package = "nlme")
+data(Ovary, package = "nlme")
+
+m1 <- nlme::lme(Reaction ~ Days,
+  random = ~ 1 + Days | Subject,
+  data = sleepstudy
+)
+
+m2 <- nlme::lme(distance ~ age + Sex, data = Orthodont, random = ~1)
+
+set.seed(123)
+sleepstudy$mygrp <- sample(1:5, size = 180, replace = TRUE)
+sleepstudy$mysubgrp <- NA
+for (i in 1:5) {
+  filter_group <- sleepstudy$mygrp == i
+  sleepstudy$mysubgrp[filter_group] <-
+    sample(1:30, size = sum(filter_group), replace = TRUE)
+}
+
+m3 <- nlme::lme(Reaction ~ Days,
+  random = ~ 1 | mygrp / mysubgrp,
+  data = sleepstudy
+)
 
-  m2 <- lme(distance ~ age + Sex, data = Orthodont, random = ~1)
+# from easystats/insight/482
+cr <<- nlme::corAR1(form = ~ 1 | Mare)
+m4 <- nlme::lme(follicles ~ Time, Ovary, correlation = cr)
 
-  set.seed(123)
-  sleepstudy$mygrp <- sample(1:5, size = 180, replace = TRUE)
-  sleepstudy$mysubgrp <- NA
-  for (i in 1:5) {
-    filter_group <- sleepstudy$mygrp == i
-    sleepstudy$mysubgrp[filter_group] <-
-      sample(1:30, size = sum(filter_group), replace = TRUE)
-  }
+test_that("nested_varCorr", {
+  skip_on_cran()
 
-  m3 <- lme(Reaction ~ Days,
-    random = ~ 1 | mygrp / mysubgrp,
-    data = sleepstudy
+  expect_equal(
+    insight:::.get_nested_lme_varcorr(m3)$mysubgrp[1, 1],
+    7.508310765,
+    tolerance = 1e-3
   )
+  expect_equal(
+    insight:::.get_nested_lme_varcorr(m3)$mygrp[1, 1],
+    0.004897827,
+    tolerance = 1e-2
+  )
+})
+
 
-  # from easystats/insight/482
-  cr <- corAR1(form = ~ 1 | Mare)
-  m4 <- lme(follicles ~ Time, Ovary, correlation = cr)
+test_that("model_info", {
+  expect_true(model_info(m1)$is_linear)
+})
 
-  test_that("nested_varCorr", {
-    skip_on_cran()
+test_that("find_predictors", {
+  expect_identical(find_predictors(m1), list(conditional = "Days"))
+  expect_identical(find_predictors(m2), list(conditional = c("age", "Sex")))
+  expect_identical(
+    find_predictors(m1, effects = "all"),
+    list(conditional = "Days", random = "Subject")
+  )
+  expect_identical(
+    find_predictors(m2, effects = "all"),
+    list(conditional = c("age", "Sex"), random = "Subject")
+  )
+  expect_identical(find_predictors(m1, flatten = TRUE), "Days")
+  expect_identical(
+    find_predictors(m1, effects = "random"),
+    list(random = "Subject")
+  )
+  expect_identical(
+    find_predictors(m2, effects = "random"),
+    list(random = "Subject")
+  )
+})
+
+test_that("find_response", {
+  expect_identical(find_response(m1), "Reaction")
+  expect_identical(find_response(m2), "distance")
+})
+
+test_that("get_response", {
+  expect_equal(get_response(m1), sleepstudy$Reaction, ignore_attr = TRUE)
+})
+
+test_that("find_random", {
+  expect_identical(find_random(m1), list(random = "Subject"))
+  expect_identical(find_random(m2), list(random = "Subject"))
+})
+
+test_that("get_random", {
+  expect_equal(get_random(m1), data.frame(Subject = sleepstudy$Subject), ignore_attr = TRUE)
+  expect_equal(get_random(m2), data.frame(Subject = Orthodont$Subject), ignore_attr = TRUE)
+})
+
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
+})
+
+test_that("get_data", {
+  expect_equal(nrow(get_data(m1)), 180, ignore_attr = TRUE)
+  expect_identical(colnames(get_data(m1)), c("Reaction", "Days", "Subject"))
+  expect_identical(colnames(get_data(m2)), c("distance", "age", "Sex", "Subject"))
+})
+
+test_that("get_df", {
+  expect_equal(get_df(m1, type = "residual"), c(161, 161), ignore_attr = TRUE)
+  expect_equal(get_df(m1, type = "normal"), Inf, ignore_attr = TRUE)
+  expect_equal(get_df(m1, type = "wald"), c(161, 161), ignore_attr = TRUE)
+  expect_equal(get_df(m2, type = "residual"), c(80, 80, 25), ignore_attr = TRUE)
+  expect_equal(get_df(m2, type = "normal"), Inf, ignore_attr = TRUE)
+  expect_equal(get_df(m3, type = "residual"), c(98, 76), ignore_attr = TRUE)
+  expect_equal(get_df(m3, type = "normal"), Inf, ignore_attr = TRUE)
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1), 2)
+  expect_equal(
+    find_formula(m1),
+    list(
+      conditional = as.formula("Reaction ~ Days"),
+      random = as.formula("~1 + Days | Subject")
+    ),
+    ignore_attr = TRUE
+  )
+  expect_length(find_formula(m2), 2)
+  expect_equal(
+    find_formula(m2),
+    list(
+      conditional = as.formula("distance ~ age + Sex"),
+      random = as.formula("~1 | Subject")
+    ),
+    ignore_attr = TRUE
+  )
+  expect_length(find_formula(m4), 2)
+  expect_equal(
+    find_formula(m4),
+    list(
+      conditional = as.formula("follicles ~ Time"),
+      correlation = as.formula("~1 | Mare")
+    ),
+    ignore_attr = TRUE
+  )
+})
 
-    expect_equal(
-      insight:::.get_nested_lme_varcorr(m3)$mysubgrp[1, 1],
-      7.508310765,
-      tolerance = 1e-3
+test_that("find_variables", {
+  expect_identical(
+    find_variables(m1),
+    list(
+      response = "Reaction",
+      conditional = "Days",
+      random = "Subject"
+    )
+  )
+  expect_identical(
+    find_variables(m1, flatten = TRUE),
+    c("Reaction", "Days", "Subject")
+  )
+  expect_identical(
+    find_variables(m2),
+    list(
+      response = "distance",
+      conditional = c("age", "Sex"),
+      random = "Subject"
     )
-    expect_equal(
-      insight:::.get_nested_lme_varcorr(m3)$mygrp[1, 1],
-      0.004897827,
-      tolerance = 1e-2
+  )
+  expect_identical(
+    find_variables(m4),
+    list(
+      response = "follicles",
+      conditional = "Time",
+      correlation = "Mare"
     )
-  })
+  )
+})
 
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 180, ignore_attr = TRUE)
+})
 
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_linear)
-  })
+test_that("linkfun", {
+  expect_false(is.null(link_function(m1)))
+})
 
-  test_that("find_predictors", {
-    expect_identical(find_predictors(m1), list(conditional = "Days"))
-    expect_identical(find_predictors(m2), list(conditional = c("age", "Sex")))
-    expect_identical(
-      find_predictors(m1, effects = "all"),
-      list(conditional = "Days", random = "Subject")
-    )
-    expect_identical(
-      find_predictors(m2, effects = "all"),
-      list(conditional = c("age", "Sex"), random = "Subject")
-    )
-    expect_identical(find_predictors(m1, flatten = TRUE), "Days")
-    expect_identical(
-      find_predictors(m1, effects = "random"),
-      list(random = "Subject")
-    )
-    expect_identical(
-      find_predictors(m2, effects = "random"),
-      list(random = "Subject")
-    )
-  })
-
-  test_that("find_response", {
-    expect_identical(find_response(m1), "Reaction")
-    expect_identical(find_response(m2), "distance")
-  })
-
-  test_that("get_response", {
-    expect_equal(get_response(m1), sleepstudy$Reaction, ignore_attr = TRUE)
-  })
-
-  test_that("find_random", {
-    expect_identical(find_random(m1), list(random = "Subject"))
-    expect_identical(find_random(m2), list(random = "Subject"))
-  })
-
-  test_that("get_random", {
-    expect_equal(get_random(m1), data.frame(Subject = sleepstudy$Subject), ignore_attr = TRUE)
-    expect_equal(get_random(m2), data.frame(Subject = Orthodont$Subject), ignore_attr = TRUE)
-  })
-
-  test_that("link_inverse", {
-    expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
-  })
-
-  test_that("get_data", {
-    expect_equal(nrow(get_data(m1)), 180, ignore_attr = TRUE)
-    expect_identical(colnames(get_data(m1)), c("Reaction", "Days", "Subject"))
-    expect_identical(colnames(get_data(m2)), c("distance", "age", "Sex", "Subject"))
-  })
-
-  test_that("get_df", {
-    expect_equal(get_df(m1, type = "residual"), c(161, 161), ignore_attr = TRUE)
-    expect_equal(get_df(m1, type = "normal"), Inf, ignore_attr = TRUE)
-    expect_equal(get_df(m1, type = "wald"), c(161, 161), ignore_attr = TRUE)
-    expect_equal(get_df(m2, type = "residual"), c(80, 80, 25), ignore_attr = TRUE)
-    expect_equal(get_df(m2, type = "normal"), Inf, ignore_attr = TRUE)
-    expect_equal(get_df(m3, type = "residual"), c(98, 76), ignore_attr = TRUE)
-    expect_equal(get_df(m3, type = "normal"), Inf, ignore_attr = TRUE)
-  })
-
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 2)
-    expect_equal(
-      find_formula(m1),
-      list(
-        conditional = as.formula("Reaction ~ Days"),
-        random = as.formula("~1 + Days | Subject")
-      ),
-      ignore_attr = TRUE
-    )
-    expect_length(find_formula(m2), 2)
-    expect_equal(
-      find_formula(m2),
-      list(
-        conditional = as.formula("distance ~ age + Sex"),
-        random = as.formula("~1 | Subject")
-      ),
-      ignore_attr = TRUE
+test_that("find_parameters", {
+  expect_identical(
+    find_parameters(m1),
+    list(
+      conditional = c("(Intercept)", "Days"),
+      random = c("(Intercept)", "Days")
     )
-    expect_length(find_formula(m4), 2)
-    expect_equal(
-      find_formula(m4),
-      list(
-        conditional = as.formula("follicles ~ Time"),
-        correlation = as.formula("~1 | Mare")
-      ),
-      ignore_attr = TRUE
-    )
-  })
-
-  test_that("find_variables", {
-    expect_identical(
-      find_variables(m1),
-      list(
-        response = "Reaction",
-        conditional = "Days",
-        random = "Subject"
-      )
-    )
-    expect_identical(
-      find_variables(m1, flatten = TRUE),
-      c("Reaction", "Days", "Subject")
-    )
-    expect_identical(
-      find_variables(m2),
-      list(
-        response = "distance",
-        conditional = c("age", "Sex"),
-        random = "Subject"
-      )
-    )
-    expect_identical(
-      find_variables(m4),
-      list(
-        response = "follicles",
-        conditional = "Time",
-        correlation = "Mare"
-      )
-    )
-  })
-
-  test_that("n_obs", {
-    expect_equal(n_obs(m1), 180, ignore_attr = TRUE)
-  })
-
-  test_that("linkfun", {
-    expect_false(is.null(link_function(m1)))
-  })
-
-  test_that("find_parameters", {
-    expect_identical(
-      find_parameters(m1),
-      list(
-        conditional = c("(Intercept)", "Days"),
-        random = c("(Intercept)", "Days")
-      )
-    )
-    expect_equal(nrow(get_parameters(m1)), 2) # nolint
-    expect_identical(get_parameters(m1)$Parameter, c("(Intercept)", "Days"))
-    expect_identical(
-      find_parameters(m2),
-      list(
-        conditional = c("(Intercept)", "age", "SexFemale"),
-        random = "(Intercept)"
-      )
+  )
+  expect_equal(nrow(get_parameters(m1)), 2) # nolint
+  expect_identical(get_parameters(m1)$Parameter, c("(Intercept)", "Days"))
+  expect_identical(
+    find_parameters(m2),
+    list(
+      conditional = c("(Intercept)", "age", "SexFemale"),
+      random = "(Intercept)"
     )
-  })
+  )
+})
 
-  test_that("find_algorithm", {
-    expect_identical(
-      find_algorithm(m1),
-      list(algorithm = "REML", optimizer = "nlminb")
-    )
-  })
-
-  test_that("get_variance", {
-    skip_on_cran()
-
-    expect_equal(
-      get_variance(m1),
-      list(
-        var.fixed = 908.95336262308865116211,
-        var.random = 1698.06593646939654718153,
-        var.residual = 654.94240352794997761521,
-        var.distribution = 654.94240352794997761521,
-        var.dispersion = 0,
-        var.intercept = c(Subject = 612.07951112963326067984),
-        var.slope = c(Subject.Days = 35.07130179308116169068),
-        cor.slope_intercept = c(Subject = 0.06600000000000000311)
-      ),
-      tolerance = 1e-3
-    )
-  })
-
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "t-statistic")
-    expect_identical(find_statistic(m2), "t-statistic")
-    expect_identical(find_statistic(m3), "t-statistic")
-  })
-
-
-  test_that("Issue #658", {
-    skip_if_not_or_load_if_installed("nlme")
-    models <- lapply(
-      c("", " + Sex"),
-      function(x) {
-        lme(as.formula(paste0("distance  ~ age", x)),
-          random = ~1,
-          data = Orthodont
-        )
-      }
-    )
-    dat <- lapply(models, get_data)
-    form <- lapply(models, find_formula)
-    expect_s3_class(form[[1]], "insight_formula")
-    expect_s3_class(form[[2]], "insight_formula")
-    expect_s3_class(dat[[1]], "data.frame")
-    expect_s3_class(dat[[2]], "data.frame")
-  })
-}
+test_that("find_algorithm", {
+  expect_identical(
+    find_algorithm(m1),
+    list(algorithm = "REML", optimizer = "nlminb")
+  )
+})
+
+test_that("get_variance", {
+  skip_on_cran()
+
+  expect_equal(
+    get_variance(m1),
+    list(
+      var.fixed = 908.95336262308865116211,
+      var.random = 1698.06593646939654718153,
+      var.residual = 654.94240352794997761521,
+      var.distribution = 654.94240352794997761521,
+      var.dispersion = 0,
+      var.intercept = c(Subject = 612.07951112963326067984),
+      var.slope = c(Subject.Days = 35.07130179308116169068),
+      cor.slope_intercept = c(Subject = 0.06600000000000000311)
+    ),
+    tolerance = 1e-3
+  )
+})
+
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "t-statistic")
+  expect_identical(find_statistic(m2), "t-statistic")
+  expect_identical(find_statistic(m3), "t-statistic")
+})
+
+
+test_that("Issue #658", {
+  skip_if_not_installed("nlme")
+  models <- lapply(
+    c("", " + Sex"),
+    function(x) {
+      nlme::lme(as.formula(paste0("distance  ~ age", x)),
+        random = ~1,
+        data = Orthodont
+      )
+    }
+  )
+  dat <- lapply(models, get_data)
+  form <- lapply(models, find_formula)
+  expect_s3_class(form[[1]], "insight_formula")
+  expect_s3_class(form[[2]], "insight_formula")
+  expect_s3_class(dat[[1]], "data.frame")
+  expect_s3_class(dat[[2]], "data.frame")
+})
diff --git a/tests/testthat/test-lmer.R b/tests/testthat/test-lmer.R
index 1062f5923..d569b88df 100644
--- a/tests/testthat/test-lmer.R
+++ b/tests/testthat/test-lmer.R
@@ -1,423 +1,421 @@
-if (skip_if_not_or_load_if_installed("lme4")) {
-  data(sleepstudy)
-  set.seed(123)
-  sleepstudy$mygrp <- sample(1:5, size = 180, replace = TRUE)
-  sleepstudy$mysubgrp <- NA
-  for (i in 1:5) {
-    filter_group <- sleepstudy$mygrp == i
-    sleepstudy$mysubgrp[filter_group] <-
-      sample(1:30, size = sum(filter_group), replace = TRUE)
-  }
-
-  m1 <- lme4::lmer(Reaction ~ Days + (1 + Days | Subject),
+skip_if_not_installed("lme4")
+
+data(sleepstudy, package = "lme4")
+set.seed(123)
+sleepstudy$mygrp <- sample(1:5, size = 180, replace = TRUE)
+sleepstudy$mysubgrp <- NA
+for (i in 1:5) {
+  filter_group <- sleepstudy$mygrp == i
+  sleepstudy$mysubgrp[filter_group] <-
+    sample(1:30, size = sum(filter_group), replace = TRUE)
+}
+
+m1 <- lme4::lmer(Reaction ~ Days + (1 + Days | Subject),
+  data = sleepstudy
+)
+
+m2 <- suppressMessages(
+  lme4::lmer(Reaction ~ Days + (1 | mygrp / mysubgrp) + (1 | Subject),
     data = sleepstudy
   )
-
-  m2 <- suppressMessages(
-    lme4::lmer(Reaction ~ Days + (1 | mygrp / mysubgrp) + (1 | Subject),
-      data = sleepstudy
-    )
+)
+
+test_that("model_info", {
+  expect_true(model_info(m1)$is_linear)
+  expect_true(model_info(m2)$is_linear)
+})
+
+test_that("loglik", {
+  expect_equal(get_loglikelihood(m1, estimator = "REML"), logLik(m1), ignore_attr = TRUE)
+  expect_equal(get_loglikelihood(m2, estimator = "REML"), logLik(m2), ignore_attr = TRUE)
+  expect_equal(get_loglikelihood(m1), logLik(m1), ignore_attr = TRUE)
+  expect_equal(get_loglikelihood(m2), logLik(m2), ignore_attr = TRUE)
+  expect_equal(get_loglikelihood(m1, estimator = "ML"), logLik(m1, REML = FALSE), ignore_attr = TRUE)
+  expect_equal(get_loglikelihood(m2, estimator = "ML"), logLik(m2, REML = FALSE), ignore_attr = TRUE)
+})
+
+test_that("get_df", {
+  expect_equal(get_df(m1), df.residual(m1), ignore_attr = TRUE)
+  expect_equal(get_df(m2), df.residual(m2), ignore_attr = TRUE)
+  expect_equal(get_df(m1, type = "model"), attr(logLik(m1), "df"), ignore_attr = TRUE)
+  expect_equal(get_df(m2, type = "model"), attr(logLik(m2), "df"), ignore_attr = TRUE)
+})
+
+test_that("get_df", {
+  expect_equal(
+    get_df(m1, type = "residual"),
+    df.residual(m1),
+    ignore_attr = TRUE
   )
-
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_linear)
-    expect_true(model_info(m2)$is_linear)
-  })
-
-  test_that("loglik", {
-    expect_equal(get_loglikelihood(m1, estimator = "REML"), logLik(m1), ignore_attr = TRUE)
-    expect_equal(get_loglikelihood(m2, estimator = "REML"), logLik(m2), ignore_attr = TRUE)
-    expect_equal(get_loglikelihood(m1), logLik(m1), ignore_attr = TRUE)
-    expect_equal(get_loglikelihood(m2), logLik(m2), ignore_attr = TRUE)
-    expect_equal(get_loglikelihood(m1, estimator = "ML"), logLik(m1, REML = FALSE), ignore_attr = TRUE)
-    expect_equal(get_loglikelihood(m2, estimator = "ML"), logLik(m2, REML = FALSE), ignore_attr = TRUE)
-  })
-
-  test_that("get_df", {
-    expect_equal(get_df(m1), df.residual(m1), ignore_attr = TRUE)
-    expect_equal(get_df(m2), df.residual(m2), ignore_attr = TRUE)
-    expect_equal(get_df(m1, type = "model"), attr(logLik(m1), "df"), ignore_attr = TRUE)
-    expect_equal(get_df(m2, type = "model"), attr(logLik(m2), "df"), ignore_attr = TRUE)
-  })
-
-  test_that("get_df", {
-    expect_equal(
-      get_df(m1, type = "residual"),
-      df.residual(m1),
-      ignore_attr = TRUE
-    )
-    expect_equal(
-      get_df(m1, type = "normal"),
-      Inf,
-      ignore_attr = TRUE
-    )
-    expect_equal(
-      get_df(m1, type = "wald"),
-      df.residual(m1),
-      ignore_attr = TRUE
-    )
-    expect_equal(
-      get_df(m1, type = "satterthwaite"),
-      c(`(Intercept)` = 16.99973, Days = 16.99998),
-      ignore_attr = TRUE,
-      tolerance = 1e-4
-    )
-    expect_equal(
-      as.vector(get_df(m1, type = "kenward")),
-      c(17, 17),
-      ignore_attr = TRUE,
-      tolerance = 1e-4
-    )
-    if (skip_if_not_or_load_if_installed("pbkrtest")) {
-      expect_equal(
-        as.vector(get_df(m1, type = "kenward")),
-        c(pbkrtest::get_Lb_ddf(m1, c(1, 0)), pbkrtest::get_Lb_ddf(m1, c(0, 1))),
-        ignore_attr = TRUE,
-        tolerance = 1e-4
-      )
-      expect_equal(
-        unique(as.vector(get_df(m2, type = "kenward"))),
-        c(pbkrtest::get_Lb_ddf(m2, c(1, 0)), pbkrtest::get_Lb_ddf(m2, c(0, 1))),
-        ignore_attr = TRUE,
-        tolerance = 1e-4
-      )
-    }
-  })
-
-  test_that("n_parameters", {
-    expect_equal(n_parameters(m1), 2)
-    expect_equal(n_parameters(m2), 2)
-    expect_equal(n_parameters(m1, effects = "random"), 2)
-    expect_equal(n_parameters(m2, effects = "random"), 3)
-  })
-
-  test_that("find_offset", {
-    data(mtcars)
-    model_off <- lmer(log(mpg) ~ disp + (1 | cyl), offset = log(wt), data = mtcars)
-    expect_identical(find_offset(model_off), "wt")
-    model_off <- lmer(log(mpg) ~ disp + (1 | cyl) + offset(log(wt)), data = mtcars)
-    expect_identical(find_offset(model_off), "wt")
-  })
-
-  test_that("find_predictors", {
-    expect_equal(
-      find_predictors(m1, effects = "all"),
-      list(conditional = "Days", random = "Subject")
-    )
-    expect_equal(
-      find_predictors(m1, effects = "all", flatten = TRUE),
-      c("Days", "Subject")
-    )
-    expect_equal(
-      find_predictors(m1, effects = "fixed"),
-      list(conditional = "Days")
-    )
-    expect_equal(
-      find_predictors(m1, effects = "fixed", flatten = TRUE),
-      "Days"
-    )
-    expect_equal(
-      find_predictors(m1, effects = "random"),
-      list(random = "Subject")
-    )
-    expect_equal(
-      find_predictors(m1, effects = "random", flatten = TRUE),
-      "Subject"
-    )
-    expect_equal(
-      find_predictors(m2, effects = "all"),
-      list(
-        conditional = "Days",
-        random = c("mysubgrp", "mygrp", "Subject")
-      )
-    )
-    expect_equal(
-      find_predictors(m2, effects = "all", flatten = TRUE),
-      c("Days", "mysubgrp", "mygrp", "Subject")
-    )
-    expect_equal(
-      find_predictors(m2, effects = "fixed"),
-      list(conditional = "Days")
-    )
-    expect_equal(find_predictors(m2, effects = "random"), list(random = c("mysubgrp", "mygrp", "Subject")))
-    expect_null(find_predictors(m2, effects = "all", component = "zi"))
-    expect_null(find_predictors(m2, effects = "fixed", component = "zi"))
-    expect_null(find_predictors(m2, effects = "random", component = "zi"))
-  })
-
-  test_that("find_random", {
-    expect_equal(find_random(m1), list(random = "Subject"))
-    expect_equal(find_random(m1, flatten = TRUE), "Subject")
-    expect_equal(find_random(m2), list(random = c("mysubgrp:mygrp", "mygrp", "Subject")))
-    expect_equal(find_random(m2, split_nested = TRUE), list(random = c("mysubgrp", "mygrp", "Subject")))
-    expect_equal(
-      find_random(m2, flatten = TRUE),
-      c("mysubgrp:mygrp", "mygrp", "Subject")
-    )
-    expect_equal(
-      find_random(m2, split_nested = TRUE, flatten = TRUE),
-      c("mysubgrp", "mygrp", "Subject")
-    )
-  })
-
-  test_that("find_response", {
-    expect_identical(find_response(m1), "Reaction")
-    expect_identical(find_response(m2), "Reaction")
-  })
-
-  test_that("get_response", {
-    expect_equal(get_response(m1), sleepstudy$Reaction)
-  })
-
-  test_that("link_inverse", {
-    expect_identical(link_inverse(m1)(0.2), 0.2)
-    expect_identical(link_inverse(m2)(0.2), 0.2)
-  })
-
-  test_that("get_data", {
-    expect_equal(colnames(get_data(m1)), c("Reaction", "Days", "Subject"))
-    expect_equal(colnames(get_data(m1, effects = "all")), c("Reaction", "Days", "Subject"))
-    expect_equal(colnames(get_data(m1, effects = "random")), "Subject")
-    expect_equal(
-      colnames(get_data(m2)),
-      c("Reaction", "Days", "mysubgrp", "mygrp", "Subject")
-    )
-    expect_equal(
-      colnames(get_data(m2, effects = "all")),
-      c("Reaction", "Days", "mysubgrp", "mygrp", "Subject")
-    )
-    expect_equal(colnames(get_data(m2, effects = "random")), c("mysubgrp", "mygrp", "Subject"))
-  })
-
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 2)
-    expect_length(find_formula(m2), 2)
-    expect_equal(
-      find_formula(m1, component = "conditional"),
-      list(
-        conditional = as.formula("Reaction ~ Days"),
-        random = as.formula("~1 + Days | Subject")
-      ),
-      ignore_attr = TRUE
-    )
-    expect_equal(
-      find_formula(m2, component = "conditional"),
-      list(
-        conditional = as.formula("Reaction ~ Days"),
-        random = list(
-          as.formula("~1 | mysubgrp:mygrp"),
-          as.formula("~1 | mygrp"),
-          as.formula("~1 | Subject")
-        )
-      ),
-      ignore_attr = TRUE
-    )
-  })
-
-  test_that("find_terms", {
-    expect_identical(
-      find_terms(m1),
-      list(
-        response = "Reaction",
-        conditional = "Days",
-        random = c("Days", "Subject")
-      )
-    )
-    expect_identical(
-      find_terms(m1, flatten = TRUE),
-      c("Reaction", "Days", "Subject")
-    )
-    expect_identical(
-      find_terms(m2),
-      list(
-        response = "Reaction",
-        conditional = "Days",
-        random = c("mysubgrp", "mygrp", "Subject")
-      )
-    )
-    expect_identical(
-      find_terms(m2, flatten = TRUE),
-      c("Reaction", "Days", "mysubgrp", "mygrp", "Subject")
+  expect_equal(
+    get_df(m1, type = "normal"),
+    Inf,
+    ignore_attr = TRUE
+  )
+  expect_equal(
+    get_df(m1, type = "wald"),
+    df.residual(m1),
+    ignore_attr = TRUE
+  )
+  expect_equal(
+    get_df(m1, type = "satterthwaite"),
+    c(`(Intercept)` = 16.99973, Days = 16.99998),
+    ignore_attr = TRUE,
+    tolerance = 1e-4
+  )
+  expect_equal(
+    as.vector(get_df(m1, type = "kenward")),
+    c(17, 17),
+    ignore_attr = TRUE,
+    tolerance = 1e-4
+  )
+  skip_if_not_installed("pbkrtest")
+  expect_equal(
+    as.vector(get_df(m1, type = "kenward")),
+    c(pbkrtest::get_Lb_ddf(m1, c(1, 0)), pbkrtest::get_Lb_ddf(m1, c(0, 1))),
+    ignore_attr = TRUE,
+    tolerance = 1e-4
+  )
+  expect_equal(
+    unique(as.vector(get_df(m2, type = "kenward"))),
+    c(pbkrtest::get_Lb_ddf(m2, c(1, 0)), pbkrtest::get_Lb_ddf(m2, c(0, 1))),
+    ignore_attr = TRUE,
+    tolerance = 1e-4
+  )
+})
+
+test_that("n_parameters", {
+  expect_equal(n_parameters(m1), 2)
+  expect_equal(n_parameters(m2), 2)
+  expect_equal(n_parameters(m1, effects = "random"), 2)
+  expect_equal(n_parameters(m2, effects = "random"), 3)
+})
+
+test_that("find_offset", {
+  model_off <- lme4::lmer(log(mpg) ~ disp + (1 | cyl), offset = log(wt), data = mtcars)
+  expect_identical(find_offset(model_off), "wt")
+  model_off <- lme4::lmer(log(mpg) ~ disp + (1 | cyl) + offset(log(wt)), data = mtcars)
+  expect_identical(find_offset(model_off), "wt")
+})
+
+test_that("find_predictors", {
+  expect_equal(
+    find_predictors(m1, effects = "all"),
+    list(conditional = "Days", random = "Subject")
+  )
+  expect_equal(
+    find_predictors(m1, effects = "all", flatten = TRUE),
+    c("Days", "Subject")
+  )
+  expect_equal(
+    find_predictors(m1, effects = "fixed"),
+    list(conditional = "Days")
+  )
+  expect_equal(
+    find_predictors(m1, effects = "fixed", flatten = TRUE),
+    "Days"
+  )
+  expect_equal(
+    find_predictors(m1, effects = "random"),
+    list(random = "Subject")
+  )
+  expect_equal(
+    find_predictors(m1, effects = "random", flatten = TRUE),
+    "Subject"
+  )
+  expect_equal(
+    find_predictors(m2, effects = "all"),
+    list(
+      conditional = "Days",
+      random = c("mysubgrp", "mygrp", "Subject")
     )
-  })
-
-  test_that("find_variables", {
-    expect_identical(
-      find_variables(m1),
-      list(
-        response = "Reaction",
-        conditional = "Days",
-        random = "Subject"
+  )
+  expect_equal(
+    find_predictors(m2, effects = "all", flatten = TRUE),
+    c("Days", "mysubgrp", "mygrp", "Subject")
+  )
+  expect_equal(
+    find_predictors(m2, effects = "fixed"),
+    list(conditional = "Days")
+  )
+  expect_equal(find_predictors(m2, effects = "random"), list(random = c("mysubgrp", "mygrp", "Subject")))
+  expect_null(find_predictors(m2, effects = "all", component = "zi"))
+  expect_null(find_predictors(m2, effects = "fixed", component = "zi"))
+  expect_null(find_predictors(m2, effects = "random", component = "zi"))
+})
+
+test_that("find_random", {
+  expect_equal(find_random(m1), list(random = "Subject"))
+  expect_equal(find_random(m1, flatten = TRUE), "Subject")
+  expect_equal(find_random(m2), list(random = c("mysubgrp:mygrp", "mygrp", "Subject")))
+  expect_equal(find_random(m2, split_nested = TRUE), list(random = c("mysubgrp", "mygrp", "Subject")))
+  expect_equal(
+    find_random(m2, flatten = TRUE),
+    c("mysubgrp:mygrp", "mygrp", "Subject")
+  )
+  expect_equal(
+    find_random(m2, split_nested = TRUE, flatten = TRUE),
+    c("mysubgrp", "mygrp", "Subject")
+  )
+})
+
+test_that("find_response", {
+  expect_identical(find_response(m1), "Reaction")
+  expect_identical(find_response(m2), "Reaction")
+})
+
+test_that("get_response", {
+  expect_equal(get_response(m1), sleepstudy$Reaction)
+})
+
+test_that("link_inverse", {
+  expect_identical(link_inverse(m1)(0.2), 0.2)
+  expect_identical(link_inverse(m2)(0.2), 0.2)
+})
+
+test_that("get_data", {
+  expect_equal(colnames(get_data(m1)), c("Reaction", "Days", "Subject"))
+  expect_equal(colnames(get_data(m1, effects = "all")), c("Reaction", "Days", "Subject"))
+  expect_equal(colnames(get_data(m1, effects = "random")), "Subject")
+  expect_equal(
+    colnames(get_data(m2)),
+    c("Reaction", "Days", "mysubgrp", "mygrp", "Subject")
+  )
+  expect_equal(
+    colnames(get_data(m2, effects = "all")),
+    c("Reaction", "Days", "mysubgrp", "mygrp", "Subject")
+  )
+  expect_equal(colnames(get_data(m2, effects = "random")), c("mysubgrp", "mygrp", "Subject"))
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1), 2)
+  expect_length(find_formula(m2), 2)
+  expect_equal(
+    find_formula(m1, component = "conditional"),
+    list(
+      conditional = as.formula("Reaction ~ Days"),
+      random = as.formula("~1 + Days | Subject")
+    ),
+    ignore_attr = TRUE
+  )
+  expect_equal(
+    find_formula(m2, component = "conditional"),
+    list(
+      conditional = as.formula("Reaction ~ Days"),
+      random = list(
+        as.formula("~1 | mysubgrp:mygrp"),
+        as.formula("~1 | mygrp"),
+        as.formula("~1 | Subject")
       )
+    ),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_terms", {
+  expect_identical(
+    find_terms(m1),
+    list(
+      response = "Reaction",
+      conditional = "Days",
+      random = c("Days", "Subject")
     )
-    expect_identical(
-      find_variables(m1, flatten = TRUE),
-      c("Reaction", "Days", "Subject")
-    )
-    expect_identical(
-      find_variables(m2),
-      list(
-        response = "Reaction",
-        conditional = "Days",
-        random = c("mysubgrp", "mygrp", "Subject")
-      )
+  )
+  expect_identical(
+    find_terms(m1, flatten = TRUE),
+    c("Reaction", "Days", "Subject")
+  )
+  expect_identical(
+    find_terms(m2),
+    list(
+      response = "Reaction",
+      conditional = "Days",
+      random = c("mysubgrp", "mygrp", "Subject")
     )
-    expect_identical(
-      find_variables(m2, flatten = TRUE),
-      c("Reaction", "Days", "mysubgrp", "mygrp", "Subject")
+  )
+  expect_identical(
+    find_terms(m2, flatten = TRUE),
+    c("Reaction", "Days", "mysubgrp", "mygrp", "Subject")
+  )
+})
+
+test_that("find_variables", {
+  expect_identical(
+    find_variables(m1),
+    list(
+      response = "Reaction",
+      conditional = "Days",
+      random = "Subject"
     )
-  })
-
-  test_that("get_response", {
-    expect_identical(get_response(m1), sleepstudy$Reaction)
-  })
-
-  test_that("get_predictors", {
-    expect_identical(colnames(get_predictors(m1)), "Days")
-    expect_identical(colnames(get_predictors(m2)), "Days")
-  })
-
-  test_that("get_random", {
-    expect_identical(colnames(get_random(m1)), "Subject")
-    expect_identical(colnames(get_random(m2)), c("mysubgrp", "mygrp", "Subject"))
-  })
-
-  test_that("clean_names", {
-    expect_identical(clean_names(m1), c("Reaction", "Days", "Subject"))
-    expect_identical(
-      clean_names(m2),
-      c("Reaction", "Days", "mysubgrp", "mygrp", "Subject")
+  )
+  expect_identical(
+    find_variables(m1, flatten = TRUE),
+    c("Reaction", "Days", "Subject")
+  )
+  expect_identical(
+    find_variables(m2),
+    list(
+      response = "Reaction",
+      conditional = "Days",
+      random = c("mysubgrp", "mygrp", "Subject")
     )
-  })
-
-  test_that("linkfun", {
-    expect_false(is.null(link_function(m1)))
-    expect_false(is.null(link_function(m2)))
-  })
-
-  test_that("find_parameters", {
-    expect_equal(
-      find_parameters(m1),
-      list(
-        conditional = c("(Intercept)", "Days"),
-        random = list(Subject = c("(Intercept)", "Days"))
-      )
+  )
+  expect_identical(
+    find_variables(m2, flatten = TRUE),
+    c("Reaction", "Days", "mysubgrp", "mygrp", "Subject")
+  )
+})
+
+test_that("get_response", {
+  expect_identical(get_response(m1), sleepstudy$Reaction)
+})
+
+test_that("get_predictors", {
+  expect_identical(colnames(get_predictors(m1)), "Days")
+  expect_identical(colnames(get_predictors(m2)), "Days")
+})
+
+test_that("get_random", {
+  expect_identical(colnames(get_random(m1)), "Subject")
+  expect_identical(colnames(get_random(m2)), c("mysubgrp", "mygrp", "Subject"))
+})
+
+test_that("clean_names", {
+  expect_identical(clean_names(m1), c("Reaction", "Days", "Subject"))
+  expect_identical(
+    clean_names(m2),
+    c("Reaction", "Days", "mysubgrp", "mygrp", "Subject")
+  )
+})
+
+test_that("linkfun", {
+  expect_false(is.null(link_function(m1)))
+  expect_false(is.null(link_function(m2)))
+})
+
+test_that("find_parameters", {
+  expect_equal(
+    find_parameters(m1),
+    list(
+      conditional = c("(Intercept)", "Days"),
+      random = list(Subject = c("(Intercept)", "Days"))
     )
-    expect_equal(nrow(get_parameters(m1)), 2)
-    expect_equal(get_parameters(m1)$Parameter, c("(Intercept)", "Days"))
-
-    expect_equal(
-      find_parameters(m2),
-      list(
-        conditional = c("(Intercept)", "Days"),
-        random = list(
-          `mysubgrp:mygrp` = "(Intercept)",
-          Subject = "(Intercept)",
-          mygrp = "(Intercept)"
-        )
+  )
+  expect_equal(nrow(get_parameters(m1)), 2)
+  expect_equal(get_parameters(m1)$Parameter, c("(Intercept)", "Days"))
+
+  expect_equal(
+    find_parameters(m2),
+    list(
+      conditional = c("(Intercept)", "Days"),
+      random = list(
+        `mysubgrp:mygrp` = "(Intercept)",
+        Subject = "(Intercept)",
+        mygrp = "(Intercept)"
       )
     )
+  )
 
-    expect_equal(nrow(get_parameters(m2)), 2)
-    expect_equal(get_parameters(m2)$Parameter, c("(Intercept)", "Days"))
-    expect_equal(
-      names(get_parameters(m2, effects = "random")),
-      c("mysubgrp:mygrp", "Subject", "mygrp")
-    )
-  })
-
-  test_that("is_multivariate", {
-    expect_false(is_multivariate(m1))
-    expect_false(is_multivariate(m2))
-  })
-
-  test_that("get_variance", {
-    expect_equal(
-      get_variance(m1),
-      list(
-        var.fixed = 908.9534,
-        var.random = 1698.084,
-        var.residual = 654.94,
-        var.distribution = 654.94,
-        var.dispersion = 0,
-        var.intercept = c(Subject = 612.1002),
-        var.slope = c(Subject.Days = 35.07171),
-        cor.slope_intercept = c(Subject = 0.06555124)
-      ),
-      tolerance = 1e-1
-    )
+  expect_equal(nrow(get_parameters(m2)), 2)
+  expect_equal(get_parameters(m2)$Parameter, c("(Intercept)", "Days"))
+  expect_equal(
+    names(get_parameters(m2, effects = "random")),
+    c("mysubgrp:mygrp", "Subject", "mygrp")
+  )
+})
+
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1))
+  expect_false(is_multivariate(m2))
+})
+
+test_that("get_variance", {
+  expect_equal(
+    get_variance(m1),
+    list(
+      var.fixed = 908.9534,
+      var.random = 1698.084,
+      var.residual = 654.94,
+      var.distribution = 654.94,
+      var.dispersion = 0,
+      var.intercept = c(Subject = 612.1002),
+      var.slope = c(Subject.Days = 35.07171),
+      cor.slope_intercept = c(Subject = 0.06555124)
+    ),
+    tolerance = 1e-1
+  )
 
-    expect_equal(get_variance_fixed(m1),
-      c(var.fixed = 908.9534),
-      tolerance = 1e-1
-    )
-    expect_equal(get_variance_random(m1),
-      c(var.random = 1698.084),
-      tolerance = 1e-1
-    )
-    expect_equal(
-      get_variance_residual(m1),
-      c(var.residual = 654.94),
-      tolerance = 1e-1
-    )
-    expect_equal(
-      get_variance_distribution(m1),
-      c(var.distribution = 654.94),
-      tolerance = 1e-1
-    )
-    expect_equal(get_variance_dispersion(m1),
-      c(var.dispersion = 0),
-      tolerance = 1e-1
-    )
+  expect_equal(get_variance_fixed(m1),
+    c(var.fixed = 908.9534),
+    tolerance = 1e-1
+  )
+  expect_equal(get_variance_random(m1),
+    c(var.random = 1698.084),
+    tolerance = 1e-1
+  )
+  expect_equal(
+    get_variance_residual(m1),
+    c(var.residual = 654.94),
+    tolerance = 1e-1
+  )
+  expect_equal(
+    get_variance_distribution(m1),
+    c(var.distribution = 654.94),
+    tolerance = 1e-1
+  )
+  expect_equal(get_variance_dispersion(m1),
+    c(var.dispersion = 0),
+    tolerance = 1e-1
+  )
 
-    expect_equal(
-      get_variance_intercept(m1),
-      c(var.intercept.Subject = 612.1002),
-      tolerance = 1e-1
-    )
-    expect_equal(
-      get_variance_slope(m1),
-      c(var.slope.Subject.Days = 35.07171),
-      tolerance = 1e-1
-    )
-    expect_equal(
-      get_correlation_slope_intercept(m1),
-      c(cor.slope_intercept.Subject = 0.06555124),
-      tolerance = 1e-1
-    )
+  expect_equal(
+    get_variance_intercept(m1),
+    c(var.intercept.Subject = 612.1002),
+    tolerance = 1e-1
+  )
+  expect_equal(
+    get_variance_slope(m1),
+    c(var.slope.Subject.Days = 35.07171),
+    tolerance = 1e-1
+  )
+  expect_equal(
+    get_correlation_slope_intercept(m1),
+    c(cor.slope_intercept.Subject = 0.06555124),
+    tolerance = 1e-1
+  )
 
-    if (TRUE) {
-      expect_equal(
-        suppressWarnings(get_variance(m2)),
-        list(
-          var.fixed = 889.3301,
-          var.residual = 941.8135,
-          var.distribution = 941.8135,
-          var.dispersion = 0,
-          var.intercept = c(
-            `mysubgrp:mygrp` = 0,
-            Subject = 1357.4257,
-            mygrp = 24.4064
-          )
-        ),
-        tolerance = 1e-1
+  expect_equal(
+    suppressWarnings(get_variance(m2)),
+    list(
+      var.fixed = 889.3301,
+      var.residual = 941.8135,
+      var.distribution = 941.8135,
+      var.dispersion = 0,
+      var.intercept = c(
+        `mysubgrp:mygrp` = 0,
+        Subject = 1357.4257,
+        mygrp = 24.4064
       )
-    }
-  })
+    ),
+    tolerance = 1e-1
+  )
+})
 
-  test_that("find_algorithm", {
-    expect_equal(
-      find_algorithm(m1),
-      list(algorithm = "REML", optimizer = "nloptwrap")
-    )
-  })
+test_that("find_algorithm", {
+  expect_equal(
+    find_algorithm(m1),
+    list(algorithm = "REML", optimizer = "nloptwrap")
+  )
+})
 
-  test_that("find_random_slopes", {
-    expect_equal(find_random_slopes(m1), list(random = "Days"))
-    expect_null(find_random_slopes(m2))
-  })
+test_that("find_random_slopes", {
+  expect_equal(find_random_slopes(m1), list(random = "Days"))
+  expect_null(find_random_slopes(m2))
+})
 
 
+suppressMessages({
   m3 <- lme4::lmer(Reaction ~ (1 + Days | Subject),
     data = sleepstudy
   )
@@ -436,128 +434,128 @@ if (skip_if_not_or_load_if_installed("lme4")) {
     Reaction ~ 1 + (1 | mygrp / mysubgrp) + (1 | Subject),
     data = sleepstudy
   )
+})
+
+test_that("find_formula", {
+  expect_equal(
+    find_formula(m3),
+    list(
+      conditional = as.formula("Reaction ~ 1"),
+      random = as.formula("~1 + Days | Subject")
+    ),
+    ignore_attr = TRUE
+  )
 
-  test_that("find_formula", {
-    expect_equal(
-      find_formula(m3),
-      list(
-        conditional = as.formula("Reaction ~ 1"),
-        random = as.formula("~1 + Days | Subject")
-      ),
-      ignore_attr = TRUE
-    )
-
-    expect_equal(
-      find_formula(m5),
-      list(
-        conditional = as.formula("Reaction ~ 1"),
-        random = as.formula("~1 + Days | Subject")
-      ),
-      ignore_attr = TRUE
-    )
+  expect_equal(
+    find_formula(m5),
+    list(
+      conditional = as.formula("Reaction ~ 1"),
+      random = as.formula("~1 + Days | Subject")
+    ),
+    ignore_attr = TRUE
+  )
 
-    expect_equal(
-      find_formula(m4),
-      list(
-        conditional = as.formula("Reaction ~ 1"),
-        random = list(
-          as.formula("~1 | mysubgrp:mygrp"),
-          as.formula("~1 | mygrp"),
-          as.formula("~1 | Subject")
-        )
-      ),
-      ignore_attr = TRUE
-    )
+  expect_equal(
+    find_formula(m4),
+    list(
+      conditional = as.formula("Reaction ~ 1"),
+      random = list(
+        as.formula("~1 | mysubgrp:mygrp"),
+        as.formula("~1 | mygrp"),
+        as.formula("~1 | Subject")
+      )
+    ),
+    ignore_attr = TRUE
+  )
 
-    expect_equal(
-      find_formula(m6),
-      list(
-        conditional = as.formula("Reaction ~ 1"),
-        random = list(
-          as.formula("~1 | mysubgrp:mygrp"),
-          as.formula("~1 | mygrp"),
-          as.formula("~1 | Subject")
-        )
-      ),
-      ignore_attr = TRUE
-    )
-  })
-
-  test_that("satterthwaite dof vs. emmeans", {
-    skip_if_not_or_load_if_installed("emmeans")
-    skip_if_not_or_load_if_installed("pbkrtest")
-
-    v1 <- get_varcov(m2, vcov = "kenward-roger")
-    v2 <- as.matrix(vcovAdj(m2))
-    expect_equal(v1, v2)
-
-    p1 <- get_predicted(m2, ci_method = "satterthwaite", ci = 0.95)
-    p1 <- data.frame(p1)
-    em1 <- ref_grid(
-      object = m2,
-      specs = ~Days,
-      at = list(Days = sleepstudy$Days),
-      lmer.df = "satterthwaite"
-    )
-    em1 <- confint(em1)
-    expect_equal(p1$CI_low, em1$lower.CL)
-    expect_equal(p1$CI_high, em1$upper.CL)
-
-    p2 <- get_predicted(m2, ci_method = "kenward-roger", ci = 0.95)
-    p2 <- data.frame(p2)
-    em2 <- ref_grid(
-      object = m2,
-      specs = ~Days,
-      at = list(Days = sleepstudy$Days),
-      lmer.df = "kenward-roger"
-    )
-    em2 <- confint(em2)
-    expect_equal(p2$CI_low, em2$lower.CL)
-    expect_equal(p2$CI_high, em2$upper.CL)
-  })
-
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "t-statistic")
-    expect_identical(find_statistic(m2), "t-statistic")
-  })
-
-  test_that("get_call", {
-    expect_equal(class(get_call(m1)), "call")
-    expect_equal(class(get_call(m2)), "call")
-  })
-
-  test_that("get_predicted_ci: warning when model matrix and varcovmat do not match", {
-    skip_if(getRversion() < "4.1.0")
-    mod <- suppressMessages(lmer(
-      weight ~ 1 + Time + I(Time^2) + Diet + Time:Diet + I(Time^2):Diet + (1 + Time + I(Time^2) | Chick),
-      data = ChickWeight
-    ))
-    newdata <- ChickWeight[ChickWeight$Time %in% 0:10 & ChickWeight$Chick %in% c(1, 40), ]
-    newdata$Chick[newdata$Chick == "1"] <- NA
-
-    expect_warning(
-      get_predicted(mod, data = newdata, include_random = FALSE, ci = 0.95),
-      regexp = "levels"
-    )
+  expect_equal(
+    find_formula(m6),
+    list(
+      conditional = as.formula("Reaction ~ 1"),
+      random = list(
+        as.formula("~1 | mysubgrp:mygrp"),
+        as.formula("~1 | mygrp"),
+        as.formula("~1 | Subject")
+      )
+    ),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("satterthwaite dof vs. emmeans", {
+  skip_if_not_installed("emmeans")
+  skip_if_not_installed("pbkrtest")
+
+  v1 <- get_varcov(m2, vcov = "kenward-roger")
+  v2 <- as.matrix(pbkrtest::vcovAdj(m2))
+  expect_equal(v1, v2)
+
+  p1 <- get_predicted(m2, ci_method = "satterthwaite", ci = 0.95)
+  p1 <- data.frame(p1)
+  em1 <- emmeans::ref_grid(
+    object = m2,
+    specs = ~Days,
+    at = list(Days = sleepstudy$Days),
+    lmer.df = "satterthwaite"
+  )
+  em1 <- confint(em1)
+  expect_equal(p1$CI_low, em1$lower.CL)
+  expect_equal(p1$CI_high, em1$upper.CL)
+
+  p2 <- get_predicted(m2, ci_method = "kenward-roger", ci = 0.95)
+  p2 <- data.frame(p2)
+  em2 <- emmeans::ref_grid(
+    object = m2,
+    specs = ~Days,
+    at = list(Days = sleepstudy$Days),
+    lmer.df = "kenward-roger"
+  )
+  em2 <- confint(em2)
+  expect_equal(p2$CI_low, em2$lower.CL)
+  expect_equal(p2$CI_high, em2$upper.CL)
+})
+
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "t-statistic")
+  expect_identical(find_statistic(m2), "t-statistic")
+})
+
+test_that("get_call", {
+  expect_equal(class(get_call(m1)), "call")
+  expect_equal(class(get_call(m2)), "call")
+})
+
+test_that("get_predicted_ci: warning when model matrix and varcovmat do not match", {
+  skip_if(getRversion() < "4.1.0")
+  mod <- suppressMessages(lme4::lmer(
+    weight ~ 1 + Time + I(Time^2) + Diet + Time:Diet + I(Time^2):Diet + (1 + Time + I(Time^2) | Chick),
+    data = ChickWeight
+  ))
+  newdata <- ChickWeight[ChickWeight$Time %in% 0:10 & ChickWeight$Chick %in% c(1, 40), ]
+  newdata$Chick[newdata$Chick == "1"] <- NA
+
+  expect_warning(
+    get_predicted(mod, data = newdata, include_random = FALSE, ci = 0.95),
+    regexp = "levels"
+  )
 
-    # VAB: Not sure where these hard-coded values come from
-    # Related to Issue #693. Not sure if these are valid since we arbitrarily
-    # shrink the varcov and mm to be conformable. In some cases documented in
-    # Issue #556 of {marginaleffects}, we know that this produces incorrect
-    # results, so it's probably best to be conservative and not return results
-    # here.
-    known <- data.frame(
-      Predicted = c(37.53433, 47.95719, 58.78866, 70.02873, 81.67742, 93.73472),
-      SE = c(1.68687, 0.82574, 1.52747, 2.56109, 3.61936, 4.76178),
-      CI_low = c(34.22096, 46.33525, 55.78837, 64.99819, 74.56822, 84.38154),
-      CI_high = c(40.84771, 49.57913, 61.78894, 75.05927, 88.78662, 103.08789)
-    )
+  # VAB: Not sure where these hard-coded values come from
+  # Related to Issue #693. Not sure if these are valid since we arbitrarily
+  # shrink the varcov and mm to be conformable. In some cases documented in
+  # Issue #556 of {marginaleffects}, we know that this produces incorrect
+  # results, so it's probably best to be conservative and not return results
+  # here.
+  known <- data.frame(
+    Predicted = c(37.53433, 47.95719, 58.78866, 70.02873, 81.67742, 93.73472),
+    SE = c(1.68687, 0.82574, 1.52747, 2.56109, 3.61936, 4.76178),
+    CI_low = c(34.22096, 46.33525, 55.78837, 64.99819, 74.56822, 84.38154),
+    CI_high = c(40.84771, 49.57913, 61.78894, 75.05927, 88.78662, 103.08789)
+  )
 
-    p <- suppressWarnings(get_predicted(mod, data = newdata, include_random = FALSE, ci = 0.95))
-    expect_equal(
-      head(data.frame(p)$Predicted),
-      known$Predicted,
-      tolerance = 1e-3
-    )
-  })
-}
+  p <- suppressWarnings(get_predicted(mod, data = newdata, include_random = FALSE, ci = 0.95))
+  expect_equal(
+    head(data.frame(p)$Predicted),
+    known$Predicted,
+    tolerance = 1e-3
+  )
+})
diff --git a/tests/testthat/test-lmrob_base.R b/tests/testthat/test-lmrob_base.R
index 4ea6a0b3e..270c5fa42 100644
--- a/tests/testthat/test-lmrob_base.R
+++ b/tests/testthat/test-lmrob_base.R
@@ -1,94 +1,91 @@
-if (
-
-  skip_if_not_or_load_if_installed("robustbase")) {
-  data(mtcars)
-  m1 <- lmrob(mpg ~ gear + wt + cyl, data = mtcars)
-
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_linear)
-  })
-
-  test_that("find_predictors", {
-    expect_identical(find_predictors(m1), list(conditional = c("gear", "wt", "cyl")))
-    expect_identical(find_predictors(m1, flatten = TRUE), c("gear", "wt", "cyl"))
-    expect_null(find_predictors(m1, effects = "random"))
-  })
-
-  test_that("find_random", {
-    expect_null(find_random(m1))
-  })
-
-  test_that("get_random", {
-    expect_warning(get_random(m1))
-  })
-
-  test_that("find_response", {
-    expect_identical(find_response(m1), "mpg")
-  })
-
-  test_that("get_response", {
-    expect_equal(get_response(m1), mtcars$mpg)
-  })
-
-  test_that("get_predictors", {
-    expect_equal(colnames(get_predictors(m1)), c("gear", "wt", "cyl"))
-  })
-
-  test_that("get_data", {
-    expect_equal(nrow(get_data(m1)), 32)
-    expect_equal(colnames(get_data(m1)), c("mpg", "gear", "wt", "cyl"))
-  })
-
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 1)
-    expect_equal(
-      find_formula(m1),
-      list(conditional = as.formula("mpg ~ gear + wt + cyl")),
-      ignore_attr = TRUE
-    )
-  })
-
-  test_that("find_terms", {
-    expect_equal(find_terms(m1), list(
-      response = "mpg",
-      conditional = c("gear", "wt", "cyl")
-    ))
-    expect_equal(find_terms(m1, flatten = TRUE), c("mpg", "gear", "wt", "cyl"))
-  })
-
-  test_that("n_obs", {
-    expect_equal(n_obs(m1), 32)
-  })
-
-  test_that("link_function", {
-    expect_equal(link_function(m1)(0.2), 0.2, tolerance = 1e-5)
-  })
-
-  test_that("link_inverse", {
-    expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
-  })
-
-  test_that("find_parameters", {
-    expect_equal(
-      find_parameters(m1),
-      list(conditional = c("(Intercept)", "gear", "wt", "cyl"))
-    )
-    expect_equal(nrow(get_parameters(m1)), 4)
-    expect_equal(
-      get_parameters(m1)$Parameter,
-      c("(Intercept)", "gear", "wt", "cyl")
-    )
-  })
-
-  test_that("is_multivariate", {
-    expect_false(is_multivariate(m1))
-  })
-
-  test_that("find_algorithm", {
-    expect_equal(find_algorithm(m1), list(algorithm = "SM"))
-  })
-
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "t-statistic")
-  })
-}
+skip_if_not_installed("robustbase")
+
+m1 <- robustbase::lmrob(mpg ~ gear + wt + cyl, data = mtcars)
+
+test_that("model_info", {
+  expect_true(model_info(m1)$is_linear)
+})
+
+test_that("find_predictors", {
+  expect_identical(find_predictors(m1), list(conditional = c("gear", "wt", "cyl")))
+  expect_identical(find_predictors(m1, flatten = TRUE), c("gear", "wt", "cyl"))
+  expect_null(find_predictors(m1, effects = "random"))
+})
+
+test_that("find_random", {
+  expect_null(find_random(m1))
+})
+
+test_that("get_random", {
+  expect_warning(get_random(m1))
+})
+
+test_that("find_response", {
+  expect_identical(find_response(m1), "mpg")
+})
+
+test_that("get_response", {
+  expect_equal(get_response(m1), mtcars$mpg)
+})
+
+test_that("get_predictors", {
+  expect_equal(colnames(get_predictors(m1)), c("gear", "wt", "cyl"))
+})
+
+test_that("get_data", {
+  expect_equal(nrow(get_data(m1)), 32)
+  expect_equal(colnames(get_data(m1)), c("mpg", "gear", "wt", "cyl"))
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1), 1)
+  expect_equal(
+    find_formula(m1),
+    list(conditional = as.formula("mpg ~ gear + wt + cyl")),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_terms", {
+  expect_equal(find_terms(m1), list(
+    response = "mpg",
+    conditional = c("gear", "wt", "cyl")
+  ))
+  expect_equal(find_terms(m1, flatten = TRUE), c("mpg", "gear", "wt", "cyl"))
+})
+
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 32)
+})
+
+test_that("link_function", {
+  expect_equal(link_function(m1)(0.2), 0.2, tolerance = 1e-5)
+})
+
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
+})
+
+test_that("find_parameters", {
+  expect_equal(
+    find_parameters(m1),
+    list(conditional = c("(Intercept)", "gear", "wt", "cyl"))
+  )
+  expect_equal(nrow(get_parameters(m1)), 4)
+  expect_equal(
+    get_parameters(m1)$Parameter,
+    c("(Intercept)", "gear", "wt", "cyl")
+  )
+})
+
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1))
+})
+
+test_that("find_algorithm", {
+  expect_equal(find_algorithm(m1), list(algorithm = "SM"))
+})
+
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "t-statistic")
+})
diff --git a/tests/testthat/test-lmtest.R b/tests/testthat/test-lmtest.R
index 9bb7e76a8..7c1132d44 100644
--- a/tests/testthat/test-lmtest.R
+++ b/tests/testthat/test-lmtest.R
@@ -1,15 +1,14 @@
-if (skip_if_not_or_load_if_installed("lmtest")) {
-  data("Mandible", package = "lmtest")
-  m <- lm(length ~ age, data = Mandible, subset = (age <= 28))
-  ct1 <- coeftest(m)
-  ct2 <- coeftest(m, df = Inf)
+skip_if_not_installed("lmtest")
+data("Mandible", package = "lmtest")
+m <- lm(length ~ age, data = Mandible, subset = (age <= 28))
+ct1 <- lmtest::coeftest(m)
+ct2 <- lmtest::coeftest(m, df = Inf)
 
-  test_that("find_statistic", {
-    expect_equal(find_statistic(ct1), "t-statistic")
-    expect_equal(find_statistic(ct2), "z-statistic")
-  })
-  test_that("get_statistic", {
-    expect_equal(get_statistic(ct1)$Statistic, c(-12.24446, 37.16067), tolerance = 1e-3)
-    expect_equal(get_statistic(ct2)$Statistic, c(-12.24446, 37.16067), tolerance = 1e-3)
-  })
-}
+test_that("find_statistic", {
+  expect_equal(find_statistic(ct1), "t-statistic")
+  expect_equal(find_statistic(ct2), "z-statistic")
+})
+test_that("get_statistic", {
+  expect_equal(get_statistic(ct1)$Statistic, c(-12.24446, 37.16067), tolerance = 1e-3)
+  expect_equal(get_statistic(ct2)$Statistic, c(-12.24446, 37.16067), tolerance = 1e-3)
+})
diff --git a/tests/testthat/test-logistf.R b/tests/testthat/test-logistf.R
index 8f5cb4738..4d1db0963 100644
--- a/tests/testthat/test-logistf.R
+++ b/tests/testthat/test-logistf.R
@@ -1,118 +1,115 @@
-testthat::skip_on_covr()
-
-if (
-
-  skip_if_not_or_load_if_installed("logistf")) {
-  data(sex2)
-  m1 <- logistf(case ~ age + oc + vic + vicl + vis + dia, data = sex2)
-
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_binomial)
-    expect_true(model_info(m1)$is_logit)
-    expect_false(model_info(m1)$is_linear)
-  })
-
-  test_that("find_predictors", {
-    expect_identical(find_predictors(m1), list(conditional = c(
-      "age", "oc", "vic", "vicl", "vis", "dia"
-    )))
-    expect_identical(
-      find_predictors(m1, flatten = TRUE),
-      c("age", "oc", "vic", "vicl", "vis", "dia")
+skip_on_covr()
+skip_if_not_installed("logistf")
+
+data(sex2, package = "logistf")
+m1 <- logistf::logistf(case ~ age + oc + vic + vicl + vis + dia, data = sex2)
+
+test_that("model_info", {
+  expect_true(model_info(m1)$is_binomial)
+  expect_true(model_info(m1)$is_logit)
+  expect_false(model_info(m1)$is_linear)
+})
+
+test_that("find_predictors", {
+  expect_identical(find_predictors(m1), list(conditional = c(
+    "age", "oc", "vic", "vicl", "vis", "dia"
+  )))
+  expect_identical(
+    find_predictors(m1, flatten = TRUE),
+    c("age", "oc", "vic", "vicl", "vis", "dia")
+  )
+  expect_null(find_predictors(m1, effects = "random"))
+})
+
+test_that("find_random", {
+  expect_null(find_random(m1))
+})
+
+test_that("get_random", {
+  expect_warning(get_random(m1))
+})
+
+test_that("find_response", {
+  expect_identical(find_response(m1), "case")
+})
+
+test_that("get_response", {
+  expect_equal(get_response(m1), sex2$case)
+})
+
+test_that("get_predictors", {
+  expect_equal(
+    colnames(get_predictors(m1)),
+    c("age", "oc", "vic", "vicl", "vis", "dia")
+  )
+})
+
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), plogis(0.2), tolerance = 1e-5)
+})
+
+test_that("get_data", {
+  expect_equal(nrow(get_data(m1)), 239)
+  expect_equal(
+    colnames(get_data(m1)),
+    c("case", "age", "oc", "vic", "vicl", "vis", "dia")
+  )
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1), 1)
+  expect_equal(
+    find_formula(m1),
+    list(conditional = as.formula("case ~ age + oc + vic + vicl + vis + dia")),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_terms", {
+  expect_equal(find_terms(m1), list(
+    response = "case",
+    conditional = c("age", "oc", "vic", "vicl", "vis", "dia")
+  ))
+  expect_equal(
+    find_terms(m1, flatten = TRUE),
+    c("case", "age", "oc", "vic", "vicl", "vis", "dia")
+  )
+})
+
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 239)
+})
+
+test_that("linkfun", {
+  expect_false(is.null(link_function(m1)))
+})
+
+test_that("linkinverse", {
+  expect_false(is.null(link_inverse(m1)))
+})
+
+test_that("find_parameters", {
+  expect_equal(
+    find_parameters(m1),
+    list(
+      conditional = c("(Intercept)", "age", "oc", "vic", "vicl", "vis", "dia")
     )
-    expect_null(find_predictors(m1, effects = "random"))
-  })
-
-  test_that("find_random", {
-    expect_null(find_random(m1))
-  })
-
-  test_that("get_random", {
-    expect_warning(get_random(m1))
-  })
-
-  test_that("find_response", {
-    expect_identical(find_response(m1), "case")
-  })
-
-  test_that("get_response", {
-    expect_equal(get_response(m1), sex2$case)
-  })
-
-  test_that("get_predictors", {
-    expect_equal(
-      colnames(get_predictors(m1)),
-      c("age", "oc", "vic", "vicl", "vis", "dia")
-    )
-  })
-
-  test_that("link_inverse", {
-    expect_equal(link_inverse(m1)(0.2), plogis(0.2), tolerance = 1e-5)
-  })
-
-  test_that("get_data", {
-    expect_equal(nrow(get_data(m1)), 239)
-    expect_equal(
-      colnames(get_data(m1)),
-      c("case", "age", "oc", "vic", "vicl", "vis", "dia")
-    )
-  })
-
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 1)
-    expect_equal(
-      find_formula(m1),
-      list(conditional = as.formula("case ~ age + oc + vic + vicl + vis + dia")),
-      ignore_attr = TRUE
-    )
-  })
-
-  test_that("find_terms", {
-    expect_equal(find_terms(m1), list(
-      response = "case",
-      conditional = c("age", "oc", "vic", "vicl", "vis", "dia")
-    ))
-    expect_equal(
-      find_terms(m1, flatten = TRUE),
-      c("case", "age", "oc", "vic", "vicl", "vis", "dia")
-    )
-  })
-
-  test_that("n_obs", {
-    expect_equal(n_obs(m1), 239)
-  })
-
-  test_that("linkfun", {
-    expect_false(is.null(link_function(m1)))
-  })
-
-  test_that("linkinverse", {
-    expect_false(is.null(link_inverse(m1)))
-  })
-
-  test_that("find_parameters", {
-    expect_equal(
-      find_parameters(m1),
-      list(
-        conditional = c("(Intercept)", "age", "oc", "vic", "vicl", "vis", "dia")
-      )
-    )
-    expect_equal(nrow(get_parameters(m1)), 7)
-    expect_equal(
-      get_parameters(m1)$Parameter,
-      c("(Intercept)", "age", "oc", "vic", "vicl", "vis", "dia")
-    )
-  })
-
-  test_that("is_multivariate", {
-    expect_false(is_multivariate(m1))
-  })
-
-  test_that("find_algorithm", {
-    expect_equal(find_algorithm(m1), list(algorithm = "Penalized ML"))
-  })
-
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "chi-squared statistic")
-  })
-}
+  )
+  expect_equal(nrow(get_parameters(m1)), 7)
+  expect_equal(
+    get_parameters(m1)$Parameter,
+    c("(Intercept)", "age", "oc", "vic", "vicl", "vis", "dia")
+  )
+})
+
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1))
+})
+
+test_that("find_algorithm", {
+  expect_equal(find_algorithm(m1), list(algorithm = "Penalized ML"))
+})
+
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "chi-squared statistic")
+})
diff --git a/tests/testthat/test-logitr.R b/tests/testthat/test-logitr.R
index d65faab40..1a272f8af 100644
--- a/tests/testthat/test-logitr.R
+++ b/tests/testthat/test-logitr.R
@@ -1,6 +1,7 @@
-skip_if_not_or_load_if_installed("logitr")
 skip_if_not_installed("logitr", minimum_version = "0.8.0")
 
+data(yogurt, package = "logitr")
+
 mod <- suppressMessages(logitr::logitr(
   data    = yogurt,
   outcome = "choice",
diff --git a/tests/testthat/test-marginaleffects.R b/tests/testthat/test-marginaleffects.R
index 94ceb1382..a1979054b 100644
--- a/tests/testthat/test-marginaleffects.R
+++ b/tests/testthat/test-marginaleffects.R
@@ -1,11 +1,11 @@
-testthat::skip_on_cran()
-skip_if_not_or_load_if_installed("marginaleffects")
-skip_if_not_or_load_if_installed("emmeans")
+skip_on_cran()
+skip_if_not_installed("marginaleffects")
+skip_if_not_installed("emmeans")
 
 test_that("marginaleffects", {
   m <- lm(Sepal.Width ~ Species * Petal.Length, data = iris)
 
-  x <- marginaleffects(m,
+  x <- marginaleffects::marginaleffects(m,
     variables = "Petal.Length",
     newdata = insight::get_datagrid(m, at = "Species")
   )
diff --git a/tests/testthat/test-mclogit.R b/tests/testthat/test-mclogit.R
index 76c00e8cb..fc533a8b0 100644
--- a/tests/testthat/test-mclogit.R
+++ b/tests/testthat/test-mclogit.R
@@ -1,21 +1,20 @@
-skip_if_not_or_load_if_installed("mclogit")
+skip_if_not_installed("mclogit")
 
-data(Transport)
-mod_mb <- mblogit(factor(gear) ~ mpg + hp, data = mtcars, trace = FALSE)
-mod_mc <- mclogit(resp | suburb ~ distance + cost, data = Transport, trace = FALSE)
+data(Transport, package = "mclogit")
+mod_mb <- mclogit::mblogit(factor(gear) ~ mpg + hp, data = mtcars, trace = FALSE)
+mod_mc <- mclogit::mclogit(resp | suburb ~ distance + cost, data = Transport, trace = FALSE)
 
 test_that("mblogit and mclogit is not linear", {
-  if (packageVersion("mclogit") >= "0.9.1") {
-    expect_false(model_info(mod_mb)$is_linear)
-    expect_true(model_info(mod_mb)$is_logit)
-    expect_true(is_model(mod_mb))
-    expect_true(is_model_supported(mod_mb))
+  skip_if_not(packageVersion("mclogit") >= "0.9.1")
+  expect_false(model_info(mod_mb)$is_linear)
+  expect_true(model_info(mod_mb)$is_logit)
+  expect_true(is_model(mod_mb))
+  expect_true(is_model_supported(mod_mb))
 
-    expect_false(model_info(mod_mc)$is_linear)
-    expect_true(model_info(mod_mc)$is_logit)
-    expect_true(is_model(mod_mc))
-    expect_true(is_model_supported(mod_mc))
-  }
+  expect_false(model_info(mod_mc)$is_linear)
+  expect_true(model_info(mod_mc)$is_logit)
+  expect_true(is_model(mod_mc))
+  expect_true(is_model_supported(mod_mc))
 })
 
 test_that("get_parameters", {
diff --git a/tests/testthat/test-metaBMA.R b/tests/testthat/test-metaBMA.R
index e67b5a7df..d181d53af 100644
--- a/tests/testthat/test-metaBMA.R
+++ b/tests/testthat/test-metaBMA.R
@@ -1,32 +1,32 @@
-if (skip_if_not_or_load_if_installed("metaBMA")) {
-  data(towels)
-  set.seed(123)
-  mf <- meta_fixed(logOR,
-    SE,
-    study,
-    data = towels,
-    d = prior("norm", c(mean = 0, sd = 0.3), lower = 0)
-  )
+skip_if_not_installed("metaBMA")
 
-  test_that("get_priors-metaBMA", {
-    priors <- get_priors(mf)
-    expect_identical(priors$Distribution, "Normal")
-    expect_equal(priors$Scale, 0.3, tolerance = 1e-2)
-  })
+data(towels, package = "metaBMA")
+set.seed(123)
+mf <- metaBMA::meta_fixed(logOR,
+  SE,
+  study,
+  data = towels,
+  d = metaBMA::prior("norm", c(mean = 0, sd = 0.3), lower = 0)
+)
 
+test_that("get_priors-metaBMA", {
+  priors <- get_priors(mf)
+  expect_identical(priors$Distribution, "Normal")
+  expect_equal(priors$Scale, 0.3, tolerance = 1e-2)
+})
 
-  set.seed(123)
-  mr <- suppressWarnings(
-    meta_random(logOR, SE, study,
-      data = towels,
-      d = prior("cauchy", c(location = 0, scale = 0.707)),
-      tau = prior("invgamma", c(shape = 1, scale = 0.15))
-    )
+
+set.seed(123)
+mr <- suppressWarnings(
+  metaBMA::meta_random(logOR, SE, study,
+    data = towels,
+    d = metaBMA::prior("cauchy", c(location = 0, scale = 0.707)),
+    tau = metaBMA::prior("invgamma", c(shape = 1, scale = 0.15))
   )
+)
 
-  test_that("get_priors-metaBMA", {
-    priors <- get_priors(mr)
-    expect_identical(priors$Distribution, c("Student's t", "Inverse gamma"))
-    expect_equal(priors$Scale, c(0.707, 0.15), tolerance = 1e-2)
-  })
-}
+test_that("get_priors-metaBMA", {
+  priors <- get_priors(mr)
+  expect_identical(priors$Distribution, c("Student's t", "Inverse gamma"))
+  expect_equal(priors$Scale, c(0.707, 0.15), tolerance = 1e-2)
+})
diff --git a/tests/testthat/test-metafor.R b/tests/testthat/test-metafor.R
index 651f32b61..4f351a026 100644
--- a/tests/testthat/test-metafor.R
+++ b/tests/testthat/test-metafor.R
@@ -1,56 +1,57 @@
-if (skip_if_not_or_load_if_installed("metafor")) {
-  d <- data.frame(
-    estimate = c(0.111, 0.245, 0.8, 1.1, 0.03),
-    std.error = c(0.05, 0.111, 0.001, 0.2, 0.01)
-  )
-  mydat <<- d
-  model <- metafor::rma(yi = estimate, sei = std.error, data = mydat)
-
-  test_that("model_info", {
-    expect_true(model_info(model)$is_linear)
-    expect_true(model_info(model)$is_meta)
-  })
+skip_if_not_installed("metafor")
+skip_if_not_installed("metadat")
 
-  test_that("find_formula", {
-    expect_equal(
-      find_formula(model),
-      list(conditional = estimate ~ 1),
-      ignore_attr = TRUE
-    )
-  })
+d <- data.frame(
+  estimate = c(0.111, 0.245, 0.8, 1.1, 0.03),
+  std.error = c(0.05, 0.111, 0.001, 0.2, 0.01)
+)
+mydat <<- d
+model <- metafor::rma(yi = estimate, sei = std.error, data = mydat)
 
-  out <- get_data(model)
-  test_that("get_data", {
-    expect_equal(
-      out$estimate,
-      c(0.111, 0.245, 0.8, 1.1, 0.03),
-      tolerance = 1e-3
-    )
-    expect_identical(dim(out), as.integer(c(5, 3)))
-    expect_identical(colnames(out), c("estimate", "std.error", "Weights"))
-  })
+test_that("model_info", {
+  expect_true(model_info(model)$is_linear)
+  expect_true(model_info(model)$is_meta)
+})
 
-  out <- get_data(model, source = "mf")
-  test_that("get_data, modelframe", {
-    expect_identical(dim(out), as.integer(c(5, 3)))
-    expect_identical(colnames(out), c("estimate", "std.error", "Weights"))
-  })
+test_that("find_formula", {
+  expect_equal(
+    find_formula(model),
+    list(conditional = estimate ~ 1),
+    ignore_attr = TRUE
+  )
+})
 
-  data(dat.bcg)
-  dat <- escalc(
-    measure = "RR", ai = tpos, bi = tneg, ci = cpos,
-    di = cneg, data = dat.bcg
+out <- get_data(model)
+test_that("get_data", {
+  expect_equal(
+    out$estimate,
+    c(0.111, 0.245, 0.8, 1.1, 0.03),
+    tolerance = 1e-3
   )
-  dat$alloc <- ifelse(dat$alloc == "random", "random", "other")
-  model <- rma(yi, vi,
-    mods = ~alloc, data = dat, digits = 3,
-    slab = author
+  expect_identical(dim(out), as.integer(c(5, 3)))
+  expect_identical(colnames(out), c("estimate", "std.error", "Weights"))
+})
+
+out <- get_data(model, source = "mf")
+test_that("get_data, modelframe", {
+  expect_identical(dim(out), as.integer(c(5, 3)))
+  expect_identical(colnames(out), c("estimate", "std.error", "Weights"))
+})
+
+data(dat.bcg, package = "metadat")
+dat <- metafor::escalc(
+  measure = "RR", ai = tpos, bi = tneg, ci = cpos,
+  di = cneg, data = dat.bcg
+)
+dat$alloc <- ifelse(dat$alloc == "random", "random", "other")
+model <- metafor::rma(yi, vi,
+  mods = ~alloc, data = dat, digits = 3,
+  slab = author
+)
+test_that("get_data, modelframe", {
+  expect_equal(
+    find_formula(model),
+    list(conditional = yi ~ alloc, dispersion = yi ~ alloc),
+    ignore_attr = TRUE
   )
-  test_that("get_data, modelframe", {
-    expect_equal(
-      find_formula(model),
-      list(conditional = yi ~ alloc, dispersion = yi ~ alloc),
-      ignore_attr = TRUE
-    )
-  })
-}
+})
diff --git a/tests/testthat/test-metaplus.R b/tests/testthat/test-metaplus.R
index 1c4329119..d75e3dd57 100644
--- a/tests/testthat/test-metaplus.R
+++ b/tests/testthat/test-metaplus.R
@@ -1,7 +1,7 @@
-skip_if_not_or_load_if_installed("metaplus")
+skip_if_not_installed("metaplus")
 
-data(mag)
-m <- metaplus(yi, sei, slab = study, data = mag)
+data(mag, package = "metaplus")
+m <- metaplus::metaplus(yi, sei, slab = study, data = mag)
 
 test_that("find_parameters", {
   expect_identical(
diff --git a/tests/testthat/test-mhurdle.R b/tests/testthat/test-mhurdle.R
index 8b92ade1b..b1f2e808c 100644
--- a/tests/testthat/test-mhurdle.R
+++ b/tests/testthat/test-mhurdle.R
@@ -1,7 +1,8 @@
-skip_if_not_or_load_if_installed("mhurdle")
+skip_if_not_installed("mhurdle")
+
 data("Interview", package = "mhurdle")
-m1 <- mhurdle(shows ~ 0 | linc + smsa + age + educ + size, data = Interview, h2 = TRUE, dist = "n", method = "bhhh")
-m2 <- mhurdle(shows ~ educ + size | linc | smsa + age,
+m1 <- mhurdle::mhurdle(shows ~ 0 | linc + smsa + age + educ + size, data = Interview, h2 = TRUE, dist = "n", method = "bhhh")
+m2 <- mhurdle::mhurdle(shows ~ educ + size | linc | smsa + age,
   data = Interview,
   h2 = FALSE, method = "bhhh", corr = TRUE, finalHessian = TRUE
 )
diff --git a/tests/testthat/test-mipo.R b/tests/testthat/test-mipo.R
index e151343c1..a0123a668 100644
--- a/tests/testthat/test-mipo.R
+++ b/tests/testthat/test-mipo.R
@@ -8,9 +8,11 @@ test_that("param", {
   imp <- suppressWarnings(mice::mice(d$amp, m = 2, printFlag = FALSE))
   imp.l <- mice::complete(imp, action = "long")
   model <- list() ## Fit and pool models
-  for (i in 1:2) capture.output({
-    model[[i]] <- nnet::multinom(cyl ~ disp + hp, data = imp.l, subset = .imp == i)
-  })
+  for (i in 1:2) {
+    capture.output({
+      model[[i]] <- nnet::multinom(cyl ~ disp + hp, data = imp.l, subset = .imp == i)
+    })
+  }
   pooled <- mice::pool(model)
 
   expect_snapshot(get_parameters(pooled))
diff --git a/tests/testthat/test-mlogit.R b/tests/testthat/test-mlogit.R
index f764b53a5..aa3b0f385 100644
--- a/tests/testthat/test-mlogit.R
+++ b/tests/testthat/test-mlogit.R
@@ -1,125 +1,125 @@
-if (skip_if_not_or_load_if_installed("mlogit") && skip_if_not_or_load_if_installed("mclogit")) {
-  data("Fishing")
-  Fish <-
-    mlogit.data(Fishing,
-      varying = 2:9,
-      shape = "wide",
-      choice = "mode"
-    )
+skip_if_not_installed("mlogit")
 
-  m1 <- mlogit(mode ~ price + catch, data = Fish)
-  m2 <- mlogit(mode ~ price + catch | income, data = Fish)
+data("Fishing", package = "mlogit")
+Fish <-
+  mlogit::mlogit.data(Fishing,
+    varying = 2:9,
+    shape = "wide",
+    choice = "mode"
+  )
 
-  test_that("model_info", {
-    expect_false(model_info(m1)$is_ordinal)
-    expect_false(model_info(m2)$is_ordinal)
-    expect_true(model_info(m1)$is_multinomial)
-    expect_true(model_info(m2)$is_multinomial)
-    expect_false(model_info(m1)$is_linear)
-  })
+m1 <- mlogit::mlogit(mode ~ price + catch, data = Fish)
+m2 <- mlogit::mlogit(mode ~ price + catch | income, data = Fish)
 
-  test_that("find_predictors", {
-    expect_identical(find_predictors(m1), list(conditional = c("price", "catch")))
-    expect_identical(find_predictors(m1, flatten = TRUE), c("price", "catch"))
-    expect_null(find_predictors(m1, effects = "random"))
-    expect_identical(find_predictors(m2), list(conditional = c("price", "catch", "income")))
-    expect_identical(
-      find_predictors(m2, flatten = TRUE),
-      c("price", "catch", "income")
-    )
-    expect_null(find_predictors(m2, effects = "random"))
-  })
+test_that("model_info", {
+  expect_false(model_info(m1)$is_ordinal)
+  expect_false(model_info(m2)$is_ordinal)
+  expect_true(model_info(m1)$is_multinomial)
+  expect_true(model_info(m2)$is_multinomial)
+  expect_false(model_info(m1)$is_linear)
+})
+
+test_that("find_predictors", {
+  expect_identical(find_predictors(m1), list(conditional = c("price", "catch")))
+  expect_identical(find_predictors(m1, flatten = TRUE), c("price", "catch"))
+  expect_null(find_predictors(m1, effects = "random"))
+  expect_identical(find_predictors(m2), list(conditional = c("price", "catch", "income")))
+  expect_identical(
+    find_predictors(m2, flatten = TRUE),
+    c("price", "catch", "income")
+  )
+  expect_null(find_predictors(m2, effects = "random"))
+})
 
-  test_that("find_response", {
-    expect_identical(find_response(m1), "mode")
-    expect_identical(find_response(m2), "mode")
-  })
+test_that("find_response", {
+  expect_identical(find_response(m1), "mode")
+  expect_identical(find_response(m2), "mode")
+})
 
-  if (getRversion() >= "3.6.0") {
-    test_that("get_response", {
-      expect_identical(get_response(m1), as.vector(Fish$mode))
-    })
+test_that("get_response", {
+  skip_if_not(getRversion() >= "3.6.0")
+  expect_identical(get_response(m1), as.vector(Fish$mode))
+})
 
-    test_that("get_data", {
-      expect_identical(nrow(get_data(m1, verbose = FALSE)), 4728L)
-      expect_identical(nrow(get_data(m2, verbose = FALSE)), 4728L)
+test_that("get_data", {
+  skip_if_not(getRversion() >= "3.6.0")
+  expect_identical(nrow(get_data(m1, verbose = FALSE)), 4728L)
+  expect_identical(nrow(get_data(m2, verbose = FALSE)), 4728L)
 
-      if (packageVersion("mlogit") <= "1.0-3.1") {
-        expect_identical(
-          colnames(get_data(m1, verbose = FALSE)),
-          c("mode", "price", "catch", "probabilities", "linpred")
-        )
-        expect_identical(
-          colnames(get_data(m2, verbose = FALSE)),
-          c(
-            "mode",
-            "price",
-            "catch",
-            "income",
-            "probabilities",
-            "linpred"
-          )
-        )
-      } else {
-        expect_identical(
-          colnames(get_data(m1, verbose = FALSE)),
-          c("mode", "price", "catch", "idx", "probabilities", "linpred")
-        )
-        expect_identical(
-          colnames(get_data(m2, verbose = FALSE)),
-          c(
-            "mode",
-            "price",
-            "catch",
-            "income",
-            "idx",
-            "probabilities",
-            "linpred"
-          )
-        )
-      }
-    })
+  if (packageVersion("mlogit") <= "1.0-3.1") {
+    expect_identical(
+      colnames(get_data(m1, verbose = FALSE)),
+      c("mode", "price", "catch", "probabilities", "linpred")
+    )
+    expect_identical(
+      colnames(get_data(m2, verbose = FALSE)),
+      c(
+        "mode",
+        "price",
+        "catch",
+        "income",
+        "probabilities",
+        "linpred"
+      )
+    )
+  } else {
+    expect_identical(
+      colnames(get_data(m1, verbose = FALSE)),
+      c("mode", "price", "catch", "idx", "probabilities", "linpred")
+    )
+    expect_identical(
+      colnames(get_data(m2, verbose = FALSE)),
+      c(
+        "mode",
+        "price",
+        "catch",
+        "income",
+        "idx",
+        "probabilities",
+        "linpred"
+      )
+    )
   }
+})
 
-  test_that("link_inverse", {
-    expect_equal(link_inverse(m1)(0.2), plogis(0.2), tolerance = 1e-5)
-    expect_equal(link_inverse(m2)(0.2), plogis(0.2), tolerance = 1e-5)
-  })
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), plogis(0.2), tolerance = 1e-5)
+  expect_equal(link_inverse(m2)(0.2), plogis(0.2), tolerance = 1e-5)
+})
 
 
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 1)
-    expect_length(find_formula(m2), 1)
-  })
+test_that("find_formula", {
+  expect_length(find_formula(m1), 1)
+  expect_length(find_formula(m2), 1)
+})
 
-  test_that("find_terms", {
-    expect_identical(find_terms(m1), list(
-      response = "mode",
-      conditional = c("price", "catch")
-    ))
-    expect_identical(find_terms(m1, flatten = TRUE), c("mode", "price", "catch"))
-    expect_identical(find_terms(m2), list(
-      response = "mode",
-      conditional = c("price", "catch", "income")
-    ))
-    expect_identical(
-      find_terms(m2, flatten = TRUE),
-      c("mode", "price", "catch", "income")
-    )
-  })
+test_that("find_terms", {
+  expect_identical(find_terms(m1), list(
+    response = "mode",
+    conditional = c("price", "catch")
+  ))
+  expect_identical(find_terms(m1, flatten = TRUE), c("mode", "price", "catch"))
+  expect_identical(find_terms(m2), list(
+    response = "mode",
+    conditional = c("price", "catch", "income")
+  ))
+  expect_identical(
+    find_terms(m2, flatten = TRUE),
+    c("mode", "price", "catch", "income")
+  )
+})
 
-  test_that("n_obs", {
-    expect_identical(n_obs(m1), 4728L)
-    expect_identical(n_obs(m2), 4728L)
-  })
+test_that("n_obs", {
+  expect_identical(n_obs(m1), 4728L)
+  expect_identical(n_obs(m2), 4728L)
+})
 
-  test_that("linkfun", {
-    expect_false(is.null(link_function(m1)))
-    expect_false(is.null(link_function(m2)))
-  })
+test_that("linkfun", {
+  expect_false(is.null(link_function(m1)))
+  expect_false(is.null(link_function(m2)))
+})
 
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "z-statistic")
-    expect_identical(find_statistic(m2), "z-statistic")
-  })
-}
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "z-statistic")
+  expect_identical(find_statistic(m2), "z-statistic")
+})
diff --git a/tests/testthat/test-mmrm.R b/tests/testthat/test-mmrm.R
index f78be79d9..9e3f37f66 100644
--- a/tests/testthat/test-mmrm.R
+++ b/tests/testthat/test-mmrm.R
@@ -1,8 +1,14 @@
-skip_if_not_or_load_if_installed("mmrm")
+skip_if_not_installed("mmrm")
 skip_if(getRversion() < "4.0.0")
 
-data(fev_data)
-mod_mmrm <- mmrm(
+# see https://github.com/georgheinze/logistf/pull/54
+skip_if(
+  "as.character.formula" %in% methods(as.character),
+  "Package `logistf` is loaded and breaks `mmrm::mmrm()`"
+)
+
+data(fev_data, package = "mmrm")
+mod_mmrm <- mmrm::mmrm(
   formula = FEV1 ~ RACE + SEX + ARMCD * AVISIT + us(AVISIT | USUBJID),
   data = fev_data
 )
@@ -30,7 +36,7 @@ test_that("n_parameters", {
 })
 
 test_that("find_offset", {
-  model_off <- mmrm(
+  model_off <- mmrm::mmrm(
     log(FEV1) ~ RACE + SEX + ARMCD * AVISIT + us(AVISIT | USUBJID) + offset(log(FEV1_BL)),
     data = fev_data
   )
diff --git a/tests/testthat/test-model_data.R b/tests/testthat/test-model_data.R
index 126e35841..5fbbe4943 100644
--- a/tests/testthat/test-model_data.R
+++ b/tests/testthat/test-model_data.R
@@ -1,46 +1,43 @@
-if (
-  skip_if_not_or_load_if_installed("splines") &&
-    skip_if_not_or_load_if_installed("TMB") &&
-    skip_if_not_or_load_if_installed("glmmTMB") &&
-    getRversion() >= "4.0.0") {
-  data(iris)
+skip_if_not_installed("splines")
+skip_if_not_installed("TMB")
+skip_if_not_installed("glmmTMB")
+skip_if_not(getRversion() >= "4.0.0")
 
-  m1 <- lm(Sepal.Length ~ Species + ns(Petal.Width), data = iris)
-  m2 <- lm(Sepal.Length ~ Species + ns(Petal.Width, knots = 2), data = iris)
-  m3 <- lm(Sepal.Length ~ Species + bs(Petal.Width, degree = 3), data = iris)
-  m4 <- lm(Sepal.Length ~ Species + bs(Petal.Width, degree = 1), data = iris)
-  m5 <- lm(Sepal.Length ~ Species + Petal.Width, data = iris)
+m1 <- lm(Sepal.Length ~ Species + splines::ns(Petal.Width), data = iris)
+m2 <- lm(Sepal.Length ~ Species + splines::ns(Petal.Width, knots = 2), data = iris)
+m3 <- lm(Sepal.Length ~ Species + splines::bs(Petal.Width, degree = 3), data = iris)
+m4 <- lm(Sepal.Length ~ Species + splines::bs(Petal.Width, degree = 1), data = iris)
+m5 <- lm(Sepal.Length ~ Species + Petal.Width, data = iris)
 
 
-  test_that("get_data", {
-    mf1 <- get_data(m1)
-    mf2 <- get_data(m2)
-    mf3 <- get_data(m3)
-    mf4 <- get_data(m4)
-    mf5 <- model.frame(m5)
+test_that("get_data", {
+  mf1 <- get_data(m1)
+  mf2 <- get_data(m2)
+  mf3 <- get_data(m3)
+  mf4 <- get_data(m4)
+  mf5 <- model.frame(m5)
 
-    expect_identical(as.vector(mf1$Petal.Width), as.vector(mf5$Petal.Width))
-    expect_identical(as.vector(mf2$Petal.Width), as.vector(mf5$Petal.Width))
-    expect_identical(as.vector(mf3$Petal.Width), as.vector(mf5$Petal.Width))
-    expect_identical(as.vector(mf4$Petal.Width), as.vector(mf5$Petal.Width))
-  })
+  expect_identical(as.vector(mf1$Petal.Width), as.vector(mf5$Petal.Width))
+  expect_identical(as.vector(mf2$Petal.Width), as.vector(mf5$Petal.Width))
+  expect_identical(as.vector(mf3$Petal.Width), as.vector(mf5$Petal.Width))
+  expect_identical(as.vector(mf4$Petal.Width), as.vector(mf5$Petal.Width))
+})
 
-  data("Salamanders")
-  skip_on_os("mac") # error: FreeADFunObject
-  m <- glmmTMB(
-    count ~ spp + cover + mined + poly(DOP, 3) + (1 | site),
-    ziformula = ~ spp + mined,
-    dispformula = ~DOY,
-    data = Salamanders,
-    family = nbinom2
-  )
+data(Salamanders, package = "glmmTMB")
+skip_on_os("mac") # error: FreeADFunObject
+m <- glmmTMB::glmmTMB(
+  count ~ spp + cover + mined + poly(DOP, 3) + (1 | site),
+  ziformula = ~ spp + mined,
+  dispformula = ~DOY,
+  data = Salamanders,
+  family = glmmTMB::nbinom2
+)
 
-  test_that("get_data", {
-    mf <- get_data(m)
-    expect_identical(ncol(mf), 7L)
-    expect_identical(
-      colnames(mf),
-      c("count", "spp", "cover", "mined", "DOP", "site", "DOY")
-    )
-  })
-}
+test_that("get_data", {
+  mf <- get_data(m)
+  expect_identical(ncol(mf), 7L)
+  expect_identical(
+    colnames(mf),
+    c("count", "spp", "cover", "mined", "DOP", "site", "DOY")
+  )
+})
diff --git a/tests/testthat/test-model_info.R b/tests/testthat/test-model_info.R
index 79c023151..81d7fc427 100644
--- a/tests/testthat/test-model_info.R
+++ b/tests/testthat/test-model_info.R
@@ -1,30 +1,28 @@
-if (skip_if_not_or_load_if_installed("BayesFactor")) {
-  model <- BayesFactor::proportionBF(15, 25, p = 0.5)
-  mi <- insight::model_info(model)
-  test_that("model_info-BF-proptest", {
-    expect_true(mi$is_binomial)
-    expect_false(mi$is_linear)
-  })
+skip_if_not_installed("BayesFactor")
 
-  model <- prop.test(15, 25, p = 0.5)
-  mi <- insight::model_info(model)
-  test_that("model_info-BF-proptest", {
-    expect_true(mi$is_binomial)
-    expect_false(mi$is_linear)
-    expect_false(mi$is_correlation)
-  })
-}
+model <- BayesFactor::proportionBF(15, 25, p = 0.5)
+mi <- insight::model_info(model)
+test_that("model_info-BF-proptest", {
+  expect_true(mi$is_binomial)
+  expect_false(mi$is_linear)
+})
 
+model <- prop.test(15, 25, p = 0.5)
+mi <- insight::model_info(model)
+test_that("model_info-BF-proptest", {
+  expect_true(mi$is_binomial)
+  expect_false(mi$is_linear)
+  expect_false(mi$is_correlation)
+})
 
-if (skip_if_not_or_load_if_installed("tweedie") && skip_if_not_or_load_if_installed("statmod")) {
-  unloadNamespace("glmmTMB")
-  d <- data.frame(x = 1:20, y = rgamma(20, shape = 5))
-  # Fit a poisson generalized linear model with identity link
-  model <- glm(y ~ x, data = d, family = statmod::tweedie(var.power = 1, link.power = 1))
-  mi <- insight::model_info(model)
-  test_that("model_info-tweedie", {
-    expect_true(mi$is_tweedie)
-    expect_false(mi$is_poisson)
-    expect_equal(mi$family, "Tweedie")
-  })
-}
+skip_if_not_installed("tweedie")
+
+d <- data.frame(x = 1:20, y = rgamma(20, shape = 5))
+# Fit a poisson generalized linear model with identity link
+model <- glm(y ~ x, data = d, family = statmod::tweedie(var.power = 1, link.power = 1))
+mi <- insight::model_info(model)
+test_that("model_info-tweedie", {
+  expect_true(mi$is_tweedie)
+  expect_false(mi$is_poisson)
+  expect_equal(mi$family, "Tweedie")
+})
diff --git a/tests/testthat/test-multinom.R b/tests/testthat/test-multinom.R
index d78cbffc5..486a8513f 100644
--- a/tests/testthat/test-multinom.R
+++ b/tests/testthat/test-multinom.R
@@ -1,121 +1,122 @@
-if (skip_if_not_or_load_if_installed("nnet") && skip_if_not_or_load_if_installed("MASS")) {
-  data("birthwt")
-  void <- capture.output({
-    m1 <- nnet::multinom(low ~ age + lwt + race + smoke, data = birthwt)
-  })
+skip_if_not_installed("nnet")
+skip_if_not_installed("MASS")
 
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_binomial)
-    expect_false(model_info(m1)$is_linear)
-  })
+data("birthwt", package = "MASS")
+void <- capture.output({
+  m1 <- nnet::multinom(low ~ age + lwt + race + smoke, data = birthwt)
+})
 
-  test_that("n_parameters", {
-    expect_equal(n_parameters(m1), 5)
-  })
+test_that("model_info", {
+  expect_true(model_info(m1)$is_binomial)
+  expect_false(model_info(m1)$is_linear)
+})
 
-  test_that("find_predictors", {
-    expect_identical(find_predictors(m1), list(conditional = c("age", "lwt", "race", "smoke")))
-    expect_identical(
-      find_predictors(m1, flatten = TRUE),
-      c("age", "lwt", "race", "smoke")
-    )
-    expect_null(find_predictors(m1, effects = "random"))
-  })
+test_that("n_parameters", {
+  expect_equal(n_parameters(m1), 5)
+})
 
-  test_that("find_response", {
-    expect_identical(find_response(m1), "low")
-  })
+test_that("find_predictors", {
+  expect_identical(find_predictors(m1), list(conditional = c("age", "lwt", "race", "smoke")))
+  expect_identical(
+    find_predictors(m1, flatten = TRUE),
+    c("age", "lwt", "race", "smoke")
+  )
+  expect_null(find_predictors(m1, effects = "random"))
+})
 
-  test_that("link_inverse", {
-    expect_equal(link_inverse(m1)(0.2), plogis(0.2), tolerance = 1e-5)
-  })
+test_that("find_response", {
+  expect_identical(find_response(m1), "low")
+})
 
-  test_that("get_data", {
-    expect_equal(nrow(get_data(m1)), 189)
-    expect_equal(
-      colnames(get_data(m1)),
-      c("low", "age", "lwt", "race", "smoke")
-    )
-  })
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), plogis(0.2), tolerance = 1e-5)
+})
 
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 1)
-    expect_equal(
-      find_formula(m1),
-      list(conditional = as.formula("low ~ age + lwt + race + smoke")),
-      ignore_attr = TRUE
-    )
-  })
+test_that("get_data", {
+  expect_equal(nrow(get_data(m1)), 189)
+  expect_equal(
+    colnames(get_data(m1)),
+    c("low", "age", "lwt", "race", "smoke")
+  )
+})
 
-  test_that("find_terms", {
-    expect_equal(find_terms(m1), list(
-      response = "low",
-      conditional = c("age", "lwt", "race", "smoke")
-    ))
-    expect_equal(
-      find_terms(m1, flatten = TRUE),
-      c("low", "age", "lwt", "race", "smoke")
-    )
-  })
+test_that("find_formula", {
+  expect_length(find_formula(m1), 1)
+  expect_equal(
+    find_formula(m1),
+    list(conditional = as.formula("low ~ age + lwt + race + smoke")),
+    ignore_attr = TRUE
+  )
+})
 
-  test_that("n_obs", {
-    expect_equal(n_obs(m1), 189)
-  })
+test_that("find_terms", {
+  expect_equal(find_terms(m1), list(
+    response = "low",
+    conditional = c("age", "lwt", "race", "smoke")
+  ))
+  expect_equal(
+    find_terms(m1, flatten = TRUE),
+    c("low", "age", "lwt", "race", "smoke")
+  )
+})
 
-  test_that("linkfun", {
-    expect_false(is.null(link_function(m1)))
-  })
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 189)
+})
 
-  test_that("find_parameters", {
-    expect_equal(
-      find_parameters(m1),
-      list(conditional = c(
-        "(Intercept)", "age", "lwt", "race", "smoke"
-      ))
-    )
-    expect_equal(nrow(get_parameters(m1)), 5)
-    expect_equal(
-      get_parameters(m1)$Parameter,
-      c("(Intercept)", "age", "lwt", "race", "smoke")
-    )
-  })
+test_that("linkfun", {
+  expect_false(is.null(link_function(m1)))
+})
 
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "t-statistic")
-  })
+test_that("find_parameters", {
+  expect_equal(
+    find_parameters(m1),
+    list(conditional = c(
+      "(Intercept)", "age", "lwt", "race", "smoke"
+    ))
+  )
+  expect_equal(nrow(get_parameters(m1)), 5)
+  expect_equal(
+    get_parameters(m1)$Parameter,
+    c("(Intercept)", "age", "lwt", "race", "smoke")
+  )
+})
 
-  test_that("get_predicted", {
-    void <- capture.output({
-      # binary outcome
-      m1 <- nnet::multinom(low ~ age + lwt + race + smoke, data = birthwt)
-      # multinomial outcome
-      m2 <- nnet::multinom(ftv ~ age + lwt + race + smoke, data = birthwt)
-    })
-
-    # binary outcomes produces an atomic vector
-    x <- get_predicted(m1, predict = "classification")
-    expect_true(is.atomic(x) && !is.null(x) && is.null(dim(x)))
-    expect_true(all(levels(x) %in% c("0", "1")))
-    x <- get_predicted(m1, predict = "expectation")
-    expect_true(is.atomic(x) && !is.null(x) && is.null(dim(x)))
-    x <- get_predicted(m1, predict = NULL, type = "class")
-    expect_true(is.atomic(x) && !is.null(x) && is.null(dim(x)))
-    expect_true(all(levels(x) %in% c("0", "1")))
-    x <- get_predicted(m1, predict = NULL, type = "probs")
-    expect_true(is.atomic(x) && !is.null(x) && is.null(dim(x)))
-
-    # multinomial outcomes depends on predict type
-    x <- get_predicted(m2, predict = "classification")
-    expect_true(is.atomic(x) && !is.null(x) && is.null(dim(x)))
-    expect_true(all(levels(x) %in% as.character(0:6)))
-    x <- get_predicted(m2, predict = "expectation")
-    expect_s3_class(x, "data.frame")
-    expect_true(all(c("Row", "Response", "Predicted") %in% colnames(x)))
-    x <- get_predicted(m2, predict = NULL, type = "class")
-    expect_true(is.atomic(x) && !is.null(x) && is.null(dim(x)))
-    expect_true(all(levels(x) %in% as.character(0:6)))
-    x <- get_predicted(m2, predict = NULL, type = "probs")
-    expect_s3_class(x, "data.frame")
-    expect_true(all(c("Row", "Response", "Predicted") %in% colnames(x)))
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "t-statistic")
+})
+
+test_that("get_predicted", {
+  void <- capture.output({
+    # binary outcome
+    m1 <- nnet::multinom(low ~ age + lwt + race + smoke, data = birthwt)
+    # multinomial outcome
+    m2 <- nnet::multinom(ftv ~ age + lwt + race + smoke, data = birthwt)
   })
-}
+
+  # binary outcomes produces an atomic vector
+  x <- get_predicted(m1, predict = "classification")
+  expect_true(is.atomic(x) && !is.null(x) && is.null(dim(x)))
+  expect_true(all(levels(x) %in% c("0", "1")))
+  x <- get_predicted(m1, predict = "expectation")
+  expect_true(is.atomic(x) && !is.null(x) && is.null(dim(x)))
+  x <- get_predicted(m1, predict = NULL, type = "class")
+  expect_true(is.atomic(x) && !is.null(x) && is.null(dim(x)))
+  expect_true(all(levels(x) %in% c("0", "1")))
+  x <- get_predicted(m1, predict = NULL, type = "probs")
+  expect_true(is.atomic(x) && !is.null(x) && is.null(dim(x)))
+
+  # multinomial outcomes depends on predict type
+  x <- get_predicted(m2, predict = "classification")
+  expect_true(is.atomic(x) && !is.null(x) && is.null(dim(x)))
+  expect_true(all(levels(x) %in% as.character(0:6)))
+  x <- get_predicted(m2, predict = "expectation")
+  expect_s3_class(x, "data.frame")
+  expect_true(all(c("Row", "Response", "Predicted") %in% colnames(x)))
+  x <- get_predicted(m2, predict = NULL, type = "class")
+  expect_true(is.atomic(x) && !is.null(x) && is.null(dim(x)))
+  expect_true(all(levels(x) %in% as.character(0:6)))
+  x <- get_predicted(m2, predict = NULL, type = "probs")
+  expect_s3_class(x, "data.frame")
+  expect_true(all(c("Row", "Response", "Predicted") %in% colnames(x)))
+})
diff --git a/tests/testthat/test-mvrstanarm.R b/tests/testthat/test-mvrstanarm.R
index b52b8a255..015399cf0 100644
--- a/tests/testthat/test-mvrstanarm.R
+++ b/tests/testthat/test-mvrstanarm.R
@@ -1,1047 +1,1044 @@
-.runStanTest <- Sys.getenv("RunAllinsightStanTests") == "yes"
+skip_on_cran()
+skip_if_offline()
+skip_if_not_installed("rstanarm")
 
-if (.runStanTest &&
-  suppressWarnings(
-    skip_if_not_or_load_if_installed("rstanarm")
-  )) {
-  data("pbcLong")
-  m1 <- download_model("stanmvreg_1")
+data("pbcLong", package = "rstanarm")
+m1 <- download_model("stanmvreg_1")
 
-  test_that("clean_names", {
-    expect_identical(
-      clean_names(m1),
-      c("logBili", "albumin", "year", "id", "sex")
-    )
-  })
+test_that("clean_names", {
+  expect_identical(
+    clean_names(m1),
+    c("logBili", "albumin", "year", "id", "sex")
+  )
+})
 
-  test_that("find_predictors", {
-    expect_identical(
-      find_predictors(m1),
-      list(
-        y1 = list(conditional = "year"),
-        y2 = list(conditional = c("sex", "year"))
-      )
+test_that("find_predictors", {
+  expect_identical(
+    find_predictors(m1),
+    list(
+      y1 = list(conditional = "year"),
+      y2 = list(conditional = c("sex", "year"))
     )
-    expect_identical(find_predictors(m1, flatten = TRUE), c("year", "sex"))
-    expect_identical(
-      find_predictors(m1, effects = "all", component = "all"),
-      list(
-        y1 = list(conditional = "year", random = "id"),
-        y2 = list(
-          conditional = c("sex", "year"),
-          random = "id"
-        )
+  )
+  expect_identical(find_predictors(m1, flatten = TRUE), c("year", "sex"))
+  expect_identical(
+    find_predictors(m1, effects = "all", component = "all"),
+    list(
+      y1 = list(conditional = "year", random = "id"),
+      y2 = list(
+        conditional = c("sex", "year"),
+        random = "id"
       )
     )
-    expect_identical(
-      find_predictors(
-        m1,
-        effects = "all",
-        component = "all",
-        flatten = TRUE
-      ),
-      c("year", "id", "sex")
-    )
-  })
+  )
+  expect_identical(
+    find_predictors(
+      m1,
+      effects = "all",
+      component = "all",
+      flatten = TRUE
+    ),
+    c("year", "id", "sex")
+  )
+})
 
-  test_that("find_response", {
-    expect_equal(
-      find_response(m1, combine = TRUE),
-      c(y1 = "logBili", y2 = "albumin")
-    )
-    expect_equal(
-      find_response(m1, combine = FALSE),
-      c(y1 = "logBili", y2 = "albumin")
-    )
-  })
+test_that("find_response", {
+  expect_equal(
+    find_response(m1, combine = TRUE),
+    c(y1 = "logBili", y2 = "albumin")
+  )
+  expect_equal(
+    find_response(m1, combine = FALSE),
+    c(y1 = "logBili", y2 = "albumin")
+  )
+})
 
-  test_that("get_response", {
-    expect_equal(nrow(get_response(m1)), 304)
-    expect_equal(colnames(get_response(m1)), c("logBili", "albumin"))
-  })
+test_that("get_response", {
+  expect_equal(nrow(get_response(m1)), 304)
+  expect_equal(colnames(get_response(m1)), c("logBili", "albumin"))
+})
 
-  test_that("find_statistic", {
-    expect_null(find_statistic(m1))
-  })
+test_that("find_statistic", {
+  expect_null(find_statistic(m1))
+})
 
-  test_that("find_variables", {
-    expect_identical(
-      find_variables(m1),
-      list(
-        response = c(y1 = "logBili", y2 = "albumin"),
-        y1 = list(conditional = "year", random = "id"),
-        y2 = list(
-          conditional = c("sex", "year"),
-          random = "id"
-        )
+test_that("find_variables", {
+  expect_identical(
+    find_variables(m1),
+    list(
+      response = c(y1 = "logBili", y2 = "albumin"),
+      y1 = list(conditional = "year", random = "id"),
+      y2 = list(
+        conditional = c("sex", "year"),
+        random = "id"
       )
     )
-    expect_identical(
-      find_variables(m1, flatten = TRUE),
-      c("logBili", "albumin", "year", "id", "sex")
+  )
+  expect_identical(
+    find_variables(m1, flatten = TRUE),
+    c("logBili", "albumin", "year", "id", "sex")
+  )
+  expect_identical(
+    find_variables(m1, effects = "random"),
+    list(
+      response = c(y1 = "logBili", y2 = "albumin"),
+      y1 = list(random = "id"),
+      y2 = list(random = "id")
     )
-    expect_identical(
-      find_variables(m1, effects = "random"),
-      list(
-        response = c(y1 = "logBili", y2 = "albumin"),
-        y1 = list(random = "id"),
-        y2 = list(random = "id")
+  )
+})
+
+test_that("find_terms", {
+  expect_identical(
+    find_terms(m1),
+    list(
+      y1 = list(
+        response = "logBili",
+        conditional = "year",
+        random = "id"
+      ),
+      y2 = list(
+        response = "albumin",
+        conditional = c("sex", "year"),
+        random = c("year", "id")
       )
     )
-  })
+  )
+  expect_identical(
+    find_terms(m1, flatten = TRUE),
+    c("logBili", "year", "id", "albumin", "sex")
+  )
+})
 
-  test_that("find_terms", {
-    expect_identical(
-      find_terms(m1),
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 304)
+})
+
+test_that("find_paramaters", {
+  expect_equal(
+    find_parameters(m1, component = "all"),
+    structure(
       list(
         y1 = list(
-          response = "logBili",
-          conditional = "year",
-          random = "id"
+          conditional = c("(Intercept)", "year"),
+          random = sprintf("b[(Intercept) id:%i]", 1:40),
+          sigma = "sigma"
         ),
         y2 = list(
-          response = "albumin",
-          conditional = c("sex", "year"),
-          random = c("year", "id")
+          conditional = c("(Intercept)", "sexf", "year"),
+          random = sprintf(
+            c("b[(Intercept) id:%i]", "b[year id:%i]"),
+            rep(1:40, each = 2)
+          ),
+          sigma = "sigma"
         )
-      )
-    )
-    expect_identical(
-      find_terms(m1, flatten = TRUE),
-      c("logBili", "year", "id", "albumin", "sex")
+      ),
+      is_mv = "1"
     )
-  })
-
-  test_that("n_obs", {
-    expect_equal(n_obs(m1), 304)
-  })
+  )
 
-  test_that("find_paramaters", {
-    expect_equal(
-      find_parameters(m1, component = "all"),
-      structure(
-        list(
-          y1 = list(
-            conditional = c("(Intercept)", "year"),
-            random = sprintf("b[(Intercept) id:%i]", 1:40),
-            sigma = "sigma"
-          ),
-          y2 = list(
-            conditional = c("(Intercept)", "sexf", "year"),
-            random = sprintf(
-              c("b[(Intercept) id:%i]", "b[year id:%i]"),
-              rep(1:40, each = 2)
-            ),
-            sigma = "sigma"
-          )
+  expect_equal(
+    find_parameters(m1),
+    structure(
+      list(
+        y1 = list(
+          conditional = c("(Intercept)", "year"),
+          random = sprintf("b[(Intercept) id:%i]", 1:40)
         ),
-        is_mv = "1"
-      )
-    )
-
-    expect_equal(
-      find_parameters(m1),
-      structure(
-        list(
-          y1 = list(
-            conditional = c("(Intercept)", "year"),
-            random = sprintf("b[(Intercept) id:%i]", 1:40)
-          ),
-          y2 = list(
-            conditional = c("(Intercept)", "sexf", "year"),
-            random = sprintf(
-              c("b[(Intercept) id:%i]", "b[year id:%i]"),
-              rep(1:40, each = 2)
-            )
+        y2 = list(
+          conditional = c("(Intercept)", "sexf", "year"),
+          random = sprintf(
+            c("b[(Intercept) id:%i]", "b[year id:%i]"),
+            rep(1:40, each = 2)
           )
-        ),
-        is_mv = "1"
-      )
+        )
+      ),
+      is_mv = "1"
     )
+  )
 
-    expect_equal(
-      find_parameters(m1, effects = "fixed", component = "all"),
-      structure(
-        list(
-          y1 = list(
-            conditional = c("(Intercept)", "year"),
-            sigma = "sigma"
-          ),
-          y2 = list(
-            conditional = c("(Intercept)", "sexf", "year"),
-            sigma = "sigma"
-          )
+  expect_equal(
+    find_parameters(m1, effects = "fixed", component = "all"),
+    structure(
+      list(
+        y1 = list(
+          conditional = c("(Intercept)", "year"),
+          sigma = "sigma"
         ),
-        is_mv = "1"
-      )
+        y2 = list(
+          conditional = c("(Intercept)", "sexf", "year"),
+          sigma = "sigma"
+        )
+      ),
+      is_mv = "1"
     )
+  )
 
-    expect_equal(
-      find_parameters(m1, effects = "fixed"),
-      structure(
-        list(
-          y1 = list(conditional = c("(Intercept)", "year")),
-          y2 = list(conditional = c("(Intercept)", "sexf", "year"))
-        ),
-        is_mv = "1"
-      )
+  expect_equal(
+    find_parameters(m1, effects = "fixed"),
+    structure(
+      list(
+        y1 = list(conditional = c("(Intercept)", "year")),
+        y2 = list(conditional = c("(Intercept)", "sexf", "year"))
+      ),
+      is_mv = "1"
     )
+  )
 
-    expect_equal(
-      find_parameters(m1, effects = "random", component = "all"),
-      structure(
-        list(
-          y1 = list(random = sprintf("b[(Intercept) id:%i]", 1:40)),
-          y2 = list(random = sprintf(
-            c("b[(Intercept) id:%i]", "b[year id:%i]"),
-            rep(1:40, each = 2)
-          ))
-        ),
-        is_mv = "1"
-      )
+  expect_equal(
+    find_parameters(m1, effects = "random", component = "all"),
+    structure(
+      list(
+        y1 = list(random = sprintf("b[(Intercept) id:%i]", 1:40)),
+        y2 = list(random = sprintf(
+          c("b[(Intercept) id:%i]", "b[year id:%i]"),
+          rep(1:40, each = 2)
+        ))
+      ),
+      is_mv = "1"
     )
+  )
 
-    expect_equal(
-      find_parameters(m1, effects = "random"),
-      structure(
-        list(
-          y1 = list(random = sprintf("b[(Intercept) id:%i]", 1:40)),
-          y2 = list(random = sprintf(
-            c("b[(Intercept) id:%i]", "b[year id:%i]"),
-            rep(1:40, each = 2)
-          ))
-        ),
-        is_mv = "1"
-      )
+  expect_equal(
+    find_parameters(m1, effects = "random"),
+    structure(
+      list(
+        y1 = list(random = sprintf("b[(Intercept) id:%i]", 1:40)),
+        y2 = list(random = sprintf(
+          c("b[(Intercept) id:%i]", "b[year id:%i]"),
+          rep(1:40, each = 2)
+        ))
+      ),
+      is_mv = "1"
     )
-  })
+  )
+})
 
-  test_that("get_parameters", {
-    expect_equal(
-      colnames(get_parameters(m1)),
-      c(
-        "y1|(Intercept)",
-        "y1|year",
-        "y2|(Intercept)",
-        "y2|sexf",
-        "y2|year"
-      )
+test_that("get_parameters", {
+  expect_equal(
+    colnames(get_parameters(m1)),
+    c(
+      "y1|(Intercept)",
+      "y1|year",
+      "y2|(Intercept)",
+      "y2|sexf",
+      "y2|year"
     )
-    expect_equal(
-      colnames(get_parameters(m1, effects = "all")),
-      c(
-        "y1|(Intercept)",
-        "y1|year",
-        sprintf("b[y1|(Intercept) id:%i]", 1:40),
-        "y2|(Intercept)",
-        "y2|sexf",
-        "y2|year",
-        sprintf(
-          c("b[y2|(Intercept) id:%i]", "b[y2|year id:%i]"),
-          rep(1:40, each = 2)
-        )
+  )
+  expect_equal(
+    colnames(get_parameters(m1, effects = "all")),
+    c(
+      "y1|(Intercept)",
+      "y1|year",
+      sprintf("b[y1|(Intercept) id:%i]", 1:40),
+      "y2|(Intercept)",
+      "y2|sexf",
+      "y2|year",
+      sprintf(
+        c("b[y2|(Intercept) id:%i]", "b[y2|year id:%i]"),
+        rep(1:40, each = 2)
       )
     )
-  })
+  )
+})
 
-  test_that("linkfun", {
-    expect_false(is.null(link_function(m1)))
-    expect_length(link_function(m1), 2)
-  })
+test_that("linkfun", {
+  expect_false(is.null(link_function(m1)))
+  expect_length(link_function(m1), 2)
+})
 
-  test_that("linkinv", {
-    expect_false(is.null(link_inverse(m1)))
-    expect_length(link_inverse(m1), 2)
-  })
+test_that("linkinv", {
+  expect_false(is.null(link_inverse(m1)))
+  expect_length(link_inverse(m1), 2)
+})
 
 
-  test_that("is_multivariate", {
-    expect_true(is_multivariate(m1))
-  })
+test_that("is_multivariate", {
+  expect_true(is_multivariate(m1))
+})
 
-  test_that("clean_parameters", {
-    expect_identical(
-      clean_parameters(m1),
-      structure(
-        list(
-          Parameter = c(
-            "(Intercept)",
-            "year",
-            "(Intercept)",
-            "sexf",
-            "year",
-            "b[(Intercept) id:1]",
-            "b[(Intercept) id:2]",
-            "b[(Intercept) id:3]",
-            "b[(Intercept) id:4]",
-            "b[(Intercept) id:5]",
-            "b[(Intercept) id:6]",
-            "b[(Intercept) id:7]",
-            "b[(Intercept) id:8]",
-            "b[(Intercept) id:9]",
-            "b[(Intercept) id:10]",
-            "b[(Intercept) id:11]",
-            "b[(Intercept) id:12]",
-            "b[(Intercept) id:13]",
-            "b[(Intercept) id:14]",
-            "b[(Intercept) id:15]",
-            "b[(Intercept) id:16]",
-            "b[(Intercept) id:17]",
-            "b[(Intercept) id:18]",
-            "b[(Intercept) id:19]",
-            "b[(Intercept) id:20]",
-            "b[(Intercept) id:21]",
-            "b[(Intercept) id:22]",
-            "b[(Intercept) id:23]",
-            "b[(Intercept) id:24]",
-            "b[(Intercept) id:25]",
-            "b[(Intercept) id:26]",
-            "b[(Intercept) id:27]",
-            "b[(Intercept) id:28]",
-            "b[(Intercept) id:29]",
-            "b[(Intercept) id:30]",
-            "b[(Intercept) id:31]",
-            "b[(Intercept) id:32]",
-            "b[(Intercept) id:33]",
-            "b[(Intercept) id:34]",
-            "b[(Intercept) id:35]",
-            "b[(Intercept) id:36]",
-            "b[(Intercept) id:37]",
-            "b[(Intercept) id:38]",
-            "b[(Intercept) id:39]",
-            "b[(Intercept) id:40]",
-            "b[(Intercept) id:1]",
-            "b[year id:1]",
-            "b[(Intercept) id:2]",
-            "b[year id:2]",
-            "b[(Intercept) id:3]",
-            "b[year id:3]",
-            "b[(Intercept) id:4]",
-            "b[year id:4]",
-            "b[(Intercept) id:5]",
-            "b[year id:5]",
-            "b[(Intercept) id:6]",
-            "b[year id:6]",
-            "b[(Intercept) id:7]",
-            "b[year id:7]",
-            "b[(Intercept) id:8]",
-            "b[year id:8]",
-            "b[(Intercept) id:9]",
-            "b[year id:9]",
-            "b[(Intercept) id:10]",
-            "b[year id:10]",
-            "b[(Intercept) id:11]",
-            "b[year id:11]",
-            "b[(Intercept) id:12]",
-            "b[year id:12]",
-            "b[(Intercept) id:13]",
-            "b[year id:13]",
-            "b[(Intercept) id:14]",
-            "b[year id:14]",
-            "b[(Intercept) id:15]",
-            "b[year id:15]",
-            "b[(Intercept) id:16]",
-            "b[year id:16]",
-            "b[(Intercept) id:17]",
-            "b[year id:17]",
-            "b[(Intercept) id:18]",
-            "b[year id:18]",
-            "b[(Intercept) id:19]",
-            "b[year id:19]",
-            "b[(Intercept) id:20]",
-            "b[year id:20]",
-            "b[(Intercept) id:21]",
-            "b[year id:21]",
-            "b[(Intercept) id:22]",
-            "b[year id:22]",
-            "b[(Intercept) id:23]",
-            "b[year id:23]",
-            "b[(Intercept) id:24]",
-            "b[year id:24]",
-            "b[(Intercept) id:25]",
-            "b[year id:25]",
-            "b[(Intercept) id:26]",
-            "b[year id:26]",
-            "b[(Intercept) id:27]",
-            "b[year id:27]",
-            "b[(Intercept) id:28]",
-            "b[year id:28]",
-            "b[(Intercept) id:29]",
-            "b[year id:29]",
-            "b[(Intercept) id:30]",
-            "b[year id:30]",
-            "b[(Intercept) id:31]",
-            "b[year id:31]",
-            "b[(Intercept) id:32]",
-            "b[year id:32]",
-            "b[(Intercept) id:33]",
-            "b[year id:33]",
-            "b[(Intercept) id:34]",
-            "b[year id:34]",
-            "b[(Intercept) id:35]",
-            "b[year id:35]",
-            "b[(Intercept) id:36]",
-            "b[year id:36]",
-            "b[(Intercept) id:37]",
-            "b[year id:37]",
-            "b[(Intercept) id:38]",
-            "b[year id:38]",
-            "b[(Intercept) id:39]",
-            "b[year id:39]",
-            "b[(Intercept) id:40]",
-            "b[year id:40]",
-            "sigma",
-            "sigma"
-          ),
-          Effects = c(
-            "fixed",
-            "fixed",
-            "fixed",
-            "fixed",
-            "fixed",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "random",
-            "fixed",
-            "fixed"
-          ),
-          Component = c(
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "conditional",
-            "sigma",
-            "sigma"
-          ),
-          Group = c(
-            "",
-            "",
-            "",
-            "",
-            "",
-            "Intercept: id",
-            "Intercept: id",
-            "Intercept: id",
-            "Intercept: id",
-            "Intercept: id",
-            "Intercept: id",
-            "Intercept: id",
-            "Intercept: id",
-            "Intercept: id",
-            "Intercept: id",
-            "Intercept: id",
-            "Intercept: id",
-            "Intercept: id",
-            "Intercept: id",
-            "Intercept: id",
-            "Intercept: id",
-            "Intercept: id",
-            "Intercept: id",
-            "Intercept: id",
-            "Intercept: id",
-            "Intercept: id",
-            "Intercept: id",
-            "Intercept: id",
-            "Intercept: id",
-            "Intercept: id",
-            "Intercept: id",
-            "Intercept: id",
-            "Intercept: id",
-            "Intercept: id",
-            "Intercept: id",
-            "Intercept: id",
-            "Intercept: id",
-            "Intercept: id",
-            "Intercept: id",
-            "Intercept: id",
-            "Intercept: id",
-            "Intercept: id",
-            "Intercept: id",
-            "Intercept: id",
-            "Intercept: id",
-            "Intercept: id",
-            "year: id",
-            "Intercept: id",
-            "year: id",
-            "Intercept: id",
-            "year: id",
-            "Intercept: id",
-            "year: id",
-            "Intercept: id",
-            "year: id",
-            "Intercept: id",
-            "year: id",
-            "Intercept: id",
-            "year: id",
-            "Intercept: id",
-            "year: id",
-            "Intercept: id",
-            "year: id",
-            "Intercept: id",
-            "year: id",
-            "Intercept: id",
-            "year: id",
-            "Intercept: id",
-            "year: id",
-            "Intercept: id",
-            "year: id",
-            "Intercept: id",
-            "year: id",
-            "Intercept: id",
-            "year: id",
-            "Intercept: id",
-            "year: id",
-            "Intercept: id",
-            "year: id",
-            "Intercept: id",
-            "year: id",
-            "Intercept: id",
-            "year: id",
-            "Intercept: id",
-            "year: id",
-            "Intercept: id",
-            "year: id",
-            "Intercept: id",
-            "year: id",
-            "Intercept: id",
-            "year: id",
-            "Intercept: id",
-            "year: id",
-            "Intercept: id",
-            "year: id",
-            "Intercept: id",
-            "year: id",
-            "Intercept: id",
-            "year: id",
-            "Intercept: id",
-            "year: id",
-            "Intercept: id",
-            "year: id",
-            "Intercept: id",
-            "year: id",
-            "Intercept: id",
-            "year: id",
-            "Intercept: id",
-            "year: id",
-            "Intercept: id",
-            "year: id",
-            "Intercept: id",
-            "year: id",
-            "Intercept: id",
-            "year: id",
-            "Intercept: id",
-            "year: id",
-            "Intercept: id",
-            "year: id",
-            "Intercept: id",
-            "year: id",
-            "Intercept: id",
-            "year: id",
-            "Intercept: id",
-            "year: id",
-            "",
-            ""
-          ),
-          Response = c(
-            "y1",
-            "y1",
-            "y2",
-            "y2",
-            "y2",
-            "y1",
-            "y1",
-            "y1",
-            "y1",
-            "y1",
-            "y1",
-            "y1",
-            "y1",
-            "y1",
-            "y1",
-            "y1",
-            "y1",
-            "y1",
-            "y1",
-            "y1",
-            "y1",
-            "y1",
-            "y1",
-            "y1",
-            "y1",
-            "y1",
-            "y1",
-            "y1",
-            "y1",
-            "y1",
-            "y1",
-            "y1",
-            "y1",
-            "y1",
-            "y1",
-            "y1",
-            "y1",
-            "y1",
-            "y1",
-            "y1",
-            "y1",
-            "y1",
-            "y1",
-            "y1",
-            "y1",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y2",
-            "y1",
-            "y2"
-          ),
-          Cleaned_Parameter = c(
-            "(Intercept)",
-            "year",
-            "(Intercept)",
-            "sexf",
-            "year",
-            "id:1",
-            "id:2",
-            "id:3",
-            "id:4",
-            "id:5",
-            "id:6",
-            "id:7",
-            "id:8",
-            "id:9",
-            "id:10",
-            "id:11",
-            "id:12",
-            "id:13",
-            "id:14",
-            "id:15",
-            "id:16",
-            "id:17",
-            "id:18",
-            "id:19",
-            "id:20",
-            "id:21",
-            "id:22",
-            "id:23",
-            "id:24",
-            "id:25",
-            "id:26",
-            "id:27",
-            "id:28",
-            "id:29",
-            "id:30",
-            "id:31",
-            "id:32",
-            "id:33",
-            "id:34",
-            "id:35",
-            "id:36",
-            "id:37",
-            "id:38",
-            "id:39",
-            "id:40",
-            "id:1",
-            "id:1",
-            "id:2",
-            "id:2",
-            "id:3",
-            "id:3",
-            "id:4",
-            "id:4",
-            "id:5",
-            "id:5",
-            "id:6",
-            "id:6",
-            "id:7",
-            "id:7",
-            "id:8",
-            "id:8",
-            "id:9",
-            "id:9",
-            "id:10",
-            "id:10",
-            "id:11",
-            "id:11",
-            "id:12",
-            "id:12",
-            "id:13",
-            "id:13",
-            "id:14",
-            "id:14",
-            "id:15",
-            "id:15",
-            "id:16",
-            "id:16",
-            "id:17",
-            "id:17",
-            "id:18",
-            "id:18",
-            "id:19",
-            "id:19",
-            "id:20",
-            "id:20",
-            "id:21",
-            "id:21",
-            "id:22",
-            "id:22",
-            "id:23",
-            "id:23",
-            "id:24",
-            "id:24",
-            "id:25",
-            "id:25",
-            "id:26",
-            "id:26",
-            "id:27",
-            "id:27",
-            "id:28",
-            "id:28",
-            "id:29",
-            "id:29",
-            "id:30",
-            "id:30",
-            "id:31",
-            "id:31",
-            "id:32",
-            "id:32",
-            "id:33",
-            "id:33",
-            "id:34",
-            "id:34",
-            "id:35",
-            "id:35",
-            "id:36",
-            "id:36",
-            "id:37",
-            "id:37",
-            "id:38",
-            "id:38",
-            "id:39",
-            "id:39",
-            "id:40",
-            "id:40",
-            "sigma",
-            "sigma"
-          )
+test_that("clean_parameters", {
+  expect_identical(
+    clean_parameters(m1),
+    structure(
+      list(
+        Parameter = c(
+          "(Intercept)",
+          "year",
+          "(Intercept)",
+          "sexf",
+          "year",
+          "b[(Intercept) id:1]",
+          "b[(Intercept) id:2]",
+          "b[(Intercept) id:3]",
+          "b[(Intercept) id:4]",
+          "b[(Intercept) id:5]",
+          "b[(Intercept) id:6]",
+          "b[(Intercept) id:7]",
+          "b[(Intercept) id:8]",
+          "b[(Intercept) id:9]",
+          "b[(Intercept) id:10]",
+          "b[(Intercept) id:11]",
+          "b[(Intercept) id:12]",
+          "b[(Intercept) id:13]",
+          "b[(Intercept) id:14]",
+          "b[(Intercept) id:15]",
+          "b[(Intercept) id:16]",
+          "b[(Intercept) id:17]",
+          "b[(Intercept) id:18]",
+          "b[(Intercept) id:19]",
+          "b[(Intercept) id:20]",
+          "b[(Intercept) id:21]",
+          "b[(Intercept) id:22]",
+          "b[(Intercept) id:23]",
+          "b[(Intercept) id:24]",
+          "b[(Intercept) id:25]",
+          "b[(Intercept) id:26]",
+          "b[(Intercept) id:27]",
+          "b[(Intercept) id:28]",
+          "b[(Intercept) id:29]",
+          "b[(Intercept) id:30]",
+          "b[(Intercept) id:31]",
+          "b[(Intercept) id:32]",
+          "b[(Intercept) id:33]",
+          "b[(Intercept) id:34]",
+          "b[(Intercept) id:35]",
+          "b[(Intercept) id:36]",
+          "b[(Intercept) id:37]",
+          "b[(Intercept) id:38]",
+          "b[(Intercept) id:39]",
+          "b[(Intercept) id:40]",
+          "b[(Intercept) id:1]",
+          "b[year id:1]",
+          "b[(Intercept) id:2]",
+          "b[year id:2]",
+          "b[(Intercept) id:3]",
+          "b[year id:3]",
+          "b[(Intercept) id:4]",
+          "b[year id:4]",
+          "b[(Intercept) id:5]",
+          "b[year id:5]",
+          "b[(Intercept) id:6]",
+          "b[year id:6]",
+          "b[(Intercept) id:7]",
+          "b[year id:7]",
+          "b[(Intercept) id:8]",
+          "b[year id:8]",
+          "b[(Intercept) id:9]",
+          "b[year id:9]",
+          "b[(Intercept) id:10]",
+          "b[year id:10]",
+          "b[(Intercept) id:11]",
+          "b[year id:11]",
+          "b[(Intercept) id:12]",
+          "b[year id:12]",
+          "b[(Intercept) id:13]",
+          "b[year id:13]",
+          "b[(Intercept) id:14]",
+          "b[year id:14]",
+          "b[(Intercept) id:15]",
+          "b[year id:15]",
+          "b[(Intercept) id:16]",
+          "b[year id:16]",
+          "b[(Intercept) id:17]",
+          "b[year id:17]",
+          "b[(Intercept) id:18]",
+          "b[year id:18]",
+          "b[(Intercept) id:19]",
+          "b[year id:19]",
+          "b[(Intercept) id:20]",
+          "b[year id:20]",
+          "b[(Intercept) id:21]",
+          "b[year id:21]",
+          "b[(Intercept) id:22]",
+          "b[year id:22]",
+          "b[(Intercept) id:23]",
+          "b[year id:23]",
+          "b[(Intercept) id:24]",
+          "b[year id:24]",
+          "b[(Intercept) id:25]",
+          "b[year id:25]",
+          "b[(Intercept) id:26]",
+          "b[year id:26]",
+          "b[(Intercept) id:27]",
+          "b[year id:27]",
+          "b[(Intercept) id:28]",
+          "b[year id:28]",
+          "b[(Intercept) id:29]",
+          "b[year id:29]",
+          "b[(Intercept) id:30]",
+          "b[year id:30]",
+          "b[(Intercept) id:31]",
+          "b[year id:31]",
+          "b[(Intercept) id:32]",
+          "b[year id:32]",
+          "b[(Intercept) id:33]",
+          "b[year id:33]",
+          "b[(Intercept) id:34]",
+          "b[year id:34]",
+          "b[(Intercept) id:35]",
+          "b[year id:35]",
+          "b[(Intercept) id:36]",
+          "b[year id:36]",
+          "b[(Intercept) id:37]",
+          "b[year id:37]",
+          "b[(Intercept) id:38]",
+          "b[year id:38]",
+          "b[(Intercept) id:39]",
+          "b[year id:39]",
+          "b[(Intercept) id:40]",
+          "b[year id:40]",
+          "sigma",
+          "sigma"
         ),
-        class = c("clean_parameters", "data.frame"),
-        row.names = c(NA, -127L)
-      )
+        Effects = c(
+          "fixed",
+          "fixed",
+          "fixed",
+          "fixed",
+          "fixed",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "random",
+          "fixed",
+          "fixed"
+        ),
+        Component = c(
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "sigma",
+          "sigma"
+        ),
+        Group = c(
+          "",
+          "",
+          "",
+          "",
+          "",
+          "Intercept: id",
+          "Intercept: id",
+          "Intercept: id",
+          "Intercept: id",
+          "Intercept: id",
+          "Intercept: id",
+          "Intercept: id",
+          "Intercept: id",
+          "Intercept: id",
+          "Intercept: id",
+          "Intercept: id",
+          "Intercept: id",
+          "Intercept: id",
+          "Intercept: id",
+          "Intercept: id",
+          "Intercept: id",
+          "Intercept: id",
+          "Intercept: id",
+          "Intercept: id",
+          "Intercept: id",
+          "Intercept: id",
+          "Intercept: id",
+          "Intercept: id",
+          "Intercept: id",
+          "Intercept: id",
+          "Intercept: id",
+          "Intercept: id",
+          "Intercept: id",
+          "Intercept: id",
+          "Intercept: id",
+          "Intercept: id",
+          "Intercept: id",
+          "Intercept: id",
+          "Intercept: id",
+          "Intercept: id",
+          "Intercept: id",
+          "Intercept: id",
+          "Intercept: id",
+          "Intercept: id",
+          "Intercept: id",
+          "Intercept: id",
+          "year: id",
+          "Intercept: id",
+          "year: id",
+          "Intercept: id",
+          "year: id",
+          "Intercept: id",
+          "year: id",
+          "Intercept: id",
+          "year: id",
+          "Intercept: id",
+          "year: id",
+          "Intercept: id",
+          "year: id",
+          "Intercept: id",
+          "year: id",
+          "Intercept: id",
+          "year: id",
+          "Intercept: id",
+          "year: id",
+          "Intercept: id",
+          "year: id",
+          "Intercept: id",
+          "year: id",
+          "Intercept: id",
+          "year: id",
+          "Intercept: id",
+          "year: id",
+          "Intercept: id",
+          "year: id",
+          "Intercept: id",
+          "year: id",
+          "Intercept: id",
+          "year: id",
+          "Intercept: id",
+          "year: id",
+          "Intercept: id",
+          "year: id",
+          "Intercept: id",
+          "year: id",
+          "Intercept: id",
+          "year: id",
+          "Intercept: id",
+          "year: id",
+          "Intercept: id",
+          "year: id",
+          "Intercept: id",
+          "year: id",
+          "Intercept: id",
+          "year: id",
+          "Intercept: id",
+          "year: id",
+          "Intercept: id",
+          "year: id",
+          "Intercept: id",
+          "year: id",
+          "Intercept: id",
+          "year: id",
+          "Intercept: id",
+          "year: id",
+          "Intercept: id",
+          "year: id",
+          "Intercept: id",
+          "year: id",
+          "Intercept: id",
+          "year: id",
+          "Intercept: id",
+          "year: id",
+          "Intercept: id",
+          "year: id",
+          "Intercept: id",
+          "year: id",
+          "Intercept: id",
+          "year: id",
+          "Intercept: id",
+          "year: id",
+          "Intercept: id",
+          "year: id",
+          "Intercept: id",
+          "year: id",
+          "",
+          ""
+        ),
+        Response = c(
+          "y1",
+          "y1",
+          "y2",
+          "y2",
+          "y2",
+          "y1",
+          "y1",
+          "y1",
+          "y1",
+          "y1",
+          "y1",
+          "y1",
+          "y1",
+          "y1",
+          "y1",
+          "y1",
+          "y1",
+          "y1",
+          "y1",
+          "y1",
+          "y1",
+          "y1",
+          "y1",
+          "y1",
+          "y1",
+          "y1",
+          "y1",
+          "y1",
+          "y1",
+          "y1",
+          "y1",
+          "y1",
+          "y1",
+          "y1",
+          "y1",
+          "y1",
+          "y1",
+          "y1",
+          "y1",
+          "y1",
+          "y1",
+          "y1",
+          "y1",
+          "y1",
+          "y1",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y2",
+          "y1",
+          "y2"
+        ),
+        Cleaned_Parameter = c(
+          "(Intercept)",
+          "year",
+          "(Intercept)",
+          "sexf",
+          "year",
+          "id:1",
+          "id:2",
+          "id:3",
+          "id:4",
+          "id:5",
+          "id:6",
+          "id:7",
+          "id:8",
+          "id:9",
+          "id:10",
+          "id:11",
+          "id:12",
+          "id:13",
+          "id:14",
+          "id:15",
+          "id:16",
+          "id:17",
+          "id:18",
+          "id:19",
+          "id:20",
+          "id:21",
+          "id:22",
+          "id:23",
+          "id:24",
+          "id:25",
+          "id:26",
+          "id:27",
+          "id:28",
+          "id:29",
+          "id:30",
+          "id:31",
+          "id:32",
+          "id:33",
+          "id:34",
+          "id:35",
+          "id:36",
+          "id:37",
+          "id:38",
+          "id:39",
+          "id:40",
+          "id:1",
+          "id:1",
+          "id:2",
+          "id:2",
+          "id:3",
+          "id:3",
+          "id:4",
+          "id:4",
+          "id:5",
+          "id:5",
+          "id:6",
+          "id:6",
+          "id:7",
+          "id:7",
+          "id:8",
+          "id:8",
+          "id:9",
+          "id:9",
+          "id:10",
+          "id:10",
+          "id:11",
+          "id:11",
+          "id:12",
+          "id:12",
+          "id:13",
+          "id:13",
+          "id:14",
+          "id:14",
+          "id:15",
+          "id:15",
+          "id:16",
+          "id:16",
+          "id:17",
+          "id:17",
+          "id:18",
+          "id:18",
+          "id:19",
+          "id:19",
+          "id:20",
+          "id:20",
+          "id:21",
+          "id:21",
+          "id:22",
+          "id:22",
+          "id:23",
+          "id:23",
+          "id:24",
+          "id:24",
+          "id:25",
+          "id:25",
+          "id:26",
+          "id:26",
+          "id:27",
+          "id:27",
+          "id:28",
+          "id:28",
+          "id:29",
+          "id:29",
+          "id:30",
+          "id:30",
+          "id:31",
+          "id:31",
+          "id:32",
+          "id:32",
+          "id:33",
+          "id:33",
+          "id:34",
+          "id:34",
+          "id:35",
+          "id:35",
+          "id:36",
+          "id:36",
+          "id:37",
+          "id:37",
+          "id:38",
+          "id:38",
+          "id:39",
+          "id:39",
+          "id:40",
+          "id:40",
+          "sigma",
+          "sigma"
+        )
+      ),
+      class = c("clean_parameters", "data.frame"),
+      row.names = c(NA, -127L)
     )
-  })
-}
+  )
+})
diff --git a/tests/testthat/test-n_grouplevels.R b/tests/testthat/test-n_grouplevels.R
index c76551321..729a95981 100644
--- a/tests/testthat/test-n_grouplevels.R
+++ b/tests/testthat/test-n_grouplevels.R
@@ -1,23 +1,23 @@
-if (skip_if_not_or_load_if_installed("lme4")) {
-  data(sleepstudy)
-  d <- sleepstudy
-  set.seed(12345)
-  d$grp <- sample(1:5, size = 180, replace = TRUE)
-  d$subgrp <- NA
-  for (i in 1:5) {
-    filter_group <- d$grp == i
-    d$subgrp[filter_group] <-
-      sample(1:30, size = sum(filter_group), replace = TRUE)
-  }
-  dd <<- d
-  model <- lmer(
-    Reaction ~ Days + (1 | grp / subgrp) + (1 | Subject),
-    data = dd
-  )
+skip_if_not_installed("lme4")
 
-  test_that("n_grouplevels", {
-    out <- n_grouplevels(model)
-    expect_identical(out$Group, c("subgrp", "grp", "Subject", "subgrp:grp"))
-    expect_identical(out$N_levels, c(30L, 5L, 18L, 108L))
-  })
+data(sleepstudy, package = "lme4")
+d <- sleepstudy
+set.seed(12345)
+d$grp <- sample(1:5, size = 180, replace = TRUE)
+d$subgrp <- NA
+for (i in 1:5) {
+  filter_group <- d$grp == i
+  d$subgrp[filter_group] <-
+    sample(1:30, size = sum(filter_group), replace = TRUE)
 }
+dd <<- d
+model <- lme4::lmer(
+  Reaction ~ Days + (1 | grp / subgrp) + (1 | Subject),
+  data = dd
+)
+
+test_that("n_grouplevels", {
+  out <- n_grouplevels(model)
+  expect_identical(out$Group, c("subgrp", "grp", "Subject", "subgrp:grp"))
+  expect_identical(out$N_levels, c(30L, 5L, 18L, 108L))
+})
diff --git a/tests/testthat/test-n_parameters_rank-deficiency.R b/tests/testthat/test-n_parameters_rank-deficiency.R
index 0e8611ea7..51f9a1c35 100644
--- a/tests/testthat/test-n_parameters_rank-deficiency.R
+++ b/tests/testthat/test-n_parameters_rank-deficiency.R
@@ -1,5 +1,3 @@
-set.seed(123)
-data(mtcars)
 m <- lm(formula = wt ~ am * cyl * vs, data = mtcars)
 
 test_that("n_parameters-rank_deficiency", {
diff --git a/tests/testthat/test-namespace.R b/tests/testthat/test-namespace.R
index 7a301ebd9..5a886d5e4 100644
--- a/tests/testthat/test-namespace.R
+++ b/tests/testthat/test-namespace.R
@@ -1,95 +1,78 @@
-if (skip_if_not_or_load_if_installed("splines")) {
-  data(iris)
-  m1 <- lm(Sepal.Length ~ splines::bs(Petal.Width, df = 4) + Species, data = iris)
-
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_linear)
-  })
-
-  test_that("find_predictors", {
-    expect_identical(find_predictors(m1), list(conditional = c("Petal.Width", "Species")))
-    expect_identical(
-      find_predictors(m1, flatten = TRUE),
-      c("Petal.Width", "Species")
-    )
-    expect_null(find_predictors(m1, effects = "random"))
-  })
-
-  test_that("get_predictors", {
-    expect_equal(get_predictors(m1), iris[, c("Petal.Width", "Species")])
-  })
-
-  test_that("find_response", {
-    expect_identical(find_response(m1), "Sepal.Length")
-  })
-
-  test_that("get_response", {
-    expect_identical(get_response(m1), iris$Sepal.Length)
-  })
-
-  test_that("link_inverse", {
-    expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-4)
-  })
-
-  test_that("link_function", {
-    expect_equal(link_function(m1)(0.2), 0.2, tolerance = 1e-4)
-  })
-
-  test_that("get_data", {
-    expect_equal(nrow(get_data(m1)), 150)
-    expect_equal(
-      colnames(get_data(m1)),
-      c("Sepal.Length", "Petal.Width", "Species")
-    )
-  })
-
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 1)
-    expect_equal(
-      find_formula(m1),
-      list(
-        conditional = as.formula("Sepal.Length ~ splines::bs(Petal.Width, df = 4) + Species")
-      ),
-      ignore_attr = TRUE
-    )
-  })
-
-  test_that("find_variables", {
-    expect_equal(
-      find_variables(m1),
-      list(
-        response = "Sepal.Length",
-        conditional = c("Petal.Width", "Species")
-      )
-    )
-    expect_equal(
-      find_variables(m1, flatten = TRUE),
-      c("Sepal.Length", "Petal.Width", "Species")
-    )
-  })
-
-  test_that("find_parameters", {
-    expect_equal(
-      find_parameters(m1),
-      list(
-        conditional = c(
-          "(Intercept)",
-          "splines::bs(Petal.Width, df = 4)1",
-          "splines::bs(Petal.Width, df = 4)2",
-          "splines::bs(Petal.Width, df = 4)3",
-          "splines::bs(Petal.Width, df = 4)4",
-          "Speciesversicolor",
-          "Speciesvirginica"
-        )
-      )
+skip_if_not_installed("splines")
+
+m1 <- lm(Sepal.Length ~ splines::bs(Petal.Width, df = 4) + Species, data = iris)
+
+test_that("model_info", {
+  expect_true(model_info(m1)$is_linear)
+})
+
+test_that("find_predictors", {
+  expect_identical(find_predictors(m1), list(conditional = c("Petal.Width", "Species")))
+  expect_identical(
+    find_predictors(m1, flatten = TRUE),
+    c("Petal.Width", "Species")
+  )
+  expect_null(find_predictors(m1, effects = "random"))
+})
+
+test_that("get_predictors", {
+  expect_equal(get_predictors(m1), iris[, c("Petal.Width", "Species")])
+})
+
+test_that("find_response", {
+  expect_identical(find_response(m1), "Sepal.Length")
+})
+
+test_that("get_response", {
+  expect_identical(get_response(m1), iris$Sepal.Length)
+})
+
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-4)
+})
+
+test_that("link_function", {
+  expect_equal(link_function(m1)(0.2), 0.2, tolerance = 1e-4)
+})
+
+test_that("get_data", {
+  expect_equal(nrow(get_data(m1)), 150)
+  expect_equal(
+    colnames(get_data(m1)),
+    c("Sepal.Length", "Petal.Width", "Species")
+  )
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1), 1)
+  expect_equal(
+    find_formula(m1),
+    list(
+      conditional = as.formula("Sepal.Length ~ splines::bs(Petal.Width, df = 4) + Species")
+    ),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_variables", {
+  expect_equal(
+    find_variables(m1),
+    list(
+      response = "Sepal.Length",
+      conditional = c("Petal.Width", "Species")
     )
-  })
+  )
+  expect_equal(
+    find_variables(m1, flatten = TRUE),
+    c("Sepal.Length", "Petal.Width", "Species")
+  )
+})
 
-  test_that("get_parameters", {
-    expect_equal(nrow(get_parameters(m1)), 7)
-    expect_equal(
-      get_parameters(m1)$Parameter,
-      c(
+test_that("find_parameters", {
+  expect_equal(
+    find_parameters(m1),
+    list(
+      conditional = c(
         "(Intercept)",
         "splines::bs(Petal.Width, df = 4)1",
         "splines::bs(Petal.Width, df = 4)2",
@@ -99,23 +82,39 @@ if (skip_if_not_or_load_if_installed("splines")) {
         "Speciesvirginica"
       )
     )
-  })
-
-  test_that("find_algorithm", {
-    expect_equal(find_algorithm(m1), list(algorithm = "OLS"))
-  })
-
-  test_that("find_terms", {
-    expect_equal(
-      find_terms(m1),
-      list(
-        response = "Sepal.Length",
-        conditional = c("splines", "bs(Petal.Width, df = 4)", "Species")
-      )
+  )
+})
+
+test_that("get_parameters", {
+  expect_equal(nrow(get_parameters(m1)), 7)
+  expect_equal(
+    get_parameters(m1)$Parameter,
+    c(
+      "(Intercept)",
+      "splines::bs(Petal.Width, df = 4)1",
+      "splines::bs(Petal.Width, df = 4)2",
+      "splines::bs(Petal.Width, df = 4)3",
+      "splines::bs(Petal.Width, df = 4)4",
+      "Speciesversicolor",
+      "Speciesvirginica"
+    )
+  )
+})
+
+test_that("find_algorithm", {
+  expect_equal(find_algorithm(m1), list(algorithm = "OLS"))
+})
+
+test_that("find_terms", {
+  expect_equal(
+    find_terms(m1),
+    list(
+      response = "Sepal.Length",
+      conditional = c("splines", "bs(Petal.Width, df = 4)", "Species")
     )
-  })
+  )
+})
 
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "t-statistic")
-  })
-}
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "t-statistic")
+})
diff --git a/tests/testthat/test-negbin.R b/tests/testthat/test-negbin.R
index 7f92abc75..409a6a0ed 100644
--- a/tests/testthat/test-negbin.R
+++ b/tests/testthat/test-negbin.R
@@ -1,172 +1,172 @@
-if (skip_if_not_or_load_if_installed("aod")) {
-  data(dja)
-  m1 <- suppressWarnings(
-    aod::negbin(y ~ group + offset(log(trisk)),
-      random = ~village,
-      data = dja
-    )
-  )
+skip_if_not_installed("aod")
 
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_negbin)
-    expect_true(model_info(m1)$is_mixed)
-    expect_false(model_info(m1)$is_linear)
-  })
-
-  test_that("find_predictors", {
-    expect_identical(find_predictors(m1), list(conditional = c("group", "trisk")))
-    expect_identical(find_predictors(m1, flatten = TRUE), c("group", "trisk"))
-    expect_identical(
-      find_predictors(m1, effects = "random"),
-      list(random = "village")
-    )
-    expect_identical(
-      find_predictors(m1, effects = "all"),
-      list(
-        conditional = c("group", "trisk"),
-        random = "village"
-      )
+data(dja, package = "aod")
+m1 <- suppressWarnings(
+  aod::negbin(y ~ group + offset(log(trisk)),
+    random = ~village,
+    data = dja
+  )
+)
+
+test_that("model_info", {
+  expect_true(model_info(m1)$is_negbin)
+  expect_true(model_info(m1)$is_mixed)
+  expect_false(model_info(m1)$is_linear)
+})
+
+test_that("find_predictors", {
+  expect_identical(find_predictors(m1), list(conditional = c("group", "trisk")))
+  expect_identical(find_predictors(m1, flatten = TRUE), c("group", "trisk"))
+  expect_identical(
+    find_predictors(m1, effects = "random"),
+    list(random = "village")
+  )
+  expect_identical(
+    find_predictors(m1, effects = "all"),
+    list(
+      conditional = c("group", "trisk"),
+      random = "village"
     )
-  })
+  )
+})
 
-  test_that("get_df", {
-    expect_equal(
-      get_df(m1, type = "residual"),
-      df.residual(m1),
-      ignore_attr = TRUE
-    )
-    expect_equal(
-      get_df(m1, type = "normal"),
-      Inf,
-      ignore_attr = TRUE
-    )
-    expect_equal(
-      get_df(m1, type = "wald"),
-      Inf,
-      ignore_attr = TRUE
-    )
-  })
-
-  test_that("find_random", {
-    expect_identical(find_random(m1), list(random = "village"))
-  })
-
-  test_that("get_random", {
-    expect_equal(get_random(m1), dja[, "village", drop = FALSE], ignore_attr = TRUE)
-  })
-
-  test_that("find_response", {
-    expect_identical(find_response(m1), "y")
-    expect_identical(find_response(m1, combine = FALSE), "y")
-  })
-
-  test_that("get_response", {
-    expect_equal(get_response(m1), dja[, "y"])
-  })
-
-  test_that("get_predictors", {
-    expect_equal(colnames(get_predictors(m1)), c("group", "trisk"))
-  })
-
-  test_that("link_inverse", {
-    expect_equal(link_inverse(m1)(0.2), exp(0.2), tolerance = 1e-5)
-  })
-
-  test_that("link_function", {
-    expect_equal(link_function(m1)(0.2), log(0.2), tolerance = 1e-5)
-  })
-
-  test_that("get_data", {
-    expect_equal(nrow(get_data(m1, verbose = FALSE)), 75)
-    expect_equal(colnames(get_data(m1, verbose = FALSE)), c("y", "group", "trisk", "village"))
-  })
-
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 2)
-    expect_equal(
-      find_formula(m1),
-      list(
-        conditional = as.formula("y ~ group + offset(log(trisk))"),
-        random = as.formula("~village")
-      ),
-      ignore_attr = TRUE
-    )
-  })
-
-  test_that("find_variables", {
-    expect_equal(
-      find_variables(m1),
-      list(
-        response = "y",
-        conditional = c("group", "trisk"),
-        random = "village"
-      )
-    )
-    expect_equal(
-      find_variables(m1, flatten = TRUE),
-      c("y", "group", "trisk", "village")
+test_that("get_df", {
+  expect_equal(
+    get_df(m1, type = "residual"),
+    aod::df.residual(m1),
+    ignore_attr = TRUE
+  )
+  expect_equal(
+    get_df(m1, type = "normal"),
+    Inf,
+    ignore_attr = TRUE
+  )
+  expect_equal(
+    get_df(m1, type = "wald"),
+    Inf,
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_random", {
+  expect_identical(find_random(m1), list(random = "village"))
+})
+
+test_that("get_random", {
+  expect_equal(get_random(m1), dja[, "village", drop = FALSE], ignore_attr = TRUE)
+})
+
+test_that("find_response", {
+  expect_identical(find_response(m1), "y")
+  expect_identical(find_response(m1, combine = FALSE), "y")
+})
+
+test_that("get_response", {
+  expect_equal(get_response(m1), dja[, "y"])
+})
+
+test_that("get_predictors", {
+  expect_equal(colnames(get_predictors(m1)), c("group", "trisk"))
+})
+
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), exp(0.2), tolerance = 1e-5)
+})
+
+test_that("link_function", {
+  expect_equal(link_function(m1)(0.2), log(0.2), tolerance = 1e-5)
+})
+
+test_that("get_data", {
+  expect_equal(nrow(get_data(m1, verbose = FALSE)), 75)
+  expect_equal(colnames(get_data(m1, verbose = FALSE)), c("y", "group", "trisk", "village"))
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1), 2)
+  expect_equal(
+    find_formula(m1),
+    list(
+      conditional = as.formula("y ~ group + offset(log(trisk))"),
+      random = as.formula("~village")
+    ),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_variables", {
+  expect_equal(
+    find_variables(m1),
+    list(
+      response = "y",
+      conditional = c("group", "trisk"),
+      random = "village"
     )
-  })
-
-  test_that("n_obs", {
-    expect_equal(n_obs(m1), 75)
-  })
-
-  test_that("find_parameters", {
-    expect_equal(
-      find_parameters(m1),
-      list(
-        conditional = c("(Intercept)", "groupTREAT"),
-        random = c(
-          "phi.villageBAK",
-          "phi.villageBAM",
-          "phi.villageBAN",
-          "phi.villageBIJ",
-          "phi.villageBOU",
-          "phi.villageBYD",
-          "phi.villageDEM",
-          "phi.villageDIA",
-          "phi.villageHAM",
-          "phi.villageLAM",
-          "phi.villageLAY",
-          "phi.villageMAF",
-          "phi.villageMAH",
-          "phi.villageMAK",
-          "phi.villageMED",
-          "phi.villageNAB",
-          "phi.villageSAG",
-          "phi.villageSAM",
-          "phi.villageSOU"
-        )
+  )
+  expect_equal(
+    find_variables(m1, flatten = TRUE),
+    c("y", "group", "trisk", "village")
+  )
+})
+
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 75)
+})
+
+test_that("find_parameters", {
+  expect_equal(
+    find_parameters(m1),
+    list(
+      conditional = c("(Intercept)", "groupTREAT"),
+      random = c(
+        "phi.villageBAK",
+        "phi.villageBAM",
+        "phi.villageBAN",
+        "phi.villageBIJ",
+        "phi.villageBOU",
+        "phi.villageBYD",
+        "phi.villageDEM",
+        "phi.villageDIA",
+        "phi.villageHAM",
+        "phi.villageLAM",
+        "phi.villageLAY",
+        "phi.villageMAF",
+        "phi.villageMAH",
+        "phi.villageMAK",
+        "phi.villageMED",
+        "phi.villageNAB",
+        "phi.villageSAG",
+        "phi.villageSAM",
+        "phi.villageSOU"
       )
     )
-    expect_equal(nrow(get_parameters(m1)), 2)
-    expect_equal(
-      get_parameters(m1)$Parameter,
-      c("(Intercept)", "groupTREAT")
-    )
-  })
-
-  test_that("is_multivariate", {
-    expect_false(is_multivariate(m1))
-  })
-
-  test_that("find_terms", {
-    expect_equal(
-      find_terms(m1),
-      list(
-        response = "y",
-        conditional = c("group", "offset(log(trisk))"),
-        random = "village"
-      )
+  )
+  expect_equal(nrow(get_parameters(m1)), 2)
+  expect_equal(
+    get_parameters(m1)$Parameter,
+    c("(Intercept)", "groupTREAT")
+  )
+})
+
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1))
+})
+
+test_that("find_terms", {
+  expect_equal(
+    find_terms(m1),
+    list(
+      response = "y",
+      conditional = c("group", "offset(log(trisk))"),
+      random = "village"
     )
-  })
+  )
+})
 
-  test_that("find_algorithm", {
-    expect_equal(find_algorithm(m1), list(algorithm = "ML"))
-  })
+test_that("find_algorithm", {
+  expect_equal(find_algorithm(m1), list(algorithm = "ML"))
+})
 
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "z-statistic")
-  })
-}
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "z-statistic")
+})
diff --git a/tests/testthat/test-nlmer.R b/tests/testthat/test-nlmer.R
index 56e4a8422..601a432fb 100644
--- a/tests/testthat/test-nlmer.R
+++ b/tests/testthat/test-nlmer.R
@@ -1,19 +1,19 @@
-if (skip_if_not_or_load_if_installed("lme4")) {
-  set.seed(123)
-  startvec <- c(Asym = 200, xmid = 725, scal = 350)
-  nm1 <-
-    lme4::nlmer(
-      formula = circumference ~ SSlogis(age, Asym, xmid, scal) ~ Asym | Tree,
-      data = Orange,
-      start = startvec
-    )
+skip_if_not_installed("lme4")
 
-  test_that("model_info", {
-    skip_if(getRversion() < "4.1.0")
-    expect_true(model_info(nm1)$is_linear)
-  })
+set.seed(123)
+startvec <- c(Asym = 200, xmid = 725, scal = 350)
+nm1 <-
+  lme4::nlmer(
+    formula = circumference ~ SSlogis(age, Asym, xmid, scal) ~ Asym | Tree,
+    data = Orange,
+    start = startvec
+  )
 
-  test_that("find_statistic", {
-    expect_identical(find_statistic(nm1), "t-statistic")
-  })
-}
+test_that("model_info", {
+  skip_if(getRversion() < "4.1.0")
+  expect_true(model_info(nm1)$is_linear)
+})
+
+test_that("find_statistic", {
+  expect_identical(find_statistic(nm1), "t-statistic")
+})
diff --git a/tests/testthat/test-null_model.R b/tests/testthat/test-null_model.R
index a7b257588..8344b14d8 100644
--- a/tests/testthat/test-null_model.R
+++ b/tests/testthat/test-null_model.R
@@ -1,46 +1,44 @@
-if (
-  skip_if_not_or_load_if_installed("glmmTMB") &&
-    skip_if_not_or_load_if_installed("lme4") &&
-    skip_if_not_or_load_if_installed("TMB") &&
-    getRversion() >= "4.0.0") {
-  data(mtcars)
-  m1 <- suppressWarnings(glmer.nb(mpg ~ disp + (1 | cyl) + offset(log(wt)), data = mtcars))
-  m2 <- suppressWarnings(glmer.nb(mpg ~ disp + (1 | cyl), offset = log(wt), data = mtcars))
+skip_if_not_installed("glmmTMB")
+skip_if_not_installed("lme4")
+skip_if_not_installed("TMB")
+skip_if_not(getRversion() >= "4.0.0")
 
-  test_that("null_model with offset", {
-    nm1 <- null_model(m1)
-    nm2 <- null_model(m2)
-    expect_equal(fixef(nm1), fixef(nm2), tolerance = 1e-4)
-  })
+m1 <- suppressWarnings(lme4::glmer.nb(mpg ~ disp + (1 | cyl) + offset(log(wt)), data = mtcars))
+m2 <- suppressWarnings(lme4::glmer.nb(mpg ~ disp + (1 | cyl), offset = log(wt), data = mtcars))
 
-  skip_on_os("mac") # error: FreeADFunObject
-  m1 <- suppressWarnings(glmmTMB(mpg ~ disp + (1 | cyl) + offset(log(wt)), data = mtcars))
-  m2 <- suppressWarnings(glmmTMB(mpg ~ disp + (1 | cyl), offset = log(wt), data = mtcars))
+test_that("null_model with offset", {
+  nm1 <- null_model(m1)
+  nm2 <- null_model(m2)
+  expect_equal(glmmTMB::fixef(nm1), glmmTMB::fixef(nm2), tolerance = 1e-4)
+})
 
-  test_that("null_model with offset", {
-    nm1 <- null_model(m1)
-    nm2 <- null_model(m2)
-    expect_equal(fixef(nm1), fixef(nm2), tolerance = 1e-4)
-  })
+skip_on_os("mac") # error: FreeADFunObject
+m1 <- suppressWarnings(glmmTMB::glmmTMB(mpg ~ disp + (1 | cyl) + offset(log(wt)), data = mtcars))
+m2 <- suppressWarnings(glmmTMB::glmmTMB(mpg ~ disp + (1 | cyl), offset = log(wt), data = mtcars))
 
+test_that("null_model with offset", {
+  nm1 <- null_model(m1)
+  nm2 <- null_model(m2)
+  expect_equal(glmmTMB::fixef(nm1), glmmTMB::fixef(nm2), tolerance = 1e-4)
+})
 
-  # set.seed(123)
-  # N <- 100 # Samples
-  # x <- runif(N, 0, 10) # Predictor
-  # off <- rgamma(N, 3, 2) # Offset variable
-  # yhat <- -1 + x * 0.5 + log(off) # Prediction on log scale
-  #
-  # y <- rpois(N, exp(yhat)) # Poisson process
-  # y <- ifelse(rbinom(N, 1, 0.3), 0, y) # Zero-inflation process
-  #
-  # d <<- data.frame(y = y, x, logOff = log(off)) # Storage dataframe
-  #
-  # m1 <- glm(y ~ x + offset(logOff), data = d, family = "poisson")
-  # m2 <- glm(y ~ x, offset = logOff, data = d, family = "poisson")
-  #
-  # test_that("null_model with offset", {
-  #   nm1 <- null_model(m1)
-  #   nm2 <- null_model(m2)
-  #   expect_equal(coef(nm1), coef(nm2), tolerance = 1e-4)
-  # })
-}
+
+# set.seed(123)
+# N <- 100 # Samples
+# x <- runif(N, 0, 10) # Predictor
+# off <- rgamma(N, 3, 2) # Offset variable
+# yhat <- -1 + x * 0.5 + log(off) # Prediction on log scale
+#
+# y <- rpois(N, exp(yhat)) # Poisson process
+# y <- ifelse(rbinom(N, 1, 0.3), 0, y) # Zero-inflation process
+#
+# d <<- data.frame(y = y, x, logOff = log(off)) # Storage dataframe
+#
+# m1 <- glm(y ~ x + offset(logOff), data = d, family = "poisson")
+# m2 <- glm(y ~ x, offset = logOff, data = d, family = "poisson")
+#
+# test_that("null_model with offset", {
+#   nm1 <- null_model(m1)
+#   nm2 <- null_model(m2)
+#   expect_equal(coef(nm1), coef(nm2), tolerance = 1e-4)
+# })
diff --git a/tests/testthat/test-offset.R b/tests/testthat/test-offset.R
index 118b63083..7d149745c 100644
--- a/tests/testthat/test-offset.R
+++ b/tests/testthat/test-offset.R
@@ -1,43 +1,41 @@
-if (
+skip_if_not_installed("pscl")
 
-  skip_if_not_or_load_if_installed("pscl")) {
-  # Generate some zero-inflated data
-  set.seed(123)
-  N <- 100 # Samples
-  x <- runif(N, 0, 10) # Predictor
-  off <- rgamma(N, 3, 2) # Offset variable
-  yhat <- -1 + x * 0.5 + log(off) # Prediction on log scale
-  y <- rpois(N, exp(yhat)) # Poisson process
-  y <- ifelse(rbinom(N, 1, 0.3), 0, y) # Zero-inflation process
+# Generate some zero-inflated data
+set.seed(123)
+N <- 100 # Samples
+x <- runif(N, 0, 10) # Predictor
+off <- rgamma(N, 3, 2) # Offset variable
+yhat <- -1 + x * 0.5 + log(off) # Prediction on log scale
+y <- rpois(N, exp(yhat)) # Poisson process
+y <- ifelse(rbinom(N, 1, 0.3), 0, y) # Zero-inflation process
 
-  d <<- data.frame(y = y, x, logOff = log(off)) # Storage dataframe
+d <<- data.frame(y = y, x, logOff = log(off)) # Storage dataframe
 
-  # Fit zeroinfl model using 2 methods of offset input
-  m1 <- zeroinfl(y ~ offset(logOff) + x | 1, data = d, dist = "poisson")
-  m2 <- zeroinfl(y ~ x | 1,
-    data = d,
-    offset = logOff,
-    dist = "poisson"
-  )
+# Fit zeroinfl model using 2 methods of offset input
+m1 <- pscl::zeroinfl(y ~ offset(logOff) + x | 1, data = d, dist = "poisson")
+m2 <- pscl::zeroinfl(y ~ x | 1,
+  data = d,
+  offset = logOff,
+  dist = "poisson"
+)
 
-  # Fit zeroinfl model without offset data
-  m3 <- zeroinfl(y ~ x | 1, data = d, dist = "poisson")
+# Fit zeroinfl model without offset data
+m3 <- pscl::zeroinfl(y ~ x | 1, data = d, dist = "poisson")
 
-  test_that("offset in get_data()", {
-    expect_equal(colnames(get_data(m1)), c("y", "logOff", "x"))
-    expect_equal(colnames(get_data(m2)), c("y", "x", "logOff"))
-    expect_equal(colnames(get_data(m3)), c("y", "x"))
-  })
+test_that("offset in get_data()", {
+  expect_equal(colnames(get_data(m1)), c("y", "logOff", "x"))
+  expect_equal(colnames(get_data(m2)), c("y", "x", "logOff"))
+  expect_equal(colnames(get_data(m3)), c("y", "x"))
+})
 
-  test_that("offset in get_data()", {
-    expect_equal(find_offset(m1), "logOff")
-    expect_equal(find_offset(m2), "logOff")
-    expect_null(find_offset(m3))
-  })
+test_that("offset in get_data()", {
+  expect_equal(find_offset(m1), "logOff")
+  expect_equal(find_offset(m2), "logOff")
+  expect_null(find_offset(m3))
+})
 
-  # test_that("offset in null_model()", {
-  #   nm1 <- null_model(m1)
-  #   nm2 <- null_model(m2)
-  #   expect_equal(coef(nm1), coef(nm2), tolerance = 1e-4)
-  # })
-}
+# test_that("offset in null_model()", {
+#   nm1 <- null_model(m1)
+#   nm2 <- null_model(m2)
+#   expect_equal(coef(nm1), coef(nm2), tolerance = 1e-4)
+# })
diff --git a/tests/testthat/test-ols.R b/tests/testthat/test-ols.R
index 51574277c..ba06731dd 100644
--- a/tests/testthat/test-ols.R
+++ b/tests/testthat/test-ols.R
@@ -1,100 +1,97 @@
-if (
-
-  skip_if_not_or_load_if_installed("rms")) {
-  data(mtcars)
-  m1 <- ols(mpg ~ rcs(hp, 3) * cyl + wt, data = mtcars)
-
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_linear)
-  })
-
-  test_that("find_predictors", {
-    expect_identical(find_predictors(m1), list(conditional = c("hp", "cyl", "wt")))
-    expect_identical(find_predictors(m1, flatten = TRUE), c("hp", "cyl", "wt"))
-    expect_null(find_predictors(m1, effects = "random"))
-  })
-
-  test_that("find_random", {
-    expect_null(find_random(m1))
-  })
-
-  test_that("get_random", {
-    expect_warning(get_random(m1))
-  })
-
-  test_that("find_response", {
-    expect_identical(find_response(m1), "mpg")
-  })
-
-  test_that("get_response", {
-    expect_equal(get_response(m1), mtcars$mpg)
-  })
-
-  test_that("get_predictors", {
-    expect_equal(colnames(get_predictors(m1)), c("hp", "cyl", "wt"))
-  })
-
-  test_that("get_data", {
-    expect_equal(nrow(get_data(m1)), 32)
-    expect_equal(colnames(get_data(m1)), c("mpg", "hp", "cyl", "wt"))
-  })
-
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 1)
-    expect_equal(
-      find_formula(m1),
-      list(conditional = as.formula("mpg ~ rcs(hp, 3) * cyl + wt")),
-      ignore_attr = TRUE
+skip_if_not_installed("rms")
+
+m1 <- rms::ols(mpg ~ rms::rcs(hp, 3) * cyl + wt, data = mtcars)
+
+test_that("model_info", {
+  expect_true(model_info(m1)$is_linear)
+})
+
+test_that("find_predictors", {
+  expect_identical(find_predictors(m1), list(conditional = c("hp", "cyl", "wt")))
+  expect_identical(find_predictors(m1, flatten = TRUE), c("hp", "cyl", "wt"))
+  expect_null(find_predictors(m1, effects = "random"))
+})
+
+test_that("find_random", {
+  expect_null(find_random(m1))
+})
+
+test_that("get_random", {
+  expect_warning(get_random(m1))
+})
+
+test_that("find_response", {
+  expect_identical(find_response(m1), "mpg")
+})
+
+test_that("get_response", {
+  expect_equal(get_response(m1), mtcars$mpg)
+})
+
+test_that("get_predictors", {
+  expect_equal(colnames(get_predictors(m1)), c("hp", "cyl", "wt"))
+})
+
+test_that("get_data", {
+  expect_equal(nrow(get_data(m1)), 32)
+  expect_equal(colnames(get_data(m1)), c("mpg", "hp", "cyl", "wt"))
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1), 1)
+  expect_equal(
+    find_formula(m1),
+    list(conditional = as.formula("mpg ~ rms::rcs(hp, 3) * cyl + wt")),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_variables", {
+  expect_equal(find_variables(m1), list(
+    response = "mpg",
+    conditional = c("hp", "cyl", "wt")
+  ))
+  expect_equal(
+    find_variables(m1, flatten = TRUE),
+    c("mpg", "hp", "cyl", "wt")
+  )
+})
+
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 32)
+})
+
+test_that("linkfun", {
+  expect_equal(link_function(m1)(0.2), 0.2, tolerance = 1e-5)
+})
+
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
+})
+
+test_that("find_parameters", {
+  expect_equal(
+    find_parameters(m1),
+    list(
+      conditional = c("Intercept", "hp", "hp'", "cyl", "wt", "hp * cyl", "hp' * cyl")
     )
-  })
-
-  test_that("find_variables", {
-    expect_equal(find_variables(m1), list(
-      response = "mpg",
-      conditional = c("hp", "cyl", "wt")
-    ))
-    expect_equal(
-      find_variables(m1, flatten = TRUE),
-      c("mpg", "hp", "cyl", "wt")
-    )
-  })
-
-  test_that("n_obs", {
-    expect_equal(n_obs(m1), 32)
-  })
-
-  test_that("linkfun", {
-    expect_equal(link_function(m1)(0.2), 0.2, tolerance = 1e-5)
-  })
-
-  test_that("link_inverse", {
-    expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
-  })
-
-  test_that("find_parameters", {
-    expect_equal(
-      find_parameters(m1),
-      list(
-        conditional = c("Intercept", "hp", "hp'", "cyl", "wt", "hp * cyl", "hp' * cyl")
-      )
-    )
-    expect_equal(nrow(get_parameters(m1)), 7)
-    expect_equal(
-      get_parameters(m1)$Parameter,
-      c("Intercept", "hp", "hp'", "cyl", "wt", "hp * cyl", "hp' * cyl")
-    )
-  })
-
-  test_that("is_multivariate", {
-    expect_false(is_multivariate(m1))
-  })
-
-  test_that("find_algorithm", {
-    expect_equal(find_algorithm(m1), list(algorithm = "OLS"))
-  })
-
-  # TO DO
-  # test_that("find_statistic", {
-  #   expect_null(find_statistic(m1))
-  # })
-}
+  )
+  expect_equal(nrow(get_parameters(m1)), 7)
+  expect_equal(
+    get_parameters(m1)$Parameter,
+    c("Intercept", "hp", "hp'", "cyl", "wt", "hp * cyl", "hp' * cyl")
+  )
+})
+
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1))
+})
+
+test_that("find_algorithm", {
+  expect_equal(find_algorithm(m1), list(algorithm = "OLS"))
+})
+
+# TO DO
+# test_that("find_statistic", {
+#   expect_null(find_statistic(m1))
+# })
diff --git a/tests/testthat/test-panelr.R b/tests/testthat/test-panelr.R
index c222400e7..dbe30e8a9 100644
--- a/tests/testthat/test-panelr.R
+++ b/tests/testthat/test-panelr.R
@@ -1,271 +1,271 @@
-if (skip_if_not_or_load_if_installed("panelr")) {
-  data("WageData")
-  wages <- panel_data(WageData, id = id, wave = t)
-  m1 <- wbm(lwage ~ lag(union) + wks | blk + fem | blk * lag(union), data = wages)
-  m2 <- wbm(lwage ~ lag(union) + wks | blk + t | (t | id), data = wages)
+skip_if_not_installed("panelr")
 
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_linear)
-    expect_true(model_info(m2)$is_linear)
-  })
+data("WageData", package = "panelr")
+wages <- panelr::panel_data(WageData, id = id, wave = t)
+m1 <- panelr::wbm(lwage ~ lag(union) + wks | blk + fem | blk * lag(union), data = wages)
+m2 <- panelr::wbm(lwage ~ lag(union) + wks | blk + t | (t | id), data = wages)
 
-  test_that("find_predictors", {
-    expect_identical(
-      find_predictors(m1),
-      list(
-        conditional = c("union", "wks"),
-        instruments = c("blk", "fem"),
-        interactions = c("blk", "union")
-      )
-    )
-    expect_identical(
-      find_predictors(m1, flatten = TRUE),
-      c("union", "wks", "blk", "fem")
+test_that("model_info", {
+  expect_true(model_info(m1)$is_linear)
+  expect_true(model_info(m2)$is_linear)
+})
+
+test_that("find_predictors", {
+  expect_identical(
+    find_predictors(m1),
+    list(
+      conditional = c("union", "wks"),
+      instruments = c("blk", "fem"),
+      interactions = c("blk", "union")
     )
-    expect_null(find_predictors(m1, effects = "random"))
+  )
+  expect_identical(
+    find_predictors(m1, flatten = TRUE),
+    c("union", "wks", "blk", "fem")
+  )
+  expect_null(find_predictors(m1, effects = "random"))
 
-    expect_identical(
-      find_predictors(m2),
-      list(
-        conditional = c("union", "wks"),
-        instruments = c("blk", "t")
-      )
+  expect_identical(
+    find_predictors(m2),
+    list(
+      conditional = c("union", "wks"),
+      instruments = c("blk", "t")
     )
-    expect_identical(find_predictors(m2, effects = "random"), list(random = "id"))
-  })
+  )
+  expect_identical(find_predictors(m2, effects = "random"), list(random = "id"))
+})
 
-  test_that("find_random", {
-    expect_null(find_random(m1))
-    expect_identical(find_random(m2), list(random = "id"))
-  })
+test_that("find_random", {
+  expect_null(find_random(m1))
+  expect_identical(find_random(m2), list(random = "id"))
+})
 
-  test_that("get_random", {
-    expect_warning(expect_null(get_random(m1)))
-    expect_equal(get_random(m2)[[1]], model.frame(m2)$id)
-  })
+test_that("get_random", {
+  expect_warning(expect_null(get_random(m1)))
+  expect_equal(get_random(m2)[[1]], model.frame(m2)$id)
+})
 
-  test_that("find_response", {
-    expect_identical(find_response(m1), "lwage")
-  })
+test_that("find_response", {
+  expect_identical(find_response(m1), "lwage")
+})
 
-  test_that("get_response", {
-    expect_equal(get_response(m1), model.frame(m1)$lwage)
-  })
+test_that("get_response", {
+  expect_equal(get_response(m1), model.frame(m1)$lwage)
+})
 
-  test_that("get_predictors", {
-    expect_equal(
-      colnames(get_predictors(m1)),
-      c("lag(union)", "wks", "blk", "fem")
-    )
-    expect_equal(
-      colnames(get_predictors(m2)),
-      c("lag(union)", "wks", "blk", "t")
-    )
-  })
+test_that("get_predictors", {
+  expect_equal(
+    colnames(get_predictors(m1)),
+    c("lag(union)", "wks", "blk", "fem")
+  )
+  expect_equal(
+    colnames(get_predictors(m2)),
+    c("lag(union)", "wks", "blk", "t")
+  )
+})
 
-  test_that("link_inverse", {
-    expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
-  })
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
+})
 
-  test_that("clean_parameters", {
-    cp <- clean_parameters(m1)
-    expect_equal(
-      cp$Cleaned_Parameter,
-      c(
-        "union", "wks", "(Intercept)", "imean(lag(union))", "imean(wks)",
-        "blk", "fem", "union:blk"
-      )
+test_that("clean_parameters", {
+  cp <- clean_parameters(m1)
+  expect_equal(
+    cp$Cleaned_Parameter,
+    c(
+      "union", "wks", "(Intercept)", "imean(lag(union))", "imean(wks)",
+      "blk", "fem", "union:blk"
     )
-    expect_equal(
-      cp$Component,
-      c(
-        "conditional", "conditional", "instruments", "instruments",
-        "instruments", "instruments", "instruments", "interactions"
-      )
+  )
+  expect_equal(
+    cp$Component,
+    c(
+      "conditional", "conditional", "instruments", "instruments",
+      "instruments", "instruments", "instruments", "interactions"
     )
-  })
+  )
+})
 
-  test_that("get_data", {
-    expect_equal(nrow(get_data(m1)), 3570)
-    expect_equal(
-      colnames(get_data(m1)),
-      c(
-        "lwage",
-        "id",
-        "t",
-        "lag(union)",
-        "wks",
-        "blk",
-        "fem",
-        "imean(lag(union))",
-        "imean(wks)",
-        "imean(lag(union):blk)",
-        "lag(union):blk"
-      )
+test_that("get_data", {
+  expect_equal(nrow(get_data(m1)), 3570)
+  expect_equal(
+    colnames(get_data(m1)),
+    c(
+      "lwage",
+      "id",
+      "t",
+      "lag(union)",
+      "wks",
+      "blk",
+      "fem",
+      "imean(lag(union))",
+      "imean(wks)",
+      "imean(lag(union):blk)",
+      "lag(union):blk"
     )
-    expect_equal(
-      colnames(get_data(m2)),
-      c(
-        "lwage",
-        "id",
-        "t",
-        "lag(union)",
-        "wks",
-        "blk",
-        "imean(lag(union))",
-        "imean(wks)"
-      )
+  )
+  expect_equal(
+    colnames(get_data(m2)),
+    c(
+      "lwage",
+      "id",
+      "t",
+      "lag(union)",
+      "wks",
+      "blk",
+      "imean(lag(union))",
+      "imean(wks)"
     )
-  })
+  )
+})
 
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 3)
-    expect_equal(
-      find_formula(m1),
-      list(
-        conditional = as.formula("lwage ~ lag(union) + wks"),
-        instruments = as.formula("~blk + fem"),
-        interactions = as.formula("~blk * lag(union)")
-      ),
-      ignore_attr = TRUE
-    )
+test_that("find_formula", {
+  expect_length(find_formula(m1), 3)
+  expect_equal(
+    find_formula(m1),
+    list(
+      conditional = as.formula("lwage ~ lag(union) + wks"),
+      instruments = as.formula("~blk + fem"),
+      interactions = as.formula("~blk * lag(union)")
+    ),
+    ignore_attr = TRUE
+  )
 
-    expect_equal(
-      find_formula(m2),
-      list(
-        conditional = as.formula("lwage ~ lag(union) + wks"),
-        instruments = as.formula("~blk + t"),
-        random = as.formula("~t | id")
-      ),
-      ignore_attr = TRUE
-    )
-  })
+  expect_equal(
+    find_formula(m2),
+    list(
+      conditional = as.formula("lwage ~ lag(union) + wks"),
+      instruments = as.formula("~blk + t"),
+      random = as.formula("~t | id")
+    ),
+    ignore_attr = TRUE
+  )
+})
 
-  test_that("find_variables", {
-    expect_equal(
-      find_variables(m1),
-      list(
-        response = "lwage",
-        conditional = c("union", "wks"),
-        instruments = c("blk", "fem"),
-        interactions = c("blk", "union")
-      )
-    )
-    expect_equal(
-      find_variables(m1, flatten = TRUE),
-      c("lwage", "union", "wks", "blk", "fem")
+test_that("find_variables", {
+  expect_equal(
+    find_variables(m1),
+    list(
+      response = "lwage",
+      conditional = c("union", "wks"),
+      instruments = c("blk", "fem"),
+      interactions = c("blk", "union")
     )
+  )
+  expect_equal(
+    find_variables(m1, flatten = TRUE),
+    c("lwage", "union", "wks", "blk", "fem")
+  )
 
-    expect_equal(
-      find_variables(m2),
-      list(
-        response = "lwage",
-        conditional = c("union", "wks"),
-        instruments = c("blk", "t"),
-        random = "id"
-      )
+  expect_equal(
+    find_variables(m2),
+    list(
+      response = "lwage",
+      conditional = c("union", "wks"),
+      instruments = c("blk", "t"),
+      random = "id"
     )
-    expect_equal(
-      find_variables(m2, flatten = TRUE),
-      c("lwage", "union", "wks", "blk", "t", "id")
-    )
-  })
+  )
+  expect_equal(
+    find_variables(m2, flatten = TRUE),
+    c("lwage", "union", "wks", "blk", "t", "id")
+  )
+})
 
-  test_that("n_obs", {
-    expect_equal(n_obs(m1), 3570)
-    expect_equal(n_obs(m2), 3570)
-  })
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 3570)
+  expect_equal(n_obs(m2), 3570)
+})
 
-  test_that("linkfun", {
-    expect_false(is.null(link_function(m1)))
-  })
+test_that("linkfun", {
+  expect_false(is.null(link_function(m1)))
+})
 
-  test_that("find_parameters", {
-    expect_equal(
-      find_parameters(m1),
-      list(
-        conditional = c("lag(union)", "wks"),
-        instruments = c("(Intercept)", "imean(lag(union))", "imean(wks)", "blk", "fem"),
-        random = "lag(union):blk"
-      )
+test_that("find_parameters", {
+  expect_equal(
+    find_parameters(m1),
+    list(
+      conditional = c("lag(union)", "wks"),
+      instruments = c("(Intercept)", "imean(lag(union))", "imean(wks)", "blk", "fem"),
+      random = "lag(union):blk"
     )
+  )
 
-    expect_equal(nrow(get_parameters(m1)), 8)
+  expect_equal(nrow(get_parameters(m1)), 8)
 
-    expect_equal(
-      find_parameters(m2),
-      list(
-        conditional = c("lag(union)", "wks"),
-        instruments = c("(Intercept)", "imean(lag(union))", "imean(wks)", "blk", "t")
-      )
+  expect_equal(
+    find_parameters(m2),
+    list(
+      conditional = c("lag(union)", "wks"),
+      instruments = c("(Intercept)", "imean(lag(union))", "imean(wks)", "blk", "t")
     )
-  })
+  )
+})
 
 
-  test_that("get_parameters", {
-    expect_equal(
-      get_parameters(m1),
-      data.frame(
-        Parameter = c(
-          "lag(union)",
-          "wks",
-          "(Intercept)",
-          "imean(lag(union))",
-          "imean(wks)",
-          "blk",
-          "fem",
-          "lag(union):blk"
-        ),
-        Estimate = c(
-          0.0582474262882615, -0.00163678667081885, 6.59813245629044,
-          -0.0279959204722801, 0.00438047648390025, -0.229414915661438,
-          -0.441756913071962, -0.127319623945541
-        ),
-        Component = c(
-          "within", "within", "between", "between",
-          "between", "between", "between", "interactions"
-        ),
-        stringsAsFactors = FALSE
+test_that("get_parameters", {
+  expect_equal(
+    get_parameters(m1),
+    data.frame(
+      Parameter = c(
+        "lag(union)",
+        "wks",
+        "(Intercept)",
+        "imean(lag(union))",
+        "imean(wks)",
+        "blk",
+        "fem",
+        "lag(union):blk"
       ),
-      tolerance = 1e-4
-    )
-  })
+      Estimate = c(
+        0.0582474262882615, -0.00163678667081885, 6.59813245629044,
+        -0.0279959204722801, 0.00438047648390025, -0.229414915661438,
+        -0.441756913071962, -0.127319623945541
+      ),
+      Component = c(
+        "within", "within", "between", "between",
+        "between", "between", "between", "interactions"
+      ),
+      stringsAsFactors = FALSE
+    ),
+    tolerance = 1e-4
+  )
+})
 
 
-  test_that("find_terms", {
-    expect_equal(
-      find_terms(m1),
-      list(
-        response = "lwage",
-        conditional = c("lag(union)", "wks"),
-        instruments = c("blk", "fem"),
-        interactions = c("blk", "lag(union)")
-      )
+test_that("find_terms", {
+  expect_equal(
+    find_terms(m1),
+    list(
+      response = "lwage",
+      conditional = c("lag(union)", "wks"),
+      instruments = c("blk", "fem"),
+      interactions = c("blk", "lag(union)")
     )
-    expect_equal(
-      find_terms(m2),
-      list(
-        response = "lwage",
-        conditional = c("lag(union)", "wks"),
-        instruments = c("blk", "t"),
-        random = c("t", "id")
-      )
+  )
+  expect_equal(
+    find_terms(m2),
+    list(
+      response = "lwage",
+      conditional = c("lag(union)", "wks"),
+      instruments = c("blk", "t"),
+      random = c("t", "id")
     )
-  })
-
-  test_that("is_multivariate", {
-    expect_false(is_multivariate(m1))
-  })
+  )
+})
 
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "t-statistic")
-    expect_identical(find_statistic(m2), "t-statistic")
-  })
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1))
+})
 
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "t-statistic")
+  expect_identical(find_statistic(m2), "t-statistic")
+})
 
-  if (TRUE) {
-    v <- get_variance(m1)
-    expect_equal(v$var.intercept, c(id = 0.125306895731005), tolerance = 1e-4)
-    expect_equal(v$var.fixed, 0.0273792999320531, tolerance = 1e-4)
-  }
-}
+test_that("get_variance", {
+  skip_on_cran()
+  v <- get_variance(m1)
+  expect_equal(v$var.intercept, c(id = 0.125306895731005), tolerance = 1e-4)
+  expect_equal(v$var.fixed, 0.0273792999320531, tolerance = 1e-4)
+})
diff --git a/tests/testthat/test-plm.R b/tests/testthat/test-plm.R
index 5266fadf7..cec095a96 100644
--- a/tests/testthat/test-plm.R
+++ b/tests/testthat/test-plm.R
@@ -1,137 +1,136 @@
-if (getRversion() > "3.5") {
-  if (skip_if_not_or_load_if_installed("plm")) {
-    data(Crime)
-    m1 <- suppressWarnings(plm(lcrmrte ~ lprbarr + factor(year) | . - lprbarr + lmix, data = Crime, model = "random"))
-
-    # data
-    set.seed(123)
-    data("Produc", package = "plm")
-
-    # model
-    m2 <- suppressWarnings(plm::plm(
-      formula = log(gsp) ~ log(pcap) + log(pc) + log(emp) + unemp,
-      data = Produc,
-      index = c("state", "year")
-    ))
-
-    test_that("model_info", {
-      expect_true(model_info(m1)$is_linear)
-    })
-
-    test_that("find_predictors", {
-      expect_identical(
-        find_predictors(m1),
-        list(
-          conditional = c("lprbarr", "year"),
-          instruments = c("lprbarr", "lmix")
-        )
+skip_if_not(getRversion() > "3.5")
+skip_if_not_installed("plm")
+
+data(Crime, package = "plm")
+m1 <- suppressWarnings(plm::plm(lcrmrte ~ lprbarr + factor(year) | . - lprbarr + lmix, data = Crime, model = "random"))
+
+# data
+set.seed(123)
+data("Produc", package = "plm")
+
+# model
+m2 <- suppressWarnings(plm::plm(
+  formula = log(gsp) ~ log(pcap) + log(pc) + log(emp) + unemp,
+  data = Produc,
+  index = c("state", "year")
+))
+
+test_that("model_info", {
+  expect_true(model_info(m1)$is_linear)
+})
+
+test_that("find_predictors", {
+  expect_identical(
+    find_predictors(m1),
+    list(
+      conditional = c("lprbarr", "year"),
+      instruments = c("lprbarr", "lmix")
+    )
+  )
+  expect_identical(
+    find_predictors(m1, flatten = TRUE),
+    c("lprbarr", "year", "lmix")
+  )
+  expect_null(find_predictors(m1, effects = "random"))
+})
+
+test_that("find_random", {
+  expect_null(find_random(m1))
+})
+
+test_that("get_random", {
+  expect_warning(get_random(m1))
+})
+
+test_that("find_response", {
+  expect_identical(find_response(m1), "lcrmrte")
+})
+
+test_that("get_response", {
+  expect_equal(get_response(m1), Crime$lcrmrte)
+})
+
+test_that("get_predictors", {
+  expect_equal(colnames(get_predictors(m1)), c("lprbarr", "year", "lmix"))
+})
+
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
+})
+
+test_that("get_data", {
+  expect_equal(nrow(get_data(m1)), 630)
+  expect_equal(
+    colnames(get_data(m1)),
+    c("lcrmrte", "lprbarr", "year", "lmix")
+  )
+
+  expect_equal(nrow(get_data(m2)), 816)
+  expect_equal(
+    colnames(get_data(m2)),
+    c("gsp", "pcap", "pc", "emp", "unemp", "state", "year")
+  )
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1), 2)
+  expect_equal(
+    find_formula(m1),
+    list(
+      conditional = as.formula("lcrmrte ~ lprbarr + factor(year)"),
+      instruments = as.formula("~-lprbarr + lmix")
+    ),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_variables", {
+  expect_equal(
+    find_variables(m1),
+    list(
+      response = "lcrmrte",
+      conditional = c("lprbarr", "year"),
+      instruments = c("lprbarr", "lmix")
+    )
+  )
+  expect_equal(
+    find_variables(m1, flatten = TRUE),
+    c("lcrmrte", "lprbarr", "year", "lmix")
+  )
+})
+
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 630)
+})
+
+test_that("linkfun", {
+  expect_false(is.null(link_function(m1)))
+})
+
+test_that("find_parameters", {
+  expect_equal(
+    find_parameters(m1),
+    list(
+      conditional = c(
+        "(Intercept)",
+        "lprbarr",
+        "factor(year)82",
+        "factor(year)83",
+        "factor(year)84",
+        "factor(year)85",
+        "factor(year)86",
+        "factor(year)87"
       )
-      expect_identical(
-        find_predictors(m1, flatten = TRUE),
-        c("lprbarr", "year", "lmix")
-      )
-      expect_null(find_predictors(m1, effects = "random"))
-    })
-
-    test_that("find_random", {
-      expect_null(find_random(m1))
-    })
-
-    test_that("get_random", {
-      expect_warning(get_random(m1))
-    })
-
-    test_that("find_response", {
-      expect_identical(find_response(m1), "lcrmrte")
-    })
-
-    test_that("get_response", {
-      expect_equal(get_response(m1), Crime$lcrmrte)
-    })
-
-    test_that("get_predictors", {
-      expect_equal(colnames(get_predictors(m1)), c("lprbarr", "year", "lmix"))
-    })
-
-    test_that("link_inverse", {
-      expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
-    })
-
-    test_that("get_data", {
-      expect_equal(nrow(get_data(m1)), 630)
-      expect_equal(
-        colnames(get_data(m1)),
-        c("lcrmrte", "lprbarr", "year", "lmix")
-      )
-
-      expect_equal(nrow(get_data(m2)), 816)
-      expect_equal(
-        colnames(get_data(m2)),
-        c("gsp", "pcap", "pc", "emp", "unemp", "state", "year")
-      )
-    })
-
-    test_that("find_formula", {
-      expect_length(find_formula(m1), 2)
-      expect_equal(
-        find_formula(m1),
-        list(
-          conditional = as.formula("lcrmrte ~ lprbarr + factor(year)"),
-          instruments = as.formula("~-lprbarr + lmix")
-        ),
-        ignore_attr = TRUE
-      )
-    })
-
-    test_that("find_variables", {
-      expect_equal(
-        find_variables(m1),
-        list(
-          response = "lcrmrte",
-          conditional = c("lprbarr", "year"),
-          instruments = c("lprbarr", "lmix")
-        )
-      )
-      expect_equal(
-        find_variables(m1, flatten = TRUE),
-        c("lcrmrte", "lprbarr", "year", "lmix")
-      )
-    })
-
-    test_that("n_obs", {
-      expect_equal(n_obs(m1), 630)
-    })
-
-    test_that("linkfun", {
-      expect_false(is.null(link_function(m1)))
-    })
-
-    test_that("find_parameters", {
-      expect_equal(
-        find_parameters(m1),
-        list(
-          conditional = c(
-            "(Intercept)",
-            "lprbarr",
-            "factor(year)82",
-            "factor(year)83",
-            "factor(year)84",
-            "factor(year)85",
-            "factor(year)86",
-            "factor(year)87"
-          )
-        )
-      )
-      expect_equal(nrow(get_parameters(m1)), 8)
-    })
-
-    test_that("is_multivariate", {
-      expect_false(is_multivariate(m1))
-    })
-
-    test_that("find_statistic", {
-      expect_identical(find_statistic(m1), "z-statistic")
-      expect_identical(find_statistic(m2), "t-statistic")
-    })
-  }
-}
+    )
+  )
+  expect_equal(nrow(get_parameters(m1)), 8)
+})
+
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1))
+})
+
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "z-statistic")
+  expect_identical(find_statistic(m2), "t-statistic")
+})
diff --git a/tests/testthat/test-polr.R b/tests/testthat/test-polr.R
index bfb9a397e..178b2daf7 100644
--- a/tests/testthat/test-polr.R
+++ b/tests/testthat/test-polr.R
@@ -1,109 +1,92 @@
-if (skip_if_not_or_load_if_installed("MASS")) {
-  data(housing, package = "MASS")
-
-  m1 <- polr(Sat ~ Infl + Type + Cont, data = housing, weights = Freq)
-
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_ordinal)
-    expect_false(model_info(m1)$is_multinomial)
-  })
-
-  test_that("find_predictors", {
-    expect_identical(find_predictors(m1), list(conditional = c("Infl", "Type", "Cont")))
-    expect_identical(
-      find_predictors(m1, flatten = TRUE),
-      c("Infl", "Type", "Cont")
-    )
-    expect_null(find_predictors(m1, effects = "random"))
-  })
-
-  test_that("find_response", {
-    expect_identical(find_response(m1), "Sat")
-  })
-
-  test_that("link_inverse", {
-    expect_equal(link_inverse(m1)(0.2), plogis(0.2), tolerance = 1e-5)
-  })
-
-  test_that("get_data", {
-    expect_equal(nrow(get_data(m1)), 72)
-    expect_equal(
-      colnames(get_data(m1)),
-      c("Sat", "Infl", "Type", "Cont", "Freq")
-    )
-  })
-
-  test_that("get_df", {
-    expect_equal(
-      get_df(m1, type = "residual"),
-      df.residual(m1),
-      ignore_attr = TRUE
-    )
-    expect_equal(
-      get_df(m1, type = "normal"),
-      Inf,
-      ignore_attr = TRUE
-    )
-    expect_equal(
-      get_df(m1, type = "wald"),
-      df.residual(m1), # model has t-statistic
-      ignore_attr = TRUE
-    )
-  })
-
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 1)
-    expect_equal(
-      find_formula(m1),
-      list(conditional = as.formula("Sat ~ Infl + Type + Cont")),
-      ignore_attr = TRUE
-    )
-  })
-
-  test_that("find_terms", {
-    expect_equal(find_terms(m1), list(
-      response = "Sat",
-      conditional = c("Infl", "Type", "Cont")
-    ))
-    expect_equal(
-      find_terms(m1, flatten = TRUE),
-      c("Sat", "Infl", "Type", "Cont")
-    )
-  })
-
-  test_that("n_obs", {
-    expect_equal(n_obs(m1), 1681)
-  })
-
-  test_that("linkfun", {
-    expect_false(is.null(link_function(m1)))
-  })
-
-
-  test_that("find_parameters", {
-    expect_equal(
-      find_parameters(m1),
-      list(
-        conditional =
-          c(
-            "Intercept: Low|Medium",
-            "Intercept: Medium|High",
-            "InflMedium",
-            "InflHigh",
-            "TypeApartment",
-            "TypeAtrium",
-            "TypeTerrace",
-            "ContHigh"
-          )
-      )
-    )
-  })
-
-  test_that("get_parameters", {
-    expect_equal(
-      get_parameters(m1),
-      data.frame(
-        Parameter = c(
+skip_if_not_installed("MASS")
+
+data(housing, package = "MASS")
+
+m1 <- MASS::polr(Sat ~ Infl + Type + Cont, data = housing, weights = Freq)
+
+test_that("model_info", {
+  expect_true(model_info(m1)$is_ordinal)
+  expect_false(model_info(m1)$is_multinomial)
+})
+
+test_that("find_predictors", {
+  expect_identical(find_predictors(m1), list(conditional = c("Infl", "Type", "Cont")))
+  expect_identical(
+    find_predictors(m1, flatten = TRUE),
+    c("Infl", "Type", "Cont")
+  )
+  expect_null(find_predictors(m1, effects = "random"))
+})
+
+test_that("find_response", {
+  expect_identical(find_response(m1), "Sat")
+})
+
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), plogis(0.2), tolerance = 1e-5)
+})
+
+test_that("get_data", {
+  expect_equal(nrow(get_data(m1)), 72)
+  expect_equal(
+    colnames(get_data(m1)),
+    c("Sat", "Infl", "Type", "Cont", "Freq")
+  )
+})
+
+test_that("get_df", {
+  expect_equal(
+    get_df(m1, type = "residual"),
+    df.residual(m1),
+    ignore_attr = TRUE
+  )
+  expect_equal(
+    get_df(m1, type = "normal"),
+    Inf,
+    ignore_attr = TRUE
+  )
+  expect_equal(
+    get_df(m1, type = "wald"),
+    df.residual(m1), # model has t-statistic
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1), 1)
+  expect_equal(
+    find_formula(m1),
+    list(conditional = as.formula("Sat ~ Infl + Type + Cont")),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_terms", {
+  expect_equal(find_terms(m1), list(
+    response = "Sat",
+    conditional = c("Infl", "Type", "Cont")
+  ))
+  expect_equal(
+    find_terms(m1, flatten = TRUE),
+    c("Sat", "Infl", "Type", "Cont")
+  )
+})
+
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 1681)
+})
+
+test_that("linkfun", {
+  expect_false(is.null(link_function(m1)))
+})
+
+
+test_that("find_parameters", {
+  expect_equal(
+    find_parameters(m1),
+    list(
+      conditional =
+        c(
           "Intercept: Low|Medium",
           "Intercept: Medium|High",
           "InflMedium",
@@ -112,50 +95,67 @@ if (skip_if_not_or_load_if_installed("MASS")) {
           "TypeAtrium",
           "TypeTerrace",
           "ContHigh"
-        ),
-        Estimate = c(
-          -0.4961353438375,
-          0.690708290379271,
-          0.566393738890106,
-          1.28881906381232,
-          -0.572350146429611,
-          -0.366186566153346,
-          -1.09101490767244,
-          0.360284149947385
-        ),
-        stringsAsFactors = FALSE,
-        row.names = NULL
-      )
+        )
+    )
+  )
+})
+
+test_that("get_parameters", {
+  expect_equal(
+    get_parameters(m1),
+    data.frame(
+      Parameter = c(
+        "Intercept: Low|Medium",
+        "Intercept: Medium|High",
+        "InflMedium",
+        "InflHigh",
+        "TypeApartment",
+        "TypeAtrium",
+        "TypeTerrace",
+        "ContHigh"
+      ),
+      Estimate = c(
+        -0.4961353438375,
+        0.690708290379271,
+        0.566393738890106,
+        1.28881906381232,
+        -0.572350146429611,
+        -0.366186566153346,
+        -1.09101490767244,
+        0.360284149947385
+      ),
+      stringsAsFactors = FALSE,
+      row.names = NULL
     )
-  })
-
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "t-statistic")
-  })
-
-  test_that("get_predicted", {
-    p1 <- get_predicted(m1, predict = "expectation")
-    p2 <- get_predicted(m1, predict = "classification")
-    p3 <- get_predicted(m1, predict = NULL, type = "probs")
-    p4 <- get_predicted(m1, predict = NULL, type = "class")
-    expect_s3_class(p1, "get_predicted")
-    expect_s3_class(p2, "get_predicted")
-    expect_s3_class(p3, "get_predicted")
-    expect_s3_class(p4, "get_predicted")
-    expect_equal(p1, p3)
-    expect_equal(p2, p4)
-    expect_true(inherits(p1, "data.frame"))
-    expect_true(inherits(p2, "factor"))
-    expect_true(inherits(p3, "data.frame"))
-    expect_true(inherits(p4, "factor"))
-    expect_true(all(c("Row", "Response", "Predicted") %in% colnames(p1)))
-    expect_true(all(c("Row", "Response", "Predicted") %in% colnames(p3)))
-
-    d <- get_datagrid(m1, at = "Type", verbose = FALSE)
-
-    p1 <- get_predicted(m1, predict = "expectation", data = d, verbose = FALSE)
-
-    expect_equal(colnames(p1), c("Row", "Type", "Response", "Predicted"))
-    expect_equal(dim(p1), c(12, 4))
-  })
-}
+  )
+})
+
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "t-statistic")
+})
+
+test_that("get_predicted", {
+  p1 <- get_predicted(m1, predict = "expectation")
+  p2 <- get_predicted(m1, predict = "classification")
+  p3 <- get_predicted(m1, predict = NULL, type = "probs")
+  p4 <- get_predicted(m1, predict = NULL, type = "class")
+  expect_s3_class(p1, "get_predicted")
+  expect_s3_class(p2, "get_predicted")
+  expect_s3_class(p3, "get_predicted")
+  expect_s3_class(p4, "get_predicted")
+  expect_equal(p1, p3)
+  expect_equal(p2, p4)
+  expect_true(inherits(p1, "data.frame"))
+  expect_true(inherits(p2, "factor"))
+  expect_true(inherits(p3, "data.frame"))
+  expect_true(inherits(p4, "factor"))
+  expect_true(all(c("Row", "Response", "Predicted") %in% colnames(p1)))
+  expect_true(all(c("Row", "Response", "Predicted") %in% colnames(p3)))
+
+  d <- get_datagrid(m1, at = "Type", verbose = FALSE)
+
+  p1 <- get_predicted(m1, predict = "expectation", data = d, verbose = FALSE)
+
+  expect_equal(colnames(p1), c("Row", "Type", "Response", "Predicted"))
+  expect_equal(dim(p1), c(12, 4))
+})
diff --git a/tests/testthat/test-proportion_response.R b/tests/testthat/test-proportion_response.R
index 5da87bc36..e916e1db3 100644
--- a/tests/testthat/test-proportion_response.R
+++ b/tests/testthat/test-proportion_response.R
@@ -1,28 +1,26 @@
-if (skip_if_not_or_load_if_installed("lme4")) {
-  data(mtcars)
+skip_if_not_installed("lme4")
 
-  m1 <- suppressMessages(suppressWarnings(glmer(
-    vs / cyl ~ disp + (1 | cyl),
-    data = mtcars,
-    family = binomial(link = "logit")
-  )))
+m1 <- suppressMessages(suppressWarnings(lme4::glmer(
+  vs / cyl ~ disp + (1 | cyl),
+  data = mtcars,
+  family = binomial(link = "logit")
+)))
 
-  m2 <- suppressMessages(suppressWarnings(glmer(
-    I(vs / cyl) ~ disp + (1 | cyl),
-    data = mtcars,
-    family = binomial(link = "logit")
-  )))
+m2 <- suppressMessages(suppressWarnings(lme4::glmer(
+  I(vs / cyl) ~ disp + (1 | cyl),
+  data = mtcars,
+  family = binomial(link = "logit")
+)))
 
-  test_that("get_response", {
-    expect_equal(head(get_response(m1, as_proportion = TRUE)), c(0, 0, 0.25, 0.16667, 0, 0.16667), tolerance = 1e-2)
-    expect_equal(head(get_response(m1, as_proportion = FALSE)), head(mtcars[, c("vs", "cyl")]), tolerance = 1e-2)
-    expect_equal(get_response(m2), mtcars[, c("vs", "cyl")])
-  })
+test_that("get_response", {
+  expect_equal(head(get_response(m1, as_proportion = TRUE)), c(0, 0, 0.25, 0.16667, 0, 0.16667), tolerance = 1e-2)
+  expect_equal(head(get_response(m1, as_proportion = FALSE)), head(mtcars[, c("vs", "cyl")]), tolerance = 1e-2)
+  expect_equal(get_response(m2), mtcars[, c("vs", "cyl")])
+})
 
-  test_that("find_response", {
-    expect_equal(find_response(m1), "vs/cyl")
-    expect_equal(find_response(m2), "I(vs/cyl)")
-    expect_equal(find_response(m1, combine = FALSE), c("vs", "cyl"))
-    expect_equal(find_response(m2, combine = FALSE), c("vs", "cyl"))
-  })
-}
+test_that("find_response", {
+  expect_equal(find_response(m1), "vs/cyl")
+  expect_equal(find_response(m2), "I(vs/cyl)")
+  expect_equal(find_response(m1, combine = FALSE), c("vs", "cyl"))
+  expect_equal(find_response(m2, combine = FALSE), c("vs", "cyl"))
+})
diff --git a/tests/testthat/test-psm.R b/tests/testthat/test-psm.R
index eb1301fcd..4c9234665 100644
--- a/tests/testthat/test-psm.R
+++ b/tests/testthat/test-psm.R
@@ -1,126 +1,118 @@
-if (skip_if_not_or_load_if_installed("rms")) {
-  n <- 400
-  set.seed(1)
-  age <- rnorm(n, 50, 12)
-  sex <- factor(sample(c("Female", "Male"), n, TRUE))
-  # Population hazard function:
-  h <- 0.02 * exp(0.06 * (age - 50) + 0.8 * (sex == "Female"))
-  d.time <- -log(runif(n)) / h
-  cens <- 15 * runif(n)
-  death <- ifelse(d.time <= cens, 1, 0)
-  d.time <- pmin(d.time, cens)
-
-  dat <<- data.frame(d.time, death, sex, age, stringsAsFactors = FALSE)
-
-  m1 <- psm(Surv(d.time, death) ~ sex * pol(age, 2),
-    dist = "lognormal",
-    data = dat
+skip_if_not_installed("rms")
+skip_if_not_installed("survival")
+
+Surv <- survival::Surv
+pol <- rms::pol
+
+n <- 400
+set.seed(1)
+age <- rnorm(n, 50, 12)
+sex <- factor(sample(c("Female", "Male"), n, TRUE))
+# Population hazard function:
+h <- 0.02 * exp(0.06 * (age - 50) + 0.8 * (sex == "Female"))
+d.time <- -log(runif(n)) / h
+cens <- 15 * runif(n)
+death <- ifelse(d.time <= cens, 1, 0)
+d.time <- pmin(d.time, cens)
+
+dat <<- data.frame(d.time, death, sex, age, stringsAsFactors = FALSE)
+
+m1 <- rms::psm(Surv(d.time, death) ~ sex * pol(age, 2),
+  dist = "lognormal",
+  data = dat
+)
+
+test_that("model_info", {
+  expect_false(model_info(m1)$is_binomial)
+  expect_false(model_info(m1)$is_logit)
+})
+
+test_that("find_predictors", {
+  expect_identical(find_predictors(m1), list(conditional = c("sex", "age")))
+  expect_identical(find_predictors(m1, flatten = TRUE), c("sex", "age"))
+  expect_null(find_predictors(m1, effects = "random"))
+})
+
+test_that("find_random", {
+  expect_null(find_random(m1))
+})
+
+test_that("get_random", {
+  expect_warning(get_random(m1))
+})
+
+test_that("find_response", {
+  expect_identical(find_response(m1), "Surv(d.time, death)")
+  expect_identical(find_response(m1, combine = FALSE), c("d.time", "death"))
+})
+
+test_that("get_response", {
+  expect_equal(get_response(m1), dat[, c("d.time", "death")])
+})
+
+test_that("get_predictors", {
+  expect_equal(colnames(get_predictors(m1)), c("sex", "age"))
+})
+
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), exp(0.2), tolerance = 1e-5)
+})
+
+test_that("get_data", {
+  expect_equal(nrow(get_data(m1)), 400)
+  expect_equal(colnames(get_data(m1)), c("d.time", "death", "sex", "age"))
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1), 1)
+  expect_equal(
+    find_formula(m1),
+    list(conditional = as.formula(
+      "Surv(d.time, death) ~ sex * pol(age, 2)"
+    )),
+    ignore_attr = TRUE
   )
-
-  test_that("model_info", {
-    expect_false(model_info(m1)$is_binomial)
-    expect_false(model_info(m1)$is_logit)
-  })
-
-  test_that("find_predictors", {
-    expect_identical(find_predictors(m1), list(conditional = c("sex", "age")))
-    expect_identical(find_predictors(m1, flatten = TRUE), c("sex", "age"))
-    expect_null(find_predictors(m1, effects = "random"))
-  })
-
-  test_that("find_random", {
-    expect_null(find_random(m1))
-  })
-
-  test_that("get_random", {
-    expect_warning(get_random(m1))
-  })
-
-  test_that("find_response", {
-    expect_identical(find_response(m1), "Surv(d.time, death)")
-    expect_identical(find_response(m1, combine = FALSE), c("d.time", "death"))
-  })
-
-  test_that("get_response", {
-    expect_equal(get_response(m1), dat[, c("d.time", "death")])
-  })
-
-  test_that("get_predictors", {
-    expect_equal(colnames(get_predictors(m1)), c("sex", "age"))
-  })
-
-  test_that("link_inverse", {
-    expect_equal(link_inverse(m1)(0.2), exp(0.2), tolerance = 1e-5)
-  })
-
-  test_that("get_data", {
-    expect_equal(nrow(get_data(m1)), 400)
-    expect_equal(colnames(get_data(m1)), c("d.time", "death", "sex", "age"))
-  })
-
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 1)
-    expect_equal(
-      find_formula(m1),
-      list(conditional = as.formula(
-        "Surv(d.time, death) ~ sex * pol(age, 2)"
-      )),
-      ignore_attr = TRUE
-    )
-  })
-
-  test_that("find_terms", {
-    expect_length(find_terms(m1), 2)
-    expect_equal(
-      find_terms(m1),
-      list(
-        response = "Surv(d.time, death)",
-        conditional = c("sex", "pol(age, 2)")
-      )
-    )
-  })
-
-  test_that("find_variables", {
-    expect_equal(find_variables(m1), list(
-      response = c("d.time", "death"),
-      conditional = c("sex", "age")
-    ))
-    expect_equal(
-      find_variables(m1, flatten = TRUE),
-      c("d.time", "death", "sex", "age")
+})
+
+test_that("find_terms", {
+  expect_length(find_terms(m1), 2)
+  expect_equal(
+    find_terms(m1),
+    list(
+      response = "Surv(d.time, death)",
+      conditional = c("sex", "pol(age, 2)")
     )
-  })
-
-  test_that("n_obs", {
-    expect_equal(n_obs(m1), 400)
-  })
-
-  test_that("linkfun", {
-    expect_false(is.null(link_function(m1)))
-  })
-
-  test_that("linkinverse", {
-    expect_false(is.null(link_inverse(m1)))
-  })
-
-  test_that("find_parameters", {
-    expect_equal(
-      find_parameters(m1),
-      list(
-        conditional = c(
-          "(Intercept)",
-          "sex=Male",
-          "age",
-          "age^2",
-          "sex=Male * age",
-          "sex=Male * age^2"
-        )
-      )
-    )
-    expect_equal(nrow(get_parameters(m1)), 6)
-    expect_equal(
-      get_parameters(m1)$Parameter,
-      c(
+  )
+})
+
+test_that("find_variables", {
+  expect_equal(find_variables(m1), list(
+    response = c("d.time", "death"),
+    conditional = c("sex", "age")
+  ))
+  expect_equal(
+    find_variables(m1, flatten = TRUE),
+    c("d.time", "death", "sex", "age")
+  )
+})
+
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 400)
+})
+
+test_that("linkfun", {
+  expect_false(is.null(link_function(m1)))
+})
+
+test_that("linkinverse", {
+  expect_false(is.null(link_inverse(m1)))
+})
+
+test_that("find_parameters", {
+  expect_equal(
+    find_parameters(m1),
+    list(
+      conditional = c(
         "(Intercept)",
         "sex=Male",
         "age",
@@ -129,17 +121,29 @@ if (skip_if_not_or_load_if_installed("rms")) {
         "sex=Male * age^2"
       )
     )
-  })
+  )
+  expect_equal(nrow(get_parameters(m1)), 6)
+  expect_equal(
+    get_parameters(m1)$Parameter,
+    c(
+      "(Intercept)",
+      "sex=Male",
+      "age",
+      "age^2",
+      "sex=Male * age",
+      "sex=Male * age^2"
+    )
+  )
+})
 
-  test_that("is_multivariate", {
-    expect_false(is_multivariate(m1))
-  })
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1))
+})
 
-  test_that("find_algorithm", {
-    expect_warning(find_algorithm(m1))
-  })
+test_that("find_algorithm", {
+  expect_warning(find_algorithm(m1))
+})
 
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "z-statistic")
-  })
-}
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "z-statistic")
+})
diff --git a/tests/testthat/test-r3_4.R b/tests/testthat/test-r3_4.R
index 50af4351d..fbe6b5a2f 100644
--- a/tests/testthat/test-r3_4.R
+++ b/tests/testthat/test-r3_4.R
@@ -1,7 +1,4 @@
-if (skip_if_not_or_load_if_installed("insight")) {
-  data(mtcars)
+test_that("find_random", {
   m <- glm(am ~ mpg, mtcars, family = binomial())
-  test_that("find_random", {
-    expect_null(find_random(m))
-  })
-}
+  expect_null(find_random(m))
+})
diff --git a/tests/testthat/test-response_data2.R b/tests/testthat/test-response_data2.R
index 6e7034ba7..5d8b8b218 100644
--- a/tests/testthat/test-response_data2.R
+++ b/tests/testthat/test-response_data2.R
@@ -1,116 +1,114 @@
-if (suppressWarnings(
-  skip_if_not_or_load_if_installed("lme4")
-)) {
-  data(cbpp)
-  cbpp$trials <<- cbpp$size - cbpp$incidence
+skip_if_not_installed("lme4")
 
-  m1 <- glmer(
-    cbind(incidence, trials) ~ period + (1 | herd),
-    data = cbpp,
-    family = binomial
+data(cbpp, package = "lme4")
+cbpp$trials <<- cbpp$size - cbpp$incidence
+
+m1 <- lme4::glmer(
+  cbind(incidence, trials) ~ period + (1 | herd),
+  data = cbpp,
+  family = binomial
+)
+m2 <- lme4::glmer(
+  cbind(incidence, size - incidence) ~ period + (1 | herd),
+  data = cbpp,
+  family = binomial
+)
+m3 <- glm(
+  cbind(incidence, trials) ~ period,
+  data = cbpp,
+  family = binomial
+)
+m4 <- glm(
+  cbind(incidence, size - incidence) ~ period,
+  data = cbpp,
+  family = binomial
+)
+m5 <- lme4::glmer(
+  cbind(incidence, size - incidence) ~ (1 | herd),
+  data = cbpp,
+  family = binomial
+)
+
+test_that("find_response", {
+  expect_equal(
+    find_response(m1, combine = TRUE),
+    "cbind(incidence, trials)"
+  )
+  expect_equal(
+    find_response(m2, combine = TRUE),
+    "cbind(incidence, size - incidence)"
+  )
+  expect_equal(
+    find_response(m3, combine = TRUE),
+    "cbind(incidence, trials)"
   )
-  m2 <- glmer(
-    cbind(incidence, size - incidence) ~ period + (1 | herd),
-    data = cbpp,
-    family = binomial
+  expect_equal(
+    find_response(m4, combine = TRUE),
+    "cbind(incidence, size - incidence)"
   )
-  m3 <- glm(
-    cbind(incidence, trials) ~ period,
-    data = cbpp,
-    family = binomial
+  expect_equal(
+    find_response(m5, combine = TRUE),
+    "cbind(incidence, size - incidence)"
   )
-  m4 <- glm(
-    cbind(incidence, size - incidence) ~ period,
-    data = cbpp,
-    family = binomial
+  expect_equal(
+    find_response(m1, combine = FALSE),
+    c("incidence", "trials")
   )
-  m5 <- glmer(
-    cbind(incidence, size - incidence) ~ (1 | herd),
-    data = cbpp,
-    family = binomial
+  expect_equal(find_response(m2, combine = FALSE), c("incidence", "size"))
+  expect_equal(
+    find_response(m3, combine = FALSE),
+    c("incidence", "trials")
   )
+  expect_equal(find_response(m4, combine = FALSE), c("incidence", "size"))
+  expect_equal(find_response(m5, combine = FALSE), c("incidence", "size"))
+})
 
-  test_that("find_response", {
-    expect_equal(
-      find_response(m1, combine = TRUE),
-      "cbind(incidence, trials)"
-    )
-    expect_equal(
-      find_response(m2, combine = TRUE),
-      "cbind(incidence, size - incidence)"
-    )
-    expect_equal(
-      find_response(m3, combine = TRUE),
-      "cbind(incidence, trials)"
-    )
-    expect_equal(
-      find_response(m4, combine = TRUE),
-      "cbind(incidence, size - incidence)"
-    )
-    expect_equal(
-      find_response(m5, combine = TRUE),
-      "cbind(incidence, size - incidence)"
-    )
-    expect_equal(
-      find_response(m1, combine = FALSE),
-      c("incidence", "trials")
-    )
-    expect_equal(find_response(m2, combine = FALSE), c("incidence", "size"))
-    expect_equal(
-      find_response(m3, combine = FALSE),
-      c("incidence", "trials")
-    )
-    expect_equal(find_response(m4, combine = FALSE), c("incidence", "size"))
-    expect_equal(find_response(m5, combine = FALSE), c("incidence", "size"))
-  })
+test_that("get_response", {
+  expect_equal(colnames(get_response(m1)), c("incidence", "trials"))
+  expect_equal(colnames(get_response(m2)), c("incidence", "size"))
+  expect_equal(colnames(get_response(m3)), c("incidence", "trials"))
+  expect_equal(colnames(get_response(m4)), c("incidence", "size"))
+  expect_equal(colnames(get_response(m5)), c("incidence", "size"))
+})
 
-  test_that("get_response", {
-    expect_equal(colnames(get_response(m1)), c("incidence", "trials"))
-    expect_equal(colnames(get_response(m2)), c("incidence", "size"))
-    expect_equal(colnames(get_response(m3)), c("incidence", "trials"))
-    expect_equal(colnames(get_response(m4)), c("incidence", "size"))
-    expect_equal(colnames(get_response(m5)), c("incidence", "size"))
-  })
+test_that("get_data", {
+  expect_equal(
+    colnames(get_data(m1)),
+    c("incidence", "trials", "period", "herd")
+  )
+  expect_equal(
+    colnames(get_data(m2)),
+    c("incidence", "size", "period", "herd")
+  )
+  get_data(m3)
+  get_data(m4)
+  expect_equal(
+    colnames(get_data(m5)),
+    c("incidence", "size", "herd")
+  )
+})
 
-  test_that("get_data", {
-    expect_equal(
-      colnames(get_data(m1)),
-      c("incidence", "trials", "period", "herd")
-    )
-    expect_equal(
-      colnames(get_data(m2)),
-      c("incidence", "size", "period", "herd")
-    )
-    get_data(m3)
-    get_data(m4)
-    expect_equal(
-      colnames(get_data(m5)),
-      c("incidence", "size", "herd")
-    )
-  })
+set.seed(123)
 
-  set.seed(123)
-  data(mtcars)
-  m6 <-
-    stats::aov(
-      formula = mpg ~ wt + qsec + Error(disp / am),
-      data = mtcars
-    )
+m6 <-
+  stats::aov(
+    formula = mpg ~ wt + qsec + Error(disp / am),
+    data = mtcars
+  )
 
-  # TO DO
-  # test_that("mod-info", {
-  #   get_data(m6)
-  #   find_response(m6)
-  #   get_response(m6)
-  #   find_formula(m6)
-  # })
+# TO DO
+# test_that("mod-info", {
+#   get_data(m6)
+#   find_response(m6)
+#   get_response(m6)
+#   find_formula(m6)
+# })
 
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "z-statistic")
-    expect_identical(find_statistic(m2), "z-statistic")
-    expect_identical(find_statistic(m3), "z-statistic")
-    expect_identical(find_statistic(m4), "z-statistic")
-    expect_identical(find_statistic(m5), "z-statistic")
-    expect_identical(find_statistic(m6), "F-statistic")
-  })
-}
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "z-statistic")
+  expect_identical(find_statistic(m2), "z-statistic")
+  expect_identical(find_statistic(m3), "z-statistic")
+  expect_identical(find_statistic(m4), "z-statistic")
+  expect_identical(find_statistic(m5), "z-statistic")
+  expect_identical(find_statistic(m6), "F-statistic")
+})
diff --git a/tests/testthat/test-rlm.R b/tests/testthat/test-rlm.R
index 53b7f32c4..34c0c7d91 100644
--- a/tests/testthat/test-rlm.R
+++ b/tests/testthat/test-rlm.R
@@ -1,25 +1,23 @@
-if (skip_if_not_or_load_if_installed("MASS")) {
-  test_that("model.matrix.rlm accepts `data` argument", {
-    mod <- MASS::rlm(mpg ~ hp + factor(cyl), mtcars)
-    mm <- get_modelmatrix(mod)
-    expect_true(is.matrix(mm))
-    expect_equal(dim(mm), c(32, 4))
-    mm <- get_modelmatrix(mod, data = head(mtcars))
-    expect_true(is.matrix(mm))
-    expect_equal(dim(mm), c(6, 4))
-  })
+skip_if_not_installed("MASS")
 
-  if (TRUE) {
-    test_that("predict.rlm", {
-      mod <- MASS::rlm(mpg ~ hp + factor(cyl), mtcars)
-      a <- get_predicted(mod)
-      b <- get_predicted(mod, predict = NULL, type = "response", verbose = FALSE)
-      expect_s3_class(a, "get_predicted")
-      expect_s3_class(b, "get_predicted")
-      expect_equal(a, b, ignore_attr = TRUE)
-      expect_equal(as.vector(a), as.vector(b))
-      expect_error(get_predicted(mod, predict = "link"))
-      expect_error(get_predicted(mod, predict = NULL, type = "link"))
-    })
-  }
-}
+test_that("model.matrix.rlm accepts `data` argument", {
+  mod <- MASS::rlm(mpg ~ hp + factor(cyl), mtcars)
+  mm <- get_modelmatrix(mod)
+  expect_true(is.matrix(mm))
+  expect_equal(dim(mm), c(32, 4))
+  mm <- get_modelmatrix(mod, data = head(mtcars))
+  expect_true(is.matrix(mm))
+  expect_equal(dim(mm), c(6, 4))
+})
+
+test_that("predict.rlm", {
+  mod <- MASS::rlm(mpg ~ hp + factor(cyl), mtcars)
+  a <- get_predicted(mod)
+  b <- get_predicted(mod, predict = NULL, type = "response", verbose = FALSE)
+  expect_s3_class(a, "get_predicted")
+  expect_s3_class(b, "get_predicted")
+  expect_equal(a, b, ignore_attr = TRUE)
+  expect_equal(as.vector(a), as.vector(b))
+  expect_error(get_predicted(mod, predict = "link"))
+  expect_error(get_predicted(mod, predict = NULL, type = "link"))
+})
diff --git a/tests/testthat/test-rlmer.R b/tests/testthat/test-rlmer.R
index bf696b6f1..8651dd7d1 100644
--- a/tests/testthat/test-rlmer.R
+++ b/tests/testthat/test-rlmer.R
@@ -1,302 +1,307 @@
-if (skip_if_not_or_load_if_installed("robustlmm") && utils::packageVersion("robustlmm") >= "3.0.1" &&
-  skip_if_not_or_load_if_installed("lme4") && getRversion() >= "4.1.0") {
-  data(sleepstudy)
+skip_if_not_installed("robustlmm", minimum_version = "3.0.1")
+skip_if_not_installed("lme4")
+skip_if_not(getRversion() >= "4.1.0")
 
-  set.seed(123)
-  sleepstudy$mygrp <- sample(1:5, size = 180, replace = TRUE)
-  sleepstudy$mysubgrp <- NA
-  for (i in 1:5) {
-    filter_group <- sleepstudy$mygrp == i
-    sleepstudy$mysubgrp[filter_group] <-
-      sample(1:30,
-        size = sum(filter_group),
-        replace = TRUE
-      )
-  }
+data(sleepstudy, package = "lme4")
+
+set.seed(123)
+sleepstudy$mygrp <- sample(1:5, size = 180, replace = TRUE)
+sleepstudy$mysubgrp <- NA
+for (i in 1:5) {
+  filter_group <- sleepstudy$mygrp == i
+  sleepstudy$mysubgrp[filter_group] <-
+    sample(1:30,
+      size = sum(filter_group),
+      replace = TRUE
+    )
+}
 
-  dat <<- sleepstudy
+dat <<- sleepstudy
 
-  m1 <- rlmer(
+library(lme4)
+
+suppressMessages({
+  m1 <- robustlmm::rlmer(
     Reaction ~ Days + (Days | Subject),
     data = dat,
-    rho.sigma.e = psi2propII(smoothPsi, k = 2.28),
-    rho.sigma.b = chgDefaults(smoothPsi, k = 5.11, s = 10)
+    rho.sigma.e = robustlmm::psi2propII(robustlmm::smoothPsi, k = 2.28),
+    rho.sigma.b = robustlmm::chgDefaults(robustlmm::smoothPsi, k = 5.11, s = 10)
   )
 
-  m2 <- rlmer(
+  m2 <- robustlmm::rlmer(
     Reaction ~ Days + (1 | mygrp / mysubgrp) + (1 | Subject),
     data = dat,
-    rho.sigma.e = psi2propII(smoothPsi, k = 2.28),
-    rho.sigma.b = chgDefaults(smoothPsi, k = 5.11, s = 10)
+    rho.sigma.e = robustlmm::psi2propII(robustlmm::smoothPsi, k = 2.28),
+    rho.sigma.b = robustlmm::chgDefaults(robustlmm::smoothPsi, k = 5.11, s = 10)
   )
+})
 
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_linear)
-    expect_true(model_info(m2)$is_linear)
-  })
-
-  test_that("find_predictors", {
-    expect_identical(
-      find_predictors(m1, effects = "all"),
-      list(conditional = "Days", random = "Subject")
-    )
-    expect_identical(
-      find_predictors(m1, effects = "all", flatten = TRUE),
-      c("Days", "Subject")
-    )
-    expect_identical(
-      find_predictors(m1, effects = "fixed"),
-      list(conditional = "Days")
-    )
-    expect_identical(
-      find_predictors(m1, effects = "fixed", flatten = TRUE),
-      "Days"
-    )
-    expect_identical(
-      find_predictors(m1, effects = "random"),
-      list(random = "Subject")
-    )
-    expect_identical(
-      find_predictors(m1, effects = "random", flatten = TRUE),
-      "Subject"
-    )
-    expect_identical(
-      find_predictors(m2, effects = "all"),
-      list(
-        conditional = "Days",
-        random = c("mysubgrp", "mygrp", "Subject")
-      )
-    )
-    expect_identical(
-      find_predictors(m2, effects = "all", flatten = TRUE),
-      c("Days", "mysubgrp", "mygrp", "Subject")
-    )
-    expect_identical(
-      find_predictors(m2, effects = "fixed"),
-      list(conditional = "Days")
-    )
-    expect_identical(find_predictors(m2, effects = "random"), list(random = c("mysubgrp", "mygrp", "Subject")))
-    expect_null(find_predictors(m2, effects = "all", component = "zi"))
-    expect_null(find_predictors(m2, effects = "fixed", component = "zi"))
-    expect_null(find_predictors(m2, effects = "random", component = "zi"))
-  })
+test_that("model_info", {
+  expect_true(model_info(m1)$is_linear)
+  expect_true(model_info(m2)$is_linear)
+})
 
-  test_that("find_random", {
-    expect_identical(find_random(m1), list(random = "Subject"))
-    expect_identical(find_random(m1, flatten = TRUE), "Subject")
-    expect_identical(find_random(m2), list(random = c(
-      "mysubgrp:mygrp", "mygrp", "Subject"
-    )))
-    expect_identical(find_random(m2, split_nested = TRUE), list(random = c("mysubgrp", "mygrp", "Subject")))
-    expect_identical(
-      find_random(m2, flatten = TRUE),
-      c("mysubgrp:mygrp", "mygrp", "Subject")
-    )
-    expect_identical(
-      find_random(m2, split_nested = TRUE, flatten = TRUE),
-      c("mysubgrp", "mygrp", "Subject")
+test_that("find_predictors", {
+  expect_identical(
+    find_predictors(m1, effects = "all"),
+    list(conditional = "Days", random = "Subject")
+  )
+  expect_identical(
+    find_predictors(m1, effects = "all", flatten = TRUE),
+    c("Days", "Subject")
+  )
+  expect_identical(
+    find_predictors(m1, effects = "fixed"),
+    list(conditional = "Days")
+  )
+  expect_identical(
+    find_predictors(m1, effects = "fixed", flatten = TRUE),
+    "Days"
+  )
+  expect_identical(
+    find_predictors(m1, effects = "random"),
+    list(random = "Subject")
+  )
+  expect_identical(
+    find_predictors(m1, effects = "random", flatten = TRUE),
+    "Subject"
+  )
+  expect_identical(
+    find_predictors(m2, effects = "all"),
+    list(
+      conditional = "Days",
+      random = c("mysubgrp", "mygrp", "Subject")
     )
-  })
+  )
+  expect_identical(
+    find_predictors(m2, effects = "all", flatten = TRUE),
+    c("Days", "mysubgrp", "mygrp", "Subject")
+  )
+  expect_identical(
+    find_predictors(m2, effects = "fixed"),
+    list(conditional = "Days")
+  )
+  expect_identical(find_predictors(m2, effects = "random"), list(random = c("mysubgrp", "mygrp", "Subject")))
+  expect_null(find_predictors(m2, effects = "all", component = "zi"))
+  expect_null(find_predictors(m2, effects = "fixed", component = "zi"))
+  expect_null(find_predictors(m2, effects = "random", component = "zi"))
+})
 
-  test_that("find_response", {
-    expect_identical(find_response(m1), "Reaction")
-    expect_identical(find_response(m2), "Reaction")
-  })
+test_that("find_random", {
+  expect_identical(find_random(m1), list(random = "Subject"))
+  expect_identical(find_random(m1, flatten = TRUE), "Subject")
+  expect_identical(find_random(m2), list(random = c(
+    "mysubgrp:mygrp", "mygrp", "Subject"
+  )))
+  expect_identical(find_random(m2, split_nested = TRUE), list(random = c("mysubgrp", "mygrp", "Subject")))
+  expect_identical(
+    find_random(m2, flatten = TRUE),
+    c("mysubgrp:mygrp", "mygrp", "Subject")
+  )
+  expect_identical(
+    find_random(m2, split_nested = TRUE, flatten = TRUE),
+    c("mysubgrp", "mygrp", "Subject")
+  )
+})
 
-  test_that("get_response", {
-    expect_identical(get_response(m1), sleepstudy$Reaction)
-  })
+test_that("find_response", {
+  expect_identical(find_response(m1), "Reaction")
+  expect_identical(find_response(m2), "Reaction")
+})
 
-  test_that("link_inverse", {
-    expect_identical(link_inverse(m1)(0.2), 0.2)
-    expect_identical(link_inverse(m2)(0.2), 0.2)
-  })
+test_that("get_response", {
+  expect_identical(get_response(m1), sleepstudy$Reaction)
+})
 
-  test_that("get_data", {
-    expect_identical(colnames(get_data(m1)), c("Reaction", "Days", "Subject"))
-    expect_identical(colnames(get_data(m1, effects = "all")), c("Reaction", "Days", "Subject"))
-    expect_identical(colnames(get_data(m1, effects = "random")), "Subject")
-    expect_identical(
-      colnames(get_data(m2)),
-      c("Reaction", "Days", "mysubgrp", "mygrp", "Subject")
-    )
-    expect_identical(
-      colnames(get_data(m2, effects = "all")),
-      c("Reaction", "Days", "mysubgrp", "mygrp", "Subject")
-    )
-    expect_identical(colnames(get_data(m2, effects = "random")), c("mysubgrp", "mygrp", "Subject"))
-  })
+test_that("link_inverse", {
+  expect_identical(link_inverse(m1)(0.2), 0.2)
+  expect_identical(link_inverse(m2)(0.2), 0.2)
+})
 
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 2)
-    expect_length(find_formula(m2), 2)
-    expect_equal(
-      find_formula(m1, component = "conditional"),
-      list(
-        conditional = as.formula("Reaction ~ Days"),
-        random = as.formula("~Days | Subject")
-      ),
-      ignore_attr = TRUE
-    )
-    expect_equal(
-      find_formula(m2, component = "conditional"),
-      list(
-        conditional = as.formula("Reaction ~ Days"),
-        random = list(
-          as.formula("~1 | mysubgrp:mygrp"),
-          as.formula("~1 | mygrp"),
-          as.formula("~1 | Subject")
-        )
-      ),
-      ignore_attr = TRUE
-    )
-  })
+test_that("get_data", {
+  expect_identical(colnames(get_data(m1)), c("Reaction", "Days", "Subject"))
+  expect_identical(colnames(get_data(m1, effects = "all")), c("Reaction", "Days", "Subject"))
+  expect_identical(colnames(get_data(m1, effects = "random")), "Subject")
+  expect_identical(
+    colnames(get_data(m2)),
+    c("Reaction", "Days", "mysubgrp", "mygrp", "Subject")
+  )
+  expect_identical(
+    colnames(get_data(m2, effects = "all")),
+    c("Reaction", "Days", "mysubgrp", "mygrp", "Subject")
+  )
+  expect_identical(colnames(get_data(m2, effects = "random")), c("mysubgrp", "mygrp", "Subject"))
+})
 
-  test_that("find_terms", {
-    expect_identical(
-      find_terms(m1),
-      list(
-        response = "Reaction",
-        conditional = "Days",
-        random = c("Days", "Subject")
-      )
-    )
-    expect_identical(
-      find_terms(m1, flatten = TRUE),
-      c("Reaction", "Days", "Subject")
-    )
-    expect_identical(
-      find_terms(m2),
-      list(
-        response = "Reaction",
-        conditional = "Days",
-        random = c("mysubgrp", "mygrp", "Subject")
+test_that("find_formula", {
+  expect_length(find_formula(m1), 2)
+  expect_length(find_formula(m2), 2)
+  expect_equal(
+    find_formula(m1, component = "conditional"),
+    list(
+      conditional = as.formula("Reaction ~ Days"),
+      random = as.formula("~Days | Subject")
+    ),
+    ignore_attr = TRUE
+  )
+  expect_equal(
+    find_formula(m2, component = "conditional"),
+    list(
+      conditional = as.formula("Reaction ~ Days"),
+      random = list(
+        as.formula("~1 | mysubgrp:mygrp"),
+        as.formula("~1 | mygrp"),
+        as.formula("~1 | Subject")
       )
+    ),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_terms", {
+  expect_identical(
+    find_terms(m1),
+    list(
+      response = "Reaction",
+      conditional = "Days",
+      random = c("Days", "Subject")
     )
-    expect_identical(
-      find_terms(m2, flatten = TRUE),
-      c("Reaction", "Days", "mysubgrp", "mygrp", "Subject")
+  )
+  expect_identical(
+    find_terms(m1, flatten = TRUE),
+    c("Reaction", "Days", "Subject")
+  )
+  expect_identical(
+    find_terms(m2),
+    list(
+      response = "Reaction",
+      conditional = "Days",
+      random = c("mysubgrp", "mygrp", "Subject")
     )
-  })
+  )
+  expect_identical(
+    find_terms(m2, flatten = TRUE),
+    c("Reaction", "Days", "mysubgrp", "mygrp", "Subject")
+  )
+})
 
-  test_that("find_variables", {
-    expect_identical(
-      find_variables(m1),
-      list(
-        response = "Reaction",
-        conditional = "Days",
-        random = "Subject"
-      )
+test_that("find_variables", {
+  expect_identical(
+    find_variables(m1),
+    list(
+      response = "Reaction",
+      conditional = "Days",
+      random = "Subject"
     )
-  })
+  )
+})
 
-  test_that("get_response", {
-    expect_identical(get_response(m1), sleepstudy$Reaction)
-  })
+test_that("get_response", {
+  expect_identical(get_response(m1), sleepstudy$Reaction)
+})
 
-  test_that("get_predictors", {
-    expect_identical(colnames(get_predictors(m1)), "Days")
-    expect_identical(colnames(get_predictors(m2)), "Days")
-  })
+test_that("get_predictors", {
+  expect_identical(colnames(get_predictors(m1)), "Days")
+  expect_identical(colnames(get_predictors(m2)), "Days")
+})
 
-  test_that("get_random", {
-    expect_identical(colnames(get_random(m1)), "Subject")
-    expect_identical(
-      colnames(get_random(m2)),
-      c("mysubgrp", "mygrp", "Subject")
-    )
-  })
+test_that("get_random", {
+  expect_identical(colnames(get_random(m1)), "Subject")
+  expect_identical(
+    colnames(get_random(m2)),
+    c("mysubgrp", "mygrp", "Subject")
+  )
+})
 
-  test_that("clean_names", {
-    expect_identical(clean_names(m1), c("Reaction", "Days", "Subject"))
-    expect_identical(
-      clean_names(m2),
-      c("Reaction", "Days", "mysubgrp", "mygrp", "Subject")
-    )
-  })
+test_that("clean_names", {
+  expect_identical(clean_names(m1), c("Reaction", "Days", "Subject"))
+  expect_identical(
+    clean_names(m2),
+    c("Reaction", "Days", "mysubgrp", "mygrp", "Subject")
+  )
+})
 
-  test_that("linkfun", {
-    expect_false(is.null(link_function(m1)))
-    expect_false(is.null(link_function(m2)))
-  })
+test_that("linkfun", {
+  expect_false(is.null(link_function(m1)))
+  expect_false(is.null(link_function(m2)))
+})
 
-  test_that("find_parameters", {
-    expect_identical(
-      find_parameters(m1),
-      list(
-        conditional = c("(Intercept)", "Days"),
-        random = list(Subject = c("(Intercept)", "Days"))
-      )
+test_that("find_parameters", {
+  expect_identical(
+    find_parameters(m1),
+    list(
+      conditional = c("(Intercept)", "Days"),
+      random = list(Subject = c("(Intercept)", "Days"))
     )
-    expect_identical(nrow(get_parameters(m1)), 2L)
-    expect_identical(get_parameters(m1)$Parameter, c("(Intercept)", "Days"))
+  )
+  expect_identical(nrow(get_parameters(m1)), 2L)
+  expect_identical(get_parameters(m1)$Parameter, c("(Intercept)", "Days"))
 
-    expect_identical(
-      find_parameters(m2),
-      list(
-        conditional = c("(Intercept)", "Days"),
-        random = list(
-          `mysubgrp:mygrp` = "(Intercept)",
-          Subject = "(Intercept)",
-          mygrp = "(Intercept)"
-        )
+  expect_identical(
+    find_parameters(m2),
+    list(
+      conditional = c("(Intercept)", "Days"),
+      random = list(
+        `mysubgrp:mygrp` = "(Intercept)",
+        Subject = "(Intercept)",
+        mygrp = "(Intercept)"
       )
     )
+  )
 
-    expect_identical(nrow(get_parameters(m2)), 2L)
-    expect_identical(get_parameters(m2)$Parameter, c("(Intercept)", "Days"))
-    expect_named(
-      get_parameters(m2, effects = "random"),
-      c("mysubgrp:mygrp", "Subject", "mygrp")
-    )
-  })
+  expect_identical(nrow(get_parameters(m2)), 2L)
+  expect_identical(get_parameters(m2)$Parameter, c("(Intercept)", "Days"))
+  expect_named(
+    get_parameters(m2, effects = "random"),
+    c("mysubgrp:mygrp", "Subject", "mygrp")
+  )
+})
 
-  test_that("is_multivariate", {
-    expect_false(is_multivariate(m1))
-    expect_false(is_multivariate(m2))
-  })
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1))
+  expect_false(is_multivariate(m2))
+})
 
-  test_that("get_variance", {
-    skip_on_cran()
+test_that("get_variance", {
+  skip_on_cran()
 
-    expect_equal(
-      get_variance(m1),
-      list(
-        var.fixed = 944.68388146469, var.random = 1911.1173962696,
-        var.residual = 399.07090932584, var.distribution = 399.07090932584,
-        var.dispersion = 0, var.intercept = c(Subject = 782.758817383975),
-        var.slope = c(Subject.Days = 41.8070895953001),
-        cor.slope_intercept = c(Subject = -0.0387835013909591)
-      ),
-      tolerance = 1e-3
-    )
+  expect_equal(
+    get_variance(m1),
+    list(
+      var.fixed = 944.68388146469, var.random = 1911.1173962696,
+      var.residual = 399.07090932584, var.distribution = 399.07090932584,
+      var.dispersion = 0, var.intercept = c(Subject = 782.758817383975),
+      var.slope = c(Subject.Days = 41.8070895953001),
+      cor.slope_intercept = c(Subject = -0.0387835013909591)
+    ),
+    tolerance = 1e-3
+  )
 
-    expect_equal(
-      get_variance(m2),
-      list(
-        var.fixed = 914.841369705921, var.random = 1406.78220075798,
-        var.residual = 809.318117542254, var.distribution = 809.318117542254,
-        var.dispersion = 0,
-        var.intercept = c(`mysubgrp:mygrp` = 0, Subject = 1390.66848960835, mygrp = 16.1137111496379)
-      ),
-      tolerance = 1e-3
-    )
-  })
+  expect_equal(
+    get_variance(m2),
+    list(
+      var.fixed = 914.841369705921, var.random = 1406.78220075798,
+      var.residual = 809.318117542254, var.distribution = 809.318117542254,
+      var.dispersion = 0,
+      var.intercept = c(`mysubgrp:mygrp` = 0, Subject = 1390.66848960835, mygrp = 16.1137111496379)
+    ),
+    tolerance = 1e-3
+  )
+})
 
-  test_that("find_algorithm", {
-    expect_identical(
-      find_algorithm(m1),
-      list(algorithm = "REML", optimizer = "rlmer.fit.DAS.nondiag")
-    )
-  })
+test_that("find_algorithm", {
+  expect_identical(
+    find_algorithm(m1),
+    list(algorithm = "REML", optimizer = "rlmer.fit.DAS.nondiag")
+  )
+})
 
-  test_that("find_random_slopes", {
-    expect_identical(find_random_slopes(m1), list(random = "Days"))
-    expect_null(find_random_slopes(m2))
-  })
+test_that("find_random_slopes", {
+  expect_identical(find_random_slopes(m1), list(random = "Days"))
+  expect_null(find_random_slopes(m2))
+})
 
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "t-statistic")
-    expect_identical(find_statistic(m2), "t-statistic")
-  })
-}
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "t-statistic")
+  expect_identical(find_statistic(m2), "t-statistic")
+})
diff --git a/tests/testthat/test-rms.R b/tests/testthat/test-rms.R
index e3dc4f71a..d6ffef15f 100644
--- a/tests/testthat/test-rms.R
+++ b/tests/testthat/test-rms.R
@@ -1,118 +1,117 @@
-if (skip_if_not_or_load_if_installed("rms")) {
-  data(mtcars)
-  m1 <- lrm(am ~ mpg + gear, data = mtcars)
-
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_binomial)
-    expect_true(model_info(m1)$is_logit)
-    expect_false(model_info(m1)$is_linear)
-  })
-
-  test_that("find_predictors", {
-    expect_identical(find_predictors(m1), list(conditional = c("mpg", "gear")))
-    expect_identical(find_predictors(m1, flatten = TRUE), c("mpg", "gear"))
-    expect_null(find_predictors(m1, effects = "random"))
-  })
-
-  test_that("find_random", {
-    expect_null(find_random(m1))
-  })
-
-  test_that("get_random", {
-    expect_warning(get_random(m1))
-  })
-
-  test_that("find_response", {
-    expect_identical(find_response(m1), "am")
-  })
-
-  test_that("get_response", {
-    expect_equal(get_response(m1), mtcars$am)
-  })
-
-  test_that("get_predictors", {
-    expect_equal(colnames(get_predictors(m1)), c("mpg", "gear"))
-  })
-
-  test_that("link_inverse", {
-    expect_equal(link_inverse(m1)(0.2), plogis(0.2), tolerance = 1e-5)
-  })
-
-  test_that("get_data", {
-    expect_equal(nrow(get_data(m1)), 32)
-    expect_equal(colnames(get_data(m1)), c("am", "mpg", "gear"))
-  })
-
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 1)
-    expect_equal(
-      find_formula(m1),
-      list(conditional = as.formula("am ~ mpg + gear")),
-      ignore_attr = TRUE
-    )
-  })
-
-  test_that("find_terms", {
-    expect_equal(find_terms(m1), list(
-      response = "am",
-      conditional = c("mpg", "gear")
-    ))
-    expect_equal(find_terms(m1, flatten = TRUE), c("am", "mpg", "gear"))
-  })
-
-  test_that("n_obs", {
-    expect_equal(n_obs(m1), 32)
-  })
-
-  test_that("linkfun", {
-    expect_false(is.null(link_function(m1)))
-  })
-
-  test_that("linkinverse", {
-    expect_false(is.null(link_inverse(m1)))
-  })
-
-  test_that("find_parameters", {
-    expect_equal(
-      find_parameters(m1),
-      list(conditional = c("Intercept", "mpg", "gear"))
-    )
-    expect_equal(nrow(get_parameters(m1)), 3)
-    expect_equal(
-      get_parameters(m1)$Parameter,
-      c("Intercept", "mpg", "gear")
-    )
-  })
-
-  test_that("is_multivariate", {
-    expect_false(is_multivariate(m1))
-  })
-
-  test_that("find_algorithm", {
-    expect_equal(find_algorithm(m1), list(algorithm = "ML"))
-  })
-
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "z-statistic")
-  })
-
-  m2 <- rms::orm(mpg ~ cyl + disp + hp + drat, data = mtcars)
-  aov_model <- anova(m2)
-
-  test_that("find_statistic anova", {
-    expect_identical(find_statistic(aov_model), "chi-squared statistic")
-  })
-
-  test_that("find_parameters anova", {
-    expect_identical(find_parameters(aov_model), list(conditional = c("cyl", "disp", "hp", "drat", "TOTAL")))
-  })
-
-  test_that("get_statistic anova", {
-    expect_identical(
-      get_statistic(aov_model)$Statistic,
-      aov_model[, 1],
-      ignore_attr = TRUE,
-      tolerance = 1e-3
-    )
-  })
-}
+skip_if_not_installed("rms")
+
+m1 <- rms::lrm(am ~ mpg + gear, data = mtcars)
+
+test_that("model_info", {
+  expect_true(model_info(m1)$is_binomial)
+  expect_true(model_info(m1)$is_logit)
+  expect_false(model_info(m1)$is_linear)
+})
+
+test_that("find_predictors", {
+  expect_identical(find_predictors(m1), list(conditional = c("mpg", "gear")))
+  expect_identical(find_predictors(m1, flatten = TRUE), c("mpg", "gear"))
+  expect_null(find_predictors(m1, effects = "random"))
+})
+
+test_that("find_random", {
+  expect_null(find_random(m1))
+})
+
+test_that("get_random", {
+  expect_warning(get_random(m1))
+})
+
+test_that("find_response", {
+  expect_identical(find_response(m1), "am")
+})
+
+test_that("get_response", {
+  expect_equal(get_response(m1), mtcars$am)
+})
+
+test_that("get_predictors", {
+  expect_equal(colnames(get_predictors(m1)), c("mpg", "gear"))
+})
+
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), plogis(0.2), tolerance = 1e-5)
+})
+
+test_that("get_data", {
+  expect_equal(nrow(get_data(m1)), 32)
+  expect_equal(colnames(get_data(m1)), c("am", "mpg", "gear"))
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1), 1)
+  expect_equal(
+    find_formula(m1),
+    list(conditional = as.formula("am ~ mpg + gear")),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_terms", {
+  expect_equal(find_terms(m1), list(
+    response = "am",
+    conditional = c("mpg", "gear")
+  ))
+  expect_equal(find_terms(m1, flatten = TRUE), c("am", "mpg", "gear"))
+})
+
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 32)
+})
+
+test_that("linkfun", {
+  expect_false(is.null(link_function(m1)))
+})
+
+test_that("linkinverse", {
+  expect_false(is.null(link_inverse(m1)))
+})
+
+test_that("find_parameters", {
+  expect_equal(
+    find_parameters(m1),
+    list(conditional = c("Intercept", "mpg", "gear"))
+  )
+  expect_equal(nrow(get_parameters(m1)), 3)
+  expect_equal(
+    get_parameters(m1)$Parameter,
+    c("Intercept", "mpg", "gear")
+  )
+})
+
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1))
+})
+
+test_that("find_algorithm", {
+  expect_equal(find_algorithm(m1), list(algorithm = "ML"))
+})
+
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "z-statistic")
+})
+
+m2 <- rms::orm(mpg ~ cyl + disp + hp + drat, data = mtcars)
+aov_model <- anova(m2)
+
+test_that("find_statistic anova", {
+  expect_identical(find_statistic(aov_model), "chi-squared statistic")
+})
+
+test_that("find_parameters anova", {
+  expect_identical(find_parameters(aov_model), list(conditional = c("cyl", "disp", "hp", "drat", "TOTAL")))
+})
+
+test_that("get_statistic anova", {
+  expect_identical(
+    get_statistic(aov_model)$Statistic,
+    aov_model[, 1],
+    ignore_attr = TRUE,
+    tolerance = 1e-3
+  )
+})
diff --git a/tests/testthat/test-rq.R b/tests/testthat/test-rq.R
index a7127fe09..e6ec908d6 100644
--- a/tests/testthat/test-rq.R
+++ b/tests/testthat/test-rq.R
@@ -1,115 +1,114 @@
 skip_if_not(getRversion() >= "4.2.0")
-
-if (skip_if_not_or_load_if_installed("quantreg")) {
-  data(stackloss)
-  m1 <-
-    rq(stack.loss ~ Air.Flow + Water.Temp,
-      data = stackloss,
-      tau = 0.25
-    )
-
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_linear)
-  })
-
-  test_that("find_predictors", {
-    expect_identical(
-      find_predictors(m1),
-      list(conditional = c("Air.Flow", "Water.Temp"))
-    )
-    expect_identical(
-      find_predictors(m1, flatten = TRUE),
-      c("Air.Flow", "Water.Temp")
-    )
-    expect_null(find_predictors(m1, effects = "random"))
-  })
-
-  test_that("find_random", {
-    expect_null(find_random(m1))
-  })
-
-  test_that("get_random", {
-    expect_warning(get_random(m1))
-  })
-
-  test_that("find_response", {
-    expect_identical(find_response(m1), "stack.loss")
-  })
-
-  test_that("get_response", {
-    expect_equal(get_response(m1), stackloss$stack.loss)
-  })
-
-  test_that("get_predictors", {
-    expect_equal(colnames(get_predictors(m1)), c("Air.Flow", "Water.Temp"))
-  })
-
-  test_that("get_data", {
-    expect_equal(nrow(get_data(m1)), 21)
-    expect_equal(
-      colnames(get_data(m1)),
-      c("stack.loss", "Air.Flow", "Water.Temp")
-    )
-  })
-
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 1)
-    expect_equal(
-      find_formula(m1),
-      list(conditional = as.formula("stack.loss ~ Air.Flow + Water.Temp")),
-      ignore_attr = TRUE
+skip_if_not_installed("quantreg")
+
+data(stackloss)
+m1 <-
+  quantreg::rq(stack.loss ~ Air.Flow + Water.Temp,
+    data = stackloss,
+    tau = 0.25
+  )
+
+test_that("model_info", {
+  expect_true(model_info(m1)$is_linear)
+})
+
+test_that("find_predictors", {
+  expect_identical(
+    find_predictors(m1),
+    list(conditional = c("Air.Flow", "Water.Temp"))
+  )
+  expect_identical(
+    find_predictors(m1, flatten = TRUE),
+    c("Air.Flow", "Water.Temp")
+  )
+  expect_null(find_predictors(m1, effects = "random"))
+})
+
+test_that("find_random", {
+  expect_null(find_random(m1))
+})
+
+test_that("get_random", {
+  expect_warning(get_random(m1))
+})
+
+test_that("find_response", {
+  expect_identical(find_response(m1), "stack.loss")
+})
+
+test_that("get_response", {
+  expect_equal(get_response(m1), stackloss$stack.loss)
+})
+
+test_that("get_predictors", {
+  expect_equal(colnames(get_predictors(m1)), c("Air.Flow", "Water.Temp"))
+})
+
+test_that("get_data", {
+  expect_equal(nrow(get_data(m1)), 21)
+  expect_equal(
+    colnames(get_data(m1)),
+    c("stack.loss", "Air.Flow", "Water.Temp")
+  )
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1), 1)
+  expect_equal(
+    find_formula(m1),
+    list(conditional = as.formula("stack.loss ~ Air.Flow + Water.Temp")),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_terms", {
+  expect_equal(
+    find_terms(m1),
+    list(
+      response = "stack.loss",
+      conditional = c("Air.Flow", "Water.Temp")
     )
-  })
-
-  test_that("find_terms", {
-    expect_equal(
-      find_terms(m1),
-      list(
-        response = "stack.loss",
-        conditional = c("Air.Flow", "Water.Temp")
-      )
-    )
-    expect_equal(
-      find_terms(m1, flatten = TRUE),
-      c("stack.loss", "Air.Flow", "Water.Temp")
-    )
-  })
-
-  test_that("n_obs", {
-    expect_equal(n_obs(m1), 21)
-  })
-
-  test_that("link_function", {
-    expect_equal(link_function(m1)(0.2), 0.2, tolerance = 1e-5)
-  })
-
-  test_that("link_inverse", {
-    expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
-  })
-
-  test_that("find_parameters", {
-    expect_equal(
-      find_parameters(m1),
-      list(conditional = c(
-        "(Intercept)", "Air.Flow", "Water.Temp"
-      ))
-    )
-    expect_equal(nrow(get_parameters(m1)), 3)
-    expect_equal(
-      get_parameters(m1)$Parameter,
-      c("(Intercept)", "Air.Flow", "Water.Temp")
-    )
-  })
-
-  test_that("is_multivariate", {
-    expect_false(is_multivariate(m1))
-  })
-
-  test_that("find_algorithm", {
-    expect_equal(find_algorithm(m1), list(algorithm = "br"))
-  })
-
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "t-statistic")
-  })
-}
+  )
+  expect_equal(
+    find_terms(m1, flatten = TRUE),
+    c("stack.loss", "Air.Flow", "Water.Temp")
+  )
+})
+
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 21)
+})
+
+test_that("link_function", {
+  expect_equal(link_function(m1)(0.2), 0.2, tolerance = 1e-5)
+})
+
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
+})
+
+test_that("find_parameters", {
+  expect_equal(
+    find_parameters(m1),
+    list(conditional = c(
+      "(Intercept)", "Air.Flow", "Water.Temp"
+    ))
+  )
+  expect_equal(nrow(get_parameters(m1)), 3)
+  expect_equal(
+    get_parameters(m1)$Parameter,
+    c("(Intercept)", "Air.Flow", "Water.Temp")
+  )
+})
+
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1))
+})
+
+test_that("find_algorithm", {
+  expect_equal(find_algorithm(m1), list(algorithm = "br"))
+})
+
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "t-statistic")
+})
diff --git a/tests/testthat/test-rqss.R b/tests/testthat/test-rqss.R
index 225a12720..256e7821b 100644
--- a/tests/testthat/test-rqss.R
+++ b/tests/testthat/test-rqss.R
@@ -1,99 +1,102 @@
-if (FALSE &&
-
-
-  skip_if_not_or_load_if_installed("quantreg")) {
-  ## NOTE Run this test conditionally every now and then, requires package
-  ##      "tripack", which has a non-standard license.
-
-  data("CobarOre")
-  set.seed(123)
-  CobarOre$w <- rnorm(nrow(CobarOre))
-
-  # model
-  m1 <- rqss(z ~ w + qss(cbind(x, y), lambda = 0.08), data = CobarOre)
-
-
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_linear)
-  })
-
-  test_that("find_predictors", {
-    expect_identical(
-      find_predictors(m1),
-      list(conditional = c("w", "x", "y"))
-    )
-    expect_identical(
-      find_predictors(m1, flatten = TRUE),
-      c("w", "x", "y")
-    )
-    expect_null(find_predictors(m1, effects = "random"))
-  })
-
-  test_that("find_random", {
-    expect_null(find_random(m1))
-  })
-
-  test_that("get_random", {
-    expect_warning(get_random(m1))
-  })
-
-  test_that("find_response", {
-    expect_identical(find_response(m1), "z")
-  })
-
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 1)
-    expect_equal(
-      find_formula(m1),
-      list(conditional = as.formula("z ~ w + qss(cbind(x, y), lambda = 0.08)")),
-      ignore_attr = TRUE
-    )
-  })
-
-  test_that("find_terms", {
-    expect_equal(
-      find_terms(m1),
-      list(response = "z", conditional = c("w", "qss(cbind(x, y), lambda = 0.08)"))
-    )
-    expect_equal(
-      find_terms(m1, flatten = TRUE),
-      c("z", "w", "qss(cbind(x, y), lambda = 0.08)")
-    )
-  })
-
-  test_that("n_obs", {
-    expect_equal(n_obs(m1), 38)
-  })
-
-  test_that("link_function", {
-    expect_equal(link_function(m1)(0.2), 0.2, tolerance = 1e-5)
-  })
-
-  test_that("link_inverse", {
-    expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
-  })
-
-  test_that("find_parameters", {
-    expect_equal(
-      find_parameters(m1),
-      list(conditional = c("(Intercept)", "w"), smooth_terms = "cbind(x, y)")
-    )
-    expect_equal(nrow(get_parameters(m1)), 3)
-    expect_equal(
-      get_parameters(m1)$Parameter,
-      c("(Intercept)", "w", "cbind(x, y)")
-    )
-  })
-
-  test_that("is_multivariate", {
-    expect_false(is_multivariate(m1))
-  })
-
-  test_that("find_algorithm", {
-    expect_equal(find_algorithm(m1), list(algorithm = "sfn"))
-  })
-
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "t-statistic")
-  })
-}
+skip_on_cran()
+skip_if_not_installed("quantreg")
+skip_if_not_installed("interp")
+
+## NOTE Run this test conditionally every now and then, requires package
+##      "tripack", which has a non-standard license.
+
+suppressPackageStartupMessages({
+  library(quantreg)
+})
+
+data("CobarOre", package = "quantreg")
+set.seed(123)
+CobarOre$w <- rnorm(nrow(CobarOre))
+
+# model
+m1 <- rqss(z ~ w + qss(cbind(x, y), lambda = 0.08), data = CobarOre)
+
+
+test_that("model_info", {
+  expect_true(model_info(m1)$is_linear)
+})
+
+test_that("find_predictors", {
+  expect_identical(
+    find_predictors(m1),
+    list(conditional = c("w", "x", "y"))
+  )
+  expect_identical(
+    find_predictors(m1, flatten = TRUE),
+    c("w", "x", "y")
+  )
+  expect_null(find_predictors(m1, effects = "random"))
+})
+
+test_that("find_random", {
+  expect_null(find_random(m1))
+})
+
+test_that("get_random", {
+  expect_warning(get_random(m1))
+})
+
+test_that("find_response", {
+  expect_identical(find_response(m1), "z")
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1), 1)
+  expect_equal(
+    find_formula(m1),
+    list(conditional = as.formula("z ~ w + qss(cbind(x, y), lambda = 0.08)")),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_terms", {
+  expect_equal(
+    find_terms(m1),
+    list(response = "z", conditional = c("w", "qss(cbind(x, y), lambda = 0.08)"))
+  )
+  expect_equal(
+    find_terms(m1, flatten = TRUE),
+    c("z", "w", "qss(cbind(x, y), lambda = 0.08)")
+  )
+})
+
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 38)
+})
+
+test_that("link_function", {
+  expect_equal(link_function(m1)(0.2), 0.2, tolerance = 1e-5)
+})
+
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
+})
+
+test_that("find_parameters", {
+  expect_equal(
+    find_parameters(m1),
+    list(conditional = c("(Intercept)", "w"), smooth_terms = "cbind(x, y)")
+  )
+  expect_equal(nrow(get_parameters(m1)), 3)
+  expect_equal(
+    get_parameters(m1)$Parameter,
+    c("(Intercept)", "w", "cbind(x, y)")
+  )
+})
+
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1))
+})
+
+test_that("find_algorithm", {
+  expect_equal(find_algorithm(m1), list(algorithm = "sfn"))
+})
+
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "t-statistic")
+})
diff --git a/tests/testthat/test-rstanarm.R b/tests/testthat/test-rstanarm.R
index d0bf6e5b7..adda70370 100644
--- a/tests/testthat/test-rstanarm.R
+++ b/tests/testthat/test-rstanarm.R
@@ -1,531 +1,536 @@
-.runStanTest <- Sys.getenv("RunAllinsightStanTests") == "yes"
-
-if (.runStanTest) {
-  if (suppressWarnings(
-    skip_if_not_or_load_if_installed("lme4") &&
-      skip_if_not_or_load_if_installed("BayesFactor") &&
-      skip_if_not_or_load_if_installed("rstanarm")
-  )) {
-    # skip_on_cran()
-    skip_if_offline()
-
-    # defining models ---------------------
-
-    m1 <- insight::download_model("stanreg_merMod_5")
-    m2 <- insight::download_model("stanreg_glm_6")
-    m3 <- insight::download_model("stanreg_glm_1")
-
-    data("puzzles")
-    m4 <- suppressWarnings(
-      stan_glm(
-        RT ~ color * shape,
-        data = puzzles,
-        prior = rstanarm::cauchy(0, c(3, 1, 2)),
-        iter = 500,
-        chains = 2,
-        refresh = 0
+skip_on_cran()
+skip_if_offline()
+skip_if_not_installed("lme4")
+skip_if_not_installed("BayesFactor")
+skip_if_not_installed("rstanarm")
+
+suppressPackageStartupMessages({
+  library(rstanarm)
+})
+
+data(sleepstudy, package = "lme4")
+
+# defining models ---------------------
+
+m1 <- insight::download_model("stanreg_merMod_5")
+m2 <- insight::download_model("stanreg_glm_6")
+m3 <- insight::download_model("stanreg_glm_1")
+
+data("puzzles", package = "BayesFactor")
+m4 <- suppressWarnings(
+  stan_glm(
+    RT ~ color * shape,
+    data = puzzles,
+    prior = cauchy(0, c(3, 1, 2)),
+    iter = 500,
+    chains = 2,
+    refresh = 0
+  )
+)
+m5 <- suppressWarnings(
+  stan_glm(
+    RT ~ color * shape,
+    data = puzzles,
+    prior = cauchy(0, c(1, 2, 3)),
+    iter = 500,
+    chains = 2,
+    refresh = 0
+  )
+)
+m6 <- insight::download_model("stanreg_gamm4_1")
+
+m7 <- suppressWarnings(
+  stan_lm(mpg ~ wt + qsec + am,
+    data = mtcars, prior = R2(0.75),
+    chains = 1, iter = 300, refresh = 0
+  )
+)
+
+m8 <- stan_lmer(Reaction ~ Days + (1 | Subject), data = sleepstudy, refresh = 0)
+
+m9 <- stan_aov(yield ~ block + N * P * K, data = npk, prior = R2(0.5), refresh = 0)
+
+N <- 200
+x <- rnorm(N, 2, 1)
+z <- rnorm(N, 2, 1)
+mu <- binomial(link = "logit")$linkinv(1 + 0.2 * x)
+phi <- exp(1.5 + 0.4 * z)
+y <- rbeta(N, mu * phi, (1 - mu) * phi)
+hist(y, col = "dark grey", border = FALSE, xlim = c(0, 1))
+fake_dat <- data.frame(y, x, z)
+m10 <- stan_betareg(
+  y ~ x | z,
+  data = fake_dat,
+  link = "logit",
+  link.phi = "log",
+  refresh = 0,
+  algorithm = "optimizing" # just for speed of example
+)
+
+ols <- lm(mpg ~ wt + qsec + am,
+  data = mtcars, # all row are complete so ...
+  na.action = na.exclude
+) # not necessary in this case
+b <- coef(ols)[-1]
+R <- qr.R(ols$qr)[-1, -1]
+SSR <- crossprod(ols$residuals)[1]
+not_NA <- !is.na(fitted(ols))
+N <- sum(not_NA)
+xbar <- colMeans(mtcars[not_NA, c("wt", "qsec", "am")])
+y <- mtcars$mpg[not_NA]
+ybar <- mean(y)
+s_y <- sd(y)
+m11 <- suppressWarnings(
+  stan_biglm.fit(b, R, SSR, N, xbar, ybar, s_y,
+    prior = R2(0.75),
+    # the next line is only to make the example go fast
+    refresh = 0,
+    chains = 1, iter = 500, seed = 12345
+  )
+)
+
+dat <- infert[order(infert$stratum), ] # order by strata
+m12 <- suppressWarnings(
+  stan_clogit(case ~ spontaneous + induced + (1 | education),
+    strata = stratum,
+    data = dat,
+    subset = parity <= 2,
+    QR = TRUE,
+    chains = 2, iter = 500, refresh = 0
+  )
+) # for speed only
+
+test_that("stan_jm", {
+  skip_on_os("windows")
+  skip_on_os(c("mac", "linux", "solaris"), arch = "i386")
+  void <- capture.output(
+    m13 <- suppressMessages(
+      suppressWarnings(
+        stan_jm(
+          formulaLong = logBili ~ year + (1 | id),
+          dataLong = pbcLong,
+          formulaEvent = Surv(futimeYears, death) ~ sex + trt,
+          dataEvent = pbcSurv,
+          time_var = "year",
+          # this next line is only to keep the example small in size!
+          chains = 1, cores = 1, seed = 12345, iter = 1000, refresh = 0
+        )
       )
     )
-    m5 <- suppressWarnings(
-      stan_glm(
-        RT ~ color * shape,
-        data = puzzles,
-        prior = rstanarm::cauchy(0, c(1, 2, 3)),
-        iter = 500,
-        chains = 2,
-        refresh = 0
-      )
+  )
+  # expect_snapshot(model_info(m13))
+})
+
+data("Orange", package = "datasets")
+Orange$circumference <- Orange$circumference / 100
+Orange$age <- Orange$age / 100
+
+
+## TODO probably re-enable once strange check error is resolved
+
+# m14 <- stan_nlmer(
+#   circumference ~ SSlogis(age, Asym, xmid, scal) ~ Asym | Tree,
+#   data = Orange,
+#   # for speed only
+#   chains = 1,
+#   iter = 1000
+# )
+
+invisible(capture.output(
+  m15 <- suppressWarnings(
+    stan_mvmer(
+      formula = list(
+        logBili ~ year + (1 | id),
+        albumin ~ sex + year + (year | id)
+      ),
+      data = pbcLong,
+      # this next line is only to keep the example small in size!
+      chains = 1, cores = 1, seed = 12345, iter = 1000, refresh = 0
     )
-    m6 <- insight::download_model("stanreg_gamm4_1")
-
-    m7 <- suppressWarnings(
-      stan_lm(mpg ~ wt + qsec + am,
-        data = mtcars, prior = R2(0.75),
-        chains = 1, iter = 300, refresh = 0
-      )
+  )
+))
+
+test_that("model_info-stanreg-glm", {
+  expect_equal(
+    model_info(m1),
+    list(
+      is_binomial = TRUE, is_bernoulli = FALSE, is_count = FALSE,
+      is_poisson = FALSE, is_negbin = FALSE, is_beta = FALSE, is_betabinomial = FALSE,
+      is_dirichlet = FALSE, is_exponential = FALSE, is_logit = TRUE,
+      is_probit = FALSE, is_censored = FALSE, is_truncated = FALSE,
+      is_survival = FALSE, is_linear = FALSE, is_tweedie = FALSE,
+      is_zeroinf = FALSE, is_zero_inflated = FALSE, is_dispersion = FALSE,
+      is_hurdle = FALSE, is_ordinal = FALSE, is_cumulative = FALSE,
+      is_multinomial = FALSE, is_categorical = FALSE, is_mixed = TRUE,
+      is_multivariate = FALSE, is_trial = TRUE, is_bayesian = TRUE,
+      is_gam = FALSE, is_anova = FALSE, is_timeseries = FALSE,
+      is_ttest = FALSE, is_correlation = FALSE, is_onewaytest = FALSE,
+      is_chi2test = FALSE, is_ranktest = FALSE, is_levenetest = FALSE,
+      is_variancetest = FALSE, is_xtab = FALSE, is_proptest = FALSE,
+      is_binomtest = FALSE, is_ftest = FALSE, is_meta = FALSE,
+      link_function = "logit", family = "binomial", n_obs = 56L,
+      n_grouplevels = c(herd = 15L)
     )
-
-    m8 <- stan_lmer(Reaction ~ Days + (1 | Subject), data = sleepstudy, refresh = 0)
-
-    m9 <- stan_aov(yield ~ block + N * P * K, data = npk, prior = R2(0.5), refresh = 0)
-
-    N <- 200
-    x <- rnorm(N, 2, 1)
-    z <- rnorm(N, 2, 1)
-    mu <- binomial(link = "logit")$linkinv(1 + 0.2 * x)
-    phi <- exp(1.5 + 0.4 * z)
-    y <- rbeta(N, mu * phi, (1 - mu) * phi)
-    hist(y, col = "dark grey", border = FALSE, xlim = c(0, 1))
-    fake_dat <- data.frame(y, x, z)
-    m10 <- stan_betareg(
-      y ~ x | z,
-      data = fake_dat,
-      link = "logit",
-      link.phi = "log",
-      refresh = 0,
-      algorithm = "optimizing" # just for speed of example
+  )
+
+  expect_equal(
+    model_info(m2),
+    list(
+      is_binomial = FALSE, is_bernoulli = FALSE, is_count = FALSE,
+      is_poisson = FALSE, is_negbin = FALSE, is_beta = FALSE, is_betabinomial = FALSE,
+      is_dirichlet = FALSE, is_exponential = FALSE, is_logit = FALSE,
+      is_probit = FALSE, is_censored = FALSE, is_truncated = FALSE,
+      is_survival = FALSE, is_linear = TRUE, is_tweedie = FALSE,
+      is_zeroinf = FALSE, is_zero_inflated = FALSE, is_dispersion = FALSE,
+      is_hurdle = FALSE, is_ordinal = FALSE, is_cumulative = FALSE,
+      is_multinomial = FALSE, is_categorical = FALSE, is_mixed = FALSE,
+      is_multivariate = FALSE, is_trial = FALSE, is_bayesian = TRUE,
+      is_gam = FALSE, is_anova = FALSE, is_timeseries = FALSE,
+      is_ttest = FALSE, is_correlation = FALSE, is_onewaytest = FALSE,
+      is_chi2test = FALSE, is_ranktest = FALSE, is_levenetest = FALSE,
+      is_variancetest = FALSE, is_xtab = FALSE, is_proptest = FALSE,
+      is_binomtest = FALSE, is_ftest = FALSE, is_meta = FALSE,
+      link_function = "identity", family = "gaussian", n_obs = 150L,
+      n_grouplevels = NULL
     )
-
-    ols <- lm(mpg ~ wt + qsec + am,
-      data = mtcars, # all row are complete so ...
-      na.action = na.exclude
-    ) # not necessary in this case
-    b <- coef(ols)[-1]
-    R <- qr.R(ols$qr)[-1, -1]
-    SSR <- crossprod(ols$residuals)[1]
-    not_NA <- !is.na(fitted(ols))
-    N <- sum(not_NA)
-    xbar <- colMeans(mtcars[not_NA, c("wt", "qsec", "am")])
-    y <- mtcars$mpg[not_NA]
-    ybar <- mean(y)
-    s_y <- sd(y)
-    m11 <- suppressWarnings(
-      stan_biglm.fit(b, R, SSR, N, xbar, ybar, s_y,
-        prior = R2(0.75),
-        # the next line is only to make the example go fast
-        refresh = 0,
-        chains = 1, iter = 500, seed = 12345
-      )
+  )
+
+  expect_equal(
+    model_info(m3),
+    list(
+      is_binomial = TRUE, is_bernoulli = TRUE, is_count = FALSE,
+      is_poisson = FALSE, is_negbin = FALSE, is_beta = FALSE, is_betabinomial = FALSE,
+      is_dirichlet = FALSE, is_exponential = FALSE, is_logit = TRUE,
+      is_probit = FALSE, is_censored = FALSE, is_truncated = FALSE,
+      is_survival = FALSE, is_linear = FALSE, is_tweedie = FALSE,
+      is_zeroinf = FALSE, is_zero_inflated = FALSE, is_dispersion = FALSE,
+      is_hurdle = FALSE, is_ordinal = FALSE, is_cumulative = FALSE,
+      is_multinomial = FALSE, is_categorical = FALSE, is_mixed = FALSE,
+      is_multivariate = FALSE, is_trial = FALSE, is_bayesian = TRUE,
+      is_gam = FALSE, is_anova = FALSE, is_timeseries = FALSE,
+      is_ttest = FALSE, is_correlation = FALSE, is_onewaytest = FALSE,
+      is_chi2test = FALSE, is_ranktest = FALSE, is_levenetest = FALSE,
+      is_variancetest = FALSE, is_xtab = FALSE, is_proptest = FALSE,
+      is_binomtest = FALSE, is_ftest = FALSE, is_meta = FALSE,
+      link_function = "logit", family = "binomial", n_obs = 32L,
+      n_grouplevels = NULL
     )
-
-    dat <- infert[order(infert$stratum), ] # order by strata
-    m12 <- suppressWarnings(
-      stan_clogit(case ~ spontaneous + induced + (1 | education),
-        strata = stratum,
-        data = dat,
-        subset = parity <= 2,
-        QR = TRUE,
-        chains = 2, iter = 500, refresh = 0
-      )
-    ) # for speed only
-
-    if (.Platform$OS.type != "windows" || .Platform$r_arch != "i386") {
-      void <- capture.output(
-        m13 <- suppressMessages(
-          suppressWarnings(
-            stan_jm(
-              formulaLong = logBili ~ year + (1 | id),
-              dataLong = pbcLong,
-              formulaEvent = Surv(futimeYears, death) ~ sex + trt,
-              dataEvent = pbcSurv,
-              time_var = "year",
-              # this next line is only to keep the example small in size!
-              chains = 1, cores = 1, seed = 12345, iter = 1000, refresh = 0
-            )
-          )
-        )
-      )
-      # expect_snapshot(model_info(m13))
-    }
-
-    data("Orange", package = "datasets")
-    Orange$circumference <- Orange$circumference / 100
-    Orange$age <- Orange$age / 100
-
-
-    ## TODO probably re-enable once strange check error is resolved
-
-    # m14 <- stan_nlmer(
-    #   circumference ~ SSlogis(age, Asym, xmid, scal) ~ Asym | Tree,
-    #   data = Orange,
-    #   # for speed only
-    #   chains = 1,
-    #   iter = 1000
-    # )
-
-    m15 <- suppressWarnings(
-      stan_mvmer(
-        formula = list(
-          logBili ~ year + (1 | id),
-          albumin ~ sex + year + (year | id)
-        ),
-        data = pbcLong,
-        # this next line is only to keep the example small in size!
-        chains = 1, cores = 1, seed = 12345, iter = 1000, refresh = 0
-      )
+  )
+
+  ## TODO add model m4 to m15
+})
+
+test_that("n_parameters", {
+  expect_equal(n_parameters(m1), 21)
+  expect_equal(n_parameters(m1, effects = "fixed"), 5)
+})
+
+test_that("get_priors", {
+  expect_equal(
+    colnames(get_priors(m1)),
+    c("Parameter", "Distribution", "Location", "Scale")
+  )
+  expect_equal(
+    colnames(get_priors(m2)),
+    c(
+      "Parameter",
+      "Distribution",
+      "Location",
+      "Scale",
+      "Adjusted_Scale"
     )
-
-    test_that("model_info-stanreg-glm", {
-      expect_equal(
-        model_info(m1),
-        list(
-          is_binomial = TRUE, is_bernoulli = FALSE, is_count = FALSE,
-          is_poisson = FALSE, is_negbin = FALSE, is_beta = FALSE, is_betabinomial = FALSE,
-          is_dirichlet = FALSE, is_exponential = FALSE, is_logit = TRUE,
-          is_probit = FALSE, is_censored = FALSE, is_truncated = FALSE,
-          is_survival = FALSE, is_linear = FALSE, is_tweedie = FALSE,
-          is_zeroinf = FALSE, is_zero_inflated = FALSE, is_dispersion = FALSE,
-          is_hurdle = FALSE, is_ordinal = FALSE, is_cumulative = FALSE,
-          is_multinomial = FALSE, is_categorical = FALSE, is_mixed = TRUE,
-          is_multivariate = FALSE, is_trial = TRUE, is_bayesian = TRUE,
-          is_gam = FALSE, is_anova = FALSE, is_timeseries = FALSE,
-          is_ttest = FALSE, is_correlation = FALSE, is_onewaytest = FALSE,
-          is_chi2test = FALSE, is_ranktest = FALSE, is_levenetest = FALSE,
-          is_variancetest = FALSE, is_xtab = FALSE, is_proptest = FALSE,
-          is_binomtest = FALSE, is_ftest = FALSE, is_meta = FALSE,
-          link_function = "logit", family = "binomial", n_obs = 56L,
-          n_grouplevels = c(herd = 15L)
-        )
-      )
-
-      expect_equal(
-        model_info(m2),
-        list(
-          is_binomial = FALSE, is_bernoulli = FALSE, is_count = FALSE,
-          is_poisson = FALSE, is_negbin = FALSE, is_beta = FALSE, is_betabinomial = FALSE,
-          is_dirichlet = FALSE, is_exponential = FALSE, is_logit = FALSE,
-          is_probit = FALSE, is_censored = FALSE, is_truncated = FALSE,
-          is_survival = FALSE, is_linear = TRUE, is_tweedie = FALSE,
-          is_zeroinf = FALSE, is_zero_inflated = FALSE, is_dispersion = FALSE,
-          is_hurdle = FALSE, is_ordinal = FALSE, is_cumulative = FALSE,
-          is_multinomial = FALSE, is_categorical = FALSE, is_mixed = FALSE,
-          is_multivariate = FALSE, is_trial = FALSE, is_bayesian = TRUE,
-          is_gam = FALSE, is_anova = FALSE, is_timeseries = FALSE,
-          is_ttest = FALSE, is_correlation = FALSE, is_onewaytest = FALSE,
-          is_chi2test = FALSE, is_ranktest = FALSE, is_levenetest = FALSE,
-          is_variancetest = FALSE, is_xtab = FALSE, is_proptest = FALSE,
-          is_binomtest = FALSE, is_ftest = FALSE, is_meta = FALSE,
-          link_function = "identity", family = "gaussian", n_obs = 150L,
-          n_grouplevels = NULL
-        )
-      )
-
-      expect_equal(
-        model_info(m3),
-        list(
-          is_binomial = TRUE, is_bernoulli = TRUE, is_count = FALSE,
-          is_poisson = FALSE, is_negbin = FALSE, is_beta = FALSE, is_betabinomial = FALSE,
-          is_dirichlet = FALSE, is_exponential = FALSE, is_logit = TRUE,
-          is_probit = FALSE, is_censored = FALSE, is_truncated = FALSE,
-          is_survival = FALSE, is_linear = FALSE, is_tweedie = FALSE,
-          is_zeroinf = FALSE, is_zero_inflated = FALSE, is_dispersion = FALSE,
-          is_hurdle = FALSE, is_ordinal = FALSE, is_cumulative = FALSE,
-          is_multinomial = FALSE, is_categorical = FALSE, is_mixed = FALSE,
-          is_multivariate = FALSE, is_trial = FALSE, is_bayesian = TRUE,
-          is_gam = FALSE, is_anova = FALSE, is_timeseries = FALSE,
-          is_ttest = FALSE, is_correlation = FALSE, is_onewaytest = FALSE,
-          is_chi2test = FALSE, is_ranktest = FALSE, is_levenetest = FALSE,
-          is_variancetest = FALSE, is_xtab = FALSE, is_proptest = FALSE,
-          is_binomtest = FALSE, is_ftest = FALSE, is_meta = FALSE,
-          link_function = "logit", family = "binomial", n_obs = 32L,
-          n_grouplevels = NULL
-        )
-      )
-
-      ## TODO add model m4 to m15
-    })
-
-    test_that("n_parameters", {
-      expect_equal(n_parameters(m1), 21)
-      expect_equal(n_parameters(m1, effects = "fixed"), 5)
-    })
-
-    test_that("get_priors", {
-      expect_equal(
-        colnames(get_priors(m1)),
-        c("Parameter", "Distribution", "Location", "Scale")
-      )
-      expect_equal(
-        colnames(get_priors(m2)),
-        c(
-          "Parameter",
-          "Distribution",
-          "Location",
-          "Scale",
-          "Adjusted_Scale"
-        )
-      )
-      expect_equal(get_priors(m1)$Scale, c(2.5, 2.5, 2.5, 2.5, 2.5), tolerance = 1e-3)
-      expect_equal(get_priors(m2)$Adjusted_Scale, c(1.08967, 2.30381, 2.30381, 0.61727, 0.53603, 0.41197), tolerance = 1e-3)
-      expect_equal(get_priors(m3)$Adjusted_Scale, c(NA, 2.555042), tolerance = 1e-3)
-      expect_equal(get_priors(m4)$Adjusted_Scale, c(6.399801, NA, NA, NA), tolerance = 1e-3)
-      expect_equal(get_priors(m5)$Adjusted_Scale, c(6.399801, NA, NA, NA), tolerance = 1e-3)
-      expect_equal(
-        get_priors(m6),
-        data.frame(
-          Parameter = "(Intercept)",
-          Distribution = "normal",
-          Location = 3.057333,
-          Scale = 2.5,
-          Adjusted_Scale = 1.089666,
-          stringsAsFactors = FALSE,
-          row.names = NULL
-        ),
-        tolerance = 1e-3
-      )
-    })
-
-
-    test_that("clean_names", {
-      expect_identical(
-        clean_names(m1),
-        c("incidence", "size", "period", "herd")
-      )
-    })
-
-
-    test_that("find_predictors", {
-      expect_identical(find_predictors(m1), list(conditional = c("size", "period")))
-      expect_identical(find_predictors(m1, flatten = TRUE), c("size", "period"))
-      expect_identical(
-        find_predictors(m1, effects = "all", component = "all"),
-        list(
-          conditional = c("size", "period"),
-          random = "herd"
-        )
-      )
-      expect_identical(
-        find_predictors(
-          m1,
-          effects = "all",
-          component = "all",
-          flatten = TRUE
-        ),
-        c("size", "period", "herd")
-      )
-    })
-
-    test_that("find_response", {
-      expect_equal(
-        find_response(m1, combine = TRUE),
-        "cbind(incidence, size - incidence)"
-      )
-      expect_equal(
-        find_response(m1, combine = FALSE),
-        c("incidence", "size")
-      )
-    })
-
-    test_that("get_response", {
-      expect_equal(nrow(get_response(m1)), 56)
-      expect_equal(colnames(get_response(m1)), c("incidence", "size"))
-    })
-
-    test_that("find_random", {
-      expect_equal(find_random(m1), list(random = "herd"))
-    })
-
-    test_that("get_random", {
-      expect_equal(get_random(m1), lme4::cbpp[, "herd", drop = FALSE])
-    })
-
-    test_that("find_terms", {
-      expect_identical(
-        find_terms(m1),
-        list(
-          response = "cbind(incidence, size - incidence)",
-          conditional = c("size", "period"),
-          random = "herd"
-        )
-      )
-    })
-
-    test_that("find_variables", {
-      expect_identical(
-        find_variables(m1),
-        list(
-          response = c("incidence", "size"),
-          conditional = c("size", "period"),
-          random = "herd"
-        )
-      )
-      expect_identical(
-        find_variables(m1, effects = "fixed"),
-        list(
-          response = c("incidence", "size"),
-          conditional = c("size", "period")
-        )
-      )
-      expect_null(find_variables(m1, component = "zi"))
-    })
-
-    test_that("n_obs", {
-      expect_equal(n_obs(m1), 56)
-      expect_equal(n_obs(m1, disaggregate = TRUE), 842)
-    })
-
-    test_that("find_paramaters", {
-      expect_equal(
-        find_parameters(m1),
-        list(
-          conditional = c("(Intercept)", "size", "period2", "period3", "period4"),
-          random = c(sprintf("b[(Intercept) herd:%i]", 1:15), "Sigma[herd:(Intercept),(Intercept)]")
-        )
-      )
-      expect_equal(
-        find_parameters(m1, flatten = TRUE),
-        c(
-          "(Intercept)",
-          "size",
-          "period2",
-          "period3",
-          "period4",
-          sprintf("b[(Intercept) herd:%i]", 1:15),
-          "Sigma[herd:(Intercept),(Intercept)]"
-        )
-      )
-    })
-
-    test_that("find_paramaters", {
-      expect_equal(
-        colnames(get_parameters(m1)),
-        c("(Intercept)", "size", "period2", "period3", "period4")
-      )
-      expect_equal(
-        colnames(get_parameters(m1, effects = "all")),
-        c(
+  )
+  expect_equal(get_priors(m1)$Scale, c(2.5, 2.5, 2.5, 2.5, 2.5), tolerance = 1e-3)
+  expect_equal(get_priors(m2)$Adjusted_Scale, c(1.08967, 2.30381, 2.30381, 0.61727, 0.53603, 0.41197), tolerance = 1e-3)
+  expect_equal(get_priors(m3)$Adjusted_Scale, c(NA, 2.555042), tolerance = 1e-3)
+  expect_equal(get_priors(m4)$Adjusted_Scale, c(6.399801, NA, NA, NA), tolerance = 1e-3)
+  expect_equal(get_priors(m5)$Adjusted_Scale, c(6.399801, NA, NA, NA), tolerance = 1e-3)
+  expect_equal(
+    get_priors(m6),
+    data.frame(
+      Parameter = "(Intercept)",
+      Distribution = "normal",
+      Location = 3.057333,
+      Scale = 2.5,
+      Adjusted_Scale = 1.089666,
+      stringsAsFactors = FALSE,
+      row.names = NULL
+    ),
+    tolerance = 1e-3
+  )
+})
+
+
+test_that("clean_names", {
+  expect_identical(
+    clean_names(m1),
+    c("incidence", "size", "period", "herd")
+  )
+})
+
+
+test_that("find_predictors", {
+  expect_identical(find_predictors(m1), list(conditional = c("size", "period")))
+  expect_identical(find_predictors(m1, flatten = TRUE), c("size", "period"))
+  expect_identical(
+    find_predictors(m1, effects = "all", component = "all"),
+    list(
+      conditional = c("size", "period"),
+      random = "herd"
+    )
+  )
+  expect_identical(
+    find_predictors(
+      m1,
+      effects = "all",
+      component = "all",
+      flatten = TRUE
+    ),
+    c("size", "period", "herd")
+  )
+})
+
+test_that("find_response", {
+  expect_equal(
+    find_response(m1, combine = TRUE),
+    "cbind(incidence, size - incidence)"
+  )
+  expect_equal(
+    find_response(m1, combine = FALSE),
+    c("incidence", "size")
+  )
+})
+
+test_that("get_response", {
+  expect_equal(nrow(get_response(m1)), 56)
+  expect_equal(colnames(get_response(m1)), c("incidence", "size"))
+})
+
+test_that("find_random", {
+  expect_equal(find_random(m1), list(random = "herd"))
+})
+
+test_that("get_random", {
+  expect_equal(get_random(m1), lme4::cbpp[, "herd", drop = FALSE])
+})
+
+test_that("find_terms", {
+  expect_identical(
+    find_terms(m1),
+    list(
+      response = "cbind(incidence, size - incidence)",
+      conditional = c("size", "period"),
+      random = "herd"
+    )
+  )
+})
+
+test_that("find_variables", {
+  expect_identical(
+    find_variables(m1),
+    list(
+      response = c("incidence", "size"),
+      conditional = c("size", "period"),
+      random = "herd"
+    )
+  )
+  expect_identical(
+    find_variables(m1, effects = "fixed"),
+    list(
+      response = c("incidence", "size"),
+      conditional = c("size", "period")
+    )
+  )
+  expect_null(find_variables(m1, component = "zi"))
+})
+
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 56)
+  expect_equal(n_obs(m1, disaggregate = TRUE), 842)
+})
+
+test_that("find_paramaters", {
+  expect_equal(
+    find_parameters(m1),
+    list(
+      conditional = c("(Intercept)", "size", "period2", "period3", "period4"),
+      random = c(sprintf("b[(Intercept) herd:%i]", 1:15), "Sigma[herd:(Intercept),(Intercept)]")
+    )
+  )
+  expect_equal(
+    find_parameters(m1, flatten = TRUE),
+    c(
+      "(Intercept)",
+      "size",
+      "period2",
+      "period3",
+      "period4",
+      sprintf("b[(Intercept) herd:%i]", 1:15),
+      "Sigma[herd:(Intercept),(Intercept)]"
+    )
+  )
+})
+
+test_that("find_paramaters", {
+  expect_equal(
+    colnames(get_parameters(m1)),
+    c("(Intercept)", "size", "period2", "period3", "period4")
+  )
+  expect_equal(
+    colnames(get_parameters(m1, effects = "all")),
+    c(
+      "(Intercept)",
+      "size",
+      "period2",
+      "period3",
+      "period4",
+      sprintf("b[(Intercept) herd:%i]", 1:15),
+      "Sigma[herd:(Intercept),(Intercept)]"
+    )
+  )
+})
+
+test_that("linkfun", {
+  expect_false(is.null(link_function(m1)))
+})
+
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), plogis(0.2), tolerance = 1e-4)
+})
+
+test_that("get_data", {
+  expect_equal(nrow(get_data(m1)), 56)
+  expect_equal(
+    colnames(get_data(m1)),
+    c("incidence", "size", "period", "herd")
+  )
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1), 2)
+  expect_equal(
+    find_formula(m1),
+    list(
+      conditional = as.formula("cbind(incidence, size - incidence) ~ size + period"),
+      random = as.formula("~1 | herd")
+    ),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("get_variance", {
+  expect_equal(
+    get_variance(m1),
+    list(
+      var.fixed = 0.36274,
+      var.random = 0.5988885,
+      var.residual = 3.28987,
+      var.distribution = 3.28987,
+      var.dispersion = 0,
+      var.intercept = c(herd = 0.59889)
+    ),
+    tolerance = 1e-3
+  )
+
+  expect_equal(get_variance_fixed(m1),
+    c(var.fixed = 0.3627389),
+    tolerance = 1e-4
+  )
+  expect_equal(get_variance_random(m1),
+    c(var.random = 0.5988885),
+    tolerance = 1e-4
+  )
+  expect_equal(get_variance_residual(m1),
+    c(var.residual = 3.289868),
+    tolerance = 1e-4
+  )
+  expect_equal(get_variance_distribution(m1),
+    c(var.distribution = 3.289868),
+    tolerance = 1e-4
+  )
+  expect_equal(get_variance_dispersion(m1),
+    c(var.dispersion = 0),
+    tolerance = 1e-4
+  )
+})
+
+test_that("find_algorithm", {
+  expect_equal(
+    find_algorithm(m1),
+    list(
+      algorithm = "sampling",
+      chains = 2,
+      iterations = 500,
+      warmup = 250
+    )
+  )
+})
+
+test_that("clean_parameters", {
+  expect_equal(
+    clean_parameters(m2),
+    structure(
+      list(
+        Parameter = c(
           "(Intercept)",
-          "size",
-          "period2",
-          "period3",
-          "period4",
-          sprintf("b[(Intercept) herd:%i]", 1:15),
-          "Sigma[herd:(Intercept),(Intercept)]"
-        )
-      )
-    })
-
-    test_that("linkfun", {
-      expect_false(is.null(link_function(m1)))
-    })
-
-    test_that("link_inverse", {
-      expect_equal(link_inverse(m1)(0.2), plogis(0.2), tolerance = 1e-4)
-    })
-
-    test_that("get_data", {
-      expect_equal(nrow(get_data(m1)), 56)
-      expect_equal(
-        colnames(get_data(m1)),
-        c("incidence", "size", "period", "herd")
-      )
-    })
-
-    test_that("find_formula", {
-      expect_length(find_formula(m1), 2)
-      expect_equal(
-        find_formula(m1),
-        list(
-          conditional = as.formula("cbind(incidence, size - incidence) ~ size + period"),
-          random = as.formula("~1 | herd")
+          "Speciesversicolor",
+          "Speciesvirginica",
+          "Petal.Length",
+          "Speciesversicolor:Petal.Length",
+          "Speciesvirginica:Petal.Length",
+          "sigma"
         ),
-        ignore_attr = TRUE
-      )
-    })
-
-    test_that("get_variance", {
-      expect_equal(
-        get_variance(m1),
-        list(
-          var.fixed = 0.36274,
-          var.random = 0.5988885,
-          var.residual = 3.28987,
-          var.distribution = 3.28987,
-          var.dispersion = 0,
-          var.intercept = c(herd = 0.59889)
+        Effects = c(
+          "fixed", "fixed", "fixed",
+          "fixed", "fixed", "fixed", "fixed"
         ),
-        tolerance = 1e-3
-      )
-
-      expect_equal(get_variance_fixed(m1),
-        c(var.fixed = 0.3627389),
-        tolerance = 1e-4
-      )
-      expect_equal(get_variance_random(m1),
-        c(var.random = 0.5988885),
-        tolerance = 1e-4
-      )
-      expect_equal(get_variance_residual(m1),
-        c(var.residual = 3.289868),
-        tolerance = 1e-4
-      )
-      expect_equal(get_variance_distribution(m1),
-        c(var.distribution = 3.289868),
-        tolerance = 1e-4
-      )
-      expect_equal(get_variance_dispersion(m1),
-        c(var.dispersion = 0),
-        tolerance = 1e-4
-      )
-    })
-
-    test_that("find_algorithm", {
-      expect_equal(
-        find_algorithm(m1),
-        list(
-          algorithm = "sampling",
-          chains = 2,
-          iterations = 500,
-          warmup = 250
-        )
-      )
-    })
-
-    test_that("clean_parameters", {
-      expect_equal(
-        clean_parameters(m2),
-        structure(
-          list(
-            Parameter = c(
-              "(Intercept)",
-              "Speciesversicolor",
-              "Speciesvirginica",
-              "Petal.Length",
-              "Speciesversicolor:Petal.Length",
-              "Speciesvirginica:Petal.Length",
-              "sigma"
-            ),
-            Effects = c(
-              "fixed", "fixed", "fixed",
-              "fixed", "fixed", "fixed", "fixed"
-            ),
-            Component = c(
-              "conditional",
-              "conditional",
-              "conditional",
-              "conditional",
-              "conditional",
-              "conditional",
-              "sigma"
-            ),
-            Cleaned_Parameter = c(
-              "(Intercept)",
-              "Speciesversicolor",
-              "Speciesvirginica",
-              "Petal.Length",
-              "Speciesversicolor:Petal.Length",
-              "Speciesvirginica:Petal.Length",
-              "sigma"
-            )
-          ),
-          class = c("clean_parameters", "data.frame"),
-          row.names = c(NA, -7L)
+        Component = c(
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "conditional",
+          "sigma"
         ),
-        ignore_attr = TRUE
-      )
-    })
-
-    test_that("find_statistic", {
-      expect_null(find_statistic(m1))
-      expect_null(find_statistic(m2))
-      expect_null(find_statistic(m3))
-      expect_null(find_statistic(m4))
-      expect_null(find_statistic(m5))
-      expect_null(find_statistic(m6))
-    })
-
-    model <- stan_glm(
-      disp ~ carb,
-      data = mtcars,
-      priors = NULL,
-      prior_intercept = NULL,
-      refresh = 0
-    )
-
-    test_that("flat_priors", {
-      p <- get_priors(model)
-      expect_equal(p$Distribution, c("uniform", "normal"))
-      expect_equal(p$Location, c(NA, 0), tolerance = 1e-3)
-    })
-  }
-}
+        Cleaned_Parameter = c(
+          "(Intercept)",
+          "Speciesversicolor",
+          "Speciesvirginica",
+          "Petal.Length",
+          "Speciesversicolor:Petal.Length",
+          "Speciesvirginica:Petal.Length",
+          "sigma"
+        )
+      ),
+      class = c("clean_parameters", "data.frame"),
+      row.names = c(NA, -7L)
+    ),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_statistic", {
+  expect_null(find_statistic(m1))
+  expect_null(find_statistic(m2))
+  expect_null(find_statistic(m3))
+  expect_null(find_statistic(m4))
+  expect_null(find_statistic(m5))
+  expect_null(find_statistic(m6))
+})
+
+model <- stan_glm(
+  disp ~ carb,
+  data = mtcars,
+  priors = NULL,
+  prior_intercept = NULL,
+  refresh = 0
+)
+
+test_that("flat_priors", {
+  p <- get_priors(model)
+  expect_equal(p$Distribution, c("uniform", "normal"))
+  expect_equal(p$Location, c(NA, 0), tolerance = 1e-3)
+})
+
+unloadNamespace("rstanarm")
diff --git a/tests/testthat/test-spatial.R b/tests/testthat/test-spatial.R
index 26b14ee5a..4d13bbd51 100644
--- a/tests/testthat/test-spatial.R
+++ b/tests/testthat/test-spatial.R
@@ -1,164 +1,163 @@
-if (TRUE) {
-  skip_if_not_or_load_if_installed("glmmTMB")
-  skip_if_not_or_load_if_installed("geoR")
-  skip_if_not_or_load_if_installed("TMB")
-
-  data(ca20)
-  d <- data.frame(
-    x = ca20$coords[, 1],
-    y = ca20$coords[, 2],
-    calcium = ca20$data,
-    elevation = ca20$covariate[, 1],
-    region = factor(ca20$covariate[, 2]),
-    pos = numFactor(scale(ca20$coords[, 1]), scale(ca20$coords[, 2])),
-    ID = factor(rep(1, length(ca20$coords[, 1])))
-  )
-  dat <<- d
-
-  m1 <- download_model("glmmTMB_spatial_1")
-
-  test_that("find_weights", {
-    expect_null(find_weights(m1))
-  })
-
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_linear)
-  })
-
-  test_that("clean_names", {
-    expect_identical(clean_names(m1), c("calcium", "elevation", "region", "pos", "ID"))
-  })
-
-  test_that("find_predictors", {
-    expect_identical(
-      find_predictors(m1, effects = "all"),
-      list(conditional = c("elevation", "region"), random = c("pos", "ID"))
-    )
-    expect_identical(
-      find_predictors(m1, effects = "all", flatten = TRUE),
-      c("elevation", "region", "pos", "ID")
-    )
+skip_if_offline()
+skip_if_not_installed("glmmTMB")
+skip_if_not_installed("geoR")
+skip_if_not_installed("TMB")
+
+data(ca20, package = "geoR")
+d <- data.frame(
+  x = ca20$coords[, 1],
+  y = ca20$coords[, 2],
+  calcium = ca20$data,
+  elevation = ca20$covariate[, 1],
+  region = factor(ca20$covariate[, 2]),
+  pos = glmmTMB::numFactor(scale(ca20$coords[, 1]), scale(ca20$coords[, 2])),
+  ID = factor(rep(1, length(ca20$coords[, 1])))
+)
+dat <<- d
+
+m1 <- download_model("glmmTMB_spatial_1")
+
+test_that("find_weights", {
+  expect_null(find_weights(m1))
+})
+
+test_that("model_info", {
+  expect_true(model_info(m1)$is_linear)
+})
+
+test_that("clean_names", {
+  expect_identical(clean_names(m1), c("calcium", "elevation", "region", "pos", "ID"))
+})
+
+test_that("find_predictors", {
+  expect_identical(
+    find_predictors(m1, effects = "all"),
+    list(conditional = c("elevation", "region"), random = c("pos", "ID"))
+  )
+  expect_identical(
+    find_predictors(m1, effects = "all", flatten = TRUE),
+    c("elevation", "region", "pos", "ID")
+  )
 
-    expect_identical(
-      find_predictors(m1, effects = "random"),
-      list(random = "ID")
-    )
-    expect_identical(find_predictors(m1, effects = "random", flatten = TRUE), "ID")
-  })
+  expect_identical(
+    find_predictors(m1, effects = "random"),
+    list(random = "ID")
+  )
+  expect_identical(find_predictors(m1, effects = "random", flatten = TRUE), "ID")
+})
 
-  test_that("find_response", {
-    expect_identical(find_response(m1), "calcium")
-  })
+test_that("find_response", {
+  expect_identical(find_response(m1), "calcium")
+})
 
-  test_that("link_inverse", {
-    expect_identical(link_inverse(m1)(0.2), 0.2)
-  })
+test_that("link_inverse", {
+  expect_identical(link_inverse(m1)(0.2), 0.2)
+})
 
-  test_that("get_data", {
-    expect_identical(
-      colnames(get_data(m1)),
-      c("calcium", "elevation", "region", "pos", "ID")
-    )
-    expect_identical(
-      colnames(get_data(m1, effects = "all")),
-      c("calcium", "elevation", "region", "pos", "ID")
-    )
-  })
+test_that("get_data", {
+  expect_identical(
+    colnames(get_data(m1)),
+    c("calcium", "elevation", "region", "pos", "ID")
+  )
+  expect_identical(
+    colnames(get_data(m1, effects = "all")),
+    c("calcium", "elevation", "region", "pos", "ID")
+  )
+})
 
-  test_that("find_predictors", {
-    expect_identical(
-      find_predictors(m1, effects = "fixed", component = "conditional"),
-      list(conditional = c("elevation", "region"))
-    )
-    expect_identical(
-      find_predictors(m1),
-      list(conditional = c("elevation", "region"))
-    )
-    expect_identical(
-      find_predictors(m1, effects = "all"),
-      list(
-        conditional = c("elevation", "region"),
-        random = c("pos", "ID")
-      )
-    )
-  })
-
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 2)
-    expect_equal(
-      find_formula(m1),
-      list(
-        conditional = as.formula("calcium ~ elevation + region"),
-        random = as.formula("~pos + 0 | ID")
-      ),
-      ignore_attr = TRUE
+test_that("find_predictors", {
+  expect_identical(
+    find_predictors(m1, effects = "fixed", component = "conditional"),
+    list(conditional = c("elevation", "region"))
+  )
+  expect_identical(
+    find_predictors(m1),
+    list(conditional = c("elevation", "region"))
+  )
+  expect_identical(
+    find_predictors(m1, effects = "all"),
+    list(
+      conditional = c("elevation", "region"),
+      random = c("pos", "ID")
     )
-  })
+  )
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1), 2)
+  expect_equal(
+    find_formula(m1),
+    list(
+      conditional = as.formula("calcium ~ elevation + region"),
+      random = as.formula("~pos + 0 | ID")
+    ),
+    ignore_attr = TRUE
+  )
+})
 
-  test_that("find_random", {
-    expect_identical(
-      find_random(m1),
-      list(random = "ID")
-    )
-  })
-
-  test_that("find_terms", {
-    expect_identical(
-      find_terms(m1),
-      list(
-        response = "calcium",
-        conditional = c("elevation", "region"),
-        random = c("pos", "ID")
-      )
+test_that("find_random", {
+  expect_identical(
+    find_random(m1),
+    list(random = "ID")
+  )
+})
+
+test_that("find_terms", {
+  expect_identical(
+    find_terms(m1),
+    list(
+      response = "calcium",
+      conditional = c("elevation", "region"),
+      random = c("pos", "ID")
     )
-  })
-
-  test_that("find_variables", {
-    expect_identical(
-      find_variables(m1),
-      list(
-        response = "calcium",
-        conditional = c("elevation", "region"),
-        random = c("pos", "ID")
-      )
+  )
+})
+
+test_that("find_variables", {
+  expect_identical(
+    find_variables(m1),
+    list(
+      response = "calcium",
+      conditional = c("elevation", "region"),
+      random = c("pos", "ID")
     )
-  })
+  )
+})
 
 
-  test_that("get_predictors", {
-    expect_identical(
-      colnames(get_predictors(m1)),
-      c("elevation", "region")
-    )
-  })
+test_that("get_predictors", {
+  expect_identical(
+    colnames(get_predictors(m1)),
+    c("elevation", "region")
+  )
+})
 
-  test_that("get_random", {
-    expect_identical(colnames(get_random(m1)), "ID")
-  })
+test_that("get_random", {
+  expect_identical(colnames(get_random(m1)), "ID")
+})
 
-  test_that("get_data", {
-    expect_identical(
-      colnames(get_data(m1)),
-      c("calcium", "elevation", "region", "pos", "ID")
-    )
-  })
+test_that("get_data", {
+  expect_identical(
+    colnames(get_data(m1)),
+    c("calcium", "elevation", "region", "pos", "ID")
+  )
+})
 
 
-  test_that("get_paramaters", {
-    expect_identical(nrow(get_parameters(m1)), 5L)
-    expect_identical(
-      get_parameters(m1)$Parameter,
-      c("(Intercept)", "elevation", "region2", "region3", "(Intercept)")
-    )
-  })
+test_that("get_paramaters", {
+  expect_identical(nrow(get_parameters(m1)), 5L)
+  expect_identical(
+    get_parameters(m1)$Parameter,
+    c("(Intercept)", "elevation", "region2", "region3", "(Intercept)")
+  )
+})
 
-  test_that("find_random_slopes", {
-    skip_on_cran()
+test_that("find_random_slopes", {
+  skip_on_cran()
 
 
-    expect_identical(
-      find_random_slopes(m1),
-      list(random = "pos")
-    )
-  })
-}
+  expect_identical(
+    find_random_slopes(m1),
+    list(random = "pos")
+  )
+})
diff --git a/tests/testthat/test-standardize_names.R b/tests/testthat/test-standardize_names.R
index 2f3fff554..b92b1053d 100644
--- a/tests/testthat/test-standardize_names.R
+++ b/tests/testthat/test-standardize_names.R
@@ -1,5 +1,5 @@
 test_that("standardize_names works as expected with parameters", {
-  skip_if_not_or_load_if_installed("parameters")
+  skip_if_not_installed("parameters")
 
   set.seed(123)
 
@@ -55,7 +55,7 @@ test_that("standardize_names works as expected with parameters", {
 
 
 test_that("standardize_names works as expected with performance", {
-  skip_if_not_or_load_if_installed("performance")
+  skip_if_not_installed("performance")
   set.seed(123)
 
   # lm object
@@ -72,7 +72,7 @@ test_that("standardize_names works as expected with performance", {
 })
 
 test_that("standardize_names works as expected with datawizard", {
-  skip_if_not_or_load_if_installed("datawizard")
+  skip_if_not_installed("datawizard")
   set.seed(123)
 
   x <- datawizard::describe_distribution(rnorm(50))
diff --git a/tests/testthat/test-survey.R b/tests/testthat/test-survey.R
index 9d2ec3786..93eb08b88 100644
--- a/tests/testthat/test-survey.R
+++ b/tests/testthat/test-survey.R
@@ -1,88 +1,88 @@
-if (skip_if_not_or_load_if_installed("survey")) {
-  data(api)
-  dstrat <-
-    svydesign(
-      id = ~1,
-      strata = ~stype,
-      weights = ~pw,
-      data = apistrat,
-      fpc = ~fpc
-    )
+skip_if_not_installed("survey")
 
-  m1 <- svyglm(api00 ~ ell + meals + mobility, design = dstrat)
+data(api, package = "survey")
+dstrat <-
+  survey::svydesign(
+    id = ~1,
+    strata = ~stype,
+    weights = ~pw,
+    data = apistrat,
+    fpc = ~fpc
+  )
 
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_linear)
-  })
+m1 <- survey::svyglm(api00 ~ ell + meals + mobility, design = dstrat)
 
-  test_that("find_predictors", {
-    expect_identical(find_predictors(m1), list(conditional = c("ell", "meals", "mobility")))
-    expect_null(find_predictors(m1, effects = "random"))
-  })
+test_that("model_info", {
+  expect_true(model_info(m1)$is_linear)
+})
 
-  test_that("find_response", {
-    expect_identical(find_response(m1), "api00")
-  })
+test_that("find_predictors", {
+  expect_identical(find_predictors(m1), list(conditional = c("ell", "meals", "mobility")))
+  expect_null(find_predictors(m1, effects = "random"))
+})
 
-  test_that("get_response", {
-    expect_equal(get_response(m1), apistrat$api00)
-  })
+test_that("find_response", {
+  expect_identical(find_response(m1), "api00")
+})
 
-  test_that("link_inverse", {
-    expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
-  })
+test_that("get_response", {
+  expect_equal(get_response(m1), apistrat$api00)
+})
 
-  test_that("get_data", {
-    expect_equal(nrow(get_data(m1, verbose = FALSE)), 200)
-    expect_equal(
-      colnames(get_data(m1, verbose = FALSE)),
-      c("api00", "ell", "meals", "mobility", "(weights)")
-    )
-  })
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
+})
 
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 1)
-    expect_equal(
-      find_formula(m1),
-      list(conditional = as.formula("api00 ~ ell + meals + mobility")),
-      ignore_attr = TRUE
-    )
-  })
+test_that("get_data", {
+  expect_equal(nrow(get_data(m1, verbose = FALSE)), 200)
+  expect_equal(
+    colnames(get_data(m1, verbose = FALSE)),
+    c("api00", "ell", "meals", "mobility", "(weights)")
+  )
+})
 
-  test_that("find_terms", {
-    expect_equal(find_terms(m1), list(
-      response = "api00",
-      conditional = c("ell", "meals", "mobility")
-    ))
-    expect_equal(
-      find_terms(m1, flatten = TRUE),
-      c("api00", "ell", "meals", "mobility")
-    )
-  })
+test_that("find_formula", {
+  expect_length(find_formula(m1), 1)
+  expect_equal(
+    find_formula(m1),
+    list(conditional = as.formula("api00 ~ ell + meals + mobility")),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_terms", {
+  expect_equal(find_terms(m1), list(
+    response = "api00",
+    conditional = c("ell", "meals", "mobility")
+  ))
+  expect_equal(
+    find_terms(m1, flatten = TRUE),
+    c("api00", "ell", "meals", "mobility")
+  )
+})
 
-  test_that("n_obs", {
-    expect_equal(n_obs(m1), 200)
-  })
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 200)
+})
 
-  test_that("linkfun", {
-    expect_false(is.null(link_function(m1)))
-  })
+test_that("linkfun", {
+  expect_false(is.null(link_function(m1)))
+})
 
-  test_that("find_parameters", {
-    expect_equal(
-      find_parameters(m1),
-      list(conditional = c(
-        "(Intercept)", "ell", "meals", "mobility"
-      ))
-    )
-    expect_equal(nrow(get_parameters(m1)), 4)
-    expect_equal(
-      get_parameters(m1)$Parameter,
-      c("(Intercept)", "ell", "meals", "mobility")
-    )
-  })
+test_that("find_parameters", {
+  expect_equal(
+    find_parameters(m1),
+    list(conditional = c(
+      "(Intercept)", "ell", "meals", "mobility"
+    ))
+  )
+  expect_equal(nrow(get_parameters(m1)), 4)
+  expect_equal(
+    get_parameters(m1)$Parameter,
+    c("(Intercept)", "ell", "meals", "mobility")
+  )
+})
 
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "t-statistic")
-  })
-}
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "t-statistic")
+})
diff --git a/tests/testthat/test-survfit.R b/tests/testthat/test-survfit.R
index 85b5329c5..a04b5a3c2 100644
--- a/tests/testthat/test-survfit.R
+++ b/tests/testthat/test-survfit.R
@@ -1,78 +1,78 @@
-if (skip_if_not_or_load_if_installed("survival")) {
-  m1 <- survfit(Surv(time, status) ~ sex + age + ph.ecog, data = lung)
+skip_if_not_installed("survival")
 
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_logit)
-    expect_false(model_info(m1)$is_linear)
-  })
+m1 <- survival::survfit(survival::Surv(time, status) ~ sex + age + ph.ecog, data = survival::lung)
 
-  test_that("find_predictors", {
-    expect_identical(find_predictors(m1), list(conditional = c("sex", "age", "ph.ecog")))
-    expect_null(find_predictors(m1, effects = "random"))
-  })
+test_that("model_info", {
+  expect_true(model_info(m1)$is_logit)
+  expect_false(model_info(m1)$is_linear)
+})
 
-  test_that("find_response", {
-    expect_identical(find_response(m1), "Surv(time, status)")
-    expect_identical(find_response(m1, combine = FALSE), c("time", "status"))
-  })
+test_that("find_predictors", {
+  expect_identical(find_predictors(m1), list(conditional = c("sex", "age", "ph.ecog")))
+  expect_null(find_predictors(m1, effects = "random"))
+})
 
-  test_that("link_inverse", {
-    expect_equal(link_inverse(m1)(0.2), plogis(0.2), tolerance = 1e-5)
-  })
+test_that("find_response", {
+  expect_identical(find_response(m1), "survival::Surv(time, status)")
+  expect_identical(find_response(m1, combine = FALSE), c("time", "status"))
+})
 
-  test_that("get_data", {
-    expect_equal(nrow(get_data(m1)), 227)
-    expect_equal(
-      colnames(get_data(m1)),
-      c("time", "status", "sex", "age", "ph.ecog")
-    )
-  })
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), plogis(0.2), tolerance = 1e-5)
+})
 
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 1)
-    expect_equal(
-      find_formula(m1),
-      list(conditional = as.formula(
-        "Surv(time, status) ~ sex + age + ph.ecog"
-      )),
-      ignore_attr = TRUE
-    )
-  })
+test_that("get_data", {
+  expect_equal(nrow(get_data(m1)), 227)
+  expect_equal(
+    colnames(get_data(m1)),
+    c("time", "status", "sex", "age", "ph.ecog")
+  )
+})
 
-  test_that("find_variables", {
-    expect_equal(find_variables(m1), list(
-      response = c("time", "status"),
-      conditional = c("sex", "age", "ph.ecog")
-    ))
-    expect_equal(
-      find_variables(m1, flatten = TRUE),
-      c("time", "status", "sex", "age", "ph.ecog")
-    )
-  })
+test_that("find_formula", {
+  expect_length(find_formula(m1), 1)
+  expect_equal(
+    find_formula(m1),
+    list(conditional = as.formula(
+      "survival::Surv(time, status) ~ sex + age + ph.ecog"
+    )),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_variables", {
+  expect_equal(find_variables(m1), list(
+    response = c("time", "status"),
+    conditional = c("sex", "age", "ph.ecog")
+  ))
+  expect_equal(
+    find_variables(m1, flatten = TRUE),
+    c("time", "status", "sex", "age", "ph.ecog")
+  )
+})
 
-  test_that("n_obs", {
-    expect_equal(n_obs(m1), 227)
-  })
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 227)
+})
 
-  test_that("linkfun", {
-    expect_false(is.null(link_function(m1)))
-  })
+test_that("linkfun", {
+  expect_false(is.null(link_function(m1)))
+})
 
-  test_that("is_multivariate", {
-    expect_false(is_multivariate(m1))
-  })
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1))
+})
 
-  test_that("find_terms", {
-    expect_equal(
-      find_terms(m1),
-      list(
-        response = "Surv(time, status)",
-        conditional = c("sex", "age", "ph.ecog")
-      )
+test_that("find_terms", {
+  expect_equal(
+    find_terms(m1),
+    list(
+      response = "Surv(time, status)",
+      conditional = c("sex", "age", "ph.ecog")
     )
-  })
+  )
+})
 
-  test_that("find_statistic", {
-    expect_null(find_statistic(m1))
-  })
-}
+test_that("find_statistic", {
+  expect_null(find_statistic(m1))
+})
diff --git a/tests/testthat/test-survreg.R b/tests/testthat/test-survreg.R
index bf337e043..3ad77d6db 100644
--- a/tests/testthat/test-survreg.R
+++ b/tests/testthat/test-survreg.R
@@ -1,10 +1,14 @@
-skip_if_not_or_load_if_installed("survival")
+skip_if_not_installed("survival")
 
-mod_survreg_1 <- survreg(Surv(futime, fustat) ~ ecog.ps + rx,
+Surv <- survival::Surv
+strata <- survival::strata
+ovarian <<- survival::ovarian
+
+mod_survreg_1 <- survival::survreg(Surv(futime, fustat) ~ ecog.ps + rx,
   data = ovarian,
   dist = "exponential"
 )
-mod_survreg_2 <- survreg(Surv(time, status) ~ ph.ecog + age + strata(sex), data = lung)
+mod_survreg_2 <- survival::survreg(Surv(time, status) ~ ph.ecog + age + strata(sex), data = survival::lung)
 
 test_that("model_info", {
   expect_false(model_info(mod_survreg_1)$is_linear)
diff --git a/tests/testthat/test-tidymodels.R b/tests/testthat/test-tidymodels.R
index f2b8837a1..984f8221f 100644
--- a/tests/testthat/test-tidymodels.R
+++ b/tests/testthat/test-tidymodels.R
@@ -1,143 +1,141 @@
-if (skip_if_not_or_load_if_installed("parsnip")) {
-  data(mtcars)
+skip_if_not_installed("parsnip")
 
-  m <- parsnip::linear_reg()
-  m <- parsnip::set_engine(m, "lm")
-  m <- parsnip::set_mode(m, "regression")
-  m <- parsnip::fit(m, mpg ~ am + vs, data = mtcars)
+m <- parsnip::linear_reg()
+m <- parsnip::set_engine(m, "lm")
+m <- parsnip::set_mode(m, "regression")
+m <- parsnip::fit(m, mpg ~ am + vs, data = mtcars)
 
-  test_that("find_formula", {
-    expect_equal(
-      find_formula(m),
-      list(conditional = as.formula("mpg ~ am + vs")),
-      ignore_attr = TRUE
-    )
-  })
+test_that("find_formula", {
+  expect_equal(
+    find_formula(m),
+    list(conditional = as.formula("mpg ~ am + vs")),
+    ignore_attr = TRUE
+  )
+})
 
-  # test_that("model_info", {
-  #   expect_true(model_info(m1)$is_poisson)
-  #   expect_true(model_info(m1)$is_count)
-  #   expect_false(model_info(m1)$is_negbin)
-  #   expect_false(model_info(m1)$is_binomial)
-  #   expect_false(model_info(m1)$is_linear)
-  # })
-  #
-  # test_that("loglik", {
-  #   expect_equal(get_loglikelihood(m1), logLik(m1), ignore_attr = TRUE)
-  # })
-  #
-  # test_that("get_df", {
-  #   expect_equal(get_df(m1), df.residual(m1), ignore_attr = TRUE)
-  #   expect_equal(get_df(m1, type = "model"), attr(logLik(m1), "df"), ignore_attr = TRUE)
-  # })
-  #
-  #
-  # test_that("find_predictors", {
-  #   expect_identical(find_predictors(m1), list(conditional = c("mined", "cover", "sample")))
-  #   expect_identical(
-  #     find_predictors(m1, flatten = TRUE),
-  #     c("mined", "cover", "sample")
-  #   )
-  #   expect_null(find_predictors(m1, effects = "random"))
-  # })
-  #
-  # test_that("find_random", {
-  #   expect_null(find_random(m1))
-  # })
-  #
-  # test_that("get_random", {
-  #   expect_warning(get_random(m1))
-  # })
-  #
-  # test_that("find_response", {
-  #   expect_identical(find_response(m1), "count")
-  # })
-  #
-  # test_that("get_response", {
-  #   expect_equal(get_response(m1), Salamanders$count)
-  # })
-  #
-  # test_that("get_predictors", {
-  #   expect_equal(colnames(get_predictors(m1)), c("mined", "cover", "sample"))
-  # })
-  #
-  # test_that("link_inverse", {
-  #   expect_equal(link_inverse(m1)(0.2), exp(0.2), tolerance = 1e-5)
-  # })
-  #
-  # test_that("linkfun", {
-  #   expect_equal(link_function(m1)(0.2), -1.609438, tolerance = 1e-4)
-  # })
-  #
-  # test_that("get_data", {
-  #   expect_equal(nrow(get_data(m1)), 644)
-  #   expect_equal(
-  #     colnames(get_data(m1)),
-  #     c("count", "mined", "cover", "sample")
-  #   )
-  # })
-  #
-  # test_that("get_call", {
-  #   expect_equal(class(get_call(m1)), "call")
-  # })
-  #
-  #
-  #
-  # test_that("find_variables", {
-  #   expect_equal(
-  #     find_variables(m1),
-  #     list(
-  #       response = "count",
-  #       conditional = c("mined", "cover", "sample")
-  #     )
-  #   )
-  #   expect_equal(
-  #     find_variables(m1, flatten = TRUE),
-  #     c("count", "mined", "cover", "sample")
-  #   )
-  # })
-  #
-  # test_that("n_obs", {
-  #   expect_equal(n_obs(m1), 644)
-  # })
-  #
-  # test_that("find_parameters", {
-  #   expect_equal(
-  #     find_parameters(m1),
-  #     list(
-  #       conditional = c("(Intercept)", "minedno", "log(cover)", "sample")
-  #     )
-  #   )
-  #   expect_equal(nrow(get_parameters(m1)), 4)
-  #   expect_equal(
-  #     get_parameters(m1)$Parameter,
-  #     c("(Intercept)", "minedno", "log(cover)", "sample")
-  #   )
-  # })
-  #
-  # test_that("is_multivariate", {
-  #   expect_false(is_multivariate(m1))
-  # })
-  #
-  # test_that("find_terms", {
-  #   expect_equal(
-  #     find_terms(m1),
-  #     list(
-  #       response = "count",
-  #       conditional = c("mined", "log(cover)", "sample")
-  #     )
-  #   )
-  # })
-  #
-  # test_that("find_algorithm", {
-  #   expect_equal(find_algorithm(m1), list(algorithm = "ML"))
-  # })
-  #
-  # test_that("find_statistic", {
-  #   expect_identical(find_statistic(m1), "z-statistic")
-  # })
-  #
-  # test_that("get_statistic", {
-  #   expect_equal(get_statistic(m1)$Statistic, c(-10.7066515607315, 18.1533878215937, -1.68918157150882, 2.23541768590273), tolerance = 1e-4)
-  # })
-}
+# test_that("model_info", {
+#   expect_true(model_info(m1)$is_poisson)
+#   expect_true(model_info(m1)$is_count)
+#   expect_false(model_info(m1)$is_negbin)
+#   expect_false(model_info(m1)$is_binomial)
+#   expect_false(model_info(m1)$is_linear)
+# })
+#
+# test_that("loglik", {
+#   expect_equal(get_loglikelihood(m1), logLik(m1), ignore_attr = TRUE)
+# })
+#
+# test_that("get_df", {
+#   expect_equal(get_df(m1), df.residual(m1), ignore_attr = TRUE)
+#   expect_equal(get_df(m1, type = "model"), attr(logLik(m1), "df"), ignore_attr = TRUE)
+# })
+#
+#
+# test_that("find_predictors", {
+#   expect_identical(find_predictors(m1), list(conditional = c("mined", "cover", "sample")))
+#   expect_identical(
+#     find_predictors(m1, flatten = TRUE),
+#     c("mined", "cover", "sample")
+#   )
+#   expect_null(find_predictors(m1, effects = "random"))
+# })
+#
+# test_that("find_random", {
+#   expect_null(find_random(m1))
+# })
+#
+# test_that("get_random", {
+#   expect_warning(get_random(m1))
+# })
+#
+# test_that("find_response", {
+#   expect_identical(find_response(m1), "count")
+# })
+#
+# test_that("get_response", {
+#   expect_equal(get_response(m1), Salamanders$count)
+# })
+#
+# test_that("get_predictors", {
+#   expect_equal(colnames(get_predictors(m1)), c("mined", "cover", "sample"))
+# })
+#
+# test_that("link_inverse", {
+#   expect_equal(link_inverse(m1)(0.2), exp(0.2), tolerance = 1e-5)
+# })
+#
+# test_that("linkfun", {
+#   expect_equal(link_function(m1)(0.2), -1.609438, tolerance = 1e-4)
+# })
+#
+# test_that("get_data", {
+#   expect_equal(nrow(get_data(m1)), 644)
+#   expect_equal(
+#     colnames(get_data(m1)),
+#     c("count", "mined", "cover", "sample")
+#   )
+# })
+#
+# test_that("get_call", {
+#   expect_equal(class(get_call(m1)), "call")
+# })
+#
+#
+#
+# test_that("find_variables", {
+#   expect_equal(
+#     find_variables(m1),
+#     list(
+#       response = "count",
+#       conditional = c("mined", "cover", "sample")
+#     )
+#   )
+#   expect_equal(
+#     find_variables(m1, flatten = TRUE),
+#     c("count", "mined", "cover", "sample")
+#   )
+# })
+#
+# test_that("n_obs", {
+#   expect_equal(n_obs(m1), 644)
+# })
+#
+# test_that("find_parameters", {
+#   expect_equal(
+#     find_parameters(m1),
+#     list(
+#       conditional = c("(Intercept)", "minedno", "log(cover)", "sample")
+#     )
+#   )
+#   expect_equal(nrow(get_parameters(m1)), 4)
+#   expect_equal(
+#     get_parameters(m1)$Parameter,
+#     c("(Intercept)", "minedno", "log(cover)", "sample")
+#   )
+# })
+#
+# test_that("is_multivariate", {
+#   expect_false(is_multivariate(m1))
+# })
+#
+# test_that("find_terms", {
+#   expect_equal(
+#     find_terms(m1),
+#     list(
+#       response = "count",
+#       conditional = c("mined", "log(cover)", "sample")
+#     )
+#   )
+# })
+#
+# test_that("find_algorithm", {
+#   expect_equal(find_algorithm(m1), list(algorithm = "ML"))
+# })
+#
+# test_that("find_statistic", {
+#   expect_identical(find_statistic(m1), "z-statistic")
+# })
+#
+# test_that("get_statistic", {
+#   expect_equal(get_statistic(m1)$Statistic, c(-10.7066515607315, 18.1533878215937, -1.68918157150882, 2.23541768590273), tolerance = 1e-4)
+# })
diff --git a/tests/testthat/test-tobit.R b/tests/testthat/test-tobit.R
index 7406fee3a..318d5c85f 100644
--- a/tests/testthat/test-tobit.R
+++ b/tests/testthat/test-tobit.R
@@ -1,4 +1,4 @@
-skip_if_not_or_load_if_installed("AER")
+skip_if_not_installed("AER")
 
 data("Affairs", package = "AER")
 m1 <- AER::tobit(
diff --git a/tests/testthat/test-truncreg.R b/tests/testthat/test-truncreg.R
index 8c8149575..5688f537d 100644
--- a/tests/testthat/test-truncreg.R
+++ b/tests/testthat/test-truncreg.R
@@ -1,70 +1,71 @@
-if (skip_if_not_or_load_if_installed("truncreg") && skip_if_not_or_load_if_installed("survival")) {
-  data("tobin", package = "survival")
-  m1 <- truncreg(durable ~ age + quant, data = tobin, subset = durable > 0)
+skip_if_not_installed("truncreg")
+skip_if_not_installed("survival")
 
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_linear)
-  })
+data("tobin", package = "survival")
+m1 <- truncreg::truncreg(durable ~ age + quant, data = tobin, subset = durable > 0)
 
-  test_that("find_predictors", {
-    expect_identical(find_predictors(m1), list(conditional = c("age", "quant")))
-    expect_identical(find_predictors(m1, flatten = TRUE), c("age", "quant"))
-    expect_null(find_predictors(m1, effects = "random"))
-  })
+test_that("model_info", {
+  expect_true(model_info(m1)$is_linear)
+})
 
-  test_that("find_response", {
-    expect_identical(find_response(m1), "durable")
-  })
+test_that("find_predictors", {
+  expect_identical(find_predictors(m1), list(conditional = c("age", "quant")))
+  expect_identical(find_predictors(m1, flatten = TRUE), c("age", "quant"))
+  expect_null(find_predictors(m1, effects = "random"))
+})
 
-  test_that("link_inverse", {
-    expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
-  })
+test_that("find_response", {
+  expect_identical(find_response(m1), "durable")
+})
 
-  test_that("get_data", {
-    expect_equal(nrow(get_data(m1)), 7)
-    expect_equal(colnames(get_data(m1)), c("durable", "age", "quant"))
-  })
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
+})
 
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 1)
-    expect_equal(
-      find_formula(m1),
-      list(conditional = as.formula("durable ~ age + quant")),
-      ignore_attr = TRUE
-    )
-  })
+test_that("get_data", {
+  expect_equal(nrow(get_data(m1)), 7)
+  expect_equal(colnames(get_data(m1)), c("durable", "age", "quant"))
+})
 
-  test_that("find_terms", {
-    expect_equal(find_terms(m1), list(
-      response = "durable",
-      conditional = c("age", "quant")
-    ))
-    expect_equal(find_terms(m1, flatten = TRUE), c("durable", "age", "quant"))
-  })
+test_that("find_formula", {
+  expect_length(find_formula(m1), 1)
+  expect_equal(
+    find_formula(m1),
+    list(conditional = as.formula("durable ~ age + quant")),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_terms", {
+  expect_equal(find_terms(m1), list(
+    response = "durable",
+    conditional = c("age", "quant")
+  ))
+  expect_equal(find_terms(m1, flatten = TRUE), c("durable", "age", "quant"))
+})
 
-  test_that("n_obs", {
-    expect_equal(n_obs(m1), 7)
-  })
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 7)
+})
 
-  test_that("linkfun", {
-    expect_false(is.null(link_function(m1)))
-  })
+test_that("linkfun", {
+  expect_false(is.null(link_function(m1)))
+})
 
-  test_that("find_parameters", {
-    expect_equal(
-      find_parameters(m1),
-      list(conditional = c(
-        "(Intercept)", "age", "quant", "sigma"
-      ))
-    )
-    expect_equal(nrow(get_parameters(m1)), 4)
-    expect_equal(
-      get_parameters(m1)$Parameter,
-      c("(Intercept)", "age", "quant", "sigma")
-    )
-  })
+test_that("find_parameters", {
+  expect_equal(
+    find_parameters(m1),
+    list(conditional = c(
+      "(Intercept)", "age", "quant", "sigma"
+    ))
+  )
+  expect_equal(nrow(get_parameters(m1)), 4)
+  expect_equal(
+    get_parameters(m1)$Parameter,
+    c("(Intercept)", "age", "quant", "sigma")
+  )
+})
 
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "t-statistic")
-  })
-}
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "t-statistic")
+})
diff --git a/tests/testthat/test-vgam.R b/tests/testthat/test-vgam.R
index c6100a7ad..ee87a3a60 100644
--- a/tests/testthat/test-vgam.R
+++ b/tests/testthat/test-vgam.R
@@ -1,199 +1,201 @@
-if (skip_if_not_or_load_if_installed("VGAM")) {
-  data("hunua")
-  m1 <- download_model("vgam_1")
-  m2 <- download_model("vgam_2")
-
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_binomial)
-    expect_true(model_info(m2)$is_binomial)
-    expect_false(model_info(m1)$is_bayesian)
-    expect_false(model_info(m2)$is_bayesian)
-  })
-
-  test_that("find_predictors", {
-    expect_identical(find_predictors(m1), list(conditional = c("vitluc", "altitude")))
-    expect_identical(
-      find_predictors(m1, flatten = TRUE),
-      c("vitluc", "altitude")
-    )
-    expect_null(find_predictors(m1, effects = "random"))
-    expect_identical(find_predictors(m2), list(conditional = c("vitluc", "altitude")))
-    expect_identical(
-      find_predictors(m2, flatten = TRUE),
-      c("vitluc", "altitude")
-    )
-    expect_null(find_predictors(m2, effects = "random"))
-  })
-
-  test_that("find_random", {
-    expect_null(find_random(m1))
-    expect_null(find_random(m2))
-  })
-
-  test_that("get_random", {
-    expect_warning(get_random(m1))
-    expect_warning(get_random(m2))
-  })
-
-  test_that("find_response", {
-    expect_identical(find_response(m1), "agaaus")
-    expect_identical(find_response(m2), "cbind(agaaus, kniexc)")
-    expect_identical(find_response(m2, combine = FALSE), c("agaaus", "kniexc"))
-  })
-
-  test_that("get_response", {
-    expect_equal(get_response(m1), hunua$agaaus)
-    expect_equal(
-      get_response(m2),
-      data.frame(agaaus = hunua$agaaus, kniexc = hunua$kniexc)
-    )
-  })
-
-  test_that("get_predictors", {
-    expect_equal(colnames(get_predictors(m1)), c("vitluc", "altitude"))
-    expect_equal(colnames(get_predictors(m2)), c("vitluc", "altitude"))
-  })
-
-  test_that("link_inverse", {
-    expect_equal(link_inverse(m1)(0.2), plogis(0.2), tolerance = 1e-5)
-    expect_equal(link_inverse(m2)(0.2), plogis(0.2), tolerance = 1e-5)
-  })
-
-  test_that("get_data", {
-    expect_equal(nrow(get_data(m1)), 392)
-    expect_equal(nrow(get_data(m2)), 392)
-    expect_equal(colnames(get_data(m1)), c("agaaus", "vitluc", "altitude"))
-    expect_equal(
-      colnames(get_data(m2)),
-      c("agaaus", "kniexc", "vitluc", "altitude")
-    )
-  })
-
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 1)
-    expect_equal(
-      find_formula(m1),
-      list(conditional = as.formula("agaaus ~ vitluc + s(altitude, df = 2)")),
-      ignore_attr = TRUE
-    )
-    expect_length(find_formula(m2), 1)
-    expect_equal(
-      find_formula(m2),
-      list(
-        conditional = as.formula("cbind(agaaus, kniexc) ~ vitluc + s(altitude, df = c(2, 3))")
-      ),
-      ignore_attr = TRUE
-    )
-  })
-
-  test_that("find_terms", {
-    expect_equal(
-      find_terms(m1),
-      list(
-        response = "agaaus",
-        conditional = c("vitluc", "s(altitude, df = 2)")
-      )
-    )
-    expect_equal(
-      find_terms(m1, flatten = TRUE),
-      c("agaaus", "vitluc", "s(altitude, df = 2)")
-    )
-    expect_equal(
-      find_terms(m2),
-      list(
-        response = "cbind(agaaus, kniexc)",
-        conditional = c("vitluc", "s(altitude, df = c(2, 3))")
-      )
-    )
-    expect_equal(
-      find_terms(m2, flatten = TRUE),
-      c(
-        "cbind(agaaus, kniexc)",
-        "vitluc",
-        "s(altitude, df = c(2, 3))"
-      )
-    )
-  })
-
-  test_that("find_variables", {
-    expect_equal(
-      find_variables(m1),
-      list(
-        response = "agaaus",
-        conditional = c("vitluc", "altitude")
-      )
-    )
-    expect_equal(
-      find_variables(m1, flatten = TRUE),
-      c("agaaus", "vitluc", "altitude")
-    )
-    expect_equal(find_variables(m2), list(
-      response = c("agaaus", "kniexc"),
+skip_if_offline()
+skip_if_not_installed("VGAM")
+
+data("hunua", package = "VGAM")
+
+m1 <- download_model("vgam_1")
+m2 <- download_model("vgam_2")
+
+test_that("model_info", {
+  expect_true(model_info(m1)$is_binomial)
+  expect_true(model_info(m2)$is_binomial)
+  expect_false(model_info(m1)$is_bayesian)
+  expect_false(model_info(m2)$is_bayesian)
+})
+
+test_that("find_predictors", {
+  expect_identical(find_predictors(m1), list(conditional = c("vitluc", "altitude")))
+  expect_identical(
+    find_predictors(m1, flatten = TRUE),
+    c("vitluc", "altitude")
+  )
+  expect_null(find_predictors(m1, effects = "random"))
+  expect_identical(find_predictors(m2), list(conditional = c("vitluc", "altitude")))
+  expect_identical(
+    find_predictors(m2, flatten = TRUE),
+    c("vitluc", "altitude")
+  )
+  expect_null(find_predictors(m2, effects = "random"))
+})
+
+test_that("find_random", {
+  expect_null(find_random(m1))
+  expect_null(find_random(m2))
+})
+
+test_that("get_random", {
+  expect_warning(get_random(m1))
+  expect_warning(get_random(m2))
+})
+
+test_that("find_response", {
+  expect_identical(find_response(m1), "agaaus")
+  expect_identical(find_response(m2), "cbind(agaaus, kniexc)")
+  expect_identical(find_response(m2, combine = FALSE), c("agaaus", "kniexc"))
+})
+
+test_that("get_response", {
+  expect_equal(get_response(m1), hunua$agaaus)
+  expect_equal(
+    get_response(m2),
+    data.frame(agaaus = hunua$agaaus, kniexc = hunua$kniexc)
+  )
+})
+
+test_that("get_predictors", {
+  expect_equal(colnames(get_predictors(m1)), c("vitluc", "altitude"))
+  expect_equal(colnames(get_predictors(m2)), c("vitluc", "altitude"))
+})
+
+test_that("link_inverse", {
+  expect_equal(link_inverse(m1)(0.2), plogis(0.2), tolerance = 1e-5)
+  expect_equal(link_inverse(m2)(0.2), plogis(0.2), tolerance = 1e-5)
+})
+
+test_that("get_data", {
+  expect_equal(nrow(get_data(m1)), 392)
+  expect_equal(nrow(get_data(m2)), 392)
+  expect_equal(colnames(get_data(m1)), c("agaaus", "vitluc", "altitude"))
+  expect_equal(
+    colnames(get_data(m2)),
+    c("agaaus", "kniexc", "vitluc", "altitude")
+  )
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1), 1)
+  expect_equal(
+    find_formula(m1),
+    list(conditional = as.formula("agaaus ~ vitluc + s(altitude, df = 2)")),
+    ignore_attr = TRUE
+  )
+  expect_length(find_formula(m2), 1)
+  expect_equal(
+    find_formula(m2),
+    list(
+      conditional = as.formula("cbind(agaaus, kniexc) ~ vitluc + s(altitude, df = c(2, 3))")
+    ),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_terms", {
+  expect_equal(
+    find_terms(m1),
+    list(
+      response = "agaaus",
+      conditional = c("vitluc", "s(altitude, df = 2)")
+    )
+  )
+  expect_equal(
+    find_terms(m1, flatten = TRUE),
+    c("agaaus", "vitluc", "s(altitude, df = 2)")
+  )
+  expect_equal(
+    find_terms(m2),
+    list(
+      response = "cbind(agaaus, kniexc)",
+      conditional = c("vitluc", "s(altitude, df = c(2, 3))")
+    )
+  )
+  expect_equal(
+    find_terms(m2, flatten = TRUE),
+    c(
+      "cbind(agaaus, kniexc)",
+      "vitluc",
+      "s(altitude, df = c(2, 3))"
+    )
+  )
+})
+
+test_that("find_variables", {
+  expect_equal(
+    find_variables(m1),
+    list(
+      response = "agaaus",
       conditional = c("vitluc", "altitude")
-    ))
-    expect_equal(
-      find_variables(m2, flatten = TRUE),
-      c("agaaus", "kniexc", "vitluc", "altitude")
-    )
-  })
-
-  test_that("n_obs", {
-    expect_equal(n_obs(m1), 392)
-    expect_equal(n_obs(m2), 392)
-  })
-
-  test_that("linkfun", {
-    expect_false(is.null(link_function(m1)))
-    expect_false(is.null(link_function(m2)))
-  })
-
-  test_that("find_parameters", {
-    expect_equal(
-      find_parameters(m1),
-      list(
-        conditional = c("(Intercept)", "vitluc"),
-        smooth_terms = "s(altitude, df = 2)"
-      )
-    )
-    expect_equal(nrow(get_parameters(m1)), 3)
-    expect_equal(
-      get_parameters(m1)$Parameter,
-      c("(Intercept)", "vitluc", "s(altitude, df = 2)")
     )
-
-    expect_equal(
-      find_parameters(m2),
-      list(
-        conditional = c(
-          "(Intercept):1",
-          "(Intercept):2",
-          "vitluc:1",
-          "vitluc:2"
-        ),
-        smooth_terms = c("s(altitude, df = c(2, 3)):1", "s(altitude, df = c(2, 3)):2")
-      )
-    )
-    expect_equal(nrow(get_parameters(m2)), 6)
-    expect_equal(
-      get_parameters(m2)$Parameter,
-      c(
+  )
+  expect_equal(
+    find_variables(m1, flatten = TRUE),
+    c("agaaus", "vitluc", "altitude")
+  )
+  expect_equal(find_variables(m2), list(
+    response = c("agaaus", "kniexc"),
+    conditional = c("vitluc", "altitude")
+  ))
+  expect_equal(
+    find_variables(m2, flatten = TRUE),
+    c("agaaus", "kniexc", "vitluc", "altitude")
+  )
+})
+
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 392)
+  expect_equal(n_obs(m2), 392)
+})
+
+test_that("linkfun", {
+  expect_false(is.null(link_function(m1)))
+  expect_false(is.null(link_function(m2)))
+})
+
+test_that("find_parameters", {
+  expect_equal(
+    find_parameters(m1),
+    list(
+      conditional = c("(Intercept)", "vitluc"),
+      smooth_terms = "s(altitude, df = 2)"
+    )
+  )
+  expect_equal(nrow(get_parameters(m1)), 3)
+  expect_equal(
+    get_parameters(m1)$Parameter,
+    c("(Intercept)", "vitluc", "s(altitude, df = 2)")
+  )
+
+  expect_equal(
+    find_parameters(m2),
+    list(
+      conditional = c(
         "(Intercept):1",
         "(Intercept):2",
         "vitluc:1",
-        "vitluc:2",
-        "s(altitude, df = c(2, 3)):1",
-        "s(altitude, df = c(2, 3)):2"
-      )
-    )
-  })
-
-  test_that("is_multivariate", {
-    expect_false(is_multivariate(m1))
-    expect_false(is_multivariate(m2))
-  })
-
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "chi-squared statistic")
-    expect_identical(find_statistic(m2), "chi-squared statistic")
-  })
-}
+        "vitluc:2"
+      ),
+      smooth_terms = c("s(altitude, df = c(2, 3)):1", "s(altitude, df = c(2, 3)):2")
+    )
+  )
+  expect_equal(nrow(get_parameters(m2)), 6)
+  expect_equal(
+    get_parameters(m2)$Parameter,
+    c(
+      "(Intercept):1",
+      "(Intercept):2",
+      "vitluc:1",
+      "vitluc:2",
+      "s(altitude, df = c(2, 3)):1",
+      "s(altitude, df = c(2, 3)):2"
+    )
+  )
+})
+
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1))
+  expect_false(is_multivariate(m2))
+})
+
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "chi-squared statistic")
+  expect_identical(find_statistic(m2), "chi-squared statistic")
+})
diff --git a/tests/testthat/test-vglm.R b/tests/testthat/test-vglm.R
index feee1b6ab..ae02addf9 100644
--- a/tests/testthat/test-vglm.R
+++ b/tests/testthat/test-vglm.R
@@ -1,112 +1,99 @@
-unloadNamespace("gam")
 skip_on_os("mac")
+skip_if_not_installed("VGAM")
+
+d.AD <- data.frame(
+  treatment = gl(3, 3),
+  outcome = gl(3, 1, 9),
+  counts = c(18, 17, 15, 20, 10, 20, 25, 13, 12)
+)
+
+m1 <-
+  VGAM::vglm(
+    counts ~ outcome + treatment,
+    family = VGAM::poissonff,
+    data = d.AD,
+    trace = FALSE
+  )
 
-if (skip_if_not_or_load_if_installed("VGAM")) {
-  d.AD <- data.frame(
-    treatment = gl(3, 3),
-    outcome = gl(3, 1, 9),
-    counts = c(18, 17, 15, 20, 10, 20, 25, 13, 12)
+test_that("model_info", {
+  expect_true(model_info(m1)$is_poisson)
+  expect_false(model_info(m1)$is_bayesian)
+  expect_false(model_info(m1)$is_linear)
+})
+
+test_that("find_predictors", {
+  expect_identical(find_predictors(m1), list(conditional = c("outcome", "treatment")))
+  expect_identical(
+    find_predictors(m1, flatten = TRUE),
+    c("outcome", "treatment")
+  )
+  expect_null(find_predictors(m1, effects = "random"))
+})
+
+test_that("find_random", {
+  expect_null(find_random(m1))
+})
+
+test_that("get_random", {
+  expect_warning(get_random(m1))
+})
+
+test_that("find_response", {
+  expect_identical(find_response(m1), "counts")
+})
+
+test_that("get_response", {
+  expect_equal(get_response(m1), d.AD$counts)
+})
+
+test_that("get_predictors", {
+  expect_equal(colnames(get_predictors(m1)), c("outcome", "treatment"))
+})
+
+li <- suppressWarnings(link_inverse(m1)(0.2)[1, 1])
+test_that("link_inverse", {
+  expect_equal(li, exp(0.2), tolerance = 1e-5)
+  expect_warning(link_inverse(m1)(0.2))
+})
+
+test_that("get_data", {
+  expect_equal(nrow(get_data(m1, verbose = FALSE)), 9)
+  expect_equal(colnames(get_data(m1, verbose = FALSE)), c("counts", "outcome", "treatment"))
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(m1), 1)
+  expect_equal(
+    find_formula(m1),
+    list(conditional = as.formula("counts ~ outcome + treatment")),
+    ignore_attr = TRUE
   )
+})
+
+test_that("find_terms", {
+  expect_equal(find_terms(m1), list(
+    response = "counts",
+    conditional = c("outcome", "treatment")
+  ))
+  expect_equal(
+    find_terms(m1, flatten = TRUE),
+    c("counts", "outcome", "treatment")
+  )
+})
 
-  m1 <-
-    vglm(
-      counts ~ outcome + treatment,
-      family = poissonff,
-      data = d.AD,
-      trace = FALSE
-    )
+test_that("n_obs", {
+  expect_equal(n_obs(m1), 9)
+})
 
-  test_that("model_info", {
-    expect_true(model_info(m1)$is_poisson)
-    expect_false(model_info(m1)$is_bayesian)
-    expect_false(model_info(m1)$is_linear)
-  })
-
-  test_that("find_predictors", {
-    expect_identical(find_predictors(m1), list(conditional = c("outcome", "treatment")))
-    expect_identical(
-      find_predictors(m1, flatten = TRUE),
-      c("outcome", "treatment")
-    )
-    expect_null(find_predictors(m1, effects = "random"))
-  })
-
-  test_that("find_random", {
-    expect_null(find_random(m1))
-  })
-
-  test_that("get_random", {
-    expect_warning(get_random(m1))
-  })
-
-  test_that("find_response", {
-    expect_identical(find_response(m1), "counts")
-  })
-
-  test_that("get_response", {
-    expect_equal(get_response(m1), d.AD$counts)
-  })
-
-  test_that("get_predictors", {
-    expect_equal(colnames(get_predictors(m1)), c("outcome", "treatment"))
-  })
-
-  li <- suppressWarnings(link_inverse(m1)(0.2)[1, 1])
-  test_that("link_inverse", {
-    expect_equal(li, exp(0.2), tolerance = 1e-5)
-    expect_warning(link_inverse(m1)(0.2))
-  })
-
-  test_that("get_data", {
-    expect_equal(nrow(get_data(m1, verbose = FALSE)), 9)
-    expect_equal(colnames(get_data(m1, verbose = FALSE)), c("counts", "outcome", "treatment"))
-  })
-
-  test_that("find_formula", {
-    expect_length(find_formula(m1), 1)
-    expect_equal(
-      find_formula(m1),
-      list(conditional = as.formula("counts ~ outcome + treatment")),
-      ignore_attr = TRUE
-    )
-  })
-
-  test_that("find_terms", {
-    expect_equal(find_terms(m1), list(
-      response = "counts",
-      conditional = c("outcome", "treatment")
-    ))
-    expect_equal(
-      find_terms(m1, flatten = TRUE),
-      c("counts", "outcome", "treatment")
-    )
-  })
-
-  test_that("n_obs", {
-    expect_equal(n_obs(m1), 9)
-  })
-
-  test_that("linkfun", {
-    expect_false(is.null(link_function(m1)))
-  })
-
-  test_that("find_parameters", {
-    expect_equal(
-      find_parameters(m1),
-      list(
-        conditional = c(
-          "(Intercept)",
-          "outcome2",
-          "outcome3",
-          "treatment2",
-          "treatment3"
-        )
-      )
-    )
-    expect_equal(nrow(get_parameters(m1)), 5)
-    expect_equal(
-      get_parameters(m1)$Parameter,
-      c(
+test_that("linkfun", {
+  expect_false(is.null(link_function(m1)))
+})
+
+test_that("find_parameters", {
+  expect_equal(
+    find_parameters(m1),
+    list(
+      conditional = c(
         "(Intercept)",
         "outcome2",
         "outcome3",
@@ -114,13 +101,24 @@ if (skip_if_not_or_load_if_installed("VGAM")) {
         "treatment3"
       )
     )
-  })
+  )
+  expect_equal(nrow(get_parameters(m1)), 5)
+  expect_equal(
+    get_parameters(m1)$Parameter,
+    c(
+      "(Intercept)",
+      "outcome2",
+      "outcome3",
+      "treatment2",
+      "treatment3"
+    )
+  )
+})
 
-  test_that("is_multivariate", {
-    expect_false(is_multivariate(m1))
-  })
+test_that("is_multivariate", {
+  expect_false(is_multivariate(m1))
+})
 
-  test_that("find_statistic", {
-    expect_identical(find_statistic(m1), "z-statistic")
-  })
-}
+test_that("find_statistic", {
+  expect_identical(find_statistic(m1), "z-statistic")
+})
diff --git a/tests/testthat/test-zeroinfl.R b/tests/testthat/test-zeroinfl.R
index d4e586b3e..62d4731b7 100644
--- a/tests/testthat/test-zeroinfl.R
+++ b/tests/testthat/test-zeroinfl.R
@@ -1,7 +1,8 @@
-skip_if_not_or_load_if_installed("pscl")
-data("bioChemists")
+skip_if_not_installed("pscl")
 
-m1 <- zeroinfl(art ~ fem + mar + kid5 + ment | kid5 + phd, data = bioChemists)
+data(bioChemists, package = "pscl")
+
+m1 <- pscl::zeroinfl(art ~ fem + mar + kid5 + ment | kid5 + phd, data = bioChemists)
 
 test_that("model_info", {
   expect_true(model_info(m1)$is_poisson)
@@ -132,7 +133,7 @@ test_that("get_statistic", {
 })
 
 test_that("get_varcov", {
-  skip_if_not_or_load_if_installed("sandwich")
+  library(sandwich) # needs to be loaded
 
   set.seed(123)
   vc1 <- get_varcov(m1, component = "all", vcov = "BS", vcov_args = list(R = 50))
@@ -151,7 +152,7 @@ test_that("get_varcov", {
   expect_equal(vc1, vc2[zero_col, zero_col], ignore_attr = TRUE)
 })
 
-m2 <- zeroinfl(formula = art ~ . | 1, data = bioChemists, dist = "negbin")
+m2 <- pscl::zeroinfl(formula = art ~ . | 1, data = bioChemists, dist = "negbin")
 
 test_that("get_statistic", {
   expect_equal(

From d0dcdf8bc5055a2ab3c74ed452ecabaf3ff003e8 Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Thu, 13 Apr 2023 08:58:40 +0200
Subject: [PATCH 23/98] add tests

---
 tests/testthat/test-get_weights.R | 20 ++++++++++++++++++--
 1 file changed, 18 insertions(+), 2 deletions(-)

diff --git a/tests/testthat/test-get_weights.R b/tests/testthat/test-get_weights.R
index e7b8cf4c3..04aeaed93 100644
--- a/tests/testthat/test-get_weights.R
+++ b/tests/testthat/test-get_weights.R
@@ -13,17 +13,33 @@ mtcars$w <- abs(rnorm(nrow(mtcars), sd = 0.5))
 
 m1 <- lme4::lmer(mpg ~ am + (1 | cyl), data = mtcars, weights = w)
 m2 <- lm(mpg ~ am, data = mtcars, weights = w)
+m3 <- suppressWarnings(glm(am ~ mpg + as.factor(vs), data = mtcars, weights = w, family = binomial()))
+m4 <- glm(am ~ mpg + as.factor(vs), data = mtcars, weights = w, family = quasibinomial())
 
 test_that("get_weights", {
   expect_equal(
     get_weights(m1),
     mtcars$w,
-    tolerance = 1e-2
+    tolerance = 1e-2,
+    ignore_attr = TRUE
   )
   expect_equal(
     get_weights(m2),
     mtcars$w,
-    tolerance = 1e-2
+    tolerance = 1e-2,
+    ignore_attr = TRUE
+  )
+  expect_equal(
+    get_weights(m3),
+    mtcars$w,
+    tolerance = 1e-2,
+    ignore_attr = TRUE
+  )
+  expect_equal(
+    get_weights(m4),
+    mtcars$w,
+    tolerance = 1e-2,
+    ignore_attr = TRUE
   )
 })
 

From 00f780c8deef26d5a827d09ef561ea71c423f899 Mon Sep 17 00:00:00 2001
From: Indrajeet Patil <patilindrajeet.science@gmail.com>
Date: Thu, 13 Apr 2023 09:50:16 +0200
Subject: [PATCH 24/98] re-trigger CI

---
 tests/testthat/test-afex_aov.R | 24 ++++++++++++++++--------
 1 file changed, 16 insertions(+), 8 deletions(-)

diff --git a/tests/testthat/test-afex_aov.R b/tests/testthat/test-afex_aov.R
index 33ac783e6..e4e63610d 100644
--- a/tests/testthat/test-afex_aov.R
+++ b/tests/testthat/test-afex_aov.R
@@ -78,35 +78,43 @@ test_that("afex_aov: afex", {
 })
 
 test_that("afex_aov: model values", {
-  expect_equal(suppressWarnings(sapply(mods, get_auxiliary)),
+  expect_equal(
+    suppressWarnings(sapply(mods, get_auxiliary)),
     c(1.75262, 1.77497, 1.77038, 1.29973, 2.08001),
     tolerance = 0.01
   )
-  expect_equal(suppressWarnings(sapply(mods, get_df)),
+  expect_equal(
+    suppressWarnings(sapply(mods, get_df)),
     c(134, 134, 149, 9, 224),
     tolerance = 0.01
   )
-  expect_equal(sapply(mods, get_loglikelihood),
+  expect_equal(
+    sapply(mods, get_loglikelihood),
     c(-411.04, -414.088, -431.688, -22.295, -517.397),
     tolerance = 0.01
   )
-  expect_equal(suppressWarnings(sapply(mods, get_sigma)),
+  expect_equal(
+    suppressWarnings(sapply(mods, get_sigma)),
     c(1.75262, 1.77497, 1.77038, 1.29973, 2.08001),
     tolerance = 0.01
   )
-  expect_equal(sapply(mods, n_obs),
+  expect_equal(
+    sapply(mods, n_obs),
     c(240, 240, 240, 16, 240),
     tolerance = 0.01
   )
-  expect_equal(sapply(mods, n_parameters),
+  expect_equal(
+    sapply(mods, n_parameters),
     c(105, 105, 90, 6, 15),
     tolerance = 0.01
   )
-  expect_equal(sapply(mods, is_mixed_model),
+  expect_equal(
+    sapply(mods, is_mixed_model),
     c(TRUE, TRUE, TRUE, FALSE, TRUE),
     tolerance = 0.01
   )
-  expect_equal(sapply(mods, get_deviance),
+  expect_equal(
+    sapply(mods, get_deviance),
     c(411.603, 422.17, 467, 15.204, 969.125),
     tolerance = 0.01
   )

From b04a75ec1ad65196cff8505b4e60d0ec935f714a Mon Sep 17 00:00:00 2001
From: Indrajeet Patil <patilindrajeet.science@gmail.com>
Date: Thu, 13 Apr 2023 10:03:04 +0200
Subject: [PATCH 25/98] retrigger CI

---
 tests/testthat/test-plm.R | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/tests/testthat/test-plm.R b/tests/testthat/test-plm.R
index cec095a96..ae480f16f 100644
--- a/tests/testthat/test-plm.R
+++ b/tests/testthat/test-plm.R
@@ -1,14 +1,17 @@
-skip_if_not(getRversion() > "3.5")
 skip_if_not_installed("plm")
 
 data(Crime, package = "plm")
-m1 <- suppressWarnings(plm::plm(lcrmrte ~ lprbarr + factor(year) | . - lprbarr + lmix, data = Crime, model = "random"))
+m1 <- suppressWarnings(
+  plm::plm(
+    lcrmrte ~ lprbarr + factor(year) | . - lprbarr + lmix,
+    data = Crime,
+    model = "random"
+  )
+)
 
-# data
 set.seed(123)
 data("Produc", package = "plm")
 
-# model
 m2 <- suppressWarnings(plm::plm(
   formula = log(gsp) ~ log(pcap) + log(pc) + log(emp) + unemp,
   data = Produc,

From 0088a88e8cf9b8589301ad2fec43c64bd4f0c0ce Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Thu, 13 Apr 2023 17:30:17 +0200
Subject: [PATCH 26/98] GLM family = binomial, error with a continuous
 predictor (#755)

---
 DESCRIPTION                       |  2 +-
 NEWS.md                           |  5 +++++
 R/get_weights.R                   |  2 +-
 tests/testthat/test-get_weights.R | 10 ++++++++++
 4 files changed, 17 insertions(+), 2 deletions(-)

diff --git a/DESCRIPTION b/DESCRIPTION
index f1fbd2676..57b379f9d 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -1,7 +1,7 @@
 Type: Package
 Package: insight
 Title: Easy Access to Model Information for Various Model Objects
-Version: 0.19.1.5
+Version: 0.19.1.6
 Authors@R: 
     c(person(given = "Daniel",
              family = "Lüdecke",
diff --git a/NEWS.md b/NEWS.md
index 47a3b86b6..2d6df3252 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -20,6 +20,11 @@
 
 * `phylolm` and `phyloglm` (package *phylolm*).
 
+## Bug fixes
+
+* Fixed issues in `get_weights()` for `glm` models without weights and `na.action`
+  not set to default in the model call.
+
 # insight 0.19.1
 
 ## New supported models
diff --git a/R/get_weights.R b/R/get_weights.R
index a6528bc64..5bd88eb17 100644
--- a/R/get_weights.R
+++ b/R/get_weights.R
@@ -78,7 +78,7 @@ get_weights.default <- function(x, na_rm = FALSE, null_as_ones = FALSE, ...) {
 
   # if all weights are 1, set return value to NULL,
   # unless the weights were explicitly set in the model call
-  if (!is.null(w) && all(w == 1L) && is.null(weight_vars)) {
+  if (!is.null(w) && isTRUE(all(w[!is.na(w)] == 1L)) && is.null(weight_vars)) {
     w <- NULL
   }
 
diff --git a/tests/testthat/test-get_weights.R b/tests/testthat/test-get_weights.R
index 04aeaed93..bd80cac0b 100644
--- a/tests/testthat/test-get_weights.R
+++ b/tests/testthat/test-get_weights.R
@@ -43,6 +43,16 @@ test_that("get_weights", {
   )
 })
 
+
+test_that("get_weights, with missing", { #754
+  set.seed(123)
+  mtcars2 <- mtcars
+  mtcars2$hp[sample(seq_len(nrow(mtcars)), 5)] <- NA
+  m <- glm(am ~ hp, na.action = na.exclude, data = mtcars2, family = binomial())
+  expect_null(get_weights(m))
+})
+
+
 skip_if_not_installed("nlme")
 data("Orthodont", package = "nlme")
 m <- nlme::lme( # a model of variance only

From a9a06b2db1aa07896a335a7c039b3204ad07e9cc Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Thu, 13 Apr 2023 17:51:49 +0200
Subject: [PATCH 27/98] add test

---
 tests/testthat/test-get_weights.R | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/tests/testthat/test-get_weights.R b/tests/testthat/test-get_weights.R
index bd80cac0b..268c22362 100644
--- a/tests/testthat/test-get_weights.R
+++ b/tests/testthat/test-get_weights.R
@@ -48,8 +48,11 @@ test_that("get_weights, with missing", { #754
   set.seed(123)
   mtcars2 <- mtcars
   mtcars2$hp[sample(seq_len(nrow(mtcars)), 5)] <- NA
-  m <- glm(am ~ hp, na.action = na.exclude, data = mtcars2, family = binomial())
-  expect_null(get_weights(m))
+  mtcars2$w <- abs(rnorm(nrow(mtcars), sd = 0.5))
+  m_w1 <- glm(am ~ hp, na.action = na.exclude, data = mtcars2, family = binomial())
+  expect_null(get_weights(m_w1))
+  m_w2 <- suppressWarnings(glm(am ~ hp, na.action = na.exclude, data = mtcars2, weights = w, family = binomial()))
+  expect_equal(weights(m_w2), get_weights(m_w2), tolerance = 1e-4, ignore_attr = TRUE)
 })
 
 

From 268f2300d2b1cbb07a37d405cb3a2b381bc10ce2 Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Thu, 13 Apr 2023 18:43:47 +0200
Subject: [PATCH 28/98] fix #756

---
 tests/testthat/_snaps/mipo.md | 32 ++++++++++++++++----------------
 tests/testthat/test-mipo.R    |  9 ++++++---
 2 files changed, 22 insertions(+), 19 deletions(-)

diff --git a/tests/testthat/_snaps/mipo.md b/tests/testthat/_snaps/mipo.md
index 087d47452..d37d68f89 100644
--- a/tests/testthat/_snaps/mipo.md
+++ b/tests/testthat/_snaps/mipo.md
@@ -1,26 +1,26 @@
 # param
 
     Code
-      get_parameters(pooled)
+      out1
     Output
-          Parameter    Estimate Response
-      1 (Intercept) -54.2937437        6
-      2        disp   0.2230706        6
-      3          hp   0.2029648        6
-      4 (Intercept) -92.8614823        8
-      5        disp   0.2577745        8
-      6          hp   0.4258580        8
+          Parameter Estimate Response
+      1 (Intercept) -54.2937        6
+      2        disp   0.2231        6
+      3          hp   0.2030        6
+      4 (Intercept) -92.8615        8
+      5        disp   0.2578        8
+      6          hp   0.4259        8
 
 ---
 
     Code
-      get_statistic(pooled)
+      out2
     Output
-          Parameter  Statistic Response
-      1 (Intercept) -1.1576689        6
-      2        disp  0.5763162        6
-      3          hp  0.3571385        6
-      4 (Intercept) -1.3732007        8
-      5        disp  0.6402012        8
-      6          hp  0.6741937        8
+          Parameter Statistic Response
+      1 (Intercept)   -1.1577        6
+      2        disp    0.5763        6
+      3          hp    0.3571        6
+      4 (Intercept)   -1.3732        8
+      5        disp    0.6402        8
+      6          hp    0.6742        8
 
diff --git a/tests/testthat/test-mipo.R b/tests/testthat/test-mipo.R
index a0123a668..c8bcd0c7d 100644
--- a/tests/testthat/test-mipo.R
+++ b/tests/testthat/test-mipo.R
@@ -14,8 +14,11 @@ test_that("param", {
     })
   }
   pooled <- mice::pool(model)
-
-  expect_snapshot(get_parameters(pooled))
-  expect_snapshot(get_statistic(pooled))
+  out1 <- get_parameters(pooled)
+  out2 <- get_statistic(pooled)
+  out1$Estimate <- round(out1$Estimate, 4)
+  out2$Statistic <- round(out2$Statistic, 4)
+  expect_snapshot(out1)
+  expect_snapshot(out2)
   expect_identical(find_parameters(pooled), list(conditional = c("(Intercept)", "disp", "hp")))
 })

From 1dc0c267d531f81f2f679bec8c4bbb3872a225e9 Mon Sep 17 00:00:00 2001
From: Indrajeet Patil <patilindrajeet.science@gmail.com>
Date: Thu, 13 Apr 2023 19:05:35 +0200
Subject: [PATCH 29/98] fix styling and link rot workflow

---
 R/is_converged.R                  | 4 +---
 man/insight-package.Rd            | 3 ++-
 man/is_converged.Rd               | 3 +--
 tests/testthat/test-get_weights.R | 2 +-
 4 files changed, 5 insertions(+), 7 deletions(-)

diff --git a/R/is_converged.R b/R/is_converged.R
index e57c76b95..62d83f8d2 100644
--- a/R/is_converged.R
+++ b/R/is_converged.R
@@ -32,8 +32,7 @@
 #'   how to resolve convergence issues. Another clue might be large parameter
 #'   values, e.g. estimates (on the scale of the linear predictor) larger than
 #'   10 in (non-identity link) generalized linear model *might* indicate
-#'   [complete separation](https://stats.oarc.ucla.edu/other/mult-pkg/faq/general/faqwhat-is-complete-or-quasi-complete-separation-in-logisticprobit-regression-and-how-do-we-deal-with-them/).
-#'   Complete separation can be addressed by regularization, e.g. penalized
+#'   complete separation, which can be addressed by regularization, e.g. penalized
 #'   regression or Bayesian regression with appropriate priors on the fixed effects.
 #'   }
 #'   \subsection{Convergence versus Singularity}{
@@ -93,7 +92,6 @@ is_converged.merMod <- function(x, tolerance = 0.001, ...) {
   # copy convergence value
   attr(retval, "gradient") <- max(abs(relgrad))
 
-  # return result
   retval
 }
 
diff --git a/man/insight-package.Rd b/man/insight-package.Rd
index 4425c93c3..03f5feeea 100644
--- a/man/insight-package.Rd
+++ b/man/insight-package.Rd
@@ -41,8 +41,9 @@ Authors:
   \item Indrajeet Patil \email{patilindrajeet.science@gmail.com} (\href{https://orcid.org/0000-0003-1995-6531}{ORCID}) (@patilindrajeets) [contributor]
   \item Philip Waggoner \email{philip.waggoner@gmail.com} (\href{https://orcid.org/0000-0002-7825-7573}{ORCID}) [contributor]
   \item Mattan S. Ben-Shachar \email{matanshm@post.bgu.ac.il} (\href{https://orcid.org/0000-0002-4287-4801}{ORCID}) [contributor]
-  \item Brenton M. Wiernik \email{brenton@wiernik.org} (\href{https://orcid.org/0000-0001-9560-6336}{ORCID}) (@bmwiernik)
+  \item Brenton M. Wiernik \email{brenton@wiernik.org} (\href{https://orcid.org/0000-0001-9560-6336}{ORCID}) (@bmwiernik) [contributor]
   \item Vincent Arel-Bundock \email{vincent.arel-bundock@umontreal.ca} (\href{https://orcid.org/0000-0003-2042-7063}{ORCID}) [contributor]
+  \item Etienne Bacher \email{etienne.bacher@protonmail.com} (\href{https://orcid.org/0000-0002-9271-5075}{ORCID}) [contributor]
 }
 
 Other contributors:
diff --git a/man/is_converged.Rd b/man/is_converged.Rd
index 71644b17c..44519cdf6 100644
--- a/man/is_converged.Rd
+++ b/man/is_converged.Rd
@@ -43,8 +43,7 @@ Convergence issues are not easy to diagnose. The help page on
 how to resolve convergence issues. Another clue might be large parameter
 values, e.g. estimates (on the scale of the linear predictor) larger than
 10 in (non-identity link) generalized linear model \emph{might} indicate
-\href{https://stats.oarc.ucla.edu/other/mult-pkg/faq/general/faqwhat-is-complete-or-quasi-complete-separation-in-logisticprobit-regression-and-how-do-we-deal-with-them/}{complete separation}.
-Complete separation can be addressed by regularization, e.g. penalized
+complete separation, which can be addressed by regularization, e.g. penalized
 regression or Bayesian regression with appropriate priors on the fixed effects.
 }
 \subsection{Convergence versus Singularity}{
diff --git a/tests/testthat/test-get_weights.R b/tests/testthat/test-get_weights.R
index 268c22362..cb93dccbc 100644
--- a/tests/testthat/test-get_weights.R
+++ b/tests/testthat/test-get_weights.R
@@ -44,7 +44,7 @@ test_that("get_weights", {
 })
 
 
-test_that("get_weights, with missing", { #754
+test_that("get_weights, with missing", { # 754
   set.seed(123)
   mtcars2 <- mtcars
   mtcars2$hp[sample(seq_len(nrow(mtcars)), 5)] <- NA

From 9e4e88ac46902ffdb9d95685114fe3aabd8d1741 Mon Sep 17 00:00:00 2001
From: Indrajeet Patil <patilindrajeet.science@gmail.com>
Date: Fri, 14 Apr 2023 09:02:40 +0200
Subject: [PATCH 30/98] make library loading quieter in tests

---
 tests/testthat/test-cpglmm.R        |  4 +++-
 tests/testthat/test-get_predicted.R | 20 ++------------------
 tests/testthat/test-rlmer.R         |  4 +++-
 tests/testthat/test-rqss.R          |  2 +-
 tests/testthat/test-rstanarm.R      |  2 +-
 tests/testthat/test-zeroinfl.R      |  5 ++++-
 6 files changed, 14 insertions(+), 23 deletions(-)

diff --git a/tests/testthat/test-cpglmm.R b/tests/testthat/test-cpglmm.R
index 988ba5a99..34ff91e61 100644
--- a/tests/testthat/test-cpglmm.R
+++ b/tests/testthat/test-cpglmm.R
@@ -1,7 +1,9 @@
 skip_if_not_installed("cplm")
 
 # cplm::cpglmm doesn't work
-suppressPackageStartupMessages(library(cplm))
+suppressPackageStartupMessages({
+  suppressWarnings(suppressMessages(library(cplm, quietly = TRUE, warn.conflicts = FALSE)))
+})
 
 data("FineRoot", package = "cplm")
 m1 <- cpglmm(RLD ~ Stock + Spacing + (1 | Plant), data = FineRoot)
diff --git a/tests/testthat/test-get_predicted.R b/tests/testthat/test-get_predicted.R
index 3a5d788d7..d0590178c 100644
--- a/tests/testthat/test-get_predicted.R
+++ b/tests/testthat/test-get_predicted.R
@@ -181,7 +181,7 @@ test_that("get_predicted - lmerMod", {
   skip_on_cran()
 
   suppressPackageStartupMessages({
-    library(rstanarm)
+    suppressWarnings(suppressMessages(library(rstanarm, quietly = TRUE, warn.conflicts = FALSE)))
   })
 
   x <- lme4::lmer(mpg ~ am + (1 | cyl), data = mtcars)
@@ -376,7 +376,7 @@ test_that("get_predicted - rstanarm", {
   skip_if_not_installed("rstanarm")
 
   suppressPackageStartupMessages({
-    library(rstanarm)
+    suppressWarnings(suppressMessages(library(rstanarm, quietly = TRUE, warn.conflicts = FALSE)))
   })
 
   # LM
@@ -638,19 +638,3 @@ test_that("zero-inflation stuff works", {
   expect_equal(p3, p4, tolerance = 1e-1, ignore_attr = TRUE)
 })
 
-
-
-
-
-# # Bug: incorrect results when var-cov and model matrix do not have exactly the same columns
-# library(insight)
-# set.seed(12345)
-# n <- 500
-# x <- sample(1:3, n, replace = TRUE)
-# y <- rnorm(n)
-# z <- ifelse(x + y + rlogis(n) > 1.5, 1, 0)
-# dat <- data.frame(x = factor(x), y = y, z = z)
-# m <- glm(z ~ x + y, family = binomial, data = dat)
-# nd <- head(dat, 2)
-# get_predicted(m, data = head(dat, 2), ci = 0.95, predict = "link") |> data.frame()
-# predict(m, type = "link", newdata = nd, se.fit = TRUE)$se.fit
diff --git a/tests/testthat/test-rlmer.R b/tests/testthat/test-rlmer.R
index 8651dd7d1..2079a1ab9 100644
--- a/tests/testthat/test-rlmer.R
+++ b/tests/testthat/test-rlmer.R
@@ -18,7 +18,9 @@ for (i in 1:5) {
 
 dat <<- sleepstudy
 
-library(lme4)
+suppressPackageStartupMessages({
+  suppressWarnings(suppressMessages(library(lme4, quietly = TRUE, warn.conflicts = FALSE)))
+})
 
 suppressMessages({
   m1 <- robustlmm::rlmer(
diff --git a/tests/testthat/test-rqss.R b/tests/testthat/test-rqss.R
index 256e7821b..320d420b4 100644
--- a/tests/testthat/test-rqss.R
+++ b/tests/testthat/test-rqss.R
@@ -6,7 +6,7 @@ skip_if_not_installed("interp")
 ##      "tripack", which has a non-standard license.
 
 suppressPackageStartupMessages({
-  library(quantreg)
+  suppressWarnings(suppressMessages(library(quantreg, quietly = TRUE, warn.conflicts = FALSE)))
 })
 
 data("CobarOre", package = "quantreg")
diff --git a/tests/testthat/test-rstanarm.R b/tests/testthat/test-rstanarm.R
index adda70370..ea6baae2a 100644
--- a/tests/testthat/test-rstanarm.R
+++ b/tests/testthat/test-rstanarm.R
@@ -5,7 +5,7 @@ skip_if_not_installed("BayesFactor")
 skip_if_not_installed("rstanarm")
 
 suppressPackageStartupMessages({
-  library(rstanarm)
+  suppressWarnings(suppressMessages(library(rstanarm, quietly = TRUE, warn.conflicts = FALSE)))
 })
 
 data(sleepstudy, package = "lme4")
diff --git a/tests/testthat/test-zeroinfl.R b/tests/testthat/test-zeroinfl.R
index 62d4731b7..851b6cb93 100644
--- a/tests/testthat/test-zeroinfl.R
+++ b/tests/testthat/test-zeroinfl.R
@@ -133,7 +133,10 @@ test_that("get_statistic", {
 })
 
 test_that("get_varcov", {
-  library(sandwich) # needs to be loaded
+  # needs to be loaded
+  suppressPackageStartupMessages({
+    suppressWarnings(suppressMessages(library(sandwich, quietly = TRUE, warn.conflicts = FALSE)))
+  })
 
   set.seed(123)
   vc1 <- get_varcov(m1, component = "all", vcov = "BS", vcov_args = list(R = 50))

From c48a491f2bf440b93c2b59af83a7a58c5152a7e9 Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Thu, 20 Apr 2023 08:37:36 +0200
Subject: [PATCH 31/98] remove relevel from pattern

---
 DESCRIPTION                       |   2 +-
 NEWS.md                           |   2 +
 R/clean_names.R                   |   4 +-
 tests/testthat/test-clean_names.R | 131 ++++++++++++++++--------------
 4 files changed, 76 insertions(+), 63 deletions(-)

diff --git a/DESCRIPTION b/DESCRIPTION
index 57b379f9d..0e7cca587 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -1,7 +1,7 @@
 Type: Package
 Package: insight
 Title: Easy Access to Model Information for Various Model Objects
-Version: 0.19.1.6
+Version: 0.19.1.7
 Authors@R: 
     c(person(given = "Daniel",
              family = "Lüdecke",
diff --git a/NEWS.md b/NEWS.md
index 2d6df3252..4179393ba 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -25,6 +25,8 @@
 * Fixed issues in `get_weights()` for `glm` models without weights and `na.action`
   not set to default in the model call.
 
+* `clean_names()` now also removes the `relevel()` pattern.
+
 # insight 0.19.1
 
 ## New supported models
diff --git a/R/clean_names.R b/R/clean_names.R
index 9135bc0a3..766b93929 100644
--- a/R/clean_names.R
+++ b/R/clean_names.R
@@ -122,7 +122,7 @@ clean_names.character <- function(x, include_names = FALSE, ...) {
     "asis", "matrx", "pol", "strata", "strat", "scale", "scored", "interaction",
     "sqrt", "sin", "cos", "tan", "acos", "asin", "atan", "atan2", "exp", "lsp",
     "rcs", "pb", "lo", "bs", "ns", "mSpline", "bSpline", "t2", "te", "ti", "tt", # need to be fixed first "mmc", "mm",
-    "mi", "mo", "gp", "s", "I"
+    "mi", "mo", "gp", "s", "I", "relevel(as.factor", "relevel"
   )
 
   # sometimes needed for panelr models, where we need to preserve "lag()"
@@ -153,6 +153,8 @@ clean_names.character <- function(x, include_names = FALSE, ...) {
           if (!ignore_asis) x[i] <- trim_ws(unique(sub("asis\\(((\\w|\\.)*).*", "\\1", x[i])))
         } else if (pattern[j] == "log(log") {
           x[i] <- trim_ws(unique(sub("^log\\(log\\(((\\w|\\.)*).*", "\\1", x[i])))
+        } else if (pattern[j] == "relevel(as.factor") {
+          x[i] <- trim_ws(unique(sub("^relevel\\(as.factor\\(((\\w|\\.)*).*", "\\1", x[i])))
         } else if (pattern[j] == "scale(log") {
           x[i] <- trim_ws(unique(sub("^scale\\(log\\(((\\w|\\.)*).*", "\\1", x[i])))
           x[i] <- trim_ws(unique(sub("^scale\\(log1p\\(((\\w|\\.)*).*", "\\1", x[i])))
diff --git a/tests/testthat/test-clean_names.R b/tests/testthat/test-clean_names.R
index 6aa37eba3..fb42570a6 100644
--- a/tests/testthat/test-clean_names.R
+++ b/tests/testthat/test-clean_names.R
@@ -1,66 +1,75 @@
 test_that("clean_names", {
-  expect_equal(clean_names(""), "")
-  expect_equal(clean_names("as.factor(test)"), "test")
-  expect_equal(clean_names("log(test)"), "test")
-  expect_equal(clean_names("log(test, base = exp(3))"), "test")
-  expect_equal(clean_names("log(test,base=exp(3))"), "test")
-  expect_equal(clean_names("log(test/10)"), "test")
-  expect_equal(clean_names("log(test^2)"), "test")
-  expect_equal(clean_names("log(log(test))"), "test")
-  expect_equal(clean_names("log(log(test/10))"), "test")
-  expect_equal(clean_names("log(log(test*2))"), "test")
-  expect_equal(clean_names("scale(log(Days1))"), "Days1")
-  expect_equal(clean_names("I(test^2)"), "test")
-  expect_equal(clean_names("I(test/10)"), "test")
-  expect_equal(clean_names("I(test ^ 2)"), "test")
-  expect_equal(clean_names("I(test / 10)"), "test")
-  expect_equal(clean_names("poly(test, 2)"), "test")
-  expect_equal(clean_names("poly(test, degrees = 2)"), "test")
-  expect_equal(clean_names("poly(test, degrees = 2, raw = TRUE)"), "test")
-  expect_equal(clean_names("ns(test)"), "test")
-  expect_equal(clean_names("ns(test, df = 2)"), "test")
-  expect_equal(clean_names("bs(test)"), "test")
-  expect_equal(clean_names("bs(test, df = 2)"), "test")
-  expect_equal(clean_names("offset(test)"), "test")
-  expect_equal(clean_names("offset(log(test))"), "test")
-  expect_equal(clean_names("factor(test)"), "test")
-  expect_equal(clean_names("as.factor(test)"), "test")
-  expect_equal(clean_names("~ 1 | test"), "test")
-  expect_equal(clean_names("~1|test"), "test")
-  expect_equal(clean_names("1 | test"), "test")
-  expect_equal(clean_names("as.factor(Sepal.Length)"), "Sepal.Length")
-  expect_equal(clean_names("log(Sepal.Length)"), "Sepal.Length")
-  expect_equal(clean_names("log(Sepal.Length, base = exp(3))"), "Sepal.Length")
-  expect_equal(clean_names("log(Sepal.Length,base=exp(3))"), "Sepal.Length")
-  expect_equal(clean_names("log(Sepal.Length/10)"), "Sepal.Length")
-  expect_equal(clean_names("log(Sepal.Length^2)"), "Sepal.Length")
-  expect_equal(clean_names("log(log(Sepal.Length))"), "Sepal.Length")
-  expect_equal(clean_names("log(log(Sepal.Length/10))"), "Sepal.Length")
-  expect_equal(clean_names("log(log(Sepal.Length*2))"), "Sepal.Length")
-  expect_equal(clean_names("I(Sepal.Length^2)"), "Sepal.Length")
-  expect_equal(clean_names("I(Sepal.Length/10)"), "Sepal.Length")
-  expect_equal(clean_names("I(Sepal.Length ^ 2)"), "Sepal.Length")
-  expect_equal(clean_names("I(Sepal.Length / 10)"), "Sepal.Length")
-  expect_equal(clean_names("poly(Sepal.Length, 2)"), "Sepal.Length")
-  expect_equal(clean_names("poly(Sepal.Length, degrees = 2)"), "Sepal.Length")
-  expect_equal(clean_names("poly(Sepal.Length, degrees = 2, raw = TRUE)"), "Sepal.Length")
-  expect_equal(clean_names("ns(Sepal.Length)"), "Sepal.Length")
-  expect_equal(clean_names("ns(Sepal.Length, df = 2)"), "Sepal.Length")
-  expect_equal(clean_names("bs(Sepal.Length)"), "Sepal.Length")
-  expect_equal(clean_names("bs(Sepal.Length, df = 2)"), "Sepal.Length")
-  expect_equal(clean_names("offset(Sepal.Length)"), "Sepal.Length")
-  expect_equal(clean_names("offset(log(Sepal.Length))"), "Sepal.Length")
-  expect_equal(clean_names("factor(Sepal.Length)"), "Sepal.Length")
-  expect_equal(clean_names("as.factor(Sepal.Length)"), "Sepal.Length")
-  expect_equal(clean_names("~ 1 | Sepal.Length"), "Sepal.Length")
-  expect_equal(clean_names("~1|Sepal.Length"), "Sepal.Length")
-  expect_equal(clean_names("1 | Sepal.Length"), "Sepal.Length")
-  expect_equal(clean_names(c("scale(a)", "scale(b)", "scale(a):scale(b)")), c("a", "b", "a:b"))
-  expect_equal(
+  expect_identical(clean_names(""), "")
+  expect_identical(clean_names("as.factor(test)"), "test")
+  expect_identical(clean_names("log(test)"), "test")
+  expect_identical(clean_names("log(test, base = exp(3))"), "test")
+  expect_identical(clean_names("log(test,base=exp(3))"), "test")
+  expect_identical(clean_names("log(test/10)"), "test")
+  expect_identical(clean_names("log(test^2)"), "test")
+  expect_identical(clean_names("log(log(test))"), "test")
+  expect_identical(clean_names("log(log(test/10))"), "test")
+  expect_identical(clean_names("log(log(test*2))"), "test")
+  expect_identical(clean_names("scale(log(Days1))"), "Days1")
+  expect_identical(clean_names("I(test^2)"), "test")
+  expect_identical(clean_names("I(test/10)"), "test")
+  expect_identical(clean_names("I(test ^ 2)"), "test")
+  expect_identical(clean_names("I(test / 10)"), "test")
+  expect_identical(clean_names("poly(test, 2)"), "test")
+  expect_identical(clean_names("poly(test, degrees = 2)"), "test")
+  expect_identical(clean_names("poly(test, degrees = 2, raw = TRUE)"), "test")
+  expect_identical(clean_names("ns(test)"), "test")
+  expect_identical(clean_names("ns(test, df = 2)"), "test")
+  expect_identical(clean_names("bs(test)"), "test")
+  expect_identical(clean_names("bs(test, df = 2)"), "test")
+  expect_identical(clean_names("offset(test)"), "test")
+  expect_identical(clean_names("offset(log(test))"), "test")
+  expect_identical(clean_names("factor(test)"), "test")
+  expect_identical(clean_names("as.factor(test)"), "test")
+  expect_identical(clean_names("~ 1 | test"), "test")
+  expect_identical(clean_names("~1|test"), "test")
+  expect_identical(clean_names("1 | test"), "test")
+  expect_identical(clean_names("as.factor(Sepal.Length)"), "Sepal.Length")
+  expect_identical(clean_names("log(Sepal.Length)"), "Sepal.Length")
+  expect_identical(clean_names("log(Sepal.Length, base = exp(3))"), "Sepal.Length")
+  expect_identical(clean_names("log(Sepal.Length,base=exp(3))"), "Sepal.Length")
+  expect_identical(clean_names("log(Sepal.Length/10)"), "Sepal.Length")
+  expect_identical(clean_names("log(Sepal.Length^2)"), "Sepal.Length")
+  expect_identical(clean_names("log(log(Sepal.Length))"), "Sepal.Length")
+  expect_identical(clean_names("log(log(Sepal.Length/10))"), "Sepal.Length")
+  expect_identical(clean_names("log(log(Sepal.Length*2))"), "Sepal.Length")
+  expect_identical(clean_names("I(Sepal.Length^2)"), "Sepal.Length")
+  expect_identical(clean_names("I(Sepal.Length/10)"), "Sepal.Length")
+  expect_identical(clean_names("I(Sepal.Length ^ 2)"), "Sepal.Length")
+  expect_identical(clean_names("I(Sepal.Length / 10)"), "Sepal.Length")
+  expect_identical(clean_names("poly(Sepal.Length, 2)"), "Sepal.Length")
+  expect_identical(clean_names("poly(Sepal.Length, degrees = 2)"), "Sepal.Length")
+  expect_identical(clean_names("poly(Sepal.Length, degrees = 2, raw = TRUE)"), "Sepal.Length")
+  expect_identical(clean_names("ns(Sepal.Length)"), "Sepal.Length")
+  expect_identical(clean_names("ns(Sepal.Length, df = 2)"), "Sepal.Length")
+  expect_identical(clean_names("bs(Sepal.Length)"), "Sepal.Length")
+  expect_identical(clean_names("bs(Sepal.Length, df = 2)"), "Sepal.Length")
+  expect_identical(clean_names("offset(Sepal.Length)"), "Sepal.Length")
+  expect_identical(clean_names("offset(log(Sepal.Length))"), "Sepal.Length")
+  expect_identical(clean_names("factor(Sepal.Length)"), "Sepal.Length")
+  expect_identical(clean_names("as.factor(Sepal.Length)"), "Sepal.Length")
+  expect_identical(clean_names("~ 1 | Sepal.Length"), "Sepal.Length")
+  expect_identical(clean_names("~1|Sepal.Length"), "Sepal.Length")
+  expect_identical(clean_names("1 | Sepal.Length"), "Sepal.Length")
+  expect_identical(clean_names(c("scale(a)", "scale(b)", "scale(a):scale(b)")), c("a", "b", "a:b"))
+  expect_identical(
     clean_names(c("scale(a)", "scale(b)", "scale(a):scale(b)"), include_names = TRUE),
     c(`scale(a)` = "a", `scale(b)` = "b", `scale(a):scale(b)` = "a:b")
   )
-  expect_equal(clean_names("s(x1, x2)"), "x1, x2")
-  expect_equal(clean_names("s(x1, x2, k = -1)"), "x1, x2")
-  expect_equal(clean_names("s(x1, x2, x3)"), "x1, x2, x3")
+  expect_identical(clean_names("s(x1, x2)"), "x1, x2")
+  expect_identical(clean_names("s(x1, x2, k = -1)"), "x1, x2")
+  expect_identical(clean_names("s(x1, x2, x3)"), "x1, x2, x3")
+})
+
+test_that("clean_names, model", {
+  m_rel1 <- lm(mpg ~ relevel(as.factor(cyl), "8") + gear, data = mtcars)
+  expect_identical(insight::clean_names(m_rel1), c("mpg", "cyl", "gear"))
+  mtcars2 <- mtcars
+  mtcars2$cyl <- as.factor(mtcars2$cyl)
+  m_rel2 <- lm(mpg ~ relevel(cyl, "8") + gear, data = mtcars2)
+  expect_identical(insight::clean_names(m_rel2), c("mpg", "cyl", "gear"))
 })

From ddb8c4a65d1fa438feae4787cab382486e8933fb Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Thu, 20 Apr 2023 08:51:44 +0200
Subject: [PATCH 32/98] minor

---
 R/clean_names.R | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/R/clean_names.R b/R/clean_names.R
index 766b93929..7063ac06b 100644
--- a/R/clean_names.R
+++ b/R/clean_names.R
@@ -189,7 +189,10 @@ clean_names.character <- function(x, include_names = FALSE, ...) {
       }
     }
     # for coxme-models, remove random-effect things...
-    trim_ws(sub("^(.*)\\|(.*)", "\\2", x[i]))
+    if (grepl("|", x[i], fixed = TRUE)) {
+      x[i] <- sub("^(.*)\\|(.*)", "\\2", x[i])
+    }
+    trim_ws(x[i])
   })
 
   # remove for random intercept only models

From 66e2a2574d4dfac02036d904d0da27d894cf85b7 Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Wed, 26 Apr 2023 18:27:39 +0200
Subject: [PATCH 33/98] fix model_info.gamlss

---
 DESCRIPTION                  |  2 +-
 NEWS.md                      |  2 +
 R/model_info.R               | 10 ++++-
 tests/testthat/test-gamlss.R | 79 ++++++++++++++++++++----------------
 4 files changed, 57 insertions(+), 36 deletions(-)

diff --git a/DESCRIPTION b/DESCRIPTION
index 0e7cca587..d1d6e8a99 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -1,7 +1,7 @@
 Type: Package
 Package: insight
 Title: Easy Access to Model Information for Various Model Objects
-Version: 0.19.1.7
+Version: 0.19.1.8
 Authors@R: 
     c(person(given = "Daniel",
              family = "Lüdecke",
diff --git a/NEWS.md b/NEWS.md
index 4179393ba..07254ed90 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -27,6 +27,8 @@
 
 * `clean_names()` now also removes the `relevel()` pattern.
 
+* Fixed issue in `model_info()` for models of class `gamlss`.
+
 # insight 0.19.1
 
 ## New supported models
diff --git a/R/model_info.R b/R/model_info.R
index 469fffbf8..b5e92eddd 100644
--- a/R/model_info.R
+++ b/R/model_info.R
@@ -1248,9 +1248,17 @@ model_info.svyolr <- function(x, ...) {
 #' @export
 model_info.gamlss <- function(x, ...) {
   faminfo <- get(x$family[1], asNamespace("gamlss"))()
+  # for ZIBNB family, we have only one value, so next line returns NA
+  fitfam <- faminfo$family[2]
+  if (is.na(fitfam)) {
+    fitfam <- faminfo$family
+    if (is.null(fitfam)) {
+      fitfam <- "unknown"
+    }
+  }
   .make_family(
     x = x,
-    fitfam = faminfo$family[2],
+    fitfam = fitfam,
     logit.link = faminfo$mu.link == "logit",
     link.fun = faminfo$mu.link,
     ...
diff --git a/tests/testthat/test-gamlss.R b/tests/testthat/test-gamlss.R
index fcf2effb9..39eb84dec 100644
--- a/tests/testthat/test-gamlss.R
+++ b/tests/testthat/test-gamlss.R
@@ -4,56 +4,67 @@ skip_if_not_installed("gamlss.data")
 pb <- gamlss::pb
 
 data(abdom, package = "gamlss.data")
-void <- capture.output(
-  m1 <-
-    gamlss::gamlss(
-      y ~ pb(x),
-      sigma.formula = ~ pb(x),
-      family = "BCT",
-      data = abdom,
-      method = mixed(1, 20)
-    )
-)
+data(usair, package = "gamlss.data")
+
+void <- capture.output({
+  m_gamlss1 <- gamlss::gamlss(
+    y ~ pb(x),
+    sigma.formula = ~ pb(x),
+    family = "BCT",
+    data = abdom,
+    method = mixed(1, 20)
+  )
+})
+
+void <- capture.output({
+  m_gamlss2 <- gamlss(y ~ x1 + x2 + x3,
+    sigma.formula = ~ x4 + x5 + x6 + x4:x5,
+    nu.formula = ~ x2 + x5,
+    tau.formula = ~ x1 + x4 + x5 + x6 + x1:x4,
+    family = ZIBNB, data = usair
+  )
+})
 
 test_that("model_info", {
-  expect_true(model_info(m1)$is_linear)
+  expect_true(model_info(m_gamlss1)$is_linear)
+  expect_true(model_info(m_gamlss2)$is_zero_inflated)  
 })
 
 test_that("find_predictors", {
-  expect_identical(find_predictors(m1), list(conditional = "x", sigma = "x"))
-  expect_identical(find_predictors(m1, flatten = TRUE), "x")
-  expect_null(find_predictors(m1, effects = "random"))
+  expect_identical(find_predictors(m_gamlss1), list(conditional = "x", sigma = "x"))
+  expect_identical(find_predictors(m_gamlss1, flatten = TRUE), "x")
+  expect_null(find_predictors(m_gamlss1, effects = "random"))
 })
 
 test_that("find_random", {
-  expect_null(find_random(m1))
+  expect_null(find_random(m_gamlss1))
 })
 
 test_that("get_random", {
-  expect_warning(get_random(m1))
+  expect_warning(get_random(m_gamlss1))
 })
 
 test_that("find_response", {
-  expect_identical(find_response(m1), "y")
+  expect_identical(find_response(m_gamlss1), "y")
 })
 
 test_that("get_response", {
-  expect_equal(get_response(m1), abdom$y)
+  expect_equal(get_response(m_gamlss1), abdom$y)
 })
 
 test_that("get_predictors", {
-  expect_equal(colnames(get_predictors(m1)), "x")
+  expect_equal(colnames(get_predictors(m_gamlss1)), "x")
 })
 
 test_that("get_data", {
-  expect_equal(nrow(get_data(m1)), 610)
-  expect_equal(colnames(get_data(m1)), c("y", "x"))
+  expect_equal(nrow(get_data(m_gamlss1)), 610)
+  expect_equal(colnames(get_data(m_gamlss1)), c("y", "x"))
 })
 
 test_that("find_formula", {
-  expect_length(find_formula(m1), 4)
+  expect_length(find_formula(m_gamlss1), 4)
   expect_equal(
-    find_formula(m1),
+    find_formula(m_gamlss1),
     list(
       conditional = as.formula("y ~ pb(x)"),
       sigma = as.formula("~pb(x)"),
@@ -66,19 +77,19 @@ test_that("find_formula", {
 
 test_that("find_variables", {
   expect_equal(
-    find_variables(m1),
+    find_variables(m_gamlss1),
     list(
       response = "y",
       conditional = "x",
       sigma = "x"
     )
   )
-  expect_equal(find_variables(m1, flatten = TRUE), c("y", "x"))
+  expect_equal(find_variables(m_gamlss1, flatten = TRUE), c("y", "x"))
 })
 
 test_that("find_terms", {
   expect_equal(
-    find_terms(m1),
+    find_terms(m_gamlss1),
     list(
       response = "y",
       conditional = "pb(x)",
@@ -90,20 +101,20 @@ test_that("find_terms", {
 })
 
 test_that("n_obs", {
-  expect_equal(n_obs(m1), 610)
+  expect_equal(n_obs(m_gamlss1), 610)
 })
 
 test_that("link_function", {
-  expect_equal(link_function(m1)(0.2), 0.2, tolerance = 1e-5)
+  expect_equal(link_function(m_gamlss1)(0.2), 0.2, tolerance = 1e-5)
 })
 
 test_that("link_inverse", {
-  expect_equal(link_inverse(m1)(0.2), 0.2, tolerance = 1e-5)
+  expect_equal(link_inverse(m_gamlss1)(0.2), 0.2, tolerance = 1e-5)
 })
 
 test_that("find_parameters", {
   expect_equal(
-    find_parameters(m1),
+    find_parameters(m_gamlss1),
     list(
       conditional = c("(Intercept)", "pb(x)"),
       sigma = c("(Intercept)", "pb(x)"),
@@ -111,17 +122,17 @@ test_that("find_parameters", {
       tau = "(Intercept)"
     )
   )
-  expect_equal(nrow(get_parameters(m1)), 6)
+  expect_equal(nrow(get_parameters(m_gamlss1)), 6)
 })
 
 test_that("is_multivariate", {
-  expect_false(is_multivariate(m1))
+  expect_false(is_multivariate(m_gamlss1))
 })
 
 test_that("find_algorithm", {
-  expect_equal(find_algorithm(m1), list(algorithm = "mixed"))
+  expect_equal(find_algorithm(m_gamlss1), list(algorithm = "mixed"))
 })
 
 test_that("find_statistic", {
-  expect_identical(find_statistic(m1), "t-statistic")
+  expect_identical(find_statistic(m_gamlss1), "t-statistic")
 })

From 18477fed999622947dad59dbc15513087ec65f8c Mon Sep 17 00:00:00 2001
From: Grant McDermott <grant.mcdermott@gmail.com>
Date: Sat, 29 Apr 2023 08:35:44 -0700
Subject: [PATCH 34/98] Include offset in get_data

---
 R/utils_get_data.R | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/R/utils_get_data.R b/R/utils_get_data.R
index ba32c265d..83832f625 100644
--- a/R/utils_get_data.R
+++ b/R/utils_get_data.R
@@ -681,7 +681,7 @@
     all = find_variables(x, flatten = TRUE),
     random = find_random(x, split_nested = TRUE, flatten = TRUE)
   )
-  remain <- intersect(c(ft, find_weights(x)), cn)
+  remain <- intersect(c(ft, find_weights(x), find_offset(x)), cn)
 
   mf <- .safe(dat[, remain, drop = FALSE], dat)
   .prepare_get_data(x, mf, effects, verbose = verbose)

From 814b8443cffea46fdca62221ebb5bda67004af27 Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Sat, 29 Apr 2023 19:59:07 +0200
Subject: [PATCH 35/98] fix test

---
 tests/testthat/test-gamlss.R | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/testthat/test-gamlss.R b/tests/testthat/test-gamlss.R
index 39eb84dec..b730460a7 100644
--- a/tests/testthat/test-gamlss.R
+++ b/tests/testthat/test-gamlss.R
@@ -17,7 +17,7 @@ void <- capture.output({
 })
 
 void <- capture.output({
-  m_gamlss2 <- gamlss(y ~ x1 + x2 + x3,
+  m_gamlss2 <- gamlss::gamlss(y ~ x1 + x2 + x3,
     sigma.formula = ~ x4 + x5 + x6 + x4:x5,
     nu.formula = ~ x2 + x5,
     tau.formula = ~ x1 + x4 + x5 + x6 + x1:x4,

From 1de7c7322194aca99bfcf10a14756eacff3a8cde Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Sat, 29 Apr 2023 20:01:30 +0200
Subject: [PATCH 36/98] tests

---
 tests/testthat/test-gamlss.R | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/tests/testthat/test-gamlss.R b/tests/testthat/test-gamlss.R
index b730460a7..6074f49fe 100644
--- a/tests/testthat/test-gamlss.R
+++ b/tests/testthat/test-gamlss.R
@@ -27,7 +27,7 @@ void <- capture.output({
 
 test_that("model_info", {
   expect_true(model_info(m_gamlss1)$is_linear)
-  expect_true(model_info(m_gamlss2)$is_zero_inflated)  
+  expect_true(model_info(m_gamlss2)$is_zero_inflated)
 })
 
 test_that("find_predictors", {
@@ -53,12 +53,12 @@ test_that("get_response", {
 })
 
 test_that("get_predictors", {
-  expect_equal(colnames(get_predictors(m_gamlss1)), "x")
+  expect_identical(colnames(get_predictors(m_gamlss1)), "x")
 })
 
 test_that("get_data", {
   expect_equal(nrow(get_data(m_gamlss1)), 610)
-  expect_equal(colnames(get_data(m_gamlss1)), c("y", "x"))
+  expect_identical(colnames(get_data(m_gamlss1)), c("y", "x"))
 })
 
 test_that("find_formula", {
@@ -76,7 +76,7 @@ test_that("find_formula", {
 })
 
 test_that("find_variables", {
-  expect_equal(
+  expect_identical(
     find_variables(m_gamlss1),
     list(
       response = "y",
@@ -84,11 +84,11 @@ test_that("find_variables", {
       sigma = "x"
     )
   )
-  expect_equal(find_variables(m_gamlss1, flatten = TRUE), c("y", "x"))
+  expect_identical(find_variables(m_gamlss1, flatten = TRUE), c("y", "x"))
 })
 
 test_that("find_terms", {
-  expect_equal(
+  expect_identical(
     find_terms(m_gamlss1),
     list(
       response = "y",
@@ -113,7 +113,7 @@ test_that("link_inverse", {
 })
 
 test_that("find_parameters", {
-  expect_equal(
+  expect_identical(
     find_parameters(m_gamlss1),
     list(
       conditional = c("(Intercept)", "pb(x)"),
@@ -130,7 +130,7 @@ test_that("is_multivariate", {
 })
 
 test_that("find_algorithm", {
-  expect_equal(find_algorithm(m_gamlss1), list(algorithm = "mixed"))
+  expect_identical(find_algorithm(m_gamlss1), list(algorithm = "mixed"))
 })
 
 test_that("find_statistic", {

From 067974bc80c5600f92e57f45d35afcf193ba3898 Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Sat, 29 Apr 2023 20:02:36 +0200
Subject: [PATCH 37/98] fix

---
 tests/testthat/test-gamlss.R | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/testthat/test-gamlss.R b/tests/testthat/test-gamlss.R
index 6074f49fe..fb55a397c 100644
--- a/tests/testthat/test-gamlss.R
+++ b/tests/testthat/test-gamlss.R
@@ -21,7 +21,7 @@ void <- capture.output({
     sigma.formula = ~ x4 + x5 + x6 + x4:x5,
     nu.formula = ~ x2 + x5,
     tau.formula = ~ x1 + x4 + x5 + x6 + x1:x4,
-    family = ZIBNB, data = usair
+    family = "ZIBNB", data = usair
   )
 })
 

From 8c9ea1f6b801ab553d8a7e97cd8c996fc2926bde Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Mon, 1 May 2023 21:31:14 +0200
Subject: [PATCH 38/98] fix get_df for brms

---
 R/get_df_residual.R | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/R/get_df_residual.R b/R/get_df_residual.R
index 1d8eaceb5..fe3268bef 100644
--- a/R/get_df_residual.R
+++ b/R/get_df_residual.R
@@ -10,13 +10,11 @@
 .degrees_of_freedom_residual.default <- function(x, verbose = TRUE, ...) {
   if (.is_bayesian_model(x) && !inherits(x, c("bayesx", "blmerMod", "bglmerMod"))) {
     if (check_if_installed("bayestestR", quietly = TRUE)) {
-      x <- tryCatch(bayestestR::bayesian_as_frequentist(x),
-        error = function(e) NULL
-      )
-      if (is.null(x)) {
+      x <- .safe(bayestestR::bayesian_as_frequentist(x))
+      if (is.null(x) && isTRUE(verbose)) {
         format_warning("Can't extract degrees of freedom from Bayesian model.")
+        return(NULL)
       }
-      return(NULL)
     } else {
       if (isTRUE(verbose)) {
         format_warning("Can't extract degrees of freedom from Bayesian model.")

From ff86abbe25fde9f3d9ddd9a2cc6d4b62c9cf5d60 Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Mon, 1 May 2023 21:33:31 +0200
Subject: [PATCH 39/98] tryCatch -> .safe

---
 R/get_df.R | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/R/get_df.R b/R/get_df.R
index e8ea95a67..8f842dca9 100644
--- a/R/get_df.R
+++ b/R/get_df.R
@@ -388,10 +388,10 @@ get_df.mediate <- function(x, ...) {
 # Model approach (model-based / logLik df) ------------------------------
 
 .model_df <- function(x) {
-  dof <- tryCatch(attr(stats::logLik(x), "df"), error = function(e) NULL)
+  dof <- .safe(attr(stats::logLik(x), "df"))
 
   if (is.null(dof) || all(is.infinite(dof)) || all(is.na(dof))) {
-    r <- tryCatch(x$rank, error = function(e) NULL)
+    r <- .safe(x$rank)
     if (!is.null(r)) {
       dof <- r + 1
     } else {

From a03d64b9b6475b27db1bde2db85abb7d686243ed Mon Sep 17 00:00:00 2001
From: Alex Reinhart <alex@refsmmat.com>
Date: Tue, 9 May 2023 06:53:14 -0400
Subject: [PATCH 40/98] Fix #760, so `get_data()` can fetch from the correct
 environment, and add tests (#761)

---
 DESCRIPTION                         |  7 ++-
 NEWS.md                             |  7 +++
 R/get_data.R                        | 15 +++---
 R/get_predicted.R                   | 10 ++--
 tests/testthat/test-get_data.R      | 80 +++++++++++++++++++++++++----
 tests/testthat/test-get_predicted.R | 19 +++++--
 6 files changed, 111 insertions(+), 27 deletions(-)

diff --git a/DESCRIPTION b/DESCRIPTION
index d1d6e8a99..4182c52f5 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -57,7 +57,12 @@ Authors@R:
              family = "Thériault",
              role = "ctb",
              email = "remi.theriault@mail.mcgill.ca",
-             comment = c(ORCID = "0000-0003-4315-6788", Twitter = "@rempsyc")))
+             comment = c(ORCID = "0000-0003-4315-6788", Twitter = "@rempsyc")),
+      person(given = "Alex",
+             family = "Reinhart",
+             role = "ctb",
+             email = "areinhar@stat.cmu.edu",
+             comment = c(ORCID = "0000-0002-6658-514X")))
 Maintainer: Daniel Lüdecke <d.luedecke@uke.de>
 Description: A tool to provide an easy, intuitive and consistent
     access to information contained in various R models, like model
diff --git a/NEWS.md b/NEWS.md
index 07254ed90..a2eda6ccc 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -29,6 +29,13 @@
 
 * Fixed issue in `model_info()` for models of class `gamlss`.
 
+* Fixed problems preventing `get_data()` from locating data defined in
+  non-global environments.
+
+* Fixed issue in `get_predicted()` for variables of class numeric matrix created
+  by `scale()`, which were correctly handled only when `get_data()` failed to
+  find the data in the appropriate environment.
+
 # insight 0.19.1
 
 ## New supported models
diff --git a/R/get_data.R b/R/get_data.R
index 8ed0b8726..9af73b5f7 100644
--- a/R/get_data.R
+++ b/R/get_data.R
@@ -209,17 +209,16 @@ get_data <- function(x, ...) {
     model_call[["data"]] <- as.name(data_name)
   }
 
-  # first, try environment of formula, see #666
-  dat <- .safe(eval(model_call$data, envir = environment(model_call$formula)))
+  # first, try environment of formula, see #666. set enclos = NULL so eval()
+  # does not fall back to parent frame when the environment is NULL, since we
+  # want to try that after checking the formula
+  dat <- .safe(eval(model_call$data, envir = environment(model_call$formula),
+                    enclos = NULL))
 
   # second, try to extract formula directly
   if (is.null(dat)) {
-    dat <- .safe(eval(model_call$data, envir = environment(find_formula(x))))
-  }
-
-  # next try, parent frame
-  if (is.null(dat)) {
-    dat <- .safe(eval(model_call$data, envir = parent.frame()))
+    dat <- .safe(eval(model_call$data, envir = environment(find_formula(x)$conditional),
+                      enclos = NULL))
   }
 
   # sanity check- if data frame is named like a function, e.g.
diff --git a/R/get_predicted.R b/R/get_predicted.R
index 2ad366d83..ce45ba968 100644
--- a/R/get_predicted.R
+++ b/R/get_predicted.R
@@ -317,14 +317,16 @@ get_predicted.lm <- function(x,
     )
   }
 
-  # 0. step: convert matrix variable types attributes to numeric, if necessary
-  dataClasses <- attributes(x[["terms"]])$dataClasses
+  args <- .get_predicted_args(x, data = data, predict = predict, verbose = verbose, ...)
+
+  # 0. step: convert matrix variable types attributes to numeric, if necessary.
   # see https://github.com/easystats/insight/pull/671
+  dataClasses <- attributes(x[["terms"]])$dataClasses
   if ("nmatrix.1" %in% dataClasses) {
     dataClasses[dataClasses == "nmatrix.1"] <- "numeric"
     attributes(x$terms)$dataClasses <- dataClasses
     attributes(attributes(x$model)$terms)$dataClasses <- dataClasses
-    x$model[] <- lapply(x$model, function(x) {
+    args$data[] <- lapply(args$data, function(x) {
       if (all(class(x) == c("matrix", "array"))) { # nolint
         as.numeric(x)
       } else {
@@ -333,8 +335,6 @@ get_predicted.lm <- function(x,
     })
   }
 
-  args <- .get_predicted_args(x, data = data, predict = predict, verbose = verbose, ...)
-
   # 1. step: predictions
   if (is.null(iterations)) {
     predictions <- predict_function(x, data = args$data)
diff --git a/tests/testthat/test-get_data.R b/tests/testthat/test-get_data.R
index efe9ec967..8a78a7da1 100644
--- a/tests/testthat/test-get_data.R
+++ b/tests/testthat/test-get_data.R
@@ -1,5 +1,61 @@
 skip_on_os("mac")
 
+test_that("retrieve from same environment", {
+  foo <- data.frame(x = 1:10, y = 2:11)
+
+  fit <- lm(y ~ x, data = foo)
+
+  expect_no_warning(cols <- names(get_data(fit)))
+
+  expect_setequal(cols, c("x", "y"))
+})
+
+test_that("retrieve from correct environment", {
+  foo <- function() {
+    foo <- data.frame(x = 1:10, y = 2:11)
+
+    return(lm(y ~ x, data = foo))
+  }
+
+  # There should be no warning about "Could not recover model data from
+  # environment"
+  expect_no_warning(cols <- names(get_data(foo())))
+
+  expect_setequal(cols, c("x", "y"))
+})
+
+test_that("fetch from local, not global, environment", {
+  # See #760. If the local environment has a modified version of data also in
+  # the global environment, we should find the local version first, not the
+  # global version.
+
+  foo <- function() {
+    mtcars$cylinders <- factor(mtcars$cyl)
+
+    return(lm(mpg ~ cylinders + disp, data = mtcars))
+  }
+
+  expect_setequal(names(get_data(foo())),
+                  c("mpg", "disp", "cylinders"))
+})
+
+test_that("retrieve from call formula environment", {
+  skip_if_not_installed("AER")
+
+  foo <- function() {
+    d <- data.frame(y = rnorm(100),
+                    x = rnorm(100))
+
+    # find_formula(fit)$conditional happens to not have an environment for tobit
+    # models, so get_data() should check environment(get_call(fit)$formula). See
+    # #666
+    return(AER::tobit(y ~ x, data = d, right = 1.5))
+  }
+
+  expect_setequal(names(get_data(foo())),
+                  c("x", "y"))
+})
+
 test_that("lme", {
   skip_if_not_installed("nlme")
   data("Orthodont", package = "nlme")
@@ -28,7 +84,7 @@ test_that("lme4", {
 test_that("additional_variables = TRUE", {
   k <- mtcars
   k$qsec[1:10] <- NA
-  k <<- k
+  k <- k
   mod <- lm(mpg ~ hp, k)
   n1 <- nrow(k)
   n2 <- nrow(insight::get_data(mod))
@@ -42,8 +98,8 @@ test_that("lm", {
   set.seed(1023)
   x <- rnorm(1000, sd = 4)
   y <- cos(x) + rnorm(1000)
-  # fails if we assign this locally
-  dat <<- data.frame(x, y)
+
+  dat <- data.frame(x, y)
   mod1 <- lm(y ~ x, data = dat)
   mod2 <- lm(y ~ cos(x), data = dat)
   expect_equal(get_data(mod1), get_data(mod2), ignore_attr = TRUE)
@@ -104,7 +160,7 @@ test_that("get_data include weights, even if ones", {
 
 
 test_that("lm with transformations", {
-  d <<- data.frame(
+  d <- data.frame(
     time = as.factor(c(1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5)),
     group = c(1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2),
     sum = c(0, 5, 10, 15, 20, 0, 20, 25, 45, 50, 0, 5, 10, 15, 20, 0, 20, 25, 45, 50, 0, 5, 10, 15, 20, 0, 20, 25, 45, 50)
@@ -117,21 +173,27 @@ test_that("lm with transformations", {
 test_that("lm with poly and NA in response", {
   d <- iris
   d[1:25, "Sepal.Length"] <- NA
-  d2 <<- d
+  d2 <- d
   m <- lm(Sepal.Length ~ Species / poly(Petal.Width, 2), data = d2)
   expect_equal(get_data(m), iris[26:150, c("Sepal.Length", "Species", "Petal.Width")], ignore_attr = TRUE)
 })
 
 
 test_that("mgcv", {
-  ## NOTE check back every now and then and see if tests still work
-  skip("works interactively")
   skip_if_not_installed("mgcv")
+
+  # mgcv::gam() deliberately does not keep its environment, so get_data() has to
+  # fall back to the model frame. See
+  # https://github.com/cran/mgcv/blob/a4e69cf44a49c84a41a42e90c86995a843733968/R/mgcv.r#L2156-L2159
   d <- iris
   d$NewFac <- rep(c(1, 2), length.out = 150)
   model <- mgcv::gam(Sepal.Length ~ s(Petal.Length, by = interaction(Species, NewFac)), data = d)
+
+  # There should be two warnings: One for failing to get the data from the
+  # environment, and one for not recovering interaction() accurately
+  expect_warning(expect_warning(model_data <- get_data(model)))
   expect_equal(
-    head(insight::get_data(model)),
+    head(model_data),
     head(d[c("Sepal.Length", "Petal.Length", "Species", "NewFac")]),
     ignore_attr = TRUE
   )
@@ -185,7 +247,7 @@ test_that("get_data() log transform", {
   set.seed(123)
   x <- abs(rnorm(100, sd = 5)) + 5
   y <- exp(2 + 0.3 * x + rnorm(100, sd = 0.4))
-  dat <<- data.frame(y, x)
+  dat <- data.frame(y, x)
 
   mod <- lm(log(y) ~ log(x), data = dat)
   expect_equal(
diff --git a/tests/testthat/test-get_predicted.R b/tests/testthat/test-get_predicted.R
index d0590178c..25a671b23 100644
--- a/tests/testthat/test-get_predicted.R
+++ b/tests/testthat/test-get_predicted.R
@@ -532,14 +532,25 @@ test_that("bugfix: used to return all zeros", {
 # Original Error: "variables were specified with different types from the fit"
 # Originates from using base R scale on dataframe (easystats/performance#432)
 test_that("bugfix: used to fail with matrix variables", {
-  mtcars2 <- mtcars
-  mtcars2$wt <- scale(mtcars2$wt)
-  m <- lm(mpg ~ wt + cyl + gear + disp, data = mtcars2)
-  pred <- get_predicted(m)
+  # put model data in a separate environment, to ensure we retrieve the correct
+  # data to fix its classes
+  foo <- function() {
+    mtcars2 <- mtcars
+    mtcars2$wt <- scale(mtcars2$wt)
+    return(lm(mpg ~ wt + cyl + gear + disp, data = mtcars2))
+  }
+  pred <- get_predicted(foo())
   expect_equal(class(pred), c("get_predicted", "numeric"))
   expect_true(all(attributes(attributes(attributes(
     pred
   )$data)$terms)$dataClasses == "numeric"))
+
+  # Now verify with the data in the same environment
+  mtcars2 <- mtcars
+  mtcars2$wt <- scale(mtcars2$wt)
+  m <- lm(mpg ~ wt + cyl + gear + disp, data = mtcars2)
+  expect_no_error(pred <- get_predicted(m))
+
   mtcars2$wt <- as.numeric(mtcars2$wt)
   m2 <- lm(mpg ~ wt + cyl + gear + disp, data = mtcars2)
   pred2 <- get_predicted(m2)

From 8fa07fc208d86ad2a04ca6502821c3913fae9713 Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Tue, 9 May 2023 12:56:12 +0200
Subject: [PATCH 41/98] lintr

---
 tests/testthat/test-get_data.R | 15 +++++++++------
 1 file changed, 9 insertions(+), 6 deletions(-)

diff --git a/tests/testthat/test-get_data.R b/tests/testthat/test-get_data.R
index 8a78a7da1..e91ff020a 100644
--- a/tests/testthat/test-get_data.R
+++ b/tests/testthat/test-get_data.R
@@ -2,11 +2,11 @@ skip_on_os("mac")
 
 test_that("retrieve from same environment", {
   foo <- data.frame(x = 1:10, y = 2:11)
-
   fit <- lm(y ~ x, data = foo)
 
-  expect_no_warning(cols <- names(get_data(fit)))
-
+  expect_no_warning({
+    cols <- names(get_data(fit))
+  })
   expect_setequal(cols, c("x", "y"))
 })
 
@@ -19,8 +19,9 @@ test_that("retrieve from correct environment", {
 
   # There should be no warning about "Could not recover model data from
   # environment"
-  expect_no_warning(cols <- names(get_data(foo())))
-
+  expect_no_warning({
+    cols <- names(get_data(foo()))
+  })
   expect_setequal(cols, c("x", "y"))
 })
 
@@ -191,7 +192,9 @@ test_that("mgcv", {
 
   # There should be two warnings: One for failing to get the data from the
   # environment, and one for not recovering interaction() accurately
-  expect_warning(expect_warning(model_data <- get_data(model)))
+  expect_warning(expect_warning({
+    model_data <- get_data(model)
+  }))
   expect_equal(
     head(model_data),
     head(d[c("Sepal.Length", "Petal.Length", "Species", "NewFac")]),

From 05bac6d8294e0db1ce929c4cb34df4b69a739042 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?R=C3=A9mi=20Th=C3=A9riault?=
 <13123390+rempsyc@users.noreply.github.com>
Date: Tue, 9 May 2023 09:11:25 -0400
Subject: [PATCH 42/98] `format_table()`: Change `Cohens_d CI` to `Cohen's d
 CI` (#763)

* `format_table()`: Change `Cohens_d CI` to `Cohen's d CI` (#762)

* lints + style

* Fix zap_small

---------

Co-authored-by: Daniel <mail@danielluedecke.de>
---
 R/format_table.R                    | 42 ++++++++++++++++++-----------
 man/export_table.Rd                 |  3 ++-
 man/format_table.Rd                 |  3 ++-
 tests/testthat/test-get_predicted.R |  1 -
 4 files changed, 30 insertions(+), 19 deletions(-)

diff --git a/R/format_table.R b/R/format_table.R
index f0c3bd740..8f0aa25ad 100644
--- a/R/format_table.R
+++ b/R/format_table.R
@@ -49,7 +49,8 @@
 #' @inheritParams format_value
 #' @inheritParams get_data
 #'
-#' @seealso Vignettes [Formatting, printing and exporting tables](https://easystats.github.io/insight/articles/display.html)
+#' @seealso Vignettes
+#' [Formatting, printing and exporting tables](https://easystats.github.io/insight/articles/display.html)
 #' and [Formatting model parameters](https://easystats.github.io/parameters/articles/model_parameters_formatting.html).
 #'
 #' @note `options(insight_use_symbols = TRUE)` override the `use_symbols` argument
@@ -163,13 +164,16 @@ format_table <- function(x,
 
 
   # Main CI and Prediction Intervals ----
-  x <- .format_main_ci_columns(x, att, ci_digits, ci_width, ci_brackets, zap_small)
-  x <- .format_main_ci_columns(x, att, ci_digits, ci_width, ci_brackets, zap_small, ci_name = "PI")
-  x <- .format_broom_ci_columns(x, ci_digits, ci_width, ci_brackets, zap_small)
+  x <- .format_main_ci_columns(x, att, ci_digits, zap_small, ci_width, ci_brackets)
+  x <- .format_main_ci_columns(x, att, ci_digits, zap_small, ci_width, ci_brackets, ci_name = "PI")
+  x <- .format_broom_ci_columns(x, ci_digits, zap_small, ci_width, ci_brackets)
 
 
+  # Misc / Effect Sizes
+  x <- .format_effectsize_columns(x, use_symbols)
+
   # Other CIs ----
-  out <- .format_other_ci_columns(x, att, ci_digits, ci_width, ci_brackets, zap_small)
+  out <- .format_other_ci_columns(x, att, ci_digits, zap_small, ci_width, ci_brackets)
   x <- out$x
   other_ci_colname <- out$other_ci_colname
 
@@ -189,8 +193,6 @@ format_table <- function(x,
   )
 
 
-  # Misc / Effect Sizes
-  x <- .format_effectsize_columns(x, use_symbols)
 
 
   # metafor ----
@@ -254,7 +256,7 @@ format_table <- function(x,
 # Format various p-values, coming from different easystats-packages
 # like bayestestR (p_ROPE, p_MAP) or performance (p_Chi2)
 
-.format_p_values <- function(x, stars = FALSE, p_digits) {
+.format_p_values <- function(x, p_digits, stars = FALSE) {
   # Specify stars for which column (#656)
   if (is.character(stars)) {
     starlist <- list("p" = FALSE)
@@ -337,6 +339,8 @@ format_table <- function(x,
 
 .format_effectsize_columns <- function(x, use_symbols) {
   names(x)[names(x) == "Cohens_d"] <- "Cohen's d"
+  names(x)[names(x) == "Cohens_d_CI_low"] <- "Cohen's d_CI_low"
+  names(x)[names(x) == "Cohens_d_CI_high"] <- "Cohen's d_CI_high"
   names(x)[names(x) == "Cohens_w"] <- "Cohen's w"
   names(x)[names(x) == "Cohens_h"] <- "Cohen's h"
   names(x)[names(x) == "Cohens_g"] <- "Cohen's g"
@@ -454,9 +458,9 @@ format_table <- function(x,
 .format_main_ci_columns <- function(x,
                                     att,
                                     ci_digits,
+                                    zap_small,
                                     ci_width = "auto",
                                     ci_brackets = TRUE,
-                                    zap_small,
                                     ci_name = "CI") {
   # Main CI
   ci_low <- names(x)[grep(paste0("^", ci_name, "_low"), names(x))]
@@ -525,7 +529,7 @@ format_table <- function(x,
 
 
 
-.format_other_ci_columns <- function(x, att, ci_digits, ci_width = "auto", ci_brackets = TRUE, zap_small) {
+.format_other_ci_columns <- function(x, att, ci_digits, zap_small, ci_width = "auto", ci_brackets = TRUE) {
   other_ci_low <- names(x)[endsWith(names(x), "_CI_low")]
   other_ci_high <- names(x)[endsWith(names(x), "_CI_high")]
   if (length(other_ci_low) >= 1 && length(other_ci_low) == length(other_ci_high)) {
@@ -575,9 +579,9 @@ format_table <- function(x,
 
 .format_broom_ci_columns <- function(x,
                                      ci_digits,
+                                     zap_small,
                                      ci_width = "auto",
-                                     ci_brackets = TRUE,
-                                     zap_small) {
+                                     ci_brackets = TRUE) {
   if (!any(grepl("conf.low", names(x), fixed = TRUE))) {
     return(x)
   }
@@ -609,7 +613,7 @@ format_table <- function(x,
 
 
 
-.format_rope_columns <- function(x, ci_width = "auto", ci_brackets = TRUE, zap_small) {
+.format_rope_columns <- function(x, zap_small, ci_width = "auto", ci_brackets = TRUE) {
   if (all(c("ROPE_low", "ROPE_high") %in% names(x))) {
     x$ROPE_low <- format_ci(
       x$ROPE_low,
@@ -659,9 +663,9 @@ format_table <- function(x,
 
 
 .format_bayes_columns <- function(x,
+                                  zap_small,
                                   stars = FALSE,
                                   rope_digits = 2,
-                                  zap_small,
                                   ci_width = "auto",
                                   ci_brackets = TRUE,
                                   exact = TRUE) {
@@ -694,11 +698,17 @@ format_table <- function(x,
   # Priors
   if ("Prior_Location" %in% names(x)) x$Prior_Location <- format_value(x$Prior_Location, protect_integers = TRUE)
   if ("Prior_Scale" %in% names(x)) x$Prior_Scale <- format_value(x$Prior_Scale, protect_integers = TRUE)
-  if ("Prior_Distribution" %in% names(x)) x$Prior_Distribution <- ifelse(is.na(x$Prior_Distribution), "", x$Prior_Distribution)
+  if ("Prior_Distribution" %in% names(x)) {
+    x$Prior_Distribution <- ifelse(
+      is.na(x$Prior_Distribution), "", x$Prior_Distribution
+    )
+  }
   if ("Prior_df" %in% names(x)) x$Prior_df <- format_value(x$Prior_df, protect_integers = TRUE)
   if (all(c("Prior_Distribution", "Prior_df") %in% names(x))) {
     missing_df <- is.na(x$Prior_df) | x$Prior_df == ""
-    x$Prior_Distribution[!missing_df] <- paste0(x$Prior_Distribution[!missing_df], " (df=", x$Prior_df[!missing_df], ")")
+    x$Prior_Distribution[!missing_df] <- paste0(
+      x$Prior_Distribution[!missing_df], " (df=", x$Prior_df[!missing_df], ")"
+    )
   }
   if (all(c("Prior_Distribution", "Prior_Location", "Prior_Scale") %in% names(x))) {
     x$Prior <- paste0(
diff --git a/man/export_table.Rd b/man/export_table.Rd
index d9048ef2f..fe8f30675 100644
--- a/man/export_table.Rd
+++ b/man/export_table.Rd
@@ -163,6 +163,7 @@ export_table(d, width = c(x = 5, z = 10))
 export_table(d, width = c(x = 5, y = 5, z = 10), align = "lcr")
 }
 \seealso{
-Vignettes \href{https://easystats.github.io/insight/articles/display.html}{Formatting, printing and exporting tables}
+Vignettes
+\href{https://easystats.github.io/insight/articles/display.html}{Formatting, printing and exporting tables}
 and \href{https://easystats.github.io/parameters/articles/model_parameters_formatting.html}{Formatting model parameters}.
 }
diff --git a/man/format_table.Rd b/man/format_table.Rd
index d805168ee..508984de0 100644
--- a/man/format_table.Rd
+++ b/man/format_table.Rd
@@ -111,6 +111,7 @@ if (require("rstanarm", warn.conflicts = FALSE) &&
 }
 }
 \seealso{
-Vignettes \href{https://easystats.github.io/insight/articles/display.html}{Formatting, printing and exporting tables}
+Vignettes
+\href{https://easystats.github.io/insight/articles/display.html}{Formatting, printing and exporting tables}
 and \href{https://easystats.github.io/parameters/articles/model_parameters_formatting.html}{Formatting model parameters}.
 }
diff --git a/tests/testthat/test-get_predicted.R b/tests/testthat/test-get_predicted.R
index 25a671b23..83b7e3406 100644
--- a/tests/testthat/test-get_predicted.R
+++ b/tests/testthat/test-get_predicted.R
@@ -648,4 +648,3 @@ test_that("zero-inflation stuff works", {
   expect_equal(p2, p4, tolerance = 1e-1, ignore_attr = TRUE)
   expect_equal(p3, p4, tolerance = 1e-1, ignore_attr = TRUE)
 })
-

From 5e1d59d2a72d7040eda90e81678c3674e1222263 Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Tue, 9 May 2023 18:00:43 +0200
Subject: [PATCH 43/98] `get_variance()` computes no fixed effects for rank
 deficient glmmTMB models (#766)

* `get_variance()` computes no fixed effects for rank deficient glmmTMB models
Fixes #765

* lintr

* add test

* add test

* finalize test

* code style

* news, desc
---
 DESCRIPTION                        |  2 +-
 NEWS.md                            |  3 +++
 R/compute_variances.R              |  7 +++++++
 tests/testthat/test-get_variance.R | 31 +++++++++++++++++++++++++-----
 4 files changed, 37 insertions(+), 6 deletions(-)

diff --git a/DESCRIPTION b/DESCRIPTION
index 4182c52f5..c4e2a0a9a 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -1,7 +1,7 @@
 Type: Package
 Package: insight
 Title: Easy Access to Model Information for Various Model Objects
-Version: 0.19.1.8
+Version: 0.19.1.9
 Authors@R: 
     c(person(given = "Daniel",
              family = "Lüdecke",
diff --git a/NEWS.md b/NEWS.md
index a2eda6ccc..a7a23801f 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -22,6 +22,9 @@
 
 ## Bug fixes
 
+* Fixed issue in `get_variance()` for *glmmTMB* models with rank deficient
+  coefficients.
+
 * Fixed issues in `get_weights()` for `glm` models without weights and `na.action`
   not set to default in the model call.
 
diff --git a/R/compute_variances.R b/R/compute_variances.R
index c95c26b36..7fa53c362 100644
--- a/R/compute_variances.R
+++ b/R/compute_variances.R
@@ -375,6 +375,13 @@
     format_warning(sprintf("%s ignores effects of dispersion model.", name_fun))
   }
 
+  # fix rank deficiency
+  rankdef <- is.na(vals$beta)
+  if (any(rankdef)) {
+    rankdef_names <- names(vals$beta)[rankdef]
+    vals$beta <- vals$beta[setdiff(names(vals$beta), rankdef_names)]
+  }
+
   vals
 }
 
diff --git a/tests/testthat/test-get_variance.R b/tests/testthat/test-get_variance.R
index c9e745943..344c2640f 100644
--- a/tests/testthat/test-get_variance.R
+++ b/tests/testthat/test-get_variance.R
@@ -241,14 +241,12 @@ m5 <- lme4::lmer(Reaction ~ Days + (0 + Days + Months | Subject), data = study_d
 
 test_that("random effects CIs, simple slope", {
   vc <- suppressWarnings(get_variance(m2))
-  expect_equal(
-    names(vc),
+  expect_named(
+    vc,
     c(
       "var.fixed", "var.random", "var.residual", "var.distribution",
       "var.dispersion", "var.slope"
-    ),
-    tolerance = 1e-3,
-    ignore_attr = TRUE
+    )
   )
 })
 
@@ -284,3 +282,26 @@ test_that("random effects CIs, poly slope", {
     ignore_attr = TRUE
   )
 })
+
+test_that("fixed effects variance for rank-deficient models, #765", {
+  skip_if_not_installed("glmmTMB", minimum_version = "1.1.8")
+  set.seed(101)
+  dd <- data.frame(
+    z = rnorm(1000),
+    x1 = 1:1000, x2 = runif(1000, 0, 10),
+    re = rep(1:20, each = 50)
+  )
+  dd <- dd |>
+    transform(x3 = as.factor(ifelse(x1 <= 500, "Low", sample(c("Middle", "High"), 1000, replace = TRUE)))) |>
+    transform(x4 = as.factor(ifelse(x1 > 500, "High", sample(c("Absent", "Low"), 1000, replace = TRUE)))) |>
+    transform(z = z + re * 5)
+
+  expect_message({
+    mod_TMB <- glmmTMB(z ~ x1 + x2 + x3 + x4 + (1 | re),
+      data = dd,
+      control = glmmTMBControl(rank_check = "adjust")
+    )
+  })
+  out <- insight::get_variance_fixed(mod_TMB)
+  expect_equal(c(var.fixed = 627.03661), tolerance = 1e-4)
+})

From 0a243d75f4cf59958730542f1d934460f29d621e Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Tue, 9 May 2023 21:57:37 +0200
Subject: [PATCH 44/98] Update test-get_predicted.R

---
 tests/testthat/test-get_predicted.R | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/testthat/test-get_predicted.R b/tests/testthat/test-get_predicted.R
index 83b7e3406..766e44127 100644
--- a/tests/testthat/test-get_predicted.R
+++ b/tests/testthat/test-get_predicted.R
@@ -560,6 +560,7 @@ test_that("bugfix: used to fail with matrix variables", {
 test_that("brms: `type` in ellipsis used to produce the wrong intervals", {
   skip_on_cran()
   skip_if_not_installed("brms")
+  skip_on_os(os = "windows")
   void <- capture.output(
     suppressMessages(mod <- brms::brm(am ~ hp + mpg,
       family = brms::bernoulli, data = mtcars,

From dfb0318c05dd1360ffeb2c930fc493bea41baa54 Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Tue, 9 May 2023 21:58:19 +0200
Subject: [PATCH 45/98] Update test-get_priors.R

---
 tests/testthat/test-get_priors.R | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/testthat/test-get_priors.R b/tests/testthat/test-get_priors.R
index 56115b6b6..7a783cda1 100644
--- a/tests/testthat/test-get_priors.R
+++ b/tests/testthat/test-get_priors.R
@@ -1,5 +1,5 @@
 test_that("get_priors", {
-  skip_on_os(os = "mac")
+  skip_on_os(os = c("mac", "windows"))
   skip_on_cran()
   skip_if_not_installed("brms")
 

From 1a0b15773db19b26097632220454a8cf4748e804 Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Tue, 9 May 2023 23:40:58 +0200
Subject: [PATCH 46/98] fix

---
 tests/testthat/test-get_variance.R | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/tests/testthat/test-get_variance.R b/tests/testthat/test-get_variance.R
index 344c2640f..acbc2e93a 100644
--- a/tests/testthat/test-get_variance.R
+++ b/tests/testthat/test-get_variance.R
@@ -291,10 +291,9 @@ test_that("fixed effects variance for rank-deficient models, #765", {
     x1 = 1:1000, x2 = runif(1000, 0, 10),
     re = rep(1:20, each = 50)
   )
-  dd <- dd |>
-    transform(x3 = as.factor(ifelse(x1 <= 500, "Low", sample(c("Middle", "High"), 1000, replace = TRUE)))) |>
-    transform(x4 = as.factor(ifelse(x1 > 500, "High", sample(c("Absent", "Low"), 1000, replace = TRUE)))) |>
-    transform(z = z + re * 5)
+  dd <- transform(dd, x3 = as.factor(ifelse(x1 <= 500, "Low", sample(c("Middle", "High"), 1000, replace = TRUE))))
+  dd <- transform(dd, x4 = as.factor(ifelse(x1 > 500, "High", sample(c("Absent", "Low"), 1000, replace = TRUE))))
+  dd <- transform(dd, z = z + re * 5)
 
   expect_message({
     mod_TMB <- glmmTMB(z ~ x1 + x2 + x3 + x4 + (1 | re),
@@ -302,6 +301,6 @@ test_that("fixed effects variance for rank-deficient models, #765", {
       control = glmmTMBControl(rank_check = "adjust")
     )
   })
-  out <- insight::get_variance_fixed(mod_TMB)
+  out <- get_variance_fixed(mod_TMB)
   expect_equal(c(var.fixed = 627.03661), tolerance = 1e-4)
 })

From 564add89c37fe519199d8fc63c8fa5a4a91f0a94 Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Wed, 10 May 2023 08:21:42 +0200
Subject: [PATCH 47/98] move back speedglm tests

---
 NEWS.md                                 |  3 ---
 {WIP => tests/testthat}/test-speedglm.R |  0
 {WIP => tests/testthat}/test-speedlm.R  | 26 ++++++++++++-------------
 3 files changed, 13 insertions(+), 16 deletions(-)
 rename {WIP => tests/testthat}/test-speedglm.R (100%)
 rename {WIP => tests/testthat}/test-speedlm.R (87%)

diff --git a/NEWS.md b/NEWS.md
index a7a23801f..8ceb7801a 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -4,9 +4,6 @@
 
 * The minimum needed R version has been bumped to `3.6`.
 
-* Tests for package *speedglm* were removed, because *speedglm* was archived on
-  CRAN.
-
 * `download_model()` no longer errors when a model object could not be downloaded,
   but instead returns `NULL`. This prevents test failures, and allows to skip
   tests when the return value of `download_model()` is `NULL`.
diff --git a/WIP/test-speedglm.R b/tests/testthat/test-speedglm.R
similarity index 100%
rename from WIP/test-speedglm.R
rename to tests/testthat/test-speedglm.R
diff --git a/WIP/test-speedlm.R b/tests/testthat/test-speedlm.R
similarity index 87%
rename from WIP/test-speedlm.R
rename to tests/testthat/test-speedlm.R
index 3b91dfb50..6df377a3a 100644
--- a/WIP/test-speedlm.R
+++ b/tests/testthat/test-speedlm.R
@@ -34,11 +34,11 @@ test_that("find_response", {
 })
 
 test_that("get_response", {
-  expect_equal(get_response(m1), iris$Sepal.Length)
+  expect_equal(get_response(m1), iris$Sepal.Length, ignore_attr = TRUE)
 })
 
 test_that("get_predictors", {
-  expect_equal(colnames(get_predictors(m1)), c("Petal.Width", "Species"))
+  expect_identical(colnames(get_predictors(m1)), c("Petal.Width", "Species"))
 })
 
 test_that("link_inverse", {
@@ -51,11 +51,11 @@ test_that("linkfun", {
 
 test_that("get_data", {
   expect_equal(nrow(get_data(m1)), 150)
-  expect_equal(
+  expect_identical(
     colnames(get_data(m1)),
     c("Sepal.Length", "Petal.Width", "Species")
   )
-  expect_equal(colnames(get_data(m2)), c("mpg", "hp", "cyl", "wt"))
+  expect_identical(colnames(get_data(m2)), c("mpg", "hp", "cyl", "wt"))
 })
 
 test_that("find_formula", {
@@ -77,18 +77,18 @@ test_that("find_formula", {
 })
 
 test_that("find_variables", {
-  expect_equal(
+  expect_identical(
     find_variables(m1),
     list(
       response = "Sepal.Length",
       conditional = c("Petal.Width", "Species")
     )
   )
-  expect_equal(
+  expect_identical(
     find_variables(m1, flatten = TRUE),
     c("Sepal.Length", "Petal.Width", "Species")
   )
-  expect_equal(
+  expect_identical(
     find_variables(m2, flatten = TRUE),
     c("mpg", "hp", "cyl", "wt")
   )
@@ -100,7 +100,7 @@ test_that("n_obs", {
 })
 
 test_that("find_parameters", {
-  expect_equal(
+  expect_identical(
     find_parameters(m1),
     list(
       conditional = c(
@@ -111,7 +111,7 @@ test_that("find_parameters", {
       )
     )
   )
-  expect_equal(
+  expect_identical(
     find_parameters(m2),
     list(
       conditional = c(
@@ -125,7 +125,7 @@ test_that("find_parameters", {
     )
   )
   expect_equal(nrow(get_parameters(m1)), 4)
-  expect_equal(
+  expect_identical(
     get_parameters(m1)$Parameter,
     c(
       "(Intercept)",
@@ -141,14 +141,14 @@ test_that("is_multivariate", {
 })
 
 test_that("find_terms", {
-  expect_equal(
+  expect_identical(
     find_terms(m1),
     list(
       response = "Sepal.Length",
       conditional = c("Petal.Width", "Species")
     )
   )
-  expect_equal(
+  expect_identical(
     find_terms(m2),
     list(
       response = "log(mpg)",
@@ -163,7 +163,7 @@ test_that("find_terms", {
 })
 
 test_that("find_algorithm", {
-  expect_equal(find_algorithm(m1), list(algorithm = "eigen"))
+  expect_identical(find_algorithm(m1), list(algorithm = "eigen"))
 })
 
 test_that("find_statistic", {

From 554faf615aef628ac2b4822cbb685efc983f3803 Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Wed, 10 May 2023 08:22:08 +0200
Subject: [PATCH 48/98] version bump

---
 DESCRIPTION | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/DESCRIPTION b/DESCRIPTION
index c4e2a0a9a..72341dde7 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -1,7 +1,7 @@
 Type: Package
 Package: insight
 Title: Easy Access to Model Information for Various Model Objects
-Version: 0.19.1.9
+Version: 0.19.1.10
 Authors@R: 
     c(person(given = "Daniel",
              family = "Lüdecke",

From 3ee61e41f2841dbb1171c31d9f4afcb88e21d2ec Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Sat, 13 May 2023 16:44:39 +0200
Subject: [PATCH 49/98] Dangerous `get_data()` behavior with `fixest` models
 and name conflicts (#768)

* Dangerous `get_data()` behavior with `fixest` models and name conflicts
Fixes #767

* check for NULL

* add tests

* typo
---
 R/get_data.R                   | 12 ++++++++++++
 tests/testthat/test-get_data.R | 27 +++++++++++++++++++++++++++
 2 files changed, 39 insertions(+)

diff --git a/R/get_data.R b/R/get_data.R
index 9af73b5f7..40b9c0684 100644
--- a/R/get_data.R
+++ b/R/get_data.R
@@ -239,6 +239,18 @@ get_data <- function(x, ...) {
     dat <- .safe(eval(model_call$data, envir = parent.env(x$call_env)))
   }
 
+  # special handling for fixest, see #767
+  if (inherits(x, "fixest") && !is.null(dat)) {
+    # when called from inside function, fixest seems to have a different
+    # environment that requires recovering from parent-environment
+    dat_fixest <- .safe(eval(model_call$data, envir = parent.env(x$call_env)))
+    # sanity check - does data from parent env. differ from current extracted
+    # data? If so, use data from parent env.
+    if (!is.null(dat_fixest) && (dim(dat_fixest)[1] == dim(dat)[1]) && (dim(dat_fixest)[2] != dim(dat)[2])) {
+      dat <- dat_fixest
+    }
+  }
+
   if (!is.null(dat) && object_has_names(model_call, "subset")) {
     dat <- subset(dat, subset = eval(model_call$subset))
   }
diff --git a/tests/testthat/test-get_data.R b/tests/testthat/test-get_data.R
index e91ff020a..7b4b4fa79 100644
--- a/tests/testthat/test-get_data.R
+++ b/tests/testthat/test-get_data.R
@@ -400,3 +400,30 @@ test_that("get_data colnames", {
   out <- get_data(m, additional_variables = TRUE)
   expect_true("qsec" %in% colnames(out))
 })
+
+
+test_that("get_data works for fixest inside functions", {
+  skip_if_not_installed("fixest")
+  data(mtcars)
+  # fit within function
+  fixest_wrapper <- function(data) {
+    data$cylinders <- factor(data$cyl)
+    fit <- fixest::feglm(mpg ~ cylinders * disp + hp, data = data)
+    return(fit)
+  }
+  global_fixest <- fixest_wrapper(data = mtcars)
+  data <- mtcars[, c("mpg", "disp")]
+  expect_named(
+    get_data(global_fixest),
+    c("mpg", "cylinders", "disp", "hp")
+  )
+
+  data(mtcars)
+  d_cyl <- mtcars
+  d_cyl$cylinders <- factor(d_cyl$cyl)
+  global_fixest <- fixest::feglm(mpg ~ cylinders * disp + hp, data = d_cyl)
+  expect_named(
+    get_data(global_fixest),
+    c("mpg", "cylinders", "disp", "hp")
+  )
+})

From 8535580c310db3d2b8eb5432bd7bce3bb3b1dd4e Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Mon, 15 May 2023 13:27:56 +0200
Subject: [PATCH 50/98] Dangerous `get_data()` behavior with `fixest` models
 and name conflicts (#769)

* Dangerous `get_data()` behavior with `fixest` models and name conflicts
Fixes #767

* test

* test

* fix test
---
 R/get_data.R                   | 37 +++++++++++++++++-----------------
 tests/testthat/test-get_data.R | 33 +++++++++++++++++++++++++-----
 2 files changed, 46 insertions(+), 24 deletions(-)

diff --git a/R/get_data.R b/R/get_data.R
index 40b9c0684..81f8bb9fb 100644
--- a/R/get_data.R
+++ b/R/get_data.R
@@ -209,16 +209,27 @@ get_data <- function(x, ...) {
     model_call[["data"]] <- as.name(data_name)
   }
 
-  # first, try environment of formula, see #666. set enclos = NULL so eval()
-  # does not fall back to parent frame when the environment is NULL, since we
-  # want to try that after checking the formula
-  dat <- .safe(eval(model_call$data, envir = environment(model_call$formula),
-                    enclos = NULL))
+  # special handling for fixest, see #767
+  if (inherits(x, "fixest")) {
+    # when called from inside function, fixest seems to have a different
+    # environment that requires recovering from parent-environment
+    dat <- .safe(eval(model_call$data, envir = parent.env(x$call_env)))
+  } else {
+    # first, try environment of formula, see #666. set enclos = NULL so eval()
+    # does not fall back to parent frame when the environment is NULL, since we
+    # want to try that after checking the formula
+    dat <- .safe(eval(model_call$data,
+      envir = environment(model_call$formula),
+      enclos = NULL
+    ))
+  }
 
   # second, try to extract formula directly
   if (is.null(dat)) {
-    dat <- .safe(eval(model_call$data, envir = environment(find_formula(x)$conditional),
-                      enclos = NULL))
+    dat <- .safe(eval(model_call$data,
+      envir = environment(find_formula(x)$conditional),
+      enclos = NULL
+    ))
   }
 
   # sanity check- if data frame is named like a function, e.g.
@@ -239,18 +250,6 @@ get_data <- function(x, ...) {
     dat <- .safe(eval(model_call$data, envir = parent.env(x$call_env)))
   }
 
-  # special handling for fixest, see #767
-  if (inherits(x, "fixest") && !is.null(dat)) {
-    # when called from inside function, fixest seems to have a different
-    # environment that requires recovering from parent-environment
-    dat_fixest <- .safe(eval(model_call$data, envir = parent.env(x$call_env)))
-    # sanity check - does data from parent env. differ from current extracted
-    # data? If so, use data from parent env.
-    if (!is.null(dat_fixest) && (dim(dat_fixest)[1] == dim(dat)[1]) && (dim(dat_fixest)[2] != dim(dat)[2])) {
-      dat <- dat_fixest
-    }
-  }
-
   if (!is.null(dat) && object_has_names(model_call, "subset")) {
     dat <- subset(dat, subset = eval(model_call$subset))
   }
diff --git a/tests/testthat/test-get_data.R b/tests/testthat/test-get_data.R
index 7b4b4fa79..ab151244d 100644
--- a/tests/testthat/test-get_data.R
+++ b/tests/testthat/test-get_data.R
@@ -405,25 +405,48 @@ test_that("get_data colnames", {
 test_that("get_data works for fixest inside functions", {
   skip_if_not_installed("fixest")
   data(mtcars)
+
   # fit within function
-  fixest_wrapper <- function(data) {
+  fixest_wrapper1 <- function(data) {
     data$cylinders <- factor(data$cyl)
     fit <- fixest::feglm(mpg ~ cylinders * disp + hp, data = data)
     return(fit)
   }
-  global_fixest <- fixest_wrapper(data = mtcars)
+  global_fixest1 <- fixest_wrapper1(data = mtcars)
   data <- mtcars[, c("mpg", "disp")]
   expect_named(
-    get_data(global_fixest),
+    get_data(global_fixest1),
+    c("mpg", "cylinders", "disp", "hp")
+  )
+
+  # fit within function, subset
+  fixest_wrapper2 <- function(data) {
+    data$cylinders <- factor(data$cyl)
+    fit <- fixest::feglm(mpg ~ cylinders * disp + hp, data = data)
+    return(fit)
+  }
+  data <- mtcars
+  global_fixest2 <- fixest_wrapper2(data = data[1:20, ])
+  expect_identical(nrow(get_data(global_fixest2)), 20L)
+  expect_named(
+    get_data(global_fixest2),
     c("mpg", "cylinders", "disp", "hp")
   )
 
   data(mtcars)
   d_cyl <- mtcars
   d_cyl$cylinders <- factor(d_cyl$cyl)
-  global_fixest <- fixest::feglm(mpg ~ cylinders * disp + hp, data = d_cyl)
+  global_fixest3 <- fixest::feglm(mpg ~ cylinders * disp + hp, data = d_cyl)
   expect_named(
-    get_data(global_fixest),
+    get_data(global_fixest3),
     c("mpg", "cylinders", "disp", "hp")
   )
+
+  # regular example
+  data(iris)
+  res <- fixest::feglm(Sepal.Length ~ Sepal.Width + Petal.Length | Species, iris, "poisson")
+  expect_named(
+    get_data(res),
+    c("Sepal.Length", "Sepal.Width", "Petal.Length", "Species")
+  )
 })

From 3270cd8d9ddc62841bd715ec7c1369a6de9f2bb2 Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Mon, 15 May 2023 15:13:40 +0200
Subject: [PATCH 51/98] `model_info()` fails for *gee* models (#771)

* `model_info()` fails for *gee* models
Fixes #770

* add test

* desc, news
---
 DESCRIPTION               |  2 +-
 NEWS.md                   |  2 ++
 R/utils_model_info.R      | 16 +++++++++----
 tests/testthat/test-gee.R | 48 +++++++++++++++++++++++++++------------
 4 files changed, 49 insertions(+), 19 deletions(-)

diff --git a/DESCRIPTION b/DESCRIPTION
index 72341dde7..2fcbd6361 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -1,7 +1,7 @@
 Type: Package
 Package: insight
 Title: Easy Access to Model Information for Various Model Objects
-Version: 0.19.1.10
+Version: 0.19.1.11
 Authors@R: 
     c(person(given = "Daniel",
              family = "Lüdecke",
diff --git a/NEWS.md b/NEWS.md
index 8ceb7801a..40be8cbd1 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -36,6 +36,8 @@
   by `scale()`, which were correctly handled only when `get_data()` failed to
   find the data in the appropriate environment.
 
+* Fixed issue in `model_info()` for `gee` models from `binomial` families.
+
 # insight 0.19.1
 
 ## New supported models
diff --git a/R/utils_model_info.R b/R/utils_model_info.R
index 8ac2971c2..626f2dc22 100644
--- a/R/utils_model_info.R
+++ b/R/utils_model_info.R
@@ -50,11 +50,19 @@
   is_bernoulli <- FALSE
 
   if (binom_fam && inherits(x, "glm") && !neg_bin_fam && !poisson_fam) {
-    resp <- stats::model.response(stats::model.frame(x))
-    if ((is.data.frame(resp) || is.matrix(resp)) && ncol(resp) == 1) {
-      resp <- as.vector(resp[[1]])
+    if (inherits(x, "gee")) {
+      resp <- .safe(get_response(x))
+    } else {
+      resp <- .safe(stats::model.response(stats::model.frame(x)))
     }
-    if (!is.data.frame(resp) && !is.matrix(resp) && all(.is.int(.factor_to_numeric(resp[[1]])))) {
+    if (!is.null(resp)) {
+      if ((is.data.frame(resp) || is.matrix(resp)) && ncol(resp) == 1) {
+        resp <- as.vector(resp[[1]])
+      }
+      if (!is.data.frame(resp) && !is.matrix(resp) && all(.is.int(.factor_to_numeric(resp[[1]])))) {
+        is_bernoulli <- TRUE
+      }
+    } else {
       is_bernoulli <- TRUE
     }
   } else if (fitfam %in% "bernoulli") {
diff --git a/tests/testthat/test-gee.R b/tests/testthat/test-gee.R
index 723d7ae53..4966ac58e 100644
--- a/tests/testthat/test-gee.R
+++ b/tests/testthat/test-gee.R
@@ -1,12 +1,32 @@
 skip_if_not_installed("gee")
 
 data(warpbreaks)
-void <- capture.output(suppressMessages(
+void <- capture.output(suppressMessages({
   m1 <- gee::gee(breaks ~ tension, id = wool, data = warpbreaks)
-))
+}))
+
+set.seed(123)
+n <- 600
+dat <- data.frame(
+  depression = rbinom(n, 1, prob = 0.15),
+  drug = rbinom(n, 1, prob = 0.5),
+  time = rep(1:3, n / 3),
+  id = rep(1:200, each = 3)
+)
+
+# test for #770
+junk <- capture.output({
+  dep_gee <- suppressMessages(gee::gee(depression ~ drug * time,
+    data = dat,
+    id = id,
+    family = binomial,
+    corstr = "independence"
+  ))
+})
 
 test_that("model_info", {
   expect_true(model_info(m1)$is_linear)
+  expect_true(model_info(dep_gee)$is_binomial)
 })
 
 test_that("find_predictors", {
@@ -27,11 +47,11 @@ test_that("find_response", {
 })
 
 test_that("get_response", {
-  expect_equal(get_response(m1), warpbreaks$breaks)
+  expect_equal(get_response(m1), warpbreaks$breaks, ignore_attr = TRUE)
 })
 
 test_that("find_random", {
-  expect_equal(find_random(m1), list(random = "wool"))
+  expect_identical(find_random(m1), list(random = "wool"))
 })
 
 test_that("get_random", {
@@ -39,7 +59,7 @@ test_that("get_random", {
 })
 
 test_that("get_predictors", {
-  expect_equal(get_predictors(m1), warpbreaks[, "tension", drop = FALSE])
+  expect_equal(get_predictors(m1), warpbreaks[, "tension", drop = FALSE], tolerance = 1e-4)
 })
 
 test_that("link_inverse", {
@@ -47,8 +67,8 @@ test_that("link_inverse", {
 })
 
 test_that("get_data", {
-  expect_equal(nrow(get_data(m1)), 54)
-  expect_equal(colnames(get_data(m1)), c("breaks", "tension", "wool"))
+  expect_identical(nrow(get_data(m1)), 54L)
+  expect_named(get_data(m1), c("breaks", "tension", "wool"))
 })
 
 test_that("find_formula", {
@@ -64,7 +84,7 @@ test_that("find_formula", {
 })
 
 test_that("find_terms", {
-  expect_equal(
+  expect_identical(
     find_terms(m1),
     list(
       response = "breaks",
@@ -72,14 +92,14 @@ test_that("find_terms", {
       random = "wool"
     )
   )
-  expect_equal(
+  expect_identical(
     find_terms(m1, flatten = TRUE),
     c("breaks", "tension", "wool")
   )
 })
 
 test_that("n_obs", {
-  expect_equal(n_obs(m1), 54)
+  expect_identical(n_obs(m1), 54L)
 })
 
 test_that("linkfun", {
@@ -87,14 +107,14 @@ test_that("linkfun", {
 })
 
 test_that("find_parameters", {
-  expect_equal(
+  expect_identical(
     find_parameters(m1),
     list(conditional = c(
       "(Intercept)", "tensionM", "tensionH"
     ))
   )
-  expect_equal(nrow(get_parameters(m1)), 3)
-  expect_equal(
+  expect_identical(nrow(get_parameters(m1)), 3L)
+  expect_identical(
     get_parameters(m1)$Parameter,
     c("(Intercept)", "tensionM", "tensionH")
   )
@@ -105,7 +125,7 @@ test_that("is_multivariate", {
 })
 
 test_that("find_algorithm", {
-  expect_equal(find_algorithm(m1), list(algorithm = "ML"))
+  expect_identical(find_algorithm(m1), list(algorithm = "ML"))
 })
 
 test_that("find_statistic", {

From 1ff6cd644321e1ee27704ae5386cdd6684279f5f Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Wed, 17 May 2023 00:13:14 +0200
Subject: [PATCH 52/98] fix format/print issues

---
 R/format_ci.R                         |  2 +-
 R/format_table.R                      |  7 +++-
 tests/testthat/_snaps/format_table.md | 16 +++++++++
 tests/testthat/test-format_table.R    | 52 ++++++++++++++++-----------
 tests/testthat/test-format_table_ci.R | 16 ++++-----
 5 files changed, 62 insertions(+), 31 deletions(-)
 create mode 100644 tests/testthat/_snaps/format_table.md

diff --git a/R/format_ci.R b/R/format_ci.R
index 1996de3b3..64bd6ae2d 100644
--- a/R/format_ci.R
+++ b/R/format_ci.R
@@ -51,7 +51,7 @@ format_ci <- function(CI_low,
     ci_brackets <- brackets
   }
 
-  if (!is.null(width) && width == "auto") {
+  if (!is.null(width) && all(width == "auto")) {
     # set default numeric value for digits
     sig_digits <- digits
 
diff --git a/R/format_table.R b/R/format_table.R
index 8f0aa25ad..3bfd1c477 100644
--- a/R/format_table.R
+++ b/R/format_table.R
@@ -692,7 +692,12 @@ format_table <- function(x,
     x$ROPE_Percentage <- format_rope(x$ROPE_Percentage, name = NULL, digits = rope_digits)
     names(x)[names(x) == "ROPE_Percentage"] <- "% in ROPE"
   }
-  x <- .format_rope_columns(x, ci_width, ci_brackets, zap_small)
+  x <- .format_rope_columns(
+    x,
+    zap_small = zap_small,
+    ci_width = ci_width,
+    ci_brackets = ci_brackets
+  )
 
 
   # Priors
diff --git a/tests/testthat/_snaps/format_table.md b/tests/testthat/_snaps/format_table.md
new file mode 100644
index 000000000..72e9cb0dd
--- /dev/null
+++ b/tests/testthat/_snaps/format_table.md
@@ -0,0 +1,16 @@
+# formatting ROPE CI
+
+    Code
+      print(parameters::equivalence_test(m10))
+    Output
+      # TOST-test for Practical Equivalence
+      
+        ROPE: [-0.83 0.83]
+      
+      Parameter            |         90% CI |   SGPV | Equivalence |      p
+      ---------------------------------------------------------------------
+      (Intercept)          | [16.39, 28.63] | < .001 |    Rejected | > .999
+      Sepal Width          | [ 6.28,  9.80] | < .001 |    Rejected | > .999
+      Species [versicolor] | [12.73, 16.44] | < .001 |    Rejected | > .999
+      Species [virginica]  | [17.81, 21.12] | < .001 |    Rejected | > .999
+
diff --git a/tests/testthat/test-format_table.R b/tests/testthat/test-format_table.R
index 2ab0866a0..9efc320a2 100644
--- a/tests/testthat/test-format_table.R
+++ b/tests/testthat/test-format_table.R
@@ -9,29 +9,29 @@ x <- suppressWarnings(as.data.frame(bayestestR::describe_posterior(m1, test = c(
 
 test_that("format_table with stars bayes", {
   out <- format_table(x)
-  expect_equal(colnames(out), c("Parameter", "Median", "95% CI", "pd", "Rhat", "ESS", "BF"))
-  expect_equal(out$BF, c("62.73", "114.21"))
-  expect_equal(out$pd, c("99.98%", "100%"))
+  expect_identical(colnames(out), c("Parameter", "Median", "95% CI", "pd", "Rhat", "ESS", "BF"))
+  expect_identical(out$BF, c("62.73", "114.21"))
+  expect_identical(out$pd, c("99.98%", "100%"))
 
   out <- format_table(x, stars = TRUE)
-  expect_equal(colnames(out), c("Parameter", "Median", "95% CI", "pd", "Rhat", "ESS", "BF"))
-  expect_equal(out$BF, c("62.73***", "114.21***"))
-  expect_equal(out$pd, c("99.98%***", "100%***"))
+  expect_identical(colnames(out), c("Parameter", "Median", "95% CI", "pd", "Rhat", "ESS", "BF"))
+  expect_identical(out$BF, c("62.73***", "114.21***"))
+  expect_identical(out$pd, c("99.98%***", "100%***"))
 
   out <- format_table(x, stars = c("pd", "BF"))
-  expect_equal(colnames(out), c("Parameter", "Median", "95% CI", "pd", "Rhat", "ESS", "BF"))
-  expect_equal(out$BF, c("62.73***", "114.21***"))
-  expect_equal(out$pd, c("99.98%***", "100%***"))
+  expect_identical(colnames(out), c("Parameter", "Median", "95% CI", "pd", "Rhat", "ESS", "BF"))
+  expect_identical(out$BF, c("62.73***", "114.21***"))
+  expect_identical(out$pd, c("99.98%***", "100%***"))
 
   out <- format_table(x, stars = "pd")
-  expect_equal(colnames(out), c("Parameter", "Median", "95% CI", "pd", "Rhat", "ESS", "BF"))
-  expect_equal(out$BF, c("62.73", "114.21"))
-  expect_equal(out$pd, c("99.98%***", "100%***"))
+  expect_identical(colnames(out), c("Parameter", "Median", "95% CI", "pd", "Rhat", "ESS", "BF"))
+  expect_identical(out$BF, c("62.73", "114.21"))
+  expect_identical(out$pd, c("99.98%***", "100%***"))
 
   out <- format_table(x, stars = "BF")
-  expect_equal(colnames(out), c("Parameter", "Median", "95% CI", "pd", "Rhat", "ESS", "BF"))
-  expect_equal(out$BF, c("62.73***", "114.21***"))
-  expect_equal(out$pd, c("99.98%", "100%"))
+  expect_identical(colnames(out), c("Parameter", "Median", "95% CI", "pd", "Rhat", "ESS", "BF"))
+  expect_identical(out$BF, c("62.73***", "114.21***"))
+  expect_identical(out$pd, c("99.98%", "100%"))
 })
 
 
@@ -41,18 +41,28 @@ x <- as.data.frame(parameters::model_parameters(lm(Sepal.Length ~ Species + Sepa
 
 test_that("format_table with stars freq", {
   out <- format_table(x)
-  expect_equal(colnames(out), c("Parameter", "Coefficient", "SE", "95% CI", "t(146)", "p"))
-  expect_equal(out$p, c("< .001", "< .001", "< .001", "< .001"))
+  expect_identical(colnames(out), c("Parameter", "Coefficient", "SE", "95% CI", "t(146)", "p"))
+  expect_identical(out$p, c("< .001", "< .001", "< .001", "< .001"))
 
   out <- format_table(x, stars = TRUE)
-  expect_equal(out$p, c("< .001***", "< .001***", "< .001***", "< .001***"))
+  expect_identical(out$p, c("< .001***", "< .001***", "< .001***", "< .001***"))
 
   out <- format_table(x, stars = c("pd", "BF"))
-  expect_equal(out$p, c("< .001", "< .001", "< .001", "< .001"))
+  expect_identical(out$p, c("< .001", "< .001", "< .001", "< .001"))
 
   out <- format_table(x, stars = "pd")
-  expect_equal(out$p, c("< .001", "< .001", "< .001", "< .001"))
+  expect_identical(out$p, c("< .001", "< .001", "< .001", "< .001"))
 
   out <- format_table(x, stars = c("BF", "p"))
-  expect_equal(out$p, c("< .001***", "< .001***", "< .001***", "< .001***"))
+  expect_identical(out$p, c("< .001***", "< .001***", "< .001***", "< .001***"))
+})
+
+# test for freq models -----------------
+skip_if_not_installed("parameters")
+test_that("formatting ROPE CI", {
+  data(iris)
+  d <- iris
+  d$Sepal.Length10 <- 10 * d$Sepal.Length
+  m10 <- lm(Sepal.Length10 ~ Sepal.Width + Species, data = d)
+  expect_snapshot(print(parameters::equivalence_test(m10)))
 })
diff --git a/tests/testthat/test-format_table_ci.R b/tests/testthat/test-format_table_ci.R
index d8267cbb6..4577ae3c6 100644
--- a/tests/testthat/test-format_table_ci.R
+++ b/tests/testthat/test-format_table_ci.R
@@ -1,16 +1,16 @@
 test_that("format_table with ci-level", {
   d <- data.frame(CI = 0.97, CI_low = 1, CI_high = 3)
   ft <- insight::format_table(d)
-  expect_equal(colnames(ft), "97% CI")
+  expect_named(ft, "97% CI")
 
   d$CI <- 0.788
   ft <- insight::format_table(d)
-  expect_equal(colnames(ft), "78.8% CI")
+  expect_named(ft, "78.8% CI")
 
   d$CI <- NULL
   attr(d, "ci") <- 0.9
   ft <- insight::format_table(d)
-  expect_equal(colnames(ft), "90% CI")
+  expect_named(ft, "90% CI")
 })
 
 test_that("format_table with multiple ci-levels", {
@@ -19,7 +19,7 @@ test_that("format_table with multiple ci-levels", {
     CI_low_0.2 = 1, CI_high_0.2 = 3
   )
   ft <- insight::format_table(d)
-  expect_equal(colnames(ft), c("97% CI", "20% CI"))
+  expect_named(ft, c("97% CI", "20% CI"))
 })
 
 
@@ -27,16 +27,16 @@ test_that("format_table with si-level", {
   d <- data.frame(CI = 0.97, CI_low = 1, CI_high = 3)
   attr(d, "ci_method") <- "SI"
   ft <- insight::format_table(d)
-  expect_equal(colnames(ft), "BF = 0.97 SI")
+  expect_named(ft, "BF = 0.97 SI")
 
   d$CI <- 0.788
   ft <- insight::format_table(d)
-  expect_equal(colnames(ft), "BF = 0.788 SI")
+  expect_named(ft, "BF = 0.788 SI")
 
   d$CI <- NULL
   attr(d, "ci") <- 0.9
   ft <- insight::format_table(d)
-  expect_equal(colnames(ft), "BF = 0.9 SI")
+  expect_named(ft, "BF = 0.9 SI")
 })
 
 
@@ -47,7 +47,7 @@ test_that("format_table with multiple si-levels", {
   )
   attr(d, "ci_method") <- "SI"
   ft <- insight::format_table(d)
-  expect_equal(colnames(ft), c("BF = 3 SI", "BF = 0.2 SI"))
+  expect_named(ft, c("BF = 3 SI", "BF = 0.2 SI"))
 })
 
 

From c078da468c06668a9ebe2db60f9c63f736bf646d Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Wed, 17 May 2023 00:13:30 +0200
Subject: [PATCH 53/98] desc

---
 DESCRIPTION | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/DESCRIPTION b/DESCRIPTION
index 2fcbd6361..aacb11580 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -1,7 +1,7 @@
 Type: Package
 Package: insight
 Title: Easy Access to Model Information for Various Model Objects
-Version: 0.19.1.11
+Version: 0.19.1.12
 Authors@R: 
     c(person(given = "Daniel",
              family = "Lüdecke",

From 867f2f868b5659b4baa6dbdeb96a354a8824a303 Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Wed, 17 May 2023 00:26:39 +0200
Subject: [PATCH 54/98] fix speedglm test

---
 tests/testthat/test-speedglm.R | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/testthat/test-speedglm.R b/tests/testthat/test-speedglm.R
index 08dd805a5..160a380f6 100644
--- a/tests/testthat/test-speedglm.R
+++ b/tests/testthat/test-speedglm.R
@@ -3,7 +3,7 @@ skip_if_not_installed("glmmTMB")
 data(Salamanders, package = "glmmTMB")
 Salamanders$cover <- abs(Salamanders$cover)
 
-m1 <- speedglm(
+m1 <- speedglm::speedglm(
   count ~ mined + log(cover) + sample,
   family = poisson(),
   data = Salamanders

From 90a4e262c2675e5a7cb40818e0cd3831131ac387 Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Wed, 17 May 2023 00:42:52 +0200
Subject: [PATCH 55/98] add speedglm to suggests

---
 DESCRIPTION | 1 +
 1 file changed, 1 insertion(+)

diff --git a/DESCRIPTION b/DESCRIPTION
index aacb11580..9c91390cb 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -177,6 +177,7 @@ Suggests:
     rstantools,
     rstudioapi,
     sandwich,
+    speedglm,
     splines,
     statmod,
     survey,

From 27c45eaa1736069343d35b2367bd7d0d901d1099 Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Sun, 21 May 2023 23:59:17 +0200
Subject: [PATCH 56/98] Support nestedLogit

---
 R/find_statistic.R     | 2 +-
 R/is_model.R           | 2 +-
 R/is_model_supported.R | 2 +-
 R/link_function.R      | 5 +++++
 R/link_inverse.R       | 4 ++++
 R/n_obs.R              | 4 ++++
 6 files changed, 16 insertions(+), 3 deletions(-)

diff --git a/R/find_statistic.R b/R/find_statistic.R
index 8b9fa83aa..7631ab154 100644
--- a/R/find_statistic.R
+++ b/R/find_statistic.R
@@ -127,7 +127,7 @@ find_statistic <- function(x, ...) {
     "margins", "marginaleffects", "marginaleffects.summary", "metaplus", "mixor",
     "MixMod", "mjoint", "mle", "mle2", "mlogit", "mblogit", "mclogit", "mmclogit",
     "mvmeta", "mvord",
-    "negbin", "negbinmfx", "negbinirr", "nlreg",
+    "negbin", "negbinmfx", "negbinirr", "nlreg", "nestedLogit",
     "objectiveML", "orm",
     "poissonmfx", "poissonirr", "psm", "probitmfx", "pgmm", "phyloglm",
     "qr", "QRNLMM", "QRLMM",
diff --git a/R/is_model.R b/R/is_model.R
index a6605a3ba..4f3417ca4 100644
--- a/R/is_model.R
+++ b/R/is_model.R
@@ -122,7 +122,7 @@ is_regression_model <- function(x) {
 
     # n --------------------
     "negbin", "negbinmfx", "negbinirr", "nlreg", "nlrq", "nls",
-    "nparLD",
+    "nparLD", "nestedLogit",
 
     # o --------------------
     "objectiveML", "ols", "osrt", "orcutt",
diff --git a/R/is_model_supported.R b/R/is_model_supported.R
index 8a462a0da..33608be57 100644
--- a/R/is_model_supported.R
+++ b/R/is_model_supported.R
@@ -92,7 +92,7 @@ supported_models <- function() {
     "multinom", "mvord", "mmclogit", "mmrm", "mmrm_fit", "mmrm_tmb",
 
     # n ----------------------------
-    "negbinmfx", "negbinirr",
+    "negbinmfx", "negbinirr", "nestedLogit",
 
     # o ----------------------------
     "ols", "onesampb", "orm",
diff --git a/R/link_function.R b/R/link_function.R
index 2b1fa09cf..bc345b25c 100644
--- a/R/link_function.R
+++ b/R/link_function.R
@@ -186,6 +186,11 @@ link_function.brglm <- link_function.default
 #' @export
 link_function.cgam <- link_function.default
 
+#' @export
+link_function.nestedLogit <- function(x, ...) {
+  stats::make.link(link = "logit")$linkfun
+}
+
 
 # Logit link ------------------------
 
diff --git a/R/link_inverse.R b/R/link_inverse.R
index 58de095ac..9e7284867 100644
--- a/R/link_inverse.R
+++ b/R/link_inverse.R
@@ -62,6 +62,10 @@ link_inverse.speedglm <- link_inverse.glm
 #' @export
 link_inverse.bigglm <- link_inverse.glm
 
+#' @export
+link_inverse.nestedLogit <- function(x, ...) {
+  stats::make.link(link = "logit")$linkinv
+}
 
 
 # Tobit Family ---------------------------------
diff --git a/R/n_obs.R b/R/n_obs.R
index cce4654c7..5fb13bc30 100644
--- a/R/n_obs.R
+++ b/R/n_obs.R
@@ -99,6 +99,10 @@ n_obs.glm <- function(x, disaggregate = FALSE, ...) {
 #' @export
 n_obs.censReg <- n_obs.default
 
+#' @export
+n_obs.nestedLogit <- function(x, disaggregate = FALSE, ...) {
+  lapply(x$models, n_obs)
+}
 
 #' @rdname n_obs
 #' @export

From 13172c33e31dd9c611f1000261bfb25bd3459404 Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Mon, 22 May 2023 14:40:14 +0200
Subject: [PATCH 57/98] NestedLogit (#773)

* Support nestedLogit

* namespace

* add methods

* get_varcov method

* more methods

* desc, news

* better response name

* also return component column

* fixes, add tests

* update readme

* add test

* enable component arg

* suggests

* tests

* wordlist

* suggests

* fix test
---
 DESCRIPTION                       |   7 +-
 NAMESPACE                         |  10 ++
 NEWS.md                           |   2 +-
 R/find_algorithm.R                |   6 ++
 R/find_parameters.R               |  19 ++++
 R/find_statistic.R                |   2 +-
 R/get_data.R                      |   9 ++
 R/get_parameters_others.R         |  29 +++++
 R/get_statistic.R                 |  34 ++++++
 R/get_varcov.R                    |  39 +++++++
 R/is_model.R                      |   2 +-
 R/is_model_supported.R            |   2 +-
 R/link_function.R                 |   5 +
 R/link_inverse.R                  |   4 +
 R/model_info.R                    |  14 +++
 R/n_obs.R                         |   4 +
 README.md                         |  67 ++++++------
 inst/WORDLIST                     |   1 +
 man/get_varcov.Rd                 |  10 ++
 man/insight-package.Rd            |   1 +
 tests/testthat/test-nestedLogit.R | 174 ++++++++++++++++++++++++++++++
 tests/testthat/test-speedlm.R     |   9 +-
 22 files changed, 407 insertions(+), 43 deletions(-)
 create mode 100644 tests/testthat/test-nestedLogit.R

diff --git a/DESCRIPTION b/DESCRIPTION
index 9c91390cb..b7ddd8cc1 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -1,7 +1,7 @@
 Type: Package
 Package: insight
 Title: Easy Access to Model Information for Various Model Objects
-Version: 0.19.1.12
+Version: 0.19.1.13
 Authors@R: 
     c(person(given = "Daniel",
              family = "Lüdecke",
@@ -97,6 +97,9 @@ Suggests:
     blme,
     boot,
     brms,
+    broom,
+    car,
+    carData,
     censReg,
     cgam,
     clubSandwich,
@@ -123,6 +126,7 @@ Suggests:
     GLMMadaptive,
     glmmTMB,
     gmnl,
+    grDevices,
     gt,
     httr,
     interp,
@@ -154,6 +158,7 @@ Suggests:
     mhurdle,
     mmrm,
     multgee,
+    nestedLogit,
     nlme,
     nnet,
     nonnest2,
diff --git a/NAMESPACE b/NAMESPACE
index 437f6eb90..5d4788eac 100644
--- a/NAMESPACE
+++ b/NAMESPACE
@@ -66,6 +66,7 @@ S3method(find_algorithm,logistf)
 S3method(find_algorithm,merMod)
 S3method(find_algorithm,merModList)
 S3method(find_algorithm,mixed)
+S3method(find_algorithm,nestedLogit)
 S3method(find_algorithm,rlmerMod)
 S3method(find_algorithm,rq)
 S3method(find_algorithm,rqss)
@@ -272,6 +273,7 @@ S3method(find_parameters,multinom)
 S3method(find_parameters,mvord)
 S3method(find_parameters,negbinirr)
 S3method(find_parameters,negbinmfx)
+S3method(find_parameters,nestedLogit)
 S3method(find_parameters,nlmerMod)
 S3method(find_parameters,nls)
 S3method(find_parameters,pgmm)
@@ -436,6 +438,7 @@ S3method(get_data,mmrm_tmb)
 S3method(get_data,model_fit)
 S3method(get_data,negbinirr)
 S3method(get_data,negbinmfx)
+S3method(get_data,nestedLogit)
 S3method(get_data,nlrq)
 S3method(get_data,nls)
 S3method(get_data,pgmm)
@@ -654,6 +657,7 @@ S3method(get_parameters,multinom)
 S3method(get_parameters,mvord)
 S3method(get_parameters,negbinirr)
 S3method(get_parameters,negbinmfx)
+S3method(get_parameters,nestedLogit)
 S3method(get_parameters,nlmerMod)
 S3method(get_parameters,orm)
 S3method(get_parameters,pgmm)
@@ -859,6 +863,7 @@ S3method(get_statistic,mvord)
 S3method(get_statistic,negbin)
 S3method(get_statistic,negbinirr)
 S3method(get_statistic,negbinmfx)
+S3method(get_statistic,nestedLogit)
 S3method(get_statistic,nlrq)
 S3method(get_statistic,ols)
 S3method(get_statistic,orm)
@@ -957,6 +962,7 @@ S3method(get_varcov,model_fit)
 S3method(get_varcov,mvord)
 S3method(get_varcov,negbinirr)
 S3method(get_varcov,negbinmfx)
+S3method(get_varcov,nestedLogit)
 S3method(get_varcov,nlrq)
 S3method(get_varcov,pgmm)
 S3method(get_varcov,poissonirr)
@@ -1091,6 +1097,7 @@ S3method(link_function,multinom)
 S3method(link_function,mvord)
 S3method(link_function,negbinirr)
 S3method(link_function,negbinmfx)
+S3method(link_function,nestedLogit)
 S3method(link_function,orm)
 S3method(link_function,phylolm)
 S3method(link_function,plm)
@@ -1211,6 +1218,7 @@ S3method(link_inverse,multinom)
 S3method(link_inverse,mvord)
 S3method(link_inverse,negbinirr)
 S3method(link_inverse,negbinmfx)
+S3method(link_inverse,nestedLogit)
 S3method(link_inverse,orm)
 S3method(link_inverse,phyloglm)
 S3method(link_inverse,phylolm)
@@ -1355,6 +1363,7 @@ S3method(model_info,multinom)
 S3method(model_info,mvord)
 S3method(model_info,negbinirr)
 S3method(model_info,negbinmfx)
+S3method(model_info,nestedLogit)
 S3method(model_info,nlrq)
 S3method(model_info,nls)
 S3method(model_info,orm)
@@ -1471,6 +1480,7 @@ S3method(n_obs,multinom)
 S3method(n_obs,mvord)
 S3method(n_obs,negbinirr)
 S3method(n_obs,negbinmfx)
+S3method(n_obs,nestedLogit)
 S3method(n_obs,nlrq)
 S3method(n_obs,phyloglm)
 S3method(n_obs,phylolm)
diff --git a/NEWS.md b/NEWS.md
index 40be8cbd1..e4f3ef66c 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -15,7 +15,7 @@
 
 ## New supported models
 
-* `phylolm` and `phyloglm` (package *phylolm*).
+* `phylolm` and `phyloglm` (package *phylolm*), `nestedLogit` (package *nestedLogit*).
 
 ## Bug fixes
 
diff --git a/R/find_algorithm.R b/R/find_algorithm.R
index debb28ff9..a21afa221 100644
--- a/R/find_algorithm.R
+++ b/R/find_algorithm.R
@@ -221,6 +221,12 @@ find_algorithm.glm <- function(x, ...) {
 }
 
 
+#' @export
+find_algorithm.nestedLogit <- function(x, ...) {
+  list("algorithm" = "ML")
+}
+
+
 #' @export
 find_algorithm.LORgee <- function(x, ...) {
   list("algorithm" = "Fisher's scoring ML")
diff --git a/R/find_parameters.R b/R/find_parameters.R
index 8e4c07f0b..50b74d25a 100644
--- a/R/find_parameters.R
+++ b/R/find_parameters.R
@@ -310,6 +310,25 @@ find_parameters.rms <- find_parameters.default
 find_parameters.tobit <- find_parameters.default
 
 
+#' @export
+find_parameters.nestedLogit <- function(x, flatten = FALSE, verbose = TRUE, ...) {
+  pars <- tryCatch(
+    {
+      p <- text_remove_backticks(row.names(stats::coef(x)))
+      list(conditional = p)
+    },
+    error = function(x) {
+      NULL
+    }
+  )
+  if (flatten) {
+    unique(unlist(pars, use.names = FALSE))
+  } else {
+    pars
+  }
+}
+
+
 #' @export
 find_parameters.Rchoice <- function(x, flatten = FALSE, ...) {
   cf <- names(stats::coef(x))
diff --git a/R/find_statistic.R b/R/find_statistic.R
index 8b9fa83aa..7631ab154 100644
--- a/R/find_statistic.R
+++ b/R/find_statistic.R
@@ -127,7 +127,7 @@ find_statistic <- function(x, ...) {
     "margins", "marginaleffects", "marginaleffects.summary", "metaplus", "mixor",
     "MixMod", "mjoint", "mle", "mle2", "mlogit", "mblogit", "mclogit", "mmclogit",
     "mvmeta", "mvord",
-    "negbin", "negbinmfx", "negbinirr", "nlreg",
+    "negbin", "negbinmfx", "negbinirr", "nlreg", "nestedLogit",
     "objectiveML", "orm",
     "poissonmfx", "poissonirr", "psm", "probitmfx", "pgmm", "phyloglm",
     "qr", "QRNLMM", "QRLMM",
diff --git a/R/get_data.R b/R/get_data.R
index 81f8bb9fb..4b53d9dc7 100644
--- a/R/get_data.R
+++ b/R/get_data.R
@@ -1759,6 +1759,15 @@ get_data.mle2 <- function(x, ...) {
 get_data.mle <- get_data.mle2
 
 
+#' @export
+get_data.nestedLogit <- function(x, ...) {
+  d <- x$data
+  if (!is.null(x$subset)) {
+    d <- subset(d, eval(parse(text = x$subset), envir = d))
+  }
+  d
+}
+
 
 #' @export
 get_data.glht <- function(x, source = "environment", verbose = TRUE, ...) {
diff --git a/R/get_parameters_others.R b/R/get_parameters_others.R
index 7f6cdc459..e8bda4dfb 100644
--- a/R/get_parameters_others.R
+++ b/R/get_parameters_others.R
@@ -38,6 +38,35 @@ get_parameters.betareg <- function(x,
 }
 
 
+#' @export
+get_parameters.nestedLogit <- function(x, component = "all", verbose = TRUE, ...) {
+  cf <- as.data.frame(stats::coef(x))
+  params <- .gather(cf, names_to = "Component", values_to = "Estimate")
+  response_levels <- unlist(lapply(x$dichotomies, function(i) {
+    paste0("{", toString(i[[1]]), "} vs. {", toString(i[[2]]), "}")
+  }))
+  params$Response <- rep(response_levels, each = nrow(cf))
+  params$Parameter <- rep(row.names(cf), times = ncol(cf))
+  row.names(params) <- NULL
+
+  if (!is.null(component) && !identical(component, "all")) {
+    comp <- intersect(names(x$models), component)
+    if (!length(comp) && verbose) {
+      format_alert(
+        paste0(
+          "No matching model found. Possible values for `component` are ",
+          toString(paste0("\"", names(x$models), "\"")),
+          "."
+        )
+      )
+    } else {
+      params <- params[params$Component %in% component, ]
+    }
+  }
+
+  text_remove_backticks(params[c("Parameter", "Estimate", "Response", "Component")])
+}
+
 
 #' @rdname get_parameters.betareg
 #' @export
diff --git a/R/get_statistic.R b/R/get_statistic.R
index 6fc0ab128..707c588ee 100644
--- a/R/get_statistic.R
+++ b/R/get_statistic.R
@@ -1118,6 +1118,40 @@ get_statistic.negbinirr <- get_statistic.logitor
 # Other models -------------------------------------------------------
 
 
+#' @export
+get_statistic.nestedLogit <- function(x, component = "all", verbose = TRUE, ...) {
+  cf <- as.data.frame(stats::coef(x))
+  out <- as.data.frame(do.call(rbind, lapply(x$models, function(i) stats::coef(summary(i)))))
+  colnames(out)[3] <- "Statistic"
+  response_levels <- unlist(lapply(x$dichotomies, function(i) {
+    paste0("{", toString(i[[1]]), "} vs. {", toString(i[[2]]), "}")
+  }))
+  out$Response <- rep(response_levels, each = nrow(cf))
+  out$Component <- rep(names(x$models), each = nrow(cf))
+  out$Parameter <- rep(row.names(cf), times = ncol(cf))
+
+  if (!is.null(component) && !identical(component, "all")) {
+    comp <- intersect(names(x$models), component)
+    if (!length(comp) && verbose) {
+      format_alert(
+        paste0(
+          "No matching model found. Possible values for `component` are ",
+          toString(paste0("\"", names(x$models), "\"")),
+          "."
+        )
+      )
+    } else {
+      out <- out[out$Component %in% component, ]
+    }
+  }
+
+  out <- text_remove_backticks(out[c("Parameter", "Statistic", "Response", "Component")])
+  row.names(out) <- NULL
+  attr(out, "statistic") <- find_statistic(x)
+  out
+}
+
+
 #' @export
 get_statistic.pgmm <- function(x,
                                component = c("conditional", "all"),
diff --git a/R/get_varcov.R b/R/get_varcov.R
index 70592b490..4771f164e 100644
--- a/R/get_varcov.R
+++ b/R/get_varcov.R
@@ -162,6 +162,45 @@ get_varcov.mlm <- function(x,
 # models with special components ---------------------------------------------
 
 
+#' @rdname get_varcov
+#' @export
+get_varcov.nestedLogit <- function(x,
+                                   component = "all",
+                                   verbose = TRUE,
+                                   vcov = NULL,
+                                   vcov_args = NULL,
+                                   ...) {
+  vcovs <- lapply(
+    x$models,
+    get_varcov,
+    verbose = verbose,
+    vcov = vcov,
+    vcov_args = vcov_args,
+    ...
+  )
+
+  if (identical(component, "all") || is.null(component)) {
+    return(vcovs)
+  }
+
+  comp <- intersect(names(vcovs), component)
+  if (!length(comp)) {
+    if (verbose) {
+      format_alert(
+        paste0(
+          "No matching model found. Possible values for `component` are ",
+          toString(paste0("\"", names(vcovs), "\"")),
+          "."
+        )
+      )
+    }
+    return(NULL)
+  }
+
+  vcovs[comp]
+}
+
+
 #' @rdname get_varcov
 #' @export
 get_varcov.betareg <- function(x,
diff --git a/R/is_model.R b/R/is_model.R
index a6605a3ba..4f3417ca4 100644
--- a/R/is_model.R
+++ b/R/is_model.R
@@ -122,7 +122,7 @@ is_regression_model <- function(x) {
 
     # n --------------------
     "negbin", "negbinmfx", "negbinirr", "nlreg", "nlrq", "nls",
-    "nparLD",
+    "nparLD", "nestedLogit",
 
     # o --------------------
     "objectiveML", "ols", "osrt", "orcutt",
diff --git a/R/is_model_supported.R b/R/is_model_supported.R
index 8a462a0da..33608be57 100644
--- a/R/is_model_supported.R
+++ b/R/is_model_supported.R
@@ -92,7 +92,7 @@ supported_models <- function() {
     "multinom", "mvord", "mmclogit", "mmrm", "mmrm_fit", "mmrm_tmb",
 
     # n ----------------------------
-    "negbinmfx", "negbinirr",
+    "negbinmfx", "negbinirr", "nestedLogit",
 
     # o ----------------------------
     "ols", "onesampb", "orm",
diff --git a/R/link_function.R b/R/link_function.R
index 2b1fa09cf..bc345b25c 100644
--- a/R/link_function.R
+++ b/R/link_function.R
@@ -186,6 +186,11 @@ link_function.brglm <- link_function.default
 #' @export
 link_function.cgam <- link_function.default
 
+#' @export
+link_function.nestedLogit <- function(x, ...) {
+  stats::make.link(link = "logit")$linkfun
+}
+
 
 # Logit link ------------------------
 
diff --git a/R/link_inverse.R b/R/link_inverse.R
index 58de095ac..9e7284867 100644
--- a/R/link_inverse.R
+++ b/R/link_inverse.R
@@ -62,6 +62,10 @@ link_inverse.speedglm <- link_inverse.glm
 #' @export
 link_inverse.bigglm <- link_inverse.glm
 
+#' @export
+link_inverse.nestedLogit <- function(x, ...) {
+  stats::make.link(link = "logit")$linkinv
+}
 
 
 # Tobit Family ---------------------------------
diff --git a/R/model_info.R b/R/model_info.R
index b5e92eddd..7731ec58e 100644
--- a/R/model_info.R
+++ b/R/model_info.R
@@ -1191,6 +1191,20 @@ model_info.polr <- function(x, ...) {
 
 
 
+#' @export
+model_info.nestedLogit <- function(x, ...) {
+  faminfo <- stats::binomial(link = "logit")
+  .make_family(
+    x = x,
+    fitfam = faminfo$family,
+    logit.link = TRUE,
+    link.fun = faminfo$link,
+    ...
+  )
+}
+
+
+
 #' @export
 model_info.hglm <- function(x, ...) {
   faminfo <- .safe({
diff --git a/R/n_obs.R b/R/n_obs.R
index cce4654c7..5fb13bc30 100644
--- a/R/n_obs.R
+++ b/R/n_obs.R
@@ -99,6 +99,10 @@ n_obs.glm <- function(x, disaggregate = FALSE, ...) {
 #' @export
 n_obs.censReg <- n_obs.default
 
+#' @export
+n_obs.nestedLogit <- function(x, disaggregate = FALSE, ...) {
+  lapply(x$models, n_obs)
+}
 
 #' @rdname n_obs
 #' @export
diff --git a/README.md b/README.md
index b7e31a212..38c369980 100644
--- a/README.md
+++ b/README.md
@@ -283,7 +283,7 @@ email or also file an issue.
 
 ## List of Supported Models by Class
 
-Currently, 224 model classes are supported.
+Currently, 225 model classes are supported.
 
 ``` r
 supported_models()
@@ -367,38 +367,39 @@ supported_models()
 #> [155] "mmrm_fit"                "mmrm_tmb"               
 #> [157] "model_fit"               "multinom"               
 #> [159] "mvord"                   "negbinirr"              
-#> [161] "negbinmfx"               "ols"                    
-#> [163] "onesampb"                "orm"                    
-#> [165] "pgmm"                    "phyloglm"               
-#> [167] "phylolm"                 "plm"                    
-#> [169] "PMCMR"                   "poissonirr"             
-#> [171] "poissonmfx"              "polr"                   
-#> [173] "probitmfx"               "psm"                    
-#> [175] "Rchoice"                 "ridgelm"                
-#> [177] "riskRegression"          "rjags"                  
-#> [179] "rlm"                     "rlmerMod"               
-#> [181] "RM"                      "rma"                    
-#> [183] "rma.uni"                 "robmixglm"              
-#> [185] "robtab"                  "rq"                     
-#> [187] "rqs"                     "rqss"                   
-#> [189] "rvar"                    "Sarlm"                  
-#> [191] "scam"                    "selection"              
-#> [193] "sem"                     "SemiParBIV"             
-#> [195] "semLm"                   "semLme"                 
-#> [197] "slm"                     "speedglm"               
-#> [199] "speedlm"                 "stanfit"                
-#> [201] "stanmvreg"               "stanreg"                
-#> [203] "summary.lm"              "survfit"                
-#> [205] "survreg"                 "svy_vglm"               
-#> [207] "svychisq"                "svyglm"                 
-#> [209] "svyolr"                  "t1way"                  
-#> [211] "tobit"                   "trimcibt"               
-#> [213] "truncreg"                "vgam"                   
-#> [215] "vglm"                    "wbgee"                  
-#> [217] "wblm"                    "wbm"                    
-#> [219] "wmcpAKP"                 "yuen"                   
-#> [221] "yuend"                   "zcpglm"                 
-#> [223] "zeroinfl"                "zerotrunc"
+#> [161] "negbinmfx"               "nestedLogit"            
+#> [163] "ols"                     "onesampb"               
+#> [165] "orm"                     "pgmm"                   
+#> [167] "phyloglm"                "phylolm"                
+#> [169] "plm"                     "PMCMR"                  
+#> [171] "poissonirr"              "poissonmfx"             
+#> [173] "polr"                    "probitmfx"              
+#> [175] "psm"                     "Rchoice"                
+#> [177] "ridgelm"                 "riskRegression"         
+#> [179] "rjags"                   "rlm"                    
+#> [181] "rlmerMod"                "RM"                     
+#> [183] "rma"                     "rma.uni"                
+#> [185] "robmixglm"               "robtab"                 
+#> [187] "rq"                      "rqs"                    
+#> [189] "rqss"                    "rvar"                   
+#> [191] "Sarlm"                   "scam"                   
+#> [193] "selection"               "sem"                    
+#> [195] "SemiParBIV"              "semLm"                  
+#> [197] "semLme"                  "slm"                    
+#> [199] "speedglm"                "speedlm"                
+#> [201] "stanfit"                 "stanmvreg"              
+#> [203] "stanreg"                 "summary.lm"             
+#> [205] "survfit"                 "survreg"                
+#> [207] "svy_vglm"                "svychisq"               
+#> [209] "svyglm"                  "svyolr"                 
+#> [211] "t1way"                   "tobit"                  
+#> [213] "trimcibt"                "truncreg"               
+#> [215] "vgam"                    "vglm"                   
+#> [217] "wbgee"                   "wblm"                   
+#> [219] "wbm"                     "wmcpAKP"                
+#> [221] "yuen"                    "yuend"                  
+#> [223] "zcpglm"                  "zeroinfl"               
+#> [225] "zerotrunc"
 ```
 
   - **Didn’t find a model?** [File an
diff --git a/inst/WORDLIST b/inst/WORDLIST
index 59fae093f..5851998d6 100644
--- a/inst/WORDLIST
+++ b/inst/WORDLIST
@@ -127,6 +127,7 @@ modelling
 multcomp
 mvord
 nd
+nestedLogit
 occurence
 optimizers
 patilindrajeets
diff --git a/man/get_varcov.Rd b/man/get_varcov.Rd
index 054734d4b..b29385629 100644
--- a/man/get_varcov.Rd
+++ b/man/get_varcov.Rd
@@ -3,6 +3,7 @@
 \name{get_varcov}
 \alias{get_varcov}
 \alias{get_varcov.default}
+\alias{get_varcov.nestedLogit}
 \alias{get_varcov.betareg}
 \alias{get_varcov.clm2}
 \alias{get_varcov.truncreg}
@@ -19,6 +20,15 @@ get_varcov(x, ...)
 
 \method{get_varcov}{default}(x, verbose = TRUE, vcov = NULL, vcov_args = NULL, ...)
 
+\method{get_varcov}{nestedLogit}(
+  x,
+  component = "all",
+  verbose = TRUE,
+  vcov = NULL,
+  vcov_args = NULL,
+  ...
+)
+
 \method{get_varcov}{betareg}(
   x,
   component = c("conditional", "precision", "all"),
diff --git a/man/insight-package.Rd b/man/insight-package.Rd
index 03f5feeea..55257ecb9 100644
--- a/man/insight-package.Rd
+++ b/man/insight-package.Rd
@@ -51,6 +51,7 @@ Other contributors:
   \item Alex Hayes \email{alexpghayes@gmail.com} (\href{https://orcid.org/0000-0002-4985-5160}{ORCID}) [reviewer]
   \item Grant McDermott \email{grantmcd@uoregon.edu} (\href{https://orcid.org/0000-0001-7883-8573}{ORCID}) [contributor]
   \item Rémi Thériault \email{remi.theriault@mail.mcgill.ca} (\href{https://orcid.org/0000-0003-4315-6788}{ORCID}) (@rempsyc) [contributor]
+  \item Alex Reinhart \email{areinhar@stat.cmu.edu} (\href{https://orcid.org/0000-0002-6658-514X}{ORCID}) [contributor]
 }
 
 }
diff --git a/tests/testthat/test-nestedLogit.R b/tests/testthat/test-nestedLogit.R
new file mode 100644
index 000000000..d565552a0
--- /dev/null
+++ b/tests/testthat/test-nestedLogit.R
@@ -0,0 +1,174 @@
+skip_if_not_installed("nestedLogit")
+skip_if_not_installed("broom")
+skip_if_not_installed("car")
+skip_if_not_installed("carData")
+
+data(Womenlf, package = "carData")
+
+comparisons <- nestedLogit::logits(
+  work = nestedLogit::dichotomy("not.work", working = c("parttime", "fulltime")),
+  full = nestedLogit::dichotomy("parttime", "fulltime")
+)
+
+mnl1 <- nestedLogit::nestedLogit(
+  partic ~ hincome + children,
+  dichotomies = comparisons,
+  data = Womenlf
+)
+
+mnl2 <- nestedLogit::nestedLogit(
+  partic ~ hincome + children,
+  dichotomies = comparisons,
+  subset = "region == 'Ontario'",
+  data = Womenlf
+)
+
+test_that("model_info", {
+  expect_true(model_info(mnl1)$is_logit)
+  expect_true(model_info(mnl2)$is_logit)
+})
+
+test_that("find_predictors", {
+  expect_identical(find_predictors(mnl1), list(conditional = c("hincome", "children")))
+  expect_identical(find_predictors(mnl2), list(conditional = c("hincome", "children")))
+  expect_identical(find_predictors(mnl1, flatten = TRUE), c("hincome", "children"))
+  expect_null(find_predictors(mnl1, effects = "random"))
+})
+
+test_that("find_random", {
+  expect_null(find_random(mnl1))
+})
+
+test_that("get_random", {
+  expect_warning(get_random(mnl1))
+})
+
+test_that("find_response", {
+  expect_identical(find_response(mnl1), "partic")
+  expect_identical(find_response(mnl2), "partic")
+})
+
+test_that("get_response", {
+  expect_equal(get_response(mnl1), Womenlf$partic, ignore_attr = TRUE)
+  expect_equal(get_response(mnl2), Womenlf$partic[Womenlf$region == "Ontario"], ignore_attr = TRUE)
+})
+
+test_that("get_predictors", {
+  expect_identical(colnames(get_predictors(mnl1)), c("hincome", "children"))
+  expect_identical(colnames(get_predictors(mnl2)), c("hincome", "children"))
+})
+
+test_that("get_data", {
+  expect_identical(nrow(get_data(mnl1)), 263L)
+  expect_identical(nrow(get_data(mnl2)), 108L)
+  expect_identical(colnames(get_data(mnl1)), c("partic", "hincome", "children", "region"))
+  expect_identical(colnames(get_data(mnl2)), c("partic", "hincome", "children", "region"))
+})
+
+test_that("find_formula", {
+  expect_length(find_formula(mnl1), 1)
+  expect_equal(
+    find_formula(mnl1),
+    list(conditional = as.formula("partic ~ hincome + children")),
+    ignore_attr = TRUE
+  )
+})
+
+test_that("find_variables", {
+  expect_identical(find_variables(mnl1), list(
+    response = "partic",
+    conditional = c("hincome", "children")
+  ))
+  expect_identical(
+    find_variables(mnl1, flatten = TRUE),
+    c("partic", "hincome", "children")
+  )
+})
+
+test_that("n_obs", {
+  expect_identical(n_obs(mnl1), list(work = 263L, full = 108L))
+  expect_identical(n_obs(mnl2), list(work = 108L, full = 44L))
+})
+
+test_that("linkfun", {
+  expect_equal(link_function(mnl1)(0.2), -1.386294, tolerance = 1e-3)
+  expect_equal(link_function(mnl2)(0.2), -1.386294, tolerance = 1e-3)
+})
+
+test_that("link_inverse", {
+  expect_equal(link_inverse(mnl1)(0.2), 0.549834, tolerance = 1e-3)
+  expect_equal(link_inverse(mnl2)(0.2), 0.549834, tolerance = 1e-3)
+})
+
+test_that("get_parameters", {
+  expect_identical(
+    find_parameters(mnl1),
+    list(conditional = c("(Intercept)", "hincome", "childrenpresent"))
+  )
+  expect_identical(nrow(get_parameters(mnl1)), 6L)
+  expect_identical(
+    get_parameters(mnl1)$Parameter,
+    c(
+      "(Intercept)", "hincome", "childrenpresent", "(Intercept)",
+      "hincome", "childrenpresent"
+    )
+  )
+  expect_equal(
+    get_parameters(mnl1)$Estimate,
+    unname(c(coef(mnl1)[, 1], coef(mnl1)[, 2])),
+    ignore_attr = TRUE
+  )
+  expect_equal(
+    get_parameters(mnl1, component = "full")$Estimate,
+    c(3.47777, -0.10727, -2.65146),
+    tolerance = 1e-3
+  )
+})
+
+test_that("is_multivariate", {
+  expect_false(is_multivariate(mnl1))
+})
+
+test_that("n_parameters", {
+  expect_identical(n_parameters(mnl1), 3L)
+})
+
+test_that("find_algorithm", {
+  expect_identical(find_algorithm(mnl1), list(algorithm = "ML"))
+})
+
+test_that("find_statistic", {
+  expect_identical(find_statistic(mnl1), "z-statistic")
+})
+
+test_that("get_statistic", {
+  expect_equal(
+    get_statistic(mnl1)$Statistic,
+    c(3.48087, -2.13894, -5.3912, 4.53361, -2.73976, -4.90035),
+    tolerance = 1e-3
+  )
+  expect_identical(
+    colnames(get_statistic(mnl1)),
+    c("Parameter", "Statistic", "Response", "Component")
+  )
+  expect_equal(
+    get_statistic(mnl1, component = "full")$Statistic,
+    c(4.53361, -2.73976, -4.90035),
+    tolerance = 1e-3
+  )
+  expect_message(get_statistic(mnl1, component = "msg"))
+})
+
+test_that("get_varcov", {
+  skip_if_not_installed("sandwich")
+  expect_equal(
+    diag(get_varcov(mnl1)$work),
+    c(`(Intercept)` = 0.14727, hincome = 0.00039, childrenpresent = 0.08542),
+    tolerance = 1e-3
+  )
+  expect_equal(
+    diag(get_varcov(mnl1, vcov = "HC3")$work),
+    c(`(Intercept)` = 0.17421, hincome = 0.00051, childrenpresent = 0.08741),
+    tolerance = 1e-3
+  )
+})
diff --git a/tests/testthat/test-speedlm.R b/tests/testthat/test-speedlm.R
index 6df377a3a..f8ce06676 100644
--- a/tests/testthat/test-speedlm.R
+++ b/tests/testthat/test-speedlm.R
@@ -2,11 +2,10 @@ skip_if_not_installed("speedglm")
 data(iris)
 data(mtcars)
 
-m1 <- speedlm(Sepal.Length ~ Petal.Width + Species, data = iris)
-m2 <-
-  speedlm(log(mpg) ~ log(hp) + cyl + I(cyl^2) + poly(wt, degree = 2, raw = TRUE),
-    data = mtcars
-  )
+m1 <- speedglm::speedlm(Sepal.Length ~ Petal.Width + Species, data = iris)
+m2 <- speedglm::speedlm(log(mpg) ~ log(hp) + cyl + I(cyl^2) + poly(wt, degree = 2, raw = TRUE),
+  data = mtcars
+)
 
 test_that("model_info", {
   expect_true(model_info(m1)$is_linear)

From 344c02c277fd7b9fd35a14c1688f6dfaac132af2 Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Mon, 22 May 2023 16:30:38 +0200
Subject: [PATCH 58/98] styler

---
 tests/testthat/test-get_data.R | 18 ++++++++++++------
 1 file changed, 12 insertions(+), 6 deletions(-)

diff --git a/tests/testthat/test-get_data.R b/tests/testthat/test-get_data.R
index ab151244d..5f94cc8fa 100644
--- a/tests/testthat/test-get_data.R
+++ b/tests/testthat/test-get_data.R
@@ -36,16 +36,20 @@ test_that("fetch from local, not global, environment", {
     return(lm(mpg ~ cylinders + disp, data = mtcars))
   }
 
-  expect_setequal(names(get_data(foo())),
-                  c("mpg", "disp", "cylinders"))
+  expect_setequal(
+    names(get_data(foo())),
+    c("mpg", "disp", "cylinders")
+  )
 })
 
 test_that("retrieve from call formula environment", {
   skip_if_not_installed("AER")
 
   foo <- function() {
-    d <- data.frame(y = rnorm(100),
-                    x = rnorm(100))
+    d <- data.frame(
+      y = rnorm(100),
+      x = rnorm(100)
+    )
 
     # find_formula(fit)$conditional happens to not have an environment for tobit
     # models, so get_data() should check environment(get_call(fit)$formula). See
@@ -53,8 +57,10 @@ test_that("retrieve from call formula environment", {
     return(AER::tobit(y ~ x, data = d, right = 1.5))
   }
 
-  expect_setequal(names(get_data(foo())),
-                  c("x", "y"))
+  expect_setequal(
+    names(get_data(foo())),
+    c("x", "y")
+  )
 })
 
 test_that("lme", {

From dd3dfac94f35c0ddacbc34fab625900522060685 Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Mon, 22 May 2023 17:12:50 +0200
Subject: [PATCH 59/98] check for NULL

---
 tests/testthat/test-GLMMadaptive.R      | 12 ++--
 tests/testthat/test-brms.R              | 91 +++++++++++++------------
 tests/testthat/test-format_table.R      |  2 +
 tests/testthat/test-gam.R               |  3 +
 tests/testthat/test-get_loglikelihood.R |  2 +
 tests/testthat/test-mvrstanarm.R        |  1 +
 tests/testthat/test-rstanarm.R          |  5 ++
 tests/testthat/test-spatial.R           |  1 +
 tests/testthat/test-vgam.R              |  3 +
 9 files changed, 72 insertions(+), 48 deletions(-)

diff --git a/tests/testthat/test-GLMMadaptive.R b/tests/testthat/test-GLMMadaptive.R
index 268b42235..67f1a7e80 100644
--- a/tests/testthat/test-GLMMadaptive.R
+++ b/tests/testthat/test-GLMMadaptive.R
@@ -5,6 +5,9 @@ skip_if_not_installed("lme4")
 m <- download_model("GLMMadaptive_zi_2")
 m2 <- download_model("GLMMadaptive_zi_1")
 
+skip_if(is.null(m))
+skip_if(is.null(m2))
+
 data(cbpp, package = "lme4")
 tmp <<- cbpp
 m3 <- GLMMadaptive::mixed_model(
@@ -68,7 +71,7 @@ test_that("find_predictors", {
   )
   expect_identical(
     find_predictors(m, effects = "all")$zero_inflated_random,
-    c("persons")
+    "persons"
   )
   expect_identical(find_predictors(m, effects = "random")$random, "persons")
   expect_identical(
@@ -167,15 +170,14 @@ test_that("clean_names", {
 
 test_that("find_formula", {
   expect_length(find_formula(m), 4)
-  expect_identical(
-    names(find_formula(m)),
+  expect_named(
+    find_formula(m),
     c(
       "conditional",
       "random",
       "zero_inflated",
       "zero_inflated_random"
-    ),
-    ignore_attr = TRUE
+    )
   )
 })
 
diff --git a/tests/testthat/test-brms.R b/tests/testthat/test-brms.R
index 05aa589d3..e01f972f7 100644
--- a/tests/testthat/test-brms.R
+++ b/tests/testthat/test-brms.R
@@ -1,3 +1,4 @@
+skip_on_cran()
 skip_if_offline()
 skip_if_not_installed("brms")
 
@@ -12,23 +13,27 @@ m6 <- insight::download_model("brms_corr_re1")
 m7 <- suppressWarnings(insight::download_model("brms_mixed_8"))
 m8 <- insight::download_model("brms_ordinal_1")
 
+all_loaded <- !vapply(list(m1, m2, m3, m4, m5, m6, m7, m8), is.null, TRUE)
+skip_if(!all(all_loaded))
+
 # Tests -------------------------------------------------------------------
 test_that("get_predicted.brmsfit: ordinal dv", {
   skip_if_not_installed("bayestestR")
+  skip_if_not_installed("rstantools")
 
   pred1 <- get_predicted(m8, ci = 0.95)
   pred2 <- get_predicted(m8, ci_method = "hdi", ci = 0.95)
-  expect_true(inherits(pred1, "get_predicted"))
-  expect_true(inherits(pred1, "data.frame"))
+  expect_s3_class(pred1, "get_predicted")
+  expect_s3_class(pred1, "data.frame")
   expect_true(all(c("Row", "Response") %in% colnames(pred1)))
 
   # ci_method changes intervals but not se or predicted
   pred1 <- data.frame(pred1)
   pred2 <- data.frame(pred2)
-  expect_equal(pred1$Row, pred2$Row)
-  expect_equal(pred1$Response, pred2$Response)
-  expect_equal(pred1$Predicted, pred2$Predicted)
-  expect_equal(pred1$SE, pred2$SE)
+  expect_equal(pred1$Row, pred2$Row, ignore_attr = TRUE)
+  expect_equal(pred1$Response, pred2$Response, ignore_attr = TRUE)
+  expect_equal(pred1$Predicted, pred2$Predicted, ignore_attr = TRUE)
+  expect_equal(pred1$SE, pred2$SE, ignore_attr = TRUE)
   expect_false(mean(pred1$CI_low == pred2$CI_low) > 0.1) # most CI bounds are different
   expect_false(mean(pred1$CI_high == pred2$CI_high) > 0.1) # most CI bounds are different
 
@@ -36,10 +41,10 @@ test_that("get_predicted.brmsfit: ordinal dv", {
   pred3 <- get_predicted(m8, centrality_function = stats::median, ci = 0.95)
   manual <- rstantools::posterior_epred(m8)
   manual <- apply(manual[, , 1], 2, median)
-  expect_equal(pred3$Predicted[1:32], manual)
+  expect_equal(pred3$Predicted[1:32], manual, ignore_attr = TRUE)
   manual <- rstantools::posterior_epred(m8)
   manual <- apply(manual[, , 1], 2, mean)
-  expect_equal(pred1$Predicted[1:32], manual)
+  expect_equal(pred1$Predicted[1:32], manual, ignore_attr = TRUE)
 })
 
 test_that("find_statistic", {
@@ -51,8 +56,8 @@ test_that("find_statistic", {
 })
 
 test_that("n_parameters", {
-  expect_equal(n_parameters(m1), 65)
-  expect_equal(n_parameters(m1, effects = "fixed"), 5)
+  expect_identical(n_parameters(m1), 65L)
+  expect_identical(n_parameters(m1, effects = "fixed"), 5L)
 })
 
 test_that("model_info", {
@@ -161,20 +166,20 @@ test_that("find_predictors", {
 })
 
 test_that("find_response", {
-  expect_equal(find_response(m1, combine = TRUE), "count")
-  expect_equal(
+  expect_identical(find_response(m1, combine = TRUE), "count")
+  expect_identical(
     find_response(m2, combine = TRUE),
     c(SepalLength = "Sepal.Length", SepalWidth = "Sepal.Width")
   )
-  expect_equal(find_response(m3, combine = TRUE), c("r", "n"))
-  expect_equal(find_response(m1, combine = FALSE), "count")
-  expect_equal(
+  expect_identical(find_response(m3, combine = TRUE), c("r", "n"))
+  expect_identical(find_response(m1, combine = FALSE), "count")
+  expect_identical(
     find_response(m2, combine = FALSE),
     c(SepalLength = "Sepal.Length", SepalWidth = "Sepal.Width")
   )
-  expect_equal(find_response(m3, combine = FALSE), c("r", "n"))
-  expect_equal(find_response(m4, combine = FALSE), "count")
-  expect_equal(
+  expect_identical(find_response(m3, combine = FALSE), c("r", "n"))
+  expect_identical(find_response(m4, combine = FALSE), "count")
+  expect_identical(
     find_response(m5, combine = TRUE),
     c(count = "count", count2 = "count2")
   )
@@ -182,15 +187,15 @@ test_that("find_response", {
 
 test_that("get_response", {
   expect_length(get_response(m1), 236)
-  expect_equal(ncol(get_response(m2)), 2)
-  expect_equal(
+  expect_identical(ncol(get_response(m2)), 2L)
+  expect_identical(
     colnames(get_response(m2)),
     c("Sepal.Length", "Sepal.Width")
   )
-  expect_equal(ncol(get_response(m3)), 2)
-  expect_equal(colnames(get_response(m3)), c("r", "n"))
+  expect_identical(ncol(get_response(m3)), 2L)
+  expect_identical(colnames(get_response(m3)), c("r", "n"))
   expect_length(get_response(m4), 250)
-  expect_equal(colnames(get_response(m5)), c("count", "count2"))
+  expect_identical(colnames(get_response(m5)), c("count", "count2"))
 })
 
 test_that("find_variables", {
@@ -264,16 +269,16 @@ test_that("find_variables", {
 })
 
 test_that("n_obs", {
-  expect_equal(n_obs(m1), 236)
-  expect_equal(n_obs(m2), 150)
-  expect_equal(n_obs(m3), 10)
-  expect_equal(n_obs(m4), 250)
-  expect_equal(n_obs(m5), 250)
+  expect_identical(n_obs(m1), 236L)
+  expect_identical(n_obs(m2), 150L)
+  expect_identical(n_obs(m3), 10L)
+  expect_identical(n_obs(m4), 250L)
+  expect_identical(n_obs(m5), 250L)
 })
 
 
 test_that("find_random", {
-  expect_equal(find_random(m5), list(
+  expect_identical(find_random(m5), list(
     count = list(
       random = "persons",
       zero_inflated_random = "persons"
@@ -283,8 +288,8 @@ test_that("find_random", {
       zero_inflated_random = "persons"
     )
   ))
-  expect_equal(find_random(m5, flatten = TRUE), "persons")
-  expect_equal(find_random(m6, flatten = TRUE), "id")
+  expect_identical(find_random(m5, flatten = TRUE), "persons")
+  expect_identical(find_random(m6, flatten = TRUE), "id")
 })
 
 
@@ -302,7 +307,7 @@ test_that("get_data", {
 
 
 test_that("find_paramaters", {
-  expect_equal(
+  expect_identical(
     find_parameters(m1),
     list(
       conditional = c(
@@ -316,7 +321,7 @@ test_that("find_paramaters", {
     )
   )
 
-  expect_equal(
+  expect_identical(
     find_parameters(m2),
     structure(
       list(
@@ -343,7 +348,7 @@ test_that("find_paramaters", {
     )
   )
 
-  expect_equal(
+  expect_identical(
     find_parameters(m4),
     list(
       conditional = c("b_Intercept", "b_child", "b_camper"),
@@ -353,7 +358,7 @@ test_that("find_paramaters", {
     )
   )
 
-  expect_equal(
+  expect_identical(
     find_parameters(m5, effects = "all"),
     structure(
       list(
@@ -380,7 +385,7 @@ test_that("find_paramaters", {
 })
 
 test_that("find_paramaters", {
-  expect_equal(
+  expect_identical(
     colnames(get_parameters(m4)),
     c(
       "b_Intercept",
@@ -391,11 +396,11 @@ test_that("find_paramaters", {
       "b_zi_camper"
     )
   )
-  expect_equal(
+  expect_identical(
     colnames(get_parameters(m4, component = "zi")),
     c("b_zi_Intercept", "b_zi_child", "b_zi_camper")
   )
-  expect_equal(
+  expect_identical(
     colnames(get_parameters(m4, effects = "all")),
     c(
       "b_Intercept", "b_child", "b_camper", "r_persons[1,Intercept]",
@@ -405,14 +410,14 @@ test_that("find_paramaters", {
       "r_persons__zi[4,Intercept]", "sd_persons__zi_Intercept"
     )
   )
-  expect_equal(
+  expect_identical(
     colnames(get_parameters(m4, effects = "random", component = "conditional")),
     c(
       "r_persons[1,Intercept]", "r_persons[2,Intercept]", "r_persons[3,Intercept]",
       "r_persons[4,Intercept]", "sd_persons__Intercept"
     )
   )
-  expect_equal(
+  expect_identical(
     colnames(get_parameters(m5, effects = "random", component = "conditional")),
     c(
       "r_persons__count[1,Intercept]", "r_persons__count[2,Intercept]",
@@ -423,7 +428,7 @@ test_that("find_paramaters", {
     )
   )
 
-  expect_equal(
+  expect_identical(
     colnames(get_parameters(m5, effects = "all", component = "all")),
     c(
       "b_count_Intercept", "b_count_child", "b_count_camper", "r_persons__count[1,Intercept]",
@@ -468,7 +473,7 @@ test_that("is_multivariate", {
 })
 
 test_that("find_terms", {
-  expect_equal(
+  expect_identical(
     find_terms(m2),
     list(
       SepalLength = list(
@@ -484,7 +489,7 @@ test_that("find_terms", {
 })
 
 test_that("find_algorithm", {
-  expect_equal(
+  expect_identical(
     find_algorithm(m1),
     list(
       algorithm = "sampling",
diff --git a/tests/testthat/test-format_table.R b/tests/testthat/test-format_table.R
index 9efc320a2..7992fe8f1 100644
--- a/tests/testthat/test-format_table.R
+++ b/tests/testthat/test-format_table.R
@@ -4,6 +4,8 @@ skip_if_not_installed("bayestestR")
 
 # test for bayesian models -----------------
 m1 <- insight::download_model("stanreg_glm_1")
+skip_if(is.null(m1))
+
 set.seed(123)
 x <- suppressWarnings(as.data.frame(bayestestR::describe_posterior(m1, test = c("pd", "bf"))))
 
diff --git a/tests/testthat/test-gam.R b/tests/testthat/test-gam.R
index ccb5de444..b1f0e86fb 100644
--- a/tests/testthat/test-gam.R
+++ b/tests/testthat/test-gam.R
@@ -28,6 +28,9 @@ m1 <- mgcv::gam(y ~ s(x0) + s(x1) + s(x2) + s(x3), data = dat2)
 m2 <- download_model("gam_zi_1")
 m3 <- download_model("gam_mv_1")
 
+skip_if(is.null(m2))
+skip_if(is.null(m3))
+
 test_that("model_info", {
   expect_true(model_info(m1)$is_linear)
   expect_true(model_info(m2)$is_count)
diff --git a/tests/testthat/test-get_loglikelihood.R b/tests/testthat/test-get_loglikelihood.R
index e51b223e7..b9b7cc4d1 100644
--- a/tests/testthat/test-get_loglikelihood.R
+++ b/tests/testthat/test-get_loglikelihood.R
@@ -94,10 +94,12 @@ test_that("get_loglikelihood - (g)lmer", {
   expect_equal(as.numeric(ll), as.numeric(ll2))
 
   model <- download_model("lmerMod_1")
+  skip_if(is.null(model))
   expect_equal(get_loglikelihood(model, estimator = "REML"), logLik(model, REML = TRUE), tolerance = 0.01, ignore_attr = TRUE)
   expect_equal(get_loglikelihood(model, estimator = "ML"), logLik(model, REML = FALSE), tolerance = 0.01, ignore_attr = TRUE)
 
   model <- download_model("merMod_1")
+  skip_if(is.null(model))
   expect_equal(get_loglikelihood(model, estimator = "REML"), logLik(model, REML = FALSE), tolerance = 0.01, ignore_attr = TRUE)
   expect_equal(get_loglikelihood(model, estimator = "ML"), logLik(model, REML = FALSE), tolerance = 0.01, ignore_attr = TRUE)
 })
diff --git a/tests/testthat/test-mvrstanarm.R b/tests/testthat/test-mvrstanarm.R
index 015399cf0..b1c04f33b 100644
--- a/tests/testthat/test-mvrstanarm.R
+++ b/tests/testthat/test-mvrstanarm.R
@@ -4,6 +4,7 @@ skip_if_not_installed("rstanarm")
 
 data("pbcLong", package = "rstanarm")
 m1 <- download_model("stanmvreg_1")
+skip_if(is.null(m1))
 
 test_that("clean_names", {
   expect_identical(
diff --git a/tests/testthat/test-rstanarm.R b/tests/testthat/test-rstanarm.R
index ea6baae2a..9adea7f17 100644
--- a/tests/testthat/test-rstanarm.R
+++ b/tests/testthat/test-rstanarm.R
@@ -16,6 +16,10 @@ m1 <- insight::download_model("stanreg_merMod_5")
 m2 <- insight::download_model("stanreg_glm_6")
 m3 <- insight::download_model("stanreg_glm_1")
 
+skip_if(is.null(m1))
+skip_if(is.null(m2))
+skip_if(is.null(m3))
+
 data("puzzles", package = "BayesFactor")
 m4 <- suppressWarnings(
   stan_glm(
@@ -38,6 +42,7 @@ m5 <- suppressWarnings(
   )
 )
 m6 <- insight::download_model("stanreg_gamm4_1")
+skip_if(is.null(m6))
 
 m7 <- suppressWarnings(
   stan_lm(mpg ~ wt + qsec + am,
diff --git a/tests/testthat/test-spatial.R b/tests/testthat/test-spatial.R
index 4d13bbd51..32399382d 100644
--- a/tests/testthat/test-spatial.R
+++ b/tests/testthat/test-spatial.R
@@ -16,6 +16,7 @@ d <- data.frame(
 dat <<- d
 
 m1 <- download_model("glmmTMB_spatial_1")
+skip_if(is.null(m1))
 
 test_that("find_weights", {
   expect_null(find_weights(m1))
diff --git a/tests/testthat/test-vgam.R b/tests/testthat/test-vgam.R
index ee87a3a60..2bc6f8fe8 100644
--- a/tests/testthat/test-vgam.R
+++ b/tests/testthat/test-vgam.R
@@ -6,6 +6,9 @@ data("hunua", package = "VGAM")
 m1 <- download_model("vgam_1")
 m2 <- download_model("vgam_2")
 
+skip_if(is.null(m1))
+skip_if(is.null(m2))
+
 test_that("model_info", {
   expect_true(model_info(m1)$is_binomial)
   expect_true(model_info(m2)$is_binomial)

From 24281e2b3a8c407b7f32d9c56eab4804677e44bd Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Mon, 22 May 2023 20:04:45 +0200
Subject: [PATCH 60/98] check for NULL (#774)

* check for NULL

* fix?

* lintr

* fix test

* fix
---
 tests/testthat/test-GLMMadaptive.R      | 12 ++--
 tests/testthat/test-brms.R              | 89 +++++++++++++------------
 tests/testthat/test-find_weights.R      |  2 +
 tests/testthat/test-format_table.R      |  3 +
 tests/testthat/test-gam.R               |  3 +
 tests/testthat/test-get_loglikelihood.R |  2 +
 tests/testthat/test-mvrstanarm.R        |  1 +
 tests/testthat/test-rstanarm.R          |  5 ++
 tests/testthat/test-spatial.R           |  1 +
 tests/testthat/test-vgam.R              | 47 +++++++------
 10 files changed, 96 insertions(+), 69 deletions(-)

diff --git a/tests/testthat/test-GLMMadaptive.R b/tests/testthat/test-GLMMadaptive.R
index 268b42235..67f1a7e80 100644
--- a/tests/testthat/test-GLMMadaptive.R
+++ b/tests/testthat/test-GLMMadaptive.R
@@ -5,6 +5,9 @@ skip_if_not_installed("lme4")
 m <- download_model("GLMMadaptive_zi_2")
 m2 <- download_model("GLMMadaptive_zi_1")
 
+skip_if(is.null(m))
+skip_if(is.null(m2))
+
 data(cbpp, package = "lme4")
 tmp <<- cbpp
 m3 <- GLMMadaptive::mixed_model(
@@ -68,7 +71,7 @@ test_that("find_predictors", {
   )
   expect_identical(
     find_predictors(m, effects = "all")$zero_inflated_random,
-    c("persons")
+    "persons"
   )
   expect_identical(find_predictors(m, effects = "random")$random, "persons")
   expect_identical(
@@ -167,15 +170,14 @@ test_that("clean_names", {
 
 test_that("find_formula", {
   expect_length(find_formula(m), 4)
-  expect_identical(
-    names(find_formula(m)),
+  expect_named(
+    find_formula(m),
     c(
       "conditional",
       "random",
       "zero_inflated",
       "zero_inflated_random"
-    ),
-    ignore_attr = TRUE
+    )
   )
 })
 
diff --git a/tests/testthat/test-brms.R b/tests/testthat/test-brms.R
index 05aa589d3..d07aeba85 100644
--- a/tests/testthat/test-brms.R
+++ b/tests/testthat/test-brms.R
@@ -1,3 +1,4 @@
+skip_on_cran()
 skip_if_offline()
 skip_if_not_installed("brms")
 
@@ -12,23 +13,27 @@ m6 <- insight::download_model("brms_corr_re1")
 m7 <- suppressWarnings(insight::download_model("brms_mixed_8"))
 m8 <- insight::download_model("brms_ordinal_1")
 
+all_loaded <- !vapply(list(m1, m2, m3, m4, m5, m6, m7, m8), is.null, TRUE)
+skip_if(!all(all_loaded))
+
 # Tests -------------------------------------------------------------------
 test_that("get_predicted.brmsfit: ordinal dv", {
   skip_if_not_installed("bayestestR")
+  skip_if_not_installed("rstantools")
 
   pred1 <- get_predicted(m8, ci = 0.95)
   pred2 <- get_predicted(m8, ci_method = "hdi", ci = 0.95)
-  expect_true(inherits(pred1, "get_predicted"))
-  expect_true(inherits(pred1, "data.frame"))
+  expect_s3_class(pred1, "get_predicted")
+  expect_s3_class(pred1, "data.frame")
   expect_true(all(c("Row", "Response") %in% colnames(pred1)))
 
   # ci_method changes intervals but not se or predicted
   pred1 <- data.frame(pred1)
   pred2 <- data.frame(pred2)
-  expect_equal(pred1$Row, pred2$Row)
-  expect_equal(pred1$Response, pred2$Response)
-  expect_equal(pred1$Predicted, pred2$Predicted)
-  expect_equal(pred1$SE, pred2$SE)
+  expect_equal(pred1$Row, pred2$Row, ignore_attr = TRUE)
+  expect_equal(pred1$Response, pred2$Response, ignore_attr = TRUE)
+  expect_equal(pred1$Predicted, pred2$Predicted, ignore_attr = TRUE)
+  expect_equal(pred1$SE, pred2$SE, ignore_attr = TRUE)
   expect_false(mean(pred1$CI_low == pred2$CI_low) > 0.1) # most CI bounds are different
   expect_false(mean(pred1$CI_high == pred2$CI_high) > 0.1) # most CI bounds are different
 
@@ -36,10 +41,10 @@ test_that("get_predicted.brmsfit: ordinal dv", {
   pred3 <- get_predicted(m8, centrality_function = stats::median, ci = 0.95)
   manual <- rstantools::posterior_epred(m8)
   manual <- apply(manual[, , 1], 2, median)
-  expect_equal(pred3$Predicted[1:32], manual)
+  expect_equal(pred3$Predicted[1:32], manual, ignore_attr = TRUE)
   manual <- rstantools::posterior_epred(m8)
   manual <- apply(manual[, , 1], 2, mean)
-  expect_equal(pred1$Predicted[1:32], manual)
+  expect_equal(pred1$Predicted[1:32], manual, ignore_attr = TRUE)
 })
 
 test_that("find_statistic", {
@@ -51,8 +56,8 @@ test_that("find_statistic", {
 })
 
 test_that("n_parameters", {
-  expect_equal(n_parameters(m1), 65)
-  expect_equal(n_parameters(m1, effects = "fixed"), 5)
+  expect_identical(n_parameters(m1), 65L)
+  expect_identical(n_parameters(m1, effects = "fixed"), 5L)
 })
 
 test_that("model_info", {
@@ -161,20 +166,20 @@ test_that("find_predictors", {
 })
 
 test_that("find_response", {
-  expect_equal(find_response(m1, combine = TRUE), "count")
-  expect_equal(
+  expect_identical(find_response(m1, combine = TRUE), "count")
+  expect_identical(
     find_response(m2, combine = TRUE),
     c(SepalLength = "Sepal.Length", SepalWidth = "Sepal.Width")
   )
-  expect_equal(find_response(m3, combine = TRUE), c("r", "n"))
-  expect_equal(find_response(m1, combine = FALSE), "count")
-  expect_equal(
+  expect_identical(find_response(m3, combine = TRUE), c("r", "n"))
+  expect_identical(find_response(m1, combine = FALSE), "count")
+  expect_identical(
     find_response(m2, combine = FALSE),
     c(SepalLength = "Sepal.Length", SepalWidth = "Sepal.Width")
   )
-  expect_equal(find_response(m3, combine = FALSE), c("r", "n"))
-  expect_equal(find_response(m4, combine = FALSE), "count")
-  expect_equal(
+  expect_identical(find_response(m3, combine = FALSE), c("r", "n"))
+  expect_identical(find_response(m4, combine = FALSE), "count")
+  expect_identical(
     find_response(m5, combine = TRUE),
     c(count = "count", count2 = "count2")
   )
@@ -182,15 +187,15 @@ test_that("find_response", {
 
 test_that("get_response", {
   expect_length(get_response(m1), 236)
-  expect_equal(ncol(get_response(m2)), 2)
-  expect_equal(
+  expect_identical(ncol(get_response(m2)), 2L)
+  expect_identical(
     colnames(get_response(m2)),
     c("Sepal.Length", "Sepal.Width")
   )
-  expect_equal(ncol(get_response(m3)), 2)
-  expect_equal(colnames(get_response(m3)), c("r", "n"))
+  expect_identical(ncol(get_response(m3)), 2L)
+  expect_identical(colnames(get_response(m3)), c("r", "n"))
   expect_length(get_response(m4), 250)
-  expect_equal(colnames(get_response(m5)), c("count", "count2"))
+  expect_identical(colnames(get_response(m5)), c("count", "count2"))
 })
 
 test_that("find_variables", {
@@ -264,16 +269,16 @@ test_that("find_variables", {
 })
 
 test_that("n_obs", {
-  expect_equal(n_obs(m1), 236)
-  expect_equal(n_obs(m2), 150)
-  expect_equal(n_obs(m3), 10)
-  expect_equal(n_obs(m4), 250)
-  expect_equal(n_obs(m5), 250)
+  expect_identical(n_obs(m1), 236L)
+  expect_identical(n_obs(m2), 150L)
+  expect_identical(n_obs(m3), 10L)
+  expect_identical(n_obs(m4), 250L)
+  expect_identical(n_obs(m5), 250L)
 })
 
 
 test_that("find_random", {
-  expect_equal(find_random(m5), list(
+  expect_identical(find_random(m5), list(
     count = list(
       random = "persons",
       zero_inflated_random = "persons"
@@ -283,8 +288,8 @@ test_that("find_random", {
       zero_inflated_random = "persons"
     )
   ))
-  expect_equal(find_random(m5, flatten = TRUE), "persons")
-  expect_equal(find_random(m6, flatten = TRUE), "id")
+  expect_identical(find_random(m5, flatten = TRUE), "persons")
+  expect_identical(find_random(m6, flatten = TRUE), "id")
 })
 
 
@@ -302,7 +307,7 @@ test_that("get_data", {
 
 
 test_that("find_paramaters", {
-  expect_equal(
+  expect_identical(
     find_parameters(m1),
     list(
       conditional = c(
@@ -316,7 +321,7 @@ test_that("find_paramaters", {
     )
   )
 
-  expect_equal(
+  expect_identical(
     find_parameters(m2),
     structure(
       list(
@@ -343,7 +348,7 @@ test_that("find_paramaters", {
     )
   )
 
-  expect_equal(
+  expect_identical(
     find_parameters(m4),
     list(
       conditional = c("b_Intercept", "b_child", "b_camper"),
@@ -353,7 +358,7 @@ test_that("find_paramaters", {
     )
   )
 
-  expect_equal(
+  expect_identical(
     find_parameters(m5, effects = "all"),
     structure(
       list(
@@ -380,7 +385,7 @@ test_that("find_paramaters", {
 })
 
 test_that("find_paramaters", {
-  expect_equal(
+  expect_identical(
     colnames(get_parameters(m4)),
     c(
       "b_Intercept",
@@ -391,11 +396,11 @@ test_that("find_paramaters", {
       "b_zi_camper"
     )
   )
-  expect_equal(
+  expect_identical(
     colnames(get_parameters(m4, component = "zi")),
     c("b_zi_Intercept", "b_zi_child", "b_zi_camper")
   )
-  expect_equal(
+  expect_identical(
     colnames(get_parameters(m4, effects = "all")),
     c(
       "b_Intercept", "b_child", "b_camper", "r_persons[1,Intercept]",
@@ -405,14 +410,14 @@ test_that("find_paramaters", {
       "r_persons__zi[4,Intercept]", "sd_persons__zi_Intercept"
     )
   )
-  expect_equal(
+  expect_identical(
     colnames(get_parameters(m4, effects = "random", component = "conditional")),
     c(
       "r_persons[1,Intercept]", "r_persons[2,Intercept]", "r_persons[3,Intercept]",
       "r_persons[4,Intercept]", "sd_persons__Intercept"
     )
   )
-  expect_equal(
+  expect_identical(
     colnames(get_parameters(m5, effects = "random", component = "conditional")),
     c(
       "r_persons__count[1,Intercept]", "r_persons__count[2,Intercept]",
@@ -423,7 +428,7 @@ test_that("find_paramaters", {
     )
   )
 
-  expect_equal(
+  expect_identical(
     colnames(get_parameters(m5, effects = "all", component = "all")),
     c(
       "b_count_Intercept", "b_count_child", "b_count_camper", "r_persons__count[1,Intercept]",
@@ -468,7 +473,7 @@ test_that("is_multivariate", {
 })
 
 test_that("find_terms", {
-  expect_equal(
+  expect_identical(
     find_terms(m2),
     list(
       SepalLength = list(
diff --git a/tests/testthat/test-find_weights.R b/tests/testthat/test-find_weights.R
index 495e95b70..dd010acf9 100644
--- a/tests/testthat/test-find_weights.R
+++ b/tests/testthat/test-find_weights.R
@@ -1,12 +1,14 @@
 skip_if_not_installed("lme4")
 
 test_that("find_weights", {
+  data(mtcars)
   mtcars$weight <- rnorm(nrow(mtcars), 1, 0.3)
   m <- lm(mpg ~ wt + cyl + vs, data = mtcars, weights = weight)
   expect_identical(find_weights(m), "weight")
 })
 
 test_that("find_weights", {
+  data(iris)
   iris$wgt <- rnorm(nrow(iris), 1, 0.3)
   m <- lme4::lmer(Sepal.Width ~ Sepal.Length + (1 | Species), data = iris, weights = wgt)
   expect_identical(find_weights(m), "wgt")
diff --git a/tests/testthat/test-format_table.R b/tests/testthat/test-format_table.R
index 9efc320a2..3018e67c8 100644
--- a/tests/testthat/test-format_table.R
+++ b/tests/testthat/test-format_table.R
@@ -1,9 +1,12 @@
 skip_if_offline()
 skip_on_os(c("mac", "linux", "solaris"))
 skip_if_not_installed("bayestestR")
+skip_if_not_installed("rstanarm")
 
 # test for bayesian models -----------------
 m1 <- insight::download_model("stanreg_glm_1")
+skip_if(is.null(m1))
+
 set.seed(123)
 x <- suppressWarnings(as.data.frame(bayestestR::describe_posterior(m1, test = c("pd", "bf"))))
 
diff --git a/tests/testthat/test-gam.R b/tests/testthat/test-gam.R
index ccb5de444..b1f0e86fb 100644
--- a/tests/testthat/test-gam.R
+++ b/tests/testthat/test-gam.R
@@ -28,6 +28,9 @@ m1 <- mgcv::gam(y ~ s(x0) + s(x1) + s(x2) + s(x3), data = dat2)
 m2 <- download_model("gam_zi_1")
 m3 <- download_model("gam_mv_1")
 
+skip_if(is.null(m2))
+skip_if(is.null(m3))
+
 test_that("model_info", {
   expect_true(model_info(m1)$is_linear)
   expect_true(model_info(m2)$is_count)
diff --git a/tests/testthat/test-get_loglikelihood.R b/tests/testthat/test-get_loglikelihood.R
index e51b223e7..b9b7cc4d1 100644
--- a/tests/testthat/test-get_loglikelihood.R
+++ b/tests/testthat/test-get_loglikelihood.R
@@ -94,10 +94,12 @@ test_that("get_loglikelihood - (g)lmer", {
   expect_equal(as.numeric(ll), as.numeric(ll2))
 
   model <- download_model("lmerMod_1")
+  skip_if(is.null(model))
   expect_equal(get_loglikelihood(model, estimator = "REML"), logLik(model, REML = TRUE), tolerance = 0.01, ignore_attr = TRUE)
   expect_equal(get_loglikelihood(model, estimator = "ML"), logLik(model, REML = FALSE), tolerance = 0.01, ignore_attr = TRUE)
 
   model <- download_model("merMod_1")
+  skip_if(is.null(model))
   expect_equal(get_loglikelihood(model, estimator = "REML"), logLik(model, REML = FALSE), tolerance = 0.01, ignore_attr = TRUE)
   expect_equal(get_loglikelihood(model, estimator = "ML"), logLik(model, REML = FALSE), tolerance = 0.01, ignore_attr = TRUE)
 })
diff --git a/tests/testthat/test-mvrstanarm.R b/tests/testthat/test-mvrstanarm.R
index 015399cf0..b1c04f33b 100644
--- a/tests/testthat/test-mvrstanarm.R
+++ b/tests/testthat/test-mvrstanarm.R
@@ -4,6 +4,7 @@ skip_if_not_installed("rstanarm")
 
 data("pbcLong", package = "rstanarm")
 m1 <- download_model("stanmvreg_1")
+skip_if(is.null(m1))
 
 test_that("clean_names", {
   expect_identical(
diff --git a/tests/testthat/test-rstanarm.R b/tests/testthat/test-rstanarm.R
index ea6baae2a..9adea7f17 100644
--- a/tests/testthat/test-rstanarm.R
+++ b/tests/testthat/test-rstanarm.R
@@ -16,6 +16,10 @@ m1 <- insight::download_model("stanreg_merMod_5")
 m2 <- insight::download_model("stanreg_glm_6")
 m3 <- insight::download_model("stanreg_glm_1")
 
+skip_if(is.null(m1))
+skip_if(is.null(m2))
+skip_if(is.null(m3))
+
 data("puzzles", package = "BayesFactor")
 m4 <- suppressWarnings(
   stan_glm(
@@ -38,6 +42,7 @@ m5 <- suppressWarnings(
   )
 )
 m6 <- insight::download_model("stanreg_gamm4_1")
+skip_if(is.null(m6))
 
 m7 <- suppressWarnings(
   stan_lm(mpg ~ wt + qsec + am,
diff --git a/tests/testthat/test-spatial.R b/tests/testthat/test-spatial.R
index 4d13bbd51..32399382d 100644
--- a/tests/testthat/test-spatial.R
+++ b/tests/testthat/test-spatial.R
@@ -16,6 +16,7 @@ d <- data.frame(
 dat <<- d
 
 m1 <- download_model("glmmTMB_spatial_1")
+skip_if(is.null(m1))
 
 test_that("find_weights", {
   expect_null(find_weights(m1))
diff --git a/tests/testthat/test-vgam.R b/tests/testthat/test-vgam.R
index ee87a3a60..3d96e0208 100644
--- a/tests/testthat/test-vgam.R
+++ b/tests/testthat/test-vgam.R
@@ -6,6 +6,9 @@ data("hunua", package = "VGAM")
 m1 <- download_model("vgam_1")
 m2 <- download_model("vgam_2")
 
+skip_if(is.null(m1))
+skip_if(is.null(m2))
+
 test_that("model_info", {
   expect_true(model_info(m1)$is_binomial)
   expect_true(model_info(m2)$is_binomial)
@@ -53,8 +56,8 @@ test_that("get_response", {
 })
 
 test_that("get_predictors", {
-  expect_equal(colnames(get_predictors(m1)), c("vitluc", "altitude"))
-  expect_equal(colnames(get_predictors(m2)), c("vitluc", "altitude"))
+  expect_identical(colnames(get_predictors(m1)), c("vitluc", "altitude"))
+  expect_identical(colnames(get_predictors(m2)), c("vitluc", "altitude"))
 })
 
 test_that("link_inverse", {
@@ -63,10 +66,10 @@ test_that("link_inverse", {
 })
 
 test_that("get_data", {
-  expect_equal(nrow(get_data(m1)), 392)
-  expect_equal(nrow(get_data(m2)), 392)
-  expect_equal(colnames(get_data(m1)), c("agaaus", "vitluc", "altitude"))
-  expect_equal(
+  expect_identical(nrow(get_data(m1)), 392L)
+  expect_identical(nrow(get_data(m2)), 392L)
+  expect_identical(colnames(get_data(m1)), c("agaaus", "vitluc", "altitude"))
+  expect_identical(
     colnames(get_data(m2)),
     c("agaaus", "kniexc", "vitluc", "altitude")
   )
@@ -90,25 +93,25 @@ test_that("find_formula", {
 })
 
 test_that("find_terms", {
-  expect_equal(
+  expect_identical(
     find_terms(m1),
     list(
       response = "agaaus",
       conditional = c("vitluc", "s(altitude, df = 2)")
     )
   )
-  expect_equal(
+  expect_identical(
     find_terms(m1, flatten = TRUE),
     c("agaaus", "vitluc", "s(altitude, df = 2)")
   )
-  expect_equal(
+  expect_identical(
     find_terms(m2),
     list(
       response = "cbind(agaaus, kniexc)",
       conditional = c("vitluc", "s(altitude, df = c(2, 3))")
     )
   )
-  expect_equal(
+  expect_identical(
     find_terms(m2, flatten = TRUE),
     c(
       "cbind(agaaus, kniexc)",
@@ -119,30 +122,30 @@ test_that("find_terms", {
 })
 
 test_that("find_variables", {
-  expect_equal(
+  expect_identical(
     find_variables(m1),
     list(
       response = "agaaus",
       conditional = c("vitluc", "altitude")
     )
   )
-  expect_equal(
+  expect_identical(
     find_variables(m1, flatten = TRUE),
     c("agaaus", "vitluc", "altitude")
   )
-  expect_equal(find_variables(m2), list(
+  expect_identical(find_variables(m2), list(
     response = c("agaaus", "kniexc"),
     conditional = c("vitluc", "altitude")
   ))
-  expect_equal(
+  expect_identical(
     find_variables(m2, flatten = TRUE),
     c("agaaus", "kniexc", "vitluc", "altitude")
   )
 })
 
 test_that("n_obs", {
-  expect_equal(n_obs(m1), 392)
-  expect_equal(n_obs(m2), 392)
+  expect_identical(n_obs(m1), 392L)
+  expect_identical(n_obs(m2), 392L)
 })
 
 test_that("linkfun", {
@@ -151,20 +154,20 @@ test_that("linkfun", {
 })
 
 test_that("find_parameters", {
-  expect_equal(
+  expect_identical(
     find_parameters(m1),
     list(
       conditional = c("(Intercept)", "vitluc"),
       smooth_terms = "s(altitude, df = 2)"
     )
   )
-  expect_equal(nrow(get_parameters(m1)), 3)
-  expect_equal(
+  expect_identical(nrow(get_parameters(m1)), 3L)
+  expect_identical(
     get_parameters(m1)$Parameter,
     c("(Intercept)", "vitluc", "s(altitude, df = 2)")
   )
 
-  expect_equal(
+  expect_identical(
     find_parameters(m2),
     list(
       conditional = c(
@@ -176,8 +179,8 @@ test_that("find_parameters", {
       smooth_terms = c("s(altitude, df = c(2, 3)):1", "s(altitude, df = c(2, 3)):2")
     )
   )
-  expect_equal(nrow(get_parameters(m2)), 6)
-  expect_equal(
+  expect_identical(nrow(get_parameters(m2)), 6L)
+  expect_identical(
     get_parameters(m2)$Parameter,
     c(
       "(Intercept):1",

From 2cbe467503fc7994f6b08b65456f1d1a77677796 Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Tue, 23 May 2023 10:02:32 +0200
Subject: [PATCH 61/98] update cran comments

---
 cran-comments.md | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/cran-comments.md b/cran-comments.md
index 1c6b4a9b1..8d3450e3f 100644
--- a/cran-comments.md
+++ b/cran-comments.md
@@ -1,8 +1,6 @@
 ## revdepcheck results
 
-We checked 33 reverse dependencies, comparing R CMD check results across CRAN and dev versions of this package.
+We checked 35 reverse dependencies, comparing R CMD check results across CRAN and dev versions of this package.
 
- * We saw no new problem
+ * We saw 0 new problems
  * We failed to check 0 packages
-
-There are errors in the CRAN check results (https://www.r-project.org/nosvn/R.check/r-devel-linux-x86_64-debian-gcc/insight-00check.html), however, these are not related to the *insight* package, but rather upstream-issues from the *tibble* package (https://cran.r-project.org/web/checks/check_results_tibble.html). The errors for *insight* should resolve once the issues in the *tibble* package are fixed.
\ No newline at end of file

From 5a964abe9d54f161b4d29c9eaa316ebdb2e1cc26 Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Tue, 23 May 2023 10:04:26 +0200
Subject: [PATCH 62/98] prepare CRAN submission

---
 DESCRIPTION | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/DESCRIPTION b/DESCRIPTION
index b7ddd8cc1..7b5019f68 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -1,7 +1,7 @@
 Type: Package
 Package: insight
 Title: Easy Access to Model Information for Various Model Objects
-Version: 0.19.1.13
+Version: 0.19.2
 Authors@R: 
     c(person(given = "Daniel",
              family = "Lüdecke",
@@ -196,7 +196,7 @@ VignetteBuilder:
     knitr
 Encoding: UTF-8
 Language: en-US
-RoxygenNote: 7.2.3.9000
+RoxygenNote: 7.2.3
 Roxygen: list(markdown = TRUE)
 Config/testthat/edition: 3
 Config/testthat/parallel: true

From b1f98dc71b71200ea2242b01be6c4ff45924c9f4 Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Tue, 23 May 2023 18:20:16 +0200
Subject: [PATCH 63/98] prepare CRAN submission (#775)

* prepare CRAN submission

* fix test

* minor

* disable tests on CRAN for now

* fix test

* fix

* todo, code-style, deprecation warning

* submitted
---
 CRAN-SUBMISSION                    |  6 +++---
 DESCRIPTION                        |  4 ++--
 R/export_table.R                   |  3 ---
 R/find_formula.R                   |  4 ++--
 R/get_deviance.R                   |  9 +--------
 R/get_loglikelihood.R              |  2 +-
 R/get_predicted_args.R             |  2 +-
 R/model_info.R                     | 14 +++++++++++++-
 tests/testthat/test-brms.R         |  2 +-
 tests/testthat/test-clmm.R         | 31 +++++++++++++++---------------
 tests/testthat/test-glmmTMB.R      |  2 ++
 tests/testthat/test-is_converged.R |  1 +
 12 files changed, 43 insertions(+), 37 deletions(-)

diff --git a/CRAN-SUBMISSION b/CRAN-SUBMISSION
index 353a436eb..4738a0ad0 100644
--- a/CRAN-SUBMISSION
+++ b/CRAN-SUBMISSION
@@ -1,3 +1,3 @@
-Version: 0.19.1
-Date: 2023-03-18 17:27:10 UTC
-SHA: cb60a11164fde497abc08c0d99bca8be3a6702c4
+Version: 0.19.2
+Date: 2023-05-23 15:29:06 UTC
+SHA: aff90a1106ec876c55d22aa833b27d2c5192d2cd
diff --git a/DESCRIPTION b/DESCRIPTION
index b7ddd8cc1..7b5019f68 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -1,7 +1,7 @@
 Type: Package
 Package: insight
 Title: Easy Access to Model Information for Various Model Objects
-Version: 0.19.1.13
+Version: 0.19.2
 Authors@R: 
     c(person(given = "Daniel",
              family = "Lüdecke",
@@ -196,7 +196,7 @@ VignetteBuilder:
     knitr
 Encoding: UTF-8
 Language: en-US
-RoxygenNote: 7.2.3.9000
+RoxygenNote: 7.2.3
 Roxygen: list(markdown = TRUE)
 Config/testthat/edition: 3
 Config/testthat/parallel: true
diff --git a/R/export_table.R b/R/export_table.R
index 92cbd6afb..8e6b8b212 100644
--- a/R/export_table.R
+++ b/R/export_table.R
@@ -153,9 +153,6 @@ export_table <- function(x,
     }))
   }
 
-  ## TODO: check if we need to move this code before the above if-statement?
-  ## attributes might get lost after do.call()
-
   # check for indention
   indent_groups <- attributes(x)$indent_groups
   indent_rows <- attributes(x)$indent_rows
diff --git a/R/find_formula.R b/R/find_formula.R
index 25f98e78e..29502c20b 100644
--- a/R/find_formula.R
+++ b/R/find_formula.R
@@ -94,7 +94,7 @@ formula_ok <- function(x, verbose = TRUE, ...) {
 
 #' @export
 find_formula.default <- function(x, verbose = TRUE, ...) {
-  f <- tryCatch(list(conditional = stats::formula(x)), error = function(x) NULL)
+  f <- .safe(list(conditional = stats::formula(x)))
   .find_formula_return(f, verbose = verbose)
 }
 
@@ -470,7 +470,7 @@ find_formula.betareg <- function(x, verbose = TRUE, ...) {
 
 #' @export
 find_formula.logitr <- function(x, verbose = TRUE, ...) {
-  f <- tryCatch(list(conditional = stats::formula(x)), error = function(x) NULL)
+  f <- .safe(list(conditional = stats::formula(x)))
   # formula() for logitr does not include outcome
   # need to paste "outcome" value from call manually to the formula
   f_cond <- trim_ws(safe_deparse(f$conditional))
diff --git a/R/get_deviance.R b/R/get_deviance.R
index 4803be8e4..8fd29066a 100644
--- a/R/get_deviance.R
+++ b/R/get_deviance.R
@@ -83,14 +83,7 @@ get_deviance.lrm <- function(x, ...) {
 
 #' @export
 get_deviance.glmmTMB <- function(x, ...) {
-  tryCatch(
-    {
-      -2 * as.numeric(get_loglikelihood(x, ...))
-    },
-    error = function(e) {
-      NULL
-    }
-  )
+  .safe(-2 * as.numeric(get_loglikelihood(x, ...)))
 }
 
 #' @export
diff --git a/R/get_loglikelihood.R b/R/get_loglikelihood.R
index 8fcbb0985..659a21a32 100644
--- a/R/get_loglikelihood.R
+++ b/R/get_loglikelihood.R
@@ -221,7 +221,7 @@ get_loglikelihood.afex_aov <- function(x, ...) {
   if (info$is_binomial) {
     resp <- .factor_to_numeric(resp, lowest = 0)
     if (!is.null(ncol(resp))) {
-      n <- apply(resp, 1, sum)
+      n <- rowSums(resp)
       resp <- ifelse(n == 0, 0, resp[, 1] / n)
     } else {
       n <- rep.int(1, length(resp))
diff --git a/R/get_predicted_args.R b/R/get_predicted_args.R
index e6e351210..f424f98bf 100644
--- a/R/get_predicted_args.R
+++ b/R/get_predicted_args.R
@@ -108,7 +108,7 @@
   # backward compatibility
   if (identical(predict, "relation")) {
     if (isTRUE(verbose)) {
-      format_alert(
+      format_warning(
         '`predict = "relation" is deprecated.',
         'Please use `predict = "expectation" instead.'
       )
diff --git a/R/model_info.R b/R/model_info.R
index 7731ec58e..f6c0343ef 100644
--- a/R/model_info.R
+++ b/R/model_info.R
@@ -171,7 +171,19 @@ model_info.logitr <- model_info.mclogit
 
 #' @export
 model_info.maxLik <- function(x, verbose = TRUE, ...) {
-  .make_family(x, verbose = verbose, ...)
+  fitfam <- .safe(eval(get_call(x)$family))
+  if (is.null(fitfam)) {
+    .make_family(x, verbose = verbose, ...)
+  } else {
+    .make_family(
+      x,
+      fitfam = fitfam$family,
+      logit.link = fitfam$link == "logit",
+      link.fun = fitfam$link,
+      verbose = verbose,
+      ...
+    )
+  }
 }
 
 #' @export
diff --git a/tests/testthat/test-brms.R b/tests/testthat/test-brms.R
index e01f972f7..d07aeba85 100644
--- a/tests/testthat/test-brms.R
+++ b/tests/testthat/test-brms.R
@@ -489,7 +489,7 @@ test_that("find_terms", {
 })
 
 test_that("find_algorithm", {
-  expect_identical(
+  expect_equal(
     find_algorithm(m1),
     list(
       algorithm = "sampling",
diff --git a/tests/testthat/test-clmm.R b/tests/testthat/test-clmm.R
index 27b29d0e8..42b1d827e 100644
--- a/tests/testthat/test-clmm.R
+++ b/tests/testthat/test-clmm.R
@@ -48,9 +48,9 @@ test_that("find_predictors", {
 })
 
 test_that("find_random", {
-  expect_equal(find_random(m1), list(random = "judge"))
-  expect_equal(find_random(m2), list(random = c("RESP", "RESP:PROD")))
-  expect_equal(find_random(m2, split_nested = TRUE), list(random = c("RESP", "PROD")))
+  expect_identical(find_random(m1), list(random = "judge"))
+  expect_identical(find_random(m2), list(random = c("RESP", "RESP:PROD")))
+  expect_identical(find_random(m2, split_nested = TRUE), list(random = c("RESP", "PROD")))
 })
 
 test_that("get_random", {
@@ -64,13 +64,13 @@ test_that("find_response", {
 })
 
 test_that("get_response", {
-  expect_equal(get_response(m1), wine$rating)
-  expect_equal(get_response(m2), soup$SURENESS)
+  expect_equal(get_response(m1), wine$rating, ignore_attr = TRUE)
+  expect_equal(get_response(m2), soup$SURENESS, ignore_attr = TRUE)
 })
 
 test_that("get_predictors", {
-  expect_equal(colnames(get_predictors(m1)), c("temp", "contact"))
-  expect_equal(colnames(get_predictors(m2)), "PROD")
+  expect_identical(colnames(get_predictors(m1)), c("temp", "contact"))
+  expect_identical(colnames(get_predictors(m2)), "PROD")
 })
 
 test_that("link_inverse", {
@@ -80,12 +80,12 @@ test_that("link_inverse", {
 
 test_that("get_data", {
   expect_equal(nrow(get_data(m1)), 72)
-  expect_equal(
+  expect_identical(
     colnames(get_data(m1)),
     c("rating", "temp", "contact", "judge")
   )
   expect_equal(nrow(get_data(m2)), 1847)
-  expect_equal(colnames(get_data(m2)), c("SURENESS", "PROD", "RESP"))
+  expect_identical(colnames(get_data(m2)), c("SURENESS", "PROD", "RESP"))
 })
 
 test_that("find_formula", {
@@ -110,7 +110,7 @@ test_that("find_formula", {
 })
 
 test_that("find_terms", {
-  expect_equal(
+  expect_identical(
     find_terms(m1),
     list(
       response = "rating",
@@ -118,11 +118,11 @@ test_that("find_terms", {
       random = "judge"
     )
   )
-  expect_equal(
+  expect_identical(
     find_terms(m1, flatten = TRUE),
     c("rating", "temp", "contact", "judge")
   )
-  expect_equal(
+  expect_identical(
     find_terms(m2),
     list(
       response = "SURENESS",
@@ -130,7 +130,7 @@ test_that("find_terms", {
       random = c("RESP", "PROD")
     )
   )
-  expect_equal(
+  expect_identical(
     find_terms(m2, flatten = TRUE),
     c("SURENESS", "PROD", "RESP")
   )
@@ -147,13 +147,13 @@ test_that("linkfun", {
 })
 
 test_that("find_parameters", {
-  expect_equal(
+  expect_identical(
     find_parameters(m1),
     list(
       conditional = c("1|2", "2|3", "3|4", "4|5", "tempwarm", "contactyes")
     )
   )
-  expect_equal(
+  expect_identical(
     find_parameters(m2),
     list(conditional = c("threshold.1", "spacing", "PRODTest"))
   )
@@ -165,6 +165,7 @@ test_that("is_multivariate", {
 })
 
 if (getRversion() > "3.6.3") {
+  skip_on_cran() ## FIXME: check on win-devel
   test_that("get_variance", {
     expect_equal(
       get_variance(m1),
diff --git a/tests/testthat/test-glmmTMB.R b/tests/testthat/test-glmmTMB.R
index 7d13937f1..b50a61a9f 100644
--- a/tests/testthat/test-glmmTMB.R
+++ b/tests/testthat/test-glmmTMB.R
@@ -69,6 +69,7 @@ test_that("get_weights", {
 })
 
 test_that("get_deviance + logLik", {
+  skip_on_cran() ## FIXME: check with win-devel
   expect_equal(get_deviance(m2), 1697.449311, tolerance = 1e-3)
   expect_equal(get_loglikelihood(m2), logLik(m2), tolerance = 1e-3, ignore_attr = TRUE)
   expect_identical(get_df(m2, type = "model"), 4L)
@@ -752,6 +753,7 @@ mpred <- glmmTMB::glmmTMB(
 )
 
 test_that("get_predicted with new levels", {
+  skip_on_cran() ## FIXME: check with win-devel
   pr <- get_predicted(mpred, data = head(Salamanders), allow.new.levels = TRUE)
   expect_equal(as.vector(pr), c(0.252, 0.39207, 0.21119, 2.20128, 2.39424, 2.28901), tolerance = 1e-3)
 })
diff --git a/tests/testthat/test-is_converged.R b/tests/testthat/test-is_converged.R
index 316c500fc..4938f70f7 100644
--- a/tests/testthat/test-is_converged.R
+++ b/tests/testthat/test-is_converged.R
@@ -26,6 +26,7 @@ test_that("is_converged", {
 
 
 skip_on_os("mac") # error: FreeADFunObject
+skip_on_cran() ## FIXME: check with win-devel
 skip_if_not_installed("glmmTMB")
 skip_if_not_installed("TMB")
 

From 9e8f1ec944b04ea43ea5dbf78cb4c4f702532716 Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Tue, 30 May 2023 18:11:58 +0200
Subject: [PATCH 64/98] skip on mac

---
 tests/testthat/test-brms.R | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/testthat/test-brms.R b/tests/testthat/test-brms.R
index d07aeba85..f5d5674f1 100644
--- a/tests/testthat/test-brms.R
+++ b/tests/testthat/test-brms.R
@@ -1,5 +1,6 @@
 skip_on_cran()
 skip_if_offline()
+skip_on_os("mac")
 skip_if_not_installed("brms")
 
 # Model fitting -----------------------------------------------------------

From d655a08b9046a896996bae04921f8745e7f9dbdc Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Tue, 6 Jun 2023 14:46:16 +0200
Subject: [PATCH 65/98] add resp.lvl to standardize_names

---
 DESCRIPTION                  |  2 +-
 NEWS.md                      |  7 ++++
 R/standardize_column_order.R |  4 +--
 R/standardize_names.R        | 62 +++++++++++++++++++-----------------
 4 files changed, 42 insertions(+), 33 deletions(-)

diff --git a/DESCRIPTION b/DESCRIPTION
index 7b5019f68..c268e651c 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -1,7 +1,7 @@
 Type: Package
 Package: insight
 Title: Easy Access to Model Information for Various Model Objects
-Version: 0.19.2
+Version: 0.19.2.1
 Authors@R: 
     c(person(given = "Daniel",
              family = "Lüdecke",
diff --git a/NEWS.md b/NEWS.md
index e4f3ef66c..223b54e65 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -1,3 +1,10 @@
+# insight 0.19.3
+
+## Changes to functions
+
+* `standardize_names()` and `standardize_column_order()` now also recognize the
+  `"response.level"` column name.
+
 # insight 0.19.2
 
 ## Breaking changes
diff --git a/R/standardize_column_order.R b/R/standardize_column_order.R
index 48bcffdc0..ce87f6993 100644
--- a/R/standardize_column_order.R
+++ b/R/standardize_column_order.R
@@ -64,7 +64,7 @@ standardize_column_order.parameters_model <- function(data,
       "Median", "Mean", "MAP", "MAD", "Dxy", "Difference", "Predicted", "Psihat",
       "Trimmed_Mean", "R2", "Mu",
       # type of estimate
-      "Group", "Component", "Response", "Effects", "Weight",
+      "Group", "Component", "Response", "Response_Level", "Effects", "Weight",
       # uncertainty
       "SE", "Std. Error", "SD", "Deviance_error",
       "CI", "CI_low", "CI_high", "Difference_CI_low", "Difference_CI_high",
@@ -107,7 +107,7 @@ standardize_column_order.parameters_model <- function(data,
       # estimate
       "estimate", "mean.group1", "mean.group2", "predicted",
       # type of estimate
-      "group", "component", "response", "effects", "weight",
+      "group", "component", "response", "response.level", "effects", "weight",
       # uncertainty
       "std.error", "std.dev",
       "conf.level", "conf.low", "conf.high", "conf.method", "conf.distribution", "conf.iterations",
diff --git a/R/standardize_names.R b/R/standardize_names.R
index 7550afb99..62855c4eb 100644
--- a/R/standardize_names.R
+++ b/R/standardize_names.R
@@ -112,37 +112,38 @@ standardize_names.parameters_distribution <- standardize_names.parameters_model
 
   # convert broom-style to easystats
   # styler: off
-  cn[cn == "term"]         <- "Parameter"
-  cn[cn == "estimate"]     <- "Coefficient"
-  cn[cn == "std.error"]    <- "SE"
-  cn[cn == "std.dev"]      <- "SD"
-  cn[cn == "p.value"]      <- "p"
-  cn[cn == "bayes.factor"] <- "BF"
-  cn[cn == "component"]    <- "Component"
-  cn[cn == "effect"]       <- "Effects"
-  cn[cn == "predicted"]    <- "Predicted"
-  cn[cn == "response"]     <- "Response"
-  cn[cn == "statistic"]    <- "Statistic"
-  cn[cn == "conf.low"]     <- "CI_low"
-  cn[cn == "conf.high"]    <- "CI_high"
-  cn[cn == "conf.level"]   <- "CI"
-  cn[cn == "conf.method"]  <- "CI_method"
-  cn[cn == "n.obs"]        <- "n_Obs"
-  cn[cn == "n"]            <- "n_Obs"
-  cn[cn == "type"]         <- "Type"
+  cn[cn == "term"]           <- "Parameter"
+  cn[cn == "estimate"]       <- "Coefficient"
+  cn[cn == "std.error"]      <- "SE"
+  cn[cn == "std.dev"]        <- "SD"
+  cn[cn == "p.value"]        <- "p"
+  cn[cn == "bayes.factor"]   <- "BF"
+  cn[cn == "component"]      <- "Component"
+  cn[cn == "effect"]         <- "Effects"
+  cn[cn == "predicted"]      <- "Predicted"
+  cn[cn == "response"]       <- "Response"
+  cn[cn == "response.level"] <- "Response_Level"
+  cn[cn == "statistic"]      <- "Statistic"
+  cn[cn == "conf.low"]       <- "CI_low"
+  cn[cn == "conf.high"]      <- "CI_high"
+  cn[cn == "conf.level"]     <- "CI"
+  cn[cn == "conf.method"]    <- "CI_method"
+  cn[cn == "n.obs"]          <- "n_Obs"
+  cn[cn == "n"]              <- "n_Obs"
+  cn[cn == "type"]           <- "Type"
   # marginaleffects
-  cn[cn == "value"]        <- "Level"
+  cn[cn == "value"]          <- "Level"
   # anova
-  cn[cn == "sumsq"]        <- "Sum_Squares"
-  cn[cn == "meansq"]       <- "Mean_Square"
-  cn[cn == "Resid..Dev"]   <- "Deviance_error"
+  cn[cn == "sumsq"]          <- "Sum_Squares"
+  cn[cn == "meansq"]         <- "Mean_Square"
+  cn[cn == "Resid..Dev"]     <- "Deviance_error"
   # convert classic summary
-  cn[cn == "Estimate"]     <- "Coefficient"
-  cn[cn == "Std. Error"]   <- "SE"
-  cn[cn == "t value"]      <- "Statistic"
-  cn[cn == "z value"]      <- "Statistic"
-  cn[cn == "Pr(>|t|)"]     <- "p"
-  cn[cn == "Pr(>|z|)"]     <- "p"
+  cn[cn == "Estimate"]       <- "Coefficient"
+  cn[cn == "Std. Error"]     <- "SE"
+  cn[cn == "t value"]        <- "Statistic"
+  cn[cn == "z value"]        <- "Statistic"
+  cn[cn == "Pr(>|t|)"]       <- "p"
+  cn[cn == "Pr(>|z|)"]       <- "p"
   # styler: on
 
   cn
@@ -162,6 +163,7 @@ standardize_names.parameters_distribution <- standardize_names.parameters_model
   cn[cn == "Component"]      <- "component"
   cn[cn == "Effects"]        <- "effect"
   cn[cn == "Response"]       <- "response"
+  cn[cn == "Response_Level"] <- "response.level"
   cn[cn == "CI"]             <- "conf.level"
   cn[cn == "df_error"]       <- "df.error"
   cn[cn == "df_residual"]    <- "df.residual"
@@ -185,8 +187,8 @@ standardize_names.parameters_distribution <- standardize_names.parameters_model
   cn[cn %in% c("Dxy", "rho", "r", "tau")] <- "estimate"
 
   # for glance
-  cn[cn %in% c("R2")] <- "r.squared"
-  cn[cn %in% c("R2_adjusted")] <- "adj.r.squared"
+  cn[cn == "R2"] <- "r.squared"
+  cn[cn == "R2_adjusted"] <- "adj.r.squared"
 
   if (("Difference" %in% cn) && !("estimate" %in% cn)) {
     cn[cn == "Difference"] <- "estimate"

From 144c3b51ed6d08517881dc0864c66531aae7c449 Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Wed, 21 Jun 2023 13:44:22 +0200
Subject: [PATCH 66/98] remove panelr tests

---
 DESCRIPTION | 1 -
 1 file changed, 1 deletion(-)

diff --git a/DESCRIPTION b/DESCRIPTION
index c268e651c..d527f8161 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -163,7 +163,6 @@ Suggests:
     nnet,
     nonnest2,
     ordinal,
-    panelr,
     parameters,
     parsnip,
     pbkrtest,

From 1a250a71c2baba07d66820c9cced5e438292654f Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Wed, 21 Jun 2023 13:44:37 +0200
Subject: [PATCH 67/98] move panelr tests to WIP

---
 {tests/testthat => WIP}/test-panelr.R | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename {tests/testthat => WIP}/test-panelr.R (100%)

diff --git a/tests/testthat/test-panelr.R b/WIP/test-panelr.R
similarity index 100%
rename from tests/testthat/test-panelr.R
rename to WIP/test-panelr.R

From 4313d0c022a9c40228904cc5f8ff484062cd21d6 Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Wed, 21 Jun 2023 14:38:19 +0200
Subject: [PATCH 68/98] fix for marginal effects

---
 DESCRIPTION               | 2 +-
 NEWS.md                   | 3 +++
 R/find_parameters_other.R | 4 ++--
 3 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/DESCRIPTION b/DESCRIPTION
index d527f8161..8154f8dbf 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -1,7 +1,7 @@
 Type: Package
 Package: insight
 Title: Easy Access to Model Information for Various Model Objects
-Version: 0.19.2.1
+Version: 0.19.2.2
 Authors@R: 
     c(person(given = "Daniel",
              family = "Lüdecke",
diff --git a/NEWS.md b/NEWS.md
index 223b54e65..2f1eaa8f2 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -5,6 +5,9 @@
 * `standardize_names()` and `standardize_column_order()` now also recognize the
   `"response.level"` column name.
 
+* `find_parameters()` for marginal effects ignores the `"s.value"` column (which
+  was added in a recent update).
+
 # insight 0.19.2
 
 ## Breaking changes
diff --git a/R/find_parameters_other.R b/R/find_parameters_other.R
index fe9e6b1a1..4bd2ad077 100644
--- a/R/find_parameters_other.R
+++ b/R/find_parameters_other.R
@@ -190,14 +190,14 @@ find_parameters.marginaleffects <- function(x, flatten = FALSE, ...) {
   # Recover dataframe
   excl <- c(
     "rowid", "type", "estimate", "std.error", "contrast", "term", "dydx",
-    "statistic", "p.value", "conf.low", "conf.high", "predicted_hi",
+    "statistic", "p.value", "s.value", "conf.low", "conf.high", "predicted_hi",
     "predicted_lo", "predicted", "eps", "marginaleffects_eps"
   )
 
   params <- x[!names(x) %in% excl]
 
   # Remove fixed variables
-  params <- params[sapply(params, function(x) length(unique(x)) > 1)]
+  params <- params[vapply(params, function(x) length(unique(x)) > 1, TRUE)]
   # Transform to list
   out <- list(marginaleffects = names(params))
 

From 1607f5313fbd029a0a151a6d26b38f8cd86c6c68 Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Wed, 21 Jun 2023 16:01:05 +0200
Subject: [PATCH 69/98] `get_random()` is pulling data from original data,
 before any missing values are dropped (#780)

* `get_random()` is pulling data from original data, before any missing values are dropped
Fixes #777

* minor

* test

* fix test

* version
---
 DESCRIPTION                      |  2 +-
 NEWS.md                          |  3 +++
 R/get_data.R                     | 27 +++++++++++++++++++--------
 tests/testthat/test-LORgee.R     | 32 ++++++++++++++++++--------------
 tests/testthat/test-get_random.R | 24 ++++++++++++++++++++++++
 5 files changed, 65 insertions(+), 23 deletions(-)
 create mode 100644 tests/testthat/test-get_random.R

diff --git a/DESCRIPTION b/DESCRIPTION
index 8154f8dbf..cff74dfd7 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -1,7 +1,7 @@
 Type: Package
 Package: insight
 Title: Easy Access to Model Information for Various Model Objects
-Version: 0.19.2.2
+Version: 0.19.2.3
 Authors@R: 
     c(person(given = "Daniel",
              family = "Lüdecke",
diff --git a/NEWS.md b/NEWS.md
index 2f1eaa8f2..579cb4b81 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -5,6 +5,9 @@
 * `standardize_names()` and `standardize_column_order()` now also recognize the
   `"response.level"` column name.
 
+* `get_random()` now returns the same observations as `get_data()` and correctly
+  removes missing values from the data before returning it.
+
 * `find_parameters()` for marginal effects ignores the `"s.value"` column (which
   was added in a recent update).
 
diff --git a/R/get_data.R b/R/get_data.R
index 4b53d9dc7..05ca66d18 100644
--- a/R/get_data.R
+++ b/R/get_data.R
@@ -74,9 +74,21 @@ get_data <- function(x, ...) {
   # we want to add the variable for subsettig, too
   model_call <- get_call(x)
 
+  # for random effects, we still need all variables to be extracted
+  # in case we have missing data. E.g., if random effects variables have
+  # no missing data, but response or other fixed effects has, "get_random()"
+  # should only return non-missing data for the model - thus, missing cases
+  # in any fixed effects variable should be removed, even if non-missing in
+  # random effects variables (see #777)
+  if (effects == "random") {
+    selected_vars <- "all"
+  } else {
+    selected_vars <- effects
+  }
+
   # extract model variables, if possible
   vars <- try(
-    find_variables(x, effects = effects, component = component, flatten = TRUE, verbose = FALSE),
+    find_variables(x, effects = selected_vars, component = component, flatten = TRUE, verbose = FALSE),
     silent = TRUE
   )
 
@@ -116,7 +128,7 @@ get_data <- function(x, ...) {
       }
       # add response, only required if "find_variables()" does not already
       # return it (which is the case when component is "all" or "conditional")
-      if (effects %in% c("all", "fixed") && !component %in% c("all", "conditional")) {
+      if (!component %in% c("all", "conditional")) {
         vars <- c(vars, find_response(x, combine = FALSE))
       }
 
@@ -144,12 +156,6 @@ get_data <- function(x, ...) {
         }
       }
 
-      # remove response for random effects
-      if (effects == "random") {
-        resp <- find_response(x, combine = FALSE)
-        dat <- dat[, setdiff(colnames(dat), resp), drop = FALSE]
-      }
-
       # complete cases only, as in model frames, need to filter attributes
       # only use model variables in complete.cases()
       if (!is.null(vars)) {
@@ -158,6 +164,11 @@ get_data <- function(x, ...) {
         cc <- stats::complete.cases(dat)
       }
 
+      # only preserve random effects
+      if (effects == "random") {
+        dat <- dat[find_random(x, split_nested = TRUE, flatten = TRUE)]
+      }
+
       if (!all(cc)) {
         # save original data, for attributes
         original_dat <- dat
diff --git a/tests/testthat/test-LORgee.R b/tests/testthat/test-LORgee.R
index 72debf5a1..a0d6e57ba 100644
--- a/tests/testthat/test-LORgee.R
+++ b/tests/testthat/test-LORgee.R
@@ -34,19 +34,23 @@ test_that("find_response", {
 })
 
 test_that("get_response", {
-  expect_equal(get_response(m1), na.omit(arthritis)$y)
+  expect_equal(get_response(m1), na.omit(arthritis)$y, ignore_attr = TRUE)
 })
 
 test_that("find_random", {
-  expect_equal(find_random(m1), list(random = "id"))
+  expect_identical(find_random(m1), list(random = "id"))
 })
 
 test_that("get_random", {
-  expect_equal(get_random(m1), arthritis[, "id", drop = FALSE], ignore_attr = TRUE)
+  expect_equal(get_random(m1), arthritis[!is.na(arthritis$y), "id", drop = FALSE], ignore_attr = TRUE)
 })
 
 test_that("get_predictors", {
-  expect_equal(get_predictors(m1), na.omit(arthritis)[, c("time", "trt", "baseline"), drop = FALSE])
+  expect_equal(
+    get_predictors(m1),
+    na.omit(arthritis)[, c("time", "trt", "baseline"), drop = FALSE],
+    ignore_attr = TRUE
+  )
 })
 
 test_that("link_inverse", {
@@ -54,8 +58,8 @@ test_that("link_inverse", {
 })
 
 test_that("get_data", {
-  expect_equal(nrow(get_data(m1)), 888)
-  expect_equal(
+  expect_identical(nrow(get_data(m1)), 888L)
+  expect_identical(
     colnames(get_data(m1)),
     c("y", "time", "trt", "baseline", "id")
   )
@@ -75,7 +79,7 @@ test_that("find_formula", {
 
 test_that("find_terms", {
   expect_length(find_terms(m1), 3)
-  expect_equal(
+  expect_identical(
     find_terms(m1),
     list(
       response = "y",
@@ -86,7 +90,7 @@ test_that("find_terms", {
 })
 
 test_that("find_variables", {
-  expect_equal(
+  expect_identical(
     find_variables(m1),
     list(
       response = "y",
@@ -94,14 +98,14 @@ test_that("find_variables", {
       random = "id"
     )
   )
-  expect_equal(
+  expect_identical(
     find_variables(m1, flatten = TRUE),
     c("y", "time", "trt", "baseline", "id")
   )
 })
 
 test_that("n_obs", {
-  expect_equal(n_obs(m1), 888)
+  expect_identical(n_obs(m1), 888L)
 })
 
 test_that("linkfun", {
@@ -109,7 +113,7 @@ test_that("linkfun", {
 })
 
 test_that("find_parameters", {
-  expect_equal(
+  expect_identical(
     find_parameters(m1),
     list(
       conditional = c(
@@ -127,8 +131,8 @@ test_that("find_parameters", {
       )
     )
   )
-  expect_equal(nrow(get_parameters(m1)), 11)
-  expect_equal(
+  expect_identical(nrow(get_parameters(m1)), 11L)
+  expect_identical(
     get_parameters(m1)$Parameter,
     c(
       "beta10",
@@ -151,7 +155,7 @@ test_that("is_multivariate", {
 })
 
 test_that("find_algorithm", {
-  expect_equal(find_algorithm(m1), list(algorithm = "Fisher's scoring ML"))
+  expect_identical(find_algorithm(m1), list(algorithm = "Fisher's scoring ML"))
 })
 
 test_that("find_statistic", {
diff --git a/tests/testthat/test-get_random.R b/tests/testthat/test-get_random.R
new file mode 100644
index 000000000..1259d945e
--- /dev/null
+++ b/tests/testthat/test-get_random.R
@@ -0,0 +1,24 @@
+skip_on_os("mac")
+skip_if_not_installed("lme4")
+test_that("get_random works with missings", {
+  data("sleepstudy", package = "lme4")
+  sleepstudy$Days[1] <- NA
+  fm1 <- lme4::lmer(Reaction ~ Days + (Days | Subject), sleepstudy)
+  expect_identical(nrow(get_data(fm1)), length(get_random(fm1)[[1]]))
+
+  set.seed(123)
+  # prepare some data...
+  sleepstudy$mygrp <- sample(1:5, size = 180, replace = TRUE)
+  sleepstudy$mysubgrp <- NA
+  for (i in 1:5) {
+    filter_group <- sleepstudy$mygrp == i
+    sleepstudy$mysubgrp[filter_group] <-
+      sample(1:30, size = sum(filter_group), replace = TRUE)
+  }
+  sleepstudy$Reaction[5] <- NA
+  mmiss2 <- lme4::lmer(
+    Reaction ~ Days + (1 | mygrp / mysubgrp) + (1 | Subject),
+    data = sleepstudy
+  )
+  expect_identical(nrow(get_random(mmiss2)), 178L)
+})

From 4c7d6e05e5abb57455ae3fd3fe387b9dd6bf4afc Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Wed, 21 Jun 2023 18:29:19 +0200
Subject: [PATCH 70/98] `get_response(<brms>)` fails with a truncated response
 (#781)

* `get_response(<brms>)` fails with a truncated response
Fixes #779

* add test

* news, version

* fix tests

* fix inaccuracy in test
---
 DESCRIPTION                        |  2 +-
 NEWS.md                            |  5 ++++
 R/find_response.R                  |  7 +++++-
 tests/testthat/test-brms.R         | 40 +++++++++++++++++++-----------
 tests/testthat/test-format_table.R | 10 ++++----
 tests/testthat/test-glmmTMB.R      | 32 ++++++++++++------------
 6 files changed, 58 insertions(+), 38 deletions(-)

diff --git a/DESCRIPTION b/DESCRIPTION
index cff74dfd7..0e3186ac8 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -1,7 +1,7 @@
 Type: Package
 Package: insight
 Title: Easy Access to Model Information for Various Model Objects
-Version: 0.19.2.3
+Version: 0.19.2.4
 Authors@R: 
     c(person(given = "Daniel",
              family = "Lüdecke",
diff --git a/NEWS.md b/NEWS.md
index 579cb4b81..d674a32cd 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -5,12 +5,17 @@
 * `standardize_names()` and `standardize_column_order()` now also recognize the
   `"response.level"` column name.
 
+## Bug fixes
+
 * `get_random()` now returns the same observations as `get_data()` and correctly
   removes missing values from the data before returning it.
 
 * `find_parameters()` for marginal effects ignores the `"s.value"` column (which
   was added in a recent update).
 
+* Fixed issue in `get_response()` for _brms_ models with `trunc()` function in
+  the response variable.
+
 # insight 0.19.2
 
 ## Breaking changes
diff --git a/R/find_response.R b/R/find_response.R
index fb9d1a87d..8ef165f68 100644
--- a/R/find_response.R
+++ b/R/find_response.R
@@ -177,7 +177,12 @@ check_cbind <- function(resp, combine, model) {
         r2 <- r3
       }
     }
-    resp <- c(r1, r2)
+    # for models with "trunc()" in response, omit that part (see #779)
+    if (startsWith(r_resp, "trunc")) {
+      resp <- r1
+    } else {
+      resp <- c(r1, r2)
+    }
   } else if (inherits(model, "DirichletRegModel")) {
     resp <- model$varnames
   } else {
diff --git a/tests/testthat/test-brms.R b/tests/testthat/test-brms.R
index f5d5674f1..5ab2d6cd4 100644
--- a/tests/testthat/test-brms.R
+++ b/tests/testthat/test-brms.R
@@ -13,11 +13,18 @@ m5 <- insight::download_model("brms_mv_5")
 m6 <- insight::download_model("brms_corr_re1")
 m7 <- suppressWarnings(insight::download_model("brms_mixed_8"))
 m8 <- insight::download_model("brms_ordinal_1")
+brms_trunc_1 <- download_model("brms_trunc_1")
 
-all_loaded <- !vapply(list(m1, m2, m3, m4, m5, m6, m7, m8), is.null, TRUE)
+all_loaded <- !vapply(list(m1, m2, m3, m4, m5, m6, m7, m8, brms_trunc_1), is.null, TRUE)
 skip_if(!all(all_loaded))
 
 # Tests -------------------------------------------------------------------
+test_that("get_predicted.brmsfit: ordinal dv", {
+  expect_identical(find_response(brms_trunc_1), "count")
+  expect_length(get_response(brms_trunc_1, source = "env"), 236)
+  expect_length(get_response(brms_trunc_1, source = "mf"), 236)
+})
+
 test_that("get_predicted.brmsfit: ordinal dv", {
   skip_if_not_installed("bayestestR")
   skip_if_not_installed("rstantools")
@@ -44,7 +51,7 @@ test_that("get_predicted.brmsfit: ordinal dv", {
   manual <- apply(manual[, , 1], 2, median)
   expect_equal(pred3$Predicted[1:32], manual, ignore_attr = TRUE)
   manual <- rstantools::posterior_epred(m8)
-  manual <- apply(manual[, , 1], 2, mean)
+  manual <- apply(manual[, , 1], 2, mean) # nolint
   expect_equal(pred1$Predicted[1:32], manual, ignore_attr = TRUE)
 })
 
@@ -296,14 +303,14 @@ test_that("find_random", {
 
 test_that("get_random", {
   zinb <- get_data(m4)
-  expect_equal(get_random(m4), zinb[, "persons", drop = FALSE])
+  expect_identical(get_random(m4), zinb[, "persons", drop = FALSE])
 })
 
 
 test_that("get_data", {
   d <- get_data(m6)
-  expect_equal(nrow(d), 200)
-  expect_equal(ncol(d), 3)
+  expect_identical(nrow(d), 200L)
+  expect_identical(ncol(d), 3L)
 })
 
 
@@ -497,7 +504,8 @@ test_that("find_algorithm", {
       chains = 1,
       iterations = 500,
       warmup = 250
-    )
+    ),
+    ignore_attr = TRUE
   )
 })
 
@@ -543,16 +551,18 @@ test_that("Issue #645", {
   skip_on_os("windows")
 
   void <- suppressMessages(suppressWarnings(capture.output(
-    mod <- brms::brm(
-      silent = 2,
-      data = mtcars,
-      family = brms::cumulative(probit),
-      formula = brms::bf(
-        cyl ~ 1 + mpg + drat + gearnl,
-        gearnl ~ 0 + (1 | gear),
-        nl = TRUE
+    {
+      mod <- brms::brm(
+        silent = 2,
+        data = mtcars,
+        family = brms::cumulative(probit),
+        formula = brms::bf(
+          cyl ~ 1 + mpg + drat + gearnl,
+          gearnl ~ 0 + (1 | gear),
+          nl = TRUE
+        )
       )
-    )
+    }
   )))
 
   p <- find_predictors(mod, flatten = TRUE)
diff --git a/tests/testthat/test-format_table.R b/tests/testthat/test-format_table.R
index 3018e67c8..c5f64f24d 100644
--- a/tests/testthat/test-format_table.R
+++ b/tests/testthat/test-format_table.R
@@ -13,27 +13,27 @@ x <- suppressWarnings(as.data.frame(bayestestR::describe_posterior(m1, test = c(
 test_that("format_table with stars bayes", {
   out <- format_table(x)
   expect_identical(colnames(out), c("Parameter", "Median", "95% CI", "pd", "Rhat", "ESS", "BF"))
-  expect_identical(out$BF, c("62.73", "114.21"))
+  expect_identical(out$BF[2], "114.21")
   expect_identical(out$pd, c("99.98%", "100%"))
 
   out <- format_table(x, stars = TRUE)
   expect_identical(colnames(out), c("Parameter", "Median", "95% CI", "pd", "Rhat", "ESS", "BF"))
-  expect_identical(out$BF, c("62.73***", "114.21***"))
+  expect_identical(out$BF[2], "114.21***")
   expect_identical(out$pd, c("99.98%***", "100%***"))
 
   out <- format_table(x, stars = c("pd", "BF"))
   expect_identical(colnames(out), c("Parameter", "Median", "95% CI", "pd", "Rhat", "ESS", "BF"))
-  expect_identical(out$BF, c("62.73***", "114.21***"))
+  expect_identical(out$BF[2], "114.21***")
   expect_identical(out$pd, c("99.98%***", "100%***"))
 
   out <- format_table(x, stars = "pd")
   expect_identical(colnames(out), c("Parameter", "Median", "95% CI", "pd", "Rhat", "ESS", "BF"))
-  expect_identical(out$BF, c("62.73", "114.21"))
+  expect_identical(out$BF[2], "114.21")
   expect_identical(out$pd, c("99.98%***", "100%***"))
 
   out <- format_table(x, stars = "BF")
   expect_identical(colnames(out), c("Parameter", "Median", "95% CI", "pd", "Rhat", "ESS", "BF"))
-  expect_identical(out$BF, c("62.73***", "114.21***"))
+  expect_identical(out$BF[2], "114.21***")
   expect_identical(out$pd, c("99.98%", "100%"))
 })
 
diff --git a/tests/testthat/test-glmmTMB.R b/tests/testthat/test-glmmTMB.R
index b50a61a9f..fa4431f6e 100644
--- a/tests/testthat/test-glmmTMB.R
+++ b/tests/testthat/test-glmmTMB.R
@@ -583,8 +583,8 @@ test_that("get_data", {
       "xb"
     )
   )
-  expect_identical(
-    colnames(get_data(m4, effects = "fixed")),
+  expect_named(
+    get_data(m4, effects = "fixed"),
     c("count", "child", "camper", "livebait", "xb")
   )
   expect_identical(colnames(get_data(m4, effects = "random")), c("persons", "ID"))
@@ -593,22 +593,22 @@ test_that("get_data", {
     m4,
     component = "zi", effects = "fixed"
   )), c("child", "livebait", "count"))
-  expect_identical(colnames(get_data(
-    m4,
-    component = "zi", effects = "random"
-  )), "ID")
-  expect_identical(
-    colnames(get_data(m4, component = "cond")),
+  expect_named(
+    get_data(m4, component = "zi", effects = "random", verbose = FALSE),
+    "ID"
+  )
+  expect_named(
+    get_data(m4, component = "cond", verbose = FALSE),
     c("count", "child", "camper", "persons")
   )
-  expect_identical(colnames(get_data(
-    m4,
-    component = "cond", effects = "fixed"
-  )), c("count", "child", "camper"))
-  expect_identical(colnames(get_data(
-    m4,
-    component = "cond", effects = "random"
-  )), "persons")
+  expect_named(
+    get_data(m4, component = "cond", effects = "fixed", verbose = FALSE),
+    c("count", "child", "camper")
+  )
+  expect_named(
+    get_data(m4, component = "cond", effects = "random", verbose = FALSE),
+    "persons"
+  )
   expect_identical(colnames(get_data(m4, component = "disp")), c("xb", "count"))
   expect_identical(colnames(get_data(
     m4,

From 19937470e7781c8227577cf10f5303560b27efaf Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Wed, 21 Jun 2023 20:35:20 +0200
Subject: [PATCH 71/98] more stable get_data() for lavaan (#782)

* more stable get_data() for lavaan
Fixes #772

* version, news
---
 DESCRIPTION                    |  2 +-
 NEWS.md                        |  3 +++
 R/get_data.R                   | 15 +++++++--------
 tests/testthat/test-get_data.R | 28 ++++++++++++++++++++++++++++
 4 files changed, 39 insertions(+), 9 deletions(-)

diff --git a/DESCRIPTION b/DESCRIPTION
index 0e3186ac8..762d7b698 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -1,7 +1,7 @@
 Type: Package
 Package: insight
 Title: Easy Access to Model Information for Various Model Objects
-Version: 0.19.2.4
+Version: 0.19.2.5
 Authors@R: 
     c(person(given = "Daniel",
              family = "Lüdecke",
diff --git a/NEWS.md b/NEWS.md
index d674a32cd..bbfb1ece1 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -5,6 +5,9 @@
 * `standardize_names()` and `standardize_column_order()` now also recognize the
   `"response.level"` column name.
 
+* `get_data()` for _lavaan_ models is now more stable at retrieving model data
+  when this is not avaible in the environment.
+
 ## Bug fixes
 
 * `get_random()` now returns the same observations as `get_data()` and correctly
diff --git a/R/get_data.R b/R/get_data.R
index 05ca66d18..8fdb8b98f 100644
--- a/R/get_data.R
+++ b/R/get_data.R
@@ -1190,18 +1190,17 @@ get_data.glimML <- function(x, effects = "all", source = "environment", verbose
 #' @export
 get_data.lavaan <- function(x, source = "environment", verbose = TRUE, ...) {
   # try to recover data from environment
-  model_data <- .get_data_from_environment(x, source = source, verbose = verbose, ...)
+  if (identical(source, "environment")) {
+    model_data <- .safe(.recover_data_from_environment(x), NULL)
 
-  if (!is.null(model_data)) {
-    return(model_data)
+    if (!is.null(model_data)) {
+      return(model_data)
+    }
   }
 
   # fall back to extract data from model frame
-  mf <- tryCatch(.recover_data_from_environment(x),
-    error = function(x) NULL
-  )
-
-  .prepare_get_data(x, stats::na.omit(mf), verbose = verbose)
+  check_if_installed("lavaan")
+  as.data.frame(lavaan::lavInspect(x, what = "data"))
 }
 
 #' @export
diff --git a/tests/testthat/test-get_data.R b/tests/testthat/test-get_data.R
index 5f94cc8fa..7367b1c24 100644
--- a/tests/testthat/test-get_data.R
+++ b/tests/testthat/test-get_data.R
@@ -138,6 +138,34 @@ test_that("get_data lavaan", {
   m <- lavaan::sem(model, data = PoliticalDemocracy)
   expect_s3_class(get_data(m, verbose = FALSE), "data.frame")
   expect_equal(head(get_data(m, verbose = FALSE)), head(PoliticalDemocracy), ignore_attr = TRUE, tolerance = 1e-3)
+
+  # works when data not in environment
+  holz_data <- lavaan::HolzingerSwineford1939
+  HS.model <- " visual  =~ x1 + x2 + x3
+                textual =~ x4 + x5 + x6
+                speed   =~ x7 + x8 + x9 "
+  m_holz <- lavaan::lavaan(HS.model,
+    data = holz_data, auto.var = TRUE, auto.fix.first = TRUE,
+    auto.cov.lv.x = TRUE
+  )
+
+  out1 <- get_data(m_holz)
+  expect_named(
+    out1,
+    c(
+      "id", "sex", "ageyr", "agemo", "school", "grade", "x1", "x2",
+      "x3", "x4", "x5", "x6", "x7", "x8", "x9"
+    )
+  )
+  expect_identical(nrow(out1), 301L)
+
+  rm(holz_data)
+  out2 <- get_data(m_holz)
+  expect_named(
+    out2,
+    c("x1", "x2","x3", "x4", "x5", "x6", "x7", "x8", "x9")
+  )
+  expect_identical(nrow(out2), 301L)
 })
 
 

From 27afcb6165fdbb888a8f7d125da9228fd7f816f2 Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Wed, 21 Jun 2023 20:36:21 +0200
Subject: [PATCH 72/98] comment out test for now

---
 tests/testthat/test-get_data.R | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/tests/testthat/test-get_data.R b/tests/testthat/test-get_data.R
index 7367b1c24..e9ed48a65 100644
--- a/tests/testthat/test-get_data.R
+++ b/tests/testthat/test-get_data.R
@@ -159,13 +159,13 @@ test_that("get_data lavaan", {
   )
   expect_identical(nrow(out1), 301L)
 
-  rm(holz_data)
-  out2 <- get_data(m_holz)
-  expect_named(
-    out2,
-    c("x1", "x2","x3", "x4", "x5", "x6", "x7", "x8", "x9")
-  )
-  expect_identical(nrow(out2), 301L)
+  # rm(holz_data)
+  # out2 <- get_data(m_holz)
+  # expect_named(
+  #   out2,
+  #   c("x1", "x2","x3", "x4", "x5", "x6", "x7", "x8", "x9")
+  # )
+  # expect_identical(nrow(out2), 301L)
 })
 
 

From b07119ee96e164c3892c174f1ab53e505ca27bca Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Wed, 21 Jun 2023 22:01:12 +0200
Subject: [PATCH 73/98] skip on linux

---
 tests/testthat/test-get_data.R | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/testthat/test-get_data.R b/tests/testthat/test-get_data.R
index e9ed48a65..4a8929452 100644
--- a/tests/testthat/test-get_data.R
+++ b/tests/testthat/test-get_data.R
@@ -149,6 +149,7 @@ test_that("get_data lavaan", {
     auto.cov.lv.x = TRUE
   )
 
+  skip_on_os(c("mac", "linux"))
   out1 <- get_data(m_holz)
   expect_named(
     out1,

From 135ce7f9b88dabf47042cb93646c98fa8aad19b7 Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Wed, 21 Jun 2023 23:58:36 +0200
Subject: [PATCH 74/98] Fix aterms in brms-responses (#785)

* Fix aterms in brms-responses
Fixes #779

* fix, add tests

* spelling, lintr

* styler

* minor
---
 NEWS.md                           |  2 +-
 R/find_response.R                 | 30 ++++++++++++++--------
 tests/testthat/test-brms.R        | 31 ++++++++++++-----------
 tests/testthat/test-brms_aterms.R | 42 +++++++++++++++++++++++++++++++
 4 files changed, 79 insertions(+), 26 deletions(-)
 create mode 100644 tests/testthat/test-brms_aterms.R

diff --git a/NEWS.md b/NEWS.md
index bbfb1ece1..87d96c25e 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -6,7 +6,7 @@
   `"response.level"` column name.
 
 * `get_data()` for _lavaan_ models is now more stable at retrieving model data
-  when this is not avaible in the environment.
+  when this is not available in the environment.
 
 ## Bug fixes
 
diff --git a/R/find_response.R b/R/find_response.R
index 8ef165f68..37a7df135 100644
--- a/R/find_response.R
+++ b/R/find_response.R
@@ -164,22 +164,32 @@ check_cbind <- function(resp, combine, model) {
     # check for brms Additional Response Information
     r1 <- trim_ws(sub("(.*)\\|(.*)", "\\1", resp))
     r2 <- trim_ws(sub("(.*)\\|(.*)\\(([^,)]*).*", "\\3", resp))
-    # check for "resp_thres" pattern
+    # check for "resp_thres" and similar patterns
     r_resp <- trim_ws(unlist(strsplit(resp, "|", fixed = TRUE))[2])
-    if (startsWith(r_resp, "resp_thres")) {
+    if (grepl("^(resp_thres|thres|resp_weights|weights|resp_se|se|resp_cens|cens)", r_resp)) {
       r3 <- trim_ws(sub("=", "", sub("(.*)\\(([^=)]*)(.*)\\)", "\\3", r_resp), fixed = TRUE))
-      names(r3) <- r3
       numeric_values <- suppressWarnings(as.numeric(r2))
       r2 <- r2[is.na(numeric_values)]
-      if (length(r2)) {
-        r2 <- c(r2, r3)
-      } else {
-        r2 <- r3
+      if (is.na(suppressWarnings(as.numeric(r3)))) {
+        if (length(r2)) {
+          r2 <- c(r2, r3)
+        } else {
+          r2 <- r3
+        }
       }
-    }
-    # for models with "trunc()" in response, omit that part (see #779)
-    if (startsWith(r_resp, "trunc")) {
+      resp <- compact_character(c(r1, r2))
+    } else if (grepl("^(resp_trunc|trunc|resp_mi|mi)", r_resp)) {
+      # for models with "trunc()", "mi()" etc. in response, which cannot have
+      # variables, omit that part (see #779)
       resp <- r1
+    } else if (grepl("^(resp_trials|trials|resp_cat|cat|resp_dec|dec)", r_resp)) {
+      if (is.na(suppressWarnings(as.numeric(r2)))) {
+        # if we have a variable, add it
+        resp <- compact_character(c(r1, r2))
+      } else {
+        # else, if we have a constant (like "trials(1)"), omit it
+        resp <- r1
+      }
     } else {
       resp <- c(r1, r2)
     }
diff --git a/tests/testthat/test-brms.R b/tests/testthat/test-brms.R
index 5ab2d6cd4..671502b80 100644
--- a/tests/testthat/test-brms.R
+++ b/tests/testthat/test-brms.R
@@ -19,7 +19,7 @@ all_loaded <- !vapply(list(m1, m2, m3, m4, m5, m6, m7, m8, brms_trunc_1), is.nul
 skip_if(!all(all_loaded))
 
 # Tests -------------------------------------------------------------------
-test_that("get_predicted.brmsfit: ordinal dv", {
+test_that("get_response.brmsfit: trunc", {
   expect_identical(find_response(brms_trunc_1), "count")
   expect_length(get_response(brms_trunc_1, source = "env"), 236)
   expect_length(get_response(brms_trunc_1, source = "mf"), 236)
@@ -384,7 +384,10 @@ test_that("find_paramaters", {
           ),
           random = c(sprintf("r_persons__count2[%i,Intercept]", 1:4), "sd_persons__count2_Intercept"),
           zero_inflated = c("b_zi_count2_Intercept", "b_zi_count2_child"),
-          zero_inflated_random = c(sprintf("r_persons__zi_count2[%i,Intercept]", 1:4), "sd_persons__zi_count2_Intercept")
+          zero_inflated_random = c(
+            sprintf("r_persons__zi_count2[%i,Intercept]", 1:4),
+            "sd_persons__zi_count2_Intercept"
+          )
         )
       ),
       "is_mv" = "1"
@@ -550,20 +553,18 @@ test_that("Issue #645", {
   # sink() writing permission fail on some Windows CI machines
   skip_on_os("windows")
 
-  void <- suppressMessages(suppressWarnings(capture.output(
-    {
-      mod <- brms::brm(
-        silent = 2,
-        data = mtcars,
-        family = brms::cumulative(probit),
-        formula = brms::bf(
-          cyl ~ 1 + mpg + drat + gearnl,
-          gearnl ~ 0 + (1 | gear),
-          nl = TRUE
-        )
+  void <- suppressMessages(suppressWarnings(capture.output({
+    mod <- brms::brm(
+      silent = 2,
+      data = mtcars,
+      family = brms::cumulative(probit),
+      formula = brms::bf(
+        cyl ~ 1 + mpg + drat + gearnl,
+        gearnl ~ 0 + (1 | gear),
+        nl = TRUE
       )
-    }
-  )))
+    )
+  })))
 
   p <- find_predictors(mod, flatten = TRUE)
   d <- get_data(mod)
diff --git a/tests/testthat/test-brms_aterms.R b/tests/testthat/test-brms_aterms.R
new file mode 100644
index 000000000..60588b850
--- /dev/null
+++ b/tests/testthat/test-brms_aterms.R
@@ -0,0 +1,42 @@
+skip_on_cran()
+skip_if_offline()
+skip_on_os("mac")
+skip_if_not_installed("brms")
+
+# Model fitting -----------------------------------------------------------
+
+aterm_1 <- download_model("brms_aterm_1")
+aterm_2 <- download_model("brms_aterm_2")
+aterm_3 <- download_model("brms_aterm_3")
+aterm_4 <- download_model("brms_aterm_4")
+
+all_loaded <- !vapply(list(aterm_1, aterm_2, aterm_3, aterm_4), is.null, TRUE)
+skip_if(!all(all_loaded))
+
+# Tests -------------------------------------------------------------------
+test_that("get_response brms aterms-trials 1", {
+  expect_identical(find_response(aterm_1), "am")
+  expect_length(get_response(aterm_1, source = "env"), 32)
+  expect_length(get_response(aterm_1, source = "mf"), 32)
+})
+
+test_that("get_response brms aterms-trials 2", {
+  expect_identical(find_response(aterm_2), c("am", "cyl"))
+  expect_named(get_response(aterm_2, source = "env"), c("am", "cyl"))
+  expect_named(get_response(aterm_2, source = "mf"), c("am", "cyl"))
+  expect_identical(nrow(get_response(aterm_2)), 32L)
+})
+
+test_that("get_response brms aterms-cens 1", {
+  expect_identical(find_response(aterm_3), c("time", "censored"))
+  expect_named(get_response(aterm_3, source = "env"), c("time", "censored"))
+  expect_named(get_response(aterm_3, source = "mf"), c("time", "censored"))
+  expect_identical(nrow(get_response(aterm_3)), 76L)
+})
+
+test_that("get_response brms aterms-cens 2", {
+  expect_identical(find_response(aterm_4), c("time", "censored"))
+  expect_named(get_response(aterm_4, source = "env"), c("time", "censored"))
+  expect_named(get_response(aterm_4, source = "mf"), c("time", "censored"))
+  expect_identical(nrow(get_response(aterm_4)), 76L)
+})

From ae447b801979934fae43d77c6643914a78597988 Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Thu, 22 Jun 2023 00:39:19 +0200
Subject: [PATCH 75/98] fix test

---
 tests/testthat/test-get_data.R | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/testthat/test-get_data.R b/tests/testthat/test-get_data.R
index 4a8929452..8b6c821d7 100644
--- a/tests/testthat/test-get_data.R
+++ b/tests/testthat/test-get_data.R
@@ -140,7 +140,7 @@ test_that("get_data lavaan", {
   expect_equal(head(get_data(m, verbose = FALSE)), head(PoliticalDemocracy), ignore_attr = TRUE, tolerance = 1e-3)
 
   # works when data not in environment
-  holz_data <- lavaan::HolzingerSwineford1939
+  holz_data <<- lavaan::HolzingerSwineford1939
   HS.model <- " visual  =~ x1 + x2 + x3
                 textual =~ x4 + x5 + x6
                 speed   =~ x7 + x8 + x9 "

From 7f2a27700a065fbd1703c948e852a633171dd074 Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Thu, 22 Jun 2023 00:39:39 +0200
Subject: [PATCH 76/98] Simplify code in `format_table()` to extract pretty
 names (#783)

Fixes #737
---
 R/format_table.R | 32 +++-----------------------------
 1 file changed, 3 insertions(+), 29 deletions(-)

diff --git a/R/format_table.R b/R/format_table.R
index 3bfd1c477..191f30305 100644
--- a/R/format_table.R
+++ b/R/format_table.R
@@ -110,38 +110,12 @@ format_table <- function(x,
 
 
   # Format parameters names ----
-
-  ## TODO: check if this simplification works
-  # I'm not sure, but I think the following three code lines should work, too
-  #
-  # shared <- intersect(x$Parameter, names(att$pretty_names))
-  # index <- match(shared, x$Parameter)
-  # x$Parameter[index] <- as.vector(att$pretty_names[x$Parameter[index]])
-
   if (pretty_names && !is.null(att$pretty_names)) {
-    # remove strings with NA names
-    att$pretty_names <- att$pretty_names[!is.na(names(att$pretty_names))]
-    if (length(att$pretty_names) != length(x$Parameter)) {
-      match_pretty_names <- match(names(att$pretty_names), x$Parameter)
-      match_pretty_names <- match_pretty_names[!is.na(match_pretty_names)]
-      if (length(match_pretty_names)) {
-        x$Parameter[match_pretty_names] <- att$pretty_names[x$Parameter[match_pretty_names]]
-      }
-    } else {
-      match_pretty_names <- att$pretty_names[x$Parameter]
-      if (!anyNA(match_pretty_names)) {
-        x$Parameter <- att$pretty_names[x$Parameter]
-      } else {
-        match_pretty_names <- match(names(att$pretty_names), x$Parameter)
-        match_pretty_names <- match_pretty_names[!is.na(match_pretty_names)]
-        if (length(match_pretty_names)) {
-          x$Parameter[match_pretty_names] <- att$pretty_names[x$Parameter[match_pretty_names]]
-        }
-      }
-    }
+    shared <- intersect(x$Parameter, names(att$pretty_names))
+    index <- match(shared, x$Parameter)
+    x$Parameter[index] <- as.vector(att$pretty_names[x$Parameter[index]])
   }
 
-
   # Format specific columns ----
   if ("n_Obs" %in% names(x)) x$n_Obs <- format_value(x$n_Obs, protect_integers = TRUE)
   if ("n_Missing" %in% names(x)) x$n_Missing <- format_value(x$n_Missing, protect_integers = TRUE)

From 6c6070b2dbf287fa9f859642350c45487fbbe39d Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Thu, 22 Jun 2023 07:51:44 +0200
Subject: [PATCH 77/98] unloadNamespace

---
 tests/testthat/test-logistf.R | 26 ++++++++++++++------------
 1 file changed, 14 insertions(+), 12 deletions(-)

diff --git a/tests/testthat/test-logistf.R b/tests/testthat/test-logistf.R
index 4d1db0963..47ad6d1e9 100644
--- a/tests/testthat/test-logistf.R
+++ b/tests/testthat/test-logistf.R
@@ -34,12 +34,12 @@ test_that("find_response", {
 })
 
 test_that("get_response", {
-  expect_equal(get_response(m1), sex2$case)
+  expect_equal(get_response(m1), sex2$case, ignore_attr = TRUE)
 })
 
 test_that("get_predictors", {
-  expect_equal(
-    colnames(get_predictors(m1)),
+  expect_named(
+    get_predictors(m1),
     c("age", "oc", "vic", "vicl", "vis", "dia")
   )
 })
@@ -49,8 +49,8 @@ test_that("link_inverse", {
 })
 
 test_that("get_data", {
-  expect_equal(nrow(get_data(m1)), 239)
-  expect_equal(
+  expect_identical(nrow(get_data(m1)), 239L)
+  expect_identical(
     colnames(get_data(m1)),
     c("case", "age", "oc", "vic", "vicl", "vis", "dia")
   )
@@ -66,18 +66,18 @@ test_that("find_formula", {
 })
 
 test_that("find_terms", {
-  expect_equal(find_terms(m1), list(
+  expect_identical(find_terms(m1), list(
     response = "case",
     conditional = c("age", "oc", "vic", "vicl", "vis", "dia")
   ))
-  expect_equal(
+  expect_identical(
     find_terms(m1, flatten = TRUE),
     c("case", "age", "oc", "vic", "vicl", "vis", "dia")
   )
 })
 
 test_that("n_obs", {
-  expect_equal(n_obs(m1), 239)
+  expect_identical(n_obs(m1), 239L)
 })
 
 test_that("linkfun", {
@@ -89,14 +89,14 @@ test_that("linkinverse", {
 })
 
 test_that("find_parameters", {
-  expect_equal(
+  expect_identical(
     find_parameters(m1),
     list(
       conditional = c("(Intercept)", "age", "oc", "vic", "vicl", "vis", "dia")
     )
   )
-  expect_equal(nrow(get_parameters(m1)), 7)
-  expect_equal(
+  expect_identical(nrow(get_parameters(m1)), 7L)
+  expect_identical(
     get_parameters(m1)$Parameter,
     c("(Intercept)", "age", "oc", "vic", "vicl", "vis", "dia")
   )
@@ -107,9 +107,11 @@ test_that("is_multivariate", {
 })
 
 test_that("find_algorithm", {
-  expect_equal(find_algorithm(m1), list(algorithm = "Penalized ML"))
+  expect_identical(find_algorithm(m1), list(algorithm = "Penalized ML"))
 })
 
 test_that("find_statistic", {
   expect_identical(find_statistic(m1), "chi-squared statistic")
 })
+
+unloadNamespace("logistf")

From 3ebbfaa8385cea4c7ba080df0ca93a42192f0b46 Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Thu, 22 Jun 2023 07:52:51 +0200
Subject: [PATCH 78/98] skip warnings

---
 tests/testthat/test-brms_aterms.R | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/tests/testthat/test-brms_aterms.R b/tests/testthat/test-brms_aterms.R
index 60588b850..6f51bac32 100644
--- a/tests/testthat/test-brms_aterms.R
+++ b/tests/testthat/test-brms_aterms.R
@@ -5,10 +5,10 @@ skip_if_not_installed("brms")
 
 # Model fitting -----------------------------------------------------------
 
-aterm_1 <- download_model("brms_aterm_1")
-aterm_2 <- download_model("brms_aterm_2")
-aterm_3 <- download_model("brms_aterm_3")
-aterm_4 <- download_model("brms_aterm_4")
+aterm_1 <- suppressWarnings(download_model("brms_aterm_1"))
+aterm_2 <- suppressWarnings(download_model("brms_aterm_2"))
+aterm_3 <- suppressWarnings(download_model("brms_aterm_3"))
+aterm_4 <- suppressWarnings(download_model("brms_aterm_4"))
 
 all_loaded <- !vapply(list(aterm_1, aterm_2, aterm_3, aterm_4), is.null, TRUE)
 skip_if(!all(all_loaded))

From bddfcfa5750fe73afd2ea8fea3bdd45f71dec91a Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Thu, 22 Jun 2023 08:45:53 +0200
Subject: [PATCH 79/98] `find_terms` can't "look" inside parentheses (#786)

---
 DESCRIPTION                      |  2 +-
 NEWS.md                          |  4 +++
 R/find_terms.R                   | 45 +++++++++++++++++++++-----------
 R/is_nested_models.R             |  7 ++++-
 man/find_terms.Rd                | 22 +++++++++++++---
 man/is_nested_models.Rd          |  6 +++++
 tests/testthat/test-brms.R       |  2 +-
 tests/testthat/test-find_terms.R | 25 +++++++++++++++---
 tests/testthat/test-logistf.R    |  2 +-
 9 files changed, 88 insertions(+), 27 deletions(-)

diff --git a/DESCRIPTION b/DESCRIPTION
index 762d7b698..9b8bf4c8e 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -1,7 +1,7 @@
 Type: Package
 Package: insight
 Title: Easy Access to Model Information for Various Model Objects
-Version: 0.19.2.5
+Version: 0.19.2.6
 Authors@R: 
     c(person(given = "Daniel",
              family = "Lüdecke",
diff --git a/NEWS.md b/NEWS.md
index 87d96c25e..5d5c83472 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -8,6 +8,10 @@
 * `get_data()` for _lavaan_ models is now more stable at retrieving model data
   when this is not available in the environment.
 
+* `find_terms()` gets an `as_term_labels` argument, to extract model terms
+  from the formula's `"term.labels"` attribute. This is closer to the behaviour
+  of `stats::terms()`, but may be insufficient, e.g. for mixed models.
+
 ## Bug fixes
 
 * `get_random()` now returns the same observations as `get_data()` and correctly
diff --git a/R/find_terms.R b/R/find_terms.R
index b1e880a49..c2d964fef 100644
--- a/R/find_terms.R
+++ b/R/find_terms.R
@@ -6,24 +6,29 @@
 #'   or arithmetic expressions like `log()`, `I()`, `as.factor()` etc. are
 #'   preserved.
 #'
+#' @param as_term_labels Logical, if `TRUE`, extracts model formula and tries to
+#'   access the `"term.labels"` attribute. This should better mimic the `terms()`
+#'   behaviour even for those models that do not have such a method, but may be
+#'   insufficient, e.g. for mixed models.
 #' @inheritParams find_formula
 #' @inheritParams find_predictors
 #'
 #' @return A list with (depending on the model) following elements (character
-#'    vectors):
-#'    \itemize{
-#'      \item `response`, the name of the response variable
-#'      \item `conditional`, the names of the predictor variables from the *conditional* model (as opposed to the zero-inflated part of a model)
-#'      \item `random`, the names of the random effects (grouping factors)
-#'      \item `zero_inflated`, the names of the predictor variables from the *zero-inflated* part of the model
-#'      \item `zero_inflated_random`, the names of the random effects (grouping factors)
-#'      \item `dispersion`, the name of the dispersion terms
-#'      \item `instruments`, the names of instrumental variables
-#'    }
-#'    Returns `NULL` if no terms could be found (for instance, due to
-#'    problems in accessing the formula).
+#' vectors):
 #'
-#' @note The difference to [find_variables()] is that `find_terms()`
+#' - `response`, the name of the response variable
+#' - `conditional`, the names of the predictor variables from the *conditional*
+#'    model (as opposed to the zero-inflated part of a model)
+#' - `random`, the names of the random effects (grouping factors)
+#' - `zero_inflated`, the names of the predictor variables from the *zero-inflated* part of the model
+#' - `zero_inflated_random`, the names of the random effects (grouping factors)
+#' - `dispersion`, the name of the dispersion terms
+#' - `instruments`, the names of instrumental variables
+#'
+#' Returns `NULL` if no terms could be found (for instance, due to
+#' problems in accessing the formula).
+#'
+#' @note The difference to [`find_variables()`] is that `find_terms()`
 #'   may return a variable multiple times in case of multiple transformations
 #'   (see examples below), while `find_variables()` returns each variable
 #'   name only once.
@@ -38,19 +43,29 @@
 #'
 #'   find_terms(m)
 #' }
+#'
+#' # sometimes, it is necessary to retrieve terms from "term.labels" attribute
+#' m <- lm(mpg ~ hp * (am + cyl), data = mtcars)
+#' find_terms(m, as_term_labels = TRUE)
 #' @export
-find_terms <- function(x, flatten = FALSE, verbose = TRUE, ...) {
+find_terms <- function(x, ...) {
   UseMethod("find_terms")
 }
 
+#' @rdname find_terms
 #' @export
-find_terms.default <- function(x, flatten = FALSE, verbose = TRUE, ...) {
+find_terms.default <- function(x, flatten = FALSE, as_term_labels = FALSE, verbose = TRUE, ...) {
   f <- find_formula(x, verbose = verbose)
 
   if (is.null(f)) {
     return(NULL)
   }
 
+  # mimics original "terms()" behaviour, leads to slightly different results
+  if (isTRUE(as_term_labels)) {
+    return(lapply(f, function(i) attr(stats::terms(i), "term.labels")))
+  }
+
   resp <- find_response(x, verbose = FALSE)
 
   if (is_multivariate(f) || isTRUE(attributes(f)$two_stage)) {
diff --git a/R/is_nested_models.R b/R/is_nested_models.R
index 33c193632..03e0eaa49 100644
--- a/R/is_nested_models.R
+++ b/R/is_nested_models.R
@@ -10,6 +10,11 @@
 #' are nested, also returns two attributes that indicate whether nesting of
 #' models is in decreasing or increasing order.
 #'
+#' @details The term "nested" here means that all the fixed predictors of a
+#' model are contained within the fixed predictors of a larger model (sometimes
+#' referred to as the encompassing model). Currently, `is_nested_models()` ignores
+#' random effects parameters.
+#'
 #' @examples
 #' m1 <- lm(Sepal.Length ~ Petal.Width + Species, data = iris)
 #' m2 <- lm(Sepal.Length ~ Species, data = iris)
@@ -24,7 +29,7 @@ is_nested_models <- function(...) {
   objects <- list(...)
   object_names <- match.call(expand.dots = FALSE)$`...`
 
-  if (!all(sapply(objects, is_regression_model))) {
+  if (!all(vapply(objects, is_regression_model, TRUE))) {
     format_error("All models must be valid regression model objects.")
   }
   names(objects) <- object_names
diff --git a/man/find_terms.Rd b/man/find_terms.Rd
index 61c2b4abf..6c2ff9d4a 100644
--- a/man/find_terms.Rd
+++ b/man/find_terms.Rd
@@ -2,32 +2,42 @@
 % Please edit documentation in R/find_terms.R
 \name{find_terms}
 \alias{find_terms}
+\alias{find_terms.default}
 \title{Find all model terms}
 \usage{
-find_terms(x, flatten = FALSE, verbose = TRUE, ...)
+find_terms(x, ...)
+
+\method{find_terms}{default}(x, flatten = FALSE, as_term_labels = FALSE, verbose = TRUE, ...)
 }
 \arguments{
 \item{x}{A fitted model.}
 
+\item{...}{Currently not used.}
+
 \item{flatten}{Logical, if \code{TRUE}, the values are returned
 as character vector, not as list. Duplicated values are removed.}
 
-\item{verbose}{Toggle warnings.}
+\item{as_term_labels}{Logical, if \code{TRUE}, extracts model formula and tries to
+access the \code{"term.labels"} attribute. This should better mimic the \code{terms()}
+behaviour even for those models that do not have such a method, but may be
+insufficient, e.g. for mixed models.}
 
-\item{...}{Currently not used.}
+\item{verbose}{Toggle warnings.}
 }
 \value{
 A list with (depending on the model) following elements (character
 vectors):
 \itemize{
 \item \code{response}, the name of the response variable
-\item \code{conditional}, the names of the predictor variables from the \emph{conditional} model (as opposed to the zero-inflated part of a model)
+\item \code{conditional}, the names of the predictor variables from the \emph{conditional}
+model (as opposed to the zero-inflated part of a model)
 \item \code{random}, the names of the random effects (grouping factors)
 \item \code{zero_inflated}, the names of the predictor variables from the \emph{zero-inflated} part of the model
 \item \code{zero_inflated_random}, the names of the random effects (grouping factors)
 \item \code{dispersion}, the name of the dispersion terms
 \item \code{instruments}, the names of instrumental variables
 }
+
 Returns \code{NULL} if no terms could be found (for instance, due to
 problems in accessing the formula).
 }
@@ -53,4 +63,8 @@ if (require("lme4")) {
 
   find_terms(m)
 }
+
+# sometimes, it is necessary to retrieve terms from "term.labels" attribute
+m <- lm(mpg ~ hp * (am + cyl), data = mtcars)
+find_terms(m, as_term_labels = TRUE)
 }
diff --git a/man/is_nested_models.Rd b/man/is_nested_models.Rd
index 6d29d170b..9c07248f2 100644
--- a/man/is_nested_models.Rd
+++ b/man/is_nested_models.Rd
@@ -18,6 +18,12 @@ models is in decreasing or increasing order.
 Checks whether a list of models are nested models, strictly
 following the order they were passed to the function.
 }
+\details{
+The term "nested" here means that all the fixed predictors of a
+model are contained within the fixed predictors of a larger model (sometimes
+referred to as the encompassing model). Currently, \code{is_nested_models()} ignores
+random effects parameters.
+}
 \examples{
 m1 <- lm(Sepal.Length ~ Petal.Width + Species, data = iris)
 m2 <- lm(Sepal.Length ~ Species, data = iris)
diff --git a/tests/testthat/test-brms.R b/tests/testthat/test-brms.R
index 671502b80..89b585c1b 100644
--- a/tests/testthat/test-brms.R
+++ b/tests/testthat/test-brms.R
@@ -13,7 +13,7 @@ m5 <- insight::download_model("brms_mv_5")
 m6 <- insight::download_model("brms_corr_re1")
 m7 <- suppressWarnings(insight::download_model("brms_mixed_8"))
 m8 <- insight::download_model("brms_ordinal_1")
-brms_trunc_1 <- download_model("brms_trunc_1")
+brms_trunc_1 <- suppressWarnings(download_model("brms_trunc_1"))
 
 all_loaded <- !vapply(list(m1, m2, m3, m4, m5, m6, m7, m8, brms_trunc_1), is.null, TRUE)
 skip_if(!all(all_loaded))
diff --git a/tests/testthat/test-find_terms.R b/tests/testthat/test-find_terms.R
index 76ef25f2e..f7ce38d05 100644
--- a/tests/testthat/test-find_terms.R
+++ b/tests/testthat/test-find_terms.R
@@ -1,8 +1,25 @@
 skip_if_not_installed("lme4")
 
+test_that("find_terms by formula", {
+  data(mtcars)
+  m <- lm(mpg ~ log(hp) * (am + factor(cyl)), data = mtcars)
+  ## FIXME: this is currently wrong behaviour
+  expect_identical(
+    find_terms(m),
+    list(response = "mpg", conditional = c("log(hp)", "(am", "factor(cyl))"))
+  )
+  expect_identical(
+    find_terms(m, as_term_labels = TRUE),
+    list(conditional = c(
+      "log(hp)", "am", "factor(cyl)", "log(hp):am",
+      "log(hp):factor(cyl)"
+    ))
+  )
+})
+
 test_that("find_terms", {
   m <- lm(Sepal.Length ~ -1 + Petal.Width + Species, data = iris)
-  expect_equal(
+  expect_identical(
     find_terms(m),
     list(response = "Sepal.Length", conditional = c("Petal.Width", "Species", "-1"))
   )
@@ -11,7 +28,7 @@ test_that("find_terms", {
 
 test_that("find_terms", {
   m <- lm(Sepal.Length ~ 0 + Petal.Width + Species, data = iris)
-  expect_equal(
+  expect_identical(
     find_terms(m),
     list(response = "Sepal.Length", conditional = c("0", "Petal.Width", "Species"))
   )
@@ -20,7 +37,7 @@ test_that("find_terms", {
 
 test_that("find_terms", {
   m <- lm(Sepal.Length ~ Petal.Width + Species - 1, data = iris)
-  expect_equal(
+  expect_identical(
     find_terms(m),
     list(response = "Sepal.Length", conditional = c("Petal.Width", "Species", "-1"))
   )
@@ -41,7 +58,7 @@ dat$post[dat$time >= 8] <- 1
 m <- suppressMessages(lme4::lmer(y ~ post + time1 + (post + time1 - 1 | g2), data = dat))
 
 test_that("find_terms", {
-  expect_equal(
+  expect_identical(
     find_terms(m),
     list(response = "y", conditional = c("post", "time1"), random = c("post", "time1", "g2"))
   )
diff --git a/tests/testthat/test-logistf.R b/tests/testthat/test-logistf.R
index 47ad6d1e9..7e8940ed5 100644
--- a/tests/testthat/test-logistf.R
+++ b/tests/testthat/test-logistf.R
@@ -77,7 +77,7 @@ test_that("find_terms", {
 })
 
 test_that("n_obs", {
-  expect_identical(n_obs(m1), 239L)
+  expect_identical(n_obs(m1), 239)
 })
 
 test_that("linkfun", {

From e5f7306a9a5954c3d73743dc34656507e51e36fd Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Fri, 23 Jun 2023 12:03:22 +0200
Subject: [PATCH 80/98] reorder (#787)

* reorder

* add test

* wordlist

* disable test for now
---
 DESCRIPTION                                   |  2 +-
 NEWS.md                                       |  5 +++
 R/standardize_column_order.R                  | 10 +++---
 inst/WORDLIST                                 |  4 ++-
 .../testthat/test-standardize_column_order.R  | 33 +++++++++++++++----
 5 files changed, 40 insertions(+), 14 deletions(-)

diff --git a/DESCRIPTION b/DESCRIPTION
index 9b8bf4c8e..1526458ac 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -1,7 +1,7 @@
 Type: Package
 Package: insight
 Title: Easy Access to Model Information for Various Model Objects
-Version: 0.19.2.6
+Version: 0.19.2.7
 Authors@R: 
     c(person(given = "Daniel",
              family = "Lüdecke",
diff --git a/NEWS.md b/NEWS.md
index 5d5c83472..aa8881465 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -1,5 +1,10 @@
 # insight 0.19.3
 
+## Breaking changes
+
+* `standardize_column_order()` has changed the position when re-ordering Bayes
+  factors, ROPEs and ESS / Rhat (mainly relevant for Bayesian models).
+
 ## Changes to functions
 
 * `standardize_names()` and `standardize_column_order()` now also recognize the
diff --git a/R/standardize_column_order.R b/R/standardize_column_order.R
index ce87f6993..00eebec28 100644
--- a/R/standardize_column_order.R
+++ b/R/standardize_column_order.R
@@ -70,7 +70,6 @@ standardize_column_order.parameters_model <- function(data,
       "CI", "CI_low", "CI_high", "Difference_CI_low", "Difference_CI_high",
       "CI_Method", "CI_Distribution", "CI_Iterations",
       "Sum_Squares", "Mean_Square",
-      "pd", "ROPE_CI", "ROPE_low", "ROPE_high", "ROPE_Percentage", "Rhat", "ESS",
       # prior details
       "Prior_Distribution", "Prior_Location", "Prior_Scale",
       # test details
@@ -82,9 +81,9 @@ standardize_column_order.parameters_model <- function(data,
       # degrees of freedom
       "df", "df_error", "df_residual",
       # p-value
-      "p", "BF", "log_BF",
+      "p", "pd", "ROPE_CI", "ROPE_low", "ROPE_high", "ROPE_Percentage", "BF", "log_BF",
       # other details
-      "Alternative", "n_Obs",
+      "Alternative", "n_Obs", "Rhat", "ESS",
       # effectsize details
       "Effectsize",
       "d", "Cohens_d", "d_CI_low", "d_CI_high",
@@ -112,7 +111,6 @@ standardize_column_order.parameters_model <- function(data,
       "std.error", "std.dev",
       "conf.level", "conf.low", "conf.high", "conf.method", "conf.distribution", "conf.iterations",
       "sum.squares", "mean.square",
-      "pd", "rope.percentage", "rhat", "ess",
       # prior details
       "prior.distribution", "prior.location", "prior.scale",
       # test details
@@ -122,9 +120,9 @@ standardize_column_order.parameters_model <- function(data,
       # degrees of freedom
       "df", "df.error", "df.residual",
       # p-value
-      "p.value", "bayes.factor", "log(bayes.factor)",
+      "p.value", "pd", "rope.percentage", "bayes.factor", "log(bayes.factor)",
       # other details
-      "alternative", "n.obs",
+      "alternative", "n.obs", "rhat", "ess",
       # effectsize details
       "effectsize",
       "d", "cohens.d", "d.conf.low", "d.conf.high",
diff --git a/inst/WORDLIST b/inst/WORDLIST
index 5851998d6..6068ea228 100644
--- a/inst/WORDLIST
+++ b/inst/WORDLIST
@@ -12,7 +12,7 @@ Coloured
 DOI
 Dom
 Elff
-Futrhermore
+ESS
 GJRM
 GLMM
 GLMMadaptive
@@ -31,6 +31,8 @@ Nakagawa
 Newburgh
 ORCID
 PIs
+Rhat
+ROPEs
 RStudio
 Rchoice
 Satterthwaite
diff --git a/tests/testthat/test-standardize_column_order.R b/tests/testthat/test-standardize_column_order.R
index ad225e7ec..2f3c1b773 100644
--- a/tests/testthat/test-standardize_column_order.R
+++ b/tests/testthat/test-standardize_column_order.R
@@ -11,8 +11,8 @@ test_that("get_predicted", {
     Method      = "Student's t-test"
   )
 
-  expect_equal(
-    names(standardize_column_order(df1, style = "easystats")),
+  expect_named(
+    standardize_column_order(df1, style = "easystats"),
     c("Parameter", "CI", "CI_low", "CI_high", "Method", "t", "df", "p")
   )
 
@@ -28,8 +28,8 @@ test_that("get_predicted", {
     method     = "Student's t-test"
   )
 
-  expect_equal(
-    names(standardize_column_order(df2, style = "broom")),
+  expect_named(
+    standardize_column_order(df2, style = "broom"),
     c(
       "estimate", "conf.level", "conf.low", "conf.high", "method",
       "statistic", "df", "p.value"
@@ -49,8 +49,29 @@ test_that("get_predicted", {
     Method      = "Student's t-test"
   )
 
-  expect_equal(
-    names(standardize_column_order(df3, style = "easystats")),
+  expect_named(
+    standardize_column_order(df3, style = "easystats"),
     c("Parameter", "CI", "Method", "t", "df", "p", "CI_Low", "CI_High")
   )
 })
+
+
+## FIXME: requires "cmdstanr" package?
+
+# test_that("reorder columns BF", {
+#   skip_on_cran()
+#   skip_on_os(c("mac", "linux"))
+#   brms_bf <- suppressWarnings(download_model("brms_bf_1"))
+#   skip_if(is.null(brms_bf))
+#   skip_if_not_installed("parameters")
+#   skip_if_not_installed("bayestestR")
+#   out <- suppressWarnings(parameters::model_parameters(brms_bf, test = c("pd", "BF", "rope")))
+
+#   expect_named(
+#     standardize_column_order(out),
+#     c(
+#       "Parameter", "Median", "Component", "CI", "CI_low", "CI_high",
+#       "pd", "ROPE_Percentage", "log_BF", "Rhat", "ESS"
+#     )
+#   )
+# })

From 5b874b4a7bbe30d1bb4f0d6e7431f8f81232715b Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Mon, 26 Jun 2023 10:28:30 +0200
Subject: [PATCH 81/98] Make sure column order of BF does not change (#788)

* Make sure column order of BF does not change

* minor

* typo

* test
---
 NEWS.md                            |  2 +-
 R/format_table.R                   | 13 +++++++-----
 tests/testthat/test-format_table.R | 33 +++++++++++++++++++++++++-----
 3 files changed, 37 insertions(+), 11 deletions(-)

diff --git a/NEWS.md b/NEWS.md
index aa8881465..ac1012a1b 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -108,7 +108,7 @@
 * `get_data()` was revised and now always tries to recover the data that was
   used to fit a model from the environment. If this fails, it falls back to
   recovering data from the model frame (the former default behaviour).
-  Futrhermore, the `source` argument can be used to explicitly force the old
+  Furthermore, the `source` argument can be used to explicitly force the old
   behaviour: `source = "mf"` will try to recover data from the model frame first,
   then possibly falling back to look in the environment.
 
diff --git a/R/format_table.R b/R/format_table.R
index 191f30305..505da9ff1 100644
--- a/R/format_table.R
+++ b/R/format_table.R
@@ -566,7 +566,7 @@ format_table <- function(x,
     {
       ci_low <- names(x)[which(names(x) == "conf.low")]
       ci_high <- names(x)[which(names(x) == "conf.high")]
-      x$conf.int <- format_ci(
+      x$conf.low <- format_ci(
         x[[ci_low]],
         x[[ci_high]],
         ci = NULL,
@@ -575,7 +575,7 @@ format_table <- function(x,
         brackets = ci_brackets,
         zap_small = zap_small
       )
-      x$conf.low <- NULL
+      names(x)[names(x) == "conf.low"] <- "conf.int"
       x$conf.high <- NULL
       x
     },
@@ -652,10 +652,13 @@ format_table <- function(x,
   }
 
   # Indices
-  if ("BF" %in% names(x)) x$BF <- format_bf(x$BF, name = NULL, stars = starlist[["BF"]], exact = exact)
+  if ("BF" %in% names(x)) {
+    x$BF <- format_bf(x$BF, name = NULL, stars = starlist[["BF"]], exact = exact)
+  }
   if ("log_BF" %in% names(x)) {
-    x$BF <- format_bf(exp(x$log_BF), name = NULL, stars = starlist[["BF"]], exact = exact)
-    x$log_BF <- NULL
+    x$log_BF <- format_bf(exp(x$log_BF), name = NULL, stars = starlist[["BF"]], exact = exact)
+    x$BF <- NULL
+    colnames(x)[colnames(x) == "log_BF"] <- "BF"
   }
   if ("pd" %in% names(x)) x$pd <- format_pd(x$pd, name = NULL, stars = starlist[["pd"]])
   if ("Rhat" %in% names(x)) x$Rhat <- format_value(x$Rhat, digits = 3)
diff --git a/tests/testthat/test-format_table.R b/tests/testthat/test-format_table.R
index c5f64f24d..c88dc9ba0 100644
--- a/tests/testthat/test-format_table.R
+++ b/tests/testthat/test-format_table.R
@@ -12,32 +12,55 @@ x <- suppressWarnings(as.data.frame(bayestestR::describe_posterior(m1, test = c(
 
 test_that("format_table with stars bayes", {
   out <- format_table(x)
-  expect_identical(colnames(out), c("Parameter", "Median", "95% CI", "pd", "Rhat", "ESS", "BF"))
+  expect_identical(colnames(out), c("Parameter", "Median", "95% CI", "pd", "BF", "Rhat", "ESS"))
   expect_identical(out$BF[2], "114.21")
   expect_identical(out$pd, c("99.98%", "100%"))
 
   out <- format_table(x, stars = TRUE)
-  expect_identical(colnames(out), c("Parameter", "Median", "95% CI", "pd", "Rhat", "ESS", "BF"))
+  expect_identical(colnames(out), c("Parameter", "Median", "95% CI", "pd", "BF", "Rhat", "ESS"))
   expect_identical(out$BF[2], "114.21***")
   expect_identical(out$pd, c("99.98%***", "100%***"))
 
   out <- format_table(x, stars = c("pd", "BF"))
-  expect_identical(colnames(out), c("Parameter", "Median", "95% CI", "pd", "Rhat", "ESS", "BF"))
+  expect_identical(colnames(out), c("Parameter", "Median", "95% CI", "pd", "BF", "Rhat", "ESS"))
   expect_identical(out$BF[2], "114.21***")
   expect_identical(out$pd, c("99.98%***", "100%***"))
 
   out <- format_table(x, stars = "pd")
-  expect_identical(colnames(out), c("Parameter", "Median", "95% CI", "pd", "Rhat", "ESS", "BF"))
+  expect_identical(colnames(out), c("Parameter", "Median", "95% CI", "pd", "BF", "Rhat", "ESS"))
   expect_identical(out$BF[2], "114.21")
   expect_identical(out$pd, c("99.98%***", "100%***"))
 
   out <- format_table(x, stars = "BF")
-  expect_identical(colnames(out), c("Parameter", "Median", "95% CI", "pd", "Rhat", "ESS", "BF"))
+  expect_identical(colnames(out), c("Parameter", "Median", "95% CI", "pd", "BF", "Rhat", "ESS"))
   expect_identical(out$BF[2], "114.21***")
   expect_identical(out$pd, c("99.98%", "100%"))
 })
 
 
+set.seed(123)
+x <- suppressWarnings(as.data.frame(bayestestR::describe_posterior(m1, test = c("pd", "bf", "rope"))))
+
+test_that("format_table with column order", {
+  out <- format_table(x)
+  expect_named(
+    out,
+    c(
+      "Parameter", "Median", "95% CI", "pd", "ROPE", "% in ROPE",
+      "BF", "Rhat", "ESS"
+    )
+  )
+  expect_named(
+    standardize_column_order(x),
+    c(
+      "Parameter", "Median", "CI", "CI_low", "CI_high", "pd", "ROPE_CI",
+      "ROPE_low", "ROPE_high", "ROPE_Percentage", "log_BF", "Rhat",
+      "ESS"
+    )
+  )
+})
+
+
 # test for freq models -----------------
 skip_if_not_installed("parameters")
 x <- as.data.frame(parameters::model_parameters(lm(Sepal.Length ~ Species + Sepal.Width, data = iris)))

From 893353fa3af3b6b761c9027b35a180dd47749932 Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Mon, 26 Jun 2023 10:39:49 +0200
Subject: [PATCH 82/98] tests

---
 tests/testthat/_snaps/windows/format_table.md | 14 +++++++
 tests/testthat/test-format_table.R            | 41 +++++++++++++-----
 .../testthat/test-standardize_column_order.R  | 42 +++++++++++--------
 3 files changed, 69 insertions(+), 28 deletions(-)
 create mode 100644 tests/testthat/_snaps/windows/format_table.md

diff --git a/tests/testthat/_snaps/windows/format_table.md b/tests/testthat/_snaps/windows/format_table.md
new file mode 100644
index 000000000..4300da6cc
--- /dev/null
+++ b/tests/testthat/_snaps/windows/format_table.md
@@ -0,0 +1,14 @@
+# reorder columns BF
+
+    Code
+      format_table(out)
+    Output
+          Parameter   Component Median         95% CI   pd % in ROPE       BF  Rhat
+      1 b_Intercept conditional  32.22 [27.22, 35.76] 100%        0% 1.97e+06 1.004
+      2        b_wt conditional  -3.76 [-4.97, -2.21] 100%        0%   330.18 1.001
+      3       sigma       sigma   3.46 [ 2.65,  4.70] 100%        0% 7.29e+03 0.992
+           ESS
+      1  88.00
+      2  92.00
+      3 168.00
+
diff --git a/tests/testthat/test-format_table.R b/tests/testthat/test-format_table.R
index c88dc9ba0..e6a2aa7da 100644
--- a/tests/testthat/test-format_table.R
+++ b/tests/testthat/test-format_table.R
@@ -7,10 +7,10 @@ skip_if_not_installed("rstanarm")
 m1 <- insight::download_model("stanreg_glm_1")
 skip_if(is.null(m1))
 
-set.seed(123)
-x <- suppressWarnings(as.data.frame(bayestestR::describe_posterior(m1, test = c("pd", "bf"))))
-
 test_that("format_table with stars bayes", {
+  set.seed(123)
+  x <- suppressWarnings(as.data.frame(bayestestR::describe_posterior(m1, test = c("pd", "bf"))))
+
   out <- format_table(x)
   expect_identical(colnames(out), c("Parameter", "Median", "95% CI", "pd", "BF", "Rhat", "ESS"))
   expect_identical(out$BF[2], "114.21")
@@ -38,10 +38,10 @@ test_that("format_table with stars bayes", {
 })
 
 
-set.seed(123)
-x <- suppressWarnings(as.data.frame(bayestestR::describe_posterior(m1, test = c("pd", "bf", "rope"))))
-
 test_that("format_table with column order", {
+  set.seed(123)
+  x <- suppressWarnings(as.data.frame(bayestestR::describe_posterior(m1, test = c("pd", "bf", "rope"))))
+
   out <- format_table(x)
   expect_named(
     out,
@@ -62,10 +62,10 @@ test_that("format_table with column order", {
 
 
 # test for freq models -----------------
-skip_if_not_installed("parameters")
-x <- as.data.frame(parameters::model_parameters(lm(Sepal.Length ~ Species + Sepal.Width, data = iris)))
-
 test_that("format_table with stars freq", {
+  skip_if_not_installed("parameters")
+  x <- as.data.frame(parameters::model_parameters(lm(Sepal.Length ~ Species + Sepal.Width, data = iris)))
+
   out <- format_table(x)
   expect_identical(colnames(out), c("Parameter", "Coefficient", "SE", "95% CI", "t(146)", "p"))
   expect_identical(out$p, c("< .001", "< .001", "< .001", "< .001"))
@@ -84,11 +84,32 @@ test_that("format_table with stars freq", {
 })
 
 # test for freq models -----------------
-skip_if_not_installed("parameters")
 test_that("formatting ROPE CI", {
+  skip_if_not_installed("parameters")
   data(iris)
   d <- iris
   d$Sepal.Length10 <- 10 * d$Sepal.Length
   m10 <- lm(Sepal.Length10 ~ Sepal.Width + Species, data = d)
   expect_snapshot(print(parameters::equivalence_test(m10)))
 })
+
+
+test_that("reorder columns BF", {
+  # brms_bf <- suppressWarnings(download_model("brms_bf_1"))
+  out <- data.frame(
+    Parameter = c("b_Intercept", "b_wt", "sigma"),
+    Component = c("conditional", "conditional", "sigma"),
+    Median = c(32.22175, -3.755645, 3.461165),
+    CI = c(0.95, 0.95, 0.95),
+    CI_low = c(27.2244525, -4.9688055, 2.6517275),
+    CI_high = c(35.75887, -2.21074025, 4.69652725),
+    pd = c(1, 1, 1),
+    ROPE_Percentage = c(0, 0, 0),
+    log_BF = c(14.4924732349718, 5.79962753110103, 8.89383915455679),
+    Rhat = c(1.00438747198895, 1.00100407213689, 0.992006699276081),
+    ESS = c(88.3152312142069, 91.7932788446396, 167.822262320689),
+    stringsAsFactors = FALSE
+  )
+
+  expect_snapshot(format_table(out), variant = "windows")
+})
diff --git a/tests/testthat/test-standardize_column_order.R b/tests/testthat/test-standardize_column_order.R
index 2f3c1b773..b2bb35a33 100644
--- a/tests/testthat/test-standardize_column_order.R
+++ b/tests/testthat/test-standardize_column_order.R
@@ -56,22 +56,28 @@ test_that("get_predicted", {
 })
 
 
-## FIXME: requires "cmdstanr" package?
-
-# test_that("reorder columns BF", {
-#   skip_on_cran()
-#   skip_on_os(c("mac", "linux"))
-#   brms_bf <- suppressWarnings(download_model("brms_bf_1"))
-#   skip_if(is.null(brms_bf))
-#   skip_if_not_installed("parameters")
-#   skip_if_not_installed("bayestestR")
-#   out <- suppressWarnings(parameters::model_parameters(brms_bf, test = c("pd", "BF", "rope")))
+test_that("reorder columns BF", {
+  # brms_bf <- suppressWarnings(download_model("brms_bf_1"))
+  out <- data.frame(
+    Parameter = c("b_Intercept", "b_wt", "sigma"),
+    Component = c("conditional", "conditional", "sigma"),
+    Median = c(32.22175, -3.755645, 3.461165),
+    CI = c(0.95, 0.95, 0.95),
+    CI_low = c(27.2244525, -4.9688055, 2.6517275),
+    CI_high = c(35.75887, -2.21074025, 4.69652725),
+    pd = c(1, 1, 1),
+    ROPE_Percentage = c(0, 0, 0),
+    log_BF = c(14.4924732349718, 5.79962753110103, 8.89383915455679),
+    Rhat = c(1.00438747198895, 1.00100407213689, 0.992006699276081),
+    ESS = c(88.3152312142069, 91.7932788446396, 167.822262320689),
+    stringsAsFactors = FALSE
+  )
 
-#   expect_named(
-#     standardize_column_order(out),
-#     c(
-#       "Parameter", "Median", "Component", "CI", "CI_low", "CI_high",
-#       "pd", "ROPE_Percentage", "log_BF", "Rhat", "ESS"
-#     )
-#   )
-# })
+  expect_named(
+    standardize_column_order(out),
+    c(
+      "Parameter", "Median", "Component", "CI", "CI_low", "CI_high",
+      "pd", "ROPE_Percentage", "log_BF", "Rhat", "ESS"
+    )
+  )
+})

From 704ee198f8f79aeab651520619a13f8fe10d9c37 Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Wed, 28 Jun 2023 15:20:52 +0200
Subject: [PATCH 83/98] sanity check for format_value

---
 R/format_value.R | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/R/format_value.R b/R/format_value.R
index 3331a461f..0b10739ae 100644
--- a/R/format_value.R
+++ b/R/format_value.R
@@ -228,6 +228,11 @@ format_percent <- function(x, ...) {
   # proper character NA
   if (is.na(.missing)) .missing <- NA_character_
 
+  # sometimes, digits can be `NULL` - sanity check
+  if (is.null(digits)) {
+    digits <- 2
+  }
+
   if (is.numeric(x)) {
     if (isTRUE(.as_percent)) {
       need_sci <- (abs(100 * x) >= 1e+5 | (log10(abs(100 * x)) < -digits)) & x != 0

From a95325c169707b37ddba06f0cd7bf5c84fc9edb5 Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Thu, 29 Jun 2023 17:14:27 +0200
Subject: [PATCH 84/98] CRAN submission (#789)

* CRAN submission

* be less verbose

* add test

* submitted
---
 CRAN-SUBMISSION                    | 6 +++---
 DESCRIPTION                        | 2 +-
 R/is_nullmodel.R                   | 7 +++++--
 cran-comments.md                   | 2 ++
 tests/testthat/test-is_nullmodel.R | 4 ++++
 5 files changed, 15 insertions(+), 6 deletions(-)

diff --git a/CRAN-SUBMISSION b/CRAN-SUBMISSION
index 4738a0ad0..7d94196fa 100644
--- a/CRAN-SUBMISSION
+++ b/CRAN-SUBMISSION
@@ -1,3 +1,3 @@
-Version: 0.19.2
-Date: 2023-05-23 15:29:06 UTC
-SHA: aff90a1106ec876c55d22aa833b27d2c5192d2cd
+Version: 0.19.3
+Date: 2023-06-27 17:03:53 UTC
+SHA: 192c44fff3e72bc693d0b937e72028bf80513077
diff --git a/DESCRIPTION b/DESCRIPTION
index 1526458ac..ae7bda315 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -1,7 +1,7 @@
 Type: Package
 Package: insight
 Title: Easy Access to Model Information for Various Model Objects
-Version: 0.19.2.7
+Version: 0.19.3
 Authors@R: 
     c(person(given = "Daniel",
              family = "Lüdecke",
diff --git a/R/is_nullmodel.R b/R/is_nullmodel.R
index d92e3783e..28829aa7d 100644
--- a/R/is_nullmodel.R
+++ b/R/is_nullmodel.R
@@ -30,9 +30,12 @@ is_nullmodel <- function(x) {
 #' @export
 is_nullmodel.default <- function(x) {
   if (is_multivariate(x)) {
-    unlist(lapply(find_predictors(x, effects = "fixed", component = "conditional"), .check_for_nullmodel))
+    unlist(lapply(
+      find_predictors(x, effects = "fixed", component = "conditional", verbose = FALSE),
+      .check_for_nullmodel
+    ))
   } else {
-    .check_for_nullmodel(find_predictors(x, effects = "fixed", component = "conditional"))
+    .check_for_nullmodel(find_predictors(x, effects = "fixed", component = "conditional", verbose = FALSE))
   }
 }
 
diff --git a/cran-comments.md b/cran-comments.md
index 8d3450e3f..3986ee2eb 100644
--- a/cran-comments.md
+++ b/cran-comments.md
@@ -1,3 +1,5 @@
+Maintainance release.
+
 ## revdepcheck results
 
 We checked 35 reverse dependencies, comparing R CMD check results across CRAN and dev versions of this package.
diff --git a/tests/testthat/test-is_nullmodel.R b/tests/testthat/test-is_nullmodel.R
index 2f7456248..33351f517 100644
--- a/tests/testthat/test-is_nullmodel.R
+++ b/tests/testthat/test-is_nullmodel.R
@@ -15,3 +15,7 @@ test_that("is_nullmodel", {
   expect_false(is_nullmodel(m4))
   expect_true(is_nullmodel(m5))
 })
+
+test_that("is_nullmodel, don't be verbose", {
+  expect_silent(is_nullmodel(lm(mtcars$mpg ~ 1)))
+})

From d5225bec666990066739f3a153b5efd2c107b699 Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Mon, 24 Jul 2023 10:38:01 +0200
Subject: [PATCH 85/98] get_predict(predict = "link") for `gaussian(link =
 "log")` models (#792)

* get_predict(predict = "link") for `gaussian(link = "log")` models
Fixes #791

* fix test

* fix test

* style

* fix warning in examples
---
 DESCRIPTION                         |   3 +-
 NEWS.md                             |   8 +
 R/get_predicted_args.R              |   4 +-
 R/model_info.R                      |  14 +-
 man/model_info.Rd                   |  14 +-
 tests/testthat/test-get_predicted.R | 220 ++++++++++++++++------------
 6 files changed, 145 insertions(+), 118 deletions(-)

diff --git a/DESCRIPTION b/DESCRIPTION
index ae7bda315..fa7abf171 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -1,7 +1,7 @@
 Type: Package
 Package: insight
 Title: Easy Access to Model Information for Various Model Objects
-Version: 0.19.3
+Version: 0.19.3.1
 Authors@R: 
     c(person(given = "Daniel",
              family = "Lüdecke",
@@ -157,6 +157,7 @@ Suggests:
     mlogit,
     mhurdle,
     mmrm,
+    modelbased,
     multgee,
     nestedLogit,
     nlme,
diff --git a/NEWS.md b/NEWS.md
index ac1012a1b..8ba72f04f 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -1,3 +1,11 @@
+# insight 0.19.3.1
+
+## Changes to functions
+
+* `get_predicted()` now accepts `predict = "link"` for gaussian models with
+  log-link (i.e. `glm(..., family = gaussian("log"))`), to return predictions
+  on the link scale.
+
 # insight 0.19.3
 
 ## Breaking changes
diff --git a/R/get_predicted_args.R b/R/get_predicted_args.R
index f424f98bf..de0b8f588 100644
--- a/R/get_predicted_args.R
+++ b/R/get_predicted_args.R
@@ -147,8 +147,8 @@
     scale_arg <- "terms"
     transform <- FALSE
 
-    # linear models are always on response scale (there is no other)
-  } else if (info$is_linear && !info$is_gam) {
+    # linear models are always on response scale (there is no other, unless gaussian("log"))
+  } else if (info$is_linear && !info$is_gam && !identical(info$link_function, "log")) {
     type_arg <- "response"
     scale_arg <- "response"
     transform <- FALSE
diff --git a/R/model_info.R b/R/model_info.R
index f6c0343ef..2156b904e 100644
--- a/R/model_info.R
+++ b/R/model_info.R
@@ -66,19 +66,11 @@
 #' dat <- data.frame(ldose, sex, SF, stringsAsFactors = FALSE)
 #' m <- glm(SF ~ sex * ldose, family = binomial)
 #'
+#' # logistic regression
 #' model_info(m)
-#' \dontrun{
-#' library(glmmTMB)
-#' data("Salamanders")
-#' m <- glmmTMB(
-#'   count ~ spp + cover + mined + (1 | site),
-#'   ziformula = ~ spp + mined,
-#'   dispformula = ~DOY,
-#'   data = Salamanders,
-#'   family = nbinom2
-#' )
-#' }
 #'
+#' # t-test
+#' m <- t.test(1:10, y = c(7:20))
 #' model_info(m)
 #' @export
 model_info <- function(x, ...) {
diff --git a/man/model_info.Rd b/man/model_info.Rd
index 1e5abaaa5..60cc1f101 100644
--- a/man/model_info.Rd
+++ b/man/model_info.Rd
@@ -81,18 +81,10 @@ SF <- cbind(numdead, numalive = 20 - numdead)
 dat <- data.frame(ldose, sex, SF, stringsAsFactors = FALSE)
 m <- glm(SF ~ sex * ldose, family = binomial)
 
+# logistic regression
 model_info(m)
-\dontrun{
-library(glmmTMB)
-data("Salamanders")
-m <- glmmTMB(
-  count ~ spp + cover + mined + (1 | site),
-  ziformula = ~ spp + mined,
-  dispformula = ~DOY,
-  data = Salamanders,
-  family = nbinom2
-)
-}
 
+# t-test
+m <- t.test(1:10, y = c(7:20))
 model_info(m)
 }
diff --git a/tests/testthat/test-get_predicted.R b/tests/testthat/test-get_predicted.R
index 766e44127..d58dcbe65 100644
--- a/tests/testthat/test-get_predicted.R
+++ b/tests/testthat/test-get_predicted.R
@@ -6,7 +6,6 @@ skip_on_cran()
 
 test_that("get_predicted - lm", {
   skip_on_cran()
-  skip_if_not_installed("rstanarm")
 
   x <- lm(mpg ~ cyl + hp, data = mtcars)
 
@@ -24,7 +23,7 @@ test_that("get_predicted - lm", {
   # Confidence
   ref <- predict(x, se.fit = TRUE, interval = "confidence")
   rez <- as.data.frame(get_predicted(x, predict = "expectation", ci = 0.95))
-  expect_equal(nrow(rez), 32)
+  expect_identical(nrow(rez), 32L)
   expect_equal(max(abs(as.data.frame(ref$fit)$fit - rez$Predicted)), 0, tolerance = 1e-10)
   expect_equal(max(abs(ref$se.fit - rez$SE)), 0, tolerance = 1e-10)
   expect_equal(max(abs(as.data.frame(ref$fit)$lwr - rez$CI_low)), 0, tolerance = 1e-10)
@@ -32,7 +31,7 @@ test_that("get_predicted - lm", {
   # Prediction
   ref <- predict(x, newdata = get_data(x), se.fit = TRUE, interval = "prediction")
   rez <- as.data.frame(get_predicted(x, predict = "prediction", ci = 0.95))
-  expect_equal(nrow(rez), 32)
+  expect_identical(nrow(rez), 32L)
   expect_equal(max(abs(as.data.frame(ref$fit)$fit - rez$Predicted)), 0, tolerance = 1e-10)
   expect_equal(max(abs(as.data.frame(ref$fit)$lwr - rez$CI_low)), 0, tolerance = 1e-10)
 
@@ -40,12 +39,14 @@ test_that("get_predicted - lm", {
   set.seed(333)
   ref <- predict(x, newdata = get_data(x), se.fit = TRUE, interval = "confidence")
   rez <- get_predicted(x, iterations = 600, ci = 0.95)
-  expect_equal(length(rez), 32)
+  expect_length(rez, 32)
   expect_null(nrow(rez))
   expect_equal(mean(abs(as.data.frame(ref$fit)$fit - summary(rez)$Predicted)), 0, tolerance = 0.1)
   expect_equal(mean(abs(as.data.frame(ref$fit)$lwr - summary(rez)$CI_low)), 0, tolerance = 0.5)
   # TODO: Is it possible to get "prediction" CIs via bootstrapping?
 
+  skip_if_not_installed("rstanarm")
+
   # vs. Bayesian
   xbayes <- rstanarm::stan_glm(mpg ~ cyl + hp, data = mtcars, refresh = 0, seed = 333)
   rez <- as.data.frame(get_predicted(x, predict = "link", ci = 0.95))
@@ -61,17 +62,16 @@ test_that("get_predicted - lm", {
 
 test_that("get_predicted - glm", {
   skip_on_cran()
-  skip_if_not_installed("rstanarm")
 
   x <- glm(vs ~ wt, data = mtcars, family = "binomial")
 
   # Link vs. relation
   rezlink <- get_predicted(x, predict = "link", ci = 0.95)
   rezrela <- get_predicted(x, predict = "expectation", ci = 0.95)
-  expect_true(min(rezlink) < 0)
-  expect_true(min(rezrela) > 0)
-  expect_true(min(summary(rezlink)$CI_low) < 0)
-  expect_true(min(summary(rezrela)$CI_low) > 0)
+  expect_lt(min(rezlink), 0)
+  expect_gt(min(rezrela), 0)
+  expect_lt(min(summary(rezlink)$CI_low), 0)
+  expect_gt(min(summary(rezrela)$CI_low), 0)
 
   # Relation vs. Prediction
   rezrela <- get_predicted(x, predict = "expectation", ci = 0.95)
@@ -82,7 +82,7 @@ test_that("get_predicted - glm", {
   # Against stats::predict
   ref <- predict(x, se.fit = TRUE, type = "response", ci = 0.95)
   rez <- as.data.frame(get_predicted(x, predict = "expectation", ci = 0.95))
-  expect_equal(nrow(rez), 32)
+  expect_identical(nrow(rez), 32L)
   expect_equal(max(abs(ref$fit - rez$Predicted)), 0, tolerance = 1e-4)
   expect_equal(max(abs(ref$se.fit - rez$SE)), 0, tolerance = 1e-4)
   ref <- as.data.frame(suppressWarnings(link_inverse(x)(predict.lm(x, interval = "confidence"))))
@@ -90,7 +90,7 @@ test_that("get_predicted - glm", {
 
   ref <- predict(x, se.fit = TRUE, type = "link")
   rez <- as.data.frame(get_predicted(x, predict = "link", ci = 0.95))
-  expect_equal(nrow(rez), 32)
+  expect_identical(nrow(rez), 32L)
   expect_equal(max(abs(ref$fit - rez$Predicted)), 0, tolerance = 1e-4)
   expect_equal(max(abs(ref$se.fit - rez$SE)), 0, tolerance = 1e-4)
 
@@ -100,6 +100,8 @@ test_that("get_predicted - glm", {
   rez <- suppressWarnings(summary(get_predicted(x, iterations = 800, verbose = FALSE, ci = 0.95)))
   expect_equal(mean(abs(ref$fit - rez$Predicted)), 0, tolerance = 0.1)
 
+  skip_if_not_installed("rstanarm")
+
   # vs. Bayesian
   xbayes <- rstanarm::stan_glm(vs ~ wt, data = mtcars, family = "binomial", refresh = 0, seed = 333)
   rez <- as.data.frame(get_predicted(x, predict = "link", ci = 0.95))
@@ -112,17 +114,43 @@ test_that("get_predicted - glm", {
   # expect_equal(mean(abs(rez$CI_low - rezbayes$CI_low)), 0, tolerance = 0.3)
 })
 
+test_that("get_predicted - glm", {
+  skip_on_cran()
+  skip_if_not_installed("modelbased")
+  # link works for gaussian with log-link
+  set.seed(123)
+  dat <- data.frame(Y = rlnorm(100), x = rnorm(100))
+  ## fit glm
+  dat_glm <- glm(Y ~ 1, data = dat, family = gaussian(link = "log"))
+  ## predictions on the response scale - correct
+  out <- modelbased::estimate_relation(dat_glm, length = 1)
+  expect_equal(
+    out$Predicted,
+    predict(dat_glm, type = "response")[1],
+    tolerance = 0.01,
+    ignore_attr = TRUE
+  )
+  ## predictions on the link scale - incorrect
+  out <- modelbased::estimate_link(dat_glm, length = 1)
+  expect_equal(
+    out$Predicted,
+    predict(dat_glm, type = "link")[1],
+    tolerance = 0.01,
+    ignore_attr = TRUE
+  )
+})
+
 test_that("get_predicted - lm (log)", {
   x <- lm(mpg ~ log(hp), data = mtcars)
   rez <- get_predicted(x)
-  expect_equal(length(rez), 32)
+  expect_length(rez, 32)
 
-  expect_equal(max(abs(rez - stats::fitted(x))), 0)
-  expect_equal(max(abs(rez - stats::predict(x))), 0)
+  expect_equal(max(abs(rez - stats::fitted(x))), 0, tolerance = 1e-4)
+  expect_equal(max(abs(rez - stats::predict(x))), 0, tolerance = 1e-4)
 
   data <- as.data.frame(rez)
-  expect_equal(max(abs(rez - data$Predicted)), 0)
-  expect_equal(nrow(data), 32)
+  expect_equal(max(abs(rez - data$Predicted)), 0, tolerance = 1e-4)
+  expect_identical(nrow(data), 32L)
 })
 
 
@@ -181,7 +209,7 @@ test_that("get_predicted - lmerMod", {
   skip_on_cran()
 
   suppressPackageStartupMessages({
-    suppressWarnings(suppressMessages(library(rstanarm, quietly = TRUE, warn.conflicts = FALSE)))
+    suppressWarnings(suppressMessages(library(rstanarm, quietly = TRUE, warn.conflicts = FALSE))) # nolint
   })
 
   x <- lme4::lmer(mpg ~ am + (1 | cyl), data = mtcars)
@@ -197,7 +225,7 @@ test_that("get_predicted - lmerMod", {
   # Bootstrap
   set.seed(333)
   rez <- as.data.frame(get_predicted(x, iterations = 5, ci = 0.95))
-  expect_equal(c(nrow(rez), ncol(rez)), c(32, 9))
+  expect_identical(c(nrow(rez), ncol(rez)), c(32L, 9L))
 
 
   # Compare to merTools
@@ -249,15 +277,15 @@ test_that("get_predicted - lmerMod (log)", {
   skip_if_not_installed("lme4")
   x <- lme4::lmer(mpg ~ am + log(hp) + (1 | cyl), data = mtcars)
   rez <- get_predicted(x)
-  expect_equal(length(rez), 32)
+  expect_length(rez, 32)
 
-  expect_equal(max(abs(rez - stats::fitted(x))), 0)
-  expect_equal(max(abs(rez - stats::predict(x))), 0)
-  expect_equal(nrow(as.data.frame(rez)), 32)
+  expect_equal(max(abs(rez - stats::fitted(x))), 0, tolerance = 1e-4)
+  expect_equal(max(abs(rez - stats::predict(x))), 0, tolerance = 1e-4)
+  expect_equal(nrow(as.data.frame(rez)), 32, tolerance = 1e-4)
 
   # No random
   rez2 <- get_predicted(x, newdata = mtcars[c("am", "hp")], verbose = FALSE)
-  expect_true(!all(is.na(as.data.frame(rez2))))
+  expect_false(all(is.na(as.data.frame(rez2))))
 })
 
 
@@ -267,13 +295,13 @@ test_that("get_predicted - merMod", {
   x <- lme4::glmer(vs ~ am + (1 | cyl), data = mtcars, family = "binomial")
   rezlink <- get_predicted(x, predict = "link", ci = 0.95)
   rezrela <- get_predicted(x, predict = "expectation", ci = 0.95)
-  expect_true(min(rezlink) < 0)
-  expect_true(min(rezrela) > 0)
-  expect_true(min(summary(rezlink)$CI_low) < 0)
-  expect_true(min(summary(rezrela)$CI_low) > 0)
-  expect_equal(max(abs(rezrela - stats::fitted(x))), 0)
-  expect_equal(max(abs(rezrela - stats::predict(x, type = "response"))), 0)
-  expect_equal(nrow(as.data.frame(rezlink)), 32)
+  expect_lt(min(rezlink), 0)
+  expect_gt(min(rezrela), 0)
+  expect_lt(min(summary(rezlink)$CI_low), 0)
+  expect_gt(min(summary(rezrela)$CI_low), 0)
+  expect_equal(max(abs(rezrela - stats::fitted(x))), 0, tolerance = 1e-4)
+  expect_equal(max(abs(rezrela - stats::predict(x, type = "response"))), 0, tolerance = 1e-4)
+  expect_identical(nrow(as.data.frame(rezlink)), 32L)
 
   # Compare with glmmTMB
   xref <- glmmTMB::glmmTMB(vs ~ am + (1 | cyl), data = mtcars, family = "binomial")
@@ -296,26 +324,26 @@ test_that("get_predicted - glmmTMB", {
   # Bootstrap
   set.seed(333)
   rez <- as.data.frame(get_predicted(x, iterations = 5, predict = "link", ci = 0.95))
-  expect_equal(c(nrow(rez), ncol(rez)), c(32, 9))
+  expect_identical(c(nrow(rez), ncol(rez)), c(32L, 9L))
 
   # Binomial
   x <- glmmTMB::glmmTMB(vs ~ am + (1 | cyl), data = mtcars, family = "binomial")
   rezlink <- get_predicted(x, predict = "link", ci = 0.95)
   rezrela <- get_predicted(x, predict = "expectation", ci = 0.95)
-  expect_true(min(rezlink) < 0)
-  expect_true(min(rezrela) > 0)
-  expect_true(min(summary(rezlink)$CI_low) < 0)
-  expect_true(min(summary(rezrela)$CI_low) > 0)
-  expect_equal(max(abs(rezrela - stats::fitted(x))), 0)
-  expect_equal(max(abs(rezrela - stats::predict(x, type = "response"))), 0)
-  expect_equal(nrow(as.data.frame(rez)), 32)
+  expect_lt(min(rezlink), 0)
+  expect_gt(min(rezrela), 0)
+  expect_lt(min(summary(rezlink)$CI_low), 0)
+  expect_gt(min(summary(rezrela)$CI_low), 0)
+  expect_equal(max(abs(rezrela - stats::fitted(x))), 0, tolerance = 1e-4)
+  expect_equal(max(abs(rezrela - stats::predict(x, type = "response"))), 0, tolerance = 1e-4)
+  expect_identical(nrow(as.data.frame(rez)), 32L)
 
   # No random
-  rez <- get_predicted(x, newdata = mtcars[c("am")], verbose = FALSE, ci = 0.95)
-  expect_true(!all(is.na(as.data.frame(rez))))
+  rez <- get_predicted(x, newdata = mtcars["am"], verbose = FALSE, ci = 0.95)
+  expect_false(all(is.na(as.data.frame(rez))))
   x <- glmmTMB::glmmTMB(Petal.Length ~ Petal.Width + (1 | Species), data = iris)
   rez <- get_predicted(x, data = data.frame(Petal.Width = c(0, 1, 2)), verbose = FALSE)
-  expect_equal(length(rez), 3)
+  expect_length(rez, 3)
 
   # vs. Bayesian
   # x <- glmmTMB::glmmTMB(mpg ~ am + (1 | cyl), data = mtcars)
@@ -332,38 +360,38 @@ test_that("get_predicted - glmmTMB", {
 test_that("get_predicted - mgcv::gam and gamm", {
   skip_if_not_installed("mgcv")
   x <- mgcv::gam(mpg ~ am + s(wt), data = mtcars)
-  expect_equal(length(get_predicted(x, ci = 0.95)), 32)
+  expect_length(get_predicted(x, ci = 0.95), 32)
   rez <- get_predicted(x, data = data.frame(am = c(0, 0, 1), wt = c(2, 3, 4)), ci = 0.95)
-  expect_equal(length(rez), 3)
+  expect_length(rez, 3)
 
   # No smooth
   rez <- get_predicted(x, data = data.frame(am = c(0, 0, 1)), ci = 0.95)
-  expect_equal(length(rez), 3)
+  expect_length(rez, 3)
   rez2 <- get_predicted(x, data = data.frame(am = c(0, 0, 1), wt = c(2, 3, 4)), ci = 0.95, include_smooth = FALSE)
   expect_equal(max(abs(as.numeric(rez - rez2))), 0, tolerance = 1e-4)
-  expect_equal(length(unique(attributes(rez)$data$wt)), 1)
+  expect_length(unique(attributes(rez)$data$wt), 1)
 
   # Bootstrap
   set.seed(333)
   rez <- summary(get_predicted(x, iterations = 50, ci = 0.95))
-  expect_equal(nrow(rez), 32)
+  expect_identical(nrow(rez), 32L)
 
   # Binomial
   x <- mgcv::gam(vs ~ am + s(wt), data = mtcars, family = "binomial")
   rez <- get_predicted(x, ci = 0.95)
-  expect_equal(length(rez), 32)
+  expect_length(rez, 32)
 
-  expect_equal(max(abs(rez - stats::fitted(x))), 0)
-  expect_equal(max(abs(rez - stats::predict(x, type = "response"))), 0)
-  expect_equal(nrow(as.data.frame(rez)), 32)
+  expect_equal(max(abs(rez - stats::fitted(x))), 0, tolerance = 1e-4)
+  expect_equal(max(abs(rez - stats::predict(x, type = "response"))), 0, tolerance = 1e-4)
+  expect_identical(nrow(as.data.frame(rez)), 32L)
 
   # GAMM
   x <- mgcv::gamm(vs ~ am + s(wt), random = list(cyl = ~1), data = mtcars, family = "binomial", verbosePQL = FALSE)
   rez <- get_predicted(x, ci = 0.95)
-  expect_equal(length(rez), 32)
-  expect_equal(max(abs(rez - x$gam$fitted.values)), 0)
-  expect_equal(max(abs(rez - stats::predict(x$gam, type = "response"))), 0)
-  expect_equal(nrow(as.data.frame(rez)), 32)
+  expect_length(rez, 32)
+  expect_equal(max(abs(rez - x$gam$fitted.values)), 0, tolerance = 1e-4)
+  expect_equal(max(abs(rez - stats::predict(x$gam, type = "response"))), 0, tolerance = 1e-4)
+  expect_identical(nrow(as.data.frame(rez)), 32L)
 })
 
 
@@ -376,7 +404,7 @@ test_that("get_predicted - rstanarm", {
   skip_if_not_installed("rstanarm")
 
   suppressPackageStartupMessages({
-    suppressWarnings(suppressMessages(library(rstanarm, quietly = TRUE, warn.conflicts = FALSE)))
+    suppressWarnings(suppressMessages(library(rstanarm, quietly = TRUE, warn.conflicts = FALSE))) # nolint
   })
 
   # LM
@@ -393,10 +421,10 @@ test_that("get_predicted - rstanarm", {
   x <- rstanarm::stan_glm(vs ~ wt, data = mtcars, family = "binomial", refresh = 0, seed = 333)
   rezlink <- summary(get_predicted(x, predict = "link", ci = 0.95))
   rezrela <- summary(get_predicted(x, predict = "expectation", ci = 0.95))
-  expect_true(min(rezlink$Predicted) < 0)
-  expect_true(min(rezrela$Predicted) > 0)
-  expect_true(min(rezlink$CI_high) < 0)
-  expect_true(min(rezrela$CI_high) > 0)
+  expect_lt(min(rezlink$Predicted), 0)
+  expect_gt(min(rezrela$Predicted), 0)
+  expect_lt(min(rezlink$CI_high), 0)
+  expect_gt(min(rezrela$CI_high), 0)
   rezpred <- summary(get_predicted(x, predict = "prediction", ci = 0.95))
   expect_equal(mean(abs(rezrela$Predicted - rezpred$Predicted)), 0, tolerance = 0.1)
   expect_true(all(mean(rezrela$CI_high - rezpred$CI_high) < 0))
@@ -412,8 +440,8 @@ test_that("get_predicted - rstanarm", {
   rezpred <- summary(get_predicted(x, predict = "prediction", ci = 0.95))
   rezrela2 <- summary(get_predicted(x, predict = "expectation", ci = 0.95, include_random = FALSE))
   rezpred2 <- summary(get_predicted(x, predict = "prediction", ci = 0.95, include_random = FALSE))
-  expect_true(mean(abs(rezrela$Predicted - rezrela2$Predicted)) > 0)
-  expect_true(mean(abs(rezpred$Predicted - rezpred2$Predicted)) > 0)
+  expect_gt(mean(abs(rezrela$Predicted - rezrela2$Predicted)), 0)
+  expect_gt(mean(abs(rezpred$Predicted - rezpred2$Predicted)), 0)
   rezrela3 <- summary(get_predicted(x, predict = "expectation", ci = 0.95, data = mtcars["am"]), verbose = FALSE)
   expect_equal(mean(abs(rezrela2$Predicted - rezrela3$Predicted)), 0, tolerance = 0.001)
 })
@@ -429,24 +457,24 @@ test_that("get_predicted - FA / PCA", {
 
   # PCA
   x <- get_predicted(psych::principal(mtcars, 3))
-  expect_equal(dim(x), c(32, 3))
+  expect_identical(dim(x), c(32L, 3L))
   x <- get_predicted(psych::principal(mtcars, 3), data = mtcars[1:5, ])
-  expect_equal(dim(x), c(5, 3))
+  expect_identical(dim(x), c(5L, 3L))
 
   x <- get_predicted(prcomp(mtcars))
-  expect_equal(dim(x), c(32, ncol(mtcars)))
+  expect_identical(dim(x), as.integer(c(32, ncol(mtcars))))
   x <- get_predicted(prcomp(mtcars), data = mtcars[1:5, ])
-  expect_equal(dim(x), c(5, ncol(mtcars)))
+  expect_identical(dim(x), as.integer(c(5, ncol(mtcars))))
 
   # FA
   x <- get_predicted(psych::fa(mtcars, 3))
-  expect_equal(dim(x), c(32, 3))
+  expect_identical(dim(x), c(32L, 3L))
   x <- get_predicted(psych::fa(mtcars, 3), data = mtcars[1:5, ])
-  expect_equal(dim(x), c(5, 3))
+  expect_identical(dim(x), c(5L, 3L))
 
   expect_error(get_predicted(fungible::faMain(mtcars, numFactors = 3)))
   x <- get_predicted(fungible::faMain(mtcars, numFactors = 3), data = mtcars[1:5, ])
-  expect_equal(dim(x), c(5, 3))
+  expect_identical(dim(x), c(5L, 3L))
 })
 
 
@@ -491,8 +519,8 @@ test_that("`predict()` vs. `get_predicted` link equivalence", {
   mod <- glm(am ~ hp + factor(cyl), family = binomial, data = mtcars)
   known <- predict(mod, type = "link", interval = "confidence", se.fit = TRUE)
   unknown <- as.data.frame(get_predicted(mod, predict = NULL, type = "link", ci = 0.95))
-  expect_equal(unname(known$fit), unknown$Predicted)
-  expect_equal(unname(known$se.fit), unknown$SE)
+  expect_equal(unname(known$fit), unknown$Predicted, ignore_attr = TRUE)
+  expect_equal(unname(known$se.fit), unknown$SE, ignore_attr = TRUE)
 
   # response
   mod <- glm(am ~ hp + factor(cyl), family = binomial, data = mtcars)
@@ -500,12 +528,12 @@ test_that("`predict()` vs. `get_predicted` link equivalence", {
   unknown1 <- as.data.frame(get_predicted(mod, predict = "expectation", ci = 0.95))
   unknown2 <- as.data.frame(get_predicted(mod, predict = NULL, type = "response", ci = 0.95))
   unknown3 <- as.data.frame(get_predicted(mod, predict = "response", ci = 0.95))
-  expect_equal(unname(known$fit), unknown1$Predicted)
-  expect_equal(unname(known$se.fit), unknown1$SE)
-  expect_equal(unname(known$fit), unknown2$Predicted)
-  expect_equal(unname(known$se.fit), unknown2$SE)
-  expect_equal(unname(known$fit), unknown3$Predicted)
-  expect_equal(unname(known$se.fit), unknown3$SE)
+  expect_equal(unname(known$fit), unknown1$Predicted, ignore_attr = TRUE)
+  expect_equal(unname(known$se.fit), unknown1$SE, ignore_attr = TRUE)
+  expect_equal(unname(known$fit), unknown2$Predicted, ignore_attr = TRUE)
+  expect_equal(unname(known$se.fit), unknown2$SE, ignore_attr = TRUE)
+  expect_equal(unname(known$fit), unknown3$Predicted, ignore_attr = TRUE)
+  expect_equal(unname(known$se.fit), unknown3$SE, ignore_attr = TRUE)
 })
 
 
@@ -540,7 +568,7 @@ test_that("bugfix: used to fail with matrix variables", {
     return(lm(mpg ~ wt + cyl + gear + disp, data = mtcars2))
   }
   pred <- get_predicted(foo())
-  expect_equal(class(pred), c("get_predicted", "numeric"))
+  expect_s3_class(pred, c("get_predicted", "numeric"))
   expect_true(all(attributes(attributes(attributes(
     pred
   )$data)$terms)$dataClasses == "numeric"))
@@ -549,12 +577,14 @@ test_that("bugfix: used to fail with matrix variables", {
   mtcars2 <- mtcars
   mtcars2$wt <- scale(mtcars2$wt)
   m <- lm(mpg ~ wt + cyl + gear + disp, data = mtcars2)
-  expect_no_error(pred <- get_predicted(m))
+  expect_no_error({
+    pred <- get_predicted(m)
+  })
 
   mtcars2$wt <- as.numeric(mtcars2$wt)
   m2 <- lm(mpg ~ wt + cyl + gear + disp, data = mtcars2)
   pred2 <- get_predicted(m2)
-  expect_equal(pred, pred2)
+  expect_equal(pred, pred2, ignore_attr = TRUE)
 })
 
 test_that("brms: `type` in ellipsis used to produce the wrong intervals", {
@@ -562,10 +592,12 @@ test_that("brms: `type` in ellipsis used to produce the wrong intervals", {
   skip_if_not_installed("brms")
   skip_on_os(os = "windows")
   void <- capture.output(
-    suppressMessages(mod <- brms::brm(am ~ hp + mpg,
-      family = brms::bernoulli, data = mtcars,
-      chains = 2, iter = 1000, seed = 1024, silent = 2
-    ))
+    suppressMessages({
+      mod <- brms::brm(am ~ hp + mpg,
+        family = brms::bernoulli, data = mtcars,
+        chains = 2, iter = 1000, seed = 1024, silent = 2
+      )
+    })
   )
   x <- get_predicted(mod, predict = "link", ci = 0.95)
   y <- get_predicted(mod, predict = "expectation", ci = 0.95)
@@ -577,20 +609,22 @@ test_that("brms: `type` in ellipsis used to produce the wrong intervals", {
   data <- mtcars
   data$cyl <- as.character(data$cyl)
   void <- capture.output(
-    suppressMessages(suppressWarnings(model <- brms::brm(cyl ~ mpg * vs + (1 | carb),
-      data = data,
-      iter = 1000,
-      seed = 1024,
-      algorithm = "meanfield",
-      refresh = 0,
-      family = brms::categorical(link = "logit", refcat = "4")
-    )))
+    suppressMessages(suppressWarnings({
+      model <- brms::brm(cyl ~ mpg * vs + (1 | carb),
+        data = data,
+        iter = 1000,
+        seed = 1024,
+        algorithm = "meanfield",
+        refresh = 0,
+        family = brms::categorical(link = "logit", refcat = "4")
+      )
+    }))
   )
   x <- as.data.frame(get_predicted(model, ci = 0.95))
   # Test shape
-  expect_equal(c(nrow(x), ncol(x)), c(32 * 3, 1006))
+  expect_identical(c(nrow(x), ncol(x)), c(96L, 1006L))
   # Test whether median point-estimate indeed different from default (mean)
-  expect_true(max(x$Predicted - get_predicted(model, centrality_function = stats::median)$Predicted) > 0)
+  expect_gt(max(x$Predicted - get_predicted(model, centrality_function = stats::median)$Predicted), 0)
 })
 
 

From 28adc2762956b8a2c7aab3124d7183f9629d03b1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?R=C3=A9mi=20Th=C3=A9riault?=
 <13123390+rempsyc@users.noreply.github.com>
Date: Sun, 6 Aug 2023 13:56:10 -0400
Subject: [PATCH 86/98] * `check_if_installed()` now automatically checks the
 package DESCRIPTION file to   determine the correct minimum version required.

---
 DESCRIPTION                              |  2 +-
 NEWS.md                                  |  6 ++-
 R/check_if_installed.R                   | 47 ++++++++++++++++++++++--
 R/get_predicted_bayesian.R               |  2 +-
 man/check_if_installed.Rd                | 13 ++++++-
 tests/testthat/test-check_if_installed.R |  8 ++++
 6 files changed, 69 insertions(+), 9 deletions(-)

diff --git a/DESCRIPTION b/DESCRIPTION
index fa7abf171..bfd5c4798 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -179,7 +179,7 @@ Suggests:
     robustbase,
     robustlmm,
     rstanarm (>= 2.21.1),
-    rstantools,
+    rstantools (>= 2.1.0),
     rstudioapi,
     sandwich,
     speedglm,
diff --git a/NEWS.md b/NEWS.md
index 8ba72f04f..8895cfec0 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -5,6 +5,9 @@
 * `get_predicted()` now accepts `predict = "link"` for gaussian models with
   log-link (i.e. `glm(..., family = gaussian("log"))`), to return predictions
   on the link scale.
+  
+* `check_if_installed()` now automatically checks the package DESCRIPTION file to 
+  determine the correct minimum version required.
 
 # insight 0.19.3
 
@@ -1270,5 +1273,4 @@
 * Fixed issue in `get_data()` for models with `cbind()`-response variables and
   matrix-like variables in the model frame (e.g. when using `poly()`).
 
-* Fixed issues with `PROreg::BBmm()`, due to changes in latest package update.
-
+* Fixed issues with `PROreg::BBmm()`, due to changes in latest package update.
\ No newline at end of file
diff --git a/R/check_if_installed.R b/R/check_if_installed.R
index c2b411295..dcdd3ec92 100644
--- a/R/check_if_installed.R
+++ b/R/check_if_installed.R
@@ -15,7 +15,10 @@
 #'   Ignored if `quietly = TRUE`.
 #' @param minimum_version A character vector, representing the minimum package
 #'   version that is required for each package. Should be of same length as
-#'   `package`. If `NULL`, no check for minimum version is done.
+#'   `package`. If `NULL`, will automatically check the DESCRIPTION file for
+#'   the correct minimum version. If using `minimum_version` with more than one
+#'   package, `NA` should be used instead of `NULL` for packages where a
+#'   specific version is not necessary.
 #' @param ... Currently ignored
 #'
 #' @return If `stop = TRUE`, and `package` is not yet installed, the
@@ -25,9 +28,15 @@
 #' @examplesIf interactive() || identical(Sys.getenv("IN_PKGDOWN"), "true")
 #' \dontrun{
 #' check_if_installed("insight")
-#' try(check_if_installed("nonexistent_package"))
+#' try(check_if_installed("datawizard", stop = FALSE))
+#' try(check_if_installed("rstanarm", stop = FALSE))
+#' try(check_if_installed("nonexistent_package", stop = FALSE))
 #' try(check_if_installed("insight", minimum_version = "99.8.7"))
 #' try(check_if_installed(c("nonexistent", "also_not_here"), stop = FALSE))
+#' try(check_if_installed(c("datawizard", "rstanarm"), stop = FALSE))
+#' try(check_if_installed(c("datawizard", "rstanarm"),
+#'   minimum_version = c(NA, "2.21.1"), stop = FALSE
+#' ))
 #' }
 #' @export
 check_if_installed <- function(package,
@@ -40,6 +49,10 @@ check_if_installed <- function(package,
   is_installed <- sapply(package, requireNamespace, quietly = TRUE)
   what_is_wrong <- what_you_can_do <- NULL
 
+  if (is.null(minimum_version)) {
+    minimum_version <- get_dep_version(dep = package)
+  }
+
   ## Test
   if (!all(is_installed)) {
     # only keep not-installed packages
@@ -58,7 +71,19 @@ check_if_installed <- function(package,
       toString(sprintf("`%s`", package))
     )
   } else if (!is.null(minimum_version)) {
-    needs_update <- utils::packageVersion(package) < package_version(minimum_version)
+    current_versions <- unlist(lapply(package, function(x) {
+      as.character(utils::packageVersion(x))
+    }))
+
+    desired_versions <- unlist(lapply(minimum_version, function(x) {
+      if (is.na(x)) {
+        0
+      } else {
+        as.character(package_version(x))
+      }
+    }))
+
+    needs_update <- current_versions < desired_versions
 
     if (any(needs_update)) {
       # only keep not-up-to-date packages
@@ -128,3 +153,19 @@ print.check_if_installed <- function(x, ...) {
     print_color(paste0("- ", names(x)[!x], collapse = "\n"), "red")
   }
 }
+
+get_dep_version <- function(dep, pkg = utils::packageName()) {
+  suggests.field <- utils::packageDescription(pkg, fields = "Suggests")
+  suggests.list <- unlist(strsplit(suggests.field, ",", fixed = TRUE))
+  out <- lapply(dep, function(x) {
+    dep.string <- grep(paste0("\n", x), suggests.list, value = TRUE, fixed = TRUE)
+    dep.string <- unlist(strsplit(dep.string, ">", fixed = TRUE))
+    out <- gsub("[^0-9.]+", "", dep.string[2])
+    out
+  })
+  out <- unlist(out)
+  if (all(is.na(out))) {
+    out <- NULL
+  }
+  out
+}
diff --git a/R/get_predicted_bayesian.R b/R/get_predicted_bayesian.R
index 6f1ccdbe2..4916b2297 100644
--- a/R/get_predicted_bayesian.R
+++ b/R/get_predicted_bayesian.R
@@ -14,7 +14,7 @@ get_predicted.stanreg <- function(x,
                                   include_smooth = TRUE,
                                   verbose = TRUE,
                                   ...) {
-  check_if_installed("rstantools", minimum_version = "2.1.0")
+  check_if_installed("rstantools")
 
   if (is.null(ci_method)) {
     ci_method <- "quantile"
diff --git a/man/check_if_installed.Rd b/man/check_if_installed.Rd
index 7f6f8f83a..9a8fc4ac4 100644
--- a/man/check_if_installed.Rd
+++ b/man/check_if_installed.Rd
@@ -26,7 +26,10 @@ needed package is not installed.}
 
 \item{minimum_version}{A character vector, representing the minimum package
 version that is required for each package. Should be of same length as
-\code{package}. If \code{NULL}, no check for minimum version is done.}
+\code{package}. If \code{NULL}, will automatically check the DESCRIPTION file for
+the correct minimum version. If using \code{minimum_version} with more than one
+package, \code{NA} should be used instead of \code{NULL} for packages where a
+specific version is not necessary.}
 
 \item{quietly}{Logical, if \code{TRUE}, invisibly returns a vector of logicals
 (\code{TRUE} for each installed package, \code{FALSE} otherwise), and does not stop
@@ -51,9 +54,15 @@ Checking if needed package is installed
 \dontshow{if (interactive() || identical(Sys.getenv("IN_PKGDOWN"), "true")) (if (getRversion() >= "3.4") withAutoprint else force)(\{ # examplesIf}
 \dontrun{
 check_if_installed("insight")
-try(check_if_installed("nonexistent_package"))
+try(check_if_installed("datawizard", stop = FALSE))
+try(check_if_installed("rstanarm", stop = FALSE))
+try(check_if_installed("nonexistent_package", stop = FALSE))
 try(check_if_installed("insight", minimum_version = "99.8.7"))
 try(check_if_installed(c("nonexistent", "also_not_here"), stop = FALSE))
+try(check_if_installed(c("datawizard", "rstanarm"), stop = FALSE))
+try(check_if_installed(c("datawizard", "rstanarm"),
+  minimum_version = c(NA, "2.21.1"), stop = FALSE
+))
 }
 \dontshow{\}) # examplesIf}
 }
diff --git a/tests/testthat/test-check_if_installed.R b/tests/testthat/test-check_if_installed.R
index bc4391eb1..b479260f7 100644
--- a/tests/testthat/test-check_if_installed.R
+++ b/tests/testthat/test-check_if_installed.R
@@ -2,4 +2,12 @@ test_that("check_if_installed", {
   skip_if(interactive())
   # mimic package name if cat were to walk on a keyboard
   expect_error(check_if_installed("xklfueofi8eur3rnfalfb"))
+
+  expect_no_error(check_if_installed(c(
+    "datawizard", "rstanarm"
+  ), minimum_version = c("0.8.0", "2.21.1")))
+
+  expect_no_error(check_if_installed(c(
+    "datawizard", "rstanarm"
+  ), minimum_version = c(NA, "2.21.1")))
 })

From a823ed5d3ca8ae4473a60e8316c125ad56373fd5 Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Sun, 6 Aug 2023 20:02:23 +0200
Subject: [PATCH 87/98] Update check_if_installed.R

---
 R/check_if_installed.R | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/R/check_if_installed.R b/R/check_if_installed.R
index dcdd3ec92..11fbfb71b 100644
--- a/R/check_if_installed.R
+++ b/R/check_if_installed.R
@@ -160,8 +160,7 @@ get_dep_version <- function(dep, pkg = utils::packageName()) {
   out <- lapply(dep, function(x) {
     dep.string <- grep(paste0("\n", x), suggests.list, value = TRUE, fixed = TRUE)
     dep.string <- unlist(strsplit(dep.string, ">", fixed = TRUE))
-    out <- gsub("[^0-9.]+", "", dep.string[2])
-    out
+    gsub("[^0-9.]+", "", dep.string[2])
   })
   out <- unlist(out)
   if (all(is.na(out))) {

From e2ac825100e43e5f5cdc81ca819370b68a6d8665 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?R=C3=A9mi=20Th=C3=A9riault?=
 <13123390+rempsyc@users.noreply.github.com>
Date: Sun, 6 Aug 2023 14:42:47 -0400
Subject: [PATCH 88/98] lints, correct tests

---
 R/check_if_installed.R                   | 12 ++++++------
 tests/testthat/test-check_if_installed.R | 16 ++++++++++++++++
 2 files changed, 22 insertions(+), 6 deletions(-)

diff --git a/R/check_if_installed.R b/R/check_if_installed.R
index 11fbfb71b..bf74422ce 100644
--- a/R/check_if_installed.R
+++ b/R/check_if_installed.R
@@ -46,7 +46,7 @@ check_if_installed <- function(package,
                                quietly = FALSE,
                                prompt = interactive(),
                                ...) {
-  is_installed <- sapply(package, requireNamespace, quietly = TRUE)
+  is_installed <- vapply(package, requireNamespace, quietly = TRUE, FUN.VALUE = TRUE)
   what_is_wrong <- what_you_can_do <- NULL
 
   if (is.null(minimum_version)) {
@@ -155,12 +155,12 @@ print.check_if_installed <- function(x, ...) {
 }
 
 get_dep_version <- function(dep, pkg = utils::packageName()) {
-  suggests.field <- utils::packageDescription(pkg, fields = "Suggests")
-  suggests.list <- unlist(strsplit(suggests.field, ",", fixed = TRUE))
+  suggests_field <- utils::packageDescription(pkg, fields = "Suggests")
+  suggests_list <- unlist(strsplit(suggests_field, ",", fixed = TRUE))
   out <- lapply(dep, function(x) {
-    dep.string <- grep(paste0("\n", x), suggests.list, value = TRUE, fixed = TRUE)
-    dep.string <- unlist(strsplit(dep.string, ">", fixed = TRUE))
-    gsub("[^0-9.]+", "", dep.string[2])
+    dep_string <- grep(paste0("\n", x), suggests_list, value = TRUE, fixed = TRUE)
+    dep_string <- unlist(strsplit(dep_string, ">", fixed = TRUE))
+    gsub("[^0-9.]+", "", dep_string[2])
   })
   out <- unlist(out)
   if (all(is.na(out))) {
diff --git a/tests/testthat/test-check_if_installed.R b/tests/testthat/test-check_if_installed.R
index b479260f7..b80e23be7 100644
--- a/tests/testthat/test-check_if_installed.R
+++ b/tests/testthat/test-check_if_installed.R
@@ -1,8 +1,20 @@
 test_that("check_if_installed", {
   skip_if(interactive())
+  skip_if_not_installed("datawizard")
+  skip_if_not_installed("rstanarm")
+
   # mimic package name if cat were to walk on a keyboard
   expect_error(check_if_installed("xklfueofi8eur3rnfalfb"))
 
+  expect_error(check_if_installed(c(
+    "datawizard",
+    minimum_version = "9.9.9"
+  )))
+
+  expect_no_error(check_if_installed(c(
+    "datawizard", "rstanarm"
+  )))
+
   expect_no_error(check_if_installed(c(
     "datawizard", "rstanarm"
   ), minimum_version = c("0.8.0", "2.21.1")))
@@ -10,4 +22,8 @@ test_that("check_if_installed", {
   expect_no_error(check_if_installed(c(
     "datawizard", "rstanarm"
   ), minimum_version = c(NA, "2.21.1")))
+
+  expect_no_error(check_if_installed(c(
+    "datawizard", "rstanarm"
+  ), minimum_version = c("0.8.0", NA)))
 })

From efcec15cee603da1e527ec0f97e0b9a3d995a039 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?R=C3=A9mi=20Th=C3=A9riault?=
 <13123390+rempsyc@users.noreply.github.com>
Date: Sun, 6 Aug 2023 15:47:19 -0400
Subject: [PATCH 89/98] .get_dep_version

---
 R/check_if_installed.R | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/R/check_if_installed.R b/R/check_if_installed.R
index bf74422ce..3964f7fc5 100644
--- a/R/check_if_installed.R
+++ b/R/check_if_installed.R
@@ -50,7 +50,7 @@ check_if_installed <- function(package,
   what_is_wrong <- what_you_can_do <- NULL
 
   if (is.null(minimum_version)) {
-    minimum_version <- get_dep_version(dep = package)
+    minimum_version <- .get_dep_version(dep = package)
   }
 
   ## Test
@@ -154,7 +154,7 @@ print.check_if_installed <- function(x, ...) {
   }
 }
 
-get_dep_version <- function(dep, pkg = utils::packageName()) {
+.get_dep_version <- function(dep, pkg = utils::packageName()) {
   suggests_field <- utils::packageDescription(pkg, fields = "Suggests")
   suggests_list <- unlist(strsplit(suggests_field, ",", fixed = TRUE))
   out <- lapply(dep, function(x) {

From 2872ad4d5703e9ab1a6d55bd651bf2335b128cdf Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Mon, 7 Aug 2023 11:45:37 +0200
Subject: [PATCH 90/98] version bump

---
 DESCRIPTION | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/DESCRIPTION b/DESCRIPTION
index bfd5c4798..e06d47d1b 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -1,7 +1,7 @@
 Type: Package
 Package: insight
 Title: Easy Access to Model Information for Various Model Objects
-Version: 0.19.3.1
+Version: 0.19.3.2
 Authors@R: 
     c(person(given = "Daniel",
              family = "Lüdecke",

From 67d624e4f5c031a2a7e8e4f2cd7261d1df1416c5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?R=C3=A9mi=20Th=C3=A9riault?=
 <13123390+rempsyc@users.noreply.github.com>
Date: Mon, 14 Aug 2023 04:34:33 -0400
Subject: [PATCH 91/98] Fix edge cases in `.get_dep_version()` (#796)

fix edge cases where there are more than one grep matches (e.g. packages boot and bootES) and when there is a required version for the first package of the Suggests list
---
 R/check_if_installed.R | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/R/check_if_installed.R b/R/check_if_installed.R
index 3964f7fc5..db8d3875c 100644
--- a/R/check_if_installed.R
+++ b/R/check_if_installed.R
@@ -158,13 +158,13 @@ print.check_if_installed <- function(x, ...) {
   suggests_field <- utils::packageDescription(pkg, fields = "Suggests")
   suggests_list <- unlist(strsplit(suggests_field, ",", fixed = TRUE))
   out <- lapply(dep, function(x) {
-    dep_string <- grep(paste0("\n", x), suggests_list, value = TRUE, fixed = TRUE)
+    dep_string <- grep(x, suggests_list, value = TRUE, fixed = TRUE)
+    dep_string <- dep_string[which.min(nchar(dep_string))]
     dep_string <- unlist(strsplit(dep_string, ">", fixed = TRUE))
     gsub("[^0-9.]+", "", dep_string[2])
   })
-  out <- unlist(out)
   if (all(is.na(out))) {
     out <- NULL
   }
-  out
+  unlist(out)
 }

From 03d2e28befb9107f9ad6ec689beb5c815d5a6301 Mon Sep 17 00:00:00 2001
From: Etienne Bacher <52219252+etiennebacher@users.noreply.github.com>
Date: Mon, 21 Aug 2023 08:46:18 +0200
Subject: [PATCH 92/98] Add "Getting help" page  (#798)

* Add "Getting help" page

* replace pkg name
---
 .github/SUPPORT.md | 29 +++++++++++++++++++++++++++++
 1 file changed, 29 insertions(+)
 create mode 100644 .github/SUPPORT.md

diff --git a/.github/SUPPORT.md b/.github/SUPPORT.md
new file mode 100644
index 000000000..588f79b00
--- /dev/null
+++ b/.github/SUPPORT.md
@@ -0,0 +1,29 @@
+# Getting help with `{insight}`
+
+Thanks for using `{insight}`. Before filing an issue, there are a few places
+to explore and pieces to put together to make the process as smooth as possible.
+
+Start by making a minimal **repr**oducible **ex**ample using the
+[reprex](http://reprex.tidyverse.org/) package. If you haven't heard of or used
+reprex before, you're in for a treat! Seriously, reprex will make all of your
+R-question-asking endeavors easier (which is a pretty insane ROI for the five to
+ten minutes it'll take you to learn what it's all about). For additional reprex
+pointers, check out the [Get help!](https://www.tidyverse.org/help/) resource
+used by the tidyverse team.
+
+Armed with your reprex, the next step is to figure out where to ask:
+
+  * If it's a question: start with StackOverflow. There are more people there to answer questions.
+  * If it's a bug: you're in the right place, file an issue.
+  * If you're not sure: let's [discuss](https://github.com/easystats/insight/discussions) it and try to figure it out! If your
+    problem _is_ a bug or a feature request, you can easily return here and
+    report it.
+
+Before opening a new issue, be sure to [search issues and pull requests](https://github.com/easystats/insight/issues) to make sure the
+bug hasn't been reported and/or already fixed in the development version. By
+default, the search will be pre-populated with `is:issue is:open`. You can
+[edit the qualifiers](https://help.github.com/articles/searching-issues-and-pull-requests/)
+(e.g. `is:pr`, `is:closed`) as needed. For example, you'd simply
+remove `is:open` to search _all_ issues in the repo, open or closed.
+
+Thanks for your help!
\ No newline at end of file

From 082baec8a2e59b87fe45361e3c6f08abdc5f176d Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Tue, 29 Aug 2023 11:21:00 +0200
Subject: [PATCH 93/98] fix invalid multibyte in trim_ws

---
 DESCRIPTION   | 2 +-
 NEWS.md       | 6 +++++-
 R/utilities.R | 2 +-
 3 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/DESCRIPTION b/DESCRIPTION
index e06d47d1b..9089a6011 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -1,7 +1,7 @@
 Type: Package
 Package: insight
 Title: Easy Access to Model Information for Various Model Objects
-Version: 0.19.3.2
+Version: 0.19.3.3
 Authors@R: 
     c(person(given = "Daniel",
              family = "Lüdecke",
diff --git a/NEWS.md b/NEWS.md
index 8895cfec0..dccea125e 100644
--- a/NEWS.md
+++ b/NEWS.md
@@ -1,4 +1,4 @@
-# insight 0.19.3.1
+# insight 0.19.4
 
 ## Changes to functions
 
@@ -9,6 +9,10 @@
 * `check_if_installed()` now automatically checks the package DESCRIPTION file to 
   determine the correct minimum version required.
 
+## Bug fixes
+
+* Fixed issue with invalid multibyte strings in `trim_ws()`.
+
 # insight 0.19.3
 
 ## Breaking changes
diff --git a/R/utilities.R b/R/utilities.R
index 99708175e..620784a5d 100644
--- a/R/utilities.R
+++ b/R/utilities.R
@@ -46,7 +46,7 @@ trim_ws <- function(x, ...) {
 
 #' @export
 trim_ws.default <- function(x, ...) {
-  gsub("^\\s+|\\s+$", "", x, perl = TRUE)
+  gsub("^\\s+|\\s+$", "", x, perl = TRUE, useBytes = TRUE)
 }
 
 #' @rdname trim_ws

From 49c12770c567d69df8d3c8faa6703a576d6e50dc Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Tue, 29 Aug 2023 11:42:33 +0200
Subject: [PATCH 94/98] fix invalid multibyte string

---
 R/export_table.R | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/R/export_table.R b/R/export_table.R
index 8e6b8b212..6190b9d2c 100644
--- a/R/export_table.R
+++ b/R/export_table.R
@@ -667,7 +667,7 @@ print.insight_table <- function(x, ...) {
     final_row <- paste0(final[row, ], collapse = sep)
     # check if we have an empty row, and if so, fill with an
     # "empty line separator", if requested by user
-    if (!is.null(empty_line) && all(nchar(trim_ws(final[row, ]), type = "width") == 0)) {
+    if (!is.null(empty_line) && !any(nzchar(trim_ws(final[row, ])))) {
       # check whether user wants to have a "cross" char where vertical and
       # horizontal lines (from empty line separator) cross. But don't add
       # a "cross" when the empty line is the last row in the table...

From 90f946ccd127cf2c45e99569f33686fcc5ee55a9 Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Tue, 29 Aug 2023 11:55:01 +0200
Subject: [PATCH 95/98] tests

---
 tests/testthat/test-export_table.R | 14 +++++++++-----
 tests/testthat/test-utilities.R    |  7 +++++++
 2 files changed, 16 insertions(+), 5 deletions(-)

diff --git a/tests/testthat/test-export_table.R b/tests/testthat/test-export_table.R
index bbd67420d..54cb72f1e 100644
--- a/tests/testthat/test-export_table.R
+++ b/tests/testthat/test-export_table.R
@@ -21,7 +21,7 @@ test_that("export_table", {
     ),
     format = "pipe",
     class = c("knitr_kable", "character")
-  ))
+  ), ignore_attr = TRUE)
 })
 
 d <- data.frame(a = c(1.3, 2, 543), b = c("ab", "cd", "abcde"), stringsAsFactors = FALSE)
@@ -38,7 +38,8 @@ test_that("export_table", {
       ),
       format = "pipe",
       class = c("knitr_kable", "character")
-    )
+    ),
+    ignore_attr = TRUE
   )
 })
 
@@ -56,7 +57,8 @@ test_that("export_table", {
       ),
       format = "pipe",
       class = c("knitr_kable", "character")
-    )
+    ),
+    ignore_attr = TRUE
   )
 })
 
@@ -73,7 +75,8 @@ test_that("export_table", {
       ),
       format = "pipe",
       class = c("knitr_kable", "character")
-    )
+    ),
+    ignore_attr = TRUE
   )
 })
 
@@ -93,6 +96,7 @@ test_that("export_table", {
       ),
       format = "pipe",
       class = c("knitr_kable", "character")
-    )
+    ),
+    ignore_attr = TRUE
   )
 })
diff --git a/tests/testthat/test-utilities.R b/tests/testthat/test-utilities.R
index 4a6e9dd15..ff6132827 100644
--- a/tests/testthat/test-utilities.R
+++ b/tests/testthat/test-utilities.R
@@ -74,3 +74,10 @@ test_that("safe_deparse_symbol() works", {
   expect_identical(safe_deparse(as.name("test")), "test")
   expect_identical(safe_deparse("test"), "\"test\"")
 })
+
+test_that("trim_ws() works with non-ascii chars", {
+  expect_identical(
+    trim_ws(c("test ", " Se\x96ora ", "works \x97fine ", "this too", "yeah")),
+    c("test", "Se\x96ora", "works \x97fine", "this too", "yeah")
+  )
+})

From 4ac80a73a5daf4c960f9fe12a351c6a62cd6a432 Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Tue, 29 Aug 2023 18:03:46 +0200
Subject: [PATCH 96/98] tests

---
 tests/testthat/test-get_modelmatrix.R | 20 +++++++-------
 tests/testthat/test-ivreg_AER.R       | 38 ++++++++++++++++++---------
 2 files changed, 35 insertions(+), 23 deletions(-)

diff --git a/tests/testthat/test-get_modelmatrix.R b/tests/testthat/test-get_modelmatrix.R
index b3c514c4b..fc7b7ef8e 100644
--- a/tests/testthat/test-get_modelmatrix.R
+++ b/tests/testthat/test-get_modelmatrix.R
@@ -5,11 +5,11 @@ test_that("Issue #612: factor padding", {
   # no factor
   mod <- glm(vs ~ cyl, data = mtcars, family = binomial)
   mm <- get_modelmatrix(mod)
-  expect_equal(nrow(mm), 32)
+  expect_identical(nrow(mm), 32L)
   mm <- get_modelmatrix(mod, data = mtcars)
-  expect_equal(nrow(mm), 32)
+  expect_identical(nrow(mm), 32L)
   mm <- get_modelmatrix(mod, data = head(mtcars))
-  expect_equal(nrow(mm), 6)
+  expect_identical(nrow(mm), 6L)
 
   # one factor
   dat <- mtcars
@@ -18,15 +18,15 @@ test_that("Issue #612: factor padding", {
 
   # no data argument
   mm <- get_modelmatrix(mod)
-  expect_equal(nrow(mm), 32)
+  expect_identical(nrow(mm), 32L)
 
   # enough factor levels
   mm <- get_modelmatrix(mod, data = head(dat))
-  expect_equal(nrow(mm), 6)
+  expect_identical(nrow(mm), 6L)
 
   # not enough factor levels
   mm <- get_modelmatrix(mod, data = dat[3, ])
-  expect_equal(nrow(mm), 1)
+  expect_identical(nrow(mm), 1L)
 })
 
 
@@ -48,7 +48,7 @@ test_that("get_modelmatrix - iv_robust", {
   out1 <- get_modelmatrix(x, data = get_datagrid(x, at = "P"))
   out2 <- model.matrix(terms(x), data = get_datagrid(x, at = "P", include_response = TRUE))
   expect_equal(out1, out2, tolerance = 1e-3, ignore_attr = TRUE)
-  expect_equal(nrow(get_datagrid(x, at = "P")), nrow(out2))
+  expect_identical(nrow(get_datagrid(x, at = "P")), nrow(out2))
 })
 
 
@@ -71,7 +71,7 @@ test_that("get_modelmatrix - ivreg", {
   out1 <- get_modelmatrix(x, data = get_datagrid(x, at = "P"))
   out2 <- model.matrix(terms(x), data = get_datagrid(x, at = "P", include_response = TRUE))
   expect_equal(out1, out2, tolerance = 1e-3, ignore_attr = TRUE)
-  expect_equal(nrow(get_datagrid(x, at = "P")), nrow(out2))
+  expect_identical(nrow(get_datagrid(x, at = "P")), nrow(out2))
 })
 
 
@@ -100,7 +100,7 @@ test_that("get_modelmatrix - lm_robust", {
   out1 <- get_modelmatrix(x, data = get_datagrid(x, at = "x"))
   out2 <- model.matrix(x, data = get_datagrid(x, at = "x", include_response = TRUE))
   expect_equal(out1, out2, tolerance = 1e-3, ignore_attr = TRUE)
-  expect_equal(nrow(get_datagrid(x, at = "x")), nrow(out2))
+  expect_identical(nrow(get_datagrid(x, at = "x")), nrow(out2))
 })
 
 
@@ -111,7 +111,7 @@ test_that("Issue #693", {
   x <- sample(1:3, n, replace = TRUE)
   w <- sample(1:4, n, replace = TRUE)
   y <- rnorm(n)
-  z <- ifelse(x + y + rlogis(n) > 1.5, 1, 0)
+  z <- as.numeric(x + y + rlogis(n) > 1.5)
   dat <<- data.frame(x = factor(x), w = factor(w), y = y, z = z)
   m <- glm(z ~ x + w + y, family = binomial, data = dat)
   nd <- head(dat, 2)
diff --git a/tests/testthat/test-ivreg_AER.R b/tests/testthat/test-ivreg_AER.R
index 53b5fbcee..75eaf6918 100644
--- a/tests/testthat/test-ivreg_AER.R
+++ b/tests/testthat/test-ivreg_AER.R
@@ -45,11 +45,15 @@ test_that("find_response", {
 })
 
 test_that("get_response", {
-  expect_equal(get_response(mod_aer_ivreg), cig_data$packs[cig_data$year == "1995"])
+  expect_equal(
+    get_response(mod_aer_ivreg),
+    cig_data$packs[cig_data$year == "1995"],
+    tolerance = 1e-5
+  )
 })
 
 test_that("get_predictors", {
-  expect_equal(
+  expect_identical(
     colnames(get_predictors(mod_aer_ivreg)),
     c("rprice", "rincome", "tdiff", "tax", "cpi")
   )
@@ -60,8 +64,8 @@ test_that("link_inverse", {
 })
 
 test_that("get_data", {
-  expect_equal(nrow(get_data(mod_aer_ivreg)), 48)
-  expect_equal(
+  expect_identical(nrow(get_data(mod_aer_ivreg)), 48L)
+  expect_identical(
     colnames(get_data(mod_aer_ivreg)),
     c("packs", "rprice", "rincome", "tdiff", "tax", "cpi", "year")
   )
@@ -86,16 +90,17 @@ test_that("find_variables", {
       response = "packs",
       conditional = c("rprice", "rincome"),
       instruments = c("rincome", "tdiff", "tax", "cpi")
-    )
+    ),
+    ignore_attr = TRUE
   )
-  expect_equal(
+  expect_identical(
     find_variables(mod_aer_ivreg, flatten = TRUE),
     c("packs", "rprice", "rincome", "tdiff", "tax", "cpi")
   )
 })
 
 test_that("n_obs", {
-  expect_equal(n_obs(mod_aer_ivreg), 48)
+  expect_identical(n_obs(mod_aer_ivreg), 48L)
 })
 
 test_that("linkfun", {
@@ -107,10 +112,11 @@ test_that("find_parameters", {
     find_parameters(mod_aer_ivreg),
     list(
       conditional = c("(Intercept)", "log(rprice)", "log(rincome)")
-    )
+    ),
+    ignore_attr = TRUE
   )
-  expect_equal(nrow(get_parameters(mod_aer_ivreg)), 3)
-  expect_equal(
+  expect_identical(nrow(get_parameters(mod_aer_ivreg)), 3L)
+  expect_identical(
     get_parameters(mod_aer_ivreg)$Parameter,
     c("(Intercept)", "log(rprice)", "log(rincome)")
   )
@@ -127,10 +133,11 @@ test_that("find_terms", {
       response = "log(packs)",
       conditional = c("log(rprice)", "log(rincome)"),
       instruments = c("log(rincome)", "tdiff", "I(tax/cpi)")
-    )
+    ),
+    ignore_attr = TRUE
   )
-  expect_equal(nrow(get_parameters(mod_aer_ivreg)), 3)
-  expect_equal(
+  expect_identicak(nrow(get_parameters(mod_aer_ivreg)), 3)
+  expect_identical(
     get_parameters(mod_aer_ivreg)$Parameter,
     c("(Intercept)", "log(rprice)", "log(rincome)")
   )
@@ -139,3 +146,8 @@ test_that("find_terms", {
 test_that("find_statistic", {
   expect_identical(find_statistic(mod_aer_ivreg), "t-statistic")
 })
+
+# to avoid `Registered S3 methods overwritten by 'ivreg'` messages
+if (isNamespaceLoaded("AER")) {
+  unloadNamespace("AER")
+}

From 222442592f567ec76ddfd1c9e5ac78e88047803a Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Tue, 29 Aug 2023 18:55:18 +0200
Subject: [PATCH 97/98] typo

---
 tests/testthat/test-ivreg_AER.R | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/testthat/test-ivreg_AER.R b/tests/testthat/test-ivreg_AER.R
index 75eaf6918..6f0a276c2 100644
--- a/tests/testthat/test-ivreg_AER.R
+++ b/tests/testthat/test-ivreg_AER.R
@@ -136,7 +136,7 @@ test_that("find_terms", {
     ),
     ignore_attr = TRUE
   )
-  expect_identicak(nrow(get_parameters(mod_aer_ivreg)), 3)
+  expect_identical(nrow(get_parameters(mod_aer_ivreg)), 3L)
   expect_identical(
     get_parameters(mod_aer_ivreg)$Parameter,
     c("(Intercept)", "log(rprice)", "log(rincome)")

From 842c6e222704b2a25c059d18a7cb2b33078782b0 Mon Sep 17 00:00:00 2001
From: Daniel <mail@danielluedecke.de>
Date: Wed, 30 Aug 2023 19:29:01 +0200
Subject: [PATCH 98/98] Add back panelr tests (#800)

* Add back panelr tests

* panelr to suggested
---
 DESCRIPTION                           |  1 +
 {WIP => tests/testthat}/test-panelr.R | 40 +++++++++++++--------------
 2 files changed, 21 insertions(+), 20 deletions(-)
 rename {WIP => tests/testthat}/test-panelr.R (90%)

diff --git a/DESCRIPTION b/DESCRIPTION
index 9089a6011..5e09f1997 100644
--- a/DESCRIPTION
+++ b/DESCRIPTION
@@ -164,6 +164,7 @@ Suggests:
     nnet,
     nonnest2,
     ordinal,
+    panelr,
     parameters,
     parsnip,
     pbkrtest,
diff --git a/WIP/test-panelr.R b/tests/testthat/test-panelr.R
similarity index 90%
rename from WIP/test-panelr.R
rename to tests/testthat/test-panelr.R
index dbe30e8a9..637b54e69 100644
--- a/WIP/test-panelr.R
+++ b/tests/testthat/test-panelr.R
@@ -42,7 +42,7 @@ test_that("find_random", {
 
 test_that("get_random", {
   expect_warning(expect_null(get_random(m1)))
-  expect_equal(get_random(m2)[[1]], model.frame(m2)$id)
+  expect_identical(get_random(m2)[[1]], model.frame(m2)$id)
 })
 
 test_that("find_response", {
@@ -50,15 +50,15 @@ test_that("find_response", {
 })
 
 test_that("get_response", {
-  expect_equal(get_response(m1), model.frame(m1)$lwage)
+  expect_identical(get_response(m1), model.frame(m1)$lwage)
 })
 
 test_that("get_predictors", {
-  expect_equal(
+  expect_identical(
     colnames(get_predictors(m1)),
     c("lag(union)", "wks", "blk", "fem")
   )
-  expect_equal(
+  expect_identical(
     colnames(get_predictors(m2)),
     c("lag(union)", "wks", "blk", "t")
   )
@@ -70,14 +70,14 @@ test_that("link_inverse", {
 
 test_that("clean_parameters", {
   cp <- clean_parameters(m1)
-  expect_equal(
+  expect_identical(
     cp$Cleaned_Parameter,
     c(
       "union", "wks", "(Intercept)", "imean(lag(union))", "imean(wks)",
       "blk", "fem", "union:blk"
     )
   )
-  expect_equal(
+  expect_identical(
     cp$Component,
     c(
       "conditional", "conditional", "instruments", "instruments",
@@ -87,8 +87,8 @@ test_that("clean_parameters", {
 })
 
 test_that("get_data", {
-  expect_equal(nrow(get_data(m1)), 3570)
-  expect_equal(
+  expect_identical(nrow(get_data(m1)), 3570L)
+  expect_identical(
     colnames(get_data(m1)),
     c(
       "lwage",
@@ -104,7 +104,7 @@ test_that("get_data", {
       "lag(union):blk"
     )
   )
-  expect_equal(
+  expect_identical(
     colnames(get_data(m2)),
     c(
       "lwage",
@@ -143,7 +143,7 @@ test_that("find_formula", {
 })
 
 test_that("find_variables", {
-  expect_equal(
+  expect_identical(
     find_variables(m1),
     list(
       response = "lwage",
@@ -152,12 +152,12 @@ test_that("find_variables", {
       interactions = c("blk", "union")
     )
   )
-  expect_equal(
+  expect_identical(
     find_variables(m1, flatten = TRUE),
     c("lwage", "union", "wks", "blk", "fem")
   )
 
-  expect_equal(
+  expect_identical(
     find_variables(m2),
     list(
       response = "lwage",
@@ -166,15 +166,15 @@ test_that("find_variables", {
       random = "id"
     )
   )
-  expect_equal(
+  expect_identical(
     find_variables(m2, flatten = TRUE),
     c("lwage", "union", "wks", "blk", "t", "id")
   )
 })
 
 test_that("n_obs", {
-  expect_equal(n_obs(m1), 3570)
-  expect_equal(n_obs(m2), 3570)
+  expect_identical(n_obs(m1), 3570L)
+  expect_identical(n_obs(m2), 3570L)
 })
 
 test_that("linkfun", {
@@ -182,7 +182,7 @@ test_that("linkfun", {
 })
 
 test_that("find_parameters", {
-  expect_equal(
+  expect_identical(
     find_parameters(m1),
     list(
       conditional = c("lag(union)", "wks"),
@@ -191,9 +191,9 @@ test_that("find_parameters", {
     )
   )
 
-  expect_equal(nrow(get_parameters(m1)), 8)
+  expect_identical(nrow(get_parameters(m1)), 8L)
 
-  expect_equal(
+  expect_identical(
     find_parameters(m2),
     list(
       conditional = c("lag(union)", "wks"),
@@ -234,7 +234,7 @@ test_that("get_parameters", {
 
 
 test_that("find_terms", {
-  expect_equal(
+  expect_identical(
     find_terms(m1),
     list(
       response = "lwage",
@@ -243,7 +243,7 @@ test_that("find_terms", {
       interactions = c("blk", "lag(union)")
     )
   )
-  expect_equal(
+  expect_identical(
     find_terms(m2),
     list(
       response = "lwage",