diff --git a/tests/testthat/setup.R b/tests/testthat/setup.R
index 305e6e1..bb9300b 100644
--- a/tests/testthat/setup.R
+++ b/tests/testthat/setup.R
@@ -3,10 +3,17 @@ tmpdir <- testthat::test_path("_TEMP")
 if (!dir.exists(tmpdir)) dir.create(tmpdir)
 tmpdir <- normalizePath(tmpdir, mustWork = TRUE)
 
-common_test <- function(mat, obj, actual_path, seed_fn, name) {
+common_test <- function(
+    obj, actual_path, ..., mat = NULL,
+    seed_fn, name, 
+    skip_multiplication = FALSE) {
+    # for TransformedMatrix, it often contain float values
+    transformed <- methods::is(seed_fn(obj), "BPCellsTransformedSeed")
     seed_class <- sprintf("BPCells%sSeed", name)
     seed_name <- sprintf("BPCellsSeed class of `%s`", name)
     matrix_name <- sprintf("BPCellsMatrix class of `%s`", name)
+    mat <- mat %||% as.matrix(obj)
+    cli::cli_inform("{.field BPCells{name}Seed} works as expected")
     testthat::test_that(
         sprintf("`BPCells%sSeed()` works as expected", name),
         {
@@ -21,58 +28,145 @@ common_test <- function(mat, obj, actual_path, seed_fn, name) {
         }
     )
 
+    cli::cli_inform("{.field subset} {seed_name} works as expected")
     testthat::test_that(
         sprintf("`subset()` %s works as expected", seed_name),
         {
             seed <- seed_fn(obj)
             testthat::expect_s4_class(seed[1:10, ], "BPCellsSeed")
+            testthat::expect_identical(
+                rownames(seed[1:10, ]),
+                rownames(seed)[1:10]
+            )
+            testthat::expect_identical(colnames(seed[1:10, ]), colnames(seed))
             testthat::expect_equal(as.matrix(seed[1:10, ]), mat[1:10, ])
             testthat::expect_s4_class(seed[, 1:10], "BPCellsSeed")
+            testthat::expect_identical(
+                colnames(seed[, 1:10]),
+                colnames(seed)[1:10]
+            )
+            testthat::expect_identical(rownames(seed[, 1:10]), rownames(seed))
             testthat::expect_equal(as.matrix(seed[, 1:10]), mat[, 1:10])
-            testthat::expect_s4_class(seed[1:10, 1:10], "BPCellsSeed")
-            testthat::expect_equal(as.matrix(seed[1:10, 1:10]), mat[1:10, 1:10])
+            seed2 <- seed[1:10, 1:10]
+            testthat::expect_s4_class(seed2, "BPCellsSeed")
+            testthat::expect_identical(rownames(seed2), rownames(seed)[1:10])
+            testthat::expect_identical(colnames(seed2), colnames(seed)[1:10])
+            testthat::expect_equal(as.matrix(seed2), mat[1:10, 1:10])
         }
     )
 
+
+    cli::cli_inform("{.field subset} {matrix_name} works as expected")
     testthat::test_that(
         sprintf("`subset()` %s works as expected", matrix_name),
         {
             obj <- BPCellsArray(obj)
             testthat::expect_s4_class(obj[1:10, ], "BPCellsMatrix")
-            testthat::expect_equal(as.matrix(obj[1:10, ]), mat[1:10, ])
+            testthat::expect_identical(
+                rownames(obj[1:10, ]),
+                rownames(obj)[1:10]
+            )
+            testthat::expect_identical(colnames(obj[1:10, ]), colnames(obj))
             testthat::expect_s4_class(obj[, 1:10], "BPCellsMatrix")
+            testthat::expect_identical(
+                colnames(obj[, 1:10]),
+                colnames(obj)[1:10]
+            )
+            testthat::expect_identical(rownames(obj[, 1:10]), rownames(obj))
+            obj2 <- obj[1:10, 1:10]
+            testthat::expect_s4_class(obj2, "BPCellsMatrix")
+            testthat::expect_identical(rownames(obj2), rownames(obj)[1:10])
+            testthat::expect_identical(colnames(obj2), colnames(obj)[1:10])
+
+            testthat::skip_if(transformed)
+            testthat::expect_equal(as.matrix(obj[1:10, ]), mat[1:10, ])
             testthat::expect_equal(as.matrix(obj[, 1:10]), mat[, 1:10])
-            testthat::expect_s4_class(obj[1:10, 1:10], "BPCellsMatrix")
-            testthat::expect_equal(as.matrix(obj[1:10, 1:10]), mat[1:10, 1:10])
+            testthat::expect_equal(as.matrix(obj2), mat[1:10, 1:10])
+        }
+    )
+
+    pseudo_mat <- matrix(sample(mat, length(mat)), nrow = nrow(mat))
+    cli::cli_inform("{.field [<-} {seed_name} works as expected")
+    testthat::test_that(
+        sprintf("`[<-()` %s works as expected", seed_name),
+        {
+            seed <- seed_fn(obj)
+            seed[1:10, ] <- pseudo_mat[1:10, ]
+            mat[1:10, ] <- pseudo_mat[1:10, ]
+            testthat::expect_s4_class(seed, "BPCellsSeed")
+            testthat::expect_equal(as.matrix(seed), mat)
+
+            seed[, 1:10] <- pseudo_mat[, 1:10]
+            mat[, 1:10] <- pseudo_mat[, 1:10]
+            testthat::expect_s4_class(seed, "BPCellsSeed")
+            testthat::expect_equal(as.matrix(seed), mat)
+
+            seed[1:10, 1:10] <- pseudo_mat[1:10, 1:10]
+            mat[1:10, 1:10] <- pseudo_mat[1:10, 1:10]
+            testthat::expect_s4_class(seed, "BPCellsSeed")
+            testthat::expect_equal(as.matrix(seed), mat)
+
+            testthat::expect_identical(storage_mode(seed), "double")
+
+            seed[1:10, mode = "integer"] <- pseudo_mat[1:10, ]
+            mat[1:10, ] <- pseudo_mat[1:10, ]
+            storage.mode(mat) <- "integer"
+            testthat::expect_s4_class(seed, "BPCellsSeed")
+            testthat::expect_identical(storage_mode(seed), "uint32_t")
+            testthat::expect_equal(as.matrix(seed), mat)
+        }
+    )
+    cli::cli_inform("{.field [<-} {matrix_name} works as expected")
+    testthat::test_that(
+        sprintf("`[<-()` %s works as expected", matrix_name),
+        {
+            obj <- BPCellsArray(obj)
+            obj[1:10, ] <- pseudo_mat[1:10, ]
+            mat[1:10, ] <- pseudo_mat[1:10, ]
+            testthat::expect_s4_class(obj, "BPCellsMatrix")
+            testthat::expect_equal(as.matrix(obj), mat)
+
+            obj[, 1:10] <- pseudo_mat[, 1:10]
+            mat[, 1:10] <- pseudo_mat[, 1:10]
+            testthat::expect_s4_class(obj, "BPCellsMatrix")
+            testthat::expect_equal(as.matrix(obj), mat)
+
+            obj[1:10, 1:10] <- pseudo_mat[1:10, 1:10]
+            mat[1:10, 1:10] <- pseudo_mat[1:10, 1:10]
+            testthat::expect_s4_class(obj, "BPCellsMatrix")
+            testthat::expect_equal(as.matrix(obj), mat)
         }
     )
 
+    cli::cli_inform("{.field convert_mode} {seed_name} works as expected")
     testthat::test_that(
-        sprintf("`convert_type()` %s works as expected", seed_name),
+        sprintf("`convert_mode()` %s works as expected", seed_name),
         {
             seed <- seed_fn(obj)
-            float_seed <- convert_type(seed, "numeric")
+            float_seed <- convert_mode(seed, "float")
             testthat::expect_s4_class(float_seed, "BPCellsConvertSeed")
-            testthat::expect_identical(type(float_seed), "double")
-            integer_seed <- convert_type(float_seed, "integer")
+            testthat::expect_identical(storage_mode(float_seed), "float")
+            integer_seed <- convert_mode(float_seed, "uint32_t")
             testthat::expect_s4_class(integer_seed, "BPCellsConvertSeed")
-            testthat::expect_identical(type(integer_seed), "integer")
+            testthat::expect_identical(storage_mode(integer_seed), "uint32_t")
         }
     )
 
+    cli::cli_inform("{.field convert_mode} {matrix_name} works as expected")
     testthat::test_that(
-        sprintf("`convert_type()` %s works as expected", matrix_name),
+        sprintf("`convert_mode()` %s works as expected", matrix_name),
         {
             obj <- BPCellsArray(obj)
-            float_obj <- convert_type(obj, "numeric")
+            float_obj <- convert_mode(obj, "float")
             testthat::expect_s4_class(float_obj, "BPCellsMatrix")
-            testthat::expect_identical(type(float_obj), "double")
-            integer_obj <- convert_type(float_obj, "integer")
+            testthat::expect_identical(storage_mode(float_obj), "float")
+            integer_obj <- convert_mode(float_obj, "uint32_t")
             testthat::expect_s4_class(integer_obj, "BPCellsMatrix")
-            testthat::expect_identical(type(integer_obj), "integer")
+            testthat::expect_identical(storage_mode(integer_obj), "uint32_t")
         }
     )
 
+    cli::cli_inform("{.field t} BPCells{name} works as expected")
     testthat::test_that(
         sprintf("`t()` BPCells%s works as expected", name),
         {
@@ -86,6 +180,7 @@ common_test <- function(mat, obj, actual_path, seed_fn, name) {
         }
     )
 
+    cli::cli_inform("{.field dimnames<-} BPCells{name} works as expected")
     testthat::test_that(
         sprintf("`dimnames<-()` BPCells%s works as expected", name),
         {
@@ -106,6 +201,7 @@ common_test <- function(mat, obj, actual_path, seed_fn, name) {
         }
     )
 
+    cli::cli_inform("{.field rownames<-} BPCells{name} works as expected")
     testthat::test_that(
         sprintf("`rownames<-()` BPCells%s works as expected", name),
         {
@@ -132,6 +228,7 @@ common_test <- function(mat, obj, actual_path, seed_fn, name) {
         }
     )
 
+    cli::cli_inform("{.field colnames<-} BPCells{name} works as expected")
     testthat::test_that(
         sprintf("`colnames<-()` BPCells%s works as expected", name),
         {
@@ -163,10 +260,14 @@ common_test <- function(mat, obj, actual_path, seed_fn, name) {
             testthat::expect_null(colnames(obj))
         }
     )
-
+    cli::cli_inform("{.field %*%} BPCells{name} works as expected")
     testthat::test_that(
         sprintf("`%%*%%` BPCells%s works as expected", name),
         {
+            testthat::skip_if(
+                skip_multiplication,
+                "Skipping for TransformedMatrix"
+            )
             seed <- seed_fn(obj)
             testthat::expect_s4_class(seed, seed_class)
             testthat::expect_warning(temp <- seed %*% t(seed))
@@ -186,6 +287,7 @@ common_test <- function(mat, obj, actual_path, seed_fn, name) {
         }
     )
 
+    cli::cli_inform("{.field rbind} {seed_name} works as expected")
     testthat::test_that(
         sprintf("`rbind()` %s works as expected", seed_name),
         {
@@ -226,21 +328,23 @@ common_test <- function(mat, obj, actual_path, seed_fn, name) {
         }
     )
 
+    cli::cli_inform("{.field rbind} {matrix_name} works as expected")
     testthat::test_that(
         sprintf("`rbind()` %s works as expected", matrix_name),
         {
             obj <- BPCellsArray(obj)
             testthat::expect_s4_class(obj, "BPCellsMatrix")
             testthat::expect_s4_class(rbind2(obj, obj), "BPCellsMatrix")
-            testthat::expect_equal(as.matrix(rbind2(obj, obj)), rbind(mat, mat))
             testthat::expect_s4_class(rbind(obj, obj), "BPCellsMatrix")
-            testthat::expect_equal(as.matrix(rbind(obj, obj)), rbind(mat, mat))
             testthat::expect_s4_class(arbind(obj, obj), "BPCellsMatrix")
-            testthat::expect_equal(as.matrix(arbind(obj, obj)), rbind(mat, mat))
             testthat::expect_s4_class(
                 bindROWS(obj, list(obj)),
                 "BPCellsMatrix"
             )
+            testthat::skip_if(transformed)
+            testthat::expect_equal(as.matrix(rbind2(obj, obj)), rbind(mat, mat))
+            testthat::expect_equal(as.matrix(rbind(obj, obj)), rbind(mat, mat))
+            testthat::expect_equal(as.matrix(arbind(obj, obj)), rbind(mat, mat))
             testthat::expect_equal(
                 as.matrix(bindROWS(obj, list(obj))),
                 rbind(mat, mat)
@@ -248,6 +352,7 @@ common_test <- function(mat, obj, actual_path, seed_fn, name) {
         }
     )
 
+    cli::cli_inform("{.field cbind} {seed_name} works as expected")
     testthat::test_that(
         sprintf("`cbind()` %s works as expected", seed_name),
         {
@@ -257,30 +362,31 @@ common_test <- function(mat, obj, actual_path, seed_fn, name) {
                 cbind2(seed, seed),
                 "BPCellsColBindMatrixSeed"
             )
-            testthat::expect_equal(
-                as.matrix(cbind2(seed, seed)),
-                cbind(mat, mat)
-            )
             testthat::expect_s4_class(
                 cbind(seed, seed),
                 "BPCellsColBindMatrixSeed"
             )
-            testthat::expect_equal(
-                as.matrix(cbind(seed, seed)),
-                cbind(mat, mat)
-            )
             testthat::expect_s4_class(
                 acbind(seed, seed),
                 "BPCellsColBindMatrixSeed"
             )
-            testthat::expect_equal(
-                as.matrix(acbind(seed, seed)),
-                cbind(mat, mat)
-            )
             testthat::expect_s4_class(
                 bindCOLS(seed, list(seed)),
                 "BPCellsColBindMatrixSeed"
             )
+            testthat::skip_if(transformed)
+            testthat::expect_equal(
+                as.matrix(cbind2(seed, seed)),
+                cbind(mat, mat)
+            )
+            testthat::expect_equal(
+                as.matrix(cbind(seed, seed)),
+                cbind(mat, mat)
+            )
+            testthat::expect_equal(
+                as.matrix(acbind(seed, seed)),
+                cbind(mat, mat)
+            )
             testthat::expect_equal(
                 as.matrix(bindCOLS(seed, list(seed))),
                 cbind(mat, mat)
@@ -288,6 +394,7 @@ common_test <- function(mat, obj, actual_path, seed_fn, name) {
         }
     )
 
+    cli::cli_inform("{.field cbind} {matrix_name} works as expected")
     testthat::test_that(
         sprintf("`cbind()` %s works as expected", matrix_name),
         {
@@ -310,7 +417,7 @@ common_test <- function(mat, obj, actual_path, seed_fn, name) {
         }
     )
 
-
+    cli::cli_inform("{.field +} {seed_name} works as expected")
     testthat::test_that(
         sprintf("`+` %s works as expected", seed_name),
         {
@@ -356,6 +463,7 @@ common_test <- function(mat, obj, actual_path, seed_fn, name) {
         }
     )
 
+    cli::cli_inform("{.field +} {matrix_name} works as expected")
     testthat::test_that(
         sprintf("`+` %s works as expected", matrix_name),
         {
@@ -401,6 +509,7 @@ common_test <- function(mat, obj, actual_path, seed_fn, name) {
         }
     )
 
+    cli::cli_inform("{.field -} {seed_name} works as expected")
     testthat::test_that(
         sprintf("`-` %s works as expected", seed_name),
         {
@@ -446,6 +555,7 @@ common_test <- function(mat, obj, actual_path, seed_fn, name) {
         }
     )
 
+    cli::cli_inform("{.field -} {matrix_name} works as expected")
     testthat::test_that(
         sprintf("`-` %s works as expected", matrix_name),
         {
@@ -491,7 +601,7 @@ common_test <- function(mat, obj, actual_path, seed_fn, name) {
         }
     )
 
-
+    cli::cli_inform("{.field *} {seed_name} works as expected")
     testthat::test_that(
         sprintf("`*` %s works as expected", seed_name),
         {
@@ -537,6 +647,7 @@ common_test <- function(mat, obj, actual_path, seed_fn, name) {
         }
     )
 
+    cli::cli_inform("{.field *} {matrix_name} works as expected")
     testthat::test_that(
         sprintf("`*` %s works as expected", matrix_name),
         {
@@ -582,6 +693,7 @@ common_test <- function(mat, obj, actual_path, seed_fn, name) {
         }
     )
 
+    cli::cli_inform("{.field /} {seed_name} works as expected")
     testthat::test_that(
         sprintf("`/` %s works as expected", seed_name),
         {
@@ -611,6 +723,7 @@ common_test <- function(mat, obj, actual_path, seed_fn, name) {
         }
     )
 
+    cli::cli_inform("{.field /} {matrix_name} works as expected")
     testthat::test_that(
         sprintf("`/` %s works as expected", matrix_name),
         {
diff --git a/tests/testthat/test_Convert.R b/tests/testthat/test_Convert.R
index 9925fb9..d908f40 100644
--- a/tests/testthat/test_Convert.R
+++ b/tests/testthat/test_Convert.R
@@ -1,9 +1,14 @@
-mat <- mock_matrix(2000, 200)
+mat <- mock_matrix(20, 20)
 path <- normalizePath(tempfile(tmpdir = tmpdir), mustWork = FALSE)
 obj <- BPCells::write_matrix_dir(mat = as(mat, "dgCMatrix"), dir = path)
 obj <- BPCells::convert_matrix_type(obj, "uint32_t")
 
-common_test(mat, obj, path, BPCellsConvertSeed, "Convert")
+common_test(
+    obj, path,
+    mat = mat, 
+    seed_fn = BPCellsConvertSeed, 
+    name = "Convert"
+)
 testthat::test_that("`subset()` BPCellsConvertSeed object works as expected", {
     seed <- BPCellsConvertSeed(obj)
     testthat::expect_s4_class(seed[1:10, ], "BPCellsConvertSeed")
diff --git a/tests/testthat/test_Dir.R b/tests/testthat/test_Dir.R
index 611e73c..52a2a3a 100644
--- a/tests/testthat/test_Dir.R
+++ b/tests/testthat/test_Dir.R
@@ -1,9 +1,13 @@
-mat <- mock_matrix(2000, 200)
+mat <- mock_matrix(20, 20)
 path <- normalizePath(tempfile(tmpdir = tmpdir), mustWork = FALSE)
 obj <- BPCells::write_matrix_dir(mat = as(mat, "dgCMatrix"), dir = path)
 
-
-common_test(mat, obj, path, BPCellsDirSeed, "Dir")
+common_test(
+    obj, path,
+    mat = mat, 
+    seed_fn = BPCellsDirSeed, 
+    name = "Dir"
+)
 testthat::test_that("`subset()` BPCellsDirSeed object works as expected", {
     seed <- BPCellsDirSeed(obj)
     testthat::expect_s4_class(seed[1:10, ], "BPCellsSubsetSeed")
diff --git a/tests/testthat/test_HDF5.R b/tests/testthat/test_HDF5.R
index c9be838..eb16500 100644
--- a/tests/testthat/test_HDF5.R
+++ b/tests/testthat/test_HDF5.R
@@ -1,11 +1,16 @@
-mat <- mock_matrix(2000, 200)
+mat <- mock_matrix(20, 20)
 path <- normalizePath(tempfile(tmpdir = tmpdir), mustWork = FALSE)
 obj <- BPCells::write_matrix_hdf5(
     mat = as(mat, "dgCMatrix"),
     path = path, group = "BPCells"
 )
 
-common_test(mat, obj, path, BPCellsHDF5Seed, "HDF5")
+common_test(
+    obj, path,
+    mat = mat, 
+    seed_fn = BPCellsHDF5Seed, 
+    name = "HDF5"
+)
 testthat::test_that("`subset()` BPCellsHDF5Seed object works as expected", {
     seed <- BPCellsHDF5Seed(obj)
     testthat::expect_s4_class(seed[1:10, ], "BPCellsSubsetSeed")
diff --git a/tests/testthat/test_Mask.R b/tests/testthat/test_Mask.R
index d17ba39..eae36a5 100644
--- a/tests/testthat/test_Mask.R
+++ b/tests/testthat/test_Mask.R
@@ -1,4 +1,4 @@
-mat <- mock_matrix(2000, 200)
+mat <- mock_matrix(20, 20)
 path <- normalizePath(tempfile(tmpdir = tmpdir), mustWork = FALSE)
 obj <- BPCells::write_matrix_dir(mat = as(mat, "dgCMatrix"), dir = path)
 mask <- matrix(
@@ -12,7 +12,12 @@ mat[mask > 0L] <- 0L
 mask <- methods::as(mask, "dgCMatrix")
 obj <- BPCells:::mask_matrix(obj, mask)
 
-common_test(mat, obj, path, BPCellsMaskSeed, "Mask")
+common_test(
+    obj, path,
+    mat = mat, 
+    seed_fn = BPCellsMaskSeed, 
+    name = "Mask"
+)
 testthat::test_that("`subset()` BPCellsMaskSeed object works as expected", {
     seed <- BPCellsMaskSeed(obj)
     testthat::expect_s4_class(seed[1:10, ], "BPCellsSubsetSeed")
diff --git a/tests/testthat/test_Mem.R b/tests/testthat/test_Mem.R
index f1d5877..aba056c 100644
--- a/tests/testthat/test_Mem.R
+++ b/tests/testthat/test_Mem.R
@@ -1,14 +1,24 @@
-mat <- mock_matrix(2000, 200)
+mat <- mock_matrix(20, 20)
 sparse_mat <- as(mat, "dgCMatrix")
 path <- character()
 
 # Packed Memory object
 obj <- BPCells::write_matrix_memory(mat = sparse_mat)
-common_test(mat, obj, path, BPCellsMemSeed, "Mem")
+common_test(
+    obj, path,
+    mat = mat, 
+    seed_fn = BPCellsMemSeed, 
+    name = "Mem"
+)
 
 # Unpacked Memory object
 obj <- BPCells::write_matrix_memory(mat = sparse_mat, FALSE)
-common_test(mat, obj, path, BPCellsMemSeed, "Mem")
+common_test(
+    obj, path,
+    mat = mat, 
+    seed_fn = BPCellsMemSeed, 
+    name = "Mem"
+)
 
 testthat::test_that("`subset()` BPCellsMemSeed object works as expected", {
     seed <- BPCellsMemSeed(obj)
diff --git a/tests/testthat/test_Multiply.R b/tests/testthat/test_Multiply.R
index c0b9cb4..dd1c2b6 100644
--- a/tests/testthat/test_Multiply.R
+++ b/tests/testthat/test_Multiply.R
@@ -1,4 +1,4 @@
-mat1 <- mock_matrix(200, 200)
+mat1 <- mock_matrix(20, 20)
 mat2 <- mock_matrix(ncol(mat1), 100)
 path <- normalizePath(
     c(tempfile(tmpdir = tmpdir), tempfile(tmpdir = tmpdir)),
@@ -9,7 +9,12 @@ obj2 <- BPCells::write_matrix_dir(mat = as(mat2, "dgCMatrix"), dir = path[2L])
 obj <- obj %*% obj2
 mat <- mat1 %*% mat2
 
-common_test(mat, obj, path, BPCellsMultiplySeed, "Multiply")
+common_test(
+    obj, path,
+    mat = mat, 
+    seed_fn = BPCellsMultiplySeed, 
+    name = "Multiply"
+)
 testthat::test_that("`subset()` BPCellsMultiplySeed object works as expected", {
     seed <- BPCellsMultiplySeed(obj)
     testthat::expect_s4_class(seed[1:10, ], "BPCellsMultiplySeed")
diff --git a/tests/testthat/test_RankTransform.R b/tests/testthat/test_RankTransform.R
index cb4a253..1cc9f14 100644
--- a/tests/testthat/test_RankTransform.R
+++ b/tests/testthat/test_RankTransform.R
@@ -1,4 +1,4 @@
-mat <- mock_matrix(2000, 200)
+mat <- mock_matrix(20, 20)
 path <- normalizePath(tempfile(tmpdir = tmpdir), mustWork = FALSE)
 obj <- BPCells::write_matrix_dir(mat = as(mat, "dgCMatrix"), dir = path)
 obj <- BPCells:::rank_transform(obj, "col")
@@ -6,8 +6,11 @@ obj <- BPCells:::rank_transform(obj, "col")
 #     ties.method = "average",
 #     preserveShape = TRUE
 # )
-# common_test(mat, obj, path, BPCellsRankTransformSeed, "RankTransform")
-
+common_test(
+    obj, path,
+    seed_fn = BPCellsRankTransformSeed,
+    name = "RankTransform"
+)
 testthat::test_that(
     "`subset()` BPCellsRankTransformSeed object works as expected",
     {
diff --git a/tests/testthat/test_RenameDims.R b/tests/testthat/test_RenameDims.R
index 46ce51d..6808475 100644
--- a/tests/testthat/test_RenameDims.R
+++ b/tests/testthat/test_RenameDims.R
@@ -1,16 +1,21 @@
-mat <- mock_matrix(2000, 200)
+mat <- mock_matrix(20, 20)
 path <- normalizePath(tempfile(tmpdir = tmpdir), mustWork = FALSE)
 obj <- BPCells::write_matrix_dir(mat = as(mat, "dgCMatrix"), dir = path)
 dimnames(obj) <- list(
-    paste0("G", seq_len(2000L)),
-    paste0("C", seq_len(200))
+    paste0("G", seq_len(nrow(obj))),
+    paste0("C", seq_len(ncol(obj)))
 )
 dimnames(mat) <- list(
-    paste0("G", seq_len(2000L)),
-    paste0("C", seq_len(200))
+    paste0("G", seq_len(nrow(obj))),
+    paste0("C", seq_len(ncol(obj)))
 )
 
-common_test(mat, obj, path, BPCellsRenameDimsSeed, "RenameDims")
+common_test(
+    obj, path,
+    mat = mat, 
+    seed_fn = BPCellsRenameDimsSeed, 
+    name = "RenameDims"
+)
 testthat::test_that(
     "`subset()` BPCellsRenameDimsSeed object works as expected",
     {
diff --git a/tests/testthat/test_Subset.R b/tests/testthat/test_Subset.R
index e9eec4d..3a335e7 100644
--- a/tests/testthat/test_Subset.R
+++ b/tests/testthat/test_Subset.R
@@ -1,10 +1,15 @@
-mat <- mock_matrix(2000, 200)
+mat <- mock_matrix(200, 40)
 path <- normalizePath(tempfile(tmpdir = tmpdir), mustWork = FALSE)
 obj <- BPCells::write_matrix_dir(mat = as(mat, "dgCMatrix"), dir = path)
-obj <- obj[1:1000L, 1:100]
-mat <- mat[1:1000L, 1:100]
+obj <- obj[1:100L, 1:20]
+mat <- mat[1:100L, 1:20]
 
-common_test(mat, obj, path, BPCellsSubsetSeed, "Subset")
+common_test(
+    obj, path,
+    mat = mat, 
+    seed_fn = BPCellsSubsetSeed, 
+    name = "Subset"
+)
 testthat::test_that("`subset()` BPCellsSubsetSeed object works as expected", {
     seed <- BPCellsSubsetSeed(obj)
     testthat::expect_s4_class(seed[1:10, ], "BPCellsSubsetSeed")
diff --git a/tests/testthat/test_cBindMatrix.R b/tests/testthat/test_cBindMatrix.R
index 71c75ef..29d4186 100644
--- a/tests/testthat/test_cBindMatrix.R
+++ b/tests/testthat/test_cBindMatrix.R
@@ -1,5 +1,5 @@
-mat1 <- mock_matrix(2000, 200)
-mat2 <- mock_matrix(2000, 200)
+mat1 <- mock_matrix(20, 20)
+mat2 <- mock_matrix(20, 20)
 path <- normalizePath(c(tempfile(tmpdir = tmpdir), tempfile(tmpdir = tmpdir)), mustWork = FALSE)
 obj1 <- BPCells::write_matrix_dir(mat = as(mat1, "dgCMatrix"), dir = path[1L])
 obj2 <- BPCells::write_matrix_dir(mat = as(mat2, "dgCMatrix"), dir = path[2L])
@@ -7,7 +7,12 @@ obj <- cbind(obj1, obj2)
 mat <- cbind(mat1, mat2)
 
 
-common_test(mat, obj, path, BPCellsBindMatrixSeed, "ColBindMatrix")
+common_test(
+    obj, path,
+    mat = mat, 
+    seed_fn = BPCellsBindMatrixSeed, 
+    name = "ColBindMatrix"
+)
 testthat::test_that("`subset()` BPCellsBindMatrixSeed object works as expected", {
     seed <- BPCellsBindMatrixSeed(obj)
     testthat::expect_s4_class(seed[1:10, ], "BPCellsColBindMatrixSeed")
diff --git a/tests/testthat/test_rBindMatrix.R b/tests/testthat/test_rBindMatrix.R
index 2c5ffad..2913424 100644
--- a/tests/testthat/test_rBindMatrix.R
+++ b/tests/testthat/test_rBindMatrix.R
@@ -1,12 +1,17 @@
-mat1 <- mock_matrix(2000, 200)
-mat2 <- mock_matrix(2000, 200)
+mat1 <- mock_matrix(20, 20)
+mat2 <- mock_matrix(20, 20)
 path <- normalizePath(c(tempfile(tmpdir = tmpdir), tempfile(tmpdir = tmpdir)), mustWork = FALSE)
 mat <- rbind(mat1, mat2)
 mat1 <- BPCells::write_matrix_dir(mat = as(mat1, "dgCMatrix"), dir = path[1L])
 mat2 <- BPCells::write_matrix_dir(mat = as(mat2, "dgCMatrix"), dir = path[2L])
 obj <- rbind(mat1, mat2)
 
-common_test(mat, obj, path, BPCellsBindMatrixSeed, "RowBindMatrix")
+common_test(
+    obj, path,
+    mat = mat, 
+    seed_fn = BPCellsBindMatrixSeed, 
+    name = "RowBindMatrix"
+)
 testthat::test_that(
     "`subset()` BPCellsBindMatrixSeed object works as expected",
     {