test: update unit tests

Author: timcadman

tests/testthat/test-smk-corDS.R

@@ -718,6 +718,16 @@ test_that("simple corDS, casewise, some", {
     expect_equal(res$sums.of.squares[4], 58.0)
 })
 
+test_that("corDS throws error when object does not exist", {
+    expect_error(corDS("nonexistent_x", "nonexistent_y"), regexp = "does not exist")
+})
+
+test_that("corDS throws error when object is of invalid type", {
+    bad_input <- list(a = 1:3, b = 4:6)
+    y <- c(1.0, 2.0, 3.0)
+    expect_error(corDS("bad_input", "y"), regexp = "must be of type")
+})
+
 #
 # Done
 #

tests/testthat/test-smk-corTestDS.R

@@ -602,6 +602,16 @@ test_that("simple corTestDS, some, with na, spearman", {
     expect_equal(res$`Correlation test`$data.name[[1]], "x.var and y.var")
 })
 
+test_that("corTestDS throws error when object does not exist", {
+    expect_error(corTestDS("nonexistent_x", "nonexistent_y", "pearson", NULL, 0.95), regexp = "does not exist")
+})
+
+test_that("corTestDS throws error when object is not numeric or integer", {
+    bad_input <- c("a", "b", "c")
+    y <- c(1.0, 2.0, 3.0)
+    expect_error(corTestDS("bad_input", "y", "pearson", NULL, 0.95), regexp = "must be of type numeric or integer")
+})
+
 #
 # Done
 #

tests/testthat/test-smk-covDS.R

@@ -232,6 +232,16 @@ test_that("numeric covDS, pairwise.complete", {
     expect_true(is.na(res$errorMessage))
 })
 
+test_that("covDS throws error when object does not exist", {
+    expect_error(covDS("nonexistent_x", "nonexistent_y", "pairwise.complete"), regexp = "does not exist")
+})
+
+test_that("covDS throws error when object is of invalid type", {
+    bad_input <- list(a = 1:3, b = 4:6)
+    y <- c(1.0, 2.0, 3.0)
+    expect_error(covDS("bad_input", "y", "pairwise.complete"), regexp = "must be of type")
+})
+
 #
 # Done
 #

tests/testthat/test-smk-kurtosisDS1.R

@@ -69,6 +69,15 @@ test_that("simple kurtosisDS1, method 3", {
     expect_equal(res$ValidityMessage, "VALID ANALYSIS")
 })
 
+test_that("kurtosisDS1 throws error when object does not exist", {
+    expect_error(kurtosisDS1("nonexistent_object", 1), regexp = "does not exist")
+})
+
+test_that("kurtosisDS1 throws error when object is not numeric or integer", {
+    bad_input <- c("a", "b", "c")
+    expect_error(kurtosisDS1("bad_input", 1), regexp = "must be of type numeric or integer")
+})
+
 #
 # Done
 #

tests/testthat/test-smk-kurtosisDS2.R

@@ -40,6 +40,15 @@ test_that("simple kurtosisDS2", {
     expect_equal(res$ValidityMessage, "VALID ANALYSIS")
 })
 
+test_that("kurtosisDS2 throws error when object does not exist", {
+    expect_error(kurtosisDS2("nonexistent_object", 2.5), regexp = "does not exist")
+})
+
+test_that("kurtosisDS2 throws error when object is not numeric or integer", {
+    bad_input <- c("a", "b", "c")
+    expect_error(kurtosisDS2("bad_input", 2.5), regexp = "must be of type numeric or integer")
+})
+
 #
 # Done
 #

tests/testthat/test-smk-meanDS.R

