R Under development (unstable) (2026-02-18 r89435 ucrt) -- "Unsuffered Consequences"
Copyright (C) 2026 The R Foundation for Statistical Computing
Platform: x86_64-w64-mingw32/x64

R is free software and comes with ABSOLUTELY NO WARRANTY.
You are welcome to redistribute it under certain conditions.
Type 'license()' or 'licence()' for distribution details.

R is a collaborative project with many contributors.
Type 'contributors()' for more information and
'citation()' on how to cite R or R packages in publications.

Type 'demo()' for some demos, 'help()' for on-line help, or
'help.start()' for an HTML browser interface to help.
Type 'q()' to quit R.

> # No need to load and attach the namespace, everything in this test script is
> # non-exported
> # library(medicalcoder)
> source('utilities.R')
> 
> dataframetools <-
+   c("mdcr_set",
+     "mdcr_select",
+     "mdcr_subset",
+     "mdcr_setorder",
+     "mdcr_setnames",
+     "mdcr_duplicated",
+     "mdcr_unique",
+     "mdcr_inner_join",
+     "mdcr_full_outer_join",
+     "mdcr_left_join",
+     "mdcr_cbind"
+   )
> 
> mdcr <- getNamespace("medicalcoder")
> 
> # are all the dataframetools in the namespcae
> stopifnot(all(dataframetools %in% names(mdcr)))
> 
> # check that there are not unaccounted for data sets.  the ..mdcr_internal_
> # prefix and .. suffix is expected.  noted in the data-raw/build_sysdata.R
> stopifnot(
+   all(
+     grep("^mdcr_", names(mdcr), value = TRUE) %in% dataframetools
+   )
+ )
> 
> ################################################################################
> # Set up data for testing
> DF <- data.frame(A = 1:10, C = NA_integer_, B = LETTERS[1:10], stringsAsFactors = FALSE)
> if (requireNamespace("dplyr", quietly = TRUE)) {
+   TBL <- getExportedValue(name = "as_tibble", ns = "dplyr")(DF)
+ } else {
+   TBL <- DF
+ }
> if (requireNamespace("data.table", quietly = TRUE)) {
+   DT <- getExportedValue(name = "copy", ns = "data.table")(DF)
+   getExportedValue(name = "setDT", ns = "data.table")(DT)
+ } else {
+   DT <- DF
+ }
> 
> ################################################################################
> # set the value of column C in row 5
> DF  <- getFromNamespace(x = "mdcr_set", ns = "medicalcoder")(DF,  i = 5L, j = "C", value = 3L)
> TBL <- getFromNamespace(x = "mdcr_set", ns = "medicalcoder")(TBL, i = 5L, j = "C", value = 3L)
> DT  <- getFromNamespace(x = "mdcr_set", ns = "medicalcoder")(DT,  i = 5L, j = "C", value = 3L)
> 
> stopifnot(
+   identical(DF[["C"]],  c(rep(NA_integer_, 4L), 3L, rep(NA_integer_, 5L))),
+   identical(TBL[["C"]], c(rep(NA_integer_, 4L), 3L, rep(NA_integer_, 5L))),
+   identical(DT[["C"]],  c(rep(NA_integer_, 4L), 3L, rep(NA_integer_, 5L)))
+ )
> 
> # set the value in two rows at a time with one value
> DF  <- getFromNamespace(x = "mdcr_set", ns = "medicalcoder")(DF,  i = c(1L, 10L), j = "C", value = 8L)
> TBL <- getFromNamespace(x = "mdcr_set", ns = "medicalcoder")(TBL, i = c(1L, 10L), j = "C", value = 8L)
> DT  <- getFromNamespace(x = "mdcr_set", ns = "medicalcoder")(DT,  i = c(1L, 10L), j = "C", value = 8L)
> 
> stopifnot(
+   identical(DF[["C"]],  c(8L, rep(NA_integer_, 3L), 3L, rep(NA_integer_, 4L), 8L)),
+   identical(TBL[["C"]], c(8L, rep(NA_integer_, 3L), 3L, rep(NA_integer_, 4L), 8L)),
+   identical(DT[["C"]],  c(8L, rep(NA_integer_, 3L), 3L, rep(NA_integer_, 4L), 8L))
+ )
> 
> # set the value in three rows at a time with three values
> DF  <- getFromNamespace(x = "mdcr_set", ns = "medicalcoder")(DF,  i = c(2L, 3L, 4L), j = "C", value = c(21L, 22L, 23L))
> TBL <- getFromNamespace(x = "mdcr_set", ns = "medicalcoder")(TBL, i = c(2L, 3L, 4L), j = "C", value = c(21L, 22L, 23L))
> DT  <- getFromNamespace(x = "mdcr_set", ns = "medicalcoder")(DT,  i = c(2L, 3L, 4L), j = "C", value = c(21L, 22L, 23L))
> 
> stopifnot(
+   identical(DF[["C"]],  c(8L, 21L, 22L, 23L, 3L, rep(NA_integer_, 4L), 8L)),
+   identical(TBL[["C"]], c(8L, 21L, 22L, 23L, 3L, rep(NA_integer_, 4L), 8L)),
+   identical(DT[["C"]],  c(8L, 21L, 22L, 23L, 3L, rep(NA_integer_, 4L), 8L))
+ )
> 
> # set a full column
> DF  <- getFromNamespace(x = "mdcr_set", ns = "medicalcoder")(DF,  j = "A", value = as.integer(11:20))
> TBL <- getFromNamespace(x = "mdcr_set", ns = "medicalcoder")(TBL, j = "A", value = as.integer(11:20))
> DT  <- getFromNamespace(x = "mdcr_set", ns = "medicalcoder")(DT,  j = "A", value = as.integer(11:20))
> 
> stopifnot(
+   identical(DF[["A"]],  as.integer(11:20)),
+   identical(TBL[["A"]], as.integer(11:20)),
+   identical(DT[["A"]],  as.integer(11:20))
+ )
> 
> # create a new column
> x <- paste("v", c(0:5, 5, 6:8))
> DF  <- getFromNamespace(x = "mdcr_set", ns = "medicalcoder")(DF,  j = "D", value = x)
> TBL <- getFromNamespace(x = "mdcr_set", ns = "medicalcoder")(TBL, j = "D", value = x)
> DT  <- getFromNamespace(x = "mdcr_set", ns = "medicalcoder")(DT,  j = "D", value = x)
> 
> stopifnot(
+   identical(DF[["D"]],  x),
+   identical(TBL[["D"]], x),
+   identical(DT[["D"]],  x)
+ )
> 
> # create a new column and only add a value to rows 2, 5, and 7
> x <- c(NA_character_, "first", NA_character_, NA_character_, "second", NA_character_, "third", rep(NA_character_, nrow(DF) - 7L))
> DF  <- getFromNamespace(x = "mdcr_set", ns = "medicalcoder")(DF,  i = c(2L, 5L, 7L), j = "newC", value = c("first", "second", "third"))
> TBL <- getFromNamespace(x = "mdcr_set", ns = "medicalcoder")(TBL, i = c(2L, 5L, 7L), j = "newC", value = c("first", "second", "third"))
> DT  <- getFromNamespace(x = "mdcr_set", ns = "medicalcoder")(DT,  i = c(2L, 5L, 7L), j = "newC", value = c("first", "second", "third"))
> 
> stopifnot(
+   identical(DF[["newC"]],  x),
+   identical(TBL[["newC"]], x),
+   identical(DT[["newC"]],  x)
+ )
> 
> ################################################################################
> # testing mdcr_select
> # set colummns - change the order of the columns
> DF  <- getFromNamespace(x = "mdcr_select", ns = "medicalcoder")(DF,  col = c("D", "B", "C", "A"))
> TBL <- getFromNamespace(x = "mdcr_select", ns = "medicalcoder")(TBL, col = c("D", "B", "C", "A"))
> DT  <- getFromNamespace(x = "mdcr_select", ns = "medicalcoder")(DT,  col = c("D", "B", "C", "A"))
> 
> stopifnot(
+   identical(names(DF),  c("D", "B", "C", "A")),
+   identical(names(TBL), c("D", "B", "C", "A")),
+   identical(names(DT),  c("D", "B", "C", "A"))
+ )
> 
> # retun the object if col is missing
> stopifnot(
+   identical(getFromNamespace(x = "mdcr_select", ns = "medicalcoder")(DF), DF),
+   identical(getFromNamespace(x = "mdcr_select", ns = "medicalcoder")(TBL), TBL),
+   identical(getFromNamespace(x = "mdcr_select", ns = "medicalcoder")(DT), DT)
+ )
> 
> # check for one column
> DFD  <- getFromNamespace(x = "mdcr_select", ns = "medicalcoder")(DF,  col = c("D"))
> TBLD <- getFromNamespace(x = "mdcr_select", ns = "medicalcoder")(TBL, col = c("D"))
> DTD  <- getFromNamespace(x = "mdcr_select", ns = "medicalcoder")(DT,  col = c("D"))
> 
> stopifnot(
+   identical(names(DFD),  c("D")),
+   identical(names(TBLD), c("D")),
+   identical(names(DTD),  c("D")),
+   identical(DFD[["D"]], paste("v", c(0:5, 5:8))),
+   identical(TBLD[["D"]], paste("v", c(0:5, 5:8))),
+   identical(DTD[["D"]], paste("v", c(0:5, 5:8))),
+   identical(class(DFD), class(DF)),
+   identical(class(TBLD), class(TBL)),
+   identical(class(DTD), class(DT))
+ )
> 
> ################################################################################
> # testing mdcr_subset
> 
> # if arg i and cols are missing then the object is retruned
> stopifnot(
+   identical(getFromNamespace(x = "mdcr_subset", ns = "medicalcoder")(DF), DF),
+   identical(getFromNamespace(x = "mdcr_subset", ns = "medicalcoder")(TBL), TBL),
+   identical(getFromNamespace(x = "mdcr_subset", ns = "medicalcoder")(DT), DT)
+ )
> 
> # with no row specfied, it is the same as calling mdcr_select
> stopifnot(
+   identical(
+     getFromNamespace(x = "mdcr_subset", ns = "medicalcoder")(DF,  col = c("D", "B", "C", "A")),
+     getFromNamespace(x = "mdcr_select", ns = "medicalcoder")(DF,  col = c("D", "B", "C", "A"))
+   ),
+   identical(
+     getFromNamespace(x = "mdcr_subset", ns = "medicalcoder")(TBL, col = c("D", "B", "C", "A")),
+     getFromNamespace(x = "mdcr_select", ns = "medicalcoder")(TBL, col = c("D", "B", "C", "A"))
+   ),
+   identical(
+     getFromNamespace(x = "mdcr_subset", ns = "medicalcoder")(DT,  col = c("D", "B", "C", "A")),
+     getFromNamespace(x = "mdcr_select", ns = "medicalcoder")(DT,  col = c("D", "B", "C", "A"))
+   )
+ )
> 
> # select one column and a subset of rows
> DF0 <- getFromNamespace(x = "mdcr_subset", ns = "medicalcoder")(DF, i = seq(1, 10, by = 2), cols = c("B"))
> DF1 <- getFromNamespace(x = "mdcr_subset", ns = "medicalcoder")(DF, i = seq(2, 10, by = 2), cols = c("B"))
> TBL0 <- getFromNamespace(x = "mdcr_subset", ns = "medicalcoder")(TBL, i = seq(1, 10, by = 2), cols = c("B"))
> TBL1 <- getFromNamespace(x = "mdcr_subset", ns = "medicalcoder")(TBL, i = seq(2, 10, by = 2), cols = c("B"))
> DT0 <- getFromNamespace(x = "mdcr_subset", ns = "medicalcoder")(DT, i = seq(1, 10, by = 2), cols = c("B"))
> DT1 <- getFromNamespace(x = "mdcr_subset", ns = "medicalcoder")(DT, i = seq(2, 10, by = 2), cols = c("B"))
> 
> stopifnot(
+   inherits(DF0, "data.frame"),
+   inherits(DF1, "data.frame"),
+   inherits(TBL0, "data.frame"),
+   inherits(TBL1, "data.frame"),
+   inherits(DT0, "data.frame"),
+   inherits(DT1, "data.frame"),
+   identical(names(DF0), "B"),
+   identical(names(DF1), "B"),
+   identical(names(TBL0), "B"),
+   identical(names(TBL1), "B"),
+   identical(names(DT0), "B"),
+   identical(names(DT1), "B")
+ )
> 
> if (requireNamespace("data.table", quietly = TRUE)) {
+   stopifnot(inherits(DT0, "data.table"), inherits(DT1, "data.table"))
+ }
> 
> if (requireNamespace("dplyr", quietly = TRUE)) {
+   stopifnot(inherits(TBL0, "tbl_df"), inherits(TBL1, "tbl_df"))
+ }
> 
> # select two columns
> DF0 <- getFromNamespace(x = "mdcr_subset", ns = "medicalcoder")(DF, i = seq(1, 10, by = 2), cols = c("B", "A"))
> DF1 <- getFromNamespace(x = "mdcr_subset", ns = "medicalcoder")(DF, i = seq(2, 10, by = 2), cols = c("B", "A"))
> TBL0 <- getFromNamespace(x = "mdcr_subset", ns = "medicalcoder")(TBL, i = seq(1, 10, by = 2), cols = c("B", "A"))
> TBL1 <- getFromNamespace(x = "mdcr_subset", ns = "medicalcoder")(TBL, i = seq(2, 10, by = 2), cols = c("B", "A"))
> DT0 <- getFromNamespace(x = "mdcr_subset", ns = "medicalcoder")(DT, i = seq(1, 10, by = 2), cols = c("B", "A"))
> DT1 <- getFromNamespace(x = "mdcr_subset", ns = "medicalcoder")(DT, i = seq(2, 10, by = 2), cols = c("B", "A"))
> 
> stopifnot(
+   inherits(DF0, "data.frame"),
+   inherits(DF1, "data.frame"),
+   inherits(TBL0, "data.frame"),
+   inherits(TBL1, "data.frame"),
+   inherits(DT0, "data.frame"),
+   inherits(DT1, "data.frame"),
+   identical(names(DF0), c("B", "A")),
+   identical(names(DF1), c("B", "A")),
+   identical(names(TBL0), c("B", "A")),
+   identical(names(TBL1), c("B", "A")),
+   identical(names(DT0), c("B", "A")),
+   identical(names(DT1), c("B", "A"))
+ )
> 
> if (requireNamespace("data.table", quietly = TRUE)) {
+   stopifnot(inherits(DT0, "data.table"), inherits(DT1, "data.table"))
+ }
> 
> if (requireNamespace("dplyr", quietly = TRUE)) {
+   stopifnot(inherits(TBL0, "tbl_df"), inherits(TBL1, "tbl_df"))
+ }
> 
> # if only i is supplied, all the columns are returned
> DF0 <- getFromNamespace(x = "mdcr_subset", ns = "medicalcoder")(DF, i = seq(1, 10, by = 2))
> DF1 <- getFromNamespace(x = "mdcr_subset", ns = "medicalcoder")(DF, i = seq(2, 10, by = 2))
> TBL0 <- getFromNamespace(x = "mdcr_subset", ns = "medicalcoder")(TBL, i = seq(1, 10, by = 2))
> TBL1 <- getFromNamespace(x = "mdcr_subset", ns = "medicalcoder")(TBL, i = seq(2, 10, by = 2))
> DT0 <- getFromNamespace(x = "mdcr_subset", ns = "medicalcoder")(DT, i = seq(1, 10, by = 2))
> DT1 <- getFromNamespace(x = "mdcr_subset", ns = "medicalcoder")(DT, i = seq(2, 10, by = 2))
> 
> stopifnot(
+   inherits(DF0, "data.frame"),
+   inherits(DF1, "data.frame"),
+   inherits(TBL0, "data.frame"),
+   inherits(TBL1, "data.frame"),
+   inherits(DT0, "data.frame"),
+   inherits(DT1, "data.frame"),
+   identical(names(DF0), c("D", "B", "C", "A")),
+   identical(names(DF1), c("D", "B", "C", "A")),
+   identical(names(TBL0), c("D", "B", "C", "A")),
+   identical(names(TBL1), c("D", "B", "C", "A")),
+   identical(names(DT0), c("D", "B", "C", "A")),
+   identical(names(DT1), c("D", "B", "C", "A"))
+ )
> 
> if (requireNamespace("data.table", quietly = TRUE)) {
+   stopifnot(inherits(DT0, "data.table"), inherits(DT1, "data.table"))
+ }
> 
> if (requireNamespace("dplyr", quietly = TRUE)) {
+   stopifnot(inherits(TBL0, "tbl_df"), inherits(TBL1, "tbl_df"))
+ }
> 
> 
> ################################################################################
> # testing mdcr_setorder
> DF <- rbind(DF0, DF1)
> TBL <- rbind(TBL0, TBL1)
> DT <- rbind(DT0, DT1)
> 
> # verify that the data.frames are not currently ordered by "A"
> 
> stopifnot(
+   identical(DF[["A"]],  as.integer(c(11, 13, 15, 17, 19, 12, 14, 16, 18, 20))),
+   identical(TBL[["A"]], as.integer(c(11, 13, 15, 17, 19, 12, 14, 16, 18, 20))),
+   identical(DT[["A"]],  as.integer(c(11, 13, 15, 17, 19, 12, 14, 16, 18, 20))),
+   identical(DF[["D"]],  paste("v", c(0, 2, 4, 5, 7, 1, 3, 5, 6, 8))),
+   identical(TBL[["D"]], paste("v", c(0, 2, 4, 5, 7, 1, 3, 5, 6, 8))),
+   identical(DT[["D"]],  paste("v", c(0, 2, 4, 5, 7, 1, 3, 5, 6, 8)))
+ )
> 
> DF <-  getFromNamespace(x = "mdcr_setorder", ns = "medicalcoder")(DF, by = c("A"))
> TBL <- getFromNamespace(x = "mdcr_setorder", ns = "medicalcoder")(TBL, by = c("A"))
> DT <-  getFromNamespace(x = "mdcr_setorder", ns = "medicalcoder")(DT, by = c("A"))
> 
> stopifnot(
+   identical(DF[["A"]],  as.integer(11:20)),
+   identical(TBL[["A"]], as.integer(11:20)),
+   identical(DT[["A"]],  as.integer(11:20)),
+   identical(DF[["D"]],  paste("v", c(0:5, 5, 6:8))),
+   identical(TBL[["D"]], paste("v", c(0:5, 5, 6:8))),
+   identical(DT[["D"]],  paste("v", c(0:5, 5, 6:8)))
+ )
> 
> ################################################################################
> # testing mdcr_setnames
> DF  <- getFromNamespace(x = "mdcr_setnames", ns = "medicalcoder")(DF,  old = "A", new = "Column A")
> TBL <- getFromNamespace(x = "mdcr_setnames", ns = "medicalcoder")(TBL, old = "A", new = "Column A")
> DT  <- getFromNamespace(x = "mdcr_setnames", ns = "medicalcoder")(DT,  old = "A", new = "Column A")
> 
> stopifnot(
+   identical(names(DF),  c("D", "B", "C", "Column A")),
+   identical(names(TBL), c("D", "B", "C", "Column A")),
+   identical(names(DT),  c("D", "B", "C", "Column A"))
+ )
> 
> ################################################################################
> # testing mdcr_duplicated
> 
> stopifnot(
+   !any(getFromNamespace(x = "mdcr_duplicated", ns = "medicalcoder")(DF)),
+   !any(getFromNamespace(x = "mdcr_duplicated", ns = "medicalcoder")(TBL)),
+   !any(getFromNamespace(x = "mdcr_duplicated", ns = "medicalcoder")(DT))
+ )
> 
> expected <- rep(FALSE, 10)
> expected[7] <- TRUE
> stopifnot(
+   identical(getFromNamespace(x = "mdcr_duplicated", ns = "medicalcoder")(DF, by = "D"), expected),
+   identical(getFromNamespace(x = "mdcr_duplicated", ns = "medicalcoder")(TBL, by = "D"), expected),
+   identical(getFromNamespace(x = "mdcr_duplicated", ns = "medicalcoder")(DT, by = "D"), expected)
+ )
> 
> # check fromLast
> expected[6:7] <- !expected[6:7]
> stopifnot(
+   identical(getFromNamespace(x = "mdcr_duplicated", ns = "medicalcoder")(DF, by = "D", fromLast = TRUE), expected),
+   identical(getFromNamespace(x = "mdcr_duplicated", ns = "medicalcoder")(TBL, by = "D", fromLast = TRUE), expected),
+   identical(getFromNamespace(x = "mdcr_duplicated", ns = "medicalcoder")(DT, by = "D", fromLast = TRUE), expected)
+ )
> 
> ################################################################################
> # testing mdcr_inner_join
> #
> # without specifying the by
> t0 <- getFromNamespace(x = "mdcr_inner_join", ns = "medicalcoder")(DF, DF[2, ])
> t1 <- getFromNamespace(x = "mdcr_inner_join", ns = "medicalcoder")(DT, DT[2, ])
> t2 <- getFromNamespace(x = "mdcr_inner_join", ns = "medicalcoder")(TBL, TBL[2, ])
Joining with `by = join_by(D, B, C, `Column A`)`
> 
> stopifnot(
+   isTRUE( all.equal(t0, DF[2, ], check.attributes = FALSE)),
+   isTRUE( all.equal(t1, DT[2, ], check.attributes = FALSE)),
+   isTRUE( all.equal(t2, TBL[2, ], check.attributes = FALSE))
+ )
> 
> t3 <- getFromNamespace(x = "mdcr_inner_join", ns = "medicalcoder")(DF, DF[c(2, 5, 1), ])
> t4 <- getFromNamespace(x = "mdcr_inner_join", ns = "medicalcoder")(DT, DT[c(2, 5, 1), ])
> t5 <- getFromNamespace(x = "mdcr_inner_join", ns = "medicalcoder")(TBL, TBL[c(2, 5, 1), ])
Joining with `by = join_by(D, B, C, `Column A`)`
> 
> stopifnot(
+   isTRUE( all.equal( t3, DF[c(1, 2, 5), ], check.attributes = FALSE)),
+   isTRUE( all.equal( t4, DT[c(1, 2, 5), ], check.attributes = FALSE)),
+   isTRUE( all.equal( t5, TBL[c(1, 2, 5), ], check.attributes = FALSE))
+   )
> 
> # test with a by statement and suffixes statement
> expected_df <-
+   data.frame(
+     x1 = c(1L, 2L, 8L),
+     x2.right = c("A", "B", "C"),
+     x2.left  = c("a", "b", "c"),
+     stringsAsFactors = FALSE
+   )
> r <- data.frame(
+   x1 = as.integer(1:10),
+   x2 = c("A", "B", "D", "E", "F", "T", "A", "C", "9", "ten"),
+   stringsAsFactors = FALSE
+ )
> l <- data.frame(
+   x1 = as.integer(c(1, 2, 33, 44, 55, 66, 77, 8, 99, 1100)),
+   x2 = c("a", "b", "d", "e", "f", "t", "a", "c", "9", "TEN"),
+   stringsAsFactors = FALSE
+ )
> outDF <- getFromNamespace(x = "mdcr_inner_join", ns = "medicalcoder")(r, l, by = "x1", suffixes = c(".right", ".left"))
> stopifnot(identical(outDF, expected_df))
> 
> if (requireNamespace("data.table", quietly = TRUE)) {
+   data.table::setDT(r)
+   data.table::setDT(l)
+   expected_dt <- data.table::copy(expected_df)
+   data.table::setDT(expected_dt)
+ } else {
+   r <- as.data.frame(r, stringsAsFactors = FALSE)
+   l <- as.data.frame(l, stringsAsFactors = FALSE)
+   expected_dt <- expected_df
+ }
> outDT <- getFromNamespace(x = "mdcr_inner_join", ns = "medicalcoder")(r, l, by = "x1", suffixes = c(".right", ".left"))
> stopifnot(identical(outDT, expected_dt))
> 
> if (requireNamespace("dplyr", quietly = TRUE)) {
+   r <- dplyr::as_tibble(r)
+   l <- dplyr::as_tibble(l)
+   expected_tb <- dplyr::as_tibble(expected_df)
+ } else {
+   r <- as.data.frame(r, stringsAsFactors = FALSE)
+   l <- as.data.frame(l, stringsAsFactors = FALSE)
+   expected_tb <- expected_df
+ }
> outTBL <- getFromNamespace(x = "mdcr_inner_join", ns = "medicalcoder")(r, l, by = "x1", suffixes = c(".right", ".left"))
> stopifnot(identical(outTBL, expected_tb))
> 
> # test with by.x and by.y statements
> r <- data.frame(
+   x1 = as.integer(1:10),
+   x2 = c("A", "B", "D", "E", "F", "T", "A", "C", "9", "ten"),
+   stringsAsFactors = FALSE
+ )
> l <- data.frame(
+   z = as.integer(c(1, 2, 33, 44, 55, 66, 77, 8, 99, 1100)),
+   x2 = c("a", "b", "d", "e", "f", "t", "a", "c", "9", "TEN"),
+   stringsAsFactors = FALSE
+ )
> outDF <- getFromNamespace(x = "mdcr_inner_join", ns = "medicalcoder")(r, l, by.x = "x1", by.y = "z", suffixes = c(".right", ".left"))
> stopifnot(identical(outDF, expected_df))
> 
> if (requireNamespace("data.table", quietly = TRUE)) {
+   data.table::setDT(r)
+   data.table::setDT(l)
+   expected_dt <- data.table::copy(expected_df)
+   data.table::setDT(expected_dt)
+ } else {
+   r <- as.data.frame(r, stringsAsFactors = FALSE)
+   l <- as.data.frame(l, stringsAsFactors = FALSE)
+   expected_dt <- expected_df
+ }
> outDT <- getFromNamespace(x = "mdcr_inner_join", ns = "medicalcoder")(r, l, by.x = "x1", by.y = "z", suffixes = c(".right", ".left"))
> stopifnot(identical(outDT, expected_dt))
> 
> if (requireNamespace("dplyr", quietly = TRUE)) {
+   r <- dplyr::as_tibble(r)
+   l <- dplyr::as_tibble(l)
+   expected_tb <- dplyr::as_tibble(expected_df)
+ } else {
+   r <- as.data.frame(r, stringsAsFactors = FALSE)
+   l <- as.data.frame(l, stringsAsFactors = FALSE)
+   expected_tb <- expected_df
+ }
> outTBL <- getFromNamespace(x = "mdcr_inner_join", ns = "medicalcoder")(r, l, by.x = "x1", by.y = "z", suffixes = c(".right", ".left"))
> stopifnot(identical(outTBL, expected_tb))
> 
> ################################################################################
> # testing mdcr_left_join
> 
> # These wrappers around merge have sort = FALSE and dplyr::left_join doesn't
> # sort the return by default.  So, build the merge, sort the result, and then
> # test for the outcome.  The first set of tests for a single
> 
> t0 <- getFromNamespace(x = "mdcr_left_join", ns = "medicalcoder")(DF, DF[2, ])
> t0 <- t0[do.call(order, t0), ]
> 
> t1 <- getFromNamespace(x = "mdcr_left_join", ns = "medicalcoder")(DF, DF[c(2, 5, 2), ])
> t1 <- t1[do.call(order, t1), ]
> 
> t2 <- getFromNamespace(x = "mdcr_left_join", ns = "medicalcoder")(DT, DT[2, ])
> t2 <- t2[do.call(order, t2), ]
> 
> t3 <- getFromNamespace(x = "mdcr_left_join", ns = "medicalcoder")(DT, DT[c(2, 5, 2), ])
> t3 <- t3[do.call(order, t3), ]
> 
> t4 <- getFromNamespace(x = "mdcr_left_join", ns = "medicalcoder")(TBL, TBL[2, ])
Joining with `by = join_by(D, B, C, `Column A`)`
> t4 <- t4[do.call(order, t4), ]
> 
> t5 <- getFromNamespace(x = "mdcr_left_join", ns = "medicalcoder")(TBL, TBL[c(2, 5, 2), ])
Joining with `by = join_by(D, B, C, `Column A`)`
> t5 <- t5[do.call(order, t5), ]
> 
> # without specifying the by
> stopifnot(
+   isTRUE( all.equal( t0, DF, check.attributes = FALSE)),
+   isTRUE( all.equal( t1, DF[c(1, 2, 2, 3:nrow(DF)), ], check.attributes = FALSE)),
+   isTRUE( all.equal( t2, DT, check.attributes = FALSE)),
+   isTRUE( all.equal( t3, DT[c(1, 2, 2, 3:nrow(DF)), ], check.attributes = FALSE)),
+   isTRUE( all.equal( t4, TBL, check.attributes = FALSE)),
+   isTRUE( all.equal( t5, TBL[c(1, 2, 2, 3:nrow(DF)), ], check.attributes = FALSE))
+ )
> 
> # tests with by statements and suffixes
> expected_df <-
+   data.frame(
+     x1 = as.integer(1:10),
+     x2.right = c("A", "B", "D", "E", "F", "T", "A", "C", "9", "ten"),
+     x2.left  = c("a", "b", rep(NA_character_, 5), "c", rep(NA_character_, 2)),
+     stringsAsFactors = FALSE
+   )
> r <- data.frame(
+   x1 = as.integer(1:10),
+   x2 = c("A", "B", "D", "E", "F", "T", "A", "C", "9", "ten"),
+   stringsAsFactors = FALSE
+ )
> l <- data.frame(
+   x1 = as.integer(c(1, 2, 33, 44, 55, 66, 77, 8, 99, 1100)),
+   x2 = c("a", "b", "d", "e", "f", "t", "a", "c", "9", "TEN"),
+   stringsAsFactors = FALSE
+ )
> outDF <- getFromNamespace(x = "mdcr_left_join", ns = "medicalcoder")(r, l, by = "x1", suffixes = c(".right", ".left"))
> outDF <- outDF[order(outDF$x1), ]
> rownames(outDF) <- NULL
> stopifnot(identical(outDF, expected_df))
> 
> if (requireNamespace("data.table", quietly = TRUE)) {
+   data.table::setDT(r)
+   data.table::setDT(l)
+   expected_dt <- data.table::copy(expected_df)
+   data.table::setDT(expected_dt)
+ } else {
+   r <- as.data.frame(r, stringsAsFactors = FALSE)
+   l <- as.data.frame(l, stringsAsFactors = FALSE)
+   expected_dt <- expected_df
+ }
> outDT <- getFromNamespace(x = "mdcr_left_join", ns = "medicalcoder")(r, l, by = "x1", suffixes = c(".right", ".left"))
> outDT <- outDT[order(outDT$x1), ]
> rownames(outDT) <- NULL
> stopifnot(identical(outDT, expected_dt))
> 
> if (requireNamespace("dplyr", quietly = TRUE)) {
+   r <- dplyr::as_tibble(r)
+   l <- dplyr::as_tibble(l)
+   expected_tb <- dplyr::as_tibble(expected_df)
+ } else {
+   r <- as.data.frame(r, stringsAsFactors = FALSE)
+   l <- as.data.frame(l, stringsAsFactors = FALSE)
+   expected_tb <- expected_df
+ }
> outTBL <- getFromNamespace(x = "mdcr_left_join", ns = "medicalcoder")(r, l, by = "x1", suffixes = c(".right", ".left"))
> outTBL <- outTBL[order(outTBL$x1), ]
> rownames(outTBL) <- NULL
> stopifnot(identical(outTBL, expected_tb))
> 
> # tests with by.x and by.x statements and suffixes
> expected_df <-
+   data.frame(
+     x1 = as.integer(1:10),
+     x2.right = c("A", "B", "D", "E", "F", "T", "A", "C", "9", "ten"),
+     x2.left  = c("a", "b", rep(NA_character_, 5), "c", rep(NA_character_, 2)),
+     stringsAsFactors = FALSE
+   )
> r <- data.frame(
+   x1 = as.integer(1:10),
+   x2 = c("A", "B", "D", "E", "F", "T", "A", "C", "9", "ten"),
+   stringsAsFactors = FALSE
+ )
> l <- data.frame(
+   l1 = as.integer(c(1, 2, 33, 44, 55, 66, 77, 8, 99, 1100)),
+   x2 = c("a", "b", "d", "e", "f", "t", "a", "c", "9", "TEN"),
+   stringsAsFactors = FALSE
+ )
> outDF <- getFromNamespace(x = "mdcr_left_join", ns = "medicalcoder")(r, l, by.x = "x1", by.y = "l1", suffixes = c(".right", ".left"))
> outDF <- outDF[order(outDF$x1), ]
> rownames(outDF) <- NULL
> stopifnot(identical(outDF, expected_df))
> 
> if (requireNamespace("data.table", quietly = TRUE)) {
+   data.table::setDT(r)
+   data.table::setDT(l)
+   expected_dt <- data.table::copy(expected_df)
+   data.table::setDT(expected_dt)
+ } else {
+   r <- as.data.frame(r, stringsAsFactors = FALSE)
+   l <- as.data.frame(l, stringsAsFactors = FALSE)
+   expected_dt <- expected_df
+ }
> outDT <- getFromNamespace(x = "mdcr_left_join", ns = "medicalcoder")(r, l, by.x = "x1", by.y = "l1", suffixes = c(".right", ".left"))
> outDT <- outDT[order(outDT$x1), ]
> rownames(outDT) <- NULL
> stopifnot(identical(outDT, expected_dt))
> 
> if (requireNamespace("dplyr", quietly = TRUE)) {
+   r <- dplyr::as_tibble(r)
+   l <- dplyr::as_tibble(l)
+   expected_tb <- dplyr::as_tibble(expected_df)
+ } else {
+   r <- as.data.frame(r, stringsAsFactors = FALSE)
+   l <- as.data.frame(l, stringsAsFactors = FALSE)
+   expected_tb <- expected_df
+ }
> outTBL <- getFromNamespace(x = "mdcr_left_join", ns = "medicalcoder")(r, l, by.x = "x1", by.y = "l1", suffixes = c(".right", ".left"))
> outTBL <- outTBL[order(outTBL$x1), ]
> rownames(outTBL) <- NULL
> stopifnot(identical(outTBL, expected_tb))
> 
> ################################################################################
> # testing mdcr_full_outer_join
> 
> expected_df <-
+   data.frame(
+     x1 = c(1L, 1L, 1L, 2L, 2L, 3L, 4L, 5L, 6L, 7L, 8L, 8L, 9L, 10L, 33L, 44L, 55L, 66L, 77L, 99L, 1100L),
+     x2 = c("A", "a", "a1", "B", "b", "D", "E", "F", "T", "A", "C", "c", "9", "ten", "d", "e", "f", "t", "a", "9", "TEN"),
+     stringsAsFactors = FALSE
+   )
> r <- data.frame(
+   x1 = as.integer(1:10),
+   x2 = c("A", "B", "D", "E", "F", "T", "A", "C", "9", "ten"),
+   stringsAsFactors = FALSE
+ )
> l <- data.frame(
+   x1 = as.integer(c(1, 1, 2, 33, 44, 55, 66, 77, 8, 99, 1100)),
+   x2 = c("a", "a1", "b", "d", "e", "f", "t", "a", "c", "9", "TEN"),
+   stringsAsFactors = FALSE
+ )
> outDF <- getFromNamespace(x = "mdcr_full_outer_join", ns = "medicalcoder")(r, l)
> outDF <- outDF[order(outDF$x1), ]
> rownames(outDF) <- NULL
> stopifnot(identical(outDF, expected_df))
> 
> if (requireNamespace("data.table", quietly = TRUE)) {
+   data.table::setDT(r)
+   data.table::setDT(l)
+   expected_dt <- data.table::copy(expected_df)
+   data.table::setDT(expected_dt)
+ } else {
+   r <- as.data.frame(r, stringsAsFactors = FALSE)
+   l <- as.data.frame(l, stringsAsFactors = FALSE)
+   expected_dt <- expected_df
+ }
> outDT <- getFromNamespace(x = "mdcr_full_outer_join", ns = "medicalcoder")(r, l)
> outDT <- outDT[order(outDT$x1), ]
> rownames(outDT) <- NULL
> stopifnot(identical(outDT, expected_dt))
> 
> if (requireNamespace("dplyr", quietly = TRUE)) {
+   r <- dplyr::as_tibble(r)
+   l <- dplyr::as_tibble(l)
+   expected_tb <- dplyr::as_tibble(expected_df)
+ } else {
+   r <- as.data.frame(r, stringsAsFactors = FALSE)
+   l <- as.data.frame(l, stringsAsFactors = FALSE)
+   expected_tb <- expected_df
+ }
> outTBL <- getFromNamespace(x = "mdcr_full_outer_join", ns = "medicalcoder")(r, l)
Joining with `by = join_by(x1, x2)`
> outTBL <- outTBL[order(outTBL$x1), ]
> rownames(outTBL) <- NULL
> stopifnot(identical(outTBL, expected_tb))
> 
> # tests with by statements and suffixes
> expected_df <-
+   data.frame(
+     x1 = as.integer(c(1, 1:10, 33, 44, 55, 66, 77, 99, 1100)),
+     x2.right = c("A", "A", "B", "D", "E", "F", "T", "A", "C", "9", "ten", rep(NA_character_, 7)),
+     x2.left  = c("a", "a1", "b", rep(NA_character_, 5), "c", rep(NA_character_, 2), "d", "e", "f", "t", "a", "9", "TEN"),
+     stringsAsFactors = FALSE
+   )
> r <- data.frame(
+   x1 = as.integer(1:10),
+   x2 = c("A", "B", "D", "E", "F", "T", "A", "C", "9", "ten"),
+   stringsAsFactors = FALSE
+ )
> l <- data.frame(
+   x1 = as.integer(c(1, 1, 2, 33, 44, 55, 66, 77, 8, 99, 1100)),
+   x2 = c("a", "a1", "b", "d", "e", "f", "t", "a", "c", "9", "TEN"),
+   stringsAsFactors = FALSE
+ )
> outDF <- getFromNamespace(x = "mdcr_full_outer_join", ns = "medicalcoder")(r, l, by = "x1", suffixes = c(".right", ".left"))
> outDF <- outDF[order(outDF$x1), ]
> rownames(outDF) <- NULL
> stopifnot(identical(outDF, expected_df))
> 
> if (requireNamespace("data.table", quietly = TRUE)) {
+   data.table::setDT(r)
+   data.table::setDT(l)
+   expected_dt <- data.table::copy(expected_df)
+   data.table::setDT(expected_dt)
+ } else {
+   r <- as.data.frame(r, stringsAsFactors = FALSE)
+   l <- as.data.frame(l, stringsAsFactors = FALSE)
+   expected_dt <- expected_df
+ }
> outDT <- getFromNamespace(x = "mdcr_full_outer_join", ns = "medicalcoder")(r, l, by = "x1", suffixes = c(".right", ".left"))
> outDT <- outDT[order(outDT$x1), ]
> rownames(outDT) <- NULL
> stopifnot(identical(outDT, expected_dt))
> 
> if (requireNamespace("dplyr", quietly = TRUE)) {
+   r <- dplyr::as_tibble(r)
+   l <- dplyr::as_tibble(l)
+   expected_tb <- dplyr::as_tibble(expected_df)
+ } else {
+   r <- as.data.frame(r, stringsAsFactors = FALSE)
+   l <- as.data.frame(l, stringsAsFactors = FALSE)
+   expected_tb <- expected_df
+ }
> outTBL <- getFromNamespace(x = "mdcr_full_outer_join", ns = "medicalcoder")(r, l, by = "x1", suffixes = c(".right", ".left"))
> outTBL <- outTBL[order(outTBL$x1), ]
> rownames(outTBL) <- NULL
> stopifnot(identical(outTBL, expected_tb))
> 
> ################################################################################
> # testing mdcr_unique
> DF <- expand.grid(x1 = LETTERS, x2 = LETTERS)
> DF <- rbind(DF, DF, DF, DF, DF, DF)
> DF <- DF[sample(seq_len(nrow(DF))), ]
> rownames(DF) <- NULL
> if (requireNamespace("dplyr", quietly = TRUE)) {
+   TBL <- getExportedValue(ns = "dplyr", name = "as_tibble")(DF)
+ } else {
+   TBL <- DF
+   class(TBL) <- c("tbl_df", class(TBL))
+ }
> if (requireNamespace("data.table", quietly = TRUE)) {
+   DT <- getExportedValue(name = "copy", ns = "data.table")(DF)
+   getExportedValue(name = "setDT", ns = "data.table")(DT)
+ } else {
+   DT <- DF
+   class(DT) <- c("data.table", class(DT))
+ }
> 
> uDF <- unique(DF)
> 
> stopifnot(
+   all.equal(uDF, getFromNamespace(x = "mdcr_unique", ns = "medicalcoder")(DF), check.attributes = FALSE),
+   all.equal(uDF, getFromNamespace(x = "mdcr_unique", ns = "medicalcoder")(DT), check.attributes = FALSE),
+   all.equal(uDF, getFromNamespace(x = "mdcr_unique", ns = "medicalcoder")(TBL), check.attributes = FALSE)
+ )
> 
> 
> ################################################################################
> # testing mdcr_cbind
> 
> ################################################################################
> #                                 End of File                                  #
> ################################################################################
> 
> proc.time()
   user  system elapsed 
   3.70    0.37    4.01