diff --git a/tests/testthat/test-output_apply_gam.R b/tests/testthat/test-output_apply_gam.R
index 6717b188..4f16ab13 100644
--- a/tests/testthat/test-output_apply_gam.R
+++ b/tests/testthat/test-output_apply_gam.R
@@ -148,64 +148,64 @@ basic_gam_taxon_key_and_name <- apply_gam(
 
 testthat::test_that("Test length of output list", {
   # length of list output is not dependent on GAM output
-  expect_equal(length(basic_gam), expected = 6)
-  expect_equal(length(corrected_gam), expected = 6)
-  expect_equal(length(basic_gam_bad), expected = 6)
-  expect_equal(length(corrected_gam_bad), expected = 6)
+  testthat::expect_equal(length(basic_gam), expected = 6)
+  testthat::expect_equal(length(corrected_gam), expected = 6)
+  testthat::expect_equal(length(basic_gam_bad), expected = 6)
+  testthat::expect_equal(length(corrected_gam_bad), expected = 6)
 })
 
 testthat::test_that("Test em_summary", {
   # em_summary is a data.frame
-  expect_true(is.data.frame(basic_gam$em_summary))
-  expect_true(is.data.frame(basic_gam_ys$em_summary))
-  expect_true(is.data.frame(basic_gam_bad$em_summary))
-  expect_true(is.data.frame(basic_gam_bad_ys$em_summary))
-  expect_true(is.data.frame(corrected_gam$em_summary))
-  expect_true(is.data.frame(corrected_gam_ys$em_summary))
-  expect_true(is.data.frame(corrected_gam_bad$em_summary))
-  expect_true(is.data.frame(corrected_gam_bad_ys$em_summary))
+  testthat::expect_true(is.data.frame(basic_gam$em_summary))
+  testthat::expect_true(is.data.frame(basic_gam_ys$em_summary))
+  testthat::expect_true(is.data.frame(basic_gam_bad$em_summary))
+  testthat::expect_true(is.data.frame(basic_gam_bad_ys$em_summary))
+  testthat::expect_true(is.data.frame(corrected_gam$em_summary))
+  testthat::expect_true(is.data.frame(corrected_gam_ys$em_summary))
+  testthat::expect_true(is.data.frame(corrected_gam_bad$em_summary))
+  testthat::expect_true(is.data.frame(corrected_gam_bad_ys$em_summary))
   # evaluation on one year
-  expect_equal(nrow(basic_gam$em_summary),
+  testthat::expect_equal(nrow(basic_gam$em_summary),
     expected = length(evaluation_year)
   )
-  expect_equal(nrow(corrected_gam$em_summary),
+  testthat::expect_equal(nrow(corrected_gam$em_summary),
     expected = length(evaluation_year)
   )
-  expect_equal(nrow(basic_gam_bad$em_summary),
+  testthat::expect_equal(nrow(basic_gam_bad$em_summary),
     expected = length(evaluation_year)
   )
-  expect_equal(nrow(corrected_gam_bad$em_summary),
+  testthat::expect_equal(nrow(corrected_gam_bad$em_summary),
     expected = length(evaluation_year)
   )
   # evaluation on two years
-  expect_equal(nrow(basic_gam_ys$em_summary),
+  testthat::expect_equal(nrow(basic_gam_ys$em_summary),
     expected = length(evaluation_years)
   )
-  expect_equal(nrow(corrected_gam_ys$em_summary),
+  testthat::expect_equal(nrow(corrected_gam_ys$em_summary),
     expected = length(evaluation_years)
   )
-  expect_equal(nrow(basic_gam_bad_ys$em_summary),
+  testthat::expect_equal(nrow(basic_gam_bad_ys$em_summary),
     expected = length(evaluation_years)
   )
-  expect_equal(nrow(corrected_gam_bad_ys$em_summary),
+  testthat::expect_equal(nrow(corrected_gam_bad_ys$em_summary),
     expected = length(evaluation_years)
   )
   # if GAM cannot be performed, em_summary and growth are NA
-  expect_true(all(
+  testthat::expect_true(all(
     is.na(corrected_gam_bad$em_summary$em_status),
     is.na(corrected_gam_bad$em_summary$growth),
     is.na(corrected_gam_bad_ys$em_summary$em_status),
     is.na(corrected_gam_bad_ys$em_summary$growth)
   ))
   # if GAM is performed em_summary and growth are numeric
-  expect_true(all(
+  testthat::expect_true(all(
     is.numeric(corrected_gam$em_summary$em_status),
     is.numeric(corrected_gam$em_summary$growth),
     is.numeric(corrected_gam_ys$em_summary$em_status),
     is.numeric(corrected_gam_ys$em_summary$growth)
   ))
   # if GAM is performed em_summary is one of 0,1,2,3
-  expect_true(all(
+  testthat::expect_true(all(
     corrected_gam$em_summary$em_status %in% c(0, 1, 2, 3),
     corrected_gam_ys$em_summary$em_status %in% c(0, 1, 2, 3)
   ))
@@ -214,10 +214,10 @@ testthat::test_that("Test em_summary", {
 testthat::test_that("Test model", {
 
   # model output is an instance of class "gam"
-  expect_true(all(class(basic_gam$model) == c("gam", "glm", "lm")))
-  expect_true(all(class(basic_gam_ys$model) == c("gam", "glm", "lm")))
-  expect_true(all(class(corrected_gam$model) == c("gam", "glm", "lm")))
-  expect_true(all(class(corrected_gam_ys$model) == c("gam", "glm", "lm")))
+  testthat::expect_true(all(class(basic_gam$model) == c("gam", "glm", "lm")))
+  testthat::expect_true(all(class(basic_gam_ys$model) == c("gam", "glm", "lm")))
+  testthat::expect_true(all(class(corrected_gam$model) == c("gam", "glm", "lm")))
+  testthat::expect_true(all(class(corrected_gam_ys$model) == c("gam", "glm", "lm")))
 
   # model output is NULL if gam is not performed
   expect_null(basic_gam_bad$model)
@@ -226,11 +226,11 @@ testthat::test_that("Test model", {
   expect_null(corrected_gam_bad_ys$model)
 
   # model formula is correct
-  expect_true(all(
+  testthat::expect_true(all(
     basic_gam$model$formula == basic_fm,
     basic_gam_ys$model$formula == basic_fm
   ))
-  expect_true(all(
+  testthat::expect_true(all(
     corrected_gam$model$formula == corrected_fm,
     corrected_gam_ys$model$formula == corrected_fm
   ))
@@ -239,99 +239,99 @@ testthat::test_that("Test model", {
 testthat::test_that("Test output", {
 
   # output is a data.frame
-  expect_true(is.data.frame(basic_gam$output))
-  expect_true(is.data.frame(basic_gam_ys$output))
-  expect_true(is.data.frame(basic_gam_bad$output))
-  expect_true(is.data.frame(basic_gam_bad_ys$output))
-  expect_true(is.data.frame(corrected_gam$output))
-  expect_true(is.data.frame(corrected_gam_ys$output))
-  expect_true(is.data.frame(corrected_gam_bad$output))
-  expect_true(is.data.frame(corrected_gam_bad_ys$output))
+  testthat::expect_true(is.data.frame(basic_gam$output))
+  testthat::expect_true(is.data.frame(basic_gam_ys$output))
+  testthat::expect_true(is.data.frame(basic_gam_bad$output))
+  testthat::expect_true(is.data.frame(basic_gam_bad_ys$output))
+  testthat::expect_true(is.data.frame(corrected_gam$output))
+  testthat::expect_true(is.data.frame(corrected_gam_ys$output))
+  testthat::expect_true(is.data.frame(corrected_gam_bad$output))
+  testthat::expect_true(is.data.frame(corrected_gam_bad_ys$output))
   # output has all columns of input df
-  expect_true(all(names(df_gam) %in% names(basic_gam$output)))
-  expect_true(all(names(df_gam) %in% names(basic_gam_ys$output)))
-  expect_true(all(names(df_bad) %in% names(basic_gam_bad$output)))
-  expect_true(all(names(df_bad) %in% names(basic_gam_bad_ys$output)))
-  expect_true(all(names(df_gam) %in% names(corrected_gam$output)))
-  expect_true(all(names(df_gam) %in% names(corrected_gam_ys$output)))
-  expect_true(all(names(df_bad) %in% names(corrected_gam_bad$output)))
-  expect_true(all(names(df_bad) %in% names(corrected_gam_bad_ys$output)))
+  testthat::expect_true(all(names(df_gam) %in% names(basic_gam$output)))
+  testthat::expect_true(all(names(df_gam) %in% names(basic_gam_ys$output)))
+  testthat::expect_true(all(names(df_bad) %in% names(basic_gam_bad$output)))
+  testthat::expect_true(all(names(df_bad) %in% names(basic_gam_bad_ys$output)))
+  testthat::expect_true(all(names(df_gam) %in% names(corrected_gam$output)))
+  testthat::expect_true(all(names(df_gam) %in% names(corrected_gam_ys$output)))
+  testthat::expect_true(all(names(df_bad) %in% names(corrected_gam_bad$output)))
+  testthat::expect_true(all(names(df_bad) %in% names(corrected_gam_bad_ys$output)))
 
   # values of these columns are also identical
-  expect_true(all(df_gam$taxonKey == basic_gam$output$taxonKey))
-  expect_true(all(df_gam$taxonKey == basic_gam_ys$output$taxonKey))
-  expect_true(all(df_bad$taxonKey == basic_gam_bad$output$taxonKey))
-  expect_true(all(df_bad$taxonKey == basic_gam_bad_ys$output$taxonKey))
-  expect_true(all(df_gam$taxonKey == corrected_gam$output$taxonKey))
-  expect_true(all(df_gam$taxonKey == corrected_gam_ys$output$taxonKey))
-  expect_true(all(df_bad$taxonKey == corrected_gam_bad$output$taxonKey))
-  expect_true(all(df_bad$taxonKey == corrected_gam_bad_ys$output$taxonKey))
-  expect_true(all(df_gam$canonicalName == basic_gam$output$canonicalName))
-  expect_true(all(df_gam$canonicalName == basic_gam_ys$output$canonicalName))
-  expect_true(all(df_bad$canonicalName == basic_gam_bad$output$canonicalName))
-  expect_true(all(df_bad$canonicalName ==
+  testthat::expect_true(all(df_gam$taxonKey == basic_gam$output$taxonKey))
+  testthat::expect_true(all(df_gam$taxonKey == basic_gam_ys$output$taxonKey))
+  testthat::expect_true(all(df_bad$taxonKey == basic_gam_bad$output$taxonKey))
+  testthat::expect_true(all(df_bad$taxonKey == basic_gam_bad_ys$output$taxonKey))
+  testthat::expect_true(all(df_gam$taxonKey == corrected_gam$output$taxonKey))
+  testthat::expect_true(all(df_gam$taxonKey == corrected_gam_ys$output$taxonKey))
+  testthat::expect_true(all(df_bad$taxonKey == corrected_gam_bad$output$taxonKey))
+  testthat::expect_true(all(df_bad$taxonKey == corrected_gam_bad_ys$output$taxonKey))
+  testthat::expect_true(all(df_gam$canonicalName == basic_gam$output$canonicalName))
+  testthat::expect_true(all(df_gam$canonicalName == basic_gam_ys$output$canonicalName))
+  testthat::expect_true(all(df_bad$canonicalName == basic_gam_bad$output$canonicalName))
+  testthat::expect_true(all(df_bad$canonicalName ==
     basic_gam_bad_ys$output$canonicalName))
-  expect_true(all(df_gam$canonicalName == corrected_gam$output$canonicalName))
-  expect_true(all(df_gam$canonicalName == corrected_gam_ys$output$canonicalName))
-  expect_true(all(df_bad$canonicalName == corrected_gam_bad$output$canonicalName))
-  expect_true(all(df_bad$canonicalName ==
+  testthat::expect_true(all(df_gam$canonicalName == corrected_gam$output$canonicalName))
+  testthat::expect_true(all(df_gam$canonicalName == corrected_gam_ys$output$canonicalName))
+  testthat::expect_true(all(df_bad$canonicalName == corrected_gam_bad$output$canonicalName))
+  testthat::expect_true(all(df_bad$canonicalName ==
     corrected_gam_bad_ys$output$canonicalName))
-  expect_true(all(df_gam$year == basic_gam$output$year))
-  expect_true(all(df_gam$year == basic_gam_ys$output$year))
-  expect_true(all(df_bad$year == basic_gam_bad$output$year))
-  expect_true(all(df_bad$year == basic_gam_bad_ys$output$year))
-  expect_true(all(df_gam$year == corrected_gam$output$year))
-  expect_true(all(df_gam$year == corrected_gam_ys$output$year))
-  expect_true(all(df_bad$year == corrected_gam_bad$output$year))
-  expect_true(all(df_bad$year == corrected_gam_bad_ys$output$year))
-  expect_true(all(df_gam$n_observations == basic_gam$output$n_observations))
-  expect_true(all(df_gam$n_observations == basic_gam_ys$output$n_observations))
-  expect_true(all(df_bad$n_observations == basic_gam_bad$output$n_observations))
-  expect_true(all(df_bad$n_observations ==
+  testthat::expect_true(all(df_gam$year == basic_gam$output$year))
+  testthat::expect_true(all(df_gam$year == basic_gam_ys$output$year))
+  testthat::expect_true(all(df_bad$year == basic_gam_bad$output$year))
+  testthat::expect_true(all(df_bad$year == basic_gam_bad_ys$output$year))
+  testthat::expect_true(all(df_gam$year == corrected_gam$output$year))
+  testthat::expect_true(all(df_gam$year == corrected_gam_ys$output$year))
+  testthat::expect_true(all(df_bad$year == corrected_gam_bad$output$year))
+  testthat::expect_true(all(df_bad$year == corrected_gam_bad_ys$output$year))
+  testthat::expect_true(all(df_gam$n_observations == basic_gam$output$n_observations))
+  testthat::expect_true(all(df_gam$n_observations == basic_gam_ys$output$n_observations))
+  testthat::expect_true(all(df_bad$n_observations == basic_gam_bad$output$n_observations))
+  testthat::expect_true(all(df_bad$n_observations ==
     basic_gam_bad_ys$output$n_observations))
-  expect_true(all(df_gam$n_observations == corrected_gam$output$n_observations))
-  expect_true(all(df_gam$n_observations == corrected_gam_ys$output$n_observations))
-  expect_true(all(df_bad$n_observations == corrected_gam_bad$output$n_observations))
-  expect_true(all(df_bad$n_observations ==
+  testthat::expect_true(all(df_gam$n_observations == corrected_gam$output$n_observations))
+  testthat::expect_true(all(df_gam$n_observations == corrected_gam_ys$output$n_observations))
+  testthat::expect_true(all(df_bad$n_observations == corrected_gam_bad$output$n_observations))
+  testthat::expect_true(all(df_bad$n_observations ==
     corrected_gam_bad_ys$output$n_observations))
 
-  expect_true(all(df_gam$baseline_observations ==
+  testthat::expect_true(all(df_gam$baseline_observations ==
     basic_gam$output$baseline_observations))
-  expect_true(all(df_gam$baseline_observations ==
+  testthat::expect_true(all(df_gam$baseline_observations ==
     basic_gam_ys$output$baseline_observations))
-  expect_true(all(df_bad$baseline_observations ==
+  testthat::expect_true(all(df_bad$baseline_observations ==
     basic_gam_bad$output$baseline_observations))
-  expect_true(all(df_bad$baseline_observations ==
+  testthat::expect_true(all(df_bad$baseline_observations ==
     basic_gam_bad_ys$output$baseline_observations))
-  expect_true(all(df_gam$baseline_observations ==
+  testthat::expect_true(all(df_gam$baseline_observations ==
     corrected_gam$output$baseline_observations))
-  expect_true(all(df_gam$baseline_observations ==
+  testthat::expect_true(all(df_gam$baseline_observations ==
     corrected_gam_ys$output$baseline_observations))
-  expect_true(all(df_bad$baseline_observations ==
+  testthat::expect_true(all(df_bad$baseline_observations ==
     corrected_gam_bad$output$baseline_observations))
-  expect_true(all(df_bad$baseline_observations ==
+  testthat::expect_true(all(df_bad$baseline_observations ==
     corrected_gam_bad_ys$output$baseline_observations))
 
   # output has columns em1, em2, em, em_status, growth, method
-  expect_true(all(c("em1", "em2", "em", "em_status", "growth", "method") %in%
+  testthat::expect_true(all(c("em1", "em2", "em", "em_status", "growth", "method") %in%
     names(basic_gam$output)))
-  expect_true(all(c("em1", "em2", "em", "em_status", "growth", "method") %in%
+  testthat::expect_true(all(c("em1", "em2", "em", "em_status", "growth", "method") %in%
     names(basic_gam_ys$output)))
-  expect_true(all(c("em1", "em2", "em", "em_status", "growth", "method") %in%
+  testthat::expect_true(all(c("em1", "em2", "em", "em_status", "growth", "method") %in%
     names(basic_gam_bad$output)))
-  expect_true(all(c("em1", "em2", "em", "em_status", "growth", "method") %in%
+  testthat::expect_true(all(c("em1", "em2", "em", "em_status", "growth", "method") %in%
     names(basic_gam_bad_ys$output)))
-  expect_true(all(c("em1", "em2", "em", "em_status", "growth", "method") %in%
+  testthat::expect_true(all(c("em1", "em2", "em", "em_status", "growth", "method") %in%
     names(corrected_gam$output)))
-  expect_true(all(c("em1", "em2", "em", "em_status", "growth", "method") %in%
+  testthat::expect_true(all(c("em1", "em2", "em", "em_status", "growth", "method") %in%
     names(corrected_gam_ys$output)))
-  expect_true(all(c("em1", "em2", "em", "em_status", "growth", "method") %in%
+  testthat::expect_true(all(c("em1", "em2", "em", "em_status", "growth", "method") %in%
     names(corrected_gam_bad$output)))
-  expect_true(all(c("em1", "em2", "em", "em_status", "growth", "method") %in%
+  testthat::expect_true(all(c("em1", "em2", "em", "em_status", "growth", "method") %in%
     names(corrected_gam_bad_ys$output)))
 
   # fit values are zero or above
-  expect_true(all(c(
+  testthat::expect_true(all(c(
     basic_gam$output$fit,
     basic_gam$output$ucl,
     basic_gam$output$lcl,
@@ -339,7 +339,7 @@ testthat::test_that("Test output", {
     corrected_gam$output$ucl,
     corrected_gam$output$lcl
   ) >= 0))
-  expect_true(all(c(
+  testthat::expect_true(all(c(
     basic_gam_ys$output$fit,
     basic_gam_ys$output$ucl,
     basic_gam_ys$output$lcl,
@@ -349,7 +349,7 @@ testthat::test_that("Test output", {
   ) >= 0))
 
   # if GAM is not performed: fit columns are NA
-  expect_true(all(is.na(c(
+  testthat::expect_true(all(is.na(c(
     basic_gam_bad$output$fit,
     basic_gam_bad$output$ucl,
     basic_gam_bad$output$lcl,
@@ -357,7 +357,7 @@ testthat::test_that("Test output", {
     corrected_gam_bad$output$ucl,
     corrected_gam_bad$output$lcl
   ))))
-  expect_true(all(is.na(c(
+  testthat::expect_true(all(is.na(c(
     basic_gam_bad_ys$output$fit,
     basic_gam_bad_ys$output$ucl,
     basic_gam_bad_ys$output$lcl,
@@ -367,121 +367,121 @@ testthat::test_that("Test output", {
   ))))
 
   # lcl <= fit <= ucl
-  expect_true(all(basic_gam$output$lcl <= basic_gam$output$fit &
+  testthat::expect_true(all(basic_gam$output$lcl <= basic_gam$output$fit &
     basic_gam$output$fit <= basic_gam$output$ucl))
-  expect_true(all(basic_gam_ys$output$lcl <= basic_gam_ys$output$fit &
+  testthat::expect_true(all(basic_gam_ys$output$lcl <= basic_gam_ys$output$fit &
     basic_gam_ys$output$fit <= basic_gam_ys$output$ucl))
-  expect_true(all(corrected_gam$output$lcl <= corrected_gam$output$fit &
+  testthat::expect_true(all(corrected_gam$output$lcl <= corrected_gam$output$fit &
     corrected_gam$output$fit <= corrected_gam$output$ucl))
-  expect_true(all(corrected_gam_ys$output$lcl <= corrected_gam_ys$output$fit &
+  testthat::expect_true(all(corrected_gam_ys$output$lcl <= corrected_gam_ys$output$fit &
     corrected_gam_ys$output$fit <= corrected_gam_ys$output$ucl))
 
   # number of years for evaluation doesn't affect fit values
-  expect_true(all(basic_gam$output$lcl == basic_gam_ys$output$lcl &
+  testthat::expect_true(all(basic_gam$output$lcl == basic_gam_ys$output$lcl &
     basic_gam$output$fit == basic_gam_ys$output$fit &
     basic_gam$output$ucl == basic_gam_ys$output$ucl))
-  expect_true(all(corrected_gam$output$lcl == corrected_gam_ys$output$lcl &
+  testthat::expect_true(all(corrected_gam$output$lcl == corrected_gam_ys$output$lcl &
     corrected_gam$output$fit == corrected_gam_ys$output$fit &
     corrected_gam$output$ucl == corrected_gam_ys$output$ucl))
 
   # em1, em2, em, em_status are numeric
-  expect_true(is.numeric(basic_gam$output$em1))
-  expect_true(is.numeric(basic_gam$output$em2))
-  expect_true(is.numeric(basic_gam$output$em))
-  expect_true(is.numeric(basic_gam$output$em_status))
-  expect_true(is.numeric(corrected_gam$output$em1))
-  expect_true(is.numeric(corrected_gam$output$em2))
-  expect_true(is.numeric(corrected_gam$output$em))
-  expect_true(is.numeric(corrected_gam$output$em_status))
-  expect_true(is.numeric(basic_gam_bad$output$em1))
-  expect_true(is.numeric(basic_gam_bad$output$em2))
-  expect_true(is.numeric(basic_gam_bad$output$em))
-  expect_true(is.numeric(basic_gam_bad$output$em_status))
-  expect_true(is.numeric(corrected_gam_bad$output$em1))
-  expect_true(is.numeric(corrected_gam_bad$output$em2))
-  expect_true(is.numeric(corrected_gam_bad$output$em))
-  expect_true(is.numeric(corrected_gam_bad$output$em_status))
+  testthat::expect_true(is.numeric(basic_gam$output$em1))
+  testthat::expect_true(is.numeric(basic_gam$output$em2))
+  testthat::expect_true(is.numeric(basic_gam$output$em))
+  testthat::expect_true(is.numeric(basic_gam$output$em_status))
+  testthat::expect_true(is.numeric(corrected_gam$output$em1))
+  testthat::expect_true(is.numeric(corrected_gam$output$em2))
+  testthat::expect_true(is.numeric(corrected_gam$output$em))
+  testthat::expect_true(is.numeric(corrected_gam$output$em_status))
+  testthat::expect_true(is.numeric(basic_gam_bad$output$em1))
+  testthat::expect_true(is.numeric(basic_gam_bad$output$em2))
+  testthat::expect_true(is.numeric(basic_gam_bad$output$em))
+  testthat::expect_true(is.numeric(basic_gam_bad$output$em_status))
+  testthat::expect_true(is.numeric(corrected_gam_bad$output$em1))
+  testthat::expect_true(is.numeric(corrected_gam_bad$output$em2))
+  testthat::expect_true(is.numeric(corrected_gam_bad$output$em))
+  testthat::expect_true(is.numeric(corrected_gam_bad$output$em_status))
 
   # if GAM is performed em1 em2 are one of c(-1, 0, 1),
-  expect_true(all(
+  testthat::expect_true(all(
     basic_gam$output$em1 %in% c(-1, 0, 1),
     basic_gam$output$em2 %in% c(-1, 0, 1)
   ))
-  expect_true(all(
+  testthat::expect_true(all(
     basic_gam_ys$output$em1 %in% c(-1, 0, 1),
     basic_gam_ys$output$em2 %in% c(-1, 0, 1)
   ))
-  expect_true(all(
+  testthat::expect_true(all(
     corrected_gam$output$em1 %in% c(-1, 0, 1),
     corrected_gam$output$em2 %in% c(-1, 0, 1)
   ))
-  expect_true(all(
+  testthat::expect_true(all(
     corrected_gam_ys$output$em1 %in% c(-1, 0, 1),
     corrected_gam_ys$output$em2 %in% c(-1, 0, 1)
   ))
 
   # if GAM is performed em is a value between -4 and +4
-  expect_true(all(basic_gam$output$em <= 4 & basic_gam$output$em >= -4))
-  expect_true(all(basic_gam_ys$output$em <= 4 & basic_gam$output$em >= -4))
-  expect_true(all(corrected_gam$output$em <= 4 & basic_gam$output$em >= -4))
-  expect_true(all(corrected_gam_ys$output$em <= 4 & basic_gam$output$em >= -4))
+  testthat::expect_true(all(basic_gam$output$em <= 4 & basic_gam$output$em >= -4))
+  testthat::expect_true(all(basic_gam_ys$output$em <= 4 & basic_gam$output$em >= -4))
+  testthat::expect_true(all(corrected_gam$output$em <= 4 & basic_gam$output$em >= -4))
+  testthat::expect_true(all(corrected_gam_ys$output$em <= 4 & basic_gam$output$em >= -4))
 
   # if GAM is performed em_stauts is one of 0, 1, 2, 3
-  expect_true(all(basic_gam$output$em_status <= 3 &
+  testthat::expect_true(all(basic_gam$output$em_status <= 3 &
     basic_gam$output$em_status >= 0))
-  expect_true(all(basic_gam_ys$output$em_status <= 3 &
+  testthat::expect_true(all(basic_gam_ys$output$em_status <= 3 &
     basic_gam_ys$output$em_status >= 0))
-  expect_true(all(corrected_gam$output$em_status <= 3 &
+  testthat::expect_true(all(corrected_gam$output$em_status <= 3 &
     corrected_gam$output$em_status >= 0))
-  expect_true(all(corrected_gam_ys$output$em_status <= 3 &
+  testthat::expect_true(all(corrected_gam_ys$output$em_status <= 3 &
     corrected_gam_ys$output$em_status >= 0))
 
   # em_status is equal to em_summary for evaluation_years
-  expect_true(all((basic_gam$output %>%
+  testthat::expect_true(all((basic_gam$output %>%
     dplyr::filter(year == evaluation_year) %>%
     pull(em_status)) ==
     (basic_gam$em_summary %>%
       dplyr::filter(year == evaluation_year) %>%
       pull(em_status))))
-  expect_true(all((basic_gam_ys$output %>%
+  testthat::expect_true(all((basic_gam_ys$output %>%
     dplyr::filter(year %in% evaluation_years) %>%
     pull(em_status)) ==
     (basic_gam_ys$em_summary %>%
       dplyr::filter(year %in% evaluation_years) %>%
       pull(em_status))))
-  expect_true(all((corrected_gam$output %>%
+  testthat::expect_true(all((corrected_gam$output %>%
     dplyr::filter(year == evaluation_year) %>%
     pull(em_status)) ==
     (corrected_gam$em_summary %>%
       dplyr::filter(year == evaluation_year) %>%
       pull(em_status))))
-  expect_true(all((corrected_gam_ys$output %>%
+  testthat::expect_true(all((corrected_gam_ys$output %>%
     dplyr::filter(year %in% evaluation_years) %>%
     pull(em_status)) ==
     (corrected_gam_ys$em_summary %>%
       dplyr::filter(year %in% evaluation_years) %>%
       pull(em_status))))
-  expect_true(all(is.na(corrected_gam_bad$output %>%
+  testthat::expect_true(all(is.na(corrected_gam_bad$output %>%
     dplyr::filter(year == evaluation_year) %>%
     pull(em_status))))
-  expect_true(all(is.na(corrected_gam_bad_ys$output %>%
+  testthat::expect_true(all(is.na(corrected_gam_bad_ys$output %>%
     dplyr::filter(year %in% evaluation_years) %>%
     pull(em_status))))
-  expect_true(all(is.na(corrected_gam_bad$output %>%
+  testthat::expect_true(all(is.na(corrected_gam_bad$output %>%
     dplyr::filter(year == evaluation_year) %>%
     pull(em_status))))
-  expect_true(all(is.na(corrected_gam_bad_ys$output %>%
+  testthat::expect_true(all(is.na(corrected_gam_bad_ys$output %>%
     dplyr::filter(year %in% evaluation_years) %>%
     pull(em_status))))
 
   # number of years for evaluation doesn't affect em1, em2, em, em_status
-  expect_true(all(
+  testthat::expect_true(all(
     basic_gam$output$em1 == basic_gam_ys$output$em1,
     basic_gam$output$em2 == basic_gam_ys$output$em2,
     basic_gam$output$em == basic_gam_ys$output$em,
     basic_gam$output$em_status == corrected_gam_ys$output$em_status
   ))
-  expect_true(all(
+  testthat::expect_true(all(
     corrected_gam_ys$output$em1 == corrected_gam_ys$output$em1,
     corrected_gam_ys$output$em2 == corrected_gam_ys$output$em2,
     corrected_gam_ys$output$em == corrected_gam_ys$output$em,
@@ -489,25 +489,25 @@ testthat::test_that("Test output", {
   ))
 
   # growth
-  expect_true(is.numeric(basic_gam$output$growth))
-  expect_true(is.numeric(basic_gam_ys$output$growth))
-  expect_true(is.numeric(basic_gam_bad$output$growth))
-  expect_true(is.numeric(basic_gam_bad_ys$output$growth))
-  expect_true(is.numeric(corrected_gam$output$growth))
-  expect_true(is.numeric(corrected_gam_ys$output$growth))
-  expect_true(is.numeric(corrected_gam_bad$output$growth))
-  expect_true(is.numeric(corrected_gam_bad_ys$output$growth))
+  testthat::expect_true(is.numeric(basic_gam$output$growth))
+  testthat::expect_true(is.numeric(basic_gam_ys$output$growth))
+  testthat::expect_true(is.numeric(basic_gam_bad$output$growth))
+  testthat::expect_true(is.numeric(basic_gam_bad_ys$output$growth))
+  testthat::expect_true(is.numeric(corrected_gam$output$growth))
+  testthat::expect_true(is.numeric(corrected_gam_ys$output$growth))
+  testthat::expect_true(is.numeric(corrected_gam_bad$output$growth))
+  testthat::expect_true(is.numeric(corrected_gam_bad_ys$output$growth))
 
   # add some checks about values of growth?
 
   # method is correctly returned
-  expect_true(all(c(
+  testthat::expect_true(all(c(
     basic_gam$output$method,
     basic_gam_bad$output$method,
     basic_gam_ys$output$method,
     basic_gam_bad_ys$output$method
   ) == "basic"))
-  expect_true(all(c(
+  testthat::expect_true(all(c(
     corrected_gam$output$method,
     corrected_gam_bad$output$method,
     corrected_gam_ys$output$method,
@@ -518,17 +518,17 @@ testthat::test_that("Test output", {
 testthat::test_that("Test first derivative", {
 
   # first derivative is a data.frame or is NULL
-  expect_true(is.data.frame(basic_gam$first_derivative))
-  expect_true(is.data.frame(basic_gam_ys$first_derivative))
-  expect_true(is.data.frame(corrected_gam$first_derivative))
-  expect_true(is.data.frame(corrected_gam_ys$first_derivative))
+  testthat::expect_true(is.data.frame(basic_gam$first_derivative))
+  testthat::expect_true(is.data.frame(basic_gam_ys$first_derivative))
+  testthat::expect_true(is.data.frame(corrected_gam$first_derivative))
+  testthat::expect_true(is.data.frame(corrected_gam_ys$first_derivative))
   expect_null(basic_gam_bad$first_derivative)
   expect_null(basic_gam_bad_ys$first_derivative)
   expect_null(corrected_gam_bad$first_derivative)
   expect_null(corrected_gam_bad_ys$first_derivative)
 
   # first derivatives has right columns
-  expect_that(
+  testthat::expect_that(
     basic_gam$first_derivative,
     has_names(expected = c(
       "smooth",
@@ -541,45 +541,45 @@ testthat::test_that("Test first derivative", {
       "upper"
     ))
   )
-  expect_true(all(names(basic_gam$first_derivative) ==
+  testthat::expect_true(all(names(basic_gam$first_derivative) ==
     names(basic_gam_ys$first_derivative)))
-  expect_true(all(names(basic_gam$first_derivative) ==
+  testthat::expect_true(all(names(basic_gam$first_derivative) ==
     names(corrected_gam$first_derivative)))
-  expect_true(all(names(corrected_gam$first_derivative) ==
+  testthat::expect_true(all(names(corrected_gam$first_derivative) ==
     names(corrected_gam_ys$first_derivative)))
 
   # smooth column contains only s(year) for basic gam
-  expect_true(unique(basic_gam$first_derivative$smooth) == "s(year)")
-  expect_true(unique(basic_gam_ys$first_derivative$smooth) == "s(year)")
-  expect_false(all(unique(corrected_gam$first_derivative$smooth) == "s(year)"))
-  expect_false(all(unique(corrected_gam_ys$first_derivative$smooth) == "s(year)"))
+  testthat::expect_true(unique(basic_gam$first_derivative$smooth) == "s(year)")
+  testthat::expect_true(unique(basic_gam_ys$first_derivative$smooth) == "s(year)")
+  testthat::expect_false(all(unique(corrected_gam$first_derivative$smooth) == "s(year)"))
+  testthat::expect_false(all(unique(corrected_gam_ys$first_derivative$smooth) == "s(year)"))
 
   # smooth column contains s(year) and s(baseline_observations) if correction
   # baseline is applied
-  expect_true(all(corrected_gam$first_derivative$smooth %in%
+  testthat::expect_true(all(corrected_gam$first_derivative$smooth %in%
     c("s(year)", "s(baseline_observations)")))
-  expect_true(all(corrected_gam_ys$first_derivative$smooth %in%
+  testthat::expect_true(all(corrected_gam_ys$first_derivative$smooth %in%
     c("s(year)", "s(baseline_observations)")))
 
   # var contains always value "year" if GAM is performed
-  expect_true("year" %in% basic_gam$first_derivative$var)
-  expect_true("year" %in% basic_gam_ys$first_derivative$var)
-  expect_true("year" %in% corrected_gam$first_derivative$var)
-  expect_true("year" %in% corrected_gam_ys$first_derivative$var)
+  testthat::expect_true("year" %in% basic_gam$first_derivative$var)
+  testthat::expect_true("year" %in% basic_gam_ys$first_derivative$var)
+  testthat::expect_true("year" %in% corrected_gam$first_derivative$var)
+  testthat::expect_true("year" %in% corrected_gam_ys$first_derivative$var)
 
   # if correction based on column baseline_observations, baseline_observations
   # is present in var
-  expect_true("baseline_observations" %in% corrected_gam$first_derivative$var)
-  expect_true("baseline_observations" %in%
+  testthat::expect_true("baseline_observations" %in% corrected_gam$first_derivative$var)
+  testthat::expect_true("baseline_observations" %in%
     corrected_gam_ys$first_derivative$var)
-  expect_false("baseline_observations" %in% basic_gam$first_derivative$var)
-  expect_false("baseline_observations" %in% basic_gam_ys$first_derivative$var)
+  testthat::expect_false("baseline_observations" %in% basic_gam$first_derivative$var)
+  testthat::expect_false("baseline_observations" %in% basic_gam_ys$first_derivative$var)
 
   # data contains numeric values
-  expect_true(is.numeric(basic_gam$first_derivative$data))
-  expect_true(is.numeric(basic_gam_ys$first_derivative$data))
-  expect_true(is.numeric(corrected_gam$first_derivative$data))
-  expect_true(is.numeric(corrected_gam_ys$first_derivative$data))
+  testthat::expect_true(is.numeric(basic_gam$first_derivative$data))
+  testthat::expect_true(is.numeric(basic_gam_ys$first_derivative$data))
+  testthat::expect_true(is.numeric(corrected_gam$first_derivative$data))
+  testthat::expect_true(is.numeric(corrected_gam_ys$first_derivative$data))
 
   # data column is equal to column year of df_gam for basic gam
   expect_equivalent(round(basic_gam$first_derivative$data),
@@ -590,75 +590,75 @@ testthat::test_that("Test first derivative", {
   )
 
   # columns derivative, se, crit, lower, upper are numeric
-  expect_true(is.numeric(basic_gam$first_derivative$derivative))
-  expect_true(is.numeric(basic_gam$first_derivative$se))
-  expect_true(is.numeric(basic_gam$first_derivative$crit))
-  expect_true(is.numeric(basic_gam$first_derivative$lower))
-  expect_true(is.numeric(basic_gam$first_derivative$upper))
-  expect_true(is.numeric(basic_gam_ys$first_derivative$derivative))
-  expect_true(is.numeric(basic_gam_ys$first_derivative$se))
-  expect_true(is.numeric(basic_gam_ys$first_derivative$crit))
-  expect_true(is.numeric(basic_gam_ys$first_derivative$lower))
-  expect_true(is.numeric(basic_gam_ys$first_derivative$upper))
-  expect_true(is.numeric(corrected_gam$first_derivative$derivative))
-  expect_true(is.numeric(corrected_gam$first_derivative$se))
-  expect_true(is.numeric(corrected_gam$first_derivative$crit))
-  expect_true(is.numeric(corrected_gam$first_derivative$lower))
-  expect_true(is.numeric(corrected_gam$first_derivative$upper))
-  expect_true(is.numeric(corrected_gam_ys$first_derivative$derivative))
-  expect_true(is.numeric(corrected_gam_ys$first_derivative$se))
-  expect_true(is.numeric(corrected_gam_ys$first_derivative$crit))
-  expect_true(is.numeric(corrected_gam_ys$first_derivative$lower))
-  expect_true(is.numeric(corrected_gam_ys$first_derivative$upper))
+  testthat::expect_true(is.numeric(basic_gam$first_derivative$derivative))
+  testthat::expect_true(is.numeric(basic_gam$first_derivative$se))
+  testthat::expect_true(is.numeric(basic_gam$first_derivative$crit))
+  testthat::expect_true(is.numeric(basic_gam$first_derivative$lower))
+  testthat::expect_true(is.numeric(basic_gam$first_derivative$upper))
+  testthat::expect_true(is.numeric(basic_gam_ys$first_derivative$derivative))
+  testthat::expect_true(is.numeric(basic_gam_ys$first_derivative$se))
+  testthat::expect_true(is.numeric(basic_gam_ys$first_derivative$crit))
+  testthat::expect_true(is.numeric(basic_gam_ys$first_derivative$lower))
+  testthat::expect_true(is.numeric(basic_gam_ys$first_derivative$upper))
+  testthat::expect_true(is.numeric(corrected_gam$first_derivative$derivative))
+  testthat::expect_true(is.numeric(corrected_gam$first_derivative$se))
+  testthat::expect_true(is.numeric(corrected_gam$first_derivative$crit))
+  testthat::expect_true(is.numeric(corrected_gam$first_derivative$lower))
+  testthat::expect_true(is.numeric(corrected_gam$first_derivative$upper))
+  testthat::expect_true(is.numeric(corrected_gam_ys$first_derivative$derivative))
+  testthat::expect_true(is.numeric(corrected_gam_ys$first_derivative$se))
+  testthat::expect_true(is.numeric(corrected_gam_ys$first_derivative$crit))
+  testthat::expect_true(is.numeric(corrected_gam_ys$first_derivative$lower))
+  testthat::expect_true(is.numeric(corrected_gam_ys$first_derivative$upper))
 
   # number of evaluation years doesn't affect 1st derivative values
-  expect_that(
+  testthat::expect_that(
     basic_gam_ys$first_derivative$derivative,
-    is_identical_to(basic_gam$first_derivative$derivative)
+    testthat::is_identical_to(basic_gam$first_derivative$derivative)
   )
-  expect_that(
+  testthat::expect_that(
     corrected_gam$first_derivative$derivative,
-    is_identical_to(corrected_gam$first_derivative$derivative)
+    testthat::is_identical_to(corrected_gam$first_derivative$derivative)
   )
-  expect_that(
+  testthat::expect_that(
     basic_gam_ys$first_derivative$se,
-    is_identical_to(basic_gam$first_derivative$se)
+    testthat::is_identical_to(basic_gam$first_derivative$se)
   )
-  expect_that(
+  testthat::expect_that(
     corrected_gam$first_derivative$se,
-    is_identical_to(corrected_gam$first_derivative$se)
+    testthat::is_identical_to(corrected_gam$first_derivative$se)
   )
-  expect_that(
+  testthat::expect_that(
     basic_gam_ys$first_derivative$crit,
-    is_identical_to(basic_gam$first_derivative$crit)
+    testthat::is_identical_to(basic_gam$first_derivative$crit)
   )
-  expect_that(
+  testthat::expect_that(
     corrected_gam$first_derivative$crit,
-    is_identical_to(corrected_gam$first_derivative$crit)
+    testthat::is_identical_to(corrected_gam$first_derivative$crit)
   )
-  expect_that(
+  testthat::expect_that(
     basic_gam_ys$first_derivative$lower,
-    is_identical_to(basic_gam$first_derivative$lower)
+    testthat::is_identical_to(basic_gam$first_derivative$lower)
   )
-  expect_that(
+  testthat::expect_that(
     corrected_gam$first_derivative$lower,
-    is_identical_to(corrected_gam$first_derivative$lower)
+    testthat::is_identical_to(corrected_gam$first_derivative$lower)
   )
-  expect_that(
+  testthat::expect_that(
     basic_gam_ys$first_derivative$upper,
-    is_identical_to(basic_gam$first_derivative$upper)
+    testthat::is_identical_to(basic_gam$first_derivative$upper)
   )
-  expect_that(
+  testthat::expect_that(
     corrected_gam$first_derivative$upper,
-    is_identical_to(corrected_gam$first_derivative$upper)
+    testthat::is_identical_to(corrected_gam$first_derivative$upper)
   )
 
   # lower <= derivative <= upper
-  expect_true(all(basic_gam$first_derivative$lower <=
+  testthat::expect_true(all(basic_gam$first_derivative$lower <=
     basic_gam$first_derivative$derivative &
     basic_gam$first_derivative$derivative <=
       basic_gam$first_derivative$upper))
-  expect_true(all(corrected_gam$first_derivative$lower <=
+  testthat::expect_true(all(corrected_gam$first_derivative$lower <=
     corrected_gam$first_derivative$derivative &
     corrected_gam$first_derivative$derivative <=
       corrected_gam$first_derivative$upper))
@@ -667,17 +667,17 @@ testthat::test_that("Test first derivative", {
 testthat::test_that("Test second derivative", {
 
   # second derivative is a data.frame or is NULL
-  expect_true(is.data.frame(basic_gam$second_derivative))
-  expect_true(is.data.frame(basic_gam_ys$second_derivative))
-  expect_true(is.data.frame(corrected_gam$second_derivative))
-  expect_true(is.data.frame(corrected_gam_ys$second_derivative))
+  testthat::expect_true(is.data.frame(basic_gam$second_derivative))
+  testthat::expect_true(is.data.frame(basic_gam_ys$second_derivative))
+  testthat::expect_true(is.data.frame(corrected_gam$second_derivative))
+  testthat::expect_true(is.data.frame(corrected_gam_ys$second_derivative))
   expect_null(basic_gam_bad$second_derivative)
   expect_null(basic_gam_bad_ys$second_derivative)
   expect_null(corrected_gam_bad$second_derivative)
   expect_null(corrected_gam_bad_ys$second_derivative)
 
   # second derivatives has right columns
-  expect_that(
+  testthat::expect_that(
     basic_gam$second_derivative,
     has_names(expected = c(
       "smooth",
@@ -690,45 +690,45 @@ testthat::test_that("Test second derivative", {
       "upper"
     ))
   )
-  expect_true(all(names(basic_gam$second_derivative) ==
+  testthat::expect_true(all(names(basic_gam$second_derivative) ==
     names(basic_gam_ys$second_derivative)))
-  expect_true(all(names(basic_gam$second_derivative) ==
+  testthat::expect_true(all(names(basic_gam$second_derivative) ==
     names(corrected_gam$second_derivative)))
-  expect_true(all(names(corrected_gam$second_derivative) ==
+  testthat::expect_true(all(names(corrected_gam$second_derivative) ==
     names(corrected_gam_ys$second_derivative)))
 
   # smooth column contains only s(year) for basic gam
-  expect_true(unique(basic_gam$second_derivative$smooth) == "s(year)")
-  expect_true(unique(basic_gam_ys$second_derivative$smooth) == "s(year)")
-  expect_false(all(unique(corrected_gam$second_derivative$smooth) == "s(year)"))
-  expect_false(all(unique(corrected_gam_ys$second_derivative$smooth) == "s(year)"))
+  testthat::expect_true(unique(basic_gam$second_derivative$smooth) == "s(year)")
+  testthat::expect_true(unique(basic_gam_ys$second_derivative$smooth) == "s(year)")
+  testthat::expect_false(all(unique(corrected_gam$second_derivative$smooth) == "s(year)"))
+  testthat::expect_false(all(unique(corrected_gam_ys$second_derivative$smooth) == "s(year)"))
 
   # smooth column contains s(year) and s(baseline_observations) if correction
   # baseline is applied
-  expect_true(all(corrected_gam$second_derivative$smooth %in%
+  testthat::expect_true(all(corrected_gam$second_derivative$smooth %in%
     c("s(year)", "s(baseline_observations)")))
-  expect_true(all(corrected_gam_ys$second_derivative$smooth %in%
+  testthat::expect_true(all(corrected_gam_ys$second_derivative$smooth %in%
     c("s(year)", "s(baseline_observations)")))
 
   # var contains always value "year" if GAM is performed
-  expect_true("year" %in% basic_gam$second_derivative$var)
-  expect_true("year" %in% basic_gam_ys$second_derivative$var)
-  expect_true("year" %in% corrected_gam$second_derivative$var)
-  expect_true("year" %in% corrected_gam_ys$second_derivative$var)
+  testthat::expect_true("year" %in% basic_gam$second_derivative$var)
+  testthat::expect_true("year" %in% basic_gam_ys$second_derivative$var)
+  testthat::expect_true("year" %in% corrected_gam$second_derivative$var)
+  testthat::expect_true("year" %in% corrected_gam_ys$second_derivative$var)
 
   # if correction based on column baseline_observations, baseline_observations
   # is present in var
-  expect_true("baseline_observations" %in% corrected_gam$second_derivative$var)
-  expect_true("baseline_observations" %in%
+  testthat::expect_true("baseline_observations" %in% corrected_gam$second_derivative$var)
+  testthat::expect_true("baseline_observations" %in%
     corrected_gam_ys$second_derivative$var)
-  expect_false("baseline_observations" %in% basic_gam$second_derivative$var)
-  expect_false("baseline_observations" %in% basic_gam_ys$second_derivative$var)
+  testthat::expect_false("baseline_observations" %in% basic_gam$second_derivative$var)
+  testthat::expect_false("baseline_observations" %in% basic_gam_ys$second_derivative$var)
 
   # data contains numeric values
-  expect_true(is.numeric(basic_gam$second_derivative$data))
-  expect_true(is.numeric(basic_gam_ys$second_derivative$data))
-  expect_true(is.numeric(corrected_gam$second_derivative$data))
-  expect_true(is.numeric(corrected_gam_ys$second_derivative$data))
+  testthat::expect_true(is.numeric(basic_gam$second_derivative$data))
+  testthat::expect_true(is.numeric(basic_gam_ys$second_derivative$data))
+  testthat::expect_true(is.numeric(corrected_gam$second_derivative$data))
+  testthat::expect_true(is.numeric(corrected_gam_ys$second_derivative$data))
 
   # data column is equal to column year of df_gam for basic gam
   expect_equivalent(round(basic_gam$second_derivative$data),
@@ -739,75 +739,75 @@ testthat::test_that("Test second derivative", {
   )
 
   # columns derivative, se, crit, lower, upper are numeric
-  expect_true(is.numeric(basic_gam$second_derivative$derivative))
-  expect_true(is.numeric(basic_gam$second_derivative$se))
-  expect_true(is.numeric(basic_gam$second_derivative$crit))
-  expect_true(is.numeric(basic_gam$second_derivative$lower))
-  expect_true(is.numeric(basic_gam$second_derivative$upper))
-  expect_true(is.numeric(basic_gam_ys$second_derivative$derivative))
-  expect_true(is.numeric(basic_gam_ys$second_derivative$se))
-  expect_true(is.numeric(basic_gam_ys$second_derivative$crit))
-  expect_true(is.numeric(basic_gam_ys$second_derivative$lower))
-  expect_true(is.numeric(basic_gam_ys$second_derivative$upper))
-  expect_true(is.numeric(corrected_gam$second_derivative$derivative))
-  expect_true(is.numeric(corrected_gam$second_derivative$se))
-  expect_true(is.numeric(corrected_gam$second_derivative$crit))
-  expect_true(is.numeric(corrected_gam$second_derivative$lower))
-  expect_true(is.numeric(corrected_gam$second_derivative$upper))
-  expect_true(is.numeric(corrected_gam_ys$second_derivative$derivative))
-  expect_true(is.numeric(corrected_gam_ys$second_derivative$se))
-  expect_true(is.numeric(corrected_gam_ys$second_derivative$crit))
-  expect_true(is.numeric(corrected_gam_ys$second_derivative$lower))
-  expect_true(is.numeric(corrected_gam_ys$second_derivative$upper))
+  testthat::expect_true(is.numeric(basic_gam$second_derivative$derivative))
+  testthat::expect_true(is.numeric(basic_gam$second_derivative$se))
+  testthat::expect_true(is.numeric(basic_gam$second_derivative$crit))
+  testthat::expect_true(is.numeric(basic_gam$second_derivative$lower))
+  testthat::expect_true(is.numeric(basic_gam$second_derivative$upper))
+  testthat::expect_true(is.numeric(basic_gam_ys$second_derivative$derivative))
+  testthat::expect_true(is.numeric(basic_gam_ys$second_derivative$se))
+  testthat::expect_true(is.numeric(basic_gam_ys$second_derivative$crit))
+  testthat::expect_true(is.numeric(basic_gam_ys$second_derivative$lower))
+  testthat::expect_true(is.numeric(basic_gam_ys$second_derivative$upper))
+  testthat::expect_true(is.numeric(corrected_gam$second_derivative$derivative))
+  testthat::expect_true(is.numeric(corrected_gam$second_derivative$se))
+  testthat::expect_true(is.numeric(corrected_gam$second_derivative$crit))
+  testthat::expect_true(is.numeric(corrected_gam$second_derivative$lower))
+  testthat::expect_true(is.numeric(corrected_gam$second_derivative$upper))
+  testthat::expect_true(is.numeric(corrected_gam_ys$second_derivative$derivative))
+  testthat::expect_true(is.numeric(corrected_gam_ys$second_derivative$se))
+  testthat::expect_true(is.numeric(corrected_gam_ys$second_derivative$crit))
+  testthat::expect_true(is.numeric(corrected_gam_ys$second_derivative$lower))
+  testthat::expect_true(is.numeric(corrected_gam_ys$second_derivative$upper))
 
   # number of evaluation years doesn't affect 2nd derivative values
-  expect_that(
+  testthat::expect_that(
     basic_gam_ys$second_derivative$derivative,
-    is_identical_to(basic_gam$second_derivative$derivative)
+    testthat::is_identical_to(basic_gam$second_derivative$derivative)
   )
-  expect_that(
+  testthat::expect_that(
     corrected_gam$second_derivative$derivative,
-    is_identical_to(corrected_gam$second_derivative$derivative)
+    testthat::is_identical_to(corrected_gam$second_derivative$derivative)
   )
-  expect_that(
+  testthat::expect_that(
     basic_gam_ys$second_derivative$se,
-    is_identical_to(basic_gam$second_derivative$se)
+    testthat::is_identical_to(basic_gam$second_derivative$se)
   )
-  expect_that(
+  testthat::expect_that(
     corrected_gam$second_derivative$se,
-    is_identical_to(corrected_gam$second_derivative$se)
+    testthat::is_identical_to(corrected_gam$second_derivative$se)
   )
-  expect_that(
+  testthat::expect_that(
     basic_gam_ys$second_derivative$crit,
-    is_identical_to(basic_gam$second_derivative$crit)
+    testthat::is_identical_to(basic_gam$second_derivative$crit)
   )
-  expect_that(
+  testthat::expect_that(
     corrected_gam$second_derivative$crit,
-    is_identical_to(corrected_gam$second_derivative$crit)
+    testthat::is_identical_to(corrected_gam$second_derivative$crit)
   )
-  expect_that(
+  testthat::expect_that(
     basic_gam_ys$second_derivative$lower,
-    is_identical_to(basic_gam$second_derivative$lower)
+    testthat::is_identical_to(basic_gam$second_derivative$lower)
   )
-  expect_that(
+  testthat::expect_that(
     corrected_gam$second_derivative$lower,
-    is_identical_to(corrected_gam$second_derivative$lower)
+    testthat::is_identical_to(corrected_gam$second_derivative$lower)
   )
-  expect_that(
+  testthat::expect_that(
     basic_gam_ys$second_derivative$upper,
-    is_identical_to(basic_gam$second_derivative$upper)
+    testthat::is_identical_to(basic_gam$second_derivative$upper)
   )
-  expect_that(
+  testthat::expect_that(
     corrected_gam$second_derivative$upper,
-    is_identical_to(corrected_gam$second_derivative$upper)
+    testthat::is_identical_to(corrected_gam$second_derivative$upper)
   )
 
   # lower <= derivative <= upper
-  expect_true(all(basic_gam$second_derivative$lower <=
+  testthat::expect_true(all(basic_gam$second_derivative$lower <=
     basic_gam$second_derivative$derivative &
     basic_gam$second_derivative$derivative <=
       basic_gam$second_derivative$upper))
-  expect_true(all(corrected_gam$second_derivative$lower <=
+  testthat::expect_true(all(corrected_gam$second_derivative$lower <=
     corrected_gam$second_derivative$derivative &
     corrected_gam$second_derivative$derivative <=
       corrected_gam$second_derivative$upper))
@@ -815,21 +815,19 @@ testthat::test_that("Test second derivative", {
 
 testthat::test_that("Test plot", {
 
-  # if gam is performed, plot is an obejct of class ggplot
-  expect_true(all(class(basic_gam$plot) == c("gg", "ggplot")))
-  expect_true(all(class(basic_gam_ys$plot) == c("gg", "ggplot")))
-  expect_true(all(class(corrected_gam$plot) == c("gg", "ggplot")))
-  expect_true(all(class(corrected_gam_ys$plot) == c("gg", "ggplot")))
-  basic_gam_occ
-  basic_gam_taxon_key_as_number
-  basic_gam_taxon_key_as_string
-  basic_gam_taxon_key_and_name
-
-  # if gam is not performed, plot slot is NULL
-  expect_null(basic_gam_bad$plot)
-  expect_null(basic_gam_bad_ys$plot)
-  expect_null(corrected_gam_bad$plot)
-  expect_null(corrected_gam_bad_ys$plot)
+  # plot is always an obejct of class ggplot
+  testthat::expect_true(all(class(basic_gam$plot) == c("gg", "ggplot")))
+  testthat::expect_true(all(class(basic_gam_ys$plot) == c("gg", "ggplot")))
+  testthat::expect_true(all(class(corrected_gam$plot) == c("gg", "ggplot")))
+  testthat::expect_true(all(class(corrected_gam_ys$plot) == c("gg", "ggplot")))
+  testthat::expect_true(all(class(basic_gam_occ$plot) == c("gg", "ggplot")))
+  testthat::expect_true(all(class(basic_gam_taxon_key_as_number) == c("gg", "ggplot")))
+  testthat::expect_true(all(class(basic_gam_taxon_key_as_string) == c("gg", "ggplot")))
+  testthat::expect_true(all(class(basic_gam_taxon_key_and_name) == c("gg", "ggplot")))
+  testthat::expect_true(all(class(basic_gam_bad$plot) == c("gg", "ggplot")))
+  testthat::expect_true(all(class(basic_gam_bad_ys$plot) == c("gg", "ggplot")))
+  testthat::expect_true(all(class(corrected_gam_bad$plot) == c("gg", "ggplot")))
+  testthat::expect_true(all(class(corrected_gam_bad_ys$plot) == c("gg", "ggplot")))
 
   # All plot titles start with "GAM"
   title_plot <- basic_gam_name$plot$labels$title
@@ -847,17 +845,17 @@ testthat::test_that("Test plot", {
     title_plot_with_key_and_name
   )
 
-  expect_true(all(substr(titles, start = 1, stop = 3) == "GAM"))
+  testthat::expect_true(all(substr(titles, start = 1, stop = 3) == "GAM"))
 
   # type of indicator follows the word GAM in title
-  expect_equal(
+  testthat::expect_equal(
     substr(title_plot,
       start = 5,
       stop = 5 + nchar(obs_indicator) - 1
     ),
     obs_indicator
   )
-  expect_equal(
+  testthat::expect_equal(
     substr(title_plot_occ,
       start = 5,
       stop = 5 + nchar(occ_indicator) - 1
@@ -866,7 +864,7 @@ testthat::test_that("Test plot", {
   )
 
   # if provided, value of argument taxon_key is in title of plot
-  expect_equal(
+  testthat::expect_equal(
     substr(
       title_plot_with_key_string,
       start = nchar(title_plot_with_key_string) - nchar(taxon_key) + 1,
@@ -875,7 +873,7 @@ testthat::test_that("Test plot", {
     taxon_key
   )
 
-  expect_equal(
+  testthat::expect_equal(
     substr(
       title_plot_with_key_number,
       start = nchar(title_plot_with_key_number) - nchar(taxon_key) + 1,
@@ -885,11 +883,11 @@ testthat::test_that("Test plot", {
   )
 
   # title of plot doens't change if taxon_key is char or numeric
-  expect_equal(title_plot_with_key_string, title_plot_with_key_number)
+  testthat::expect_equal(title_plot_with_key_string, title_plot_with_key_number)
 
   # if provided, value of argument name is in title of plot at the end
 
-  expect_equal(
+  testthat::expect_equal(
     substr(title_plot_with_name,
       start = nchar(title_plot_with_name) - nchar(name_sp) + 1,
       stop = nchar(title_plot_with_name)
@@ -899,7 +897,7 @@ testthat::test_that("Test plot", {
 
   # if both provided, values of taxon_key and name are in title of plot as
   # taxon_key_name
-  expect_equal(
+  testthat::expect_equal(
     substr(title_plot_with_key_and_name,
       start = nchar(title_plot_with_key_and_name) - nchar(name_sp) - nchar(taxon_key),
       stop = nchar(title_plot_with_key_and_name)