tests: test data_format attributes

- also more tests for Shimadzu timezone conversions
- split long lines

Author: ethanbass

tests/testthat/test-extra-agilent.R

@@ -15,6 +15,7 @@ test_that("read_chroms can read 'Agilent' MS files", {
   expect_equal(class(x)[1], "matrix")
   expect_equal(dim(x), c(95471, 3))
   expect_equal(attr(x, "parser"), "entab")
+  expect_equal(attr(x, "data_format"), "long")
   expect_equal(colnames(x), c("rt", "mz", "intensity"))
 
   # export as mzML
@@ -23,40 +24,55 @@ test_that("read_chroms can read 'Agilent' MS files", {
                         ext = "mzML")
   on.exit(unlink(path_mzml))
 
-  x1 <- read_chroms(path, parser = "chromconverter", what = "MS1",
-                    format_out = "data.table",
+  # chromConverter can read Agilent MS data and write to mzml
+  x1 <- read_chroms(path, parser = "chromconverter",
+                    format_out = "data.frame", data_format = "wide",
                     progress_bar = FALSE,
-                    export_format = "mzML", path_out = tmp)[[1]]
-  expect_s3_class(x1, "data.table")
-  expect_equal(attr(x1, "format_out"), "data.table")
+                    export_format = "mzML", path_out = tmp, force = TRUE)[[1]]
+  expect_s3_class(x1$MS1, "data.frame")
+  expect_equal(attr(x1$MS1, "format_out"), "data.frame")
+  expect_equal(attr(x1$MS1, "data_format"), "long")
+  expect_equal(attr(x1$TIC, "data_format"), "wide")
+  expect_equal(attr(x1$BPC, "data_format"), "long")
 
   xx <- read_mzml(path_mzml)
-  expect_equal(x1, xx$MS1[,-4], ignore_attr = TRUE)
-  expect_equal(x1, as.data.frame(x), ignore_attr = TRUE)
-  expect_equal(attr(x1,"sample_name"), attr(x1,"sample_name"))
-  expect_equal(attr(x1,"source_sha1"), attr(x1,"source_sha1"))
-  expect_equal(attr(x1,"time_unit"), attr(x1,"time_unit"))
-  expect_equal(attr(x1,"run_datetime"), attr(x1,"run_datetime"))
-  expect_equal(attr(x1,"operator"), attr(x1,"operator"))
-  expect_equal(attr(x1,"method"), attr(x1,"method"))
-  expect_equal(attr(x1,"detector"), attr(x1,"detector"))
+  expect_equal(xx$MS1[,-4], x1$MS1, ignore_attr = TRUE)
+  expect_equal(as.data.frame(xx$TIC), x1$TIC, ignore_attr = TRUE)
+  expect_equal(rownames(xx$TIC), rownames(x1$TIC))
+  expect_equal(xx$BPC[,1], x1$BPC[,3], ignore_attr=TRUE)
+  expect_equal(as.numeric(rownames(xx$BPC)), x1$BPC$rt, tolerance = 0.00001)
+
+  expect_equal(x1$MS1, as.data.frame(x), ignore_attr = TRUE)
+  expect_equal(attr(x1$MS1,"sample_name"), attr(x,"sample_name"))
+  expect_equal(attr(x1$MS1,"source_sha1"), attr(x,"source_sha1"))
+  expect_equal(attr(x1$MS1, "time_unit"), attr(x, "time_unit"))
+  expect_equal(attr(x1$MS1,"run_datetime"), attr(x,"run_datetime"))
+  expect_equal(attr(x1$MS1,"operator"), attr(x,"operator"))
+  expect_equal(attr(x1$MS1,"method"), attr(x,"method"))
+  expect_equal(attr(x1$MS1,"detector"), attr(x,"detector"))
+  expect_equal(attr(x1$MS1, "data_format"), "long")
 
   # rainbow
-  x1 <- read_chroms(path, parser = "rainbow",
-                    progress_bar = FALSE, precision = 0)[[1]]
-  expect_equal(class(x1)[1], "matrix")
-  expect_equal(dim(x1), c(2534, 841))
-  expect_equal(attr(x1,"run_datetime"), attr(x1,"run_datetime"))
-  expect_equal(attr(x1,"method"), attr(x1,"method"))
-  expect_equal(attr(x1,"detector"), attr(x1,"detector"))
-
   x2 <- read_chroms(path, parser = "rainbow",
+                    progress_bar = FALSE, precision = 0)[[1]]
+  expect_equal(class(x2)[1], "matrix")
+  expect_equal(dim(x2), c(2534, 841))
+  # date time stamp appears to be wrong in rainbow
+  # expect_equal(attr(x2,"run_datetime"), attr(x,"run_datetime"))
+  expect_equal(attr(x2, "method"), attr(x1$MS1, "method"))
+  expect_equal(attr(x2, "detector"), attr(x1$MS1, "detector"))
+  expect_equal(attr(x2, "data_format"), "wide")
+
+  x3 <- read_chroms(path, parser = "rainbow",
                     progress_bar = FALSE, data_format = "long",
                     format_out = "data.table",
                     precision = 0)[[1]]
-  expect_s3_class(x2, "data.table")
-  expect_equal(dim(x2), c(2131094, 3))
-  expect_equal(colnames(x2), c("rt", "mz", "intensity"))
+  expect_s3_class(x3, "data.table")
+  expect_equal(dim(x3), c(2131094, 3))
+  expect_equal(colnames(x3), c("rt", "mz", "intensity"))
+  expect_equal(attr(x3, "method"), attr(x2, "method"))
+  expect_equal(attr(x3, "detector"), attr(x2, "detector"))
+  expect_equal(attr(x3, "data_format"), "long")
 })
 
 test_that("read_chroms can read 'Agilent ChemStation' version 30 files", {
@@ -80,6 +96,7 @@ test_that("read_chroms can read 'Agilent ChemStation' version 30 files", {
   expect_equal(attr(x, "detector_y_unit"), "mAU")
   expect_equal(attr(x, "method"), "JCMONO1.M")
   expect_equal(attr(x, "time_unit"), "Minutes")
+  expect_equal(attr(x, "data_format"), "wide")
 
   x1 <- read_chroms(path, parser = "chromconverter", format_out = "data.frame",
                     data_format = "long", progress_bar = FALSE)[[1]]
@@ -89,6 +106,7 @@ test_that("read_chroms can read 'Agilent ChemStation' version 30 files", {
   expect_equal(x[,1], x1[,2], ignore_attr = TRUE)
   expect_equal(head(x1$rt, 1), -.00133333333333333, tolerance = .00001)
   expect_equal(tail(x1$rt, 1), 32.002, tolerance = .00001)
+  expect_equal(attr(x1, "data_format"), "long")
 })
 
 test_that("read_chroms can read 'Agilent ChemStation' 31 files", {
@@ -133,6 +151,9 @@ test_that("read_chroms can read 'Agilent ChemStation' 31 files", {
 
   expect_equal(attr(x, "time_unit"), "Minutes")
   expect_equal(attr(x, "time_unit"), attr(x1, "time_unit"))
+
+  expect_equal(attr(x, "data_format"), "wide")
+  expect_equal(attr(x, "data_format"), attr(x1, "data_format"))
 })
 
 test_that("read_chroms can read 'Agilent ChemStation' version 81 files", {
@@ -157,6 +178,7 @@ test_that("read_chroms can read 'Agilent ChemStation' version 81 files", {
   expect_equal(attr(x, "detector_id"), "HP G1530A")
   expect_equal(attr(x, "sample_name"), "5970 mix 10nG")
   expect_equal(attr(x, "time_unit"), "Minutes")
+  expect_equal(attr(x, "data_format"), "wide")
 
   # long format
   x1 <- read_chroms(path, progress_bar = FALSE,
@@ -168,6 +190,7 @@ test_that("read_chroms can read 'Agilent ChemStation' version 81 files", {
   expect_equal(x[,1], x1[[2]], ignore_attr = TRUE)
   expect_equal(head(x1$rt, 1), 3.00044479166667, tolerance = .00001)
   expect_equal(tail(x1$rt, 1), 11.9971114583333, tolerance = .00001)
+  expect_equal(attr(x1, "data_format"), "long")
 })
 
 test_that("read_chroms can read 'Agilent ChemStation' version 130 files", {
@@ -190,6 +213,7 @@ test_that("read_chroms can read 'Agilent ChemStation' version 130 files", {
   expect_equal(attr(x, "detector_y_unit"), "mAU")
   expect_equal(attr(x, "method"), "Phenolics_new2.M")
   expect_equal(attr(x, "time_unit"), "Minutes")
+  expect_equal(attr(x, "data_format"), "wide")
 
   # long format
   x1 <- read_chroms(path, data_format = "long", format_out = "data.table",
@@ -206,7 +230,7 @@ test_that("read_chroms can read 'Agilent ChemStation' version 130 files", {
   expect_equal(attr(x1, "detector_y_unit"), "mAU")
   expect_equal(attr(x1, "method"), "Phenolics_new2.M")
   expect_equal(attr(x1, "time_unit"), "Minutes")
-
+  expect_equal(attr(x1, "data_format"), "long")
 })
 
 
@@ -229,6 +253,7 @@ test_that("read_chroms can read 'Agilent OpenLab' 179 files", {
   expect_equal(attr(x, "sample_name"), "STD_1_1mM-1MKHCO3")
   expect_equal(attr(x, "detector_y_unit"), "nRIU")
   expect_equal(attr(x, "time_unit"), "Minutes")
+  expect_equal(attr(x, "data_format"), "wide")
 
   # long format
   x1 <- read_chroms(path, progress_bar = FALSE,
@@ -241,6 +266,7 @@ test_that("read_chroms can read 'Agilent OpenLab' 179 files", {
   expect_equal(x[,1], x1[,2], ignore_attr = TRUE)
   expect_equal(head(x1$rt,1), 0.001125, tolerance = .00001)
   expect_equal(tail(x1$rt,1), 36, tolerance = .00001)
+  expect_equal(attr(x1, "data_format"), "long")
 })
 
 test_that("read_chroms can read 'Agilent ChemStation' 179 files (8-byte format)", {
@@ -265,6 +291,7 @@ test_that("read_chroms can read 'Agilent ChemStation' 179 files (8-byte format)"
   expect_equal(attr(x, "software"), "Mustang ChemStation")
   expect_equal(attr(x, "method"), "NGS Default Edit.M")
   expect_equal(attr(x, "time_unit"), "Minutes")
+  expect_equal(attr(x, "data_format"), "wide")
 
   # test scale argument
   x1 <- read_chroms(path, progress_bar = FALSE, scale=FALSE)[[1]]
@@ -284,6 +311,7 @@ test_that("read_chroms can read 'Agilent ChemStation' 179 (4-byte format)", {
   expect_equal(dim(x), c(22800, 1))
   expect_equal(head(get_times(x), 1), 0.00083331667582194, tolerance = .00001)
   expect_equal(tail(get_times(x), 1), 19, tolerance = .00001)
+  expect_equal(attr(x, "data_format"), "wide")
 
   # check metadata
   expect_equal(attr(x, "parser"), "chromconverter")
@@ -304,15 +332,17 @@ test_that("read_chroms can read 'Agilent MassHunter' dad files", {
   skip_if_not(file.exists(path))
 
   x <- read_chroms(path, format_in = "masshunter_dad", parser = "entab",
-                   progress_bar = FALSE)
+                   progress_bar = FALSE)[[1]]
   x1 <- read_chroms(path, format_in = "masshunter_dad", parser = "aston",
-                    progress_bar = FALSE)
+                    progress_bar = FALSE)[[1]]
 
-  expect_equal(dim(x[[1]]), c(240, 276))
-  expect_equal(class(x[[1]])[1], "matrix")
-  expect_equal(x[[1]], x1[[1]], ignore_attr = TRUE)
-  expect_equal(attr(x[[1]], "parser"), "entab")
-  expect_equal(attr(x1[[1]], "parser"), "aston")
+  expect_equal(dim(x), c(240, 276))
+  expect_equal(class(x)[1], "matrix")
+  expect_equal(x, x1, ignore_attr = TRUE)
+  expect_equal(attr(x, "parser"), "entab")
+  expect_equal(attr(x1, "parser"), "aston")
+  expect_equal(attr(x, "data_format"), "wide")
+  expect_equal(attr(x1, "data_format"), "wide")
 
   x <- read_chroms(path, format_in = "masshunter_dad", parser = "entab",
                    data_format = "long", format_out = "data.frame",
@@ -327,6 +357,8 @@ test_that("read_chroms can read 'Agilent MassHunter' dad files", {
 
   expect_equal(attr(x1, "parser"), "aston")
   expect_equal(colnames(x1), c("rt", "lambda", "intensity"))
+  expect_equal(attr(x, "data_format"), "long")
+  expect_equal(attr(x1, "data_format"), "long")
 })
 
 
@@ -356,6 +388,7 @@ test_that("read_chroms can read 'Agilent ChemStation' version 181 files", {
   expect_equal(attr(x[[1]], "run_datetime"), as.POSIXct("2022-8-23 12:16:25",
                                                         tz = "UTC"))
   expect_equal(attr(x[[1]], "time_unit"), "Minutes")
+  expect_equal(attr(x[[1]], "data_format"), "wide")
 
   expect_equal(attr(x[[2]], "sample_name"), "140+H")
   expect_equal(attr(x[[2]], "file_version"), "181")
@@ -379,9 +412,10 @@ test_that("read_chroms can read 'Agilent ChemStation' version 181 files", {
   expect_equal(tail(x1$FID1A$rt, 1), 19.7048479166667, tolerance = .00001)
 
   expect_equal(extract_metadata(x)[,c(1:8)], extract_metadata(x1)[,c(1:8)])
+  expect_equal(attr(x1[[1]], "data_format"), "long")
 
   expect_warning(read_chroms(path, format_in = "agilent_d", what = "dad",
-                           progress_bar = FALSE))
+                             progress_bar = FALSE))
   expect_error(read_agilent_d(path, what = "dad"))
 
 })
@@ -419,10 +453,10 @@ test_that("read_chroms can read 'Agilent' .dx files", {
   expect_true(all(round(x$instrument$`THM1B,Right Temperature`) == 45))
 
   expect_equal(head(names(x$instrument),5), c("RID1G,Board Temperature",
-                                            "RID1F,Diode 2",
-                                            "RID1E,Diode 1",
-                                            "RID1D,Polarity",
-                                            "RID1C,Diode Balance"))
+                                              "RID1F,Diode 2",
+                                              "RID1E,Diode 1",
+                                              "RID1D,Polarity",
+                                              "RID1C,Diode Balance"))
 
   expect_equal(sapply(x$instrument, function(xx) attr(xx, "detector_y_unit")),
                c("\u00b0C","counts","counts","","","\u00b0C", "\u00b0C",
@@ -437,14 +471,15 @@ test_that("read_chroms can read 'Agilent' .dx files", {
   expect_true(all(
     sapply(x$instrument, function(xx){
       attr(xx, "run_datetime")
-      }) == 1636717143))
+    }) == 1636717143))
 
   x1 <- read_chroms(path, format_in="agilent_dx", what = c("chroms","instrument"),
                     progress_bar = FALSE, data_format = "long",
                     format_out = "data.frame")[[1]]
   expect_s3_class(x1$chroms[1], "data.frame")
   expect_equal(dim(x1$chroms), c(10000, 2))
-  expect_equal(dim(x1$instrument$`PMP1C,Solvent Ratio A`), c(43253, 2))
+  expect_equal(dim(x1$instrument[["PMP1C,Solvent Ratio A"]]), c(43253, 2))
+  expect_equal(attr(x1$chroms,"data_format"),"long")
 
   expect_warning(read_chroms(path, format_in = "agilent_dx", what = "dad",
                              progress_bar = FALSE))

tests/testthat/test-extra-asm.R

@@ -21,7 +21,7 @@ test_that("read_chroms can read ASM LC format", {
   expect_equal(attr(x[[1]], "run_datetime"), as.POSIXct("2016-10-20 06:33:54",
                                                         tz = "UTC"))
   expect_equal(as.character(attr(x[[1]], "time_unit")), "s")
-  expect_equal(as.character(attr(x[[1]], "data_format")), "wide")
+  expect_equal(as.character(attr(x[[1]], "data_format")), "long")
 })
 
 test_that("read_chroms can read ASM GC format", {
@@ -45,3 +45,4 @@ test_that("read_chroms can read ASM GC format", {
   expect_equal(as.character(attr(x, "time_unit")), "s")
   expect_equal(as.character(attr(x, "data_format")), "long")
 })
+

tests/testthat/test-extra-export.R

@@ -41,11 +41,13 @@ test_that("read_chroms can write mzML files", {
                    format_out = "data.table",
                    export_format = "mzml", path_out = tmp, force = TRUE)[[1]]
 
-  path_mzml <- fs::path(tmp, gsub(" ", "_", attr(x,"sample_name")), ext = "mzML")
+  path_mzml <- fs::path(tmp, gsub(" ", "_",
+                                  attr(x, "sample_name")), ext = "mzML")
   on.exit(unlink(path_mzml))
 
-  x1 <- read_mzml(path_mzml, what = c("MS1","metadata"))
-  expect_equal(x1$MS1[,c(1:3)], x, ignore_attr = TRUE)
+  x1 <- read_mzml(path_mzml, what = c("MS1", "metadata"))
+
+  expect_equal(x1$MS1[,c(1:3)], x[,c(2:4)], ignore_attr = TRUE)
   # expect_equal(x1$metadata$timestamp, attr(x,"run_datetime"))
   expect_equal(x1$metadata$source_file, basename(attr(x,"source_file")))
 

tests/testthat/test-extra-misc.R

@@ -74,7 +74,7 @@ test_that("read_chroms can read ANDI MS files", {
   expect_true(all(dim(x$TIC) == c(621, 1)))
   expect_true(all(dim(x$MS1) == c(7638, 3)))
 
-  x1 <- read_chroms(path, what=c("TIC"), data_format="long",
+  x1 <- read_chroms(path, what = c("TIC"), data_format="long",
                     progress_bar = FALSE)[[1]]
   expect_equal(ncol(x1), 2)
   expect_equal(colnames(x1), c("rt", "intensity"))
@@ -98,12 +98,13 @@ test_that("read_chroms can read Varian SMS", {
   tmp <- tempdir()
 
   x <- read_chroms(path_sms, progress_bar = FALSE, export_format = "mzml",
-                   path_out = tmp)[[1]]
+                   data_format = "long", path_out = tmp)[[1]] # must be in long format to export successfully
 
   path_mzml_cc <- fs::path(tmp, attr(x$MS1, "sample_name"), ext = "mzML")
   on.exit(unlink(path_mzml_cc))
 
-  x1 <- read_chroms(path_mzml, format_in = "mzml", progress_bar = FALSE)[[1]]
+  x1 <- read_chroms(path_mzml, format_in = "mzml", data_format = "long",
+                    progress_bar = FALSE)[[1]]
   x2 <- read_chroms(path_mzml_cc, format_in = "mzml", progress_bar = FALSE,
                     format_out = "data.frame")[[1]]
 
@@ -136,6 +137,10 @@ test_that("read_chroms can read Varian SMS", {
   expect_equal(attr(x$TIC, "ms_params")$temp_manifold, 50)
   expect_equal(attr(x$TIC, "ms_params")$temp_transferline, 250)
   expect_equal(attr(x$TIC, "ms_params")$axial_modulation, 4)
+  expect_equal(attr(x$TIC, "data_format"), "long")
+  expect_equal(attr(x$BPC, "data_format"), "long")
+  expect_equal(attr(x$MS1, "data_format"), "long")
+
   # attr(x$MS1, "run_datetime") # should be 8/8/2014 8:50 PM - 9:20 PM
   expect_equal(x2$metadata$source_file, basename(attr(x$MS1,"source_file")))
   # expect_equal(x2$metadata$timestamp, attr(x$MS1,"run_datetime")[1])
@@ -155,7 +160,6 @@ test_that("read_varian_peaklist function works", {
 })
 
 test_that("read_chroms can write Varian SMS to CDF", {
-
   # write CDF
   skip_if_not_installed("ncdf4")
   skip_on_cran()
@@ -171,9 +175,10 @@ test_that("read_chroms can write Varian SMS to CDF", {
   on.exit(unlink(path_cdf))
 
   x <- read_chroms(path_sms, path_out = tmp, export_format = "cdf",
-               progress_bar = FALSE)[[1]]
+                   data_format = "long", progress_bar = FALSE)[[1]]
 
   x3 <- read_cdf(path_cdf, data_format = "long", format_out = "data.frame")
+
   x3$MS1$rt <- x3$MS1$rt/60
   x3$TIC$rt <- x3$TIC$rt/60