@@ -25,7 +25,7 @@ set.standard.disclosure.settings()
 test_that("numeric meanDS", {
     input <- c(0.0, 1.0, 2.0, 3.0, 4.0)
 
-    res <- meanDS(input)
+    res <- meanDS("input")
 
     expect_length(res, 5)
     expect_equal(class(res), "list")
@@ -45,7 +45,7 @@ test_that("numeric meanDS", {
 test_that("numeric meanDS, with NA", {
     input <- c(0.0, NA, 2.0, NA, 4.0)
 
-    res <- meanDS(input)
+    res <- meanDS("input")
 
     expect_length(res, 5)
     expect_equal(class(res), "list")
@@ -65,7 +65,7 @@ test_that("numeric meanDS, with NA", {
 test_that("numeric meanDS, with all NA", {
     input <- c(NA, NA, NA, NA, NA)
 
-    res <- meanDS(input)
+    res <- meanDS("input")
 
     expect_length(res, 5)
     expect_equal(class(res), "list")
@@ -81,6 +81,15 @@ test_that("numeric meanDS, with all NA", {
     expect_equal(res$ValidityMessage, "VALID ANALYSIS")
 })
 
+test_that("meanDS throws error when object does not exist", {
+    expect_error(meanDS("nonexistent_object"), regexp = "does not exist")
+})
+
+test_that("meanDS throws error when object is not numeric or integer", {
+    bad_input <- c("a", "b", "c")
+    expect_error(meanDS("bad_input"), regexp = "must be of type numeric or integer")
+})
+
 #
 # Done
 #

tests/testthat/test-smk-meanSdGpDS.R

@@ -0,0 +1,62 @@
+#-------------------------------------------------------------------------------
+# Copyright (c) 2019-2022 University of Newcastle upon Tyne. All rights reserved.
+# Copyright (c) 2022-2025 Arjuna Technologies, Newcastle upon Tyne. All rights reserved.
+#
+# This program and the accompanying materials
+# are made available under the terms of the GNU Public License v3.0.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#-------------------------------------------------------------------------------
+
+#
+# Set up
+#
+
+# context("meanSdGpDS::smk::setup")
+
+set.standard.disclosure.settings()
+
+#
+# Tests
+#
+
+# context("meanSdGpDS::smk::numeric by factor")
+test_that("simple meanSdGpDS, numeric by factor", {
+    x_var <- c(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0)
+    index_var <- as.factor(c("A", "A", "A", "A", "A", "B", "B", "B", "B", "B"))
+
+    res <- meanSdGpDS("x_var", "index_var")
+
+    expect_equal(class(res), "list")
+    expect_true(res$Table_valid)
+    expect_equal(res$Nvalid, 10)
+    expect_equal(res$Nmissing, 0)
+    expect_equal(res$Ntotal, 10)
+    expect_equal(res$Mean_gp[["A"]], 3.0)
+    expect_equal(res$Mean_gp[["B"]], 8.0)
+})
+
+test_that("meanSdGpDS throws error when X does not exist", {
+    index_var <- as.factor(c("A", "A", "B", "B"))
+    expect_error(meanSdGpDS("nonexistent_x", "index_var"), regexp = "does not exist")
+})
+
+test_that("meanSdGpDS throws error when INDEX does not exist", {
+    x_var <- c(1.0, 2.0, 3.0, 4.0)
+    expect_error(meanSdGpDS("x_var", "nonexistent_index"), regexp = "does not exist")
+})
+
+test_that("meanSdGpDS throws error when X is not numeric or integer", {
+    bad_x <- c("a", "b", "c", "d")
+    index_var <- as.factor(c("A", "A", "B", "B"))
+    expect_error(meanSdGpDS("bad_x", "index_var"), regexp = "must be of type numeric or integer")
+})
+
+#
+# Done
+#
+
+# context("meanSdGpDS::smk::shutdown")
+
+# context("meanSdGpDS::smk::done")

tests/testthat/test-smk-quantileMeanDS.R

@@ -23,7 +23,7 @@
 test_that("numeric quantileMeanDS", {
     input <- c(0.0, 1.0, 2.0, 3.0, 4.0)
 
-    res <- quantileMeanDS(input)
+    res <- quantileMeanDS("input")
 
     expect_length(res, 8)
     expect_equal(class(res), "numeric")
@@ -54,7 +54,7 @@ test_that("numeric quantileMeanDS", {
 test_that("numeric quantileMeanDS, with NA", {
     input <- c(0.0, NA, 2.0, NA, 4.0)
 
-    res <- quantileMeanDS(input)
+    res <- quantileMeanDS("input")
 
     expect_length(res, 8)
     expect_equal(class(res), "numeric")
@@ -81,6 +81,15 @@ test_that("numeric quantileMeanDS, with NA", {
     expect_equal(res.names[[8]], "Mean")
 })
 
+test_that("quantileMeanDS throws error when object does not exist", {
+    expect_error(quantileMeanDS("nonexistent_object"), regexp = "does not exist")
+})
+
+test_that("quantileMeanDS throws error when object is not numeric or integer", {
+    bad_input <- c("a", "b", "c")
+    expect_error(quantileMeanDS("bad_input"), regexp = "must be of type numeric or integer")
+})
+
 #
 # Done
 #

tests/testthat/test-smk-skewnessDS1.R

@@ -69,6 +69,15 @@ test_that("simple skewnessDS1, method 3", {
     expect_equal(res$ValidityMessage, "VALID ANALYSIS")
 })
 
+test_that("skewnessDS1 throws error when object does not exist", {
+    expect_error(skewnessDS1("nonexistent_object", 1), regexp = "does not exist")
+})
+
+test_that("skewnessDS1 throws error when object is not numeric or integer", {
+    bad_input <- c("a", "b", "c")
+    expect_error(skewnessDS1("bad_input", 1), regexp = "must be of type numeric or integer")
+})
+
 #
 # Done
 #

tests/testthat/test-smk-skewnessDS2.R

@@ -40,6 +40,15 @@ test_that("simple skewnessDS2", {
     expect_equal(res$ValidityMessage, "VALID ANALYSIS")
 })
 
+test_that("skewnessDS2 throws error when object does not exist", {
+    expect_error(skewnessDS2("nonexistent_object", 2.5), regexp = "does not exist")
+})
+
+test_that("skewnessDS2 throws error when object is not numeric or integer", {
+    bad_input <- c("a", "b", "c")
+    expect_error(skewnessDS2("bad_input", 2.5), regexp = "must be of type numeric or integer")
+})
+
 #
 # Done
 #