Gemini: more tests for coverage

Author: MichaelChirico

tests/testthat/test-integer64.R

@@ -59,6 +59,15 @@ test_that("integer64 coercion to/from other types works for NA", {
   expect_identical(as.integer64(NA_integer_), NA_integer64_)
   expect_identical(as.integer64(NA_real_), NA_integer64_)
   expect_identical(as.integer64(NA_character_), NA_integer64_)
+
+  # Boundary and warning conditions for conversions
+  expect_warning(as.double(as.integer64("18014398509481984")), "integer precision lost while converting to double")
+  expect_warning(as.integer(as.integer64(2)^33), "NAs produced by integer overflow")
+  expect_warning(
+    as.integer64(structure(paste(rep("1", 65), collapse=""), class="bitstring")),
+    "bitstrings longer than 64 bytes converted to NA"
+  )
+  expect_identical(mean(as.integer64(1:5), na.rm = FALSE), as.integer64(3L))
 })
 
 test_that("integer64 coercion to/from factor types works", {

tests/testthat/test-matrix64.R

@@ -274,13 +274,41 @@ test_that("matrix multiplication", {
     expect_identical(matrix(x, 1L)%*%matrix(x, ncol=1L), matrix(NA_integer64_, 1L, 1L)),
     "NAs produced by integer64 overflow"
   )
+  expect_warning(
+    expect_identical(matrix(4e9, 1L, 1L)%*%matrix(x, ncol=1L), matrix(NA_integer64_, 1L, 1L)),
+    "NAs produced by integer64 overflow"
+  )
+  expect_warning(
+    expect_identical(matrix(x, 1L)%*%matrix(4e9, ncol=1L), matrix(NA_integer64_, 1L, 1L)),
+    "NAs produced by integer64 overflow"
+  )
 
   # warning in summation part
   x = rep_len(as.integer64("3000000000"), 2L) # x**2 < 2^63, but 2 * x**2 > 2^63
   expect_warning(
     expect_identical(matrix(x, 1L)%*%matrix(x, ncol=1L), matrix(NA_integer64_, 1L, 1L)),
     "NAs produced by integer64 overflow"
   )
+  expect_warning(
+    expect_identical(matrix(c(3e9, 3e9), 1L, 2L)%*%matrix(x, ncol=1L), matrix(NA_integer64_, 1L, 1L)),
+    "NAs produced by integer64 overflow"
+  )
+  expect_warning(
+    expect_identical(matrix(x, 1L)%*%matrix(c(3e9, 3e9), ncol=1L), matrix(NA_integer64_, 1L, 1L)),
+    "NAs produced by integer64 overflow"
+  )
+
+  # NA propagation in matrix multiplication
+  m_na64 = matrix(c(as.integer64(1L), NA_integer64_), 1L, 2L)
+  m_val64 = matrix(as.integer64(c(1L, 1L)), 2L, 1L)
+  m_na_dbl = matrix(c(1.0, NA_real_), 1L, 2L)
+  m_val_dbl = matrix(c(1.0, 1.0), 2L, 1L)
+
+  expect_no_warning(expect_identical(m_na64 %*% m_val64, matrix(NA_integer64_, 1L, 1L)))
+  expect_no_warning(expect_identical(m_na_dbl %*% m_val64, matrix(NA_integer64_, 1L, 1L)))
+  expect_no_warning(expect_identical(m_na64 %*% m_val_dbl, matrix(NA_integer64_, 1L, 1L)))
+  expect_no_warning(expect_identical(t(m_val_dbl) %*% matrix(c(as.integer64(1L), NA_integer64_), 2L, 1L), matrix(NA_integer64_, 1L, 1L)))
+  expect_no_warning(expect_identical(t(m_val64) %*% matrix(c(1.0, NA_real_), 2L, 1L), matrix(NA_integer64_, 1L, 1L)))
 
 })
 

tests/testthat/test-ops64.R

@@ -223,11 +223,22 @@ test_that("Overflow edge cases for arithmetic and summary functions", {
   expect_no_warning(expect_identical(NA_integer64_ * 2L, NA_integer64_))
   expect_no_warning(expect_identical(2L * NA_integer64_, NA_integer64_))
   expect_no_warning(expect_identical(sum(NA_integer64_), NA_integer64_))
+  expect_no_warning(expect_identical(sum(c(as.integer64(1L), NA_integer64_), na.rm = FALSE), NA_integer64_))
+  expect_no_warning(expect_identical(sum(c(as.integer64(1:2), NA_integer64_), na.rm = TRUE), as.integer64(3L)))
+  expect_warning(expect_identical(sum(c(max_val, as.integer64(1L), NA_integer64_), na.rm = TRUE), NA_integer64_), overflow_warning)
   expect_no_warning(expect_identical(prod(NA_integer64_), NA_integer64_))
+  expect_no_warning(expect_identical(prod(c(as.integer64(1L), NA_integer64_), na.rm = FALSE), NA_integer64_))
+  expect_no_warning(expect_identical(prod(c(as.integer64(2:3), NA_integer64_), na.rm = TRUE), as.integer64(6L)))
+  expect_warning(expect_identical(prod(c(max_val, as.integer64(2L), NA_integer64_), na.rm = TRUE), NA_integer64_), overflow_warning)
   expect_no_warning(expect_identical(cumsum(c(NA_integer64_, 1L)), c(NA_integer64_, NA_integer64_)))
   expect_no_warning(expect_identical(cumprod(c(NA_integer64_, 1L)), c(NA_integer64_, NA_integer64_)))
   expect_no_warning(expect_identical(diff(c(NA_integer64_, as.integer64(1L))), NA_integer64_))
   expect_no_warning(expect_identical(diff(c(as.integer64(1L), NA_integer64_)), NA_integer64_))
+
+  # Vectorized operations with partial overflow
+  expect_warning(expect_identical(c(max_val, as.integer64(1L)) + 1L, c(NA_integer64_, as.integer64(2L))), overflow_warning)
+  expect_warning(expect_identical(c(min_val, as.integer64(1L)) - 1L, c(NA_integer64_, as.integer64(0L))), overflow_warning)
+  expect_warning(expect_identical(c(max_val, as.integer64(1L)) * 2L, c(NA_integer64_, as.integer64(2L))), overflow_warning)
 })
 
 test_that("Logical operators", {