diff --git a/.Rbuildignore b/.Rbuildignore index c8f33b90..69ad6826 100644 --- a/.Rbuildignore +++ b/.Rbuildignore @@ -1,8 +1,9 @@ ^.*\.Rproj$ ^\.Rproj\.user$ -example.*?.R ^\.travis\.yml$ cran-comments.md ^\.github$ ^LICENSE\.md$ -^CODE_OF_CONDUCT\.md$ \ No newline at end of file +^CODE_OF_CONDUCT\.md$ +^doc$ +^Meta$ diff --git a/.gitignore b/.gitignore index 5e5317ce..9b66c27c 100644 --- a/.gitignore +++ b/.gitignore @@ -2,3 +2,5 @@ /R/*.Rhistory /tests/testthat/*.Rhistory /vignettes/*.Rhistory +doc +Meta diff --git a/DESCRIPTION b/DESCRIPTION index 5b5efa27..a13a2de0 100644 --- a/DESCRIPTION +++ b/DESCRIPTION @@ -1,7 +1,7 @@ Package: PKNCA Type: Package Title: Perform Pharmacokinetic Non-Compartmental Analysis -Version: 0.9.0 +Version: 0.9.1 Authors@R: c( person("Bill", "Denney", email="wdenney@humanpredictions.com", role=c("aut", "cre"), comment=c(ORCID="0000-0002-5759-428X")), person("Clare", "Buckeridge", email="clare.buckeridge@pfizer.com", role="aut"), diff --git a/NEWS.md b/NEWS.md index 482e6fa7..45212222 100644 --- a/NEWS.md +++ b/NEWS.md @@ -4,6 +4,10 @@ will continue until then. These will be especially noticable around the inclusion of IV NCA parameters and additional specifications of the dosing including dose amount and route. +# PKNCA 0.9.1 + +* Correct vignette building. + # PKNCA 0.9.0 * Breaking Change: `plot.PKNCAconc()` was moved to the pknca.reporting package diff --git a/vignettes/AUC-Calculation-with-PKNCA.html b/doc/AUC-Calculation-with-PKNCA.html similarity index 100% rename from vignettes/AUC-Calculation-with-PKNCA.html rename to doc/AUC-Calculation-with-PKNCA.html diff --git a/doc/Data-Cleaning-in-PKNCA.html b/doc/Data-Cleaning-in-PKNCA.html new file mode 100644 index 00000000..905fff70 --- /dev/null +++ b/doc/Data-Cleaning-in-PKNCA.html @@ -0,0 +1,425 @@ + + + + + + + + + + + + + + + + +Data-Cleaning-in-PKNCA.utf8.md + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
+ + + + + + + + + + + + +
+ + + + + + + + + + + + + + + diff --git a/vignettes/Example-theophylline.html b/doc/Example-theophylline.html similarity index 99% rename from vignettes/Example-theophylline.html rename to doc/Example-theophylline.html index 1f505538..1f9199d1 100644 --- a/vignettes/Example-theophylline.html +++ b/doc/Example-theophylline.html @@ -4062,7 +4062,7 @@

Multiple Dose Example

## attr(,"class") ## [1] "PKNCAresults" "list" ## attr(,"provenance") -## Provenance hash 51b59f882a9f3a2811324a5ff10bb22b generated on 2019-07-21 10:07:39 with R version 3.6.1 (2019-07-05). +## Provenance hash 51b59f882a9f3a2811324a5ff10bb22b generated on 2019-07-28 14:49:08 with R version 3.6.1 (2019-07-05). 
summary(results_obj)
##  start end  N     auclast        cmax
 ##      0  24 12 98.8 [23.0] 8.65 [17.0]
diff --git a/vignettes/Introduction-and-Usage.html b/doc/Introduction-and-Usage.html
similarity index 80%
rename from vignettes/Introduction-and-Usage.html
rename to doc/Introduction-and-Usage.html
index 7cead0ea..b3e60c43 100644
--- a/vignettes/Introduction-and-Usage.html
+++ b/doc/Introduction-and-Usage.html
@@ -330,44 +330,37 @@ 
Bill Denney

 
Quick Start

 
The simplest analysis requires concentration and dosing data, then five function calls can provide summarized results. (Please note that this and the other examples in this document are intended to show the typical workflow, but they are not intended to run directly. For an example to run directly, please see the theophylline example.)

 
library(PKNCA)
-library(dplyr, quietly=TRUE)

-
## 
-## Attaching package: 'dplyr'

-
## The following objects are masked from 'package:stats':
-## 
-##     filter, lag

-
## The following objects are masked from 'package:base':
-## 
-##     intersect, setdiff, setequal, union

-
## Load the PK concentration data
-d_conc <- datasets::Theoph %>%
-  mutate(Subject=as.numeric(as.character(Subject)))
-## Generate the dosing data
-d_dose <- d_conc[d_conc$Time == 0,]
-d_dose$Time <- 0
-
-## Create a concentration object specifying the concentration, time, and
-## subject columns.  (Note that any number of grouping levels is
-## supported; you are not restricted to just grouping by subject.)
-conc_obj <- PKNCAconc(d_conc,
-                      conc~Time|Subject)
-## Create a dosing object specifying the dose, time, and subject
-## columns.  (Note that the grouping factors should be the same as or a
-## subset of the grouping factors for concentration, and the grouping
-## columns must have the same names between concentration and dose
-## objects.)
-dose_obj <- PKNCAdose(d_dose,
-                      Dose~Time|Subject)
-## Combine the concentration and dosing information both to
-## automatically define the intervals for NCA calculation and provide
-## doses for calculations requiring dose.
-data_obj <- PKNCAdata(conc_obj, dose_obj)
-
-## Calculate the NCA parameters
-results_obj <- pk.nca(data_obj)
-
-## Summarize the results
-summary(results_obj)

+library(dplyr, quietly=TRUE)
+
+## Load the PK concentration data
+d_conc <- datasets::Theoph %>%
+  mutate(Subject=as.numeric(as.character(Subject)))
+## Generate the dosing data
+d_dose <- d_conc[d_conc$Time == 0,]
+d_dose$Time <- 0
+
+## Create a concentration object specifying the concentration, time, and
+## subject columns.  (Note that any number of grouping levels is
+## supported; you are not restricted to just grouping by subject.)
+conc_obj <- PKNCAconc(d_conc,
+                      conc~Time|Subject)
+## Create a dosing object specifying the dose, time, and subject
+## columns.  (Note that the grouping factors should be the same as or a
+## subset of the grouping factors for concentration, and the grouping
+## columns must have the same names between concentration and dose
+## objects.)
+dose_obj <- PKNCAdose(d_dose,
+                      Dose~Time|Subject)
+## Combine the concentration and dosing information both to
+## automatically define the intervals for NCA calculation and provide
+## doses for calculations requiring dose.
+data_obj <- PKNCAdata(conc_obj, dose_obj)
+
+## Calculate the NCA parameters
+results_obj <- pk.nca(data_obj)
+
+## Summarize the results
+summary(results_obj)
##  start end  N     auclast        cmax               tmax   half.life
 ##      0  24 12 74.6 [24.3]           .                  .           .
 ##      0 Inf 12           . 8.65 [17.0] 1.14 [0.630, 3.55] 8.18 [2.12]
@@ -388,7 +381,7 @@ 
Options: Make PKNCA Work Your Way

 
Calculation Options: the PKNCA.options Function

 
Different organizations have different requirements for computation and summarization of NCA. Options for how to perform calculations and summaries are handled by the PKNCA.options command.

 
Default options have been set to commonly-used standard parameters. The current value for options can be found by running the command with no arguments:

-
PKNCA.options()

+
PKNCA.options()

 
## $adj.r.squared.factor
 ## [1] 1e-04
 ## 
@@ -480,90 +473,90 @@ 
Calculation Options: the PKNCA.options Function

 ## 1             FALSE   FALSE    FALSE      FALSE       FALSE
 ## 2             FALSE   FALSE    FALSE      FALSE       FALSE

 
And, to reset the current values to the library defaults, run the function with the default argument set to TRUE.

-
PKNCA.options(default=TRUE)

+
PKNCA.options(default=TRUE)

 
Each of the options is documented where it is used; for example, the first.tmax option is documented in the pk.calc.tmax function.

 
 

 
Summarization Options: the PKNCA.set.summary Function

 
On top of methods of calculation, summarization method preferences differ. Typical summarization preferences include selection of the measurement of central tendency and dispersion, handling of missing values, handling of values below the limit of quantification, and more. Beyond the method for summarization, presentation is managed through user preferences. Presentation is typically controlled by rounding to either a defined number of decimal places or significant figures.

 
An example is that Cmax may be summarized by the geometric mean with the geometric CV using three significant figures, and having a summary result requires that at least half of the available values are present (not missing). The code below will set this example.

-
PKNCA.set.summary(name="cmax",
-                  point=business.geomean,
-                  spread=business.geocv,
-                  rounding=list(signif=3))

+
PKNCA.set.summary(name="cmax",
+                  point=business.geomean,
+                  spread=business.geocv,
+                  rounding=list(signif=3))

 
Another example is that Tmax is usually summarized by the median and range, and as measurements are often taken with minute resolution and recorded in hours, reporting is usually to the second decimal place.

-
PKNCA.set.summary(name="tmax",
-                  point=business.median,
-                  spread=business.range,
-                  rounding=list(round=2))

+
PKNCA.set.summary(name="tmax",
+                  point=business.median,
+                  spread=business.range,
+                  rounding=list(round=2))

 
If the functions or default rounding options provided in the library do not meet the summarization needs, a user-supplied function can be used for rounding.

-
median_na <- function(x) {
-  median(x, na.rm=TRUE)
-}
-quantprob_na <- function(x) {
-  quantile(x, probs=c(0.05, 0.95), na.rm=TRUE)
-}
-PKNCA.set.summary(name="auclast",
-                  point=median_na,
-                  spread=quantprob_na,
-                  rounding=list(signif=3))

+
median_na <- function(x) {
+  median(x, na.rm=TRUE)
+}
+quantprob_na <- function(x) {
+  quantile(x, probs=c(0.05, 0.95), na.rm=TRUE)
+}
+PKNCA.set.summary(name="auclast",
+                  point=median_na,
+                  spread=quantprob_na,
+                  rounding=list(signif=3))

 
In some cases multiple parameters may need the same summary functions (as often occurs with simulated data). Many parameters can be set simultaneously by specifying a vector of names.

-
median_na <- function(x) {
-  median(x, na.rm=TRUE)
-}
-quantprob_na <- function(x) {
-  quantile(x, probs=c(0.05, 0.95), na.rm=TRUE)
-}
-PKNCA.set.summary(name=c("auclast", "cmax", "tmax", "half.life", "aucinf.pred"),
-                  point=median_na,
-                  spread=quantprob_na,
-                  rounding=list(signif=3))

+
median_na <- function(x) {
+  median(x, na.rm=TRUE)
+}
+quantprob_na <- function(x) {
+  quantile(x, probs=c(0.05, 0.95), na.rm=TRUE)
+}
+PKNCA.set.summary(name=c("auclast", "cmax", "tmax", "half.life", "aucinf.pred"),
+                  point=median_na,
+                  spread=quantprob_na,
+                  rounding=list(signif=3))

 

 
 

 
Grouping NCA Data

 
As described in the quick start, concentration and dose data are generally grouped to identify how to separate the data. Typical groups for concentration data include study, treatment, subject, and analyte. Typical groups for dose data include study, treatment, and subject. By default, summaries are produced based on the concentration groups dropping the subject (so that averages are taken across subjects within the other parameters).

 
The quick start example can be extended to include multiple analytes as follows. The only difference is the /analyte formula element in the concentration data. The reason for the slash instead of the plus is that the last element before a slash is assumed to be the subject, and as noted before, the subject is (by default) excluded from the summary grouping (so that summaries are grouped by study, treatment, etc., but not by subject).

-
## Generate a faux multi-study, multi-analyte dataset.
-d_conc_parent <- d_conc
-d_conc_parent$Subject <- as.numeric(as.character(d_conc_parent$Subject))
-d_conc_parent$Study <- d_conc_parent$Subject <= 6
-d_conc_parent$Analyte <- "Parent"
-d_conc_metabolite <- d_conc_parent
-d_conc_metabolite$conc <- d_conc_metabolite$conc/2
-d_conc_metabolite$Analyte <- "Metabolite"
-d_conc_both <- rbind(d_conc_parent, d_conc_metabolite)
-d_conc_both <- d_conc_both[with(d_conc_both, order(Study, Subject, Time, Analyte)),]
-d_dose_both <- d_conc_both[d_conc_both$Time == 0 & d_conc_both$Analyte %in% "Parent",
-                           c("Study", "Subject", "Dose", "Time")]
-
-## Create a concentration object specifying the concentration, time,
-## study, and subject columns.  (Note that any number of grouping
-## levels is supporting; you are not restricted to this list.)
-conc_obj <- PKNCAconc(d_conc_both,
-                      conc~Time|Study+Subject/Analyte)
-## Create a dosing object specifying the dose, time, study, and
-## subject columns.  (Note that the grouping factors should be a
-## subset of the grouping factors for concentration, and the columns
-## must have the same names between concentration and dose objects.)
-dose_obj <- PKNCAdose(d_dose_both,
-                     Dose~Time|Study+Subject)
-
-# Perform and summarize the PK data as previously described
-data_obj <- PKNCAdata(conc_obj, dose_obj)
-results_obj <- pk.nca(data_obj)
-summary(results_obj)

+
## Generate a faux multi-study, multi-analyte dataset.
+d_conc_parent <- d_conc
+d_conc_parent$Subject <- as.numeric(as.character(d_conc_parent$Subject))
+d_conc_parent$Study <- d_conc_parent$Subject <= 6
+d_conc_parent$Analyte <- "Parent"
+d_conc_metabolite <- d_conc_parent
+d_conc_metabolite$conc <- d_conc_metabolite$conc/2
+d_conc_metabolite$Analyte <- "Metabolite"
+d_conc_both <- rbind(d_conc_parent, d_conc_metabolite)
+d_conc_both <- d_conc_both[with(d_conc_both, order(Study, Subject, Time, Analyte)),]
+d_dose_both <- d_conc_both[d_conc_both$Time == 0 & d_conc_both$Analyte %in% "Parent",
+                           c("Study", "Subject", "Dose", "Time")]
+
+## Create a concentration object specifying the concentration, time,
+## study, and subject columns.  (Note that any number of grouping
+## levels is supporting; you are not restricted to this list.)
+conc_obj <- PKNCAconc(d_conc_both,
+                      conc~Time|Study+Subject/Analyte)
+## Create a dosing object specifying the dose, time, study, and
+## subject columns.  (Note that the grouping factors should be a
+## subset of the grouping factors for concentration, and the columns
+## must have the same names between concentration and dose objects.)
+dose_obj <- PKNCAdose(d_dose_both,
+                     Dose~Time|Study+Subject)
+
+# Perform and summarize the PK data as previously described
+data_obj <- PKNCAdata(conc_obj, dose_obj)
+results_obj <- pk.nca(data_obj)
+summary(results_obj)

 

 

 
Selecting Calculation Intervals

 
All NCA calculations require the inverval over which they are calculated. When the concentration and dosing information are combined to the PKNCAdata object, intervals are automatically determined. The exception to this automatic determination is if the user provides intervals.

 
When selected either automatically or manually, intervals define at minimum a start time, an end time, and the parameters to be calculated. The parameter list is available from the get.interval.cols function. The parameters requested are specified by setting the entry in a data.frame as requested.

-
intervals <-
-  data.frame(start=0, end=c(24, Inf),
-             cmax=c(FALSE, TRUE),
-             tmax=c(FALSE, TRUE),
-             auclast=TRUE,
-             aucinf.obs=c(FALSE, TRUE))

+
intervals <-
+  data.frame(start=0, end=c(24, Inf),
+             cmax=c(FALSE, TRUE),
+             tmax=c(FALSE, TRUE),
+             auclast=TRUE,
+             aucinf.obs=c(FALSE, TRUE))

 
Intervals like the above is sufficient for designs with a single type of treatment– like single doses. For more complex treatments in a single analysis, like the combination of single and multiple doses, include a treatment column matching the treatment column name from the concentration data set. See the Manual Interval Specification section below for more details.

 

 
Selection of Data Used for Calculation

@@ -878,18 +871,18 @@ 
Automatic Interval Determination

 
 
 
For multiple-dose studies, PKNCA selects one group at a time and compares the concentration and dosing times. When there is a concentation measurement between doses, an interval row is added. The dosing interval (\(\tau\)) is determined by looking for pattern repeats within the dosing data using the find.tau function.

-
## find.tau can work when all doses have the same interval...
-dose_times <- seq(0, 168, by=24)
-print(dose_times)

+
## find.tau can work when all doses have the same interval...
+dose_times <- seq(0, 168, by=24)
+print(dose_times)

 
## [1]   0  24  48  72  96 120 144 168

-
PKNCA::find.tau(dose_times)

+
PKNCA::find.tau(dose_times)

 
## [1] 24

-
## or when the doses have mixed intervals (10 and 24 hours).
-dose_times <- sort(c(seq(0, 168, by=24),
-                     seq(10, 178, by=24)))
-print(dose_times)

+
## or when the doses have mixed intervals (10 and 24 hours).
+dose_times <- sort(c(seq(0, 168, by=24),
+                     seq(10, 178, by=24)))
+print(dose_times)

 
##  [1]   0  10  24  34  48  58  72  82  96 106 120 130 144 154 168 178

-
PKNCA::find.tau(dose_times)

+
PKNCA::find.tau(dose_times)

 
## [1] 24

 
After finding \(\tau\), PKNCA will also look after the last dose (or the beginning of the last dosing interval), and two additional intervals may be added:

 
    
@@ -902,19 +895,19 @@ 
    Automatic Interval Determination
    
 
    Manual Interval Specification
    
 
    Intervals can also be specified manually. Two use cases are common for manual specification: fully manual (never requesting the automatic intervals) and updating the automatic intervals.
    
 
    Fully manual intervals can be specified by providing it to the PKNCAdata call.
    
-
    intervals_manual <-
-  data.frame(start=0, end=c(24, Inf),
-             cmax=c(FALSE, TRUE),
-             tmax=c(FALSE, TRUE),
-             auclast=TRUE,
-             aucinf.obs=c(FALSE, TRUE))
-data_obj <- PKNCAdata(conc_obj, dose_obj, 
-                      intervals=intervals_manual)
    
+
    intervals_manual <-
+  data.frame(start=0, end=c(24, Inf),
+             cmax=c(FALSE, TRUE),
+             tmax=c(FALSE, TRUE),
+             auclast=TRUE,
+             aucinf.obs=c(FALSE, TRUE))
+data_obj <- PKNCAdata(conc_obj, dose_obj, 
+                      intervals=intervals_manual)
    
 
    To update the automatically-selected intervals, extract the intervals, modify them, and put them back.
    
-
    data_obj <- PKNCAdata(conc_obj, dose_obj)
-intervals_manual <- data_obj$intervals
-intervals_manual$aucinf.obs[1] <- TRUE
-data_obj$intervals <- intervals_manual
    
+
    data_obj <- PKNCAdata(conc_obj, dose_obj)
+intervals_manual <- data_obj$intervals
+intervals_manual$aucinf.obs[1] <- TRUE
+data_obj$intervals <- intervals_manual
    
 

 

 
diff --git a/vignettes/Methods-for-Dose-Aware-Interpolation-and-Extrapolation.html b/doc/Methods-for-Dose-Aware-Interpolation-and-Extrapolation.html
similarity index 100%
rename from vignettes/Methods-for-Dose-Aware-Interpolation-and-Extrapolation.html
rename to doc/Methods-for-Dose-Aware-Interpolation-and-Extrapolation.html
diff --git a/vignettes/Options-for-Controlling-PKNCA.html b/doc/Options-for-Controlling-PKNCA.html
similarity index 99%
rename from vignettes/Options-for-Controlling-PKNCA.html
rename to doc/Options-for-Controlling-PKNCA.html
index bc526b42..eaf36bea 100644
--- a/vignettes/Options-for-Controlling-PKNCA.html
+++ b/doc/Options-for-Controlling-PKNCA.html
@@ -242,7 +242,7 @@ 
Bill Denney

 
 

 
Summary

-
PKNCA has many options that control its function. These options have effects throughout the package. The options are controlled using either the PKNCA.options function or by passing the options argument to any of the functions with that as an argument. All options supported by the current version of PKNCA (0.8.5.9013) are listed below with their descriptions.

+
PKNCA has many options that control its function. These options have effects throughout the package. The options are controlled using either the PKNCA.options function or by passing the options argument to any of the functions with that as an argument. All options supported by the current version of PKNCA (0.9.0) are listed below with their descriptions.

 

 

 
Options

diff --git a/doc/PKNCA-validation.html b/doc/PKNCA-validation.html
new file mode 100644
index 00000000..4d9c2ff0
--- /dev/null
+++ b/doc/PKNCA-validation.html
@@ -0,0 +1,17782 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+PKNCA Validation
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
PKNCA Validation

+
Bill Denney

+
+
+
+
+

+
Introduction

+
To run the tests, the package must be installed with its tests:

+
    
+
  • To install from CRAN:
+
      
+
    • install.packages(pkgs="PKNCA", INSTALL_opts="--install-tests")
      • 
+
    • 
+
  • To install from GitHub:
+
      
+
    • library(devtools)
      • 
+
    • install_github("billdenney/pknca", args="--install-tests")
      • 
+
    • 
+

+
Testing and validation that results match in a local environment compared to the original environment is an important part of confirmation that a package works as expected.

+
Re-running this vignette in your local environment will confirm that local results match those in the original package development. Test success is confirmed by the existence of no failed tests; warnings are expected during testing (and not shown in this vignette for that reason); and some tests may be skipped, but those are expected as well.

+

+

+
Summary of Testing

+
The following sentence is dynamically generated to summarize the testing results: All tests passed.

+

+

+
Testing Log

+

+
Interval columns

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Testing FilenameTest DescriptionNumber of TestsNumber of Failed Testspassedresult
test-001-add.interval.col.Radd.interval.col16016list(list(message = "“, srcref = c(8, 3, 10, 70, 3, 70, 8, 10), expectation_calls = list(expect_error(add.interval.col(name = 1), regexp =”name must be a character string“, info =”interval column name must be a character string“)), call = list(expect_error(add.interval.col(name = 1), regexp =”name must be a character string“, info =”interval column name must be a character string“)), start_frame = 74, end_frame = 74, test =”add.interval.col“), list(message =”", srcref = c(11, 3, 13, 77, 3,
77, 11, 13), expectation_calls= list(expect_error(add.interval.col(name = c(“a”, “b”)), regexp = "name must have length“, info =”interval column name must be a scalar character string“)), call = list(expect_error(add.interval.col(name = c(”a“,”b“)), regexp =”name must have length“, info =”interval column name must be a scalar character string“)), start_frame = 74, end_frame = 74, test =”add.interval.col“), list(message =”", srcref = c(15, 3, 17, 87, 3, 87, 15, 17), expectation_calls = list(
expect_error(add.interval.col(name = “a”, FUN= c(“a”, “b”)), regexp = "FUN must have length == 1“, info =”interval column function must be a scalar character string or NA“)), call = list(expect_error(add.interval.col(name =”a“, FUN = c(”a“,”b“)), regexp =”FUN must have length == 1“, info =”interval column function must be a scalar character string or NA“)), start_frame = 74, end_frame = 74, test =”add.interval.col“), list(message =”", srcref = c(18, 3, 20, 80, 3, 80, 18, 20), expectation_calls = list(
expect_error(add.interval.col(name = “a”, FUN= 1), regexp = "FUN must be a character string or NA“, info =”interval column function must be a character string or NA“)), call = list(expect_error(add.interval.col(name =”a“, FUN = 1), regexp =”FUN must be a character string or NA“, info =”interval column function must be a character string or NA“)), start_frame = 74, end_frame = 74, test =”add.interval.col“), list(message =”", srcref = c(22, 3, 24, 66, 3, 66, 22, 24), expectation_calls = list(
expect_error(add.interval.col(name = “a”, FUN= NA, datatype =“individual”), regexp = "Only the‘interval’ datatype is currently supported.“, info =”interval column datatype must be ‘interval’“)), call = list(expect_error(add.interval.col(name =”a“, FUN = NA, datatype =”individual“), regexp =”Only the ‘interval’ datatype is currently supported.“, info =”interval column datatype must be ‘interval’“)), start_frame = 74, end_frame = 74, test =”add.interval.col“), list(message =”", srcref = c(26,
3, 28, 67, 3, 67, 26, 28), expectation_calls = list(expect_error(add.interval.col(name = “a”, FUN = NA, datatype = “interval”, desc = 1:2), regexp = “desc must have length == 1”, info = “interval column description must be a scalar”)), call = list(expect_error(add.interval.col(name = “a”, FUN = NA, datatype = “interval”, desc = 1:2), regexp = “desc must have length == 1”, info = “interval column description must be a scalar”)), start_frame = 74, end_frame = 74, test = “add.interval.col”), list(message = "",
srcref = c(29, 3, 31, 77,3, 77, 29, 31), expectation_calls = list(expect_error(add.interval.col(name = “a”, FUN = NA, datatype = “interval”, desc = 1), regexp = “desc must be a character string”, info = “interval column description must be a character scalar”)), call = list(expect_error(add.interval.col(name = “a”, FUN = NA, datatype = “interval”, desc = 1), regexp = “desc must be a character string”, info = “interval column description must be a character scalar”)), start_frame = 74, end_frame = 74,
test = “add.interval.col”), list(message = "", srcref = c(32, 3, 34, 69, 3, 69, 32, 34),expectation_calls = list(expect_error(add.interval.col(name = “a”, FUN = “this function does not exist”, datatype = “interval”, desc = “test addition”), regexp = "The function named ’.*’ is not defined. Please define the function before calling add.interval.col.“, info =”interval column function must exist (or be NA)“)), call = list(expect_error(add.interval.col(name =”a“, FUN =”this function does not exist",
datatype = “interval”, desc = “test addition”), regexp = "The function named ’.*’ is notdefined.Please define the function before calling add.interval.col.“, info =”interval column function must exist (or be NA)“)), start_frame = 74, end_frame = 74, test =”add.interval.col“), list(message =”“, srcref = c(37, 3, 39, 48, 3, 48, 37, 39), expectation_calls = list(expect_error(add.interval.col(name =”a“, FUN =”mean“, formalsmap = NA), regexp =”formalsmap must be a list“, info =”formalsmap must be a list")),
call = list(expect_error(add.interval.col(name = “a”, FUN = "mean", formalsmap = NA), regexp = "formalsmap must be a list“, info =”formalsmap must be a list“)), start_frame = 74, end_frame = 74, test =”add.interval.col“), list(message =”“, srcref = c(40, 3, 42, 54, 3, 54, 40, 42), expectation_calls = list(expect_error(add.interval.col(name =”a“, FUN =”mean“, formalsmap = list(1)), regexp =”formalsmap must be a named list“, info =”formalsmap must be a named list“)), call = list(expect_error(add.interval.col(name =”a",
FUN = “mean”, formalsmap =list(1)), regexp ="formalsmap mustbe a named list", info ="formalsmap must be a named list“)), start_frame = 74, end_frame = 74, test =”add.interval.col“), list(message =”“, srcref = c(43, 3, 45, 60, 3, 60, 43, 45), expectation_calls = list(expect_error(add.interval.col(name =”a“, FUN = NA, formalsmap = list(A =”b“)), regexp =”formalsmap may not be given when FUN is NA“, info =”formalsmap cannot be used with FUN=NA“)), call = list(expect_error(add.interval.col(name =”a",
FUN = NA, formalsmap = list(A = “b”)), regexp= "formalsmap maynot be given when FUN isNA", info = “formalsmap cannot be used with FUN=NA”)), start_frame = 74, end_frame = 74, test = “add.interval.col”), list(message = "“, srcref = c(46, 3, 48, 63, 3, 63, 46, 48), expectation_calls = list(expect_error(add.interval.col(name =”a“, FUN =”mean“, formalsmap = list(A =”a“,”b“)), regexp =”All formalsmap elements must be named“, info =”Each element of formalsmap must be named")), call = list(
expect_error(add.interval.col(name = “a”, FUN= “mean”, formalsmap = list(A = “a”, “b”)), regexp= “All formalsmap elements must be named”, info = “Each element of formalsmap must be named”)), start_frame = 74, end_frame = 74, test = “add.interval.col”), list(message = "“, srcref = c(49, 3, 51, 74, 3, 74, 49, 51), expectation_calls = list(expect_error(add.interval.col(name =”a“, FUN =”mean“, formalsmap = list(y =”a“)), regexp =”All names for the formalsmap list must be arguments to the function",
info = "formalsmap arguments must map to function arguments")),call = list(expect_error(add.interval.col(name = “a”, FUN = “mean”, formalsmap = list(y = “a”)), regexp = “All names for the formalsmap list must be arguments to the function”, info = “formalsmap arguments must map to function arguments”)), start_frame = 74, end_frame = 74, test = “add.interval.col”), list(message = “{…} not equal to list(…).”, srcref = c(53, 3, 64, 56, 3, 56, 53, 64), expectation_calls = list(expect_equal({
add.interval.col(name = "a", FUN = NA, datatype = “interval”, desc = “test addition”)
get(“interval.cols”, PKNCA:::.PKNCAEnv)[[“a”]]
}, list(FUN = NA, values = c(FALSE, TRUE), desc =“test addition”,formalsmap = list(), depends = c(), datatype = “interval”), info = “interval column assignment works with FUN=NA”)), call = list(expect_equal({
add.interval.col(name = "a", FUN = NA, datatype = “interval”, desc = “test addition”)
get(“interval.cols”, PKNCA:::.PKNCAEnv)[[“a”]]
}, list(FUN = NA, values = c(FALSE, TRUE), desc =“test addition”,formalsmap = list(), depends = c(), datatype = “interval”), info = “interval column assignment works with FUN=NA”)), start_frame = 74, end_frame = 74, test = “add.interval.col”), list(message = “{…} not equal to list(…).”, srcref = c(65, 3, 76, 72, 3, 72, 65, 76), expectation_calls = list(expect_equal({
add.interval.col(name = "a“, FUN =”mean", datatype = "interval“, desc =”test addition")
get(“interval.cols”, PKNCA:::.PKNCAEnv)[[“a”]]
}, list(FUN = “mean”, values =c(FALSE, TRUE), desc = "test addition", formalsmap = list(),depends =c(), datatype = “interval”), info = “interval column assignment works with FUN=a character string”)), call = list(expect_equal({
add.interval.col(name = "a“, FUN =”mean", datatype = "interval“, desc =”test addition")
get(“interval.cols”, PKNCA:::.PKNCAEnv)[[“a”]]
}, list(FUN = “mean”, values =c(FALSE, TRUE), desc = "test addition", formalsmap = list(),depends =c(), datatype = “interval”), info = “interval column assignment works with FUN=a character string”)), start_frame = 74, end_frame = 74, test = “add.interval.col”), list(message = “{…} not equal to list(…).”, srcref = c(77, 3, 88, 56, 3, 56, 77, 88), expectation_calls = list(expect_equal({
add.interval.col(name = "a“, FUN =”mean", formalsmap = list(x= “values”), desc = "testaddition")
get(“interval.cols”, PKNCA:::.PKNCAEnv)[[“a”]]
}, list(FUN = “mean”, values =c(FALSE, TRUE), desc = "test addition", formalsmap = list(x =“values”), depends = c(), datatype = “interval”), info = “interval column assignment works with FUN=NA”)), call = list(expect_equal({
add.interval.col(name = "a“, FUN =”mean", formalsmap = list(x= “values”), desc = "testaddition")
get(“interval.cols”, PKNCA:::.PKNCAEnv)[[“a”]]
}, list(FUN = “mean”, values =c(FALSE, TRUE), desc = "test addition", formalsmap = list(x =“values”), depends = c(), datatype = “interval”), info = “interval column assignment works with FUN=NA”)), start_frame = 74, end_frame = 74, test = “add.interval.col”))

+

+

+
AIC.list testing

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Testing FilenameTest DescriptionNumber of TestsNumber of Failed Testspassedresult
test-AIC.list.RAIC.list505list(list(message = “AIC.list(d1) not equal to result1.”, srcref = c(13, 3, 13, 37, 3, 37, 13, 13), expectation_calls = list(expect_equal(AIC.list(d1), result1)), call = list(expect_equal(AIC.list(d1), result1)), start_frame = 74, end_frame = 74, test = “AIC.list”), list(message = “AIC.list(d2) not equal to result2.”, srcref = c(23, 3, 23, 37, 3, 37, 23, 23), expectation_calls = list(expect_equal(AIC.list(d2), result2)), call = list(expect_equal(AIC.list(d2), result2)), start_frame = 74,
end_frame = 74,test = “AIC.list”), list(message = "AIC.list(d3) not equal to`result3.\nTRUE", srcref = c(32, 3, 32, 37, 3, 37, 32, 32), expectation_calls = list(expect_equal(AIC.list(d3), result3)), call = list(expect_equal(AIC.list(d3), result3)), start_frame = 74, end_frame = 74, test = "AIC.list"), list(message = "AIC.list(d4) not equal toresult4`.", srcref = c(41, 3, 41, 37, 3, 37, 41, 41), expectation_calls = list(expect_equal(AIC.list(d4), result4)), call = list(expect_equal(AIC.list(d4),
result4)), start_frame = 74, end_frame = 74, test =“AIC.list”), list(message= "AIC.list(d5) not equal to result5.“, srcref = c(50, 3, 50, 37, 3, 37, 50, 50), expectation_calls = list(expect_equal(AIC.list(d5), result5)), call = list(expect_equal(AIC.list(d5), result5)), start_frame = 74, end_frame = 74, test =”AIC.list"))
test-AIC.list.Rget.first.model15015list(list(message = “get.first.model(NA) not equal to NA.”, srcref = c(56, 3, 56, 39, 3, 39, 56, 56), expectation_calls = list(expect_equal(get.first.model(NA), NA)), call = list(expect_equal(get.first.model(NA), NA)), start_frame = 74, end_frame = 74, test = “get.first.model”), list(message = “get.first.model(list(NA)) not equal to NA.”, srcref = c(58, 3, 58, 45, 3, 45, 58, 58), expectation_calls = list(expect_equal(get.first.model(list(NA)), NA)), call = list(expect_equal(get.first.model(list(NA)),
NA)), start_frame = 74, end_frame= 74, test = "get.first.model"), list(message = "get.first.model(list(NA, NA)) not equal to NA.“, srcref = c(59, 3, 59, 49, 3, 49, 59, 59), expectation_calls = list(expect_equal(get.first.model(list(NA, NA)), NA)), call = list(expect_equal(get.first.model(list(NA, NA)), NA)), start_frame = 74, end_frame = 74, test =”get.first.model“), list(message =”get.first.model(list(A = NA, B = NA)) not equal to NA.", srcref = c(61, 3, 61, 53, 3, 53, 61, 61),
expectation_calls = list(expect_equal(get.first.model(list(A = NA, B = NA)),NA)), call = list(expect_equal(get.first.model(list(A = NA, B = NA)), NA)), start_frame = 74, end_frame = 74, test = “get.first.model”), list(message = “get.first.model(list(list(NA), list(NA))) not equal to NA.”, srcref = c(63, 3, 63, 61, 3, 61, 63, 63), expectation_calls = list(expect_equal(get.first.model(list(list(NA), list(NA))), NA)), call = list(expect_equal(get.first.model(list(list(NA), list(NA))), NA)),
start_frame = 74, end_frame = 74,test = "get.first.model“), list(message =”get.first.model(list(list(NA, NA))) not equal to NA.“, srcref = c(64, 3, 64, 55, 3, 55, 64, 64), expectation_calls = list(expect_equal(get.first.model(list(list(NA, NA))), NA)), call = list(expect_equal(get.first.model(list(list(NA, NA))), NA)), start_frame = 74, end_frame = 74, test =”get.first.model“), list(message =”get.first.model(list(list(list(NA, NA)))) not equal to NA.", srcref = c(65, 3, 65, 61,
3, 61, 65, 65), expectation_calls = list(expect_equal(get.first.model(list(list(list(NA, NA)))), NA)), call = list(expect_equal(get.first.model(list(list(list(NA, NA)))), NA)), start_frame = 74, end_frame = 74, test = “get.first.model”), list(message = “get.first.model(1) not equal to 1.”, srcref = c(68, 3, 68, 37, 3, 37, 68, 68), expectation_calls = list(expect_equal(get.first.model(1), 1)), call = list(expect_equal(get.first.model(1), 1)), start_frame = 74, end_frame = 74, test = “get.first.model”),
list(message ="get.first.model("B") not equal to"B".", srcref =c(69, 3,69, 41, 3, 41, 69, 69), expectation_calls = list(expect_equal(get.first.model(“B”), “B”)), call = list(expect_equal(get.first.model(“B”), “B”)), start_frame = 74, end_frame = 74, test = “get.first.model”), list(message = “get.first.model(list("A", "B")) not equal to "A".”, srcref = c(72, 3, 72, 52, 3, 52, 72, 72), expectation_calls = list(expect_equal(get.first.model(list(“A”, “B”)), “A”)), call = list(
expect_equal(get.first.model(list(“A”, “B”)), "A")), start_frame = 74, end_frame =74, test = “get.first.model”), list(message = “get.first.model(list(list(list("A")), "B")) not equal to "A".”, srcref = c(74, 3, 74, 64, 3, 64, 74, 74), expectation_calls = list(expect_equal(get.first.model(list(list(list(“A”)), “B”)), “A”)), call = list(expect_equal(get.first.model(list(list(list(“A”)), “B”)), “A”)), start_frame = 74, end_frame = 74, test = “get.first.model”), list(message = “get.first.model(list(NA, "A")) not equal to "A".”,
srcref = c(77, 3, 77, 51, 3, 51, 77, 77), expectation_calls = list(expect_equal(get.first.model(list(NA, “A”)), “A”)), call = list(expect_equal(get.first.model(list(NA, “A”)), “A”)), start_frame = 74, end_frame = 74, test = “get.first.model”), list(message = “get.first.model(list(NA, list("A"))) not equal to "A".”, srcref = c(78, 3, 78, 57, 3, 57, 78, 78), expectation_calls = list(expect_equal(get.first.model(list(NA, list(“A”))), “A”)), call = list(expect_equal(get.first.model(list(NA,
list(“A”))), “A”)), start_frame = 74, end_frame= 74, test = "get.first.model"), list(message = “get.first.model(list(list(NA, "A"), "B")) not equal to "A".”, srcref = c(79, 3, 79, 62, 3, 62, 79, 79), expectation_calls = list(expect_equal(get.first.model(list(list(NA, “A”), “B”)), “A”)), call = list(expect_equal(get.first.model(list(list(NA, “A”), “B”)), “A”)), start_frame = 74, end_frame = 74, test = “get.first.model”), list(message = “get.first.model(list(list(NA, mod1), "B")) not equal to mod1.”,
srcref = c(85, 3, 85, 64, 3, 64, 85, 85), expectation_calls = list(expect_equal(get.first.model(list(list(NA, mod1), “B”)), mod1)), call = list(expect_equal(get.first.model(list(list(NA, mod1), “B”)), mod1)), start_frame = 74, end_frame = 74, test = “get.first.model”))
test-AIC.list.Rget.best.model101list(list(message = “get.best.model(d1) not equal to mod2.”, srcref = c(93, 3, 93, 40, 3, 40, 93, 93), expectation_calls = list(expect_equal(get.best.model(d1), mod2)), call = list(expect_equal(get.best.model(d1), mod2)), start_frame = 74, end_frame = 74, test = “get.best.model”))

+

+

+
AUC and AUMC

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Testing FilenameTest DescriptionNumber of TestsNumber of Failed Testspassedresult
test-auc.Rpk.calc.auxc909list(list(message = "“, srcref = c(7, 3, 9, 81, 3, 81, 7, 9), expectation_calls = list(expect_error(pk.calc.auxc(conc = 1:2, time = 0:1, interval = 2:1, method =”linear“), regexp =”The AUC interval must be increasing“, info =”Start and end of the interval must be in the correct order“)), call = list(expect_error(pk.calc.auxc(conc = 1:2, time = 0:1, interval = 2:1, method =”linear“), regexp =”The AUC interval must be increasing“, info =”Start and end of the interval must be in the correct order")),
start_frame = 74, end_frame = 74, test= “pk.calc.auxc”),list(message = "", srcref = c(10,3, 13, 117, 3, 117, 10, 13), expectation_calls = list(expect_warning(pk.calc.auxc(conc = 1:2, time = 2:3, interval = c(1, 3), method = “linear”), regexp = “Requesting an AUC range starting \(1\) before the first measurement \(2\) is not allowed”, info = “AUC should start at or after the first measurement and should be before the last measurement”)), call = list(expect_warning(pk.calc.auxc(conc = 1:2,
time = 2:3, interval = c(1, 3), method= “linear”), regexp = "Requesting an AUC range starting \(1\) before the first measurement \(2\) is not allowed“, info =”AUC should start at or after the first measurement and should be before the last measurement“)), start_frame = 74, end_frame = 74, test =”pk.calc.auxc“), list(message =”“, srcref = c(14, 3, 16, 85, 3, 85, 14, 16), expectation_calls = list(expect_warning(v1 <- pk.calc.auxc(conc = 1:2, time = 2:3, interval = c(1, 3), method =”linear"),
info = "Starting before the beginning time returns NA (not an error)")), call = list(expect_warning(v1 <- pk.calc.auxc(conc = 1:2, time = 2:3, interval = c(1, 3), method = “linear”), info = “Starting before the beginning time returns NA (not an error)”)), start_frame = 74, end_frame = 74, test = “pk.calc.auxc”), list(message = “v1 not equal to NA.”, srcref = c(17, 3, 18, 83, 3, 83, 17, 18), expectation_calls = list(expect_equal(v1, NA, info = “Starting before the beginning time returns NA (not an error)”)),
call = list(expect_equal(v1, NA, info ="Starting beforethe beginning time returns NA (notan error)“)), start_frame = 74, end_frame = 74, test =”pk.calc.auxc“), list(message =”“, srcref = c(21, 3, 23, 62, 3, 62, 21, 23), expectation_calls = list(expect_warning(v2 <- pk.calc.auxc(conc = c(NA, NA), time = 2:3, interval = c(1, 3), method =”linear“), info =”All concentrations NA gives a warning")), call = list(expect_warning(v2 <- pk.calc.auxc(conc = c(NA, NA), time = 2:3, interval = c(1, 3),
method = "linear“), info =”All concentrations NA gives awarning")), start_frame= 74, end_frame = 74, test = “pk.calc.auxc”), list(message = “v2 not equal to NA.”, srcref = c(24, 3, 25, 50, 3, 50, 24, 25), expectation_calls = list(expect_equal(v2, NA, info = “All concentrations NA is NA”)), call = list(expect_equal(v2, NA, info = “All concentrations NA is NA”)), start_frame = 74, end_frame = 74, test = “pk.calc.auxc”), list(message = “pk.calc.auxc(…) not equal to 0.”, srcref = c(27,
3, 30, 40, 3, 40, 27, 30), expectation_calls = list(expect_equal(pk.calc.auxc(conc = c(0, 0), time = 2:3, interval = c(2, 3), method = “linear”), 0, info = “All zeros is zero”)), call = list(expect_equal(pk.calc.auxc(conc = c(0, 0), time = 2:3, interval = c(2, 3), method = “linear”), 0, info = “All zeros is zero”)), start_frame = 74, end_frame = 74, test = “pk.calc.auxc”), list(message = “pk.calc.auxc(…) not equal to 0.”, srcref = c(32, 3, 35, 56, 3, 56, 32, 35), expectation_calls = list(
expect_equal(pk.calc.auxc(conc = c(NA,0, NA), time = 2:4, interval = c(1, 3), method = "linear“), 0, info =”Mixed zeros and NA is still zero.“)), call = list(expect_equal(pk.calc.auxc(conc = c(NA, 0, NA), time = 2:4, interval = c(1, 3), method =”linear“), 0, info =”Mixed zeros and NA is still zero.“)), start_frame = 74, end_frame = 74, test =”pk.calc.auxc“), list(message =”", srcref = c(37, 3, 39, 62, 3, 62, 37, 39), expectation_calls = list(expect_error(pk.calc.auxc(conc = c(NA, 0, NA),
time = 2:4, interval = c(1, 3), method= “foo”), info = "Invalid integration methods are caught.“)), call = list(expect_error(pk.calc.auxc(conc = c(NA, 0, NA), time = 2:4, interval = c(1, 3), method =”foo“), info =”Invalid integration methods are caught.“)), start_frame = 74, end_frame = 74, test =”pk.calc.auxc"))
test-auc.Rpk.calc.auc94094list(list(message = "“, srcref = c(57, 5, 62, 46, 5, 46, 57, 62), expectation_calls = list(runner(v1 <- pk.calc.auc(conc = c(0, 1, 1), time = 0:2, interval = c(0, 2), lambda.z = NA, auc.type = t, method =”linear“))), call = list(runner(v1 <- pk.calc.auc(conc = c(0, 1, 1), time = 0:2, interval = c(0, 2), lambda.z = NA, auc.type = t, method =”linear“))), start_frame = 74, end_frame = 74, test =”pk.calc.auc“), list(message =”v1 not equal to tests[[t]].", srcref = c(63, 5, 63, 40, 5, 40,
63, 63), expectation_calls = list(expect_equal(v1, tests[[t]], info = t)), call = list(expect_equal(v1, tests[[t]], info = t)), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = “v1 not equal to tests[[t]].”, srcref = c(63, 5, 63, 40, 5, 40, 63, 63), expectation_calls = list(expect_equal(v1, tests[[t]], info = t)), call = list(expect_equal(v1, tests[[t]], info = t)), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = “v1 not equal to tests[[t]].”,
srcref = c(63,5, 63, 40, 5, 40, 63, 63), expectation_calls = list(expect_equal(v1, tests[[t]], info = t)), call = list(expect_equal(v1, tests[[t]], info = t)), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = "“, srcref = c(81, 5, 86, 46, 5, 46, 81, 86), expectation_calls = list(runner(v1 <- pk.calc.auc(conc = c(0, 1, 0), time = 0:2, interval = c(0, 2), lambda.z = NA, auc.type = t, method =”linear"))), call = list(runner(v1 <- pk.calc.auc(conc = c(0, 1, 0), time = 0:2,
interval = c(0,2), lambda.z = NA, auc.type = t, method =“linear”))), start_frame= 74, end_frame = 74, test = “pk.calc.auc”), list(message = “v1 not equal to tests[[t]].”, srcref = c(87, 5, 87, 40, 5, 40, 87, 87), expectation_calls = list(expect_equal(v1, tests[[t]], info = t)), call = list(expect_equal(v1, tests[[t]], info = t)), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = “v1 not equal to tests[[t]].”, srcref = c(87, 5, 87, 40, 5, 40, 87, 87),
expectation_calls = list(expect_equal(v1, tests[[t]], info = t)), call = list(expect_equal(v1, tests[[t]], info = t)), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = “v1 not equal to tests[[t]].”, srcref = c(87, 5, 87, 40, 5, 40, 87, 87), expectation_calls = list(expect_equal(v1, tests[[t]], info = t)), call = list(expect_equal(v1, tests[[t]], info = t)), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = "", srcref = c(102, 5, 107, 46, 5,
46, 102, 107), expectation_calls = list(runner(v1 <- pk.calc.auc(conc = c(0, 1, 0), time = 0:2,interval = c(0, 2), lambda.z = 1, auc.type = t, method = “linear”))), call = list(runner(v1 <- pk.calc.auc(conc = c(0, 1, 0), time = 0:2, interval = c(0, 2), lambda.z = 1, auc.type = t, method = “linear”))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = “v1 not equal to tests[[t]].”, srcref = c(108, 5, 108, 40, 5, 40, 108, 108), expectation_calls = list(expect_equal(v1,
tests[[t]], info = t)), call = list(expect_equal(v1, tests[[t]], info = t)), start_frame =74, end_frame = 74, test = “pk.calc.auc”), list(message = “v1 not equal to tests[[t]].”, srcref = c(108, 5, 108, 40, 5, 40, 108, 108), expectation_calls = list(expect_equal(v1, tests[[t]], info = t)), call = list(expect_equal(v1, tests[[t]], info = t)), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = “v1 not equal to tests[[t]].”, srcref = c(108, 5, 108, 40, 5,
40, 108, 108), expectation_calls = list(expect_equal(v1, tests[[t]], info = t)), call= list(expect_equal(v1, tests[[t]], info = t)), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = "“, srcref = c(123, 5, 128, 46, 5, 46, 123, 128), expectation_calls = list(runner(v1 <- pk.calc.auc(conc = c(0, 1, rep(0, 5)), time = 0:6, interval = c(0, 6), lambda.z = 1, auc.type = t, method =”linear"))), call = list(runner(v1 <- pk.calc.auc(conc = c(0, 1, rep(0, 5)), time = 0:6, interval = c(0,
6), lambda.z =1, auc.type = t, method= “linear”))), start_frame = 74, end_frame= 74, test = “pk.calc.auc”), list(message = “v1 not equal to tests[[t]].”, srcref = c(129, 5, 129, 40, 5, 40, 129, 129), expectation_calls = list(expect_equal(v1, tests[[t]], info = t)), call = list(expect_equal(v1, tests[[t]], info = t)), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = “v1 not equal to tests[[t]].”, srcref = c(129, 5, 129, 40, 5, 40, 129, 129), expectation_calls = list(
expect_equal(v1, tests[[t]], info = t)), call = list(expect_equal(v1, tests[[t]],info = t)), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = “v1 not equal to tests[[t]].”, srcref = c(129, 5, 129, 40, 5, 40, 129, 129), expectation_calls = list(expect_equal(v1, tests[[t]], info = t)), call = list(expect_equal(v1, tests[[t]], info = t)), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = "", srcref = c(152, 7, 158, 41, 7, 41, 152, 158), expectation_calls = list(
runner(v1 <- pk.calc.auc(conc = c(0, 2,0, 1, 2, 1), time= 0:5, interval = c(0, 5), lambda.z = 1, auc.type = n, conc.blq = “keep”, method = t))), call = list(runner(v1 <- pk.calc.auc(conc = c(0, 2, 0, 1, 2, 1), time = 0:5, interval = c(0, 5), lambda.z = 1, auc.type = n, conc.blq = “keep”, method = t))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = “v1 not equal to tests[[t]][[n]].”, srcref = c(159, 7, 159, 57, 7, 57, 159, 159), expectation_calls = list(expect_equal(v1,
tests[[t]][[n]], info = paste(t, n))),call = list(expect_equal(v1, tests[[t]][[n]], info =paste(t, n))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = “v1 not equal to tests[[t]][[n]].”, srcref = c(159, 7, 159, 57, 7, 57, 159, 159), expectation_calls = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), call = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = “v1 not equal to tests[[t]][[n]].”,
srcref = c(159,7, 159, 57, 7, 57, 159,159), expectation_calls = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), call = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = "“, srcref = c(152, 7, 158, 41, 7, 41, 152, 158), expectation_calls = list(runner(v1 <- pk.calc.auc(conc = c(0, 2, 0, 1, 2, 1), time = 0:5, interval = c(0, 5), lambda.z = 1, auc.type = n, conc.blq =”keep", method = t))), call = list(
runner(v1 <- pk.calc.auc(conc = c(0, 2,0, 1, 2, 1), time= 0:5, interval = c(0, 5), lambda.z = 1, auc.type = n, conc.blq = “keep”, method = t))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = “v1 not equal to tests[[t]][[n]].”, srcref = c(159, 7, 159, 57, 7, 57, 159, 159), expectation_calls = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), call = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”),
list(message ="v1 not equal to tests[[t]][[n]].", srcref = c(159, 7, 159, 57, 7,57, 159, 159), expectation_calls = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), call = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = “v1 not equal to tests[[t]][[n]].”, srcref = c(159, 7, 159, 57, 7, 57, 159, 159), expectation_calls = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))),
call = list(expect_equal(v1, tests[[t]][[n]], info =paste(t, n))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = "“, srcref = c(181, 7, 187, 41, 7, 41, 181, 187), expectation_calls = list(runner(v1 <- pk.calc.auc(conc = c(0, 2, 0, 1, 2, 1, 0, 0), time = 0:7, interval = c(0, 7), lambda.z = 1, auc.type = n, conc.blq =”keep", method = t))), call = list(runner(v1 <- pk.calc.auc(conc = c(0, 2, 0, 1, 2, 1, 0, 0), time = 0:7, interval = c(0, 7), lambda.z = 1, auc.type = n,
conc.blq =“keep”, method = t))), start_frame = 74, end_frame = 74, test = "pk.calc.auc“), list(message =”v1 not equal to tests[[t]][[n]].“, srcref = c(188, 7, 188, 57, 7, 57, 188, 188), expectation_calls = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), call = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), start_frame = 74, end_frame = 74, test =”pk.calc.auc“), list(message =”v1 not equal to tests[[t]][[n]].", srcref = c(188, 7, 188, 57, 7,
57, 188, 188),expectation_calls = list(expect_equal(v1,tests[[t]][[n]], info = paste(t, n))), call = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = “v1 not equal to tests[[t]][[n]].”, srcref = c(188, 7, 188, 57, 7, 57, 188, 188), expectation_calls = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), call = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), start_frame = 74, end_frame = 74,
test = "pk.calc.auc"), list(message= "", srcref = c(181, 7, 187, 41, 7, 41, 181, 187),expectation_calls = list(runner(v1 <- pk.calc.auc(conc = c(0, 2, 0, 1, 2, 1, 0, 0), time = 0:7, interval = c(0, 7), lambda.z = 1, auc.type = n, conc.blq = “keep”, method = t))), call = list(runner(v1 <- pk.calc.auc(conc = c(0, 2, 0, 1, 2, 1, 0, 0), time = 0:7, interval = c(0, 7), lambda.z = 1, auc.type = n, conc.blq = “keep”, method = t))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(
message = "v1 not equal to tests[[t]][[n]].", srcref = c(188, 7, 188,57, 7, 57, 188, 188), expectation_calls = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), call = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = “v1 not equal to tests[[t]][[n]].”, srcref = c(188, 7, 188, 57, 7, 57, 188, 188), expectation_calls = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))),
call = list(expect_equal(v1, tests[[t]][[n]], info =paste(t, n))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = “v1 not equal to tests[[t]][[n]].”, srcref = c(188, 7, 188, 57, 7, 57, 188, 188), expectation_calls = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), call = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = "", srcref = c(212, 7, 221, 41, 7, 41, 212,
221), expectation_calls = list(runner(v1 <- pk.calc.auc(conc = c(0, 2, 0, 1, 2, 1,0, 0), time = 0:7, interval = c(0, 7), lambda.z = 1, auc.type = n, conc.blq = list(first = “keep”, middle = “drop”, last = “keep”), method = t))), call = list(runner(v1 <- pk.calc.auc(conc = c(0, 2, 0, 1, 2, 1, 0, 0), time = 0:7, interval = c(0, 7), lambda.z = 1, auc.type = n, conc.blq = list(first = “keep”, middle = “drop”, last = “keep”), method = t))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”),
list(message ="v1 not equal to tests[[t]][[n]].", srcref = c(222, 7, 224, 36, 7,36, 222, 224), expectation_calls = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), call = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = “v1 not equal to tests[[t]][[n]].”, srcref = c(222, 7, 224, 36, 7, 36, 222, 224), expectation_calls = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))),
call = list(expect_equal(v1, tests[[t]][[n]], info =paste(t, n))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = “v1 not equal to tests[[t]][[n]].”, srcref = c(222, 7, 224, 36, 7, 36, 222, 224), expectation_calls = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), call = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = "", srcref = c(212, 7, 221, 41, 7, 41, 212,
221), expectation_calls = list(runner(v1 <- pk.calc.auc(conc = c(0, 2, 0, 1, 2, 1,0, 0), time = 0:7, interval = c(0, 7), lambda.z = 1, auc.type = n, conc.blq = list(first = “keep”, middle = “drop”, last = “keep”), method = t))), call = list(runner(v1 <- pk.calc.auc(conc = c(0, 2, 0, 1, 2, 1, 0, 0), time = 0:7, interval = c(0, 7), lambda.z = 1, auc.type = n, conc.blq = list(first = “keep”, middle = “drop”, last = “keep”), method = t))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”),
list(message ="v1 not equal to tests[[t]][[n]].", srcref = c(222, 7, 224, 36, 7,36, 222, 224), expectation_calls = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), call = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = “v1 not equal to tests[[t]][[n]].”, srcref = c(222, 7, 224, 36, 7, 36, 222, 224), expectation_calls = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))),
call = list(expect_equal(v1, tests[[t]][[n]], info =paste(t, n))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = “v1 not equal to tests[[t]][[n]].”, srcref = c(222, 7, 224, 36, 7, 36, 222, 224), expectation_calls = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), call = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = "", srcref = c(246, 7, 255, 41, 7, 41, 246,
255), expectation_calls = list(runner(v1 <- pk.calc.auc(conc = c(0, 2, 0, 1, 2, 1,0, 0), time = 0:7, interval = c(0, 7), lambda.z = NA, auc.type = n, conc.blq = list(first = “keep”, middle = “drop”, last = “keep”), method = t))), call = list(runner(v1 <- pk.calc.auc(conc = c(0, 2, 0, 1, 2, 1, 0, 0), time = 0:7, interval = c(0, 7), lambda.z = NA, auc.type = n, conc.blq = list(first = “keep”, middle = “drop”, last = “keep”), method = t))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”),
list(message ="v1 not equal to tests[[t]][[n]].", srcref = c(256, 7, 258, 36, 7,36, 256, 258), expectation_calls = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), call = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = “v1 not equal to tests[[t]][[n]].”, srcref = c(256, 7, 258, 36, 7, 36, 256, 258), expectation_calls = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))),
call = list(expect_equal(v1, tests[[t]][[n]], info =paste(t, n))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = “v1 not equal to tests[[t]][[n]].”, srcref = c(256, 7, 258, 36, 7, 36, 256, 258), expectation_calls = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), call = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = "", srcref = c(246, 7, 255, 41, 7, 41, 246,
255), expectation_calls = list(runner(v1 <- pk.calc.auc(conc = c(0, 2, 0, 1, 2, 1,0, 0), time = 0:7, interval = c(0, 7), lambda.z = NA, auc.type = n, conc.blq = list(first = “keep”, middle = “drop”, last = “keep”), method = t))), call = list(runner(v1 <- pk.calc.auc(conc = c(0, 2, 0, 1, 2, 1, 0, 0), time = 0:7, interval = c(0, 7), lambda.z = NA, auc.type = n, conc.blq = list(first = “keep”, middle = “drop”, last = “keep”), method = t))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”),
list(message ="v1 not equal to tests[[t]][[n]].", srcref = c(256, 7, 258, 36, 7,36, 256, 258), expectation_calls = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), call = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = “v1 not equal to tests[[t]][[n]].”, srcref = c(256, 7, 258, 36, 7, 36, 256, 258), expectation_calls = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))),
call = list(expect_equal(v1, tests[[t]][[n]], info =paste(t, n))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = “v1 not equal to tests[[t]][[n]].”, srcref = c(256, 7, 258, 36, 7, 36, 256, 258), expectation_calls = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), call = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = "", srcref = c(281, 7, 290, 41, 7, 41, 281,
290), expectation_calls = list(runner(v1 <- pk.calc.auc(conc = c(0, 2, 0, 1, 2, 1,NA, 0),time = 0:7, interval = c(0, 7), lambda.z = NA, auc.type = n, conc.blq = list(first = “keep”, middle = “drop”, last = “keep”), method = t))), call = list(runner(v1 <- pk.calc.auc(conc = c(0, 2, 0, 1, 2, 1, NA, 0), time = 0:7, interval = c(0, 7), lambda.z = NA, auc.type = n, conc.blq = list(first = “keep”, middle = “drop”, last = “keep”), method = t))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”),
list(message ="v1 not equal to tests[[t]][[n]].", srcref = c(291, 7, 293, 36, 7,36, 291, 293), expectation_calls = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), call = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = “v1 not equal to tests[[t]][[n]].”, srcref = c(291, 7, 293, 36, 7, 36, 291, 293), expectation_calls = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))),
call = list(expect_equal(v1, tests[[t]][[n]], info =paste(t, n))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = “v1 not equal to tests[[t]][[n]].”, srcref = c(291, 7, 293, 36, 7, 36, 291, 293), expectation_calls = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), call = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = "", srcref = c(281, 7, 290, 41, 7, 41, 281,
290), expectation_calls = list(runner(v1 <- pk.calc.auc(conc = c(0, 2, 0, 1, 2, 1,NA, 0),time = 0:7, interval = c(0, 7), lambda.z = NA, auc.type = n, conc.blq = list(first = “keep”, middle = “drop”, last = “keep”), method = t))), call = list(runner(v1 <- pk.calc.auc(conc = c(0, 2, 0, 1, 2, 1, NA, 0), time = 0:7, interval = c(0, 7), lambda.z = NA, auc.type = n, conc.blq = list(first = “keep”, middle = “drop”, last = “keep”), method = t))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”),
list(message ="v1 not equal to tests[[t]][[n]].", srcref = c(291, 7, 293, 36, 7,36, 291, 293), expectation_calls = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), call = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = “v1 not equal to tests[[t]][[n]].”, srcref = c(291, 7, 293, 36, 7, 36, 291, 293), expectation_calls = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))),
call = list(expect_equal(v1, tests[[t]][[n]], info =paste(t, n))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = “v1 not equal to tests[[t]][[n]].”, srcref = c(291, 7, 293, 36, 7, 36, 291, 293), expectation_calls = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), call = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = "", srcref = c(315, 7, 324, 41, 7, 41, 315,
324), expectation_calls = list(runner(v1 <- pk.calc.auc(conc = c(0, 2, 0, 1, 2, 1,0), time= c(0:5, 7), interval = c(0, 6), lambda.z = 1, auc.type = n, conc.blq = list(first = “keep”, middle = “drop”, last = “keep”), method = t))), call = list(runner(v1 <- pk.calc.auc(conc = c(0, 2, 0, 1, 2, 1, 0), time = c(0:5, 7), interval = c(0, 6), lambda.z = 1, auc.type = n, conc.blq = list(first = “keep”, middle = “drop”, last = “keep”), method = t))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”),
list(message ="v1 not equal to tests[[t]][[n]].", srcref = c(325, 7, 327, 36, 7,36, 325, 327), expectation_calls = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), call = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = “v1 not equal to tests[[t]][[n]].”, srcref = c(325, 7, 327, 36, 7, 36, 325, 327), expectation_calls = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))),
call = list(expect_equal(v1, tests[[t]][[n]], info =paste(t, n))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = “v1 not equal to tests[[t]][[n]].”, srcref = c(325, 7, 327, 36, 7, 36, 325, 327), expectation_calls = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), call = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = "", srcref = c(315, 7, 324, 41, 7, 41, 315,
324), expectation_calls = list(runner(v1 <- pk.calc.auc(conc = c(0, 2, 0, 1, 2, 1,0), time= c(0:5, 7), interval = c(0, 6), lambda.z = 1, auc.type = n, conc.blq = list(first = “keep”, middle = “drop”, last = “keep”), method = t))), call = list(runner(v1 <- pk.calc.auc(conc = c(0, 2, 0, 1, 2, 1, 0), time = c(0:5, 7), interval = c(0, 6), lambda.z = 1, auc.type = n, conc.blq = list(first = “keep”, middle = “drop”, last = “keep”), method = t))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”),
list(message ="v1 not equal to tests[[t]][[n]].", srcref = c(325, 7, 327, 36, 7,36, 325, 327), expectation_calls = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), call = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = “v1 not equal to tests[[t]][[n]].”, srcref = c(325, 7, 327, 36, 7, 36, 325, 327), expectation_calls = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))),
call = list(expect_equal(v1, tests[[t]][[n]], info =paste(t, n))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = “v1 not equal to tests[[t]][[n]].”, srcref = c(325, 7, 327, 36, 7, 36, 325, 327), expectation_calls = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), call = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = "", srcref = c(345, 7, 355, 36, 7, 36, 345,
355), expectation_calls = list(expect_warning(v1 <- pk.calc.auc(conc = c(0, 2, 0,1, 2, 1,0), time = c(0:5, 7), interval = c(-1, 6), lambda.z = 1, auc.type = n, conc.blq = list(first = “keep”, middle = “drop”, last = “keep”), method = t))), call = list(expect_warning(v1 <- pk.calc.auc(conc = c(0, 2, 0, 1, 2, 1, 0), time = c(0:5, 7), interval = c(-1, 6), lambda.z = 1, auc.type = n, conc.blq = list(first = “keep”, middle = “drop”, last = “keep”), method = t))), start_frame = 74, end_frame = 74,
test = "pk.calc.auc"), list(message= "v1 not equalto tests[[t]][[n]].E", srcref = c(356, 7, 358, 36, 7, 36, 356, 358), expectation_calls = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), call = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = "", srcref = c(345, 7, 355, 36, 7, 36, 345, 355), expectation_calls = list(expect_warning(v1 <- pk.calc.auc(conc = c(0, 2, 0, 1, 2, 1, 0), time = c(0:5,
7), interval = c(-1, 6), lambda.z =1, auc.type = n,conc.blq = list(first = "keep", middle = “drop”, last = “keep”), method = t))), call = list(expect_warning(v1 <- pk.calc.auc(conc = c(0, 2, 0, 1, 2, 1, 0), time = c(0:5, 7), interval = c(-1, 6), lambda.z = 1, auc.type = n, conc.blq = list(first = “keep”, middle = “drop”, last = “keep”), method = t))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = “v1 not equal to tests[[t]][[n]].”, srcref = c(356, 7, 358,
36, 7, 36, 356,358), expectation_calls= list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), call = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = "“, srcref = c(345, 7, 355, 36, 7, 36, 345, 355), expectation_calls = list(expect_warning(v1 <- pk.calc.auc(conc = c(0, 2, 0, 1, 2, 1, 0), time = c(0:5, 7), interval = c(-1, 6), lambda.z = 1, auc.type = n, conc.blq = list(first =”keep“, middle =”drop",
last = "keep"), method = t))), call= list(expect_warning(v1 <- pk.calc.auc(conc = c(0,2, 0, 1, 2, 1, 0), time = c(0:5, 7), interval = c(-1, 6), lambda.z = 1, auc.type = n, conc.blq = list(first = “keep”, middle = “drop”, last = “keep”), method = t))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = “v1 not equal to tests[[t]][[n]].”, srcref = c(356, 7, 358, 36, 7, 36, 356, 358), expectation_calls = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))),
call = list(expect_equal(v1, tests[[t]][[n]], info =paste(t, n))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = "“, srcref = c(345, 7, 355, 36, 7, 36, 345, 355), expectation_calls = list(expect_warning(v1 <- pk.calc.auc(conc = c(0, 2, 0, 1, 2, 1, 0), time = c(0:5, 7), interval = c(-1, 6), lambda.z = 1, auc.type = n, conc.blq = list(first =”keep“, middle =”drop“, last =”keep"), method = t))), call = list(expect_warning(v1 <- pk.calc.auc(conc = c(0, 2, 0, 1, 2,
1, 0), time= c(0:5, 7), interval =c(-1, 6), lambda.z = 1, auc.type = n, conc.blq = list(first = “keep”, middle = “drop”, last = “keep”), method = t))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = “v1 not equal to tests[[t]][[n]].”, srcref = c(356, 7, 358, 36, 7, 36, 356, 358), expectation_calls = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), call = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), start_frame = 74, end_frame = 74,
test = "pk.calc.auc"), list(message= "", srcref = c(345, 7, 355, 36, 7, 36, 345, 355),expectation_calls = list(expect_warning(v1 <- pk.calc.auc(conc = c(0, 2, 0, 1, 2, 1, 0), time = c(0:5, 7), interval = c(-1, 6), lambda.z = 1, auc.type = n, conc.blq = list(first = “keep”, middle = “drop”, last = “keep”), method = t))), call = list(expect_warning(v1 <- pk.calc.auc(conc = c(0, 2, 0, 1, 2, 1, 0), time = c(0:5, 7), interval = c(-1, 6), lambda.z = 1, auc.type = n, conc.blq = list(first = “keep”,
middle = "drop“, last =”keep"), method = t))), start_frame = 74, end_frame =74, test= “pk.calc.auc”), list(message = “v1 not equal to tests[[t]][[n]].”, srcref = c(356, 7, 358, 36, 7, 36, 356, 358), expectation_calls = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), call = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = "", srcref = c(345, 7, 355, 36, 7, 36, 345, 355), expectation_calls = list(
expect_warning(v1 <- pk.calc.auc(conc = c(0, 2, 0, 1,2, 1, 0), time = c(0:5,7), interval = c(-1, 6), lambda.z = 1, auc.type = n, conc.blq = list(first = “keep”, middle = “drop”, last = “keep”), method = t))), call = list(expect_warning(v1 <- pk.calc.auc(conc = c(0, 2, 0, 1, 2, 1, 0), time = c(0:5, 7), interval = c(-1, 6), lambda.z = 1, auc.type = n, conc.blq = list(first = “keep”, middle = “drop”, last = “keep”), method = t))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(
message = "v1 not equal to tests[[t]][[n]].",srcref = c(356, 7, 358,36, 7, 36, 356, 358), expectation_calls = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), call = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = "“, srcref = c(364, 3, 366, 92, 3, 92, 364, 366), expectation_calls = list(expect_warning(pk.calc.auc(conc = 1:2, time = 0:1, interval = 2:3, method =”linear“), regexp =”AUC start time \(2\) is after the maximum observed time \(1\)")),
call = list(expect_warning(pk.calc.auc(conc = 1:2, time = 0:1, interval = 2:3,method =“linear”), regexp = “AUC start time \(2\) is after the maximum observed time \(1\)”)), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = "“, srcref = c(388, 7, 398, 36, 7, 36, 388, 398), expectation_calls = list(expect_warning(v1 <- pk.calc.auc(conc = c(NA, 2, 0, 1, 2, 1, 0), time = c(0:5, 7), interval = c(0, 6), lambda.z = 1, auc.type = n, conc.blq = list(first =”keep“, middle =”drop",
last = "keep"), method = t))), call= list(expect_warning(v1 <- pk.calc.auc(conc = c(NA, 2, 0, 1, 2, 1, 0), time = c(0:5, 7), interval = c(0, 6), lambda.z = 1, auc.type = n, conc.blq = list(first = “keep”, middle = “drop”, last = “keep”), method = t))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = “v1 not equal to tests[[t]][[n]].”, srcref = c(399, 7, 401, 36, 7, 36, 399, 401), expectation_calls = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))),
call = list(expect_equal(v1, tests[[t]][[n]], info =paste(t, n))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = "“, srcref = c(388, 7, 398, 36, 7, 36, 388, 398), expectation_calls = list(expect_warning(v1 <- pk.calc.auc(conc = c(NA, 2, 0, 1, 2, 1, 0), time = c(0:5, 7), interval = c(0, 6), lambda.z = 1, auc.type = n, conc.blq = list(first =”keep“, middle =”drop“, last =”keep"), method = t))), call = list(expect_warning(v1 <- pk.calc.auc(conc = c(NA, 2, 0, 1,
2, 1, 0), time = c(0:5, 7), interval = c(0, 6), lambda.z = 1, auc.type = n, conc.blq =list(first = “keep”, middle = “drop”, last = “keep”), method = t))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = “v1 not equal to tests[[t]][[n]].”, srcref = c(399, 7, 401, 36, 7, 36, 399, 401), expectation_calls = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), call = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), start_frame = 74, end_frame = 74,
test = "pk.calc.auc"), list(message= "", srcref = c(388, 7, 398, 36, 7, 36, 388, 398),expectation_calls = list(expect_warning(v1 <- pk.calc.auc(conc = c(NA, 2, 0, 1, 2, 1, 0), time = c(0:5, 7), interval = c(0, 6), lambda.z = 1, auc.type = n, conc.blq = list(first = “keep”, middle = “drop”, last = “keep”), method = t))), call = list(expect_warning(v1 <- pk.calc.auc(conc = c(NA, 2, 0, 1, 2, 1, 0), time = c(0:5, 7), interval = c(0, 6), lambda.z = 1, auc.type = n, conc.blq = list(first = “keep”,
middle = "drop“, last =”keep"), method = t))), start_frame = 74, end_frame =74, test= “pk.calc.auc”), list(message = “v1 not equal to tests[[t]][[n]].”, srcref = c(399, 7, 401, 36, 7, 36, 399, 401), expectation_calls = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), call = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = "", srcref = c(388, 7, 398, 36, 7, 36, 388, 398), expectation_calls = list(
expect_warning(v1 <- pk.calc.auc(conc = c(NA, 2, 0, 1, 2, 1, 0), time = c(0:5,7), interval = c(0, 6), lambda.z = 1, auc.type = n, conc.blq = list(first = “keep”, middle = “drop”, last = “keep”), method = t))), call = list(expect_warning(v1 <- pk.calc.auc(conc = c(NA, 2, 0, 1, 2, 1, 0), time = c(0:5, 7), interval = c(0, 6), lambda.z = 1, auc.type = n, conc.blq = list(first = “keep”, middle = “drop”, last = “keep”), method = t))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(
message = "v1 not equal to tests[[t]][[n]].",srcref = c(399, 7, 401,36, 7, 36, 399, 401), expectation_calls = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), call = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = "", srcref = c(388, 7, 398, 36, 7, 36, 388, 398), expectation_calls = list(expect_warning(v1 <- pk.calc.auc(conc = c(NA, 2, 0, 1, 2, 1, 0), time = c(0:5, 7), interval = c(0,
6), lambda.z = 1, auc.type = n, conc.blq = list(first= “keep”, middle = "drop", last =“keep”), method = t))), call = list(expect_warning(v1 <- pk.calc.auc(conc = c(NA, 2, 0, 1, 2, 1, 0), time = c(0:5, 7), interval = c(0, 6), lambda.z = 1, auc.type = n, conc.blq = list(first = “keep”, middle = “drop”, last = “keep”), method = t))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = “v1 not equal to tests[[t]][[n]].”, srcref = c(399, 7, 401, 36, 7, 36, 399, 401
), expectation_calls = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), call =list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = "“, srcref = c(388, 7, 398, 36, 7, 36, 388, 398), expectation_calls = list(expect_warning(v1 <- pk.calc.auc(conc = c(NA, 2, 0, 1, 2, 1, 0), time = c(0:5, 7), interval = c(0, 6), lambda.z = 1, auc.type = n, conc.blq = list(first =”keep“, middle =”drop“, last =”keep"), method = t))),
call = list(expect_warning(v1 <- pk.calc.auc(conc = c(NA, 2, 0, 1, 2, 1, 0), time = c(0:5, 7), interval = c(0, 6), lambda.z = 1, auc.type = n, conc.blq = list(first = “keep”, middle = “drop”, last = “keep”), method = t))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = “v1 not equal to tests[[t]][[n]].”, srcref = c(399, 7, 401, 36, 7, 36, 399, 401), expectation_calls = list(expect_equal(v1, tests[[t]][[n]], info = paste(t, n))), call = list(expect_equal(v1,
tests[[t]][[n]], info = paste(t, n))), start_frame =74, end_frame = 74, test= "pk.calc.auc“), list(message =”“, srcref = c(405, 3, 406, 62, 3, 62, 405, 406), expectation_calls = list(expect_error(pk.calc.auc(conc = c(1, 2, 3), time = c(1, 2)), regexp =”Conc and time must be the same length“)), call = list(expect_error(pk.calc.auc(conc = c(1, 2, 3), time = c(1, 2)), regexp =”Conc and time must be the same length“)), start_frame = 74, end_frame = 74, test =”pk.calc.auc“), list(message =”",
srcref = c(409, 3, 410, 62, 3, 62,409, 410), expectation_calls = list(expect_error(pk.calc.auc(conc = c(1, 2, 3), time = c(1, 2, 1)), regexp = “Time must be monotonically increasing”)), call = list(expect_error(pk.calc.auc(conc = c(1, 2, 3), time = c(1, 2, 1)), regexp = “Time must be monotonically increasing”)), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = "", srcref = c(413, 3, 414, 62, 3, 62, 413, 414), expectation_calls = list(expect_error(pk.calc.auc(conc = c(1,
2, 3), time= c(1, 2, 2)), regexp ="Time must be monotonically increasing")),call = list(expect_error(pk.calc.auc(conc = c(1, 2, 3), time = c(1, 2, 2)), regexp = “Time must be monotonically increasing”)), start_frame = 74, end_frame = 74, test = “pk.calc.auc”), list(message = "“, srcref = c(417, 3, 419, 65, 3, 65, 417, 419), expectation_calls = list(expect_error(pk.calc.auc(conc = c(1, 2, 3), time = c(1, 2, 3), method =”wrong“), regex =”should be one of“, info =”Method names are confirmed for pk.calc.auc")),
call = list(expect_error(pk.calc.auc(conc = c(1, 2, 3), time = c(1, 2, 3), method = "wrong“), regex =”should be one of“, info =”Method names are confirmed for pk.calc.auc“)), start_frame = 74, end_frame = 74, test =”pk.calc.auc“), list(message =”pk.calc.auc.inf(…) not equal to pk.calc.auc.inf(…).", srcref = c(422, 3, 433, 37, 3, 37, 422, 433), expectation_calls = list(expect_equal(pk.calc.auc.inf(conc = c(0, 1, 1, 0), time = 0:3, interval = c(0, Inf), lambda.z = 1, check = FALSE,
method = "linear"), pk.calc.auc.inf(conc = c(0, 1, 1,0), time = 0:3, interval= c(0, Inf), lambda.z = 1, method = “linear”))), call = list(expect_equal(pk.calc.auc.inf(conc = c(0, 1, 1, 0), time = 0:3, interval = c(0, Inf), lambda.z = 1, check = FALSE, method = “linear”), pk.calc.auc.inf(conc = c(0, 1, 1, 0), time = 0:3, interval = c(0, Inf), lambda.z = 1, method = “linear”))), start_frame = 74, end_frame = 74, test = “pk.calc.auc”))
test-auc.Rpk.calc.auc.last202list(list(message = “pk.calc.auc.last(…) not equal to pk.calc.auc(…).”, srcref = c(437, 3, 446, 33, 3, 33, 437, 446), expectation_calls = list(expect_equal(pk.calc.auc.last(conc = c(0, 1, 1, 0), time = 0:3, interval = c(0, 3), method = “linear”), pk.calc.auc(conc = c(0, 1, 1, 0), time = 0:3, interval = c(0, 3), auc.type = “AUClast”, method = “linear”))), call = list(expect_equal(pk.calc.auc.last(conc = c(0, 1, 1, 0), time = 0:3, interval = c(0, 3), method = “linear”), pk.calc.auc(conc = c(0,
1, 1, 0), time= 0:3, interval = c(0, 3), auc.type = "AUClast“, method =”linear"))), start_frame = 74, end_frame = 74, test = “pk.calc.auc.last”), list(message = "“, srcref = c(447, 3, 453, 94, 3, 94, 447, 453), expectation_calls = list(expect_error(pk.calc.auc.last(conc = c(0, 1, 1, 0), time = 0:3, interval = c(0, 3), auc.type =”foo“, method =”linear“), regexp =”auc.type cannot be changed when calling pk.calc.auc.last, please use pk.calc.auc")), call = list(expect_error(pk.calc.auc.last(conc = c(0,
1, 1, 0), time= 0:3, interval = c(0, 3), auc.type = "foo“, method =”linear"), regexp = "auc.type cannot be changed when calling pk.calc.auc.last, please use pk.calc.auc“)), start_frame = 74, end_frame = 74, test =”pk.calc.auc.last"))
test-auc.Rpk.calc.auc.inf202list(list(message = “pk.calc.auc.inf(…) not equal to pk.calc.auc(…).”, srcref = c(459, 3, 470, 33, 3, 33, 459, 470), expectation_calls = list(expect_equal(pk.calc.auc.inf(conc = c(0, 1, 1, 0), time = 0:3, interval = c(0, Inf), lambda.z = 1, method = “linear”), pk.calc.auc(conc = c(0, 1, 1, 0), time = 0:3, interval = c(0, Inf), lambda.z = 1, auc.type = “AUCinf”, method = “linear”))), call = list(expect_equal(pk.calc.auc.inf(conc = c(0, 1, 1, 0), time = 0:3, interval = c(0, Inf), lambda.z = 1,
method = "linear"), pk.calc.auc(conc =c(0, 1, 1, 0), time = 0:3, interval = c(0,Inf), lambda.z = 1, auc.type = “AUCinf”, method = “linear”))), start_frame = 74, end_frame = 74, test = “pk.calc.auc.inf”), list(message = "“, srcref = c(471, 3, 477, 93, 3, 93, 471, 477), expectation_calls = list(expect_error(pk.calc.auc.inf(conc = c(0, 1, 1, 0), time = 0:3, interval = c(0, 3), auc.type =”foo“, method =”linear“), regexp =”auc.type cannot be changed when calling pk.calc.auc.inf, please use pk.calc.auc")),
call = list(expect_error(pk.calc.auc.inf(conc = c(0, 1, 1, 0), time = 0:3, interval = c(0,3), auc.type = “foo”, method = “linear”), regexp = “auc.type cannot be changed when calling pk.calc.auc.inf, please use pk.calc.auc”)), start_frame = 74, end_frame = 74, test = “pk.calc.auc.inf”))
test-auc.Rpk.calc.auc.all202list(list(message = “pk.calc.auc.all(…) not equal to pk.calc.auc(…).”, srcref = c(483, 3, 492, 33, 3, 33, 483, 492), expectation_calls = list(expect_equal(pk.calc.auc.all(conc = c(0, 1, 1, 0), time = 0:3, interval = c(0, 3), method = “linear”), pk.calc.auc(conc = c(0, 1, 1, 0), time = 0:3, interval = c(0, 3), auc.type = “AUCall”, method = “linear”))), call = list(expect_equal(pk.calc.auc.all(conc = c(0, 1, 1, 0), time = 0:3, interval = c(0, 3), method = “linear”), pk.calc.auc(conc = c(0,
1, 1, 0), time= 0:3, interval = c(0, 3), auc.type = "AUCall“, method =”linear"))), start_frame = 74, end_frame = 74, test = “pk.calc.auc.all”), list(message = "“, srcref = c(493, 3, 499, 93, 3, 93, 493, 499), expectation_calls = list(expect_error(pk.calc.auc.all(conc = c(0, 1, 1, 0), time = 0:3, interval = c(0, 3), auc.type =”foo“, method =”linear“), regexp =”auc.type cannot be changed when calling pk.calc.auc.all, please use pk.calc.auc")), call = list(expect_error(pk.calc.auc.all(conc = c(0,
1, 1, 0), time= 0:3, interval = c(0, 3), auc.type = "foo“, method =”linear"), regexp = "auc.type cannot be changed when calling pk.calc.auc.all, please use pk.calc.auc“)), start_frame = 74, end_frame = 74, test =”pk.calc.auc.all"))
test-auc.Rpk.calc.aumc303list(list(message = “pk.calc.aumc(…) not equal to 3.75.”, srcref = c(503, 3, 509, 9, 3, 9, 503, 509), expectation_calls = list(expect_equal(pk.calc.aumc(conc = c(0, 1, 1, 0.5), time = 0:3, interval = c(0, 3), method = “linear”), 3.75)), call = list(expect_equal(pk.calc.aumc(conc = c(0, 1, 1, 0.5), time = 0:3, interval = c(0, 3), method = “linear”), 3.75)), start_frame = 74, end_frame = 74, test = “pk.calc.aumc”), list(message = “pk.calc.aumc(…) not equal to 2 - 0.5/log(0.5) + 0.5/(log(0.5)^2).”,
srcref = c(510,3, 516, 36, 3, 36, 510,516), expectation_calls = list(expect_equal(pk.calc.aumc(conc = c(0, 1, 1, 0.5), time = 0:3, interval = c(0, 3), method = “lin up/log down”), 2 - 0.5/log(0.5) + 0.5/(log(0.5)^2))), call = list(expect_equal(pk.calc.aumc(conc = c(0, 1, 1, 0.5), time = 0:3, interval = c(0, 3), method = “lin up/log down”), 2 - 0.5/log(0.5) + 0.5/(log(0.5)^2))), start_frame = 74, end_frame = 74, test = “pk.calc.aumc”), list(message = “pk.calc.aumc(…) not equal to 2 - 0.5/log(0.5) + 0.5/(log(0.5)^2) + 1.5 + 0.5.”,
srcref = c(517,3, 525, 44, 3, 44, 517,525), expectation_calls = list(expect_equal(pk.calc.aumc(conc = c(0, 1, 1, 0.5), time = 0:3, interval = c(0, Inf), auc.type = “AUCinf”, lambda.z = 1, method = “lin up/log down”), 2 - 0.5/log(0.5) + 0.5/(log(0.5)^2) + 1.5 + 0.5)), call = list(expect_equal(pk.calc.aumc(conc = c(0, 1, 1, 0.5), time = 0:3, interval = c(0, Inf), auc.type = “AUCinf”, lambda.z = 1, method = “lin up/log down”), 2 - 0.5/log(0.5) + 0.5/(log(0.5)^2) + 1.5 + 0.5)), start_frame = 74,
end_frame = 74,test = “pk.calc.aumc”))
test-auc.Rpk.calc.aumc.inf202list(list(message = “pk.calc.aumc.inf(…) not equal to pk.calc.aumc(…).”, srcref = c(532, 3, 543, 34, 3, 34, 532, 543), expectation_calls = list(expect_equal(pk.calc.aumc.inf(conc = c(0, 1, 1, 0), time = 0:3, interval = c(0, Inf), lambda.z = 1, method = “linear”), pk.calc.aumc(conc = c(0, 1, 1, 0), time = 0:3, interval = c(0, Inf), lambda.z = 1, auc.type = “AUCinf”, method = “linear”))), call = list(expect_equal(pk.calc.aumc.inf(conc = c(0, 1, 1, 0), time = 0:3, interval = c(0, Inf), lambda.z = 1,
method = "linear"), pk.calc.aumc(conc =c(0, 1, 1, 0), time = 0:3, interval = c(0,Inf), lambda.z = 1, auc.type = “AUCinf”, method = “linear”))), start_frame = 74, end_frame = 74, test = “pk.calc.aumc.inf”), list(message = "“, srcref = c(544, 3, 550, 95, 3, 95, 544, 550), expectation_calls = list(expect_error(pk.calc.aumc.inf(conc = c(0, 1, 1, 0), time = 0:3, interval = c(0, 3), auc.type =”foo“, method =”linear“), regexp =”auc.type cannot be changed when calling pk.calc.aumc.inf, please use pk.calc.aumc")),
call = list(expect_error(pk.calc.aumc.inf(conc = c(0, 1,1, 0), time = 0:3, interval = c(0,3), auc.type = “foo”, method = “linear”), regexp = “auc.type cannot be changed when calling pk.calc.aumc.inf, please use pk.calc.aumc”)), start_frame = 74, end_frame = 74, test = “pk.calc.aumc.inf”))
test-auc.Rpk.calc.aumc.all202list(list(message = “pk.calc.aumc.all(…) not equal to pk.calc.aumc(…).”, srcref = c(556, 3, 565, 34, 3, 34, 556, 565), expectation_calls = list(expect_equal(pk.calc.aumc.all(conc = c(0, 1, 1, 0), time = 0:3, interval = c(0, 3), method = “linear”), pk.calc.aumc(conc = c(0, 1, 1, 0), time = 0:3, interval = c(0, 3), auc.type = “AUCall”, method = “linear”))), call = list(expect_equal(pk.calc.aumc.all(conc = c(0, 1, 1, 0), time = 0:3, interval = c(0, 3), method = “linear”), pk.calc.aumc(conc = c(0,
1, 1, 0), time= 0:3, interval = c(0, 3), auc.type = "AUCall“, method =”linear"))), start_frame = 74, end_frame = 74, test = “pk.calc.aumc.all”), list(message = "“, srcref = c(566, 3, 572, 95, 3, 95, 566, 572), expectation_calls = list(expect_error(pk.calc.aumc.all(conc = c(0, 1, 1, 0), time = 0:3, interval = c(0, 3), auc.type =”foo“, method =”linear“), regexp =”auc.type cannot be changed when calling pk.calc.aumc.all, please use pk.calc.aumc")), call = list(expect_error(pk.calc.aumc.all(conc = c(0,
1, 1, 0), time= 0:3, interval = c(0, 3), auc.type = "foo“, method =”linear"), regexp = "auc.type cannot be changed when calling pk.calc.aumc.all, please use pk.calc.aumc“)), start_frame = 74, end_frame = 74, test =”pk.calc.aumc.all"))
test-auc.Rpk.calc.aumc.last202list(list(message = “pk.calc.aumc.last(…) not equal to pk.calc.aumc(…).”, srcref = c(578, 3, 587, 34, 3, 34, 578, 587), expectation_calls = list(expect_equal(pk.calc.aumc.last(conc = c(0, 1, 1, 0), time = 0:3, interval = c(0, 3), method = “linear”), pk.calc.aumc(conc = c(0, 1, 1, 0), time = 0:3, interval = c(0, 3), auc.type = “AUClast”, method = “linear”))), call = list(expect_equal(pk.calc.aumc.last(conc = c(0, 1, 1, 0), time = 0:3, interval = c(0, 3), method = “linear”), pk.calc.aumc(conc = c(0,
1, 1, 0), time= 0:3, interval = c(0, 3), auc.type = "AUClast“, method =”linear"))), start_frame = 74, end_frame = 74, test = “pk.calc.aumc.last”), list(message = "“, srcref = c(588, 3, 594, 96, 3, 96, 588, 594), expectation_calls = list(expect_error(pk.calc.aumc.last(conc = c(0, 1, 1, 0), time = 0:3, interval = c(0, 3), auc.type =”foo“, method =”linear“), regexp =”auc.type cannot be changed when calling pk.calc.aumc.last, please use pk.calc.aumc")), call = list(expect_error(pk.calc.aumc.last(conc = c(0,
1, 1, 0), time= 0:3, interval = c(0, 3), auc.type = "foo“, method =”linear"), regexp = "auc.type cannot be changed when calling pk.calc.aumc.last, please use pk.calc.aumc“)), start_frame = 74, end_frame = 74, test =”pk.calc.aumc.last"))
test-auc.Rpk.calc.auc.inf.pred101list(list(message = “pk.calc.auc.inf.pred(…) not equal to pk.calc.auc.inf(…).”, srcref = c(598, 3, 613, 75, 3, 75, 598, 613), expectation_calls = list(expect_equal(pk.calc.auc.inf.pred(conc = c(0, 1, 1, 0), time = 0:3, clast.pred = 1, lambda.z = 1, interval = c(0, Inf), method = “linear”), pk.calc.auc.inf(conc = c(0, 1, 1, 0), time = 0:3, clast = 1, lambda.z = 1, interval = c(0, Inf), method = “linear”), info = “pk.calc.auc.inf.pred is a simple wrapper around pk.calc.auc.inf”)), call = list(
expect_equal(pk.calc.auc.inf.pred(conc= c(0, 1, 1, 0), time = 0:3, clast.pred = 1, lambda.z = 1, interval = c(0, Inf), method = “linear”), pk.calc.auc.inf(conc = c(0, 1, 1, 0), time = 0:3, clast = 1, lambda.z = 1, interval = c(0, Inf), method = “linear”), info = “pk.calc.auc.inf.pred is a simple wrapper around pk.calc.auc.inf”)), start_frame = 74, end_frame = 74, test = “pk.calc.auc.inf.pred”))
test-auc.Rpk.calc.aumc.inf.obs101list(list(message = “pk.calc.aumc.inf.obs(…) not equal to pk.calc.aumc.inf(…).”, srcref = c(617, 3, 632, 76, 3, 76, 617, 632), expectation_calls = list(expect_equal(pk.calc.aumc.inf.obs(conc = c(0, 1, 1, 0), time = 0:3, clast.obs = 1, lambda.z = 1, interval = c(0, Inf), method = “linear”), pk.calc.aumc.inf(conc = c(0, 1, 1, 0), time = 0:3, clast = 1, lambda.z = 1, interval = c(0, Inf), method = “linear”), info = “pk.calc.aumc.inf.obs is a simple wrapper around pk.calc.aumc.inf”)), call = list(
expect_equal(pk.calc.aumc.inf.obs(conc= c(0, 1, 1, 0), time = 0:3, clast.obs = 1,lambda.z= 1, interval = c(0, Inf), method = “linear”), pk.calc.aumc.inf(conc = c(0, 1, 1, 0), time = 0:3, clast = 1, lambda.z = 1, interval = c(0, Inf), method = “linear”), info = “pk.calc.aumc.inf.obs is a simple wrapper around pk.calc.aumc.inf”)), start_frame = 74, end_frame = 74, test = “pk.calc.aumc.inf.obs”))
test-auc.Rpk.calc.aumc.inf.pred101list(list(message = “pk.calc.aumc.inf.pred(…) not equal to pk.calc.aumc.inf(…).”, srcref = c(636, 3, 651, 77, 3, 77, 636, 651), expectation_calls = list(expect_equal(pk.calc.aumc.inf.pred(conc = c(0, 1, 1, 0), time = 0:3, clast.pred = 1, lambda.z = 1, interval = c(0, Inf), method = “linear”), pk.calc.aumc.inf(conc = c(0, 1, 1, 0), time = 0:3, clast = 1, lambda.z = 1, interval = c(0, Inf), method = “linear”), info = “pk.calc.aumc.inf.pred is a simple wrapper around pk.calc.aumc.inf”)),
call = list(expect_equal(pk.calc.aumc.inf.pred(conc = c(0, 1, 1, 0), time = 0:3, clast.pred= 1, lambda.z = 1, interval = c(0, Inf), method = “linear”), pk.calc.aumc.inf(conc = c(0, 1, 1, 0), time = 0:3, clast = 1, lambda.z = 1, interval = c(0, Inf), method = “linear”), info = “pk.calc.aumc.inf.pred is a simple wrapper around pk.calc.aumc.inf”)), start_frame = 74, end_frame = 74, test = “pk.calc.aumc.inf.pred”))

+

+

+
aucint

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Testing FilenameTest DescriptionNumber of TestsNumber of Failed Testspassedresult
test-aucint.RAUCint gives errors appropriately18018list(list(message = "“, srcref = c(4, 3, 7, 54, 3, 54, 4, 7), expectation_calls = list(expect_error(pk.calc.aucint(conc = 1, time = 1), regexp =”If interval is not given, start and end must be given.“, fixed = TRUE, info =”Neither start nor end is given.“)), call = list(expect_error(pk.calc.aucint(conc = 1, time = 1), regexp =”If interval is not given, start and end must be given.“, fixed = TRUE, info =”Neither start nor end is given.“)), start_frame = 74, end_frame = 74, test =”AUCint gives errors appropriately"),
list(message ="", srcref = c(8, 3, 11, 42, 3, 42, 8, 11), expectation_calls = list(expect_error(pk.calc.aucint(conc = 1, time = 1, end = 1), regexp= “If interval is not given, start and end must be given.”, fixed = TRUE, info = “start is not given.”)), call = list(expect_error(pk.calc.aucint(conc = 1, time = 1, end = 1), regexp = “If interval is not given, start and end must be given.”, fixed = TRUE, info = “start is not given.”)), start_frame = 74, end_frame = 74, test = “AUCint gives errors appropriately”),
list(message ="", srcref = c(12, 3, 15, 40, 3, 40, 12, 15), expectation_calls = list(expect_error(pk.calc.aucint(conc = 1, time = 1, start= 1), regexp = “If interval is not given, start and end must be given.”, fixed = TRUE, info = “end is not given.”)), call = list(expect_error(pk.calc.aucint(conc = 1, time = 1, start = 1), regexp = “If interval is not given, start and end must be given.”, fixed = TRUE, info = “end is not given.”)), start_frame = 74, end_frame = 74, test = “AUCint gives errors appropriately”),
list(message ="", srcref = c(16, 3, 18, 26, 3, 26, 16, 18), expectation_calls = list(expect_error(pk.calc.aucint(conc = 1, time = 1, start= 1:2, end = 1), regexp = “start must be a scalar”, fixed = TRUE)), call = list(expect_error(pk.calc.aucint(conc = 1, time = 1, start = 1:2, end = 1), regexp = “start must be a scalar”, fixed = TRUE)), start_frame = 74, end_frame = 74, test = “AUCint gives errors appropriately”), list(message = "", srcref = c(19, 3, 21, 26, 3, 26, 19, 21), expectation_calls = list(
expect_error(pk.calc.aucint(conc = 1, time = 1, start = 1, end = 1:2), regexp = "end must bea scalar", fixed =TRUE)), call = list(expect_error(pk.calc.aucint(conc = 1, time = 1, start = 1, end = 1:2), regexp = “end must be a scalar”, fixed = TRUE)), start_frame = 74, end_frame = 74, test = “AUCint gives errors appropriately”), list(message = "“, srcref = c(23, 3, 26, 41, 3, 41, 23, 26), expectation_calls = list(expect_error(pk.calc.aucint(conc = 1, time = 1, start =”A“, end = 1), regexp =”start must be a number",
fixed = TRUE, info = “start not a number”)), call = list(expect_error(pk.calc.aucint(conc = 1, time = 1, start= “A”, end = 1), regexp ="start must be a number“, fixed = TRUE, info =”start not a number“)), start_frame = 74, end_frame = 74, test =”AUCint gives errors appropriately“), list(message =”“, srcref = c(27, 3, 30, 50, 3, 50, 27, 30), expectation_calls = list(expect_error(pk.calc.aucint(conc = 1, time = 1, start = factor(”A“), end = 1), regexp =”start must be a number", fixed = TRUE,
info = "start not a number (factor)")), call = list(expect_error(pk.calc.aucint(conc = 1, time = 1, start = factor(“A”), end = 1), regexp = "start must be a number“, fixed = TRUE, info =”start not a number (factor)“)), start_frame = 74, end_frame = 74, test =”AUCint gives errors appropriately“), list(message =”“, srcref = c(31, 3, 34, 39, 3, 39, 31, 34), expectation_calls = list(expect_error(pk.calc.aucint(conc = 1, time = 1, start = Inf, end = 1), regexp =”interval beginning (or start) must be finite",
fixed = TRUE, info = “start not finite”)), call = list(expect_error(pk.calc.aucint(conc = 1,time = 1, start =Inf, end = 1), regexp = "intervalbeginning (or start) must be finite“, fixed = TRUE, info =”start not finite“)), start_frame = 74, end_frame = 74, test =”AUCint gives errors appropriately“), list(message =”“, srcref = c(36, 3, 39, 39, 3, 39, 36, 39), expectation_calls = list(expect_error(pk.calc.aucint(conc = 1, time = 1, end =”A“, start = 1), regexp =”end must be a number",
fixed = TRUE, info = “end not a number”)), call = list(expect_error(pk.calc.aucint(conc = 1,time = 1, end = "A“, start = 1), regexp =”end mustbe a number“, fixed = TRUE, info =”end not a number“)), start_frame = 74, end_frame = 74, test =”AUCint gives errors appropriately“), list(message =”“, srcref = c(40, 3, 43, 48, 3, 48, 40, 43), expectation_calls = list(expect_error(pk.calc.aucint(conc = 1, time = 1, end = factor(”A“), start = 1), regexp =”end must be a number", fixed = TRUE,
info = "endnot a number (factor)")), call = list(expect_error(pk.calc.aucint(conc = 1, time= 1, end = factor(“A”), start = 1), regexp= "end must be a number“, fixed = TRUE, info =”end not a number (factor)“)), start_frame = 74, end_frame = 74, test =”AUCint gives errors appropriately“), list(message =”“, srcref = c(45, 3, 47, 26, 3, 26, 45, 47), expectation_calls = list(expect_error(pk.calc.aucint(conc = 1, time = 1, start = 1, end = 2, interval = c(1, 2)), regexp =”start and end cannot be given if interval is given",
fixed = TRUE)), call = list(expect_error(pk.calc.aucint(conc = 1, time = 1, start = 1, end =2, interval = c(1,2)), regexp = "start andend cannot be given if interval is given“, fixed = TRUE)), start_frame = 74, end_frame = 74, test =”AUCint gives errors appropriately“), list(message =”“, srcref = c(48, 3, 50, 26, 3, 26, 48, 50), expectation_calls = list(expect_error(pk.calc.aucint(conc = 1, time = 1, interval = 1:3), regexp =”interval must be a vector with 2 elements", fixed = TRUE)),
call = list(expect_error(pk.calc.aucint(conc = 1, time = 1, interval = 1:3), regexp = "interval must be a vector with 2 elements", fixed= TRUE)), start_frame = 74, end_frame = 74, test = “AUCint gives errors appropriately”), list(message = "“, srcref = c(51, 3, 54, 44, 3, 44, 51, 54), expectation_calls = list(expect_error(pk.calc.aucint(conc = 1, time = 1, interval = c(”A“,”B“)), regexp =”interval must be numeric“, fixed = TRUE, info =”interval not a number")), call = list(expect_error(pk.calc.aucint(conc = 1,
time = 1, interval = c(“A”, “B”)), regexp = “interval must be numeric”, fixed = TRUE, info ="interval not a number")), start_frame = 74, end_frame = 74, test = “AUCint gives errors appropriately”), list(message = "“, srcref = c(55, 3, 58, 53, 3, 53, 55, 58), expectation_calls = list(expect_error(pk.calc.aucint(conc = 1, time = 1, interval = factor(c(”A“,”B“))), regexp =”interval must be numeric“, fixed = TRUE, info =”interval not a number (factor)")), call = list(expect_error(pk.calc.aucint(conc = 1,
time = 1, interval = factor(c(“A”, “B”))), regexp = “interval must be numeric”, fixed = TRUE,info = "intervalnot a number (factor)")),start_frame = 74, end_frame = 74, test = “AUCint gives errors appropriately”), list(message = "“, srcref = c(59, 3, 62, 50, 3, 50, 59, 62), expectation_calls = list(expect_error(pk.calc.aucint(conc = 1, time = 1, interval = c(Inf, 1)), regexp =”interval beginning (or start) must be finite“, fixed = TRUE, info =”interval not finite (start)")), call = list(
expect_error(pk.calc.aucint(conc = 1, time = 1, interval = c(Inf, 1)), regexp = "interval beginning (or start)must be finite", fixed =TRUE, info = “interval not finite (start)”)), start_frame = 74, end_frame = 74, test = “AUCint gives errors appropriately”), list(message = "“, srcref = c(63, 3, 66, 50, 3, 50, 63, 66), expectation_calls = list(expect_error(pk.calc.aucint(conc = 1, time = 1, interval = c(-Inf, 1)), regexp =”interval beginning (or start) must be finite“, fixed = TRUE, info =”interval not finite (start)")),
call = list(expect_error(pk.calc.aucint(conc = 1, time = 1, interval = c(-Inf, 1)), regexp ="interval beginning (or start) must be finite", fixed = TRUE, info = “interval not finite (start)”)), start_frame = 74, end_frame = 74, test = “AUCint gives errors appropriately”), list(message = "“, srcref = c(67, 3, 70, 58, 3, 58, 67, 70), expectation_calls = list(expect_error(pk.calc.aucint(conc = 1, time = 1, interval = c(1, 1)), regexp =”interval start must be before interval end.", fixed = TRUE,
info = "interval must be increasing (equal)")), call = list(expect_error(pk.calc.aucint(conc= 1, time = 1, interval = c(1, 1)), regexp= "interval start must be before interval end.“, fixed = TRUE, info =”interval must be increasing (equal)“)), start_frame = 74, end_frame = 74, test =”AUCint gives errors appropriately“), list(message =”“, srcref = c(71, 3, 74, 63, 3, 63, 71, 74), expectation_calls = list(expect_error(pk.calc.aucint(conc = 1, time = 1, interval = c(1, 0)), regexp =”interval start must be before interval end.",
fixed = TRUE, info = “interval must be increasing (decreasing)”)), call = list(expect_error(pk.calc.aucint(conc= 1, time = 1, interval= c(1, 0)), regexp = “interval start must be before interval end.”, fixed = TRUE, info = “interval must be increasing (decreasing)”)), start_frame = 74, end_frame = 74, test = “AUCint gives errors appropriately”))
test-aucint.RAUCint gives the same value when no interpolation/extrapolation is required303list(list(message = “pk.calc.aucint(…) not equal to pk.calc.auc(…).”, srcref = c(80, 3, 84, 81, 3, 81, 80, 84), expectation_calls = list(expect_equal(pk.calc.aucint(conc = tmpdata\(conc, time = tmpdata\)time, interval = c(0, 3)), pk.calc.auc(conc = tmpdata\(conc, time = tmpdata\)time, interval = c(0, 3)), info = “No interpolation/extrapolation is equivalent to normal AUC”)), call = list(expect_equal(pk.calc.aucint(conc = tmpdata\(conc, time = tmpdata\)time, interval = c(0, 3)), pk.calc.auc(conc = tmpdata$conc,
time = tmpdata$time, interval = c(0, 3)), info = "No interpolation/extrapolation is equivalent tonormal AUC")), start_frame = 74, end_frame= 74, test = “AUCint gives the same value when no interpolation/extrapolation is required”), list(message = “pk.calc.aucint(…) not equal to pk.calc.auc(…).”, srcref = c(85, 3, 89, 92, 3, 92, 85, 89), expectation_calls = list(expect_equal(pk.calc.aucint(conc = tmpdata\(conc, time = tmpdata\)time, start = 0, end = 3), pk.calc.auc(conc = tmpdata$conc,
time = tmpdata$time, interval = c(0, 3)), info = "Giving interval and start+end are the same, nointerp/extrap (test 1)")), call = list(expect_equal(pk.calc.aucint(conc = tmpdata\(conc, time = tmpdata\)time, start = 0, end = 3), pk.calc.auc(conc = tmpdata\(conc, time = tmpdata\)time, interval = c(0, 3)), info = “Giving interval and start+end are the same, no interp/extrap (test 1)”)), start_frame = 74, end_frame = 74, test = “AUCint gives the same value when no interpolation/extrapolation is required”),
list(message =“pk.calc.aucint(…) not equal to pk.calc.auc(…).”, srcref = c(90, 3, 94,92, 3, 92, 90, 94), expectation_calls = list(expect_equal(pk.calc.aucint(conc = tmpdata\(conc, time = tmpdata\)time, start = 0, end = 2), pk.calc.auc(conc = tmpdata\(conc, time = tmpdata\)time, interval = c(0, 2)), info = “Giving interval and start+end are the same, no interp/extrap (test 2)”)), call = list(expect_equal(pk.calc.aucint(conc = tmpdata\(conc, time = tmpdata\)time, start = 0, end = 2), pk.calc.auc(conc = tmpdata$conc,
time = tmpdata$time, interval = c(0, 2)), info = "Giving interval and start+end are the same,no interp/extrap(test 2)")), start_frame= 74, end_frame = 74, test = “AUCint gives the same value when no interpolation/extrapolation is required”))
test-aucint.RAUCint gives a warning and NA when it cannot interpolate or extrapolate a value404list(list(message = "“, srcref = c(100, 3, 110, 64, 3, 64, 100, 110), expectation_calls = list(expect_warning(over_dose <- pk.calc.aucint(conc = tmpdata\(conc, time = tmpdata\)time, interval = c(0, 4), time.dose = 1.5, lambda.z = NA, auc.type =”AUCinf“), regexp =”Some interpolated/extrapolated concentration values are missing (may be due to interpolating or extrapolating over a dose with lambda.z=NA). Time points with missing data are: 1.5, 4“, fixed = TRUE, info =”warned when integrating over a dose with lambda.z=NA")),
call = list(expect_warning(over_dose <- pk.calc.aucint(conc = tmpdata\(conc, time = tmpdata\)time,interval = c(0, 4), time.dose = 1.5, lambda.z = NA,auc.type = “AUCinf”), regexp = “Some interpolated/extrapolated concentration values are missing (may be due to interpolating or extrapolating over a dose with lambda.z=NA). Time points with missing data are: 1.5, 4”, fixed = TRUE, info = “warned when integrating over a dose with lambda.z=NA”)), start_frame = 74, end_frame = 74, test = “AUCint gives a warning and NA when it cannot interpolate or extrapolate a value”),
list(message =“over_dose not equal to NA.”, srcref = c(111, 3, 112, 72, 3, 72, 111, 112), expectation_calls = list(expect_equal(over_dose,NA, info = “When you cannot integrate over a dose, you get NA”)), call = list(expect_equal(over_dose, NA, info = “When you cannot integrate over a dose, you get NA”)), start_frame = 74, end_frame = 74, test = “AUCint gives a warning and NA when it cannot interpolate or extrapolate a value”), list(message = "", srcref = c(114, 3, 124, 64, 3, 64, 114,
124), expectation_calls = list(expect_warning(before_time <- pk.calc.aucint(conc = tmpdata$conc,time = tmpdata$time, interval = c(-1, 4), time.dose= c(-1.5, -0.5), lambda.z = 1, auc.type = “AUCinf”), regexp = “Some interpolated/extrapolated concentration values are missing Time points with missing data are: -1, -0.5”, fixed = TRUE, info = “warned when integrating over a dose with lambda.z=NA”)), call = list(expect_warning(before_time <- pk.calc.aucint(conc = tmpdata\(conc, time = tmpdata\)time,
interval =c(-1, 4), time.dose = c(-1.5, -0.5), lambda.z = 1, auc.type = “AUCinf”), regexp ="Some interpolated/extrapolated concentration valuesare missing Time points with missing data are: -1, -0.5“, fixed = TRUE, info =”warned when integrating over a dose with lambda.z=NA“)), start_frame = 74, end_frame = 74, test =”AUCint gives a warning and NA when it cannot interpolate or extrapolate a value“), list(message =”before_time not equal to NA.", srcref = c(125, 3, 126, 70,
3, 70, 125, 126), expectation_calls = list(expect_equal(before_time, NA, info = "When you cannotinterpolate a point, you get NA")), call =list(expect_equal(before_time, NA, info = “When you cannot interpolate a point, you get NA”)), start_frame = 74, end_frame = 74, test = “AUCint gives a warning and NA when it cannot interpolate or extrapolate a value”))
test-aucint.RAUCint respects auc.type and does the correct calculations for each AUC type909list(list(message = “pk.calc.aucint(…) not equal to pk.calc.aucint(…).”, srcref = c(134, 3, 138, 50, 3, 50, 134, 138), expectation_calls = list(expect_equal(pk.calc.aucint(conc = tmpdata\(conc, time = tmpdata\)time, interval = c(0, 3), auc.type = “AUClast”), pk.calc.aucint(conc = tmpdata\(conc, time = tmpdata\)time, interval = c(0, 3)), info = “Default AUC type is AUClast”)), call = list(expect_equal(pk.calc.aucint(conc = tmpdata\(conc, time = tmpdata\)time, interval = c(0, 3), auc.type = “AUClast”),
pk.calc.aucint(conc = tmpdata\(conc, time = tmpdata\)time, interval = c(0, 3)), info = "Default AUCtype is AUClast")), start_frame = 74, end_frame = 74, test = “AUCint respects auc.type and does the correct calculations for each AUC type”), list(message = “pk.calc.aucint(…) not equal to pk.calc.auc(…).”, srcref = c(140, 3, 144, 39, 3, 39, 140, 144), expectation_calls = list(expect_equal(pk.calc.aucint(conc = tmpdata\(conc, time = tmpdata\)time, interval = c(0, 4), auc.type = “AUCinf”,
clast = 1, lambda.z = log(2)), pk.calc.auc(conc = c(tmpdata\(conc, 0.5), time = c(tmpdata\)time, 4), interval = c(0,4)), info = "AUCinf is traced")),call = list(expect_equal(pk.calc.aucint(conc = tmpdata\(conc, time = tmpdata\)time, interval = c(0, 4), auc.type = “AUCinf”, clast = 1, lambda.z = log(2)), pk.calc.auc(conc = c(tmpdata\(conc, 0.5), time = c(tmpdata\)time, 4), interval = c(0, 4)), info = “AUCinf is traced”)), start_frame = 74, end_frame = 74, test = “AUCint respects auc.type and does the correct calculations for each AUC type”),
list(message =“pk.calc.aucint(…) not equal to +….”, srcref = c(145, 3, 151, 60, 3, 60, 145, 151), expectation_calls = list(expect_equal(pk.calc.aucint(conc = tmpdata\(conc, time = tmpdata\)time, interval = c(0, 4), auc.type = “AUCinf”, clast = 2, lambda.z = log(2)), pk.calc.auc(conc = tmpdata\(conc, time = tmpdata\)time, interval = c(0, 3)) + pk.calc.auc(conc = c(2, 1), time = c(3, 4), interval = c(3, 4)), info = “AUCinf is traced with clast respected”)), call = list(expect_equal(pk.calc.aucint(conc = tmpdata$conc,
time = tmpdata$time, interval = c(0, 4), auc.type = “AUCinf”, clast = 2, lambda.z = log(2)),pk.calc.auc(conc =tmpdata$conc, time = tmpdata$time, interval = c(0, 3)) + pk.calc.auc(conc = c(2, 1), time = c(3, 4), interval = c(3, 4)), info = “AUCinf is traced with clast respected”)), start_frame = 74, end_frame = 74, test = “AUCint respects auc.type and does the correct calculations for each AUC type”), list(message = “pk.calc.aucint(…) not equal to pk.calc.auc(…).”, srcref = c(152,
3, 156, 63, 3,63, 152, 156), expectation_calls = list(expect_equal(pk.calc.aucint(conc = tmpdata$conc, time = tmpdata$time, interval = c(0,4), auc.type = “AUCinf”, clast = 1, lambda.z = log(2) * 2), pk.calc.auc(conc = c(tmpdata\(conc, 0.25), time = c(tmpdata\)time, 4), interval = c(0, 4)), info = “AUCinf is traced with lambda.z respected”)), call = list(expect_equal(pk.calc.aucint(conc = tmpdata\(conc, time = tmpdata\)time, interval = c(0, 4), auc.type = “AUCinf”, clast = 1, lambda.z = log(2) *
2), pk.calc.auc(conc = c(tmpdata\(conc, 0.25), time = c(tmpdata\)time, 4), interval = c(0, 4)),info = "AUCinf istraced with lambda.z respected")), start_frame = 74, end_frame = 74, test = “AUCint respects auc.type and does the correct calculations for each AUC type”), list(message = “pk.calc.aucint(…) not equal to +….”, srcref = c(157, 3, 163, 73, 3, 73, 157, 163), expectation_calls = list(expect_equal(pk.calc.aucint(conc = tmpdata\(conc, time = tmpdata\)time, interval = c(0, 4),
auc.type =“AUCinf”, clast = 2, lambda.z = 2 * log(2)), pk.calc.auc(conc = tmpdata$conc, time= tmpdata$time, interval = c(0, 3)) + pk.calc.auc(conc = c(2, 0.5), time = c(3, 4), interval = c(3, 4)), info = “AUCinf is traced with clast and lambda.z respected”)), call = list(expect_equal(pk.calc.aucint(conc = tmpdata\(conc, time = tmpdata\)time, interval = c(0, 4), auc.type = “AUCinf”, clast = 2, lambda.z = 2 * log(2)), pk.calc.auc(conc = tmpdata\(conc, time = tmpdata\)time, interval = c(0, 3)) +
pk.calc.auc(conc = c(2, 0.5), time = c(3, 4), interval = c(3, 4)), info = "AUCinf is traced with clast and lambda.z respected")), start_frame = 74, end_frame = 74, test = “AUCint respects auc.type and does the correct calculations for each AUC type”), list(message = “pk.calc.aucint(…) not equal to pk.calc.auc(…).”, srcref = c(165, 3, 169, 91, 3, 91, 165, 169), expectation_calls = list(expect_equal(pk.calc.aucint(conc = tmpdata\(conc, time = tmpdata\)time, interval = c(0, 3), auc.type = “AUCall”),
pk.calc.auc(conc = tmpdata\(conc, time = tmpdata\)time, interval = c(0, 3), auc.type = “AUCall”), info = "AUCallis the same as AUClast when no BLQfollow tlast (both AUCall)“)), call = list(expect_equal(pk.calc.aucint(conc = tmpdata\(conc, time = tmpdata\)time, interval = c(0, 3), auc.type =”AUCall“), pk.calc.auc(conc = tmpdata\(conc, time = tmpdata\)time, interval = c(0, 3), auc.type =”AUCall“), info =”AUCall is the same as AUClast when no BLQ follow tlast (both AUCall)")), start_frame = 74,
end_frame =74, test = "AUCint respects auc.type and does the correct calculations for each AUC type"), list(message = "pk.calc.aucint(...) not equal to pk.calc.auc(…).“, srcref = c(170, 3, 174, 92, 3, 92, 170, 174), expectation_calls = list(expect_equal(pk.calc.aucint(conc = tmpdata\(conc, time = tmpdata\)time, interval = c(0, 3), auc.type =”AUCall“), pk.calc.auc(conc = tmpdata\(conc, time = tmpdata\)time, interval = c(0, 3), auc.type =”AUClast“), info =”AUCall is the same as AUClast when no BLQ follow tlast (test AUClast)")),
call = list(expect_equal(pk.calc.aucint(conc = tmpdata\(conc, time = tmpdata\)time, interval =c(0, 3), auc.type= “AUCall”), pk.calc.auc(conc = tmpdata\(conc, time = tmpdata\)time, interval = c(0, 3), auc.type = “AUClast”), info = “AUCall is the same as AUClast when no BLQ follow tlast (test AUClast)”)), start_frame = 74, end_frame = 74, test = “AUCint respects auc.type and does the correct calculations for each AUC type”), list(message = “pk.calc.aucint(…) not equal to pk.calc.auc(…).”,
srcref = c(175, 3, 179, 108, 3, 108, 175, 179), expectation_calls = list(expect_equal(pk.calc.aucint(conc = tmpdata_blq$conc, time = tmpdata_blq$time, interval = c(0, 4), auc.type = “AUCall”), pk.calc.auc(conc = tmpdata_blq\(conc, time = tmpdata_blq\)time, interval = c(0, 4), auc.type = “AUCall”), info = “AUCall is the same the normal calculation when no interpolation/extrapolation happens”)), call = list(expect_equal(pk.calc.aucint(conc = tmpdata_blq\(conc, time = tmpdata_blq\)time, interval = c(0,
4), auc.type = “AUCall”), pk.calc.auc(conc = tmpdata_blq\(conc, time = tmpdata_blq\)time, interval = c(0, 4),auc.type = “AUCall”), info = "AUCall is the same the normal calculation when no interpolation/extrapolation happens“)), start_frame = 74, end_frame = 74, test =”AUCint respects auc.type and does the correct calculations for each AUC type“), list(message =”pk.calc.aucint(…) not equal to pk.calc.auc(…).", srcref = c(180, 3, 184, 46, 3, 46, 180, 184), expectation_calls = list(
expect_equal(pk.calc.aucint(conc = tmpdata_blq\(conc, time = tmpdata_blq\)time, interval = c(0,3.5), auc.type =“AUCall”), pk.calc.auc(conc = c(tmpdata\(conc, 0.5), time = c(tmpdata\)time, 3.5), interval = c(0, 4), auc.type = “AUClast”), info = “AUCall traces correctly”)), call = list(expect_equal(pk.calc.aucint(conc = tmpdata_blq\(conc, time = tmpdata_blq\)time, interval = c(0, 3.5), auc.type = “AUCall”), pk.calc.auc(conc = c(tmpdata\(conc, 0.5), time = c(tmpdata\)time, 3.5), interval = c(0, 4),
auc.type =“AUClast”), info = “AUCall traces correctly”)), start_frame = 74, end_frame = 74,test = "AUCint respects auc.type and does the correct calculations for each AUC type"))
test-aucint.Raucint respects doses303list(list(message = “pk.calc.aucint(…) not equal to pk.calc.aucint(…).”, srcref = c(196, 3, 200, 99, 3, 99, 196, 200), expectation_calls = list(expect_equal(pk.calc.aucint(conc = tmpdata_blq\(conc, time = tmpdata_blq\)time, interval = c(0, 4), auc.type = “AUCall”, time.dose = time.dose_at), pk.calc.aucint(conc = tmpdata_blq\(conc, time = tmpdata_blq\)time, interval = c(0, 4), auc.type = “AUCall”), info = “Calculation with dosing at the same time as an observation causes no change.”)), call = list(
expect_equal(pk.calc.aucint(conc = tmpdata_blq\(conc, time = tmpdata_blq\)time, interval = c(0, 4),auc.type = "AUCall", time.dose = time.dose_at), pk.calc.aucint(conc = tmpdata_blq\(conc, time = tmpdata_blq\)time, interval = c(0, 4), auc.type = “AUCall”), info = “Calculation with dosing at the same time as an observation causes no change.”)), start_frame = 74, end_frame = 74, test = “aucint respects doses”), list(message = “pk.calc.aucint(…) not equal to pk.calc.aucint(…).”, srcref = c(201,
3, 205, 97, 3, 97,201, 205), expectation_calls = list(expect_equal(pk.calc.aucint(conc = tmpdata_blq$conc, time = tmpdata_blq$time, interval =c(0, 4),auc.type = “AUCall”, time.dose = time.dose_after_all), pk.calc.aucint(conc = tmpdata_blq\(conc, time = tmpdata_blq\)time, interval = c(0, 4), auc.type = “AUCall”), info = “Calculation with dosing at a time after all observations causes no change.”)), call = list(expect_equal(pk.calc.aucint(conc = tmpdata_blq\(conc, time = tmpdata_blq\)time, interval = c(0,
4), auc.type =“AUCall”, time.dose = time.dose_after_all), pk.calc.aucint(conc = tmpdata_blq$conc, time = tmpdata_blq$time, interval = c(0,4), auc.type = “AUCall”), info = “Calculation with dosing at a time after all observations causes no change.”)), start_frame = 74, end_frame = 74, test = “aucint respects doses”), list(message = “pk.calc.aucint(…) not equal to pk.calc.aucint(…).”, srcref = c(214, 3, 219, 97, 3, 97, 214, 219), expectation_calls = list(expect_equal(pk.calc.aucint(conc = tmpdata_blq$conc,
time = tmpdata_blq$time, time.dose = 5, interval = c(0, 4), auc.type = “AUCall”), pk.calc.aucint(conc = tmpdata_blq$conc, time = tmpdata_blq$time, interval = c(0, 4), auc.type = “AUCall”), info = “Calculation with dosing at a time after all observations causes no change.”)), call = list(expect_equal(pk.calc.aucint(conc = tmpdata_blq\(conc, time = tmpdata_blq\)time, time.dose = 5, interval = c(0, 4), auc.type = “AUCall”), pk.calc.aucint(conc = tmpdata_blq\(conc, time = tmpdata_blq\)time, interval = c(0,
4), auc.type =“AUCall”), info = "Calculation with dosing at a time after all observations causesno change.")), start_frame = 74, end_frame= 74, test = “aucint respects doses”))
test-aucint.Raucint works with infinite intervals404list(list(message = “pk.calc.aucint.last(…) not equal to pk.calc.auc.last(conc = tmpdata\(conc, time = tmpdata\)time).”, srcref = c(225, 3, 227, 51, 3, 51, 225, 227), expectation_calls = list(expect_equal(pk.calc.aucint.last(conc = tmpdata\(conc, time = tmpdata\)time, start = 0, end = Inf), pk.calc.auc.last(conc = tmpdata\(conc, time = tmpdata\)time), info = “Simple AUClast = aucint.last”)), call = list(expect_equal(pk.calc.aucint.last(conc = tmpdata\(conc, time = tmpdata\)time, start = 0, end = Inf),
pk.calc.auc.last(conc = tmpdata\(conc, time = tmpdata\)time), info = “Simple AUClast = aucint.last”)), start_frame =74, end_frame = 74, test= "aucintworks with infinite intervals“), list(message =”pk.calc.aucint.all(…) not equal to pk.calc.auc.all(conc = tmpdata\(conc, time = tmpdata\)time).", srcref = c(228, 3, 230, 49, 3, 49, 228, 230), expectation_calls = list(expect_equal(pk.calc.aucint.all(conc = tmpdata\(conc, time = tmpdata\)time, start = 0, end = Inf), pk.calc.auc.all(conc = tmpdata$conc,
time = tmpdata$time), info = “Simple AUCall = aucint.all”)), call = list(expect_equal(pk.calc.aucint.all(conc = tmpdata$conc, time = tmpdata$time, start = 0, end = Inf), pk.calc.auc.all(conc = tmpdata\(conc, time = tmpdata\)time), info = “Simple AUCall = aucint.all”)), start_frame = 74, end_frame = 74, test = “aucint works with infinite intervals”), list(message = “pk.calc.aucint.inf.obs(…) not equal to pk.calc.auc.inf.obs(…).”, srcref = c(231, 3, 236, 57, 3, 57, 231, 236), expectation_calls = list(
expect_equal(pk.calc.aucint.inf.obs(conc = tmpdata\(conc, time = tmpdata\)time, start = 0, end = Inf, clast.obs = 1,lambda.z = log(2)), pk.calc.auc.inf.obs(conc = tmpdata\(conc, time = tmpdata\)time, clast.obs = 1, lambda.z = log(2)), info = “Simple AUCinf.obs = aucint.inf.obs”)), call = list(expect_equal(pk.calc.aucint.inf.obs(conc = tmpdata\(conc, time = tmpdata\)time, start = 0, end = Inf, clast.obs = 1, lambda.z = log(2)), pk.calc.auc.inf.obs(conc = tmpdata\(conc, time = tmpdata\)time, clast.obs = 1,
lambda.z = log(2)), info = “Simple AUCinf.obs = aucint.inf.obs”)), start_frame = 74, end_frame =74, test = "aucintworks with infinite intervals"),list(message = “pk.calc.aucint.inf.pred(…) not equal to pk.calc.auc.inf.pred(…).”, srcref = c(237, 3, 242, 59, 3, 59, 237, 242), expectation_calls = list(expect_equal(pk.calc.aucint.inf.pred(conc = tmpdata\(conc, time = tmpdata\)time, start = 0, end = Inf, clast.pred = 2, lambda.z = log(2)), pk.calc.auc.inf.pred(conc = tmpdata\(conc, time = tmpdata\)time,
clast.pred = 2,lambda.z = log(2)), info = “Simple AUCinf.pred = aucint.inf.pred”)), call = list(expect_equal(pk.calc.aucint.inf.pred(conc =tmpdata$conc, time = tmpdata\(time, start = 0, end = Inf, clast.pred = 2, lambda.z = log(2)), pk.calc.auc.inf.pred(conc = tmpdata\)conc, time = tmpdata$time, clast.pred = 2, lambda.z = log(2)), info = “Simple AUCinf.pred = aucint.inf.pred”)), start_frame = 74, end_frame = 74, test = “aucint works with infinite intervals”))

+

+

+
AUC interval checking

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Testing FilenameTest DescriptionNumber of TestsNumber of Failed Testspassedresult
test-check.intervals.Rcheck.interval.specification24024list(list(message = "“, srcref = c(14, 5, 16, 87, 5, 87, 14, 16), expectation_calls = list(expect_warning(check.interval.specification(as.matrix(d1)), regexp =”Interval specification must be a data.frame“, info =”Interval must be a data.frame or coercable into a data frame“)), call = list(expect_warning(check.interval.specification(as.matrix(d1)), regexp =”Interval specification must be a data.frame“, info =”Interval must be a data.frame or coercable into a data frame")), start_frame = 74, end_frame = 74,
test = "check.interval.specification“), list(message =”", srcref = c(17, 5, 19,91, 5, 91, 17, 19), expectation_calls = list(expect_warning(d1.check <- check.interval.specification(d1), regexp = “Nothing to be calculated in interval specification number\(s\): 1”, info = “Warn if nothing is to be calculated in an interval specification”)), call = list(expect_warning(d1.check <- check.interval.specification(d1), regexp = “Nothing to be calculated in interval specification number\(s\): 1”,
info = "Warn if nothing is to be calculated in an interval specification")), start_frame = 74, end_frame= 74, test = “check.interval.specification”), list(message = “d1.check not equal to r1[, nameorder].”, srcref = c(20, 5, 21, 79, 5, 79, 20, 21), expectation_calls = list(expect_equal(d1.check, r1[, nameorder], info = “Expand a minimal data frame for interval specification”)), call = list(expect_equal(d1.check, r1[, nameorder], info = “Expand a minimal data frame for interval specification”)),
start_frame = 74, end_frame = 74, test = "check.interval.specification"), list(message = "check.interval.specification(d2) not equal to r2[, nameorder].“, srcref = c(30, 5, 32, 95, 5, 95, 30, 32), expectation_calls = list(expect_equal(check.interval.specification(d2), r2[, nameorder], info =”Expand a data frame interval specification with only one request given“)), call = list(expect_equal(check.interval.specification(d2), r2[, nameorder], info =”Expand a data frame interval specification with only one request given")),
start_frame = 74, end_frame = 74, test = "check.interval.specification"), list(message = "", srcref = c(36, 5, 38,72, 5, 72, 36, 38), expectation_calls = list(expect_error(check.interval.specification(d3), regexp = “Column\(s\) ‘end’ missing from interval specification”, info = “Confirm end column is in interval specification”)), call = list(expect_error(check.interval.specification(d3), regexp = “Column\(s\) ‘end’ missing from interval specification”, info = “Confirm end column is in interval specification”)),
start_frame = 74, end_frame = 74, test = "check.interval.specification"), list(message = "", srcref = c(40, 5, 42,74, 5, 74, 40, 42), expectation_calls = list(expect_error(check.interval.specification(d4), regexp = “Column\(s\) ‘start’ missing from interval specification”, info = “Confirm start column is in interval specification”)), call = list(expect_error(check.interval.specification(d4), regexp = “Column\(s\) ‘start’ missing from interval specification”, info = “Confirm start column is in interval specification”)),
start_frame = 74, end_frame = 74, test = "check.interval.specification"), list(message = "", srcref = c(44, 5, 46,84, 5, 84, 44, 46), expectation_calls = list(expect_error(check.interval.specification(d5), regexp = “Column\(s\) ‘start’, ‘end’ missing from interval specification”, info = “Confirm start and end columns are in interval specification”)), call = list(expect_error(check.interval.specification(d5), regexp = “Column\(s\) ‘start’, ‘end’ missing from interval specification”, info = “Confirm start and end columns are in interval specification”)),
start_frame = 74, end_frame = 74, test = "check.interval.specification"), list(message = "", srcref = c(50, 5, 52,86, 5, 86, 50, 52), expectation_calls = list(expect_error(check.interval.specification(d6), regexp = “interval specification has no rows”, info = “It is an error to have an interval specification with no rows”)), call = list(expect_error(check.interval.specification(d6), regexp = “interval specification has no rows”, info = “It is an error to have an interval specification with no rows”)),
start_frame = 74, end_frame = 74, test = "check.interval.specification"), list(message = "", srcref = c(56, 5, 59,74, 5, 74, 56, 59), expectation_calls = list(expect_error(check.interval.specification(d7), regexp = “Interval specification may not have NA for the starting time”, info = “Interval specification may not have NA for the starting time”)), call = list(expect_error(check.interval.specification(d7), regexp = “Interval specification may not have NA for the starting time”, info = “Interval specification may not have NA for the starting time”)),
start_frame = 74, end_frame = 74, test = "check.interval.specification"), list(message = "", srcref = c(61, 5, 64,69, 5, 69, 61, 64), expectation_calls = list(expect_error(check.interval.specification(d8), regexp = “Interval specification may not have NA for the end time”, info = “Interval specification may not have NA for the end time”)), call = list(expect_error(check.interval.specification(d8), regexp = “Interval specification may not have NA for the end time”, info = “Interval specification may not have NA for the end time”)),
start_frame = 74, end_frame = 74, test = "check.interval.specification"), list(message = "", srcref = c(66, 5, 68,89, 5, 89, 66, 68), expectation_calls = list(expect_error(check.interval.specification(d9), regexp = “start must be < end”, info = “In interval specification, start must be < end (they are equal).”)), call = list(expect_error(check.interval.specification(d9), regexp = “start must be < end”, info = “In interval specification, start must be < end (they are equal).”)), start_frame = 74,
end_frame = 74, test= “check.interval.specification”), list(message = "", srcref = c(70, 5, 72, 86, 5, 86, 70, 72), expectation_calls = list(expect_error(check.interval.specification(d10), regexp = “start must be < end”, info = “In interval specification, start must be < end (end is less).”)), call = list(expect_error(check.interval.specification(d10), regexp = “start must be < end”, info = “In interval specification, start must be < end (end is less).”)), start_frame = 74, end_frame = 74, test = “check.interval.specification”),
list(message = "", srcref = c(74, 5, 76, 98, 5, 98, 74, 76), expectation_calls =list(expect_error(check.interval.specification(d11), regexp = “start may not be infinite”, info = “In interval specification, start may not be infinite (positive infinity).”)), call = list(expect_error(check.interval.specification(d11), regexp = “start may not be infinite”, info = “In interval specification, start may not be infinite (positive infinity).”)), start_frame = 74, end_frame = 74, test = “check.interval.specification”),
list(message = "", srcref = c(78, 5, 80, 98, 5, 98, 78, 80), expectation_calls =list(expect_error(check.interval.specification(d12), regexp = “start may not be infinite”, info = “In interval specification, start may not be infinite (negative infinity).”)), call = list(expect_error(check.interval.specification(d12), regexp = “start may not be infinite”, info = “In interval specification, start may not be infinite (negative infinity).”)), start_frame = 74, end_frame = 74, test = “check.interval.specification”),
list(message = "", srcref = c(88, 5, 88, 66, 5, 66, 88, 88), expectation_calls =list(expect_warning(d13.check <-check.interval.specification(d13))), call = list(expect_warning(d13.check <- check.interval.specification(d13))), start_frame = 74, end_frame = 74, test = “check.interval.specification”), list(message = “d13.check not equal to r13[, nameorder].”, srcref = c(89, 5, 90, 92, 5, 92, 89, 90), expectation_calls = list(expect_equal(d13.check, r13[, nameorder], info = “In interval specification, end may be infinite (positive infinity).”)),
call = list(expect_equal(d13.check, r13[, nameorder], info= "In interval specification, end may be infinite (positive infinity).“)), start_frame = 74, end_frame = 74, test =”check.interval.specification“), list(message =”“, srcref = c(91, 5, 92, 98, 5, 98, 91, 92), expectation_calls = list(expect_error(check.interval.specification(data.frame(start = 0, end = -Inf)), info =”In interval specification, end may not be negative infinity (start is 0).")), call = list(expect_error(check.interval.specification(data.frame(start = 0,
end = -Inf)), info = "In interval specification, end may not be negative infinity (start is 0).")), start_frame = 74, end_frame = 74, test = “check.interval.specification”), list(message = "“, srcref = c(93, 5, 94, 101, 5, 101, 93, 94), expectation_calls = list(expect_error(check.interval.specification(data.frame(start = -Inf, end = -Inf)), info =”In interval specification, end may not be negative infinity (start is -Inf).")), call = list(expect_error(check.interval.specification(data.frame(start = -Inf,
end = -Inf)), info = "In interval specification, end may not be negative infinity (start is -Inf).")), start_frame = 74, end_frame = 74, test = “check.interval.specification”), list(message = "“, srcref = c(99, 5, 101, 98, 5, 98, 99, 101), expectation_calls = list(expect_warning(check.interval.specification(d14), regexp =”Nothing to be calculated in interval specification number\(s\): 1, 2, 3“, info =”Warn when nothing is to be calculated in all rows of the specification.")), call = list(
expect_warning(check.interval.specification(d14), regexp ="Nothing to be calculated in interval specificationnumber\(s\): 1, 2, 3“, info =”Warn when nothing is to be calculated in all rows of the specification.“)), start_frame = 74, end_frame = 74, test =”check.interval.specification“), list(message =”“, srcref = c(104, 5, 106, 110, 5, 110, 104, 106), expectation_calls = list(expect_warning(check.interval.specification(d14), regexp =”Nothing to be calculated in interval specification number\(s\): 4",
info = "Warn whennothing is to be calculated in one but not all rows of thespecification.")), call= list(expect_warning(check.interval.specification(d14), regexp = “Nothing to be calculated in interval specification number\(s\): 4”, info = “Warn when nothing is to be calculated in one but not all rows of the specification.”)), start_frame = 74, end_frame = 74, test = “check.interval.specification”), list(message = "", srcref = c(117, 5, 117, 60, 5, 60, 117, 117), expectation_calls = list(
expect_warning(v15 <- check.interval.specification(d15))),call = list(expect_warning(v15 <- check.interval.specification(d15))), start_frame = 74, end_frame = 74, test = “check.interval.specification”), list(message = “v15 not equal to r15[, c(nameorder, "treatment")].”, srcref = c(118, 5, 119, 87, 5, 87, 118, 119), expectation_calls = list(expect_equal(v15, r15[, c(nameorder, “treatment”)], info = “Extra information is maintained in the interval specification.”)), call = list(
expect_equal(v15,r15[, c(nameorder, “treatment”)], info ="Extra information is maintained in the interval specification.“)), start_frame = 74, end_frame = 74, test =”check.interval.specification“), list(message =”“, srcref = c(122, 5, 124, 64, 5, 64, 122, 124), expectation_calls = list(expect_error(check.interval.specification(d16), regexp =”Interval column ‘start’ should not be a factor“, info =”Start must be numeric and not a factor.")), call = list(expect_error(check.interval.specification(d16),
regexp = "Interval column ‘start’ should not be a factor",info = "Start must be numeric and not a factor.")),start_frame = 74, end_frame = 74, test = “check.interval.specification”), list(message = "“, srcref = c(126, 5, 128, 62, 5, 62, 126, 128), expectation_calls = list(expect_error(check.interval.specification(d17), regexp =”Interval column ‘end’ should not be a factor“, info =”End must be numeric and not a factor.“)), call = list(expect_error(check.interval.specification(d17), regexp =”Interval column ‘end’ should not be a factor",
info = "End mustbe numeric and not a factor.")), start_frame = 74, end_frame = 74, test = "check.interval.specification"))
test-check.intervals.Rcheck.interval.deps101list(list(message = “check.interval.deps(data.frame(start = 0, end = 24, aucinf.obs = TRUE)) not equal to r1[, nameorder].”, srcref = c(141, 3, 143, 82, 3, 82, 141, 143), expectation_calls = list(expect_equal(check.interval.deps(data.frame(start = 0, end = 24, aucinf.obs = TRUE)), r1[, nameorder], info = “Confirm that the interval dependencies are accurately added”)), call = list(expect_equal(check.interval.deps(data.frame(start = 0, end = 24, aucinf.obs = TRUE)), r1[, nameorder], info = “Confirm that the interval dependencies are accurately added”)),
start_frame = 74, end_frame = 74, test = “check.interval.deps”))
test-check.intervals.Rget.parameter.deps505list(list(message = "“, srcref = c(147, 3, 149, 56, 3, 56, 147, 149), expectation_calls = list(expect_error(get.parameter.deps(”foo“), regexp =”x must be the name of an NCA parameter listed by the function ‘get.interval.cols’“, info =”The argument must be a parameter.“)), call = list(expect_error(get.parameter.deps(”foo“), regexp =”x must be the name of an NCA parameter listed by the function ‘get.interval.cols’“, info =”The argument must be a parameter.")), start_frame = 74, end_frame = 74,
test = "get.parameter.deps“), list(message =”get.parameter.deps("kel.obs") not equal to c("kel.obs").", srcref = c(150, 3, 152, 95, 3, 95, 150, 152), expectation_calls = list(expect_equal(get.parameter.deps(“kel.obs”), c(“kel.obs”), info = “Parameters that have nothing that depend on them return themselves only.”)), call = list(expect_equal(get.parameter.deps(“kel.obs”), c(“kel.obs”), info = “Parameters that have nothing that depend on them return themselves only.”)), start_frame = 74,
end_frame = 74, test= “get.parameter.deps”), list(message = "get.parameter.deps("ctrough") not equal to c("ctrough", "ctrough.dn", "ptr").“, srcref = c(153, 3, 155, 129, 3, 129, 153, 155), expectation_calls = list(expect_equal(get.parameter.deps(”ctrough“), c(”ctrough“,”ctrough.dn“,”ptr“), info =”Parameters with formalsmap-related dependencies return themselves and the formalsmap-related dependencies.“)), call = list(expect_equal(get.parameter.deps(”ctrough“), c(”ctrough",
“ctrough.dn”, “ptr”),info = "Parameters with formalsmap-related dependencies return themselves and the formalsmap-related dependencies.“)), start_frame = 74, end_frame = 74, test =”get.parameter.deps“), list(message =”get.parameter.deps("start") not equal to character(0).“, srcref = c(156, 3, 158, 116, 3, 116, 156, 158), expectation_calls = list(expect_equal(get.parameter.deps(”start“), character(0), info =”Special columns that are not actually parameters have no dependencies (including themselves).")),
call = list(expect_equal(get.parameter.deps(“start”), character(0), info = "Special columns that are notactuallyparameters have no dependencies (including themselves).“)), start_frame = 74, end_frame = 74, test =”get.parameter.deps“), list(message =”get.parameter.deps("cl.obs") not equal to c("cl.obs", "vss.iv.obs", "vss.obs", "vz.obs").“, srcref = c(159, 3, 161, 64, 3, 64, 159, 161), expectation_calls = list(expect_equal(get.parameter.deps(”cl.obs“), c(”cl.obs“,”vss.iv.obs",
“vss.obs”, “vz.obs”),info = "Parameters with dependencies return them.")), call= list(expect_equal(get.parameter.deps(“cl.obs”), c(“cl.obs”, “vss.iv.obs”, “vss.obs”, “vz.obs”), info = “Parameters with dependencies return them.”)), start_frame = 74, end_frame = 74, test = “get.parameter.deps”))
test-check.intervals.Rcheck.intervals requires a valid value101list(list(message = "“, srcref = c(165, 3, 169, 3, 3, 3, 165, 169), expectation_calls = list(expect_error(check.interval.specification(data.frame(start = 0, end = 1, cmax =”A“)), regexp =”Invalid value(s) in column cmax:A“, fixed = TRUE)), call = list(expect_error(check.interval.specification(data.frame(start = 0, end = 1, cmax =”A“)), regexp =”Invalid value(s) in column cmax:A“, fixed = TRUE)), start_frame = 74, end_frame = 74, test =”check.intervals requires a valid value"))

+

+

+
Determining tau for AUCs

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Testing FilenameTest DescriptionNumber of TestsNumber of Failed Testspassedresult
test-choose-intervals.Rfind.tau16016list(list(message = “find.tau(sort(unique(c(seq(0, 168, 12), seq(4, 168, 12)))), tau.choices = NA) not equal to 12.”, srcref = c(5, 3, 9, 7, 3, 7, 5, 9), expectation_calls = list(expect_equal(find.tau(sort(unique(c(seq(0, 168, 12), seq(4, 168, 12)))), tau.choices = NA), 12)), call = list(expect_equal(find.tau(sort(unique(c(seq(0, 168, 12), seq(4, 168, 12)))), tau.choices = NA), 12)), start_frame = 74, end_frame = 74, test = “find.tau”), list(message = “find.tau(…) not equal to 12.”,
srcref = c(10, 3, 14,7, 3, 7, 10, 14), expectation_calls = list(expect_equal(find.tau(sort(unique(c(seq(0, 168, 12), seq(4, 168 + 12, 12)))), tau.choices = NA), 12)), call = list(expect_equal(find.tau(sort(unique(c(seq(0, 168, 12), seq(4, 168 + 12, 12)))), tau.choices = NA), 12)), start_frame = 74, end_frame = 74, test = “find.tau”), list(message = “find.tau(0:10, tau.choices = NA) not equal to 1.”, srcref = c(15, 3, 15, 49, 3, 49, 15, 15), expectation_calls = list(expect_equal(find.tau(0:10,
tau.choices = NA), 1)), call = list(expect_equal(find.tau(0:10,tau.choices = NA), 1)),start_frame = 74, end_frame = 74, test = “find.tau”), list(message = “find.tau(0:10, tau.choices = c(24, 168)) not equal to 1.”, srcref = c(17, 3, 17, 57, 3, 57, 17, 17), expectation_calls = list(expect_equal(find.tau(0:10, tau.choices = c(24, 168)), 1)), call = list(expect_equal(find.tau(0:10, tau.choices = c(24, 168)), 1)), start_frame = 74, end_frame = 74, test = “find.tau”), list(message = “find.tau(seq(0, 100, by = 10), tau.choices = c(24, 168)) not equal to 10.”,
srcref = c(18, 3, 19,52, 3, 52, 18, 19), expectation_calls = list(expect_equal(find.tau(seq(0, 100, by = 10), tau.choices = c(24, 168)), 10)), call = list(expect_equal(find.tau(seq(0, 100, by = 10), tau.choices = c(24, 168)), 10)), start_frame = 74, end_frame = 74, test = “find.tau”), list(message = “find.tau(seq(0, 48, by = 24), tau.choices = c(24, 168)) not equal to 24.”, srcref = c(20, 3, 21, 52, 3, 52, 20, 21), expectation_calls = list(expect_equal(find.tau(seq(0, 48, by = 24), tau.choices = c(24,
168)), 24)), call = list(expect_equal(find.tau(seq(0, 48, by =24), tau.choices = c(24,168)), 24)), start_frame = 74, end_frame = 74, test = “find.tau”), list(message = “find.tau(…) not equal to 24.”, srcref = c(23, 3, 26, 18, 3, 18, 23, 26), expectation_calls = list(expect_equal(find.tau(c(seq(0, 48, by = 24), seq(10, 48, by = 24)), tau.choices = c(24, 168)), 24)), call = list(expect_equal(find.tau(c(seq(0, 48, by = 24), seq(10, 48, by = 24)), tau.choices = c(24, 168)), 24)), start_frame = 74,
end_frame = 74, test =“find.tau”), list(message = "find.tau(...) not equal to 24.l", srcref = c(29, 3, 32, 18, 3, 18, 29, 32), expectation_calls = list(expect_equal(find.tau(c(seq(0, 48, by = 12), seq(10, 48, by = 12)), tau.choices = c(24, 168)), 24)), call = list(expect_equal(find.tau(c(seq(0, 48, by = 12), seq(10, 48, by = 12)), tau.choices = c(24, 168)), 24)), start_frame = 74, end_frame = 74, test = “find.tau”), list(message = “find.tau(…) not equal to 24.”, srcref = c(34,
3, 39, 7, 3, 7, 34, 39), expectation_calls = list(expect_equal(find.tau(sort(unique(c(seq(0,168, by= 24), seq(4, 168, by = 24), seq(10, 168, by = 24)))), tau.choices = c(24, 168)), 24)), call = list(expect_equal(find.tau(sort(unique(c(seq(0, 168, by = 24), seq(4, 168, by = 24), seq(10, 168, by = 24)))), tau.choices = c(24, 168)), 24)), start_frame = 74, end_frame = 74, test = “find.tau”), list(message = “find.tau(…) not equal to 168.”, srcref = c(40, 3, 42, 19, 3, 19, 40, 42), expectation_calls = list(
expect_equal(find.tau(c(0, 5, 19, 30) + rep((0:5) * 168, each =4), tau.choices = c(24,168)), 168)), call = list(expect_equal(find.tau(c(0, 5, 19, 30) + rep((0:5) * 168, each = 4), tau.choices = c(24, 168)), 168)), start_frame = 74, end_frame = 74, test = “find.tau”), list(message = “find.tau(rep(5, 5), tau.choices = c(24, 168)) not equal to 0.”, srcref = c(45, 3, 45, 62, 3, 62, 45, 45), expectation_calls = list(expect_equal(find.tau(rep(5, 5), tau.choices = c(24, 168)), 0)), call = list(
expect_equal(find.tau(rep(5, 5), tau.choices= c(24, 168)), 0)), start_frame = 74, end_frame = 74, test = “find.tau”), list(message = “find.tau(rep(0, 5), tau.choices = c(24, 168)) not equal to 0.”, srcref = c(46, 3, 46, 62, 3, 62, 46, 46), expectation_calls = list(expect_equal(find.tau(rep(0, 5), tau.choices = c(24, 168)), 0)), call = list(expect_equal(find.tau(rep(0, 5), tau.choices = c(24, 168)), 0)), start_frame = 74, end_frame = 74, test = “find.tau”), list(message = “find.tau(NA, tau.choices = c(24, 168)) not equal to NA.”,
srcref = c(48, 3, 50,18, 3, 18, 48, 50), expectation_calls = list(expect_equal(find.tau(NA, tau.choices = c(24, 168)), NA)), call = list(expect_equal(find.tau(NA, tau.choices = c(24, 168)), NA)), start_frame = 74, end_frame = 74, test = “find.tau”), list(message = “find.tau(rep(NA, 10), tau.choices = c(24, 168)) not equal to NA.”, srcref = c(51, 3, 53, 18, 3, 18, 51, 53), expectation_calls = list(expect_equal(find.tau(rep(NA, 10), tau.choices = c(24, 168)), NA)), call = list(expect_equal(find.tau(rep(NA,
10), tau.choices = c(24, 168)), NA)), start_frame = 74, end_frame = 74, test = "find.tau"), list(message = “find.tau(c(0, 1, 3, 5, 9), tau.choices = c(24, 168)) not equal to NA.”, srcref = c(55, 3, 57, 18, 3, 18, 55, 57), expectation_calls = list(expect_equal(find.tau(c(0, 1, 3, 5, 9), tau.choices = c(24, 168)), NA)), call = list(expect_equal(find.tau(c(0, 1, 3, 5, 9), tau.choices = c(24, 168)), NA)), start_frame = 74, end_frame = 74, test = “find.tau”), list(message = “find.tau(c(0, 1, 3, 5, 9, 24), tau.choices = NA) not equal to NA.”,
srcref = c(58, 3, 60,18, 3, 18, 58, 60), expectation_calls = list(expect_equal(find.tau(c(0, 1,3, 5, 9, 24), tau.choices = NA), NA)), call = list(expect_equal(find.tau(c(0, 1, 3, 5, 9, 24), tau.choices = NA), NA)), start_frame = 74, end_frame = 74, test = “find.tau”))
test-choose-intervals.Rchoose.auc.intervals10010list(list(message = "“, srcref = c(74, 3, 75, 61, 3, 61, 74, 75), expectation_calls = list(expect_error(choose.auc.intervals(NA, 1, tmp.single.dose.auc), regexp =”time.conc may not have any NA values“)), call = list(expect_error(choose.auc.intervals(NA, 1, tmp.single.dose.auc), regexp =”time.conc may not have any NA values“)), start_frame = 74, end_frame = 74, test =”choose.auc.intervals“), list(message =”", srcref = c(76, 3, 77, 63, 3, 63, 76, 77), expectation_calls = list(expect_error(choose.auc.intervals(1,
NA, tmp.single.dose.auc), regexp = "time.dosing may not have any NA values")), call = list(expect_error(choose.auc.intervals(1, NA, tmp.single.dose.auc), regexp = “time.dosing may not have any NA values”)), start_frame = 74, end_frame = 74, test = “choose.auc.intervals”), list(message = "“, srcref = c(80, 3, 82, 59, 3, 59, 80, 82), expectation_calls = list(expect_error(choose.auc.intervals(1, 1, single.dose.aucs = data.frame()), regexp =”interval specification has no rows")), call = list(expect_error(choose.auc.intervals(1,
1, single.dose.aucs =data.frame()), regexp ="interval specification has no rows")), start_frame= 74, end_frame = 74, test = “choose.auc.intervals”), list(message = “choose.auc.intervals(1, 1, single.dose.aucs = tmp.single.dose.auc) not equal to check.interval.specification(…).”, srcref = c(84, 3, 91, 55, 3, 55, 84, 91), expectation_calls = list(expect_equal(choose.auc.intervals(1, 1, single.dose.aucs = tmp.single.dose.auc), check.interval.specification(data.frame(start = 1, end = c(25,
Inf), auclast = c(TRUE, FALSE), aucinf = c(FALSE, TRUE), half.life = c(FALSE, TRUE))))),call = list(expect_equal(choose.auc.intervals(1, 1, single.dose.aucs = tmp.single.dose.auc), check.interval.specification(data.frame(start = 1, end = c(25, Inf), auclast = c(TRUE, FALSE), aucinf = c(FALSE, TRUE), half.life = c(FALSE, TRUE))))), start_frame = 74, end_frame = 74, test = “choose.auc.intervals”), list(message = “choose.auc.intervals(c(1, 2, 3), c(1, 3), single.dose.aucs = tmp.single.dose.auc) not equal to check.interval.specification(…).”,
srcref = c(95, 3, 102,43, 3, 43, 95, 102), expectation_calls =list(expect_equal(choose.auc.intervals(c(1, 2, 3), c(1, 3), single.dose.aucs = tmp.single.dose.auc), check.interval.specification(data.frame(start = 1, end = 3, cmax = TRUE, tmax = TRUE, auclast = TRUE)))), call = list(expect_equal(choose.auc.intervals(c(1, 2, 3), c(1, 3), single.dose.aucs = tmp.single.dose.auc), check.interval.specification(data.frame(start = 1, end = 3, cmax = TRUE, tmax = TRUE, auclast = TRUE)))), start_frame = 74,
end_frame = 74, test =“choose.auc.intervals”), list(message ="choose.auc.intervals(1:5, c(1, 3), single.dose.aucs = tmp.single.dose.auc) not equal to check.interval.specification(…).", srcref = c(106, 3, 113, 43, 3, 43, 106, 113), expectation_calls = list(expect_equal(choose.auc.intervals(1:5, c(1, 3), single.dose.aucs = tmp.single.dose.auc), check.interval.specification(data.frame(start = c(1, 3), end = c(3, 5), cmax = TRUE, tmax = TRUE, auclast = TRUE)))), call = list(expect_equal(choose.auc.intervals(1:5,
c(1, 3), single.dose.aucs = tmp.single.dose.auc), check.interval.specification(data.frame(start =c(1, 3), end = c(3, 5), cmax = TRUE, tmax = TRUE, auclast = TRUE)))), start_frame = 74, end_frame = 74, test = “choose.auc.intervals”), list(message = “choose.auc.intervals(1:6, c(1, 3), single.dose.aucs = tmp.single.dose.auc) not equal to check.interval.specification(…).”, srcref = c(117, 3, 125, 62, 3, 62, 117, 125), expectation_calls = list(expect_equal(choose.auc.intervals(1:6, c(1, 3),
single.dose.aucs = tmp.single.dose.auc), check.interval.specification(data.frame(start =c(1, 3,3), end = c(3, 5, Inf), auclast = c(TRUE, TRUE, FALSE), cmax = c(TRUE, TRUE, FALSE), tmax = c(TRUE, TRUE, FALSE), half.life = c(FALSE, FALSE, TRUE))))), call = list(expect_equal(choose.auc.intervals(1:6, c(1, 3), single.dose.aucs = tmp.single.dose.auc), check.interval.specification(data.frame(start = c(1, 3, 3), end = c(3, 5, Inf), auclast = c(TRUE, TRUE, FALSE), cmax = c(TRUE, TRUE, FALSE), tmax = c(TRUE,
TRUE, FALSE), half.life = c(FALSE, FALSE, TRUE))))), start_frame = 74, end_frame = 74, test = "choose.auc.intervals“), list(message =”choose.auc.intervals(1:6, c(1, 3, 5, 7, 9), single.dose.aucs = tmp.single.dose.auc) not equal to check.interval.specification(…).", srcref = c(127, 3, 134, 40, 3, 40, 127, 134), expectation_calls = list(expect_equal(choose.auc.intervals(1:6, c(1, 3, 5, 7, 9), single.dose.aucs = tmp.single.dose.auc), check.interval.specification(data.frame(start = c(1,
3), end = c(3, 5), auclast = TRUE, cmax = TRUE, tmax = TRUE)))), call = list(expect_equal(choose.auc.intervals(1:6, c(1, 3, 5, 7, 9), single.dose.aucs = tmp.single.dose.auc), check.interval.specification(data.frame(start = c(1, 3), end = c(3, 5), auclast = TRUE, cmax = TRUE, tmax = TRUE)))), start_frame = 74, end_frame = 74, test = “choose.auc.intervals”), list(message = “choose.auc.intervals(c(1, 2, 3, 5, 6, 7), c(1, 3, 5, 7, 9), single.dose.aucs = tmp.single.dose.auc) not equal to check.interval.specification(…).”,
srcref = c(137, 3, 145, 43, 3, 43, 137, 145),expectation_calls= list(expect_equal(choose.auc.intervals(c(1, 2, 3, 5, 6, 7), c(1, 3, 5, 7, 9), single.dose.aucs = tmp.single.dose.auc), check.interval.specification(data.frame(start = c(1, 5), end = c(3, 7), cmax = TRUE, tmax = TRUE, auclast = TRUE)))), call = list(expect_equal(choose.auc.intervals(c(1, 2, 3, 5, 6, 7), c(1, 3, 5, 7, 9), single.dose.aucs = tmp.single.dose.auc), check.interval.specification(data.frame(start = c(1, 5), end = c(3,
7), cmax = TRUE, tmax = TRUE, auclast = TRUE)))), start_frame = 74, end_frame = 74,test = "choose.auc.intervals“), list(message =”choose.auc.intervals(1:6, c(1, 3, 5, 9), single.dose.aucs = tmp.single.dose.auc) not equal to check.interval.specification(…).", srcref = c(150, 3, 157, 40, 3, 40, 150, 157), expectation_calls = list(expect_equal(choose.auc.intervals(1:6, c(1, 3, 5, 9), single.dose.aucs = tmp.single.dose.auc), check.interval.specification(data.frame(start = c(1, 3), end = c(3,
5), auclast = TRUE, cmax = TRUE, tmax = TRUE)))), call = list(expect_equal(choose.auc.intervals(1:6, c(1, 3, 5, 9), single.dose.aucs = tmp.single.dose.auc), check.interval.specification(data.frame(start = c(1, 3), end = c(3, 5), auclast = TRUE, cmax = TRUE, tmax = TRUE)))), start_frame = 74, end_frame = 74, test = “choose.auc.intervals”))

+

+

+
Class generation-general

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Testing FilenameTest DescriptionNumber of TestsNumber of Failed Testspassedresult
test-class-general.RgetColumnValueorNot303list(list(message = “getColumnValueOrNot(tmpdata, "a", "d") not equal to list(data = tmpdata, name = "a").”, srcref = c(7, 3, 8, 44, 3, 44, 7, 8), expectation_calls = list(expect_equal(getColumnValueOrNot(tmpdata, “a”, “d”), list(data = tmpdata, name = “a”))), call = list(expect_equal(getColumnValueOrNot(tmpdata, “a”, “d”), list(data = tmpdata, name = “a”))), start_frame = 74, end_frame = 74, test = “getColumnValueorNot”), list(message = “getColumnValueOrNot(tmpdata, "d", "d") not equal to list(…).”,
srcref = c(9, 3, 12, 30, 3, 30, 9, 12), expectation_calls = list(expect_equal(getColumnValueOrNot(tmpdata,“d”, “d”), list(data = cbind(tmpdata, data.frame(d = “d”, stringsAsFactors = FALSE)), name = “d”))), call = list(expect_equal(getColumnValueOrNot(tmpdata, “d”, “d”), list(data = cbind(tmpdata, data.frame(d = “d”, stringsAsFactors = FALSE)), name = “d”))), start_frame = 74, end_frame = 74, test = “getColumnValueorNot”), list(message = "", srcref = c(13, 3, 14, 116, 3, 116, 13, 14), expectation_calls = list(
expect_error(getColumnValueOrNot(tmpdata, 1:3, “d”), regexp = "value wasnot a column name nor was it a scalar or a vector matching the length of the data“)), call = list(expect_error(getColumnValueOrNot(tmpdata, 1:3,”d“), regexp =”value was not a column name nor was it a scalar or a vector matching the length of the data“)), start_frame = 74, end_frame = 74, test =”getColumnValueorNot"))
test-class-general.RsetAttributeColumn19019list(list(message = "“, srcref = c(22, 3, 25, 49, 3, 49, 22, 25), expectation_calls = list(expect_error(setAttributeColumn(object = obj1, attr_name = c(”A“,”B“)), regexp =”attr_name must be a character scalar“, info =”attr_name must be a scalar“)), call = list(expect_error(setAttributeColumn(object = obj1, attr_name = c(”A“,”B“)), regexp =”attr_name must be a character scalar“, info =”attr_name must be a scalar“)), start_frame = 74, end_frame = 74, test =”setAttributeColumn“), list(message =”",
srcref = c(26, 3, 29, 52, 3, 52, 26, 29), expectation_calls = list(expect_error(setAttributeColumn(object= obj1, attr_name = 1), regexp = “attr_name must be a character scalar”, info = “attr_name must be a character”)), call = list(expect_error(setAttributeColumn(object = obj1, attr_name = 1), regexp = “attr_name must be a character scalar”, info = “attr_name must be a character”)), start_frame = 74, end_frame = 74, test = “setAttributeColumn”), list(message = "", srcref = c(30, 3, 34, 60, 3,
60, 30, 34), expectation_calls = list(expect_error(setAttributeColumn(object= obj1, attr_name = “A”,col_name= c(“foo”, “A”), default_value = 4), regexp = “col_name must be a character scalar”)), call = list(expect_error(setAttributeColumn(object = obj1, attr_name = “A”, col_name = c(“foo”, “A”), default_value = 4), regexp = “col_name must be a character scalar”)), start_frame = 74, end_frame = 74, test = “setAttributeColumn”), list(message = "", srcref = c(35, 3, 39, 60, 3, 60, 35, 39), expectation_calls = list(
expect_error(setAttributeColumn(object = obj1, attr_name = “A”, col_name= 1, default_value = 4),regexp =“col_name must be a character scalar”)), call = list(expect_error(setAttributeColumn(object = obj1, attr_name = “A”, col_name = 1, default_value = 4), regexp = “col_name must be a character scalar”)), start_frame = 74, end_frame = 74, test = “setAttributeColumn”), list(message = "", srcref = c(40, 3, 43, 98, 3, 98, 40, 43), expectation_calls = list(expect_error(setAttributeColumn(object = obj1,
attr_name = “B”, default_value = c(1:2)), regexp = "default_value must be a scalar or the same length as the rows in the data“)), call = list(expect_error(setAttributeColumn(object = obj1, attr_name =”B“, default_value = c(1:2)), regexp =”default_value must be a scalar or the same length as the rows in the data“)), start_frame = 74, end_frame = 74, test =”setAttributeColumn“), list(message =”", srcref = c(45, 3, 48, 92, 3, 92, 45, 48), expectation_calls = list(expect_message(val1 <- setAttributeColumn(object = obj1,
attr_name = “A”, default_value = 4), regexp = "Found column named A, using it for the attribute of the same name“)), call = list(expect_message(val1 <- setAttributeColumn(object = obj1, attr_name =”A“, default_value = 4), regexp =”Found column named A, using it for the attribute of the same name“)), start_frame = 74, end_frame = 74, test =”setAttributeColumn“), list(message =”val1 not equal to structure(…).", srcref = c(49, 3, 53, 99, 3, 99, 49, 53), expectation_calls = list(expect_equal(val1,
structure(list(data= data.frame(A = rep(4, 3)), columns = list(A = “A”)), class = “PKNCAconc”),info = "col_name defaults to attr_name, column values are not automatically replaced“)), call = list(expect_equal(val1, structure(list(data = data.frame(A = rep(4, 3)), columns = list(A =”A“)), class =”PKNCAconc“), info =”col_name defaults to attr_name, column values are not automatically replaced“)), start_frame = 74, end_frame = 74, test =”setAttributeColumn“), list(message =”", srcref = c(56,
3, 60, 86, 3, 86, 56, 60), expectation_calls = list(expect_error(setAttributeColumn(object = obj1, attr_name =“foo”, stop_if_default = “bar”), regexp = “bar”, info = “Error is triggered if default value is used and stop_if_default”)), call = list(expect_error(setAttributeColumn(object = obj1, attr_name = “foo”, stop_if_default = “bar”), regexp = “bar”, info = “Error is triggered if default value is used and stop_if_default”)), start_frame = 74, end_frame = 74, test = “setAttributeColumn”), list(
message = "", srcref = c(61, 3, 65, 88, 3, 88, 61, 65), expectation_calls = list(expect_warning(setAttributeColumn(object = obj1, attr_name = “foo”, warn_if_default = “bar”), regexp = “bar”, info = “Error is triggered if default value is used and stop_if_default”)), call = list(expect_warning(setAttributeColumn(object = obj1, attr_name = “foo”, warn_if_default = “bar”), regexp = “bar”, info = “Error is triggered if default value is used and stop_if_default”)), start_frame = 74, end_frame = 74,
test = "setAttributeColumn“), list(message =”", srcref = c(66, 3, 70, 90, 3, 90, 66, 70), expectation_calls = list(expect_message(setAttributeColumn(object = obj1, attr_name = “foo”, message_if_default = “bar”), regexp = “bar”, info = “Message is triggered if default value is used and stop_if_default”)), call = list(expect_message(setAttributeColumn(object = obj1, attr_name = “foo”, message_if_default = “bar”), regexp = “bar”, info = “Message is triggered if default value is used and stop_if_default”)),
start_frame = 74, end_frame = 74, test = "setAttributeColumn"), list(message = "setAttributeColumn(object= obj1, attr_name = "foo", default_value = 4) not equal to structure(…).“, srcref = c(72, 3, 79, 106, 3, 106, 72, 79), expectation_calls = list(expect_equal(setAttributeColumn(object = obj1, attr_name =”foo“, default_value = 4), structure(list(data = data.frame(A = 1:3, foo = 4), columns = list(foo =”foo“)), class =”PKNCAconc“), info =”col_name defaults to attr_name, column values are added if the column doesn’t exist")),
call = list(expect_equal(setAttributeColumn(object = obj1, attr_name = "foo", default_value = 4),structure(list(data = data.frame(A = 1:3, foo = 4), columns = list(foo = “foo”)), class = “PKNCAconc”), info = “col_name defaults to attr_name, column values are added if the column doesn’t exist”)), start_frame = 74, end_frame = 74, test = “setAttributeColumn”), list(message = “setAttributeColumn(…) not equal to structure(…).”, srcref = c(80, 3, 88, 97, 3, 97, 80, 88), expectation_calls = list(
expect_equal(setAttributeColumn(object = obj1, attr_name = “foo”, col_name = “bar”, default_value= 4), structure(list(data = data.frame(A = 1:3, bar = 4), columns = list(foo = “bar”)), class = “PKNCAconc”), info = “attr_name is set to col_name, column values are added if the column exists”)), call = list(expect_equal(setAttributeColumn(object = obj1, attr_name = “foo”, col_name = “bar”, default_value = 4), structure(list(data = data.frame(A = 1:3, bar = 4), columns = list(foo = “bar”)), class = “PKNCAconc”),
info = "attr_name is set to col_name, column values are added if the column exists")), start_frame = 74, end_frame = 74, test = “setAttributeColumn”), list(message = “setAttributeColumn(…) not equal to structure(…).”, srcref = c(89, 3, 96, 101, 3, 101, 89, 96), expectation_calls = list(expect_equal(setAttributeColumn(object = obj1, attr_name = “foo”, col_name = “A”, default_value = 4), structure(list(data = data.frame(A = rep(4, 3)), columns = list(foo = “A”)), class = “PKNCAconc”),
info = "attr_name is set to col_name, column values are not added if thecolumn exists")), call =list(expect_equal(setAttributeColumn(object = obj1, attr_name = “foo”, col_name = “A”, default_value = 4), structure(list(data = data.frame(A = rep(4, 3)), columns = list(foo = “A”)), class = “PKNCAconc”), info = “attr_name is set to col_name, column values are not added if the column exists”)), start_frame = 74, end_frame = 74, test = “setAttributeColumn”), list(message = “setAttributeColumn(…) not equal to structure(…).”,
srcref = c(101, 3,110, 54, 3, 54, 101, 110), expectation_calls = list(expect_equal(setAttributeColumn(object = obj2, attr_name = “bar”, col_name = “B”, default_value = 5), structure(list(data = data.frame(A = rep(4, 3), B = 5), columns = list(foo = “A”, bar = “B”)), class = “PKNCAconc”), info = “Adding a second attribute works”)), call = list(expect_equal(setAttributeColumn(object = obj2, attr_name = “bar”, col_name = “B”, default_value = 5), structure(list(data = data.frame(A = rep(4, 3), B = 5),
columns = list(foo = “A”, bar = “B”)), class = "PKNCAconc"), info ="Adding a second attribute works")), start_frame = 74, end_frame = 74, test = “setAttributeColumn”), list(message = “setAttributeColumn(…) not equal to structure(…).”, srcref = c(111, 3, 119, 97, 3, 97, 111, 119), expectation_calls = list(expect_equal(setAttributeColumn(object = obj2, attr_name = “foo”, col_name = “B”, default_value = 5), structure(list(data = data.frame(A = rep(4, 3), B = 5), columns = list(foo = “B”)),
class = “PKNCAconc”), info = "Overwriting an attributeworks and is non-destructive to the existing data")), call = list(expect_equal(setAttributeColumn(object = obj2, attr_name = “foo”, col_name = “B”, default_value = 5), structure(list(data = data.frame(A = rep(4, 3), B = 5), columns = list(foo = “B”)), class = “PKNCAconc”), info = “Overwriting an attribute works and is non-destructive to the existing data”)), start_frame = 74, end_frame = 74, test = “setAttributeColumn”), list(message = “setAttributeColumn(object = obj1, attr_name = "foo", col_name = "A") not equal to setAttributeColumn(object = obj1, attr_name = "foo", col_or_value = "A").”,
srcref = c(122, 3,128, 68, 3, 68, 122, 128), expectation_calls = list(expect_equal(setAttributeColumn(object = obj1, attr_name = “foo”, col_name = “A”), setAttributeColumn(object = obj1, attr_name = “foo”, col_or_value = “A”), info = “col_or_value assigns to col_name when present”)), call = list(expect_equal(setAttributeColumn(object = obj1, attr_name = “foo”, col_name = “A”), setAttributeColumn(object = obj1, attr_name = “foo”, col_or_value = “A”), info = “col_or_value assigns to col_name when present”)),
start_frame = 74, end_frame = 74, test = "setAttributeColumn"), list(message = "setAttributeColumn(object= obj1, attr_name = "foo", default_value = 5) not equal to setAttributeColumn(object = obj1, attr_name = "foo", col_or_value = 5).“, srcref = c(129, 3, 135, 91, 3, 91, 129, 135), expectation_calls = list(expect_equal(setAttributeColumn(object = obj1, attr_name =”foo“, default_value = 5), setAttributeColumn(object = obj1, attr_name =”foo“, col_or_value = 5), info =”col_or_value assigns to default_value when not present as a col_name")),
call = list(expect_equal(setAttributeColumn(object = obj1, attr_name = "foo", default_value = 5),setAttributeColumn(object = obj1, attr_name = “foo”, col_or_value = 5), info = “col_or_value assigns to default_value when not present as a col_name”)), start_frame = 74, end_frame = 74, test = “setAttributeColumn”), list(message = "“, srcref = c(136, 3, 140, 82, 3, 82, 136, 140), expectation_calls = list(expect_error(setAttributeColumn(object = obj1, attr_name =”foo", col_or_value = 5, default_value = 1),
regexp = "Cannot provide col_or_value and col_name ordefault_value")),call = list(expect_error(setAttributeColumn(object = obj1, attr_name = “foo”, col_or_value = 5, default_value = 1), regexp = “Cannot provide col_or_value and col_name or default_value”)), start_frame = 74, end_frame = 74, test = “setAttributeColumn”), list(message = "“, srcref = c(141, 3, 145, 82, 3, 82, 141, 145), expectation_calls = list(expect_error(setAttributeColumn(object = obj1, attr_name =”foo", col_or_value = 5,
col_name = “B”), regexp = "Cannot provide col_or_valueand col_name or default_value")), call = list(expect_error(setAttributeColumn(object = obj1, attr_name = “foo”, col_or_value = 5, col_name = “B”), regexp = “Cannot provide col_or_value and col_name or default_value”)), start_frame = 74, end_frame = 74, test = “setAttributeColumn”))
test-class-general.RgetAttributeColumn10010list(list(message = “getAttributeColumn(object = obj1, attr_name = "foo") not equal to data.frame(A = 1:3).”, srcref = c(162, 3, 164, 62, 3, 62, 162, 164), expectation_calls = list(expect_equal(getAttributeColumn(object = obj1, attr_name = “foo”), data.frame(A = 1:3), info = “A data frame (not a vector) is returned”)), call = list(expect_equal(getAttributeColumn(object = obj1, attr_name = “foo”), data.frame(A = 1:3), info = “A data frame (not a vector) is returned”)), start_frame = 74, end_frame = 74,
test = "getAttributeColumn“), list(message =”getAttributeColumn(object= obj2, attr_name = "bar") not equal to data.frame(A = 1:3, B = 4:6).“, srcref = c(165, 3, 168, 109, 3, 109, 165, 168), expectation_calls = list(expect_equal(getAttributeColumn(object = obj2, attr_name =”bar“), data.frame(A = 1:3, B = 4:6), info =”A data frame (not a vector) is returned, and that data frame may have multiple columns“)), call = list(expect_equal(getAttributeColumn(object = obj2, attr_name =”bar"),
data.frame(A = 1:3,B = 4:6), info = "A data frame (not a vector) is returned, and that data frame may have multiple columns“)), start_frame = 74, end_frame = 74, test =”getAttributeColumn“), list(message =”“, srcref = c(169, 3, 171, 65, 3, 65, 169, 171), expectation_calls = list(expect_warning(val1 <- getAttributeColumn(object = obj1, attr_name =”bar“), regexp =”bar is not set“, info =”The user is warned for missing attribute")), call = list(expect_warning(val1 <- getAttributeColumn(object = obj1,
attr_name = “bar”),regexp = “bar is not set”, info ="The user is warned for missing attribute")), start_frame = 74, end_frame = 74, test = “getAttributeColumn”), list(message = “is.null(val1) isn’t true.”, srcref = c(172, 3, 173, 52, 3, 52, 172, 173), expectation_calls = list(expect_true(is.null(val1), info = “missing attributes return NULL”)), call = list(expect_true(is.null(val1), info = “missing attributes return NULL”)), start_frame = 74, end_frame = 74, test = “getAttributeColumn”), list(
message = "", srcref = c(174, 3, 176, 62, 3, 62, 174,176), expectation_calls = list(expect_warning(val1 <- getAttributeColumn(object = obj3, attr_name = “foo”), regexp = “Columns C are not present”, info = “The user is warned for missing column”)), call = list(expect_warning(val1 <- getAttributeColumn(object = obj3, attr_name = “foo”), regexp = “Columns C are not present”, info = “The user is warned for missing column”)), start_frame = 74, end_frame = 74, test = “getAttributeColumn”), list(message = “getAttributeColumn(object = obj1, attr_name = \"bar\", warn_missing = \"column\") produced .”,
srcref = c(178, 3,178, 88, 3, 88, 178, 178), expectation_calls = list(expect_silent(getAttributeColumn(object = obj1, attr_name = “bar”, warn_missing = “column”))), call = list(expect_silent(getAttributeColumn(object = obj1, attr_name = “bar”, warn_missing = “column”))), start_frame = 74, end_frame = 74, test = “getAttributeColumn”), list(message = “getAttributeColumn(object = obj3, attr_name = \"foo\", warn_missing = \"attr\") produced .”, srcref = c(179, 3, 179, 86, 3, 86, 179, 179), expectation_calls = list(
expect_silent(getAttributeColumn(object = obj3, attr_name = “foo”, warn_missing = “attr”))), call= list(expect_silent(getAttributeColumn(object = obj3, attr_name = “foo”, warn_missing = “attr”))), start_frame = 74, end_frame = 74, test = “getAttributeColumn”), list(message = “getAttributeColumn(object = obj3, attr_name = \"foo\", warn_missing = c()) produced .”, srcref = c(180, 3, 180, 83, 3, 83, 180, 180), expectation_calls = list(expect_silent(getAttributeColumn(object = obj3, attr_name = “foo”,
warn_missing = c()))), call = list(expect_silent(getAttributeColumn(object = obj3, attr_name = "foo", warn_missing = c()))), start_frame = 74, end_frame = 74, test = “getAttributeColumn”), list(message = “getAttributeColumn(object = obj3, attr_name = \"bar\", warn_missing = c()) produced .”, srcref = c(181, 3, 181, 83, 3, 83, 181, 181), expectation_calls = list(expect_silent(getAttributeColumn(object = obj3, attr_name = “bar”, warn_missing = c()))), call = list(expect_silent(getAttributeColumn(object = obj3,
attr_name = “bar”,warn_missing = c()))), start_frame= 74, end_frame =74, test = "getAttributeColumn"),list(message = "“, srcref = c(182, 3, 183, 59, 3, 59, 182, 183), expectation_calls = list(expect_error(getAttributeColumn(object = obj3, attr_name =”foo“, warn_missing = c(”foo“)), info =”warn_missing must have a valid value“)), call = list(expect_error(getAttributeColumn(object = obj3, attr_name =”foo“, warn_missing = c(”foo“)), info =”warn_missing must have a valid value")), start_frame = 74,
end_frame = 74, test = “getAttributeColumn”))
test-class-general.RgetDataName.default returns NULL404list(list(message = “getDataName(1:5) is not null.”, srcref = c(187, 3, 188, 64, 3, 64, 187, 188), expectation_calls = list(expect_null(getDataName(1:5), info = “getDataName.default returns NULL (numeric)”)), call = list(expect_null(getDataName(1:5), info = “getDataName.default returns NULL (numeric)”)), start_frame = 74, end_frame = 74, test = “getDataName.default returns NULL”), list(message = “getDataName("a") is not null.”, srcref = c(189, 3, 190, 66, 3, 66, 189, 190), expectation_calls = list(
expect_null(getDataName(“a”), info = "getDataName.default returns NULL (character)")), call = list(expect_null(getDataName(“a”), info = “getDataName.default returns NULL (character)”)), start_frame = 74, end_frame = 74, test = “getDataName.default returns NULL”), list(message = “getDataName(factor("A")) is not null.”, srcref = c(191, 3, 192, 63, 3, 63, 191, 192), expectation_calls = list(expect_null(getDataName(factor(“A”)), info = “getDataName.default returns NULL (factor)”)), call = list(
expect_null(getDataName(factor(“A”)), info = "getDataName.default returns NULL (factor)")), start_frame =74, end_frame = 74, test = “getDataName.default returns NULL”), list(message = “getDataName(TRUE) is not null.”, srcref = c(193, 3, 194, 64, 3, 64, 193, 194), expectation_calls = list(expect_null(getDataName(TRUE), info = “getDataName.default returns NULL (logical)”)), call = list(expect_null(getDataName(TRUE), info = “getDataName.default returns NULL (logical)”)), start_frame = 74, end_frame = 74,
test = "getDataName.default returns NULL"))

+

+

+
Class generation-PKNCAconc

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Testing FilenameTest DescriptionNumber of TestsNumber of Failed Testspassedresult
test-class-PKNCAconc.RPKNCAconc12012list(list(message = "“, srcref = c(15, 3, 17, 46, 3, 46, 15, 17), expectation_calls = list(expect_error(PKNCAconc(data.frame()), regexp =”data must have at least one row.“, info =”PKNCAconc requires data“)), call = list(expect_error(PKNCAconc(data.frame()), regexp =”data must have at least one row.“, info =”PKNCAconc requires data“)), start_frame = 74, end_frame = 74, test =”PKNCAconc“), list(message =”", srcref = c(20, 3, 22, 71, 3, 71, 20, 22), expectation_calls = list(expect_error(PKNCAconc(tmp.conc,
formula = XXX ~ time| treatment + ID), regexp = "All of the variables in the formulamust be in the data", info = "Allformula parameters must be in the data (LHS)“)), call = list(expect_error(PKNCAconc(tmp.conc, formula = XXX ~ time | treatment + ID), regexp =”All of the variables in the formula must be in the data“, info =”All formula parameters must be in the data (LHS)“)), start_frame = 74, end_frame = 74, test =”PKNCAconc“), list(message =”", srcref = c(23, 3, 25, 71, 3, 71, 23, 25),
expectation_calls = list(expect_error(PKNCAconc(tmp.conc, formula =conc ~ XXX | treatment + ID), regexp = "All of thevariables in the formula must be in the data“, info =”All formula parameters must be in the data (RHS)“)), call = list(expect_error(PKNCAconc(tmp.conc, formula = conc ~ XXX | treatment + ID), regexp =”All of the variables in the formula must be in the data“, info =”All formula parameters must be in the data (RHS)“)), start_frame = 74, end_frame = 74, test =”PKNCAconc"), list(
message = "", srcref= c(26, 3, 28, 74, 3, 74, 26, 28), expectation_calls = list(expect_error(PKNCAconc(tmp.conc, formula = conc ~ time | XXX + ID), regexp = “All of the variables in the formula must be in the data”, info = “All formula parameters must be in the data (groups)”)), call = list(expect_error(PKNCAconc(tmp.conc, formula = conc ~ time | XXX + ID), regexp = “All of the variables in the formula must be in the data”, info = “All formula parameters must be in the data (groups)”)), start_frame = 74,
end_frame = 74, test= “PKNCAconc”), list(message = "", srcref = c(31, 3, 33, 74, 3,74, 31, 33), expectation_calls = list(expect_error(PKNCAconc(tmp.conc, formula = conc + ID ~ time | treatment + ID), regexp = “The left hand side of the formula must have exactly one variable”, info = “The right number of parameters in the formula (LHS)”)), call = list(expect_error(PKNCAconc(tmp.conc, formula = conc + ID ~ time | treatment + ID), regexp = “The left hand side of the formula must have exactly one variable”,
info = "The right number of parameters in the formula (LHS)")), start_frame = 74, end_frame = 74, test = "PKNCAconc"),list(message = "“, srcref = c(34, 3, 36, 74, 3, 74, 34, 36), expectation_calls = list(expect_error(PKNCAconc(tmp.conc, formula = conc ~ time + ID | treatment + ID), regexp =”The right hand side of the formula \(excluding groups\) must have exactly one variable“, info =”The right number of parameters in the formula (RHS)")), call = list(expect_error(PKNCAconc(tmp.conc, formula = conc ~
time + ID | treatment+ ID), regexp = "The right hand side of the formula \(excluding groups\) must have exactly onevariable“, info =”The right number of parameters in the formula (RHS)“)), start_frame = 74, end_frame = 74, test =”PKNCAconc“), list(message =”PKNCAconc(…) not equal to PKNCAconc(…).", srcref = c(39, 3, 40, 97, 3, 97, 39, 40), expectation_calls = list(expect_equal(PKNCAconc(tmp.conc.analyte, formula = conc ~ time | treatment + ID/analyte), PKNCAconc(tmp.conc.analyte,
formula = conc ~ time| treatment + ID/analyte, subject = “ID”))),call = list(expect_equal(PKNCAconc(tmp.conc.analyte,formula = conc ~ time | treatment + ID/analyte), PKNCAconc(tmp.conc.analyte, formula = conc ~ time | treatment + ID/analyte, subject = “ID”))), start_frame = 74, end_frame = 74, test = “PKNCAconc”), list(message = "", srcref = c(41, 3, 42, 59, 3, 59, 41, 42), expectation_calls = list(expect_error(PKNCAconc(tmp.conc.analyte, formula = conc ~ time | treatment + ID/analyte, subject = 5),
regexp = "subject must be a character string")), call = list(expect_error(PKNCAconc(tmp.conc.analyte, formula= conc ~time | treatment + ID/analyte, subject = 5), regexp = “subject must be a character string”)), start_frame = 74, end_frame = 74, test = “PKNCAconc”), list(message = "“, srcref = c(43, 3, 44, 49, 3, 49, 43, 44), expectation_calls = list(expect_error(PKNCAconc(tmp.conc.analyte, formula = conc ~ time | treatment + ID/analyte, subject = c(”“,”foo“)), regexp =”subject must be a scalar")),
call = list(expect_error(PKNCAconc(tmp.conc.analyte, formula = conc~ time | treatment + ID/analyte, subject =c("“,”foo“)), regexp =”subject must be a scalar“)), start_frame = 74, end_frame = 74, test =”PKNCAconc“), list(message =”“, srcref = c(45, 3, 46, 77, 3, 77, 45, 46), expectation_calls = list(expect_error(PKNCAconc(tmp.conc.analyte, formula = conc ~ time | treatment + ID/analyte, subject =”foo“), regexp =”The subject parameter must map to a name in the data")), call = list(expect_error(PKNCAconc(tmp.conc.analyte,
formula = conc ~ time| treatment + ID/analyte, subject = “foo”), regexp = "The subject parameter must map toa name inthe data“)), start_frame = 74, end_frame = 74, test =”PKNCAconc“), list(message =”“, srcref = c(49, 3, 51, 42, 3, 42, 49, 51), expectation_calls = list(expect_error(PKNCAconc(tmp.conc.analyte, formula = conc ~ time | treatment + ID), regexp =”Rows that are not unique per group and time“, info =”Duplicated key rows")), call = list(expect_error(PKNCAconc(tmp.conc.analyte,
formula = conc ~ time| treatment + ID), regexp = "Rows that are not unique per groupand time“, info =”Duplicated keyrows“)), start_frame = 74, end_frame = 74, test =”PKNCAconc“), list(message =”PKNCAconc(…) not equal to PKNCAconc(…).“, srcref = c(53, 3, 57, 91, 3, 91, 53, 57), expectation_calls = list(expect_equal(PKNCAconc(tmp.conc.analyte, formula = conc ~ time | treatment + ID/analyte), PKNCAconc(tbl_df(tmp.conc.analyte), formula = conc ~ time | treatment + ID/analyte), info =”tbl_df and data.frame classes both work and create identical objects")),
call = list(expect_equal(PKNCAconc(tmp.conc.analyte, formula = conc~ time | treatment + ID/analyte), PKNCAconc(tbl_df(tmp.conc.analyte), formula = conc ~ time | treatment + ID/analyte), info = “tbl_df and data.frame classes both work and create identical objects”)), start_frame = 74, end_frame = 74, test = “PKNCAconc”))
test-class-PKNCAconc.RPKNCAconc with input other than data.frames101list(list(message = "“, srcref = c(63, 3, 66, 59, 3, 59, 63, 66), expectation_calls = list(expect_error(PKNCAconc(tmp, formula = conc ~ time | treatment + ID), regexp = captured_message, fixed = TRUE, info =”Attempt to coerce into a data.frame.“)), call = list(expect_error(PKNCAconc(tmp, formula = conc ~ time | treatment + ID), regexp = captured_message, fixed = TRUE, info =”Attempt to coerce into a data.frame.“)), start_frame = 74, end_frame = 74, test =”PKNCAconc with input other than data.frames"))
test-class-PKNCAconc.Rmodel frame and parameter extractions12012list(list(message = “model.frame(…) not equal to tmp.conc[, c("conc", "time", "treatment", "ID")].”, srcref = c(71, 3, 73, 76, 3, 76, 71, 73), expectation_calls = list(expect_equal(model.frame(PKNCAconc(tmp.conc, formula = conc ~ time | treatment + ID)), tmp.conc[, c(“conc”, “time”, “treatment”, “ID”)], info = “model.frame.PKNCAconc extracts the correct components”)), call = list(expect_equal(model.frame(PKNCAconc(tmp.conc, formula = conc ~ time | treatment + ID)), tmp.conc[, c(“conc”,
“time”, “treatment”,“ID”)], info = "model.frame.PKNCAconc extractsthe correct components")), start_frame = 74, end_frame = 74, test = “model frame and parameter extractions”), list(message = “getDepVar(…) not equal to tmp.conc\(conc.\nEqual", srcref = c(74, 3, 76, 73, 3, 73, 74, 76), expectation_calls = list(expect_equal(getDepVar(PKNCAconc(tmp.conc, formula = conc ~ time | treatment + ID)), tmp.conc\)conc, info =”getDepVar.PKNCAconc extracts the correct component")), call = list(expect_equal(getDepVar(PKNCAconc(tmp.conc,
formula = conc ~ time| treatment + ID)), tmp.conc$conc, info = "getDepVar.PKNCAconcextracts the correct component")),start_frame = 74, end_frame = 74, test = “model frame and parameter extractions”), list(message = “getIndepVar(…) not equal to tmp.conc\(time.\nEqual", srcref = c(77, 3, 79, 75, 3, 75, 77, 79), expectation_calls = list(expect_equal(getIndepVar(PKNCAconc(tmp.conc, formula = conc ~ time | treatment + ID)), tmp.conc\)time, info =”getIndepVar.PKNCAconc extracts the correct component")),
call = list(expect_equal(getIndepVar(PKNCAconc(tmp.conc, formula =conc ~ time | treatment + ID)), tmp.conc$time, info= “getIndepVar.PKNCAconc extracts the correct component”)), start_frame = 74, end_frame = 74, test = “model frame and parameter extractions”), list(message = “getGroups.PKNCAconc(…) not equal to tmp.conc[, c("treatment", "ID")].”, srcref = c(80, 3, 82, 74, 3, 74, 80, 82), expectation_calls = list(expect_equal(getGroups.PKNCAconc(PKNCAconc(tmp.conc, formula = conc ~
time | treatment + ID)), tmp.conc[, c(“treatment”, “ID”)], info = "getGroups.PKNCAconc extracts the correct components")), call = list(expect_equal(getGroups.PKNCAconc(PKNCAconc(tmp.conc, formula = conc ~ time | treatment + ID)), tmp.conc[, c(“treatment”, “ID”)], info = “getGroups.PKNCAconc extracts the correct components”)), start_frame = 74, end_frame = 74, test = “model frame and parameter extractions”), list(message = “getGroups.PKNCAconc(…) not equal to tmp.conc[, "ID", drop = FALSE].”,
srcref = c(85, 3, 87,97, 3, 97, 85, 87), expectation_calls = list(expect_equal(getGroups.PKNCAconc(PKNCAconc(tmp.conc,formula = conc ~ time | ID)), tmp.conc[, “ID”, drop = FALSE], info = “getGroups.PKNCAconc returns a data.frame even with a single grouping level”)), call = list(expect_equal(getGroups.PKNCAconc(PKNCAconc(tmp.conc, formula = conc ~ time | ID)), tmp.conc[, “ID”, drop = FALSE], info = “getGroups.PKNCAconc returns a data.frame even with a single grouping level”)), start_frame = 74,
end_frame = 74, test= “model frame and parameter extractions”), list(message = "getGroups.PKNCAconc(…) notequal totmp.conc[, "treatment", drop = FALSE].“, srcref = c(90, 3, 92, 77, 3, 77, 90, 92), expectation_calls = list(expect_equal(getGroups.PKNCAconc(PKNCAconc(tmp.conc, formula = conc ~ time | treatment + ID), level = 1), tmp.conc[, "treatment", drop = FALSE], info =”getGroups.PKNCAconc the correct level (numeric scalar)")), call = list(expect_equal(getGroups.PKNCAconc(PKNCAconc(tmp.conc,
formula = conc ~ time| treatment + ID), level = 1), tmp.conc[, "treatment", drop = FALSE], info = "getGroups.PKNCAconcthe correct level (numeric scalar)“)), start_frame = 74, end_frame = 74, test =”model frame and parameter extractions“), list(message =”getGroups.PKNCAconc(…) not equal to tmp.conc[, "ID", drop = FALSE].", srcref = c(93, 3, 95, 86, 3, 86, 93, 95), expectation_calls = list(expect_equal(getGroups.PKNCAconc(PKNCAconc(tmp.conc, formula = conc ~ time | treatment + ID),
level = -1), tmp.conc[, “ID”, drop = FALSE], info = "getGroups.PKNCAconc the correctlevel (negative numeric scalar)")), call = list(expect_equal(getGroups.PKNCAconc(PKNCAconc(tmp.conc, formula = conc ~ time | treatment + ID), level = -1), tmp.conc[, “ID”, drop = FALSE], info = “getGroups.PKNCAconc the correct level (negative numeric scalar)”)), start_frame = 74, end_frame = 74, test = “model frame and parameter extractions”), list(message = “getGroups.PKNCAconc(…) not equal to tmp.conc[, c("treatment", "ID"), drop = FALSE].”,
srcref = c(96, 3, 98,77, 3, 77, 96, 98), expectation_calls = list(expect_equal(getGroups.PKNCAconc(PKNCAconc(tmp.conc,formula = conc ~ time | treatment + ID), level = 1:2), tmp.conc[, c(“treatment”, “ID”), drop = FALSE], info = “getGroups.PKNCAconc the correct level (numeric vector)”)), call = list(expect_equal(getGroups.PKNCAconc(PKNCAconc(tmp.conc, formula = conc ~ time | treatment + ID), level = 1:2), tmp.conc[, c(“treatment”, “ID”), drop = FALSE], info = “getGroups.PKNCAconc the correct level (numeric vector)”)),
start_frame = 74, end_frame = 74, test = "model frame and parameterextractions"), list(message = "getGroups.PKNCAconc(…) not equal to tmp.conc[, c("ID", "treatment"), drop = FALSE].“, srcref = c(99, 3, 101, 77, 3, 77, 99, 101), expectation_calls = list(expect_equal(getGroups.PKNCAconc(PKNCAconc(tmp.conc, formula = conc ~ time | treatment + ID), level = 2:1), tmp.conc[, c("ID", "treatment"), drop = FALSE], info =”getGroups.PKNCAconc the correct level (numeric vector)")), call = list(
expect_equal(getGroups.PKNCAconc(PKNCAconc(tmp.conc, formula = conc~ time | treatment + ID), level = 2:1), tmp.conc[,c(“ID”, “treatment”), drop = FALSE], info = “getGroups.PKNCAconc the correct level (numeric vector)”)), start_frame = 74, end_frame = 74, test = “model frame and parameter extractions”), list(message = “getGroups.PKNCAconc(…) not equal to tmp.conc[, "ID", drop = FALSE].”, srcref = c(102, 3, 104, 86, 3, 86, 102, 104), expectation_calls = list(expect_equal(getGroups.PKNCAconc(PKNCAconc(tmp.conc,
formula = conc ~ time| treatment + ID), level = “ID”), tmp.conc[,“ID”, drop = FALSE], info = "getGroups.PKNCAconc thecorrect level (character string scalar)“)), call = list(expect_equal(getGroups.PKNCAconc(PKNCAconc(tmp.conc, formula = conc ~ time | treatment + ID), level =”ID“), tmp.conc[, "ID", drop = FALSE], info =”getGroups.PKNCAconc the correct level (character string scalar)“)), start_frame = 74, end_frame = 74, test =”model frame and parameter extractions“), list(message =”getGroups.PKNCAconc(…) not equal to tmp.conc[, c("ID", "treatment"), drop = FALSE].",
srcref = c(105, 3, 107, 86, 3, 86, 105, 107), expectation_calls = list(expect_equal(getGroups.PKNCAconc(PKNCAconc(tmp.conc, formula = conc ~ time | treatment + ID), level = c(“ID”, “treatment”)), tmp.conc[, c(“ID”, “treatment”), drop = FALSE], info = “getGroups.PKNCAconc the correct level (character string vector)”)), call = list(expect_equal(getGroups.PKNCAconc(PKNCAconc(tmp.conc, formula = conc ~ time | treatment + ID), level = c(“ID”, “treatment”)), tmp.conc[, c(“ID”, “treatment”), drop = FALSE],
info = "getGroups.PKNCAconc the correct level (character stringvector)")), start_frame = 74, end_frame =74, test= “model frame and parameter extractions”), list(message = "“, srcref = c(108, 3, 110, 88, 3, 88, 108, 110), expectation_calls = list(expect_error(getGroups.PKNCAconc(PKNCAconc(tmp.conc, formula = conc ~ time | treatment + ID), level =”foo“), regexp =”Not all levels are listed in the group names“, info =”getGroups.PKNCAconc gives an error if a group name is not present")),
call = list(expect_error(getGroups.PKNCAconc(PKNCAconc(tmp.conc, formula = conc ~ time | treatment + ID), level = “foo”), regexp = “Not all levels are listed in the group names”, info = “getGroups.PKNCAconc gives an error if a group name is not present”)), start_frame = 74, end_frame = 74, test = “model frame and parameter extractions”))
test-class-PKNCAconc.Rsplit.PKNCAconc505list(list(message = “base::split(myconc) not equal to split.PKNCAconc(myconc).”, srcref = c(116, 3, 117, 54, 3, 54, 116, 117), expectation_calls = list(expect_equal(base::split(myconc), split.PKNCAconc(myconc), info = “The generic is correctly called”)), call = list(expect_equal(base::split(myconc), split.PKNCAconc(myconc), info = “The generic is correctly called”)), start_frame = 74, end_frame = 74, test = “split.PKNCAconc”), list(message = “all(…) isn’t true.”, srcref = c(119, 3, 123, 69,
3, 69, 119, 123), expectation_calls = list(expect_true(all(sapply(tmpsplit, function(x) {
all(names(x) == names(myconc))
})), info = "All parameter names are accurately transferred")), call =list(expect_true(all(sapply(tmpsplit, function(x) {
all(names(x) == names(myconc))
})), info = "All parameter names are accurately transferred")), start_frame = 74, end_frame = 74, test = "split.PKNCAconc"), list(message = “all(…) isn’t true.”, srcref = c(124, 3, 132, 78, 3, 78, 124, 132), expectation_calls = list(expect_true(all(sapply(tmpsplit, function(x) {
x_nodata <- x
x_nodata$data <- NULL
mc_nodata <- myconc
mc_nodata$data <- NULL
identical(x_nodata, mc_nodata)
})), info = "All values (other than data) are accurately transferred.")), call = list(expect_true(all(sapply(tmpsplit, function(x) {
x_nodata <- x
x_nodata$data <- NULL
mc_nodata <- myconc
mc_nodata$data <- NULL
identical(x_nodata, mc_nodata)
})), info = "All values (other than data) are accurately transferred.")), start_frame = 74, end_frame = 74, test ="split.PKNCAconc“), list(message =”split.PKNCAconc(NA) not equal to {…}.", srcref = c(133, 3, 139, 66, 3, 66, 133, 139), expectation_calls = list(expect_equal(split.PKNCAconc(NA), {
tmp <- list(NA)
attr(tmp, “groupid”)<- data.frame(NA)[, c()]
tmp
}, info = "NA split returns an effectively null split.")), call = list(expect_equal(split.PKNCAconc(NA), {
tmp <- list(NA)
attr(tmp, “groupid”)<- data.frame(NA)[, c()]
tmp
}, info = "NA split returns an effectively null split.")), start_frame= 74, end_frame =74, test = "split.PKNCAconc"), list(message = “length(tmp_myconc_na_split) not equal to 4.”, srcref = c(155, 3, 157, 63, 3, 63, 155, 157), expectation_calls = list(expect_equal(length(tmp_myconc_na_split), 4, info = “NA values in groups are kept not dropped”)), call = list(expect_equal(length(tmp_myconc_na_split), 4, info = “NA values in groups are kept not dropped”)), start_frame = 74, end_frame = 74,
test = "split.PKNCAconc"))
test-class-PKNCAconc.Rprint.PKNCAconc303list(list(message = “print\\.PKNCAconc\\(myconc\\) does not match "Formula for concentration:\n conc ~ time | treatment + ID\n With 2 subjects defined in the ‘ID’ column.\n Nominal time column is not specified.\n \n First 6 rows of concentration data:\\n treatment ID time conc\n Trt 1 1 0 0.0000000\n Trt 1 1 1 0.7052248\n Trt 1 1 2 0.7144320\n Trt 1 1 3 0.8596094\n Trt 1 1 4 0.9998126\n Trt 1 1 5 0.7651474".value: "Formula for concentration:\\n conc ~ time \| treatment \+ ID\\n<environment: 0x000000002e6ca950>\\nWith 2 subjects defined in the ‘ID’ column\.\\nNominal time column is not specified\.\\n\\nFirst 6 rows of concentration data:\\\\n treatment ID time conc exclude volume duration\\n Trt 1 1 0 0\.0000000  NA 0\\n Trt 1 1 1 0\.7052248  NA 0\\n Trt 1 1 2 0\.7144320  NA 0\\n Trt 1 1 3 0\.8596094  NA 0\\n Trt 1 1 4 0\.9998126  NA 0\\n Trt 1 1 5 0\.7651474  NA 0"”,
srcref = c(164, 3, 178, 53, 3, 53, 164, 178), expectation_calls = list(expect_output(print.PKNCAconc(myconc),regexp =“Formula for concentration:conc ~ time | treatment + IDWith 2 subjects defined in the ‘ID’ column.Nominal time column is not specified.First 6 rows of concentration data:\n treatment ID time concTrt 1 1 0 0.0000000Trt 1 1 1 0.7052248Trt 1 1 2 0.7144320Trt 1 1 3 0.8596094Trt 1 1 4 0.9998126Trt 1 1 5 0.7651474”,
info = "Generic print.PKNCAconc works"), expect_match(act$cap,enc2native(regexp), …, info = info, label= act$lab)), call = list(expect_output(print.PKNCAconc(myconc), regexp = “Formula for concentration:conc ~ time | treatment + IDWith 2 subjects defined in the ‘ID’ column.Nominal time column is not specified.First 6 rows of concentration data:\n treatment ID time concTrt 1 1 0 0.0000000Trt 1 1 1 0.7052248Trt 1 1 2 0.7144320Trt 1 1 3 0.8596094Trt 1 1 4 0.9998126Trt 1 1 5 0.7651474”,
info = "Generic print.PKNCAconc works"), expect_match(act$cap,enc2native(regexp), …, info = info, label= act$lab)), start_frame = 74, end_frame = 75, test = “print.PKNCAconc”), list(message = “print\\.PKNCAconc\\(myconc, n = 0\\) does not match "Formula for concentration:\n conc ~ time | treatment + ID\nWith 2 subjects defined in the ‘ID’ column.\nNominal time column is not specified.".value: "Formula for concentration:\\n conc ~ time \| treatment \+ ID\\n<environment: 0x000000002e6ca950>\\nWith 2 subjects defined in the ‘ID’ column\.\\nNominal time column is not specified\."”,
srcref = c(179, 3, 184, 64, 3, 64, 179, 184), expectation_calls = list(expect_output(print.PKNCAconc(myconc, n= 0), regexp = “Formula for concentration:conc ~ time | treatment + ID2 subjects defined in the ‘ID’ column.time column is not specified.”, info = “print.PKNCAconc respects the n argument.”), expect_match(act\(cap, enc2native(regexp), ..., info = info, label = act\)lab)), call = list(expect_output(print.PKNCAconc(myconc, n = 0), regexp = “Formula for concentration:conc ~ time | treatment + ID2 subjects defined in the ‘ID’ column.time column is not specified.”,
info = "print.PKNCAconc respects the n argument."), expect_match(act$cap, enc2native(regexp), …, info =info, label = act$lab)), start_frame = 74, end_frame = 75, test = “print.PKNCAconc”), list(message = “print\\.PKNCAconc\\(myconc, n = -98\\) does not match "Formula for concentration:\n conc ~ time | treatment + ID\n With 2 subjects defined in the ‘ID’ column.\n Nominal time column is not specified.\n \n First 2 rows of concentration data:\\n treatment ID time conc\n Trt 1 1 0 0.0000000\n Trt 1 1 1 0.7052248".value: "Formula for concentration:\\n conc ~ time \| treatment \+ ID\\n<environment: 0x000000002e6ca950>\\nWith 2 subjects defined in the ‘ID’ column\.\\nNominal time column is not specified\.\\n\\nFirst 2 rows of concentration data:\\\\n treatment ID time conc exclude volume duration\\n Trt 1 1 0 0\.0000000  NA 0\\n Trt 1 1 1 0\.7052248  NA 0"”,
srcref = c(185, 3, 195, 76, 3, 76, 185, 195), expectation_calls = list(expect_output(print.PKNCAconc(myconc, n= -98),regexp = “Formula for concentration:conc ~ time | treatment + IDWith 2 subjects defined in the ‘ID’ column.Nominal time column is not specified.First 2 rows of concentration data:\n treatment ID time concTrt 1 1 0 0.0000000Trt 1 1 1 0.7052248”,
info = "print.PKNCAconc accurately uses negative n argument."),expect_match(act$cap, enc2native(regexp),…, info= info, label = act$lab)), call = list(expect_output(print.PKNCAconc(myconc, n = -98), regexp = “Formula for concentration:conc ~ time | treatment + IDWith 2 subjects defined in the ‘ID’ column.Nominal time column is not specified.First 2 rows of concentration data:\n treatment ID time concTrt 1 1 0 0.0000000Trt 1 1 1 0.7052248”,
info = "print.PKNCAconc accurately uses negative n argument."),expect_match(act$cap, enc2native(regexp),…, info= info, label = act$lab)), start_frame = 74, end_frame = 75, test = “print.PKNCAconc”))
test-class-PKNCAconc.Rsummary.PKNCAconc101list(list(message = “summary\\(myconc\\) does not match "Formula for concentration:\n conc ~ time | treatment + ID\n With 2 subjects defined in the ‘ID’ column.\n Nominal time column is not specified.\n \n Group summary:\n Group Name Count\n treatment 2\n ID 4".value: "Formula for concentration:\\n conc ~ time \| treatment \+ ID\\n<environment: 0x000000002d55c410>\\nWith 2 subjects defined in the ‘ID’ column\.\\nNominal time column is not specified\.\\n\\nGroup summary:\\n Group Name Count\\n treatment 2\\n ID 4"”,
srcref = c(202, 3, 212, 56, 3, 56, 202, 212), expectation_calls = list(expect_output(summary(myconc), regexp ="Formulafor concentration:conc ~ time | treatment + IDWith 2 subjects defined in the ‘ID’ column.Nominal time column is not specified.Group summary:Group Name Counttreatment 2ID 4“, info =”Generic summary.PKNCAconc works."), expect_match(act$cap,
enc2native(regexp), …, info = info, label = act$lab)), call =list(expect_output(summary(myconc), regexp= "Formula for concentration:conc ~ time | treatment + IDWith 2 subjects defined in the ‘ID’ column.Nominal time column is not specified.Group summary:Group Name Counttreatment 2ID 4“, info =”Generic summary.PKNCAconc works."), expect_match(act$cap,
enc2native(regexp), …, info = info, label = act$lab)), start_frame = 74, end_frame = 75, test = "summary.PKNCAconc"))
test-class-PKNCAconc.RPKNCAconc with exclusions101list(list(message = “myconc not equal to structure(…).”, srcref = c(219, 3, 229, 47, 3, 47, 219, 229), expectation_calls = list(expect_equal(myconc, structure(list(data = cbind(tmp.conc, volume = NA, duration = 0), formula = conc ~ time | treatment + ID, subject = “ID”, exclude = “excl”, columns = list(volume = “volume”, duration = “duration”)), class = c(“PKNCAconc”, “list”)))), call = list(expect_equal(myconc, structure(list(data = cbind(tmp.conc, volume = NA, duration = 0), formula = conc ~
time | treatment + ID, subject = “ID”, exclude = “excl”, columns =list(volume = "volume“, duration =”duration")), class = c(“PKNCAconc”, “list”)))), start_frame = 74, end_frame = 74, test = “PKNCAconc with exclusions”))
test-class-PKNCAconc.RPKNCAconc with duration101list(list(message = “myconc not equal to structure(…).”, srcref = c(238, 3, 249, 47, 3, 47, 238, 249), expectation_calls = list(expect_equal(myconc, structure(list(data = cbind(tmp.conc, data.frame(exclude = NA, volume = NA, stringsAsFactors = FALSE)), formula = conc ~ time | treatment + ID, subject = “ID”, exclude = “exclude”, columns = list(volume = “volume”, duration = “duration_test”)), class = c(“PKNCAconc”, “list”)))), call = list(expect_equal(myconc, structure(list(data = cbind(tmp.conc,
data.frame(exclude =NA, volume = NA, stringsAsFactors = FALSE)), formula = conc ~ time | treatment + ID, subject = "ID“, exclude =”exclude“, columns = list(volume =”volume“, duration =”duration_test“)), class = c(”PKNCAconc“,”list“)))), start_frame = 74, end_frame = 74, test =”PKNCAconc with duration"))
test-class-PKNCAconc.RPKNCAconc with nominal time added202list(list(message = “myconc not equal to structure(…).”, srcref = c(256, 3, 269, 47, 3, 47, 256, 269), expectation_calls = list(expect_equal(myconc, structure(list(data = cbind(tmp.conc, data.frame(exclude = NA, volume = NA, duration = 0, stringsAsFactors = FALSE)), formula = conc ~ time | treatment + ID, subject = “ID”, exclude = “exclude”, columns = list(volume = “volume”, duration = “duration”, time.nominal = “tnom”)), class = c(“PKNCAconc”, “list”)))), call = list(expect_equal(myconc,
structure(list(data =cbind(tmp.conc, data.frame(exclude = NA, volume = NA, duration= 0, stringsAsFactors = FALSE)), formula = conc ~ time | treatment + ID, subject = “ID”, exclude = “exclude”, columns = list(volume = “volume”, duration = “duration”, time.nominal = “tnom”)), class = c(“PKNCAconc”, “list”)))), start_frame = 74, end_frame = 74, test = “PKNCAconc with nominal time added”), list(message = “PKNCAconc(tmp.conc, formula = conc ~ time | treatment + ID, time.nominal = "foo") not equal to structure(…).”,
srcref = c(270, 3, 284, 47, 3, 47, 270, 284), expectation_calls = list(expect_equal(PKNCAconc(tmp.conc, formula = conc~ time | treatment + ID, time.nominal = “foo”), structure(list(data = cbind(tmp.conc, data.frame(exclude = NA, volume = NA, duration = 0, foo = NA, stringsAsFactors = FALSE)), formula = conc ~ time | treatment + ID, subject = “ID”, exclude = “exclude”, columns = list(volume = “volume”, duration = “duration”, time.nominal = “foo”)), class = c(“PKNCAconc”, “list”)))), call = list(
expect_equal(PKNCAconc(tmp.conc, formula = conc ~ time | treatment + ID, time.nominal = “foo”), structure(list(data= cbind(tmp.conc, data.frame(exclude = NA, volume = NA, duration = 0, foo = NA, stringsAsFactors = FALSE)), formula = conc ~ time | treatment + ID, subject = “ID”, exclude = “exclude”, columns = list(volume = “volume”, duration = “duration”, time.nominal = “foo”)), class = c(“PKNCAconc”, “list”)))), start_frame = 74, end_frame = 74, test = “PKNCAconc with nominal time added”))
test-class-PKNCAconc.RPKNCAconc with volume added303list(list(message = “myconc not equal to structure(…).”, srcref = c(291, 3, 302, 47, 3, 47, 291, 302), expectation_calls = list(expect_equal(myconc, structure(list(data = cbind(tmp.conc, data.frame(exclude = NA, duration = 0, stringsAsFactors = FALSE)), formula = conc ~ time | treatment + ID, subject = “ID”, exclude = “exclude”, columns = list(volume = “vol”, duration = “duration”)), class = c(“PKNCAconc”, “list”)))), call = list(expect_equal(myconc, structure(list(data = cbind(tmp.conc,
data.frame(exclude =NA, duration = 0, stringsAsFactors = FALSE)),formula = conc ~ time | treatment + ID, subject = "ID“, exclude =”exclude“, columns = list(volume =”vol“, duration =”duration“)), class = c(”PKNCAconc“,”list“)))), start_frame = 74, end_frame = 74, test =”PKNCAconc with volume added“), list(message =”myconc_manual_vol not equal to structure(…).", srcref = c(304, 3, 316, 47, 3, 47, 304, 316), expectation_calls = list(expect_equal(myconc_manual_vol, structure(list(data = cbind(tmp.conc,
data.frame(exclude =NA, volume = 2, duration = 0, stringsAsFactors= FALSE)), formula = conc ~ time | treatment + ID,subject = “ID”, exclude = “exclude”, columns = list(volume = “volume”, duration = “duration”)), class = c(“PKNCAconc”, “list”)))), call = list(expect_equal(myconc_manual_vol, structure(list(data = cbind(tmp.conc, data.frame(exclude = NA, volume = 2, duration = 0, stringsAsFactors = FALSE)), formula = conc ~ time | treatment + ID, subject = “ID”, exclude = “exclude”, columns = list(volume = “volume”,
duration = “duration”)), class = c(“PKNCAconc”, “list”)))), start_frame = 74, end_frame = 74, test = "PKNCAconc with volume added“), list(message =”myconc_manual_vol_vector not equal to structure(…).“, srcref = c(318, 3, 330, 47, 3, 47, 318, 330), expectation_calls = list(expect_equal(myconc_manual_vol_vector, structure(list(data = cbind(tmp.conc, data.frame(exclude = NA, volume = 1:nrow(tmp.conc), duration = 0, stringsAsFactors = FALSE)), formula = conc ~ time | treatment + ID, subject =”ID",
exclude = “exclude”,columns = list(volume = “volume”, duration = "duration")), class= c(“PKNCAconc”, “list”)))), call= list(expect_equal(myconc_manual_vol_vector, structure(list(data = cbind(tmp.conc, data.frame(exclude = NA, volume = 1:nrow(tmp.conc), duration = 0, stringsAsFactors = FALSE)), formula = conc ~ time | treatment + ID, subject = “ID”, exclude = “exclude”, columns = list(volume = “volume”, duration = “duration”)), class = c(“PKNCAconc”, “list”)))), start_frame = 74, end_frame = 74,
test = "PKNCAconc with volume added"))

+

+

+
Class generation-PKNCAdata

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Testing FilenameTest DescriptionNumber of TestsNumber of Failed Testspassedresult
test-class-PKNCAdata.RPKNCAdata10010list(list(message = “PKNCAdata(obj.conc, obj.dose) not equal to PKNCAdata(obj.dose, obj.conc).”, srcref = c(35, 3, 37, 53, 3, 53, 35, 37), expectation_calls = list(expect_equal(PKNCAdata(obj.conc, obj.dose), PKNCAdata(obj.dose, obj.conc), info = “Input arguments are reversible”)), call = list(expect_equal(PKNCAdata(obj.conc, obj.dose), PKNCAdata(obj.dose, obj.conc), info = “Input arguments are reversible”)), start_frame = 74, end_frame = 74, test = “PKNCAdata”), list(message = “PKNCAdata(obj.conc.analyte, obj.dose) not equal to PKNCAdata(obj.dose, obj.conc.analyte).”,
srcref = c(38, 3, 40,60, 3, 60, 38, 40), expectation_calls = list(expect_equal(PKNCAdata(obj.conc.analyte, obj.dose), PKNCAdata(obj.dose, obj.conc.analyte),info = “Combination of dose and analyte works”)), call = list(expect_equal(PKNCAdata(obj.conc.analyte, obj.dose), PKNCAdata(obj.dose, obj.conc.analyte), info = “Combination of dose and analyte works”)), start_frame = 74, end_frame = 74, test = “PKNCAdata”), list(message = “PKNCAdata(…) not equal to PKNCAdata(obj.conc, obj.dose).”,
srcref = c(41, 3, 44,76, 3, 76, 41, 44), expectation_calls = list(expect_equal(PKNCAdata(data.conc = tmp.conc, formula.conc= conc ~ time | treatment + ID, data.dose = tmp.dose, formula.dose = dose ~ time | treatment + ID), PKNCAdata(obj.conc, obj.dose), info = “Concentration and dose data can be created on the fly”)), call = list(expect_equal(PKNCAdata(data.conc = tmp.conc, formula.conc = conc ~ time | treatment + ID, data.dose = tmp.dose, formula.dose = dose ~ time | treatment + ID), PKNCAdata(obj.conc,
obj.dose), info =“Concentration and dose data can be created on the fly”)), start_frame = 74, end_frame = 74, test = "PKNCAdata"), list(message= "", srcref = c(47, 3, 49, 35, 3, 35, 47, 49), expectation_calls = list(expect_error(PKNCAdata(obj.conc, obj.dose, options = “a”), regexp = “options must be a list.”, info = “Option class”)), call = list(expect_error(PKNCAdata(obj.conc, obj.dose, options = “a”), regexp = “options must be a list.”, info = “Option class”)), start_frame = 74, end_frame = 74,
test = “PKNCAdata”),list(message = "", srcref = c(50, 3, 52, 39, 3, 39, 50, 52), expectation_calls = list(expect_error(PKNCAdata(obj.conc, obj.dose,options= list(1)), regexp = “options must have names.”, info = “Option structure”)), call = list(expect_error(PKNCAdata(obj.conc, obj.dose, options = list(1)), regexp = “options must have names.”, info = “Option structure”)), start_frame = 74, end_frame = 74, test = “PKNCAdata”), list(message = "", srcref = c(53, 3, 55, 35, 3, 35, 53, 55), expectation_calls = list(
expect_error(PKNCAdata(obj.conc, obj.dose, options = list(foo = 1)), regexp = "Invalid setting for PKNCA.*foo“, info =”Option names")), call = list(expect_error(PKNCAdata(obj.conc, obj.dose, options = list(foo = 1)), regexp = "Invalid setting for PKNCA.*foo“, info =”Option names“)), start_frame = 74, end_frame = 74, test =”PKNCAdata“), list(message =”PKNCAdata(obj.conc, obj.dose) not equal to {…}.", srcref = c(58, 3, 71, 52, 3, 52, 58, 71), expectation_calls = list(expect_equal(PKNCAdata(obj.conc,
obj.dose), {
tmp.intervals <- merge(PKNCA.options(“single.dose.aucs”), tmp.dose)
tmp.intervals <- tmp.intervals[order(tmp.intervals\(treatment, tmp.intervals\)ID), ]
tmp.intervals$time <-NULL
tmp.intervals$dose <-NULL
tmp <- list(conc = obj.conc, dose = obj.dose, options = list(), intervals = tmp.intervals)
class(tmp) <- c("PKNCAdata“,”list")
tmp
}, check.attributes = FALSE, info = “Selection of single dose AUCs”)), call = list(expect_equal(PKNCAdata(obj.conc, obj.dose), {
tmp.intervals <- merge(PKNCA.options(“single.dose.aucs”), tmp.dose)
tmp.intervals <- tmp.intervals[order(tmp.intervals\(treatment, tmp.intervals\)ID), ]
tmp.intervals$time <-NULL
tmp.intervals$dose <-NULL
tmp <- list(conc = obj.conc, dose = obj.dose, options = list(), intervals = tmp.intervals)
class(tmp) <- c("PKNCAdata“,”list")
tmp
}, check.attributes = FALSE, info = “Selection of single dose AUCs”)), start_frame = 74, end_frame = 74, test= “PKNCAdata”), list(message = "", srcref =c(79, 3,81, 83, 3, 83, 79, 81), expectation_calls = list(expect_warning(PKNCAdata(obj.conc, obj.dose), regexp = “No intervals generated due to no concentration data for treatment=Trt 1, ID=1”, info = “Missing concentration data with dose data gives a warning.”)), call = list(expect_warning(PKNCAdata(obj.conc, obj.dose), regexp = “No intervals generated due to no concentration data for treatment=Trt 1, ID=1”,
info = "Missing concentration data with dose data gives a warning.")), start_frame = 74, end_frame = 74, test = “PKNCAdata”), list(message = "", srcref = c(83, 3, 84, 92, 3, 92, 83, 84), expectation_calls = list(expect_warning(PKNCAdata(obj.conc, obj.dose, formula.conc = a ~ b), regexp = “data.conc was given as a PKNCAconc object. Ignoring formula.conc”)), call = list(expect_warning(PKNCAdata(obj.conc, obj.dose, formula.conc = a ~ b), regexp = “data.conc was given as a PKNCAconc object. Ignoring formula.conc”)),
start_frame = 74, end_frame = 74, test = “PKNCAdata”), list(message = "", srcref = c(85, 3, 86, 92, 3, 92,85, 86), expectation_calls = list(expect_warning(PKNCAdata(obj.conc, obj.dose, formula.dose = a ~ b), regexp = “data.dose was given as a PKNCAdose object. Ignoring formula.dose”)), call = list(expect_warning(PKNCAdata(obj.conc, obj.dose, formula.dose = a ~ b), regexp = “data.dose was given as a PKNCAdose object. Ignoring formula.dose”)), start_frame = 74, end_frame = 74, test = “PKNCAdata”))
test-class-PKNCAdata.RPKNCAdata with no or limited dose information404list(list(message = "“, srcref = c(94, 3, 96, 70, 3, 70, 94, 96), expectation_calls = list(expect_error(PKNCAdata(obj.conc), regexp =”If data.dose is not given, intervals must be given“, info =”One of dose and intervals is required (no dose)“)), call = list(expect_error(PKNCAdata(obj.conc), regexp =”If data.dose is not given, intervals must be given“, info =”One of dose and intervals is required (no dose)“)), start_frame = 74, end_frame = 74, test =”PKNCAdata with no or limited dose information"),
list(message = "", srcref = c(97, 3, 99, 70, 3, 70, 97, 99), expectation_calls = list(expect_error(PKNCAdata(obj.conc, data.dose = NA), regexp = "Ifdata.doseis not given, intervals must be given“, info =”One of dose and intervals is required (NA dose)“)), call = list(expect_error(PKNCAdata(obj.conc, data.dose = NA), regexp =”If data.dose is not given, intervals must be given“, info =”One of dose and intervals is required (NA dose)“)), start_frame = 74, end_frame = 74, test =”PKNCAdata with no or limited dose information"),
list(message = "PKNCAdata(…) not equal to {…}.", srcref = c(100, 3, 109, 17, 3, 17, 100,109), expectation_calls = list(expect_equal(PKNCAdata(obj.conc, intervals = data.frame(start = 0, end = 24, aucinf.obs = TRUE)), {
tmp <- list(conc= obj.conc, dose = NA, options = list(), intervals = check.interval.specification(data.frame(start = 0,end = 24, aucinf.obs = TRUE)))
class(tmp) <- c("PKNCAdata“,”list")
tmp
})), call = list(expect_equal(PKNCAdata(obj.conc, intervals = data.frame(start = 0, end = 24, aucinf.obs =TRUE)), {
tmp <- list(conc= obj.conc, dose = NA, options = list(), intervals = check.interval.specification(data.frame(start = 0,end = 24, aucinf.obs = TRUE)))
class(tmp) <- c("PKNCAdata“,”list")
tmp
})), start_frame = 74, end_frame = 74, test = “PKNCAdata with no or limited dose information”), list(message = "", srcref =c(116, 3, 118, 56, 3, 56,116, 118), expectation_calls = list(expect_error(PKNCAdata(obj.conc, obj.dose), regexp = “Dose times were not given, so intervals must be manually specified.”, info = “No dose times requires intervals.”)), call = list(expect_error(PKNCAdata(obj.conc, obj.dose), regexp = “Dose times were not given, so intervals must be manually specified.”, info = “No dose times requires intervals.”)),
start_frame = 74,end_frame = 74, test = “PKNCAdata with no or limited dose information”))
test-class-PKNCAdata.Rprint.PKNCAdata303list(list(message = “print\\.PKNCAdata\\(obj\\.data\\.nodose\\) does not match "Formula for concentration:\n conc ~ time | treatment + ID\nWith 2 subjects defined in the ‘ID’ column.\nNominal time column is not specified.\n \nFirst 6 rows of concentration data:\\n treatment ID time conc exclude\n Trt 1 1 0 0.0000000 \n Trt 1 1 1 0.7052248 \n Trt 1 1 2 0.7144320 \n Trt 1 1 3 0.8596094 \n Trt 1 1 4 0.9998126 \n Trt 1 1 5 0.7651474 \nNo dosing information.\n\nWith 1 rows of AUC specifications.\nNo options are set differently than default.".value: "Formula for concentration:\\n conc ~ time \| treatment \+ ID\\n<environment: 0x000000002f3a49e0>\\nWith 2 subjects defined in the ‘ID’ column\.\\nNominal time column is not specified\.\\n\\nFirst 6 rows of concentration data:\\\\n treatment ID time conc exclude volume duration\\n Trt 1 1 0 0\.0000000  NA 0\\n Trt 1 1 1 0\.7052248  NA 0\\n Trt 1 1 2 0\.7144320  NA 0\\n Trt 1 1 3 0\.8596094  NA 0\\n Trt 1 1 4 0\.9998126  NA 0\\n Trt 1 1 5 0\.7651474  NA 0\\nNo dosing information\.\\n\\nWith 1 rows of AUC specifications\.\\nNo options are set differently than default\."”,
srcref = c(134, 3, 152, 68, 3, 68, 134, 152), expectation_calls = list(expect_output(print.PKNCAdata(obj.data.nodose), regexp = "Formula for concentration:conc ~ time | treatment + ID2 subjects defined in the ‘ID’ column.time column is not specified.6 rows of concentration data:\n treatment ID time conc excludeTrt 1 1 0 0.0000000 Trt 1 1 1 0.7052248 Trt 1 1 2 0.7144320 Trt 1 1 3 0.8596094 Trt 1 1 4 0.9998126 Trt 1 1 5 0.7651474 dosing information.1 rows of AUC specifications.options are set differently than default.",
info = "Generic print.PKNCAdata works with no dosing"), expect_match(act$cap, enc2native(regexp), …,info = info, label = act$lab)), call = list(expect_output(print.PKNCAdata(obj.data.nodose), regexp = “Formula for concentration:conc ~ time | treatment + ID2 subjects defined in the ‘ID’ column.time column is not specified.6 rows of concentration data:\n treatment ID time conc excludeTrt 1 1 0 0.0000000 Trt 1 1 1 0.7052248 Trt 1 1 2 0.7144320 Trt 1 1 3 0.8596094 Trt 1 1 4 0.9998126 Trt 1 1 5 0.7651474 dosing information.1 rows of AUC specifications.options are set differently than default.”,
info = "Generic print.PKNCAdata works with no dosing"), expect_match(act$cap, enc2native(regexp), …,info = info, label = act$lab)), start_frame = 74, end_frame = 75, test = “print.PKNCAdata”), list(message = “print\\.PKNCAdata\\(obj\\.data\\.dose\\) does not match "Formula for concentration:\n conc ~ time | treatment + ID\nWith 2 subjects defined in the ‘ID’ column.\nNominal time column is not specified.\n \nFirst 6 rows of concentration data:\\n treatment ID time conc exclude\n Trt 1 1 0 0.0000000 \n Trt 1 1 1 0.7052248 \n Trt 1 1 2 0.7144320 \n Trt 1 1 3 0.8596094 \n Trt 1 1 4 0.9998126 \n Trt 1 1 5 0.7651474 \nFormula for dosing:\n dose ~ time | treatment + ID\nNominal time column is not specified.\n \nData for dosing:\n treatment ID dose time exclude route duration\n Trt 1 1 1 0  extravascular 0\n Trt 1 2 1 0  extravascular 0\n Trt 2 1 2 0  extravascular 0\n Trt 2 2 2 0  extravascular 0\nWith 1 rows of AUC specifications.\nNo options are set differently than default.".value: "Formula for concentration:\\n conc ~ time \| treatment \+ ID\\n<environment: 0x000000002f3a49e0>\\nWith 2 subjects defined in the ‘ID’ column\.\\nNominal time column is not specified\.\\n\\nFirst 6 rows of concentration data:\\\\n treatment ID time conc exclude volume duration\\n Trt 1 1 0 0\.0000000  NA 0\\n Trt 1 1 1 0\.7052248  NA 0\\n Trt 1 1 2 0\.7144320  NA 0\\n Trt 1 1 3 0\.8596094  NA 0\\n Trt 1 1 4 0\.9998126  NA 0\\n Trt 1 1 5 0\.7651474  NA 0\\nFormula for dosing:\\n dose ~ time \| treatment \+ ID\\nNominal time column is not specified\.\\n\\nData for dosing:\\n treatment ID dose time exclude route duration\\n Trt 1 1 1 0  extravascular 0\\n Trt 1 2 1 0  extravascular 0\\n Trt 2 1 2 0  extravascular 0\\n Trt 2 2 2 0  extravascular 0\\n\\nWith 8 rows of AUC specifications\.\\nNo options are set differently than default\."”,
srcref = c(153, 3, 179, 65, 3, 65, 153, 179), expectation_calls = list(expect_output(print.PKNCAdata(obj.data.dose), regexp= "Formula for concentration:conc ~ time | treatment + ID2 subjects defined in the ‘ID’ column.time column is not specified.6 rows of concentration data:\n treatment ID time conc excludeTrt 1 1 0 0.0000000 Trt 1 1 1 0.7052248 Trt 1 1 2 0.7144320 Trt 1 1 3 0.8596094 Trt 1 1 4 0.9998126 Trt 1 1 5 0.7651474 for dosing:dose ~ time | treatment + IDtime column is not specified.for dosing:treatment ID dose time exclude route durationTrt 1 1 1 0  extravascular 0Trt 1 2 1 0  extravascular 0Trt 2 1 2 0  extravascular 0Trt 2 2 2 0  extravascular 01 rows of AUC specifications.options are set differently than default.",
info = "Generic print.PKNCAdata works with dosing"), expect_match(act$cap, enc2native(regexp), …, info = info, label =act$lab)), call = list(expect_output(print.PKNCAdata(obj.data.dose), regexp = “Formula for concentration:conc ~ time | treatment + ID2 subjects defined in the ‘ID’ column.time column is not specified.6 rows of concentration data:\n treatment ID time conc excludeTrt 1 1 0 0.0000000 Trt 1 1 1 0.7052248 Trt 1 1 2 0.7144320 Trt 1 1 3 0.8596094 Trt 1 1 4 0.9998126 Trt 1 1 5 0.7651474 for dosing:dose ~ time | treatment + IDtime column is not specified.for dosing:treatment ID dose time exclude route durationTrt 1 1 1 0  extravascular 0Trt 1 2 1 0  extravascular 0Trt 2 1 2 0  extravascular 0Trt 2 2 2 0  extravascular 01 rows of AUC specifications.options are set differently than default.”,
info = "Generic print.PKNCAdata works with dosing"), expect_match(act$cap, enc2native(regexp), …, info = info, label =act$lab)), start_frame =74, end_frame = 75, test = “print.PKNCAdata”), list(message = “print\\.PKNCAdata\\(obj\\.data\\.nodose\\.opt\\) does not match "Formula for concentration:\n conc ~ time | treatment + ID\nWith 2 subjects defined in the ‘ID’ column.\nNominal time column is not specified.\n \nFirst 6 rows of concentration data:\\n treatment ID time conc exclude\n Trt 1 1 0 0.0000000 \n Trt 1 1 1 0.7052248 \n Trt 1 1 2 0.7144320 \n Trt 1 1 3 0.8596094 \n Trt 1 1 4 0.9998126 \n Trt 1 1 5 0.7651474 \nNo dosing information.\n\nWith 1 rows of AUC specifications.\nOptions changed from default are:\n\(min.hl.r.squared\\n[1] 0.95\".\nActual value: \"Formula for concentration:\\\\n conc ~ time \\| treatment \\+ ID\\\\n<environment: 0x000000002f3a49e0>\\\\nWith 2 subjects defined in the 'ID' column\\.\\\\nNominal time column is not specified\\.\\\\n\\\\nFirst 6 rows of concentration data:\\\\n treatment ID time conc exclude volume duration\\\\n Trt 1 1 0 0\\.0000000 <NA> NA 0\\\\n Trt 1 1 1 0\\.7052248 <NA> NA 0\\\\n Trt 1 1 2 0\\.7144320 <NA> NA 0\\\\n Trt 1 1 3 0\\.8596094 <NA> NA 0\\\\n Trt 1 1 4 0\\.9998126 <NA> NA 0\\\\n Trt 1 1 5 0\\.7651474 <NA> NA 0\\\\nNo dosing information\\.\\\\n\\\\nWith 1 rows of AUC specifications\\.\\\\nOptions changed from default are:\\\\n\\\)min\.hl\.r\.squared\\n\[1\] 0\.95\\n"”,
srcref = c(181, 3, 201, 93, 3, 93, 181, 201), expectation_calls = list(expect_output(print.PKNCAdata(obj.data.nodose.opt), regexp = "Formula for concentration:conc ~ time | treatment + ID2 subjects defined in the ‘ID’ column.time column is not specified.6 rows of concentration data:\n treatment ID time conc excludeTrt 1 1 0 0.0000000 Trt 1 1 1 0.7052248 Trt 1 1 2 0.7144320 Trt 1 1 3 0.8596094 Trt 1 1 4 0.9998126 Trt 1 1 5 0.7651474 dosing information.1 rows of AUC specifications.changed from default are:$min.hl.r.squared0.95",
info = "Generic print.PKNCAdata works with no dosing and with options changed"), expect_match(act$cap,enc2native(regexp), …, info = info, label = act$lab)), call = list(expect_output(print.PKNCAdata(obj.data.nodose.opt), regexp = “Formula for concentration:conc ~ time | treatment + ID2 subjects defined in the ‘ID’ column.time column is not specified.6 rows of concentration data:\n treatment ID time conc excludeTrt 1 1 0 0.0000000 Trt 1 1 1 0.7052248 Trt 1 1 2 0.7144320 Trt 1 1 3 0.8596094 Trt 1 1 4 0.9998126 Trt 1 1 5 0.7651474 dosing information.1 rows of AUC specifications.changed from default are:$min.hl.r.squared0.95”,
info = "Generic print.PKNCAdata works with no dosing and with options changed"), expect_match(act$cap,enc2native(regexp), …, info = info, label = act$lab)), start_frame = 74, end_frame = 75, test = “print.PKNCAdata”))
test-class-PKNCAdata.Rsummary.PKNCAdata101list(list(message = “summary\\(obj\\.data\\.nodose\\) does not match "Formula for concentration:\n conc ~ time | treatment + ID\nWith 2 subjects defined in the ‘ID’ column.\nNominal time column is not specified.\n\nGroup summary:\n Group Name Count\n treatment 2\n ID 4\n\nFirst 6 rows of concentration data:\\n treatment ID time conc exclude\n Trt 1 1 0 0.0000000 \n Trt 1 1 1 0.7052248 \n Trt 1 1 2 0.7144320 \n Trt 1 1 3 0.8596094 \n Trt 1 1 4 0.9998126 \n Trt 1 1 5 0.7651474 \nNo dosing information.\n\nWith 1 rows of AUC specifications.\nNo options are set differently than default.".value: "Formula for concentration:\\n conc ~ time \| treatment \+ ID\\n<environment: 0x000000002f201560>\\nWith 2 subjects defined in the ‘ID’ column\.\\nNominal time column is not specified\.\\n\\nGroup summary:\\n Group Name Count\\n treatment 2\\n ID 4\\n\\nFirst 6 rows of concentration data:\\\\n treatment ID time conc exclude volume duration\\n Trt 1 1 0 0\.0000000  NA 0\\n Trt 1 1 1 0\.7052248  NA 0\\n Trt 1 1 2 0\.7144320  NA 0\\n Trt 1 1 3 0\.8596094  NA 0\\n Trt 1 1 4 0\.9998126  NA 0\\n Trt 1 1 5 0\.7651474  NA 0\\nNo dosing information\.\\n\\nWith 1 rows of AUC specifications\.\\nNo options are set differently than default\."”,
srcref = c(212, 3, 235, 56, 3, 56, 212, 235), expectation_calls = list(expect_output(summary(obj.data.nodose), regexp = "Formula for concentration:conc ~ time | treatment + ID2 subjects defined in the ‘ID’ column.time column is not specified.summary:Group Name Counttreatment 2ID 46 rows of concentration data:\n treatment ID time conc excludeTrt 1 1 0 0.0000000 Trt 1 1 1 0.7052248 Trt 1 1 2 0.7144320 Trt 1 1 3 0.8596094 Trt 1 1 4 0.9998126 Trt 1 1 5 0.7651474 dosing information.1 rows of AUC specifications.options are set differently than default.",
info = "Generic summary.PKNCAdata works."), expect_match(act$cap, enc2native(regexp), …, info = info, label = act$lab)), call = list(expect_output(summary(obj.data.nodose), regexp = “Formula for concentration:conc ~ time | treatment + ID2 subjects defined in the ‘ID’ column.time column is not specified.summary:Group Name Counttreatment 2ID 46 rows of concentration data:\n treatment ID time conc excludeTrt 1 1 0 0.0000000 Trt 1 1 1 0.7052248 Trt 1 1 2 0.7144320 Trt 1 1 3 0.8596094 Trt 1 1 4 0.9998126 Trt 1 1 5 0.7651474 dosing information.1 rows of AUC specifications.options are set differently than default.”,
info = "Generic summary.PKNCAdata works."), expect_match(act$cap, enc2native(regexp), …, info = info, label = act$lab)), start_frame = 74, end_frame = 75, test = “summary.PKNCAdata”))
test-class-PKNCAdata.Rsplitting PKNCAdata101list(list(message = “split(mydata) not equal to list(…).”, srcref = c(246, 3, 257, 36, 3, 36, 246, 257), expectation_calls = list(expect_equal(split(mydata), list(Trt 1\n1 = list(conc = splitconc[[1]], dose = NA, intervals = check.interval.specification(data.frame(start = 0, end = 24, aucinf.obs = TRUE)), options = list()), Trt 1\n2 = list(conc = splitconc[[2]], dose = NA, intervals = check.interval.specification(data.frame(start = 0, end = 24, aucinf.obs = TRUE)), options = list())))),
call = list(expect_equal(split(mydata), list(Trt 1\n1 = list(conc = splitconc[[1]], dose = NA, intervals= check.interval.specification(data.frame(start = 0, end = 24, aucinf.obs = TRUE)), options = list()), Trt 1\n2 = list(conc = splitconc[[2]], dose = NA, intervals = check.interval.specification(data.frame(start = 0, end = 24, aucinf.obs = TRUE)), options = list())))), start_frame = 74, end_frame = 74, test = “splitting PKNCAdata”))
test-class-PKNCAdata.Rno intervals auto-determined (Fix GitHub issue #84)303list(list(message = “two_single_dose_treatments\(intervals not equal to `interval_1`.\nTRUE", srcref = c(285, 3, 289, 3, 3, 3, 285, 289), expectation_calls = list(expect_equal(two_single_dose_treatments\)intervals, interval_1, check.attributes = FALSE)), call = list(expect_equal(two_single_dose_treatments$intervals, interval_1, check.attributes = FALSE)), start_frame = 74, end_frame = 74, test =”no intervals auto-determined (Fix GitHub issue #84)“), list(message =”", srcref = c(301, 3, 308, 3, 3,
3, 301, 308), expectation_calls = list(expect_warning(two_multiple_dose_treatments <- PKNCAdata(PKNCAconc(data= tmp_conc, Conc~ Time | Treatment + Subject), PKNCAdose(data = tmp_dose, Dose ~ Time | Subject)), regexp = “No intervals generated”)), call = list(expect_warning(two_multiple_dose_treatments <- PKNCAdata(PKNCAconc(data = tmp_conc, Conc ~ Time | Treatment + Subject), PKNCAdose(data = tmp_dose, Dose ~ Time | Subject)), regexp = “No intervals generated”)), start_frame = 74, end_frame = 74,
test = "no intervalsauto-determined (Fix GitHub issue #84)“), list(message =”two_multiple_dose_treatments$intervals not equal to interval_2.E", srcref = c(309, 3, 312, 3, 3, 3, 309, 312), expectation_calls = list(expect_equal(two_multiple_dose_treatments\(intervals, interval_2)), call = list(expect_equal(two_multiple_dose_treatments\)intervals, interval_2)), start_frame = 74, end_frame = 74, test = “no intervals auto-determined (Fix GitHub issue #84)”))
test-class-PKNCAdata.REnsure that unexpected arguments to PKNCAdata give an error (related to issue #83)101list(list(message = "“, srcref = c(322, 3, 323, 41, 3, 41, 322, 323), expectation_calls = list(expect_error(mydata <- PKNCAdata(obj.conc, obj.dose, 1), regexp =”Unknown argument“)), call = list(expect_error(mydata <- PKNCAdata(obj.conc, obj.dose, 1), regexp =”Unknown argument“)), start_frame = 74, end_frame = 74, test =”Ensure that unexpected arguments to PKNCAdata give an error (related to issue #83)"))
test-class-PKNCAdata.Rintervals may be a tibble101list(list(message = “as.data.frame(pk.nca(mydata_tibble)) not equal to as.data.frame(pk.nca(mydata)).”, srcref = c(336, 3, 339, 3, 3, 3, 336, 339), expectation_calls = list(expect_equal(as.data.frame(pk.nca(mydata_tibble)), as.data.frame(pk.nca(mydata)))), call = list(expect_equal(as.data.frame(pk.nca(mydata_tibble)), as.data.frame(pk.nca(mydata)))), start_frame = 74, end_frame = 74, test = “intervals may be a tibble”))

+

+

+
Class generation-PKNCAdose

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Testing FilenameTest DescriptionNumber of TestsNumber of Failed Testspassedresult
test-class-PKNCAdose.RPKNCAdose12012list(list(message = "“, srcref = c(21, 3, 23, 46, 3, 46, 21, 23), expectation_calls = list(expect_error(PKNCAdose(data.frame()), regexp =”data must have at least one row.“, info =”PKNCAconc requires data“)), call = list(expect_error(PKNCAdose(data.frame()), regexp =”data must have at least one row.“, info =”PKNCAconc requires data“)), start_frame = 74, end_frame = 74, test =”PKNCAdose“), list(message =”", srcref = c(26, 3, 28, 71, 3, 71, 26, 28), expectation_calls = list(expect_error(PKNCAdose(tmp.dose,
formula = dosea ~ time | treatment + ID), regexp = "The left side formula must bea variable in the data,empty, or‘.’.“, info =”All formula parameters must be in the data (LHS)“)), call = list(expect_error(PKNCAdose(tmp.dose, formula = dosea ~ time | treatment + ID), regexp =”The left side formula must be a variable in the data, empty, or ‘.’.“, info =”All formula parameters must be in the data (LHS)“)), start_frame = 74, end_frame = 74, test =”PKNCAdose“), list(message =”", srcref = c(29,
3, 31, 71, 3, 71, 29, 31), expectation_calls = list(expect_error(PKNCAdose(tmp.dose,formula = dose ~ timea |treatment+ ID), regexp = “The right side formula must be a variable in the data or ‘.’.”, info = “All formula parameters must be in the data (RHS)”)), call = list(expect_error(PKNCAdose(tmp.dose, formula = dose ~ timea | treatment + ID), regexp = “The right side formula must be a variable in the data or ‘.’.”, info = “All formula parameters must be in the data (RHS)”)), start_frame = 74,
end_frame = 74, test= “PKNCAdose”), list(message = "", srcref= c(32, 3, 34, 74,3, 74, 32, 34), expectation_calls= list(expect_error(PKNCAdose(tmp.dose, formula = dose ~ time | treatmenta + ID), regexp = “All of the variables in the groups must be in the data”, info = “All formula parameters must be in the data (groups)”)), call = list(expect_error(PKNCAdose(tmp.dose, formula = dose ~ time | treatmenta + ID), regexp = “All of the variables in the groups must be in the data”, info = “All formula parameters must be in the data (groups)”)),
start_frame = 74, end_frame = 74, test = “PKNCAdose”), list(message = "", srcref= c(37, 3, 39, 74, 3, 74,37, 39),expectation_calls = list(expect_error(PKNCAdose(tmp.dose, formula = dose + ID ~ time | treatment + ID), regexp = “The left side of the formula must have zero or one variable”, info = “The right number of parameters in the formula (LHS)”)), call = list(expect_error(PKNCAdose(tmp.dose, formula = dose + ID ~ time | treatment + ID), regexp = “The left side of the formula must have zero or one variable”,
info = "The right number of parameters in the formula (LHS)")),start_frame = 74,end_frame = 74, test = "PKNCAdose“), list(message =”“, srcref = c(40, 3, 42, 74, 3, 74, 40, 42), expectation_calls = list(expect_error(PKNCAdose(tmp.dose, formula = dose ~ time + ID | treatment + ID), regexp =”The right side of the formula \(excluding groups\) must have exactly one variable“, info =”The right number of parameters in the formula (RHS)")), call = list(expect_error(PKNCAdose(tmp.dose, formula = dose ~
time + ID | treatment+ ID), regexp = "The right side of the formula \(excludinggroups\) must have exactly one variable“, info =”The right number of parameters in the formula (RHS)“)), start_frame = 74, end_frame = 74, test =”PKNCAdose“), list(message =”“, srcref = c(43, 3, 45, 74, 3, 74, 43, 45), expectation_calls = list(expect_error(PKNCAdose(tmp.dose, formula = ~time + ID | treatment + ID), regexp =”The right side of the formula \(excluding groups\) must have exactly one variable",
info = "The right number of parameters in the formula (RHS)")),call = list(expect_error(PKNCAdose(tmp.dose, formula = ~time + ID | treatment + ID), regexp = “The right side of the formula \(excluding groups\) must have exactly one variable”, info = “The right number of parameters in the formula (RHS)”)), start_frame = 74, end_frame = 74, test = “PKNCAdose”), list(message = “PKNCAdose(tmp.dose, formula = . ~ time | treatment + ID) not equal to structure(…).”, srcref = c(48, 3, 60, 74,
3, 74, 48, 60), expectation_calls = list(expect_equal(PKNCAdose(tmp.dose, formula = .~ time | treatment + ID), structure(list(data = cbind(tmp.dose, data.frame(exclude = NA, route = “extravascular”, duration = 0, stringsAsFactors = FALSE)), formula = . ~ time | treatment + ID, exclude = “exclude”, columns = list(route = “route”, duration = “duration”)), class = c(“PKNCAdose”, “list”)), info = “PKNCAdose accepts . on the left side of the formula”)), call = list(expect_equal(PKNCAdose(tmp.dose, formula = . ~
time | treatment + ID), structure(list(data = cbind(tmp.dose, data.frame(exclude= NA, route = "extravascular", duration = 0, stringsAsFactors = FALSE)), formula = . ~ time | treatment + ID, exclude = “exclude”, columns = list(route = “route”, duration = “duration”)), class = c(“PKNCAdose”, “list”)), info = “PKNCAdose accepts . on the left side of the formula”)), start_frame = 74, end_frame = 74, test = “PKNCAdose”), list(message = “PKNCAdose(tmp.dose, formula = dose ~ . | treatment + ID) not equal to structure(…).”,
srcref = c(61, 3, 73,75, 3, 75, 61, 73), expectation_calls = list(expect_equal(PKNCAdose(tmp.dose, formula = dose~ . | treatment + ID), structure(list(data = cbind(tmp.dose, data.frame(exclude = NA, route = “extravascular”, duration = 0, stringsAsFactors = FALSE)), formula = dose ~ . | treatment + ID, exclude = “exclude”, columns = list(route = “route”, duration = “duration”)), class = c(“PKNCAdose”, “list”)), info = “PKNCAdose accepts . on the right side of the formula”)), call = list(expect_equal(PKNCAdose(tmp.dose,
formula = dose ~. | treatment + ID), structure(list(data =cbind(tmp.dose, data.frame(exclude = NA, route = "extravascular“, duration = 0, stringsAsFactors = FALSE)), formula = dose ~ . | treatment + ID, exclude =”exclude“, columns = list(route =”route“, duration =”duration“)), class = c(”PKNCAdose“,”list“)), info =”PKNCAdose accepts . on the right side of the formula“)), start_frame = 74, end_frame = 74, test =”PKNCAdose“), list(message =”", srcref = c(77, 3, 79, 63, 3, 63, 77, 79
), expectation_calls = list(expect_error(PKNCAdose(tmp.dose.na, formula = dose ~ time| treatment + ID), regex= "Somebut not all values are missing for the independent variable“, info =”Dose time must either all or none be NA.“)), call = list(expect_error(PKNCAdose(tmp.dose.na, formula = dose ~ time | treatment + ID), regex =”Some but not all values are missing for the independent variable“, info =”Dose time must either all or none be NA.“)), start_frame = 74, end_frame = 74, test =”PKNCAdose"),
list(message = "", srcref = c(84, 3, 86, 42, 3, 42, 84, 86), expectation_calls =list(expect_error(PKNCAdose(bad.dose.analyte, formula = dose ~ time | treatment + ID), regexp = “Rows that are not unique per group and time”, info = “Duplicated key rows”)), call = list(expect_error(PKNCAdose(bad.dose.analyte, formula = dose ~ time | treatment + ID), regexp = “Rows that are not unique per group and time”, info = “Duplicated key rows”)), start_frame = 74, end_frame = 74, test = “PKNCAdose”), list(
message = "PKNCAdose(tmp.dose, formula = dose ~ time | treatment + ID) not equal to PKNCAdose(…).RUE", srcref = c(88, 3, 92, 91, 3, 91, 88, 92), expectation_calls = list(expect_equal(PKNCAdose(tmp.dose, formula = dose ~ time | treatment + ID), PKNCAdose(tbl_df(tmp.dose), formula = dose ~ time | treatment + ID), info = “tbl_df and data.frame classes both work and create identical objects”)), call = list(expect_equal(PKNCAdose(tmp.dose, formula = dose ~ time | treatment + ID), PKNCAdose(tbl_df(tmp.dose),
formula = dose ~ time | treatment + ID), info = "tbl_dfand data.frame classes both work and create identical objects“)), start_frame = 74, end_frame = 74, test =”PKNCAdose"))
test-class-PKNCAdose.RPKNCAdose without a data.frame as input101list(list(message = "“, srcref = c(98, 3, 101, 79, 3, 79, 98, 101), expectation_calls = list(expect_error(PKNCAdose(tmp, formula = . ~ time | treatment + ID), regexp = captured_message, fixed = TRUE, info =”PKNCAdose tries to make arbitrary data into a data.frame“)), call = list(expect_error(PKNCAdose(tmp, formula = . ~ time | treatment + ID), regexp = captured_message, fixed = TRUE, info =”PKNCAdose tries to make arbitrary data into a data.frame“)), start_frame = 74, end_frame = 74, test =”PKNCAdose without a data.frame as input"))
test-class-PKNCAdose.RPKNCAdose model.frame13013list(list(message = “getDepVar.PKNCAdose(mydose1) not equal to rep(1:2, each = 5).”, srcref = c(115, 3, 117, 71, 3, 71, 115, 117), expectation_calls = list(expect_equal(getDepVar.PKNCAdose(mydose1), rep(1:2, each = 5), info = “getDepVar.PKNCAdose works with two-sided formula”)), call = list(expect_equal(getDepVar.PKNCAdose(mydose1), rep(1:2, each = 5), info = “getDepVar.PKNCAdose works with two-sided formula”)), start_frame = 74, end_frame = 74, test = “PKNCAdose model.frame”), list(message = “getIndepVar.PKNCAdose(mydose1) not equal to rep(0, 10).”,
srcref = c(118, 3, 120, 73, 3, 73, 118, 120), expectation_calls= list(expect_equal(getIndepVar.PKNCAdose(mydose1),rep(0, 10), info = “getIndepVar.PKNCAdose works with two-sided formula”)), call = list(expect_equal(getIndepVar.PKNCAdose(mydose1), rep(0, 10), info = “getIndepVar.PKNCAdose works with two-sided formula”)), start_frame = 74, end_frame = 74, test = “PKNCAdose model.frame”), list(message = “model.frame.PKNCAdose(mydose1) not equal to data.frame(…).”, srcref = c(121, 3, 128,
73, 3, 73, 121, 128), expectation_calls = list(expect_equal(model.frame.PKNCAdose(mydose1), data.frame(`getDepVar.PKNCAdose(formula)= rep(1:2, each = 5),getIndepVar.PKNCAdose(formula)= 0, treatment = rep(c("Trt 1", "Trt 2"), each = 5), ID = rep(1:5, 2), stringsAsFactors = FALSE), check.attributes = FALSE, info = "model.frame.PKNCAdose works with two-sided formula")), call = list(expect_equal(model.frame.PKNCAdose(mydose1), data.frame(getDepVar.PKNCAdose(formula)= rep(1:2, each = 5),getIndepVar.PKNCAdose(formula)` = 0,
treatment = rep(c("Trt 1“,”Trt 2"), each = 5), ID = rep(1:5, 2), stringsAsFactors = FALSE), check.attributes = FALSE, info = “model.frame.PKNCAdose works with two-sided formula”)), start_frame = 74, end_frame = 74, test = “PKNCAdose model.frame”), list(message = “getDepVar.PKNCAdose(mydose2) not equal to rep(NA_integer_, 10).”, srcref = c(131, 3, 133, 71, 3, 71, 131, 133), expectation_calls = list(expect_equal(getDepVar.PKNCAdose(mydose2), rep(NA, 10), info = “getDepVar.PKNCAdose works with one-sided formula”)),
call = list(expect_equal(getDepVar.PKNCAdose(mydose2), rep(NA,10), info = "getDepVar.PKNCAdose works withone-sided formula“)), start_frame = 74, end_frame = 74, test =”PKNCAdose model.frame“), list(message =”getIndepVar.PKNCAdose(mydose2) not equal to rep(0, 10).“, srcref = c(134, 3, 136, 73, 3, 73, 134, 136), expectation_calls = list(expect_equal(getIndepVar.PKNCAdose(mydose2), rep(0, 10), info =”getIndepVar.PKNCAdose works with one-sided formula")), call = list(expect_equal(getIndepVar.PKNCAdose(mydose2),
rep(0, 10), info = "getIndepVar.PKNCAdose works with one-sidedformula")), start_frame = 74, end_frame = 74, test =“PKNCAdose model.frame”), list(message = “model.frame.PKNCAdose(mydose2) not equal to data.frame(…).”, srcref = c(137, 3, 144, 73, 3, 73, 137, 144), expectation_calls = list(expect_equal(model.frame.PKNCAdose(mydose2), data.frame(getDepVar.PKNCAdose(formula) = NA, getIndepVar.PKNCAdose(formula) = 0, treatment = rep(c(“Trt 1”, “Trt 2”), each = 5), ID = rep(1:5, 2), stringsAsFactors = FALSE),
check.attributes = FALSE, info = "model.frame.PKNCAdose works with one-sided formula")), call = list(expect_equal(model.frame.PKNCAdose(mydose2), data.frame(getDepVar.PKNCAdose(formula) = NA, getIndepVar.PKNCAdose(formula) = 0, treatment = rep(c(“Trt 1”, “Trt 2”), each = 5), ID = rep(1:5, 2), stringsAsFactors = FALSE), check.attributes = FALSE, info = “model.frame.PKNCAdose works with one-sided formula”)), start_frame = 74, end_frame = 74, test = “PKNCAdose model.frame”), list(message = “getDepVar.PKNCAdose(mydose3) not equal to rep(NA_integer_, 10).”,
srcref = c(147, 3, 149, 84, 3, 84, 147, 149), expectation_calls= list(expect_equal(getDepVar.PKNCAdose(mydose3), rep(NA, 10), info = “getDepVar.PKNCAdose works with one-sided formula (‘.’ on LHS)”)), call = list(expect_equal(getDepVar.PKNCAdose(mydose3), rep(NA, 10), info = “getDepVar.PKNCAdose works with one-sided formula (‘.’ on LHS)”)), start_frame = 74, end_frame = 74, test = “PKNCAdose model.frame”), list(message = “getIndepVar.PKNCAdose(mydose3) not equal to rep(0, 10).”, srcref = c(150,
3, 152, 86, 3, 86, 150, 152), expectation_calls = list(expect_equal(getIndepVar.PKNCAdose(mydose3), rep(0, 10), info =“getIndepVar.PKNCAdose works with one-sided formula (‘.’ on LHS)”)), call = list(expect_equal(getIndepVar.PKNCAdose(mydose3), rep(0, 10), info = “getIndepVar.PKNCAdose works with one-sided formula (‘.’ on LHS)”)), start_frame = 74, end_frame = 74, test = “PKNCAdose model.frame”), list(message = “model.frame.PKNCAdose(mydose3) not equal to data.frame(…).”, srcref = c(153,
3, 160, 86, 3, 86, 153, 160), expectation_calls = list(expect_equal(model.frame.PKNCAdose(mydose3), data.frame(`getDepVar.PKNCAdose(formula)= NA,getIndepVar.PKNCAdose(formula)= 0, treatment = rep(c("Trt 1", "Trt 2"), each = 5), ID = rep(1:5, 2), stringsAsFactors = FALSE), check.attributes = FALSE, info = "model.frame.PKNCAdose works with one-sided formula ('.' on LHS)")), call = list(expect_equal(model.frame.PKNCAdose(mydose3), data.frame(getDepVar.PKNCAdose(formula)= NA,getIndepVar.PKNCAdose(formula)` = 0,
treatment = rep(c("Trt 1“,”Trt 2"), each = 5), ID = rep(1:5, 2), stringsAsFactors = FALSE), check.attributes = FALSE, info = “model.frame.PKNCAdose works with one-sided formula (‘.’ on LHS)”)), start_frame = 74, end_frame = 74, test = “PKNCAdose model.frame”), list(message = “getDepVar.PKNCAdose(mydose4) not equal to rep(1:2, each = 5).”, srcref = c(163, 3, 165, 84, 3, 84, 163, 165), expectation_calls = list(expect_equal(getDepVar.PKNCAdose(mydose4), rep(1:2, each = 5), info = “getDepVar.PKNCAdose works with one-sided formula (‘.’ on RHS)”)),
call = list(expect_equal(getDepVar.PKNCAdose(mydose4), rep(1:2,each = 5), info ="getDepVar.PKNCAdose works with one-sided formula (‘.’ on RHS)“)), start_frame = 74, end_frame = 74, test =”PKNCAdose model.frame“), list(message =”getIndepVar.PKNCAdose(mydose4) not equal to rep(NA_integer_, 10).“, srcref = c(166, 3, 168, 86, 3, 86, 166, 168), expectation_calls = list(expect_equal(getIndepVar.PKNCAdose(mydose4), rep(NA, 10), info =”getIndepVar.PKNCAdose works with one-sided formula (‘.’ on RHS)")),
call = list(expect_equal(getIndepVar.PKNCAdose(mydose4), rep(NA, 10), info = "getIndepVar.PKNCAdose workswith one-sided formula (‘.’ on RHS)“)), start_frame = 74, end_frame = 74, test =”PKNCAdose model.frame“), list(message =”model.frame.PKNCAdose(mydose4) not equal to data.frame(…).", srcref = c(169, 3, 176, 86, 3, 86, 169, 176), expectation_calls = list(expect_equal(model.frame.PKNCAdose(mydose4), data.frame(getDepVar.PKNCAdose(formula) = rep(1:2, each = 5), getIndepVar.PKNCAdose(formula) = NA,
treatment = rep(c("Trt 1“,”Trt 2"), each = 5), ID = rep(1:5, 2), stringsAsFactors = FALSE), check.attributes = FALSE, info = “model.frame.PKNCAdose works with one-sided formula (‘.’ on RHS)”)), call = list(expect_equal(model.frame.PKNCAdose(mydose4), data.frame(getDepVar.PKNCAdose(formula) = rep(1:2, each = 5), getIndepVar.PKNCAdose(formula) = NA, treatment = rep(c(“Trt 1”, “Trt 2”), each = 5), ID = rep(1:5, 2), stringsAsFactors = FALSE), check.attributes = FALSE, info = “model.frame.PKNCAdose works with one-sided formula (‘.’ on RHS)”)),
start_frame = 74, end_frame = 74, test = "PKNCAdose model.frame"), list(message ="", srcref = c(179, 3, 181, 73, 3, 73, 179, 181), expectation_calls = list(expect_error(PKNCAdose(formula = dose ~ . | treatment + ID, data = rbind(tmp.dose, tmp.dose)), regexp = "Rows that are not unique per group and time.*found within dosing data“, info =”Dosing must have unique values with time and group")), call = list(expect_error(PKNCAdose(formula = dose ~ . | treatment + ID, data = rbind(tmp.dose, tmp.dose)),
regexp = "Rows that are not unique per group and time.*found within dosing data",info = "Dosing must haveunique values with time and group“)), start_frame = 74, end_frame = 74, test =”PKNCAdose model.frame"))
test-class-PKNCAdose.Rprint.PKNCAdose404list(list(message = “print(mydose) does not match "Formula for dosing:\n dose ~ time | treatment + ID\nNominal time column is not specified.\n\nFirst 6 rows of dosing data:\\n treatment ID dose time exclude route duration\n Trt 1 1 1 0  extravascular 0\n Trt 1 2 1 0  extravascular 0\n Trt 1 3 1 0  extravascular 0\n Trt 1 4 1 0  extravascular 0\n Trt 1 5 1 0  extravascular 0\n Trt 2 1 2 0  extravascular 0".value: "Formula for dosing:\n dose ~ time | treatment + ID\nNominal time column is not specified.\n\nFirst 6 rows of dosing data:\\n treatment ID dose time exclude route duration\n Trt 1 1 1 0  extravascular 0\n Trt 1 2 1 0  extravascular 0\n Trt 1 3 1 0  extravascular 0\n Trt 1 4 1 0  extravascular 0\n Trt 1 5 1 0  extravascular 0\n Trt 2 1 2 0  extravascular 0"”,
srcref = c(193, 3, 207, 53, 3, 53, 193, 207), expectation_calls= list(expect_output(print(mydose), regexp= "Formula for dosing:dose ~ time | treatment + IDtime column is not specified.6 rows of dosing data:\n treatment ID dose time exclude route durationTrt 1 1 1 0  extravascular 0Trt 1 2 1 0  extravascular 0Trt 1 3 1 0  extravascular 0Trt 1 4 1 0  extravascular 0Trt 1 5 1 0  extravascular 0Trt 2 1 2 0  extravascular 0",
fixed = TRUE, info = “Generic print.PKNCAdose works”), expect_match(act$cap,enc2native(regexp), …,info = info, label = act$lab)), call = list(expect_output(print(mydose), regexp = “Formula for dosing:dose ~ time | treatment + IDtime column is not specified.6 rows of dosing data:\n treatment ID dose time exclude route durationTrt 1 1 1 0  extravascular 0Trt 1 2 1 0  extravascular 0Trt 1 3 1 0  extravascular 0Trt 1 4 1 0  extravascular 0Trt 1 5 1 0  extravascular 0Trt 2 1 2 0  extravascular 0”,
fixed = TRUE, info = “Generic print.PKNCAdose works”), expect_match(act$cap,enc2native(regexp), …,info = info, label = act$lab)), start_frame = 74, end_frame = 75, test = “print.PKNCAdose”), list(message = “print(mydose.nogroup) does not match "Formula for dosing:\n dose ~ time\nNominal time column is not specified.\n\nData for dosing:\n treatment ID dose time exclude route duration\n Trt 1 1 1 0  extravascular 0".value: "Formula for dosing:\n dose ~ time\nNominal time column is not specified.\n\nData for dosing:\n treatment ID dose time exclude route duration\n Trt 1 1 1 0  extravascular 0"”,
srcref = c(208, 3, 217, 68, 3, 68, 208, 217), expectation_calls= list(expect_output(print(mydose.nogroup), regexp= “Formula for dosing:dose ~ timetime column is not specified.for dosing:treatment ID dose time exclude route durationTrt 1 1 1 0  extravascular 0”, fixed = TRUE, info = “Generic print.PKNCAdose works with no groups”), expect_match(act\(cap, enc2native(regexp), ..., info = info, label = act\)lab)), call = list(expect_output(print(mydose.nogroup),
regexp = "Formulafor dosing:dose ~ timetime column is not specified.for dosing:treatment ID dose time exclude route durationTrt 1 1 1 0  extravascular 0“, fixed = TRUE, info =”Generic print.PKNCAdose works with no groups“), expect_match(act\(cap, enc2native(regexp), ..., info = info, label = act\)lab)), start_frame = 74, end_frame = 75, test =”print.PKNCAdose“), list(message =”print(mydose, n = -5) does not match "Formula for dosing:\n dose ~ time | treatment + ID\nNominal time column is not specified.\n\nFirst 5 rows of dosing data:\\n treatment ID dose time exclude route duration\n Trt 1 1 1 0  extravascular 0\n Trt 1 2 1 0  extravascular 0\n Trt 1 3 1 0  extravascular 0\n Trt 1 4 1 0  extravascular 0\n Trt 1 5 1 0  extravascular 0".value: "Formula for dosing:\n dose ~ time | treatment + ID\nNominal time column is not specified.\n\nFirst 5 rows of dosing data:\\n treatment ID dose time exclude route duration\n Trt 1 1 1 0  extravascular 0\n Trt 1 2 1 0  extravascular 0\n Trt 1 3 1 0  extravascular 0\n Trt 1 4 1 0  extravascular 0\n Trt 1 5 1 0  extravascular 0"",
srcref = c(219, 3, 232, 53, 3, 53, 219, 232), expectation_calls= list(expect_output(print(mydose, n = -5), regexp= “Formula for dosing:dose ~ time | treatment + IDtime column is not specified.5 rows of dosing data:\n treatment ID dose time exclude route durationTrt 1 1 1 0  extravascular 0Trt 1 2 1 0  extravascular 0Trt 1 3 1 0  extravascular 0Trt 1 4 1 0  extravascular 0Trt 1 5 1 0  extravascular 0”,
fixed = TRUE, info = “Generic print.PKNCAdose works”), expect_match(act$cap,enc2native(regexp), …,info = info, label = act$lab)), call = list(expect_output(print(mydose, n = -5), regexp = “Formula for dosing:dose ~ time | treatment + IDtime column is not specified.5 rows of dosing data:\n treatment ID dose time exclude route durationTrt 1 1 1 0  extravascular 0Trt 1 2 1 0  extravascular 0Trt 1 3 1 0  extravascular 0Trt 1 4 1 0  extravascular 0Trt 1 5 1 0  extravascular 0”,
fixed = TRUE, info = “Generic print.PKNCAdose works”), expect_match(act$cap,enc2native(regexp), …,info = info, label = act$lab)), start_frame = 74, end_frame = 75, test = “print.PKNCAdose”), list(message = “print(mydose, summarize = TRUE) does not match "Formula for dosing:\n dose ~ time | treatment + ID\nNominal time column is not specified.\n\nNumber unique entries in each group:\n treatment ID\n 2 5".value: "Formula for dosing:\n dose ~ time | treatment + ID\nNominal time column is not specified.\n\nNumber unique entries in each group:\n treatment ID\n 2 5"”,
srcref = c(234, 3, 243, 53, 3, 53, 234, 243), expectation_calls= list(expect_output(print(mydose, summarize = TRUE), regexp = “Formula for dosing:dose ~ time | treatment + IDtime column is not specified.unique entries in each group:treatment ID2 5”, fixed = TRUE, info = “Summary print.PKNCAdose works”), expect_match(act\(cap, enc2native(regexp), ..., info = info, label = act\)lab)), call = list(expect_output(print(mydose, summarize = TRUE), regexp = “Formula for dosing:dose ~ time | treatment + IDtime column is not specified.unique entries in each group:treatment ID2 5”,
fixed = TRUE, info = “Summary print.PKNCAdose works”), expect_match(act$cap,enc2native(regexp), …,info = info, label = act$lab)), start_frame = 74, end_frame = 75, test = “print.PKNCAdose”))
test-class-PKNCAdose.RPKNCAdose with exclusions101list(list(message = “mydose not equal to structure(…).”, srcref = c(251, 3, 261, 47, 3, 47, 251, 261), expectation_calls = list(expect_equal(mydose, structure(list(data = cbind(tmp.dose, data.frame(route = “extravascular”, duration = 0, stringsAsFactors = FALSE)), formula = dose ~ time | treatment + ID, exclude = “excl”, columns = list(route = “route”, duration = “duration”)), class = c(“PKNCAdose”, “list”)))), call = list(expect_equal(mydose, structure(list(data = cbind(tmp.dose, data.frame(route = “extravascular”,
duration = 0, stringsAsFactors = FALSE)), formula = dose ~ time| treatment + ID,exclude = “excl”, columns = list(route = “route”, duration = “duration”)), class = c(“PKNCAdose”, “list”)))), start_frame = 74, end_frame = 74, test = “PKNCAdose with exclusions”))
test-class-PKNCAdose.RPKNCAdose route and duration606list(list(message = “PKNCAdose(tmp.dose, formula = dose ~ time | treatment + ID) not equal to PKNCAdose(tmp.dose, formula = dose ~ time | treatment + ID, route = "extravascular").”, srcref = c(267, 3, 269, 56, 3, 56, 267, 269), expectation_calls = list(expect_equal(PKNCAdose(tmp.dose, formula = dose ~ time | treatment + ID), PKNCAdose(tmp.dose, formula = dose ~ time | treatment + ID, route = “extravascular”), info = “route is assumed as extravascular”)), call = list(expect_equal(PKNCAdose(tmp.dose,
formula = dose ~ time| treatment + ID), PKNCAdose(tmp.dose, formula = dose ~ time | treatment + ID, route= "extravascular“), info =”route is assumed as extravascular“)), start_frame = 74, end_frame = 74, test =”PKNCAdose route and duration“), list(message =”PKNCAdose(tmp.dose, formula = dose ~ time | treatment + ID) not equal to PKNCAdose(tmp.dose, formula = dose ~ time | treatment + ID, duration = 0).", srcref = c(270, 3, 272, 47, 3, 47, 270, 272), expectation_calls = list(expect_equal(PKNCAdose(tmp.dose,
formula = dose ~ time| treatment + ID), PKNCAdose(tmp.dose, formula = dose ~ time | treatment + ID, duration = 0),info = “duration is assumed as 0”)), call = list(expect_equal(PKNCAdose(tmp.dose, formula = dose ~ time | treatment + ID), PKNCAdose(tmp.dose, formula = dose ~ time | treatment + ID, duration = 0), info = “duration is assumed as 0”)), start_frame = 74, end_frame = 74, test = “PKNCAdose route and duration”), list(message = “PKNCAdose(tmp.dose, formula = dose ~ time | treatment + ID) not equal to PKNCAdose(…).”,
srcref = c(273, 3, 275, 63, 3, 63, 273, 275), expectation_calls= list(expect_equal(PKNCAdose(tmp.dose, formula = dose ~ time | treatment + ID), PKNCAdose(tmp.dose, formula = dose ~ time | treatment + ID, duration = 0, route = “extravascular”), info = “route and duration are correctly assumed”)), call = list(expect_equal(PKNCAdose(tmp.dose, formula = dose ~ time | treatment + ID), PKNCAdose(tmp.dose, formula = dose ~ time | treatment + ID, duration = 0, route = “extravascular”), info = “route and duration are correctly assumed”)),
start_frame = 74, end_frame = 74, test = "PKNCAdose route and duration"), list(message = "dose.iv not equal to {\n …}.", srcref = c(278, 3, 284, 48, 3, 48, 278, 284), expectation_calls = list(expect_equal(dose.iv, {
tmp <- dose.ev
tmp\(data\)route <- "intravascular"
tmp
}, info = "Intravascularroute works")), call = list(expect_equal(dose.iv, {
tmp <- dose.ev
tmp\(data\)route <- "intravascular"
tmp
}, info = "Intravascularroute works")), start_frame = 74, end_frame = 74, test = "PKNCAdose route and duration"), list(message = "“, srcref = c(285, 3, 287, 54, 3, 54, 285, 287), expectation_calls = list(expect_error(PKNCAdose(tmp.dose, formula = dose ~ time | treatment + ID, duration = 0, route =”foo“), regexp =”route must have values of either ‘extravascular’ or ‘intravascular’. Please set to one of those values and retry.“, info =”route must be an accepted value")), call = list(expect_error(PKNCAdose(tmp.dose,
formula = dose ~ time| treatment + ID, duration = 0, route = "foo“), regexp =”route must have values ofeither ’extravascular’ or ‘intravascular’. Please set to one of those values and retry.“, info =”route must be an accepted value“)), start_frame = 74, end_frame = 74, test =”PKNCAdose route and duration“), list(message =”{…} not equivalent to {…}.", srcref = c(292, 3, 302, 6, 3, 6, 292, 302), expectation_calls = list(expect_equivalent({
tmp <- PKNCAdose(tmp.dose, formula = dose ~ time | treatment +ID, duration = 0,route = “intravascular”)
tmp\(data <- tmp\)data[, sort(names(tmp$data))]
tmp
}, {
tmp <- PKNCAdose(tmp.dose.iv, formula = dose ~ time | treatment+ ID, duration =0, route = “route”)
tmp\(data <- tmp\)data[, sort(names(tmp$data))]
tmp
})), call = list(expect_equivalent({
tmp <- PKNCAdose(tmp.dose, formula = dose ~ time | treatment +ID, duration = 0,route = “intravascular”)
tmp\(data <- tmp\)data[, sort(names(tmp$data))]
tmp
}, {
tmp <- PKNCAdose(tmp.dose.iv, formula = dose ~ time | treatment+ ID, duration =0, route = “route”)
tmp\(data <- tmp\)data[, sort(names(tmp$data))]
tmp
})), start_frame = 74, end_frame = 74, test = "PKNCAdose route andduration"))
test-class-PKNCAdose.Rtime.nominal within PKNCAdose303list(list(message = “PKNCAdose(tmp.dose, formula = dose ~ time | treatment + ID, time.nominal = "nom_time") not equal to structure(…).”, srcref = c(311, 3, 325, 53, 3, 53, 311, 325), expectation_calls = list(expect_equal(PKNCAdose(tmp.dose, formula = dose ~ time | treatment + ID, time.nominal = “nom_time”), structure(list(data = cbind(tmp.dose, data.frame(exclude = NA, route = “extravascular”, duration = 0, stringsAsFactors = FALSE)), formula = dose ~ time | treatment + ID, exclude = “exclude”,
columns = list(route= “route”, duration = “duration”, time.nominal = “nom_time”)), class = c(“PKNCAdose”,“list”)), info = “PKNCAdose accepts time.nominal”)), call = list(expect_equal(PKNCAdose(tmp.dose, formula = dose ~ time | treatment + ID, time.nominal = “nom_time”), structure(list(data = cbind(tmp.dose, data.frame(exclude = NA, route = “extravascular”, duration = 0, stringsAsFactors = FALSE)), formula = dose ~ time | treatment + ID, exclude = “exclude”, columns = list(route = “route”, duration = “duration”,
time.nominal = "nom_time“)), class = c(”PKNCAdose“,”list")), info = "PKNCAdose accepts time.nominal")), start_frame = 74, end_frame = 74, test = “time.nominal within PKNCAdose”), list(message = "“, srcref = c(326, 3, 329, 74, 3, 74, 326, 329), expectation_calls = list(expect_error(PKNCAdose(tmp.dose, formula = dose ~ time | treatment + ID, time.nominal =”foo“), regexp =”time.nominal, if given, must be a column name in the input data“, info =”PKNCAdose time.nominal must be a column in the data")),
call = list(expect_error(PKNCAdose(tmp.dose, formula = dose ~ time | treatment +ID, time.nominal = “foo”), regexp= “time.nominal, if given, must be a column name in the input data”, info = “PKNCAdose time.nominal must be a column in the data”)), start_frame = 74, end_frame = 74, test = “time.nominal within PKNCAdose”), list(message = “print(dose_with_nom_time) does not match "Formula for dosing:\n dose ~ time | treatment + ID\nNominal time column is: nom_time\n\nFirst 6 rows of dosing data:\\n treatment ID dose time nom_time exclude route duration\n Trt 1 1 1 0 0  extravascular 0\n Trt 1 2 1 0 0  extravascular 0\n Trt 1 3 1 0 0  extravascular 0\n Trt 1 4 1 0 0  extravascular 0\n Trt 1 5 1 0 0  extravascular 0\n Trt 2 1 2 0 0  extravascular 0".value: "Formula for dosing:\n dose ~ time | treatment + ID\nNominal time column is: nom_time\n\nFirst 6 rows of dosing data:\\n treatment ID dose time nom_time exclude route duration\n Trt 1 1 1 0 0  extravascular 0\n Trt 1 2 1 0 0  extravascular 0\n Trt 1 3 1 0 0  extravascular 0\n Trt 1 4 1 0 0  extravascular 0\n Trt 1 5 1 0 0  extravascular 0\n Trt 2 1 2 0 0  extravascular 0"”,
srcref = c(333, 3, 347, 53, 3, 53, 333, 347), expectation_calls= list(expect_output(print(dose_with_nom_time), regexp = “Formula for dosing:dose ~ time | treatment + IDtime column is: nom_time6 rows of dosing data:\n treatment ID dose time nom_time exclude route durationTrt 1 1 1 0 0  extravascular 0Trt 1 2 1 0 0  extravascular 0Trt 1 3 1 0 0  extravascular 0Trt 1 4 1 0 0  extravascular 0Trt 1 5 1 0 0  extravascular 0Trt 2 1 2 0 0  extravascular 0”,
fixed = TRUE, info = “Generic print.PKNCAdose works”), expect_match(act$cap,enc2native(regexp), …,info = info, label = act$lab)), call = list(expect_output(print(dose_with_nom_time), regexp = “Formula for dosing:dose ~ time | treatment + IDtime column is: nom_time6 rows of dosing data:\n treatment ID dose time nom_time exclude route durationTrt 1 1 1 0 0  extravascular 0Trt 1 2 1 0 0  extravascular 0Trt 1 3 1 0 0  extravascular 0Trt 1 4 1 0 0  extravascular 0Trt 1 5 1 0 0  extravascular 0Trt 2 1 2 0 0  extravascular 0”,
fixed = TRUE, info = “Generic print.PKNCAdose works”), expect_match(act$cap,enc2native(regexp), …,info = info, label = act$lab)), start_frame = 74, end_frame = 75, test = “time.nominal within PKNCAdose”))
test-class-PKNCAdose.RsetDuration303list(list(message = “setDuration(mydose) not equal to mydose.”, srcref = c(356, 3, 358, 51, 3, 51, 356, 358), expectation_calls = list(expect_equal(setDuration(mydose), mydose, info = “No changes with no arguments”)), call = list(expect_equal(setDuration(mydose), mydose, info = “No changes with no arguments”)), start_frame = 74, end_frame = 74, test = “setDuration”), list(message = "", srcref = c(359, 3, 362, 57, 3, 57, 359, 362), expectation_calls = list(expect_error(setDuration(mydose,
duration = “foo”, rate = “bar”), regexp = "Both duration and rate cannot be givenat the same time", fixed= TRUE,info = “Cannot give both duration and rate”)), call = list(expect_error(setDuration(mydose, duration = “foo”, rate = “bar”), regexp = “Both duration and rate cannot be given at the same time”, fixed = TRUE, info = “Cannot give both duration and rate”)), start_frame = 74, end_frame = 74, test = “setDuration”), list(message = "", srcref = c(363, 3, 366, 63, 3, 63, 363, 366), expectation_calls = list(
expect_error(setDuration(mydose, duration = “foobar”), regexp ="duration must benumeric without missing(NA) or infinite values, and all values must be >= 0“, fixed = TRUE, info =”Cannot give both duration as non-numeric“)), call = list(expect_error(setDuration(mydose, duration =”foobar“), regexp =”duration must be numeric without missing (NA) or infinite values, and all values must be >= 0“, fixed = TRUE, info =”Cannot give both duration as non-numeric")), start_frame = 74, end_frame = 74,
test = “setDuration”))

+

+

+
Class generation-PKNCAresults

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Testing FilenameTest DescriptionNumber of TestsNumber of Failed Testspassedresult
test-class-PKNCAresults.RPKNCAresults generation808list(list(message = “names(myresult) not equal to c("result", "data", "exclude").”, srcref = c(16, 3, 18, 108, 3, 108, 16, 18), expectation_calls = list(expect_equal(names(myresult), c(“result”, “data”, “exclude”), info = “Make sure that the result has the expected names (and only the expected names) in it.”)), call = list(expect_equal(names(myresult), c(“result”, “data”, “exclude”), info = “Make sure that the result has the expected names (and only the expected names) in it.”)), start_frame = 74,
end_frame = 74, test = "PKNCAresults generation“), list(message =”checkProvenance(myresult) isn’ttrue.", srcref =c(19, 3, 20, 71, 3, 71, 19, 20), expectation_calls = list(expect_true(checkProvenance(myresult), info = “Provenance exists and can be confirmed on results”)), call = list(expect_true(checkProvenance(myresult), info = “Provenance exists and can be confirmed on results”)), start_frame = 74, end_frame = 74, test = “PKNCAresults generation”), list(message = “myresult$data not equal to {…}.”,
srcref = c(24, 3, 30, 97, 3, 97, 24, 30), expectation_calls = list(expect_equal(myresult$data, {
tmp <- mydata
tmp$options <- PKNCA.options()
tmp
}, info = "The data is just a copy of the input data plus an instantiation of the PKNCA.options")), call = list(expect_equal(myresult$data, {
tmp <- mydata
tmp$options <- PKNCA.options()
tmp
}, info = "The data is just a copy of the input data plus an instantiation of the PKNCA.options")), start_frame = 74, end_frame = 74, test ="PKNCAresults generation“), list(message =”myresult\(result not equal to `verify.result`.\nTRUE", srcref = c(54, 3, 56, 150, 3, 150, 54, 56), expectation_calls = list(expect_equal(myresult\)result, verify.result, tol = 0.001, info = “The specific order of the levels isn’t important– the fact that they are factors and that the set doesn’t change is important.”)),
call = list(expect_equal(myresult$result, verify.result, tol = 0.001, info = "The specific order of the levels isn’timportant– the fact that they are factors and that the set doesn’t change is important.“)), start_frame = 74, end_frame = 74, test =”PKNCAresults generation“), list(message =”as.data.frame(myresult) not equal to verify.result.“, srcref = c(59, 3, 60, 102, 3, 102, 59, 60), expectation_calls = list(expect_equal(as.data.frame(myresult), verify.result, tol = 0.001, info =”Conversion of PKNCAresults to a data.frame in long format (default long format)")),
call = list(expect_equal(as.data.frame(myresult), verify.result, tol = 0.001, info = "Conversion of PKNCAresults toa data.frame in long format (default long format)“)), start_frame = 74, end_frame = 74, test =”PKNCAresults generation“), list(message =”as.data.frame(myresult, out.format = "long") not equal to verify.result.“, srcref = c(61, 3, 62, 105, 3, 105, 61, 62), expectation_calls = list(expect_equal(as.data.frame(myresult, out.format =”long“), verify.result, tol = 0.001, info =”Conversion of PKNCAresults to a data.frame in long format (specifying long format)")),
call = list(expect_equal(as.data.frame(myresult, out.format = “long”), verify.result, tol = 0.001,info = "Conversion of PKNCAresults to a data.framein long format (specifying long format)“)), start_frame = 74, end_frame = 74, test =”PKNCAresults generation“), list(message =”as.data.frame(myresult, out.format = "wide") not equal to tidyr::spread_(verify.result, "PPTESTCD", "PPORRES").", srcref = c(63, 3, 66, 105, 3, 105, 63, 66), expectation_calls = list(expect_equal(as.data.frame(myresult,
out.format = “wide”), tidyr::spread_(verify.result, “PPTESTCD”, “PPORRES”), tol = 0.001, info = "Conversion of PKNCAresults to a data.frame in wide format (specifying wide format)“)), call = list(expect_equal(as.data.frame(myresult, out.format =”wide“), tidyr::spread_(verify.result,”PPTESTCD“,”PPORRES“), tol = 0.001, info =”Conversion of PKNCAresults to a data.frame in wide format (specifying wide format)“)), start_frame = 74, end_frame = 74, test =”PKNCAresults generation“), list(message =”comparison_orig\(PPORRES[comparison_orig\)PPTESTCD %in% "aucint.inf.obs"] not equal to comparison_12\(PPORRES[comparison_12\)PPTESTCD %in% "aucint.inf.obs"].",
srcref = c(84, 3, 86, 70, 3, 70, 84, 86), expectation_calls = list(expect_equal(comparison_orig$PPORRES[comparison_orig$PPTESTCD %in% "aucint.inf.obs"], comparison_12\(PPORRES[comparison_12\)PPTESTCD %in% “aucint.inf.obs”], info = “Time shift does not affect aucint calculations.”)), call = list(expect_equal(comparison_orig\(PPORRES[comparison_orig\)PPTESTCD %in% “aucint.inf.obs”], comparison_12\(PPORRES[comparison_12\)PPTESTCD %in% “aucint.inf.obs”], info = “Time shift does not affect aucint calculations.”)),
start_frame = 74, end_frame = 74, test = “PKNCAresults generation”))
test-class-PKNCAresults.RPKNCAresults has exclude, when applicable403list(list(message = “Too few points for half-life calculation (min.hl.points=3 with only 0 points)”, srcref = c(100, 3, 100, 28, 3, 28, 100, 100), call = list(pk.nca(mydata), parallel::mclapply(X = splitdata[mask_has_interval], FUN = pk.nca.intervals, options = data$options), lapply(X, FUN, …), FUN(X[[i]], …), tryCatch({
args <- list(conc = conc_data_interval[[col.conc]], time = conc_data_interval[[col.time]], volume= conc_data_interval[[col.volume]], duration.conc =conc_data_interval[[col.duration.conc]], dose = dose_data_interval[[col.dose]], time.dose = dose_data_interval[[col.time.dose]], duration.dose = dose_data_interval[[col.duration.dose]], route = dose_data_interval[[col.route]], conc.group = conc_data_group[[col.conc]], time.group = conc_data_group[[col.time]], volume.group = conc_data_group[[col.volume]],
duration.conc.group= conc_data_group[[col.duration.conc]], dose.group = dose_data_group[[col.dose]], time.dose.group = dose_data_group[[col.time.dose]], duration.dose.group = dose_data_group[[col.duration.dose]], route.group = dose_data_group[[col.route]], interval = all.intervals[i, , drop = FALSE], options = options)
if (!is.null(col.include_half.life)) {
args$include_half.life <- conc_data_interval[[col.include_half.life]]
}
if (!is.null(col.exclude_half.life)) {
args$exclude_half.life <- conc_data_interval[[col.exclude_half.life]]
}
calculated.interval <- do.call(pk.nca.interval, args)
}, error = function(e) {
e$message <- paste(error.preamble, e$message, sep = “:”)
stop(e)
}), tryCatchList(expr, classes, parentenv, handlers), tryCatchOne(expr, names, parentenv, handlers[[1]]), doTryCatch(return(expr), name, parentenv, handler), do.call(pk.nca.interval, args), (function (conc, time, volume, duration.conc, dose, time.dose, duration.dose, route, conc.group = NULL, time.group = NULL, volume.group = NULL, duration.conc.group = NULL, dose.group = NULL, time.dose.group = NULL, duration.dose.group = NULL, route.group = NULL, include_half.life = NULL, exclude_half.life = NULL,
interval, options = list())
{
if (!is.data.frame(interval)) {
stop("interval mustbe a data.frame")
}
if (nrow(interval) != 1)
stop("interval mustbe a one-row data.frame")
ret <- data.frame(PPTESTCD = NA, PPORRES = NA)[-1, ]
all.intervals <- get.interval.cols()
if (length(dose) == 0) {
dose <- NA
time.dose <- NA
duration.dose <- NA
}
for (n in rev(names(all.intervals))) {
if (interval[[1, n]]) {
for (deps in all.intervals[[n]]$depends) {
interval[1,deps] <- TRUE
}
}
}
for (n in names(all.intervals)) if (interval[[1, n]] & !is.na(all.intervals[[n]]$FUN)) {
call.args <- list()
arglist <- setdiff(names(formals(get(all.intervals[[n]]$FUN))), “…”)
arglist <- stats::setNames(object = as.list(arglist), arglist)
arglist[names(all.intervals[[n]]\(formalsmap)] <- all.intervals[[n]]\)formalsmap
arglist <- arglist[!sapply(arglist, is.null)]
for (arg_formal in names(arglist)) {
arg_mapped <- arglist[[arg_formal]]
if (arg_mapped == “conc”) {
call.args[[arg_formal]] <- conc
}
else if (arg_mapped == “time”) {
call.args[[arg_formal]] <- time - interval$start[1]
}
else if (arg_mapped == “volume”) {
call.args[[arg_formal]] <- volume
}
else if (arg_mapped == “duration.conc”) {
call.args[[arg_formal]] <- duration.conc
}
else if (arg_mapped == “dose”) {
call.args[[arg_formal]] <- dose
}
else if (arg_mapped == “time.dose”) {
call.args[[arg_formal]] <- time.dose - interval$start[1]
}
else if (arg_mapped == “duration.dose”) {
call.args[[arg_formal]] <- duration.dose
}
else if (arg_mapped == “route”) {
call.args[[arg_formal]] <- route
}
else if (arg_mapped == “conc.group”) {
call.args[[arg_formal]] <- conc.group
}
else if (arg_mapped == “time.group”) {
call.args[[arg_formal]] <- time.group
}
else if (arg_mapped == “volume.group”) {
call.args[[arg_formal]] <- volume.group
}
else if (arg_mapped == “duration.conc.group”) {
call.args[[arg_formal]] <- duration.conc.group
}
else if (arg_mapped == “dose.group”) {
call.args[[arg_formal]] <- dose.group
}
else if (arg_mapped == “time.dose.group”) {
call.args[[arg_formal]] <- time.dose.group
}
else if (arg_mapped == “duration.dose.group”) {
call.args[[arg_formal]] <- duration.dose.group
}
else if (arg_mapped == “route.group”) {
call.args[[arg_formal]] <- route.group
}
else if (arg_mapped %in% c(“start”, “end”)) {
call.args[[arg_formal]] <- interval[1, arg_mapped]
}
else if (arg_mapped == “options”) {
call.args[[arg_formal]] <- options
}
else if (any(mask.arg <- ret$PPTESTCD %in% arg_mapped)) {
call.args[[arg_formal]] <- ret$PPORRES[mask.arg]
}
else {
if (class(formals(get(all.intervals[[n]]$FUN))[[arg_formal]]) == “name”) {
arg_text <- if (arg_formal == arg_mapped) {
sprintf(“‘%s’”, arg_formal)
}
else {
sprintf(“‘%s’ mapped to ‘%s’”, arg_formal, arg_mapped)
}
stop(sprintf(“Cannot find argument %s for NCA function ‘%s’”, arg_text, all.intervals[[n]]$FUN))
}
}
}
if (n %in% "half.life") {
if (!is.null(include_half.life)) {
call.args$conc <- call.args$conc[include_half.life]
call.args$time <- call.args$time[include_half.life]
call.args$manually.selected.points <- TRUE
}
else if (!is.null(exclude_half.life)) {
call.args$conc <- call.args$conc[!exclude_half.life]
call.args$time <- call.args$time[!exclude_half.life]
}
}
tmp.result <- do.call(all.intervals[[n]]$FUN, call.args)
exclude_reason <- if(!is.null(attr(tmp.result, “exclude”))) {
attr(tmp.result,“exclude”)
}
else {
NA
}
if (is.data.frame(tmp.result)) {
ret <- rbind(ret, data.frame(PPTESTCD = names(tmp.result), PPORRES = unlist(tmp.result, use.names = FALSE),exclude = exclude_reason,stringsAsFactors = FALSE))
}
else {
ret <- rbind(ret, data.frame(PPTESTCD = n, PPORRES = tmp.result, exclude = exclude_reason,stringsAsFactors= FALSE))
}
}
ret
})(conc = c(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), time = 0:24, volume = c(NA, NA,NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA), duration.conc = c(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), dose = 1, time.dose = 0, duration.dose = 0, route = “extravascular”, conc.group = c(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), time.group = 0:24, volume.group = c(NA,
NA, NA, NA, NA, NA, NA, NA,NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA), duration.conc.group = c(0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), dose.group = 1, time.dose.group = 0, duration.dose.group = 0, route.group = “extravascular”, interval = list(start = 0, end = Inf, auclast = FALSE, aucall = FALSE, aumclast = FALSE, aumcall = FALSE, aucint.last = FALSE, aucint.last.dose = FALSE, aucint.all = FALSE, aucint.all.dose = FALSE, auclast.dn = FALSE,
aucall.dn = FALSE, aumclast.dn = FALSE, aumcall.dn = FALSE, cmax = TRUE, cmin = FALSE, tmax = TRUE, tlast = FALSE, tfirst = FALSE, clast.obs= FALSE,cl.last = FALSE, cl.all = FALSE, f = FALSE, mrt.last = FALSE, mrt.iv.last = FALSE, vss.last = FALSE, vss.iv.last = FALSE, cav = FALSE, ctrough = FALSE, ptr = FALSE, tlag = FALSE, deg.fluc = FALSE, swing = FALSE, ceoi = FALSE, ae = FALSE, clr.last = FALSE, clr.obs = FALSE, clr.pred = FALSE, fe = FALSE, half.life = TRUE, r.squared = FALSE, adj.r.squared = FALSE,
lambda.z = FALSE, lambda.z.time.first = FALSE, lambda.z.n.points = FALSE, clast.pred = FALSE, span.ratio = FALSE, cmax.dn = FALSE, cmin.dn =FALSE, clast.obs.dn = FALSE, clast.pred.dn = FALSE, cav.dn = FALSE, ctrough.dn = FALSE, thalf.eff.last = FALSE, thalf.eff.iv.last = FALSE, kel.last = FALSE, kel.iv.last = FALSE, aucinf.obs = TRUE, aucinf.pred = FALSE, aumcinf.obs = FALSE, aumcinf.pred = FALSE, aucint.inf.obs = FALSE, aucint.inf.obs.dose = FALSE, aucint.inf.pred = FALSE, aucint.inf.pred.dose = FALSE,
aucinf.obs.dn = FALSE, aucinf.pred.dn = FALSE, aumcinf.obs.dn = FALSE, aumcinf.pred.dn = FALSE, aucpext.obs = FALSE,aucpext.pred = FALSE, cl.obs = FALSE, cl.pred = FALSE, mrt.obs = FALSE, mrt.pred = FALSE, mrt.iv.obs = FALSE, mrt.iv.pred = FALSE, mrt.md.obs = FALSE, mrt.md.pred = FALSE, vz.obs = FALSE, vz.pred = FALSE, vss.obs = FALSE, vss.pred = FALSE, vss.iv.obs = FALSE, vss.iv.pred = FALSE, vss.md.obs = FALSE, vss.md.pred = FALSE, vd.obs = FALSE, vd.pred = FALSE, thalf.eff.obs = FALSE, thalf.eff.pred = FALSE,
thalf.eff.iv.obs = FALSE, thalf.eff.iv.pred = FALSE, kel.obs = FALSE, kel.pred = FALSE, kel.iv.obs= FALSE, kel.iv.pred = FALSE, treatment =“Trt 1”,ID = 2), options = list(adj.r.squared.factor = 1e-04, max.missing = 0.5, auc.method = “lin up/log down”, conc.na = “drop”, conc.blq = list(first = “keep”, middle = “drop”, last = “keep”), first.tmax = TRUE, allow.tmax.in.half.life = FALSE, min.hl.points = 3, min.span.ratio = 2, max.aucinf.pext = 20, min.hl.r.squared = 0.9, tau.choices = NA, single.dose.aucs = list(
start = c(0, 0), end = c(24, Inf), auclast = c(TRUE, FALSE), aucall = c(FALSE, FALSE), aumclast =c(FALSE, FALSE), aumcall = c(FALSE, FALSE),aucint.last = c(FALSE, FALSE), aucint.last.dose = c(FALSE, FALSE), aucint.all = c(FALSE, FALSE), aucint.all.dose = c(FALSE, FALSE), auclast.dn = c(FALSE, FALSE), aucall.dn = c(FALSE, FALSE), aumclast.dn = c(FALSE, FALSE), aumcall.dn = c(FALSE, FALSE), cmax = c(FALSE, TRUE), cmin = c(FALSE, FALSE), tmax = c(FALSE, TRUE), tlast = c(FALSE, FALSE), tfirst = c(FALSE,
FALSE), clast.obs = c(FALSE, FALSE), cl.last = c(FALSE, FALSE), cl.all = c(FALSE, FALSE), f = c(FALSE, FALSE), mrt.last = c(FALSE, FALSE), mrt.iv.last= c(FALSE, FALSE), vss.last = c(FALSE, FALSE), vss.iv.last = c(FALSE, FALSE), cav = c(FALSE, FALSE), ctrough = c(FALSE, FALSE), ptr = c(FALSE, FALSE), tlag = c(FALSE, FALSE), deg.fluc = c(FALSE, FALSE), swing = c(FALSE, FALSE), ceoi = c(FALSE, FALSE), ae = c(FALSE, FALSE), clr.last = c(FALSE, FALSE), clr.obs = c(FALSE, FALSE), clr.pred = c(FALSE,
FALSE), fe = c(FALSE, FALSE), half.life = c(FALSE, TRUE), r.squared = c(FALSE, FALSE), adj.r.squared = c(FALSE, FALSE), lambda.z = c(FALSE, FALSE), lambda.z.time.first = c(FALSE, FALSE), lambda.z.n.points = c(FALSE, FALSE), clast.pred = c(FALSE, FALSE), span.ratio = c(FALSE, FALSE), cmax.dn = c(FALSE, FALSE), cmin.dn = c(FALSE, FALSE), clast.obs.dn = c(FALSE, FALSE), clast.pred.dn = c(FALSE, FALSE), cav.dn = c(FALSE, FALSE), ctrough.dn = c(FALSE, FALSE), thalf.eff.last = c(FALSE, FALSE), thalf.eff.iv.last = c(FALSE,
FALSE), kel.last = c(FALSE, FALSE), kel.iv.last = c(FALSE, FALSE), aucinf.obs = c(FALSE, TRUE), aucinf.pred = c(FALSE, FALSE), aumcinf.obs =c(FALSE,FALSE), aumcinf.pred = c(FALSE, FALSE), aucint.inf.obs = c(FALSE, FALSE), aucint.inf.obs.dose = c(FALSE, FALSE), aucint.inf.pred = c(FALSE, FALSE), aucint.inf.pred.dose = c(FALSE, FALSE), aucinf.obs.dn = c(FALSE, FALSE), aucinf.pred.dn = c(FALSE, FALSE), aumcinf.obs.dn = c(FALSE, FALSE), aumcinf.pred.dn = c(FALSE, FALSE), aucpext.obs = c(FALSE,
FALSE), aucpext.pred = c(FALSE, FALSE), cl.obs = c(FALSE, FALSE), cl.pred = c(FALSE, FALSE), mrt.obs = c(FALSE, FALSE), mrt.pred = c(FALSE, FALSE), mrt.iv.obs = c(FALSE, FALSE), mrt.iv.pred = c(FALSE, FALSE), mrt.md.obs = c(FALSE, FALSE), mrt.md.pred = c(FALSE, FALSE), vz.obs = c(FALSE, FALSE), vz.pred = c(FALSE, FALSE), vss.obs = c(FALSE, FALSE), vss.pred = c(FALSE, FALSE), vss.iv.obs = c(FALSE, FALSE), vss.iv.pred = c(FALSE, FALSE), vss.md.obs = c(FALSE, FALSE), vss.md.pred = c(FALSE, FALSE
), vd.obs = c(FALSE, FALSE), vd.pred = c(FALSE, FALSE), thalf.eff.obs = c(FALSE, FALSE), thalf.eff.pred = c(FALSE, FALSE), thalf.eff.iv.obs =c(FALSE,FALSE), thalf.eff.iv.pred = c(FALSE, FALSE), kel.obs = c(FALSE, FALSE), kel.pred = c(FALSE, FALSE), kel.iv.obs = c(FALSE, FALSE), kel.iv.pred = c(FALSE, FALSE)))), do.call(all.intervals[[n]]$FUN, call.args), pk.calc.half.life(conc = c(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), time = c(0, 1, 2, 3, 4, 5, 6, 7, 8,
9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24), tmax = NA, tlast = NA, options = list(adj.r.squared.factor = 1e-04, max.missing =0.5, auc.method = “lin up/log down”, conc.na = “drop”, conc.blq = list(first = “keep”, middle = “drop”, last = “keep”), first.tmax = TRUE, allow.tmax.in.half.life = FALSE, min.hl.points = 3, min.span.ratio = 2, max.aucinf.pext = 20, min.hl.r.squared = 0.9, tau.choices = NA, single.dose.aucs = list(start = c(0, 0), end = c(24, Inf), auclast = c(TRUE, FALSE
), aucall = c(FALSE, FALSE),aumclast = c(FALSE, FALSE), aumcall = c(FALSE, FALSE), aucint.last = c(FALSE, FALSE), aucint.last.dose = c(FALSE, FALSE), aucint.all = c(FALSE, FALSE), aucint.all.dose = c(FALSE, FALSE), auclast.dn = c(FALSE, FALSE), aucall.dn = c(FALSE, FALSE), aumclast.dn = c(FALSE, FALSE), aumcall.dn = c(FALSE, FALSE), cmax = c(FALSE, TRUE), cmin = c(FALSE, FALSE), tmax = c(FALSE, TRUE), tlast = c(FALSE, FALSE), tfirst = c(FALSE, FALSE), clast.obs = c(FALSE, FALSE), cl.last = c(FALSE,
FALSE), cl.all = c(FALSE, FALSE), f = c(FALSE, FALSE), mrt.last = c(FALSE, FALSE), mrt.iv.last = c(FALSE, FALSE), vss.last = c(FALSE, FALSE), vss.iv.last= c(FALSE, FALSE), cav = c(FALSE, FALSE), ctrough = c(FALSE, FALSE), ptr = c(FALSE, FALSE), tlag = c(FALSE, FALSE), deg.fluc = c(FALSE, FALSE), swing = c(FALSE, FALSE), ceoi = c(FALSE, FALSE), ae = c(FALSE, FALSE), clr.last = c(FALSE, FALSE), clr.obs = c(FALSE, FALSE), clr.pred = c(FALSE, FALSE), fe = c(FALSE, FALSE), half.life = c(FALSE, TRUE),
r.squared = c(FALSE, FALSE), adj.r.squared = c(FALSE, FALSE), lambda.z = c(FALSE, FALSE), lambda.z.time.first = c(FALSE, FALSE), lambda.z.n.points = c(FALSE, FALSE), clast.pred = c(FALSE, FALSE), span.ratio = c(FALSE, FALSE), cmax.dn = c(FALSE, FALSE), cmin.dn = c(FALSE, FALSE), clast.obs.dn = c(FALSE, FALSE), clast.pred.dn = c(FALSE, FALSE), cav.dn = c(FALSE, FALSE), ctrough.dn = c(FALSE, FALSE), thalf.eff.last = c(FALSE, FALSE), thalf.eff.iv.last = c(FALSE, FALSE), kel.last = c(FALSE, FALSE
), kel.iv.last = c(FALSE, FALSE), aucinf.obs = c(FALSE, TRUE), aucinf.pred = c(FALSE, FALSE), aumcinf.obs = c(FALSE,FALSE), aumcinf.pred = c(FALSE, FALSE), aucint.inf.obs = c(FALSE, FALSE), aucint.inf.obs.dose = c(FALSE, FALSE), aucint.inf.pred = c(FALSE, FALSE), aucint.inf.pred.dose = c(FALSE, FALSE), aucinf.obs.dn = c(FALSE, FALSE), aucinf.pred.dn = c(FALSE, FALSE), aumcinf.obs.dn = c(FALSE, FALSE), aumcinf.pred.dn = c(FALSE, FALSE), aucpext.obs = c(FALSE, FALSE), aucpext.pred = c(FALSE, FALSE
), cl.obs = c(FALSE, FALSE), cl.pred = c(FALSE, FALSE), mrt.obs = c(FALSE, FALSE), mrt.pred = c(FALSE, FALSE), mrt.iv.obs = c(FALSE, FALSE),mrt.iv.pred = c(FALSE, FALSE), mrt.md.obs = c(FALSE, FALSE), mrt.md.pred = c(FALSE, FALSE), vz.obs = c(FALSE, FALSE), vz.pred = c(FALSE, FALSE), vss.obs = c(FALSE, FALSE), vss.pred = c(FALSE, FALSE), vss.iv.obs = c(FALSE, FALSE), vss.iv.pred = c(FALSE, FALSE), vss.md.obs = c(FALSE, FALSE), vss.md.pred = c(FALSE, FALSE), vd.obs = c(FALSE, FALSE), vd.pred = c(FALSE,
FALSE), thalf.eff.obs =c(FALSE, FALSE), thalf.eff.pred = c(FALSE, FALSE), thalf.eff.iv.obs = c(FALSE, FALSE), thalf.eff.iv.pred = c(FALSE, FALSE), kel.obs = c(FALSE, FALSE), kel.pred = c(FALSE, FALSE), kel.iv.obs = c(FALSE, FALSE), kel.iv.pred = c(FALSE, FALSE)))), warning(attr(ret, “exclude”))), start_frame = 74, end_frame = 86, test = “PKNCAresults has exclude, when applicable”), list(message = “all(…) isn’t true.”, srcref = c(102, 3, 111, 3, 3, 3, 102, 111), expectation_calls = list(expect_true(all(myresult_df$PPTESTCD %in%
c(“adj.r.squared”, "aucinf.obs“,”auclast“,”clast.obs“,”clast.pred“,”cmax“,”half.life“,”lambda.z“,”lambda.z.n.points“,”lambda.z.time.first“,”r.squared“,”span.ratio“,”tlast“,”tmax“)), info =”verify that only expected results are present“)), call = list(expect_true(all(myresult_df$PPTESTCD %in% c(”adj.r.squared“,”aucinf.obs“,”auclast“,”clast.obs“,”clast.pred“,”cmax“,”half.life“,”lambda.z“,”lambda.z.n.points“,”lambda.z.time.first“,”r.squared“,”span.ratio“,”tlast“,”tmax")),
info = "verify that onlyexpected results are present")), start_frame = 74, end_frame = 74, test ="PKNCAresults hasexclude, when applicable"), list(message = “unique(…) not equal to "Too few points for half-life calculation (min.hl.points=3 with only 0 points)".”, srcref = c(112, 3, 123, 3, 3, 3, 112, 123), expectation_calls = list(expect_equal(unique(myresult_df\(exclude[myresult_df\)ID == 2 & myresult_df$PPTESTCD %in% c(“lambda.z”, “r.squared”, “adj.r.squared”, “lambda.z.time.first”,
“lambda.z.n.points”, "clast.pred“,”half.life“,”span.ratio“)]),”Too few points for half-life calculation (min.hl.points=3 with only 0 points)", info= “exclusions are propogated to results”)), call = list(expect_equal(unique(myresult_df\(exclude[myresult_df\)ID == 2 & myresult_df$PPTESTCD %in% c(“lambda.z”, “r.squared”, “adj.r.squared”, “lambda.z.time.first”, “lambda.z.n.points”, “clast.pred”, “half.life”, “span.ratio”)]), “Too few points for half-life calculation (min.hl.points=3 with only 0 points)”,
info = "exclusions are propogated to results“)), start_frame = 74, end_frame = 74, test =”PKNCAresults has exclude,when applicable"), list(message =“unique(…) not equal to NA.”, srcref = c(124, 3, 136, 3, 3, 3, 124, 136), expectation_calls = list(expect_equal(unique(myresult_df\(exclude[!(myresult_df\)ID == 2 & myresult_df$PPTESTCD %in% c(“lambda.z”, “r.squared”, “adj.r.squared”, “lambda.z.time.first”, “lambda.z.n.points”, “clast.pred”, “half.life”, “span.ratio”))]), NA, info = “exclusions are propogated to results only when applicable”)),
call = list(expect_equal(unique(myresult_df\(exclude[!(myresult_df\)ID == 2 & myresult_df$PPTESTCD %in% c(“lambda.z”,“r.squared”, "adj.r.squared“,”lambda.z.time.first“,”lambda.z.n.points“,”clast.pred“,”half.life“,”span.ratio“))]), NA, info =”exclusions are propogated to results only when applicable“)), start_frame = 74, end_frame = 74, test =”PKNCAresults has exclude, when applicable"))
test-class-PKNCAresults.RPKNCAresults summary906list(list(message = “is.data.frame(mysummary) isn’t true.”, srcref = c(151, 3, 151, 39, 3, 39, 151, 151), expectation_calls = list(expect_true(is.data.frame(mysummary))), call = list(expect_true(is.data.frame(mysummary))), start_frame = 74, end_frame = 74, test = “PKNCAresults summary”), list(message = “mysummary not equal to as_summary_PKNCAresults(…).”, srcref = c(152, 3, 170, 3, 3, 3, 152, 170), expectation_calls = list(expect_equal(mysummary, as_summary_PKNCAresults(data.frame(start = 0,
end = c(24, Inf), treatment = “Trt 1”, N = “2”, auclast = c(“13.8 [2.51]”, “.”), cmax = c(“.”, "0.970 [4.29]"), tmax= c(“.”, "3.00 [2.00, 4.00]"), half.life = c(“.”, “14.2 [2.79]”), aucinf.obs = c(“.”, “20.5 [6.84]”), stringsAsFactors = FALSE), caption = “auclast, cmax, aucinf.obs: geometric mean and geometric coefficient of variation; tmax: median and range; half.life: arithmetic mean and standard deviation”), info = “simple summary of PKNCAresults performs as expected”)), call = list(expect_equal(mysummary,
as_summary_PKNCAresults(data.frame(start = 0, end = c(24, Inf), treatment = “Trt 1”, N = “2”, auclast = c("13.8 [2.51]“,”.“), cmax = c(”.","0.970 [4.29]“), tmax = c(”.“,”3.00 [2.00, 4.00]“), half.life = c(”.“,”14.2 [2.79]“), aucinf.obs = c(”.“,”20.5 [6.84]“), stringsAsFactors = FALSE), caption =”auclast, cmax, aucinf.obs: geometric mean and geometric coefficient of variation; tmax: median and range; half.life: arithmetic mean and standard deviation“), info =”simple summary of PKNCAresults performs as expected")),
start_frame = 74, end_frame = 74, test = “PKNCAresults summary”), list(message = "Too few points for half-life calculation (min.hl.points=3 with only0 points)", srcref = c(182, 3, 182, 28, 3, 28, 182, 182), call = list(pk.nca(mydata), parallel::mclapply(X = splitdata[mask_has_interval], FUN = pk.nca.intervals, options = data$options), lapply(X, FUN, …), FUN(X[[i]], …), tryCatch({
args <- list(conc = conc_data_interval[[col.conc]], time = conc_data_interval[[col.time]], volume= conc_data_interval[[col.volume]], duration.conc =conc_data_interval[[col.duration.conc]], dose = dose_data_interval[[col.dose]], time.dose = dose_data_interval[[col.time.dose]], duration.dose = dose_data_interval[[col.duration.dose]], route = dose_data_interval[[col.route]], conc.group = conc_data_group[[col.conc]], time.group = conc_data_group[[col.time]], volume.group = conc_data_group[[col.volume]],
duration.conc.group= conc_data_group[[col.duration.conc]], dose.group = dose_data_group[[col.dose]], time.dose.group = dose_data_group[[col.time.dose]], duration.dose.group = dose_data_group[[col.duration.dose]], route.group = dose_data_group[[col.route]], interval = all.intervals[i, , drop = FALSE], options = options)
if (!is.null(col.include_half.life)) {
args$include_half.life <- conc_data_interval[[col.include_half.life]]
}
if (!is.null(col.exclude_half.life)) {
args$exclude_half.life <- conc_data_interval[[col.exclude_half.life]]
}
calculated.interval <- do.call(pk.nca.interval, args)
}, error = function(e) {
e$message <- paste(error.preamble, e$message, sep = “:”)
stop(e)
}), tryCatchList(expr, classes, parentenv, handlers), tryCatchOne(expr, names, parentenv, handlers[[1]]), doTryCatch(return(expr), name, parentenv, handler), do.call(pk.nca.interval, args), (function (conc, time, volume, duration.conc, dose, time.dose, duration.dose, route, conc.group = NULL, time.group = NULL, volume.group = NULL, duration.conc.group = NULL, dose.group = NULL, time.dose.group = NULL, duration.dose.group = NULL, route.group = NULL, include_half.life = NULL, exclude_half.life = NULL,
interval, options = list())
{
if (!is.data.frame(interval)) {
stop("interval mustbe a data.frame")
}
if (nrow(interval) != 1)
stop("interval mustbe a one-row data.frame")
ret <- data.frame(PPTESTCD = NA, PPORRES = NA)[-1, ]
all.intervals <- get.interval.cols()
if (length(dose) == 0) {
dose <- NA
time.dose <- NA
duration.dose <- NA
}
for (n in rev(names(all.intervals))) {
if (interval[[1, n]]) {
for (deps in all.intervals[[n]]$depends) {
interval[1,deps] <- TRUE
}
}
}
for (n in names(all.intervals)) if (interval[[1, n]] & !is.na(all.intervals[[n]]$FUN)) {
call.args <- list()
arglist <- setdiff(names(formals(get(all.intervals[[n]]$FUN))), “…”)
arglist <- stats::setNames(object = as.list(arglist), arglist)
arglist[names(all.intervals[[n]]\(formalsmap)] <- all.intervals[[n]]\)formalsmap
arglist <- arglist[!sapply(arglist, is.null)]
for (arg_formal in names(arglist)) {
arg_mapped <- arglist[[arg_formal]]
if (arg_mapped == “conc”) {
call.args[[arg_formal]] <- conc
}
else if (arg_mapped == “time”) {
call.args[[arg_formal]] <- time - interval$start[1]
}
else if (arg_mapped == “volume”) {
call.args[[arg_formal]] <- volume
}
else if (arg_mapped == “duration.conc”) {
call.args[[arg_formal]] <- duration.conc
}
else if (arg_mapped == “dose”) {
call.args[[arg_formal]] <- dose
}
else if (arg_mapped == “time.dose”) {
call.args[[arg_formal]] <- time.dose - interval$start[1]
}
else if (arg_mapped == “duration.dose”) {
call.args[[arg_formal]] <- duration.dose
}
else if (arg_mapped == “route”) {
call.args[[arg_formal]] <- route
}
else if (arg_mapped == “conc.group”) {
call.args[[arg_formal]] <- conc.group
}
else if (arg_mapped == “time.group”) {
call.args[[arg_formal]] <- time.group
}
else if (arg_mapped == “volume.group”) {
call.args[[arg_formal]] <- volume.group
}
else if (arg_mapped == “duration.conc.group”) {
call.args[[arg_formal]] <- duration.conc.group
}
else if (arg_mapped == “dose.group”) {
call.args[[arg_formal]] <- dose.group
}
else if (arg_mapped == “time.dose.group”) {
call.args[[arg_formal]] <- time.dose.group
}
else if (arg_mapped == “duration.dose.group”) {
call.args[[arg_formal]] <- duration.dose.group
}
else if (arg_mapped == “route.group”) {
call.args[[arg_formal]] <- route.group
}
else if (arg_mapped %in% c(“start”, “end”)) {
call.args[[arg_formal]] <- interval[1, arg_mapped]
}
else if (arg_mapped == “options”) {
call.args[[arg_formal]] <- options
}
else if (any(mask.arg <- ret$PPTESTCD %in% arg_mapped)) {
call.args[[arg_formal]] <- ret$PPORRES[mask.arg]
}
else {
if (class(formals(get(all.intervals[[n]]$FUN))[[arg_formal]]) == “name”) {
arg_text <- if (arg_formal == arg_mapped) {
sprintf(“‘%s’”, arg_formal)
}
else {
sprintf(“‘%s’ mapped to ‘%s’”, arg_formal, arg_mapped)
}
stop(sprintf(“Cannot find argument %s for NCA function ‘%s’”, arg_text, all.intervals[[n]]$FUN))
}
}
}
if (n %in% "half.life") {
if (!is.null(include_half.life)) {
call.args$conc <- call.args$conc[include_half.life]
call.args$time <- call.args$time[include_half.life]
call.args$manually.selected.points <- TRUE
}
else if (!is.null(exclude_half.life)) {
call.args$conc <- call.args$conc[!exclude_half.life]
call.args$time <- call.args$time[!exclude_half.life]
}
}
tmp.result <- do.call(all.intervals[[n]]$FUN, call.args)
exclude_reason <- if(!is.null(attr(tmp.result, “exclude”))) {
attr(tmp.result,“exclude”)
}
else {
NA
}
if (is.data.frame(tmp.result)) {
ret <- rbind(ret, data.frame(PPTESTCD = names(tmp.result), PPORRES = unlist(tmp.result, use.names = FALSE),exclude = exclude_reason,stringsAsFactors = FALSE))
}
else {
ret <- rbind(ret, data.frame(PPTESTCD = n, PPORRES = tmp.result, exclude = exclude_reason,stringsAsFactors= FALSE))
}
}
ret
})(conc = c(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), time = 0:24, volume = c(NA, NA,NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA), duration.conc = c(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), dose = 1, time.dose = 0, duration.dose = 0, route = “extravascular”, conc.group = c(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), time.group = 0:24, volume.group = c(NA,
NA, NA, NA, NA, NA, NA, NA,NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA), duration.conc.group = c(0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), dose.group = 1, time.dose.group = 0, duration.dose.group = 0, route.group = “extravascular”, interval = list(start = 0, end = Inf, auclast = FALSE, aucall = FALSE, aumclast = FALSE, aumcall = FALSE, aucint.last = FALSE, aucint.last.dose = FALSE, aucint.all = FALSE, aucint.all.dose = FALSE, auclast.dn = FALSE,
aucall.dn = FALSE, aumclast.dn = FALSE, aumcall.dn = FALSE, cmax = TRUE, cmin = FALSE, tmax = TRUE, tlast = FALSE, tfirst = FALSE, clast.obs= FALSE,cl.last = FALSE, cl.all = FALSE, f = FALSE, mrt.last = FALSE, mrt.iv.last = FALSE, vss.last = FALSE, vss.iv.last = FALSE, cav = FALSE, ctrough = FALSE, ptr = FALSE, tlag = FALSE, deg.fluc = FALSE, swing = FALSE, ceoi = FALSE, ae = FALSE, clr.last = FALSE, clr.obs = FALSE, clr.pred = FALSE, fe = FALSE, half.life = TRUE, r.squared = FALSE, adj.r.squared = FALSE,
lambda.z = FALSE, lambda.z.time.first = FALSE, lambda.z.n.points = FALSE, clast.pred = FALSE, span.ratio = FALSE, cmax.dn = FALSE, cmin.dn =FALSE, clast.obs.dn = FALSE, clast.pred.dn = FALSE, cav.dn = FALSE, ctrough.dn = FALSE, thalf.eff.last = FALSE, thalf.eff.iv.last = FALSE, kel.last = FALSE, kel.iv.last = FALSE, aucinf.obs = TRUE, aucinf.pred = FALSE, aumcinf.obs = FALSE, aumcinf.pred = FALSE, aucint.inf.obs = FALSE, aucint.inf.obs.dose = FALSE, aucint.inf.pred = FALSE, aucint.inf.pred.dose = FALSE,
aucinf.obs.dn = FALSE, aucinf.pred.dn = FALSE, aumcinf.obs.dn = FALSE, aumcinf.pred.dn = FALSE, aucpext.obs = FALSE,aucpext.pred = FALSE, cl.obs = FALSE, cl.pred = FALSE, mrt.obs = FALSE, mrt.pred = FALSE, mrt.iv.obs = FALSE, mrt.iv.pred = FALSE, mrt.md.obs = FALSE, mrt.md.pred = FALSE, vz.obs = FALSE, vz.pred = FALSE, vss.obs = FALSE, vss.pred = FALSE, vss.iv.obs = FALSE, vss.iv.pred = FALSE, vss.md.obs = FALSE, vss.md.pred = FALSE, vd.obs = FALSE, vd.pred = FALSE, thalf.eff.obs = FALSE, thalf.eff.pred = FALSE,
thalf.eff.iv.obs = FALSE, thalf.eff.iv.pred = FALSE, kel.obs = FALSE, kel.pred = FALSE, kel.iv.obs= FALSE, kel.iv.pred = FALSE, treatment =“Trt 1”,ID = 2), options = list(adj.r.squared.factor = 1e-04, max.missing = 0.5, auc.method = “lin up/log down”, conc.na = “drop”, conc.blq = list(first = “keep”, middle = “drop”, last = “keep”), first.tmax = TRUE, allow.tmax.in.half.life = FALSE, min.hl.points = 3, min.span.ratio = 2, max.aucinf.pext = 20, min.hl.r.squared = 0.9, tau.choices = NA, single.dose.aucs = list(
start = c(0, 0), end = c(24, Inf), auclast = c(TRUE, FALSE), aucall = c(FALSE, FALSE), aumclast =c(FALSE, FALSE), aumcall = c(FALSE, FALSE),aucint.last = c(FALSE, FALSE), aucint.last.dose = c(FALSE, FALSE), aucint.all = c(FALSE, FALSE), aucint.all.dose = c(FALSE, FALSE), auclast.dn = c(FALSE, FALSE), aucall.dn = c(FALSE, FALSE), aumclast.dn = c(FALSE, FALSE), aumcall.dn = c(FALSE, FALSE), cmax = c(FALSE, TRUE), cmin = c(FALSE, FALSE), tmax = c(FALSE, TRUE), tlast = c(FALSE, FALSE), tfirst = c(FALSE,
FALSE), clast.obs = c(FALSE, FALSE), cl.last = c(FALSE, FALSE), cl.all = c(FALSE, FALSE), f = c(FALSE, FALSE), mrt.last = c(FALSE, FALSE), mrt.iv.last= c(FALSE, FALSE), vss.last = c(FALSE, FALSE), vss.iv.last = c(FALSE, FALSE), cav = c(FALSE, FALSE), ctrough = c(FALSE, FALSE), ptr = c(FALSE, FALSE), tlag = c(FALSE, FALSE), deg.fluc = c(FALSE, FALSE), swing = c(FALSE, FALSE), ceoi = c(FALSE, FALSE), ae = c(FALSE, FALSE), clr.last = c(FALSE, FALSE), clr.obs = c(FALSE, FALSE), clr.pred = c(FALSE,
FALSE), fe = c(FALSE, FALSE), half.life = c(FALSE, TRUE), r.squared = c(FALSE, FALSE), adj.r.squared = c(FALSE, FALSE), lambda.z = c(FALSE, FALSE), lambda.z.time.first = c(FALSE, FALSE), lambda.z.n.points = c(FALSE, FALSE), clast.pred = c(FALSE, FALSE), span.ratio = c(FALSE, FALSE), cmax.dn = c(FALSE, FALSE), cmin.dn = c(FALSE, FALSE), clast.obs.dn = c(FALSE, FALSE), clast.pred.dn = c(FALSE, FALSE), cav.dn = c(FALSE, FALSE), ctrough.dn = c(FALSE, FALSE), thalf.eff.last = c(FALSE, FALSE), thalf.eff.iv.last = c(FALSE,
FALSE), kel.last = c(FALSE, FALSE), kel.iv.last = c(FALSE, FALSE), aucinf.obs = c(FALSE, TRUE), aucinf.pred = c(FALSE, FALSE), aumcinf.obs =c(FALSE,FALSE), aumcinf.pred = c(FALSE, FALSE), aucint.inf.obs = c(FALSE, FALSE), aucint.inf.obs.dose = c(FALSE, FALSE), aucint.inf.pred = c(FALSE, FALSE), aucint.inf.pred.dose = c(FALSE, FALSE), aucinf.obs.dn = c(FALSE, FALSE), aucinf.pred.dn = c(FALSE, FALSE), aumcinf.obs.dn = c(FALSE, FALSE), aumcinf.pred.dn = c(FALSE, FALSE), aucpext.obs = c(FALSE,
FALSE), aucpext.pred = c(FALSE, FALSE), cl.obs = c(FALSE, FALSE), cl.pred = c(FALSE, FALSE), mrt.obs = c(FALSE, FALSE), mrt.pred = c(FALSE, FALSE), mrt.iv.obs = c(FALSE, FALSE), mrt.iv.pred = c(FALSE, FALSE), mrt.md.obs = c(FALSE, FALSE), mrt.md.pred = c(FALSE, FALSE), vz.obs = c(FALSE, FALSE), vz.pred = c(FALSE, FALSE), vss.obs = c(FALSE, FALSE), vss.pred = c(FALSE, FALSE), vss.iv.obs = c(FALSE, FALSE), vss.iv.pred = c(FALSE, FALSE), vss.md.obs = c(FALSE, FALSE), vss.md.pred = c(FALSE, FALSE
), vd.obs = c(FALSE, FALSE), vd.pred = c(FALSE, FALSE), thalf.eff.obs = c(FALSE, FALSE), thalf.eff.pred = c(FALSE, FALSE), thalf.eff.iv.obs =c(FALSE,FALSE), thalf.eff.iv.pred = c(FALSE, FALSE), kel.obs = c(FALSE, FALSE), kel.pred = c(FALSE, FALSE), kel.iv.obs = c(FALSE, FALSE), kel.iv.pred = c(FALSE, FALSE)))), do.call(all.intervals[[n]]$FUN, call.args), pk.calc.half.life(conc = c(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), time = c(0, 1, 2, 3, 4, 5, 6, 7, 8,
9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24), tmax = NA, tlast = NA, options = list(adj.r.squared.factor = 1e-04, max.missing =0.5, auc.method = “lin up/log down”, conc.na = “drop”, conc.blq = list(first = “keep”, middle = “drop”, last = “keep”), first.tmax = TRUE, allow.tmax.in.half.life = FALSE, min.hl.points = 3, min.span.ratio = 2, max.aucinf.pext = 20, min.hl.r.squared = 0.9, tau.choices = NA, single.dose.aucs = list(start = c(0, 0), end = c(24, Inf), auclast = c(TRUE, FALSE
), aucall = c(FALSE, FALSE),aumclast = c(FALSE, FALSE), aumcall = c(FALSE, FALSE), aucint.last = c(FALSE, FALSE), aucint.last.dose = c(FALSE, FALSE), aucint.all = c(FALSE, FALSE), aucint.all.dose = c(FALSE, FALSE), auclast.dn = c(FALSE, FALSE), aucall.dn = c(FALSE, FALSE), aumclast.dn = c(FALSE, FALSE), aumcall.dn = c(FALSE, FALSE), cmax = c(FALSE, TRUE), cmin = c(FALSE, FALSE), tmax = c(FALSE, TRUE), tlast = c(FALSE, FALSE), tfirst = c(FALSE, FALSE), clast.obs = c(FALSE, FALSE), cl.last = c(FALSE,
FALSE), cl.all = c(FALSE, FALSE), f = c(FALSE, FALSE), mrt.last = c(FALSE, FALSE), mrt.iv.last = c(FALSE, FALSE), vss.last = c(FALSE, FALSE), vss.iv.last= c(FALSE, FALSE), cav = c(FALSE, FALSE), ctrough = c(FALSE, FALSE), ptr = c(FALSE, FALSE), tlag = c(FALSE, FALSE), deg.fluc = c(FALSE, FALSE), swing = c(FALSE, FALSE), ceoi = c(FALSE, FALSE), ae = c(FALSE, FALSE), clr.last = c(FALSE, FALSE), clr.obs = c(FALSE, FALSE), clr.pred = c(FALSE, FALSE), fe = c(FALSE, FALSE), half.life = c(FALSE, TRUE),
r.squared = c(FALSE, FALSE), adj.r.squared = c(FALSE, FALSE), lambda.z = c(FALSE, FALSE), lambda.z.time.first = c(FALSE, FALSE), lambda.z.n.points = c(FALSE, FALSE), clast.pred = c(FALSE, FALSE), span.ratio = c(FALSE, FALSE), cmax.dn = c(FALSE, FALSE), cmin.dn = c(FALSE, FALSE), clast.obs.dn = c(FALSE, FALSE), clast.pred.dn = c(FALSE, FALSE), cav.dn = c(FALSE, FALSE), ctrough.dn = c(FALSE, FALSE), thalf.eff.last = c(FALSE, FALSE), thalf.eff.iv.last = c(FALSE, FALSE), kel.last = c(FALSE, FALSE
), kel.iv.last = c(FALSE, FALSE), aucinf.obs = c(FALSE, TRUE), aucinf.pred = c(FALSE, FALSE), aumcinf.obs = c(FALSE,FALSE), aumcinf.pred = c(FALSE, FALSE), aucint.inf.obs = c(FALSE, FALSE), aucint.inf.obs.dose = c(FALSE, FALSE), aucint.inf.pred = c(FALSE, FALSE), aucint.inf.pred.dose = c(FALSE, FALSE), aucinf.obs.dn = c(FALSE, FALSE), aucinf.pred.dn = c(FALSE, FALSE), aumcinf.obs.dn = c(FALSE, FALSE), aumcinf.pred.dn = c(FALSE, FALSE), aucpext.obs = c(FALSE, FALSE), aucpext.pred = c(FALSE, FALSE
), cl.obs = c(FALSE, FALSE), cl.pred = c(FALSE, FALSE), mrt.obs = c(FALSE, FALSE), mrt.pred = c(FALSE, FALSE), mrt.iv.obs = c(FALSE, FALSE),mrt.iv.pred = c(FALSE, FALSE), mrt.md.obs = c(FALSE, FALSE), mrt.md.pred = c(FALSE, FALSE), vz.obs = c(FALSE, FALSE), vz.pred = c(FALSE, FALSE), vss.obs = c(FALSE, FALSE), vss.pred = c(FALSE, FALSE), vss.iv.obs = c(FALSE, FALSE), vss.iv.pred = c(FALSE, FALSE), vss.md.obs = c(FALSE, FALSE), vss.md.pred = c(FALSE, FALSE), vd.obs = c(FALSE, FALSE), vd.pred = c(FALSE,
FALSE), thalf.eff.obs =c(FALSE, FALSE), thalf.eff.pred = c(FALSE, FALSE), thalf.eff.iv.obs = c(FALSE, FALSE), thalf.eff.iv.pred = c(FALSE, FALSE), kel.obs = c(FALSE, FALSE), kel.pred = c(FALSE, FALSE), kel.iv.obs = c(FALSE, FALSE), kel.iv.pred = c(FALSE, FALSE)))), warning(attr(ret, “exclude”))), start_frame = 74, end_frame = 86, test = “PKNCAresults summary”), list(message = “mysummary not equal to as_summary_PKNCAresults(…).”, srcref = c(184, 3, 202, 3, 3, 3, 184, 202), expectation_calls = list(
expect_equal(mysummary,as_summary_PKNCAresults(data.frame(start = 0, end = c(24, Inf), treatment= “Trt 1”, N = “2”, auclast = c(“13.5 [NC]”, “.”), cmax = c(“.”, “1.00 [NC]”), tmax = c(“.”, “4.00 [4.00, 4.00]”), half.life = c(“.”, “16.1 [NC]”), aucinf.obs = c(“.”, “21.5 [NC]”), stringsAsFactors = FALSE), caption = “auclast, cmax, aucinf.obs: geometric mean and geometric coefficient of variation; tmax: median and range; half.life: arithmetic mean and standard deviation”), info = “summary of PKNCAresults with some missing values results in NA for spread”)),
call = list(expect_equal(mysummary, as_summary_PKNCAresults(data.frame(start = 0, end = c(24, Inf), treatment = "Trt1“, N =”2", auclast = c("13.5 [NC]“,”.“), cmax = c(”.“,”1.00 [NC]“), tmax = c(”.“,”4.00 [4.00, 4.00]“), half.life = c(”.“,”16.1 [NC]“), aucinf.obs = c(”.“,”21.5 [NC]“), stringsAsFactors = FALSE), caption =”auclast, cmax, aucinf.obs: geometric mean and geometric coefficient of variation; tmax: median and range; half.life: arithmetic mean and standard deviation“), info =”summary of PKNCAresults with some missing values results in NA for spread")),
start_frame = 74, end_frame = 74, test = “PKNCAresults summary”), list(message = "Too few points for half-life calculation (min.hl.points=3 with only0 points)", srcref = c(214, 3, 214, 28, 3, 28, 214, 214), call = list(pk.nca(mydata), parallel::mclapply(X = splitdata[mask_has_interval], FUN = pk.nca.intervals, options = data$options), lapply(X, FUN, …), FUN(X[[i]], …), tryCatch({
args <- list(conc = conc_data_interval[[col.conc]], time = conc_data_interval[[col.time]], volume= conc_data_interval[[col.volume]], duration.conc =conc_data_interval[[col.duration.conc]], dose = dose_data_interval[[col.dose]], time.dose = dose_data_interval[[col.time.dose]], duration.dose = dose_data_interval[[col.duration.dose]], route = dose_data_interval[[col.route]], conc.group = conc_data_group[[col.conc]], time.group = conc_data_group[[col.time]], volume.group = conc_data_group[[col.volume]],
duration.conc.group= conc_data_group[[col.duration.conc]], dose.group = dose_data_group[[col.dose]], time.dose.group = dose_data_group[[col.time.dose]], duration.dose.group = dose_data_group[[col.duration.dose]], route.group = dose_data_group[[col.route]], interval = all.intervals[i, , drop = FALSE], options = options)
if (!is.null(col.include_half.life)) {
args$include_half.life <- conc_data_interval[[col.include_half.life]]
}
if (!is.null(col.exclude_half.life)) {
args$exclude_half.life <- conc_data_interval[[col.exclude_half.life]]
}
calculated.interval <- do.call(pk.nca.interval, args)
}, error = function(e) {
e$message <- paste(error.preamble, e$message, sep = “:”)
stop(e)
}), tryCatchList(expr, classes, parentenv, handlers), tryCatchOne(expr, names, parentenv, handlers[[1]]), doTryCatch(return(expr), name, parentenv, handler), do.call(pk.nca.interval, args), (function (conc, time, volume, duration.conc, dose, time.dose, duration.dose, route, conc.group = NULL, time.group = NULL, volume.group = NULL, duration.conc.group = NULL, dose.group = NULL, time.dose.group = NULL, duration.dose.group = NULL, route.group = NULL, include_half.life = NULL, exclude_half.life = NULL,
interval, options = list())
{
if (!is.data.frame(interval)) {
stop("interval mustbe a data.frame")
}
if (nrow(interval) != 1)
stop("interval mustbe a one-row data.frame")
ret <- data.frame(PPTESTCD = NA, PPORRES = NA)[-1, ]
all.intervals <- get.interval.cols()
if (length(dose) == 0) {
dose <- NA
time.dose <- NA
duration.dose <- NA
}
for (n in rev(names(all.intervals))) {
if (interval[[1, n]]) {
for (deps in all.intervals[[n]]$depends) {
interval[1,deps] <- TRUE
}
}
}
for (n in names(all.intervals)) if (interval[[1, n]] & !is.na(all.intervals[[n]]$FUN)) {
call.args <- list()
arglist <- setdiff(names(formals(get(all.intervals[[n]]$FUN))), “…”)
arglist <- stats::setNames(object = as.list(arglist), arglist)
arglist[names(all.intervals[[n]]\(formalsmap)] <- all.intervals[[n]]\)formalsmap
arglist <- arglist[!sapply(arglist, is.null)]
for (arg_formal in names(arglist)) {
arg_mapped <- arglist[[arg_formal]]
if (arg_mapped == “conc”) {
call.args[[arg_formal]] <- conc
}
else if (arg_mapped == “time”) {
call.args[[arg_formal]] <- time - interval$start[1]
}
else if (arg_mapped == “volume”) {
call.args[[arg_formal]] <- volume
}
else if (arg_mapped == “duration.conc”) {
call.args[[arg_formal]] <- duration.conc
}
else if (arg_mapped == “dose”) {
call.args[[arg_formal]] <- dose
}
else if (arg_mapped == “time.dose”) {
call.args[[arg_formal]] <- time.dose - interval$start[1]
}
else if (arg_mapped == “duration.dose”) {
call.args[[arg_formal]] <- duration.dose
}
else if (arg_mapped == “route”) {
call.args[[arg_formal]] <- route
}
else if (arg_mapped == “conc.group”) {
call.args[[arg_formal]] <- conc.group
}
else if (arg_mapped == “time.group”) {
call.args[[arg_formal]] <- time.group
}
else if (arg_mapped == “volume.group”) {
call.args[[arg_formal]] <- volume.group
}
else if (arg_mapped == “duration.conc.group”) {
call.args[[arg_formal]] <- duration.conc.group
}
else if (arg_mapped == “dose.group”) {
call.args[[arg_formal]] <- dose.group
}
else if (arg_mapped == “time.dose.group”) {
call.args[[arg_formal]] <- time.dose.group
}
else if (arg_mapped == “duration.dose.group”) {
call.args[[arg_formal]] <- duration.dose.group
}
else if (arg_mapped == “route.group”) {
call.args[[arg_formal]] <- route.group
}
else if (arg_mapped %in% c(“start”, “end”)) {
call.args[[arg_formal]] <- interval[1, arg_mapped]
}
else if (arg_mapped == “options”) {
call.args[[arg_formal]] <- options
}
else if (any(mask.arg <- ret$PPTESTCD %in% arg_mapped)) {
call.args[[arg_formal]] <- ret$PPORRES[mask.arg]
}
else {
if (class(formals(get(all.intervals[[n]]$FUN))[[arg_formal]]) == “name”) {
arg_text <- if (arg_formal == arg_mapped) {
sprintf(“‘%s’”, arg_formal)
}
else {
sprintf(“‘%s’ mapped to ‘%s’”, arg_formal, arg_mapped)
}
stop(sprintf(“Cannot find argument %s for NCA function ‘%s’”, arg_text, all.intervals[[n]]$FUN))
}
}
}
if (n %in% "half.life") {
if (!is.null(include_half.life)) {
call.args$conc <- call.args$conc[include_half.life]
call.args$time <- call.args$time[include_half.life]
call.args$manually.selected.points <- TRUE
}
else if (!is.null(exclude_half.life)) {
call.args$conc <- call.args$conc[!exclude_half.life]
call.args$time <- call.args$time[!exclude_half.life]
}
}
tmp.result <- do.call(all.intervals[[n]]$FUN, call.args)
exclude_reason <- if(!is.null(attr(tmp.result, “exclude”))) {
attr(tmp.result,“exclude”)
}
else {
NA
}
if (is.data.frame(tmp.result)) {
ret <- rbind(ret, data.frame(PPTESTCD = names(tmp.result), PPORRES = unlist(tmp.result, use.names = FALSE),exclude = exclude_reason,stringsAsFactors = FALSE))
}
else {
ret <- rbind(ret, data.frame(PPTESTCD = n, PPORRES = tmp.result, exclude = exclude_reason,stringsAsFactors= FALSE))
}
}
ret
})(conc = c(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), time = 0:24, volume = c(NA, NA,NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA), duration.conc = c(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), dose = 1, time.dose = 0, duration.dose = 0, route = “extravascular”, conc.group = c(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), time.group = 0:24, volume.group = c(NA,
NA, NA, NA, NA, NA, NA, NA,NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA), duration.conc.group = c(0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), dose.group = 1, time.dose.group = 0, duration.dose.group = 0, route.group = “extravascular”, interval = list(start = 0, end = Inf, auclast = FALSE, aucall = FALSE, aumclast = FALSE, aumcall = FALSE, aucint.last = FALSE, aucint.last.dose = FALSE, aucint.all = FALSE, aucint.all.dose = FALSE, auclast.dn = FALSE,
aucall.dn = FALSE, aumclast.dn = FALSE, aumcall.dn = FALSE, cmax = TRUE, cmin = FALSE, tmax = TRUE, tlast = FALSE, tfirst = FALSE, clast.obs= FALSE,cl.last = FALSE, cl.all = FALSE, f = FALSE, mrt.last = FALSE, mrt.iv.last = FALSE, vss.last = FALSE, vss.iv.last = FALSE, cav = FALSE, ctrough = FALSE, ptr = FALSE, tlag = FALSE, deg.fluc = FALSE, swing = FALSE, ceoi = FALSE, ae = FALSE, clr.last = FALSE, clr.obs = FALSE, clr.pred = FALSE, fe = FALSE, half.life = TRUE, r.squared = FALSE, adj.r.squared = FALSE,
lambda.z = FALSE, lambda.z.time.first = FALSE, lambda.z.n.points = FALSE, clast.pred = FALSE, span.ratio = FALSE, cmax.dn = FALSE, cmin.dn =FALSE, clast.obs.dn = FALSE, clast.pred.dn = FALSE, cav.dn = FALSE, ctrough.dn = FALSE, thalf.eff.last = FALSE, thalf.eff.iv.last = FALSE, kel.last = FALSE, kel.iv.last = FALSE, aucinf.obs = TRUE, aucinf.pred = FALSE, aumcinf.obs = FALSE, aumcinf.pred = FALSE, aucint.inf.obs = FALSE, aucint.inf.obs.dose = FALSE, aucint.inf.pred = FALSE, aucint.inf.pred.dose = FALSE,
aucinf.obs.dn = FALSE, aucinf.pred.dn = FALSE, aumcinf.obs.dn = FALSE, aumcinf.pred.dn = FALSE, aucpext.obs = FALSE,aucpext.pred = FALSE, cl.obs = FALSE, cl.pred = FALSE, mrt.obs = FALSE, mrt.pred = FALSE, mrt.iv.obs = FALSE, mrt.iv.pred = FALSE, mrt.md.obs = FALSE, mrt.md.pred = FALSE, vz.obs = FALSE, vz.pred = FALSE, vss.obs = FALSE, vss.pred = FALSE, vss.iv.obs = FALSE, vss.iv.pred = FALSE, vss.md.obs = FALSE, vss.md.pred = FALSE, vd.obs = FALSE, vd.pred = FALSE, thalf.eff.obs = FALSE, thalf.eff.pred = FALSE,
thalf.eff.iv.obs = FALSE, thalf.eff.iv.pred = FALSE, kel.obs = FALSE, kel.pred = FALSE, kel.iv.obs= FALSE, kel.iv.pred = FALSE, treatment =“Trt 1”,ID = 1), options = list(adj.r.squared.factor = 1e-04, max.missing = 0.5, auc.method = “lin up/log down”, conc.na = “drop”, conc.blq = list(first = “keep”, middle = “drop”, last = “keep”), first.tmax = TRUE, allow.tmax.in.half.life = FALSE, min.hl.points = 3, min.span.ratio = 2, max.aucinf.pext = 20, min.hl.r.squared = 0.9, tau.choices = NA, single.dose.aucs = list(
start = c(0, 0), end = c(24, Inf), auclast = c(TRUE, FALSE), aucall = c(FALSE, FALSE), aumclast =c(FALSE, FALSE), aumcall = c(FALSE, FALSE),aucint.last = c(FALSE, FALSE), aucint.last.dose = c(FALSE, FALSE), aucint.all = c(FALSE, FALSE), aucint.all.dose = c(FALSE, FALSE), auclast.dn = c(FALSE, FALSE), aucall.dn = c(FALSE, FALSE), aumclast.dn = c(FALSE, FALSE), aumcall.dn = c(FALSE, FALSE), cmax = c(FALSE, TRUE), cmin = c(FALSE, FALSE), tmax = c(FALSE, TRUE), tlast = c(FALSE, FALSE), tfirst = c(FALSE,
FALSE), clast.obs = c(FALSE, FALSE), cl.last = c(FALSE, FALSE), cl.all = c(FALSE, FALSE), f = c(FALSE, FALSE), mrt.last = c(FALSE, FALSE), mrt.iv.last= c(FALSE, FALSE), vss.last = c(FALSE, FALSE), vss.iv.last = c(FALSE, FALSE), cav = c(FALSE, FALSE), ctrough = c(FALSE, FALSE), ptr = c(FALSE, FALSE), tlag = c(FALSE, FALSE), deg.fluc = c(FALSE, FALSE), swing = c(FALSE, FALSE), ceoi = c(FALSE, FALSE), ae = c(FALSE, FALSE), clr.last = c(FALSE, FALSE), clr.obs = c(FALSE, FALSE), clr.pred = c(FALSE,
FALSE), fe = c(FALSE, FALSE), half.life = c(FALSE, TRUE), r.squared = c(FALSE, FALSE), adj.r.squared = c(FALSE, FALSE), lambda.z = c(FALSE, FALSE), lambda.z.time.first = c(FALSE, FALSE), lambda.z.n.points = c(FALSE, FALSE), clast.pred = c(FALSE, FALSE), span.ratio = c(FALSE, FALSE), cmax.dn = c(FALSE, FALSE), cmin.dn = c(FALSE, FALSE), clast.obs.dn = c(FALSE, FALSE), clast.pred.dn = c(FALSE, FALSE), cav.dn = c(FALSE, FALSE), ctrough.dn = c(FALSE, FALSE), thalf.eff.last = c(FALSE, FALSE), thalf.eff.iv.last = c(FALSE,
FALSE), kel.last = c(FALSE, FALSE), kel.iv.last = c(FALSE, FALSE), aucinf.obs = c(FALSE, TRUE), aucinf.pred = c(FALSE, FALSE), aumcinf.obs =c(FALSE,FALSE), aumcinf.pred = c(FALSE, FALSE), aucint.inf.obs = c(FALSE, FALSE), aucint.inf.obs.dose = c(FALSE, FALSE), aucint.inf.pred = c(FALSE, FALSE), aucint.inf.pred.dose = c(FALSE, FALSE), aucinf.obs.dn = c(FALSE, FALSE), aucinf.pred.dn = c(FALSE, FALSE), aumcinf.obs.dn = c(FALSE, FALSE), aumcinf.pred.dn = c(FALSE, FALSE), aucpext.obs = c(FALSE,
FALSE), aucpext.pred = c(FALSE, FALSE), cl.obs = c(FALSE, FALSE), cl.pred = c(FALSE, FALSE), mrt.obs = c(FALSE, FALSE), mrt.pred = c(FALSE, FALSE), mrt.iv.obs = c(FALSE, FALSE), mrt.iv.pred = c(FALSE, FALSE), mrt.md.obs = c(FALSE, FALSE), mrt.md.pred = c(FALSE, FALSE), vz.obs = c(FALSE, FALSE), vz.pred = c(FALSE, FALSE), vss.obs = c(FALSE, FALSE), vss.pred = c(FALSE, FALSE), vss.iv.obs = c(FALSE, FALSE), vss.iv.pred = c(FALSE, FALSE), vss.md.obs = c(FALSE, FALSE), vss.md.pred = c(FALSE, FALSE
), vd.obs = c(FALSE, FALSE), vd.pred = c(FALSE, FALSE), thalf.eff.obs = c(FALSE, FALSE), thalf.eff.pred = c(FALSE, FALSE), thalf.eff.iv.obs =c(FALSE,FALSE), thalf.eff.iv.pred = c(FALSE, FALSE), kel.obs = c(FALSE, FALSE), kel.pred = c(FALSE, FALSE), kel.iv.obs = c(FALSE, FALSE), kel.iv.pred = c(FALSE, FALSE)))), do.call(all.intervals[[n]]$FUN, call.args), pk.calc.half.life(conc = c(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), time = c(0, 1, 2, 3, 4, 5, 6, 7, 8,
9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24), tmax = NA, tlast = NA, options = list(adj.r.squared.factor = 1e-04, max.missing =0.5, auc.method = “lin up/log down”, conc.na = “drop”, conc.blq = list(first = “keep”, middle = “drop”, last = “keep”), first.tmax = TRUE, allow.tmax.in.half.life = FALSE, min.hl.points = 3, min.span.ratio = 2, max.aucinf.pext = 20, min.hl.r.squared = 0.9, tau.choices = NA, single.dose.aucs = list(start = c(0, 0), end = c(24, Inf), auclast = c(TRUE, FALSE
), aucall = c(FALSE, FALSE),aumclast = c(FALSE, FALSE), aumcall = c(FALSE, FALSE), aucint.last = c(FALSE, FALSE), aucint.last.dose = c(FALSE, FALSE), aucint.all = c(FALSE, FALSE), aucint.all.dose = c(FALSE, FALSE), auclast.dn = c(FALSE, FALSE), aucall.dn = c(FALSE, FALSE), aumclast.dn = c(FALSE, FALSE), aumcall.dn = c(FALSE, FALSE), cmax = c(FALSE, TRUE), cmin = c(FALSE, FALSE), tmax = c(FALSE, TRUE), tlast = c(FALSE, FALSE), tfirst = c(FALSE, FALSE), clast.obs = c(FALSE, FALSE), cl.last = c(FALSE,
FALSE), cl.all = c(FALSE, FALSE), f = c(FALSE, FALSE), mrt.last = c(FALSE, FALSE), mrt.iv.last = c(FALSE, FALSE), vss.last = c(FALSE, FALSE), vss.iv.last= c(FALSE, FALSE), cav = c(FALSE, FALSE), ctrough = c(FALSE, FALSE), ptr = c(FALSE, FALSE), tlag = c(FALSE, FALSE), deg.fluc = c(FALSE, FALSE), swing = c(FALSE, FALSE), ceoi = c(FALSE, FALSE), ae = c(FALSE, FALSE), clr.last = c(FALSE, FALSE), clr.obs = c(FALSE, FALSE), clr.pred = c(FALSE, FALSE), fe = c(FALSE, FALSE), half.life = c(FALSE, TRUE),
r.squared = c(FALSE, FALSE), adj.r.squared = c(FALSE, FALSE), lambda.z = c(FALSE, FALSE), lambda.z.time.first = c(FALSE, FALSE), lambda.z.n.points = c(FALSE, FALSE), clast.pred = c(FALSE, FALSE), span.ratio = c(FALSE, FALSE), cmax.dn = c(FALSE, FALSE), cmin.dn = c(FALSE, FALSE), clast.obs.dn = c(FALSE, FALSE), clast.pred.dn = c(FALSE, FALSE), cav.dn = c(FALSE, FALSE), ctrough.dn = c(FALSE, FALSE), thalf.eff.last = c(FALSE, FALSE), thalf.eff.iv.last = c(FALSE, FALSE), kel.last = c(FALSE, FALSE
), kel.iv.last = c(FALSE, FALSE), aucinf.obs = c(FALSE, TRUE), aucinf.pred = c(FALSE, FALSE), aumcinf.obs = c(FALSE,FALSE), aumcinf.pred = c(FALSE, FALSE), aucint.inf.obs = c(FALSE, FALSE), aucint.inf.obs.dose = c(FALSE, FALSE), aucint.inf.pred = c(FALSE, FALSE), aucint.inf.pred.dose = c(FALSE, FALSE), aucinf.obs.dn = c(FALSE, FALSE), aucinf.pred.dn = c(FALSE, FALSE), aumcinf.obs.dn = c(FALSE, FALSE), aumcinf.pred.dn = c(FALSE, FALSE), aucpext.obs = c(FALSE, FALSE), aucpext.pred = c(FALSE, FALSE
), cl.obs = c(FALSE, FALSE), cl.pred = c(FALSE, FALSE), mrt.obs = c(FALSE, FALSE), mrt.pred = c(FALSE, FALSE), mrt.iv.obs = c(FALSE, FALSE),mrt.iv.pred = c(FALSE, FALSE), mrt.md.obs = c(FALSE, FALSE), mrt.md.pred = c(FALSE, FALSE), vz.obs = c(FALSE, FALSE), vz.pred = c(FALSE, FALSE), vss.obs = c(FALSE, FALSE), vss.pred = c(FALSE, FALSE), vss.iv.obs = c(FALSE, FALSE), vss.iv.pred = c(FALSE, FALSE), vss.md.obs = c(FALSE, FALSE), vss.md.pred = c(FALSE, FALSE), vd.obs = c(FALSE, FALSE), vd.pred = c(FALSE,
FALSE), thalf.eff.obs =c(FALSE, FALSE), thalf.eff.pred = c(FALSE, FALSE), thalf.eff.iv.obs = c(FALSE, FALSE), thalf.eff.iv.pred = c(FALSE, FALSE), kel.obs = c(FALSE, FALSE), kel.pred = c(FALSE, FALSE), kel.iv.obs = c(FALSE, FALSE), kel.iv.pred = c(FALSE, FALSE)))), warning(attr(ret, “exclude”))), start_frame = 74, end_frame = 86, test = “PKNCAresults summary”), list(message = “Too few points for half-life calculation (min.hl.points=3 with only 0 points)”, srcref = c(214, 3, 214, 28, 3, 28, 214,
214), call = list(pk.nca(mydata), parallel::mclapply(X = splitdata[mask_has_interval], FUN = pk.nca.intervals, options =data$options), lapply(X,FUN, …), FUN(X[[i]], …), tryCatch({
args <- list(conc = conc_data_interval[[col.conc]], time = conc_data_interval[[col.time]], volume= conc_data_interval[[col.volume]], duration.conc =conc_data_interval[[col.duration.conc]], dose = dose_data_interval[[col.dose]], time.dose = dose_data_interval[[col.time.dose]], duration.dose = dose_data_interval[[col.duration.dose]], route = dose_data_interval[[col.route]], conc.group = conc_data_group[[col.conc]], time.group = conc_data_group[[col.time]], volume.group = conc_data_group[[col.volume]],
duration.conc.group= conc_data_group[[col.duration.conc]], dose.group = dose_data_group[[col.dose]], time.dose.group = dose_data_group[[col.time.dose]], duration.dose.group = dose_data_group[[col.duration.dose]], route.group = dose_data_group[[col.route]], interval = all.intervals[i, , drop = FALSE], options = options)
if (!is.null(col.include_half.life)) {
args$include_half.life <- conc_data_interval[[col.include_half.life]]
}
if (!is.null(col.exclude_half.life)) {
args$exclude_half.life <- conc_data_interval[[col.exclude_half.life]]
}
calculated.interval <- do.call(pk.nca.interval, args)
}, error = function(e) {
e$message <- paste(error.preamble, e$message, sep = “:”)
stop(e)
}), tryCatchList(expr, classes, parentenv, handlers), tryCatchOne(expr, names, parentenv, handlers[[1]]), doTryCatch(return(expr), name, parentenv, handler), do.call(pk.nca.interval, args), (function (conc, time, volume, duration.conc, dose, time.dose, duration.dose, route, conc.group = NULL, time.group = NULL, volume.group = NULL, duration.conc.group = NULL, dose.group = NULL, time.dose.group = NULL, duration.dose.group = NULL, route.group = NULL, include_half.life = NULL, exclude_half.life = NULL,
interval, options = list())
{
if (!is.data.frame(interval)) {
stop("interval mustbe a data.frame")
}
if (nrow(interval) != 1)
stop("interval mustbe a one-row data.frame")
ret <- data.frame(PPTESTCD = NA, PPORRES = NA)[-1, ]
all.intervals <- get.interval.cols()
if (length(dose) == 0) {
dose <- NA
time.dose <- NA
duration.dose <- NA
}
for (n in rev(names(all.intervals))) {
if (interval[[1, n]]) {
for (deps in all.intervals[[n]]$depends) {
interval[1,deps] <- TRUE
}
}
}
for (n in names(all.intervals)) if (interval[[1, n]] & !is.na(all.intervals[[n]]$FUN)) {
call.args <- list()
arglist <- setdiff(names(formals(get(all.intervals[[n]]$FUN))), “…”)
arglist <- stats::setNames(object = as.list(arglist), arglist)
arglist[names(all.intervals[[n]]\(formalsmap)] <- all.intervals[[n]]\)formalsmap
arglist <- arglist[!sapply(arglist, is.null)]
for (arg_formal in names(arglist)) {
arg_mapped <- arglist[[arg_formal]]
if (arg_mapped == “conc”) {
call.args[[arg_formal]] <- conc
}
else if (arg_mapped == “time”) {
call.args[[arg_formal]] <- time - interval$start[1]
}
else if (arg_mapped == “volume”) {
call.args[[arg_formal]] <- volume
}
else if (arg_mapped == “duration.conc”) {
call.args[[arg_formal]] <- duration.conc
}
else if (arg_mapped == “dose”) {
call.args[[arg_formal]] <- dose
}
else if (arg_mapped == “time.dose”) {
call.args[[arg_formal]] <- time.dose - interval$start[1]
}
else if (arg_mapped == “duration.dose”) {
call.args[[arg_formal]] <- duration.dose
}
else if (arg_mapped == “route”) {
call.args[[arg_formal]] <- route
}
else if (arg_mapped == “conc.group”) {
call.args[[arg_formal]] <- conc.group
}
else if (arg_mapped == “time.group”) {
call.args[[arg_formal]] <- time.group
}
else if (arg_mapped == “volume.group”) {
call.args[[arg_formal]] <- volume.group
}
else if (arg_mapped == “duration.conc.group”) {
call.args[[arg_formal]] <- duration.conc.group
}
else if (arg_mapped == “dose.group”) {
call.args[[arg_formal]] <- dose.group
}
else if (arg_mapped == “time.dose.group”) {
call.args[[arg_formal]] <- time.dose.group
}
else if (arg_mapped == “duration.dose.group”) {
call.args[[arg_formal]] <- duration.dose.group
}
else if (arg_mapped == “route.group”) {
call.args[[arg_formal]] <- route.group
}
else if (arg_mapped %in% c(“start”, “end”)) {
call.args[[arg_formal]] <- interval[1, arg_mapped]
}
else if (arg_mapped == “options”) {
call.args[[arg_formal]] <- options
}
else if (any(mask.arg <- ret$PPTESTCD %in% arg_mapped)) {
call.args[[arg_formal]] <- ret$PPORRES[mask.arg]
}
else {
if (class(formals(get(all.intervals[[n]]$FUN))[[arg_formal]]) == “name”) {
arg_text <- if (arg_formal == arg_mapped) {
sprintf(“‘%s’”, arg_formal)
}
else {
sprintf(“‘%s’ mapped to ‘%s’”, arg_formal, arg_mapped)
}
stop(sprintf(“Cannot find argument %s for NCA function ‘%s’”, arg_text, all.intervals[[n]]$FUN))
}
}
}
if (n %in% "half.life") {
if (!is.null(include_half.life)) {
call.args$conc <- call.args$conc[include_half.life]
call.args$time <- call.args$time[include_half.life]
call.args$manually.selected.points <- TRUE
}
else if (!is.null(exclude_half.life)) {
call.args$conc <- call.args$conc[!exclude_half.life]
call.args$time <- call.args$time[!exclude_half.life]
}
}
tmp.result <- do.call(all.intervals[[n]]$FUN, call.args)
exclude_reason <- if(!is.null(attr(tmp.result, “exclude”))) {
attr(tmp.result,“exclude”)
}
else {
NA
}
if (is.data.frame(tmp.result)) {
ret <- rbind(ret, data.frame(PPTESTCD = names(tmp.result), PPORRES = unlist(tmp.result, use.names = FALSE),exclude = exclude_reason,stringsAsFactors = FALSE))
}
else {
ret <- rbind(ret, data.frame(PPTESTCD = n, PPORRES = tmp.result, exclude = exclude_reason,stringsAsFactors= FALSE))
}
}
ret
})(conc = c(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), time = 0:24, volume = c(NA, NA,NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA), duration.conc = c(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), dose = 1, time.dose = 0, duration.dose = 0, route = “extravascular”, conc.group = c(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), time.group = 0:24, volume.group = c(NA,
NA, NA, NA, NA, NA, NA, NA,NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA, NA), duration.conc.group = c(0, 0, 0, 0, 0, 0, 0, 0,0, 0, 0,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), dose.group = 1, time.dose.group = 0, duration.dose.group = 0, route.group = “extravascular”, interval = list(start = 0, end = Inf, auclast = FALSE, aucall = FALSE, aumclast = FALSE, aumcall = FALSE, aucint.last = FALSE, aucint.last.dose = FALSE, aucint.all = FALSE, aucint.all.dose = FALSE, auclast.dn = FALSE,
aucall.dn = FALSE, aumclast.dn = FALSE, aumcall.dn = FALSE, cmax = TRUE, cmin = FALSE, tmax = TRUE, tlast = FALSE, tfirst = FALSE, clast.obs= FALSE,cl.last = FALSE, cl.all = FALSE, f = FALSE, mrt.last = FALSE, mrt.iv.last = FALSE, vss.last = FALSE, vss.iv.last = FALSE, cav = FALSE, ctrough = FALSE, ptr = FALSE, tlag = FALSE, deg.fluc = FALSE, swing = FALSE, ceoi = FALSE, ae = FALSE, clr.last = FALSE, clr.obs = FALSE, clr.pred = FALSE, fe = FALSE, half.life = TRUE, r.squared = FALSE, adj.r.squared = FALSE,
lambda.z = FALSE, lambda.z.time.first = FALSE, lambda.z.n.points = FALSE, clast.pred = FALSE, span.ratio = FALSE, cmax.dn = FALSE, cmin.dn =FALSE, clast.obs.dn = FALSE, clast.pred.dn = FALSE, cav.dn = FALSE, ctrough.dn = FALSE, thalf.eff.last = FALSE, thalf.eff.iv.last = FALSE, kel.last = FALSE, kel.iv.last = FALSE, aucinf.obs = TRUE, aucinf.pred = FALSE, aumcinf.obs = FALSE, aumcinf.pred = FALSE, aucint.inf.obs = FALSE, aucint.inf.obs.dose = FALSE, aucint.inf.pred = FALSE, aucint.inf.pred.dose = FALSE,
aucinf.obs.dn = FALSE, aucinf.pred.dn = FALSE, aumcinf.obs.dn = FALSE, aumcinf.pred.dn = FALSE, aucpext.obs = FALSE,aucpext.pred = FALSE, cl.obs = FALSE, cl.pred = FALSE, mrt.obs = FALSE, mrt.pred = FALSE, mrt.iv.obs = FALSE, mrt.iv.pred = FALSE, mrt.md.obs = FALSE, mrt.md.pred = FALSE, vz.obs = FALSE, vz.pred = FALSE, vss.obs = FALSE, vss.pred = FALSE, vss.iv.obs = FALSE, vss.iv.pred = FALSE, vss.md.obs = FALSE, vss.md.pred = FALSE, vd.obs = FALSE, vd.pred = FALSE, thalf.eff.obs = FALSE, thalf.eff.pred = FALSE,
thalf.eff.iv.obs = FALSE, thalf.eff.iv.pred = FALSE, kel.obs = FALSE, kel.pred = FALSE, kel.iv.obs= FALSE, kel.iv.pred = FALSE, treatment =“Trt 1”,ID = 2), options = list(adj.r.squared.factor = 1e-04, max.missing = 0.5, auc.method = “lin up/log down”, conc.na = “drop”, conc.blq = list(first = “keep”, middle = “drop”, last = “keep”), first.tmax = TRUE, allow.tmax.in.half.life = FALSE, min.hl.points = 3, min.span.ratio = 2, max.aucinf.pext = 20, min.hl.r.squared = 0.9, tau.choices = NA, single.dose.aucs = list(
start = c(0, 0), end = c(24, Inf), auclast = c(TRUE, FALSE), aucall = c(FALSE, FALSE), aumclast =c(FALSE, FALSE), aumcall = c(FALSE, FALSE),aucint.last = c(FALSE, FALSE), aucint.last.dose = c(FALSE, FALSE), aucint.all = c(FALSE, FALSE), aucint.all.dose = c(FALSE, FALSE), auclast.dn = c(FALSE, FALSE), aucall.dn = c(FALSE, FALSE), aumclast.dn = c(FALSE, FALSE), aumcall.dn = c(FALSE, FALSE), cmax = c(FALSE, TRUE), cmin = c(FALSE, FALSE), tmax = c(FALSE, TRUE), tlast = c(FALSE, FALSE), tfirst = c(FALSE,
FALSE), clast.obs = c(FALSE, FALSE), cl.last = c(FALSE, FALSE), cl.all = c(FALSE, FALSE), f = c(FALSE, FALSE), mrt.last = c(FALSE, FALSE), mrt.iv.last= c(FALSE, FALSE), vss.last = c(FALSE, FALSE), vss.iv.last = c(FALSE, FALSE), cav = c(FALSE, FALSE), ctrough = c(FALSE, FALSE), ptr = c(FALSE, FALSE), tlag = c(FALSE, FALSE), deg.fluc = c(FALSE, FALSE), swing = c(FALSE, FALSE), ceoi = c(FALSE, FALSE), ae = c(FALSE, FALSE), clr.last = c(FALSE, FALSE), clr.obs = c(FALSE, FALSE), clr.pred = c(FALSE,
FALSE), fe = c(FALSE, FALSE), half.life = c(FALSE, TRUE), r.squared = c(FALSE, FALSE), adj.r.squared = c(FALSE, FALSE), lambda.z = c(FALSE, FALSE), lambda.z.time.first = c(FALSE, FALSE), lambda.z.n.points = c(FALSE, FALSE), clast.pred = c(FALSE, FALSE), span.ratio = c(FALSE, FALSE), cmax.dn = c(FALSE, FALSE), cmin.dn = c(FALSE, FALSE), clast.obs.dn = c(FALSE, FALSE), clast.pred.dn = c(FALSE, FALSE), cav.dn = c(FALSE, FALSE), ctrough.dn = c(FALSE, FALSE), thalf.eff.last = c(FALSE, FALSE), thalf.eff.iv.last = c(FALSE,
FALSE), kel.last = c(FALSE, FALSE), kel.iv.last = c(FALSE, FALSE), aucinf.obs = c(FALSE, TRUE), aucinf.pred = c(FALSE, FALSE), aumcinf.obs =c(FALSE,FALSE), aumcinf.pred = c(FALSE, FALSE), aucint.inf.obs = c(FALSE, FALSE), aucint.inf.obs.dose = c(FALSE, FALSE), aucint.inf.pred = c(FALSE, FALSE), aucint.inf.pred.dose = c(FALSE, FALSE), aucinf.obs.dn = c(FALSE, FALSE), aucinf.pred.dn = c(FALSE, FALSE), aumcinf.obs.dn = c(FALSE, FALSE), aumcinf.pred.dn = c(FALSE, FALSE), aucpext.obs = c(FALSE,
FALSE), aucpext.pred = c(FALSE, FALSE), cl.obs = c(FALSE, FALSE), cl.pred = c(FALSE, FALSE), mrt.obs = c(FALSE, FALSE), mrt.pred = c(FALSE, FALSE), mrt.iv.obs = c(FALSE, FALSE), mrt.iv.pred = c(FALSE, FALSE), mrt.md.obs = c(FALSE, FALSE), mrt.md.pred = c(FALSE, FALSE), vz.obs = c(FALSE, FALSE), vz.pred = c(FALSE, FALSE), vss.obs = c(FALSE, FALSE), vss.pred = c(FALSE, FALSE), vss.iv.obs = c(FALSE, FALSE), vss.iv.pred = c(FALSE, FALSE), vss.md.obs = c(FALSE, FALSE), vss.md.pred = c(FALSE, FALSE
), vd.obs = c(FALSE, FALSE), vd.pred = c(FALSE, FALSE), thalf.eff.obs = c(FALSE, FALSE), thalf.eff.pred = c(FALSE, FALSE), thalf.eff.iv.obs =c(FALSE,FALSE), thalf.eff.iv.pred = c(FALSE, FALSE), kel.obs = c(FALSE, FALSE), kel.pred = c(FALSE, FALSE), kel.iv.obs = c(FALSE, FALSE), kel.iv.pred = c(FALSE, FALSE)))), do.call(all.intervals[[n]]$FUN, call.args), pk.calc.half.life(conc = c(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), time = c(0, 1, 2, 3, 4, 5, 6, 7, 8,
9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24), tmax = NA, tlast = NA, options = list(adj.r.squared.factor = 1e-04, max.missing =0.5, auc.method = “lin up/log down”, conc.na = “drop”, conc.blq = list(first = “keep”, middle = “drop”, last = “keep”), first.tmax = TRUE, allow.tmax.in.half.life = FALSE, min.hl.points = 3, min.span.ratio = 2, max.aucinf.pext = 20, min.hl.r.squared = 0.9, tau.choices = NA, single.dose.aucs = list(start = c(0, 0), end = c(24, Inf), auclast = c(TRUE, FALSE
), aucall = c(FALSE, FALSE),aumclast = c(FALSE, FALSE), aumcall = c(FALSE, FALSE), aucint.last = c(FALSE, FALSE), aucint.last.dose = c(FALSE, FALSE), aucint.all = c(FALSE, FALSE), aucint.all.dose = c(FALSE, FALSE), auclast.dn = c(FALSE, FALSE), aucall.dn = c(FALSE, FALSE), aumclast.dn = c(FALSE, FALSE), aumcall.dn = c(FALSE, FALSE), cmax = c(FALSE, TRUE), cmin = c(FALSE, FALSE), tmax = c(FALSE, TRUE), tlast = c(FALSE, FALSE), tfirst = c(FALSE, FALSE), clast.obs = c(FALSE, FALSE), cl.last = c(FALSE,
FALSE), cl.all = c(FALSE, FALSE), f = c(FALSE, FALSE), mrt.last = c(FALSE, FALSE), mrt.iv.last = c(FALSE, FALSE), vss.last = c(FALSE, FALSE), vss.iv.last= c(FALSE, FALSE), cav = c(FALSE, FALSE), ctrough = c(FALSE, FALSE), ptr = c(FALSE, FALSE), tlag = c(FALSE, FALSE), deg.fluc = c(FALSE, FALSE), swing = c(FALSE, FALSE), ceoi = c(FALSE, FALSE), ae = c(FALSE, FALSE), clr.last = c(FALSE, FALSE), clr.obs = c(FALSE, FALSE), clr.pred = c(FALSE, FALSE), fe = c(FALSE, FALSE), half.life = c(FALSE, TRUE),
r.squared = c(FALSE, FALSE), adj.r.squared = c(FALSE, FALSE), lambda.z = c(FALSE, FALSE), lambda.z.time.first = c(FALSE, FALSE), lambda.z.n.points = c(FALSE, FALSE), clast.pred = c(FALSE, FALSE), span.ratio = c(FALSE, FALSE), cmax.dn = c(FALSE, FALSE), cmin.dn = c(FALSE, FALSE), clast.obs.dn = c(FALSE, FALSE), clast.pred.dn = c(FALSE, FALSE), cav.dn = c(FALSE, FALSE), ctrough.dn = c(FALSE, FALSE), thalf.eff.last = c(FALSE, FALSE), thalf.eff.iv.last = c(FALSE, FALSE), kel.last = c(FALSE, FALSE
), kel.iv.last = c(FALSE, FALSE), aucinf.obs = c(FALSE, TRUE), aucinf.pred = c(FALSE, FALSE), aumcinf.obs = c(FALSE,FALSE), aumcinf.pred = c(FALSE, FALSE), aucint.inf.obs = c(FALSE, FALSE), aucint.inf.obs.dose = c(FALSE, FALSE), aucint.inf.pred = c(FALSE, FALSE), aucint.inf.pred.dose = c(FALSE, FALSE), aucinf.obs.dn = c(FALSE, FALSE), aucinf.pred.dn = c(FALSE, FALSE), aumcinf.obs.dn = c(FALSE, FALSE), aumcinf.pred.dn = c(FALSE, FALSE), aucpext.obs = c(FALSE, FALSE), aucpext.pred = c(FALSE, FALSE
), cl.obs = c(FALSE, FALSE), cl.pred = c(FALSE, FALSE), mrt.obs = c(FALSE, FALSE), mrt.pred = c(FALSE, FALSE), mrt.iv.obs = c(FALSE, FALSE),mrt.iv.pred = c(FALSE, FALSE), mrt.md.obs = c(FALSE, FALSE), mrt.md.pred = c(FALSE, FALSE), vz.obs = c(FALSE, FALSE), vz.pred = c(FALSE, FALSE), vss.obs = c(FALSE, FALSE), vss.pred = c(FALSE, FALSE), vss.iv.obs = c(FALSE, FALSE), vss.iv.pred = c(FALSE, FALSE), vss.md.obs = c(FALSE, FALSE), vss.md.pred = c(FALSE, FALSE), vd.obs = c(FALSE, FALSE), vd.pred = c(FALSE,
FALSE), thalf.eff.obs =c(FALSE, FALSE), thalf.eff.pred = c(FALSE, FALSE), thalf.eff.iv.obs = c(FALSE, FALSE), thalf.eff.iv.pred = c(FALSE, FALSE), kel.obs = c(FALSE, FALSE), kel.pred = c(FALSE, FALSE), kel.iv.obs = c(FALSE, FALSE), kel.iv.pred = c(FALSE, FALSE)))), warning(attr(ret, “exclude”))), start_frame = 74, end_frame = 86, test = “PKNCAresults summary”), list(message = “mysummary not equal to as_summary_PKNCAresults(…).”, srcref = c(216, 3, 233, 3, 3, 3, 216, 233), expectation_calls = list(
expect_equal(mysummary,as_summary_PKNCAresults(data.frame(start = 0, end = c(24, Inf), treatment= “Trt 1”, N = “2”, auclast = c(“NC”, “.”),cmax = c(“.”, “NC”), tmax = c(“.”, “NC”), half.life = c(“.”, “NC”), aucinf.obs = c(“.”, “NC”), stringsAsFactors = FALSE), caption = “auclast, cmax, aucinf.obs: geometric mean and geometric coefficient of variation; tmax: median and range; half.life: arithmetic mean and standard deviation”), info = “summary of PKNCAresults without most results gives NC”)),
call = list(expect_equal(mysummary, as_summary_PKNCAresults(data.frame(start = 0, end = c(24, Inf), treatment = "Trt1“, N =”2", auclast = c(“NC”, ".“), cmax = c(”.“,”NC“), tmax = c(”.“,”NC“), half.life = c(”.“,”NC“), aucinf.obs = c(”.“,”NC“), stringsAsFactors = FALSE), caption =”auclast, cmax, aucinf.obs: geometric mean and geometric coefficient of variation; tmax: median and range; half.life: arithmetic mean and standard deviation“), info =”summary of PKNCAresults without most results gives NC")),
start_frame = 74, end_frame = 74, test = “PKNCAresults summary”), list(message = "mysummary notequal to as_summary_PKNCAresults(…).E", srcref = c(238, 3, 256, 3, 3, 3, 238, 256), expectation_calls = list(expect_equal(mysummary, as_summary_PKNCAresults(data.frame(start = 0, end = c(24, Inf), treatment = “Trt 1”, N = “2”, auclast = c(“NoCalc”, “NR”), cmax = c(“NR”, “NoCalc”), tmax = c(“NR”, “NoCalc”), half.life = c(“NR”, “NoCalc”), aucinf.obs = c(“NR”, “NoCalc”), stringsAsFactors = FALSE),
caption = "auclast, cmax, aucinf.obs: geometric mean and geometric coefficient of variation; tmax:median and range;half.life: arithmetic mean and standard deviation“), info =”Summary respects the not.requested.string and not.calculated.string“)), call = list(expect_equal(mysummary, as_summary_PKNCAresults(data.frame(start = 0, end = c(24, Inf), treatment =”Trt 1“, N =”2“, auclast = c(”NoCalc“,”NR“), cmax = c(”NR“,”NoCalc“), tmax = c(”NR“,”NoCalc“), half.life = c(”NR“,”NoCalc“), aucinf.obs = c(”NR",
“NoCalc”), stringsAsFactors = FALSE), caption = "auclast, cmax, aucinf.obs: geometric mean and geometric coefficientof variation; tmax: median and range; half.life: arithmetic mean and standard deviation“), info =”Summary respects the not.requested.string and not.calculated.string“)), start_frame = 74, end_frame = 74, test =”PKNCAresults summary“), list(message =”mysummary not equal to as_summary_PKNCAresults(…).", srcref = c(262, 3, 278, 3, 3, 3, 262, 278), expectation_calls = list(
expect_equal(mysummary,as_summary_PKNCAresults(data.frame(start = 0, end = c(24, Inf), treatment= “Trt 1”, auclast= c(“NoCalc”, “NR”), cmax = c("NR“,”NoCalc“), tmax = c(”NR“,”NoCalc“), half.life = c(”NR“,”NoCalc“), aucinf.obs = c(”NR“,”NoCalc“), stringsAsFactors = FALSE), caption =”auclast, cmax, aucinf.obs: geometric mean and geometric coefficient of variation; tmax: median and range; half.life: arithmetic mean and standard deviation“), info =”N is optionally omitted")), call = list(
expect_equal(mysummary,as_summary_PKNCAresults(data.frame(start = 0, end = c(24, Inf), treatment= “Trt 1”, auclast= c(“NoCalc”, “NR”), cmax = c("NR“,”NoCalc“), tmax = c(”NR“,”NoCalc“), half.life = c(”NR“,”NoCalc“), aucinf.obs = c(”NR“,”NoCalc“), stringsAsFactors = FALSE), caption =”auclast, cmax, aucinf.obs: geometric mean and geometric coefficient of variation; tmax: median and range; half.life: arithmetic mean and standard deviation“), info =”N is optionally omitted")), start_frame = 74,
end_frame = 74, test = "PKNCAresults summary"))
test-class-PKNCAresults.Rdropping start and end from groups is allowed with a warning.202list(list(message = "“, srcref = c(289, 3, 292, 3, 3, 3, 289, 292), expectation_calls = list(expect_warning(current_summary <- summary(myresult, drop.group = c(”ID“,”start“)), regex =”drop.group including start or end may result“, fixed = TRUE)), call = list(expect_warning(current_summary <- summary(myresult, drop.group = c(”ID“,”start“)), regex =”drop.group including start or end may result“, fixed = TRUE)), start_frame = 74, end_frame = 74, test =”dropping start and end from groups is allowed with a warning."),
list(message = ""start\" %in% names(current_summary) isn’t false.", srcref = c(293, 3, 293, 51, 3, 51, 293, 293), expectation_calls = list(expect_false(“start” %in% names(current_summary))), call = list(expect_false(“start” %in% names(current_summary))), start_frame = 74, end_frame = 74, test = “dropping start and end from groups is allowed with a warning.”))
test-class-PKNCAresults.Rsummary.PKNCAresults manages exclusions as missing not as non-existent.303list(list(message = “mysummary not equal to as_summary_PKNCAresults(…).”, srcref = c(323, 3, 341, 3, 3, 3, 323, 341), expectation_calls = list(expect_equal(mysummary, as_summary_PKNCAresults(data.frame(start = 0, end = c(24, Inf), treatment = “Trt 1”, N = “2”, auclast = c(“13.8 [2.51]”, “.”), cmax = c(“.”, “0.970 [4.29]”), tmax = c(“.”, “3.00 [2.00, 4.00]”), half.life = c(“.”, “14.2 [2.79]”), aucinf.obs = c(“.”, “20.5 [6.84]”), stringsAsFactors = FALSE), caption = “auclast, cmax, aucinf.obs: geometric mean and geometric coefficient of variation; tmax: median and range; half.life: arithmetic mean and standard deviation”),
info = "simple summary of PKNCAresults performs as expected")), call = list(expect_equal(mysummary, as_summary_PKNCAresults(data.frame(start= 0, end= c(24, Inf), treatment = “Trt 1”, N = “2”, auclast = c(“13.8 [2.51]”, “.”), cmax = c(“.”, “0.970 [4.29]”), tmax = c(“.”, “3.00 [2.00, 4.00]”), half.life = c(“.”, “14.2 [2.79]”), aucinf.obs = c(“.”, “20.5 [6.84]”), stringsAsFactors = FALSE), caption = “auclast, cmax, aucinf.obs: geometric mean and geometric coefficient of variation; tmax: median and range; half.life: arithmetic mean and standard deviation”),
info = "simple summary of PKNCAresults performs as expected")), start_frame = 74, end_frame = 74,test = "summary.PKNCAresults manages exclusions as missing not as non-existent.“), list(message =”mysummary_excluded not equal to as_summary_PKNCAresults(…).“, srcref = c(342, 3, 359, 77, 3, 77, 342, 359), expectation_calls = list(expect_equal(mysummary_excluded, as_summary_PKNCAresults(data.frame(start = 0, end = c(24, Inf), treatment =”Trt 1“, N =”2“, auclast = c(”14.0 [NC]“,”."),
cmax = c(“.”, "0.970 [4.29]“), tmax = c(”.“,”3.00 [2.00, 4.00]“), half.life = c(”.“,”14.2 [2.79]"), aucinf.obs = c(“.”, “20.5 [6.84]”), stringsAsFactors = FALSE), caption = “auclast, cmax, aucinf.obs: geometric mean and geometric coefficient of variation; tmax: median and range; half.life: arithmetic mean and standard deviation”), info = “summary of PKNCAresults correctly excludes auclast when requested”)), call = list(expect_equal(mysummary_excluded, as_summary_PKNCAresults(data.frame(start = 0,
end = c(24, Inf), treatment = “Trt 1”, N = “2”, auclast = c(“14.0 [NC]”, “.”), cmax = c(“.”, "0.970 [4.29]"), tmax =c(“.”, "3.00 [2.00, 4.00]"), half.life = c(“.”, “14.2 [2.79]”), aucinf.obs = c(“.”, “20.5 [6.84]”), stringsAsFactors = FALSE), caption = “auclast, cmax, aucinf.obs: geometric mean and geometric coefficient of variation; tmax: median and range; half.life: arithmetic mean and standard deviation”), info = “summary of PKNCAresults correctly excludes auclast when requested”)), start_frame = 74,
end_frame = 74, test = "summary.PKNCAresults manages exclusions as missing not as non-existent."),list(message = "`mysummary_excluded2` notequal toas_summary_PKNCAresults(…).“, srcref = c(360, 3, 378, 3, 3, 3, 360, 378), expectation_calls = list(expect_equal(mysummary_excluded2, as_summary_PKNCAresults(data.frame(start = 0, end = c(24, Inf), treatment =”Trt 1“, N =”2“, auclast = c(”NC“,”.“), cmax = c(”.“,”0.970 [4.29]“), tmax = c(”.“,”3.00 [2.00, 4.00]“), half.life = c(”.“,”14.2 [2.79]"),
aucinf.obs = c(“.”, "20.5 [6.84]“), stringsAsFactors = FALSE), caption =”auclast, cmax, aucinf.obs: geometric meanand geometric coefficientof variation; tmax: median and range; half.life: arithmetic mean and standard deviation“), info =”summary of PKNCAresults correctly excludes all of auclast when requested“)), call = list(expect_equal(mysummary_excluded2, as_summary_PKNCAresults(data.frame(start = 0, end = c(24, Inf), treatment =”Trt 1“, N =”2“, auclast = c(”NC“,”.“), cmax = c(”.“,”0.970 [4.29]"),
tmax = c(“.”, "3.00 [2.00, 4.00]“), half.life = c(”.“,”14.2 [2.79]“), aucinf.obs = c(”.“,”20.5 [6.84]"), stringsAsFactors = FALSE), caption= "auclast, cmax, aucinf.obs: geometric mean and geometric coefficient of variation; tmax: median and range; half.life: arithmetic mean and standard deviation“), info =”summary of PKNCAresults correctly excludes all of auclast when requested“)), start_frame = 74, end_frame = 74, test =”summary.PKNCAresults manages exclusions as missing not as non-existent."))
test-class-PKNCAresults.Rprint.summary_PKNCAresults works101list(list(message = "print\\(summary\\(myresult\\)\\) does not match " start end treatment N auclast cmax tmax half.life.\n 0 24 Trt 1 2 13.8 \\[2.51\\] . . ..\n 0 Inf Trt 1 2 . 0.970 \\[4.29\\] 3.00 \\[2.00, 4.00\\] 14.2 \\[2.79\\].*\n\nCaption: auclast, cmax, aucinf.obs: geometric mean and geometric coefficient of variation; tmax: median and range; half.life: arithmetic mean and standard deviation".value: " start end treatment N auclast cmax tmax half\.life\\n 0 24 Trt 1 2 13\.8 \[2\.51\] \. \. \.\\n 0 Inf Trt 1 2 \. 0\.970 \[4\.29\] 3\.00 \[2\.00, 4\.00\] 14\.2 \[2\.79\]\\n aucinf\.obs\\n \.\\n 20\.5 \[6\.84\]\\n\\nCaption: auclast, cmax, aucinf\.obs: geometric mean and geometric coefficient of variation; tmax: median and range; half\.life: arithmetic mean and standard deviation\\n"",
srcref = c(389, 3, 399,3, 3, 3, 389, 399), expectation_calls = list(expect_output(print(summary(myresult)), paste("start end treatment Nauclastcmax tmax half.life.“,” 0 24 Trt 1 2 13.8 \[2.51\] . . ..“,” 0 Inf Trt 1 2 . 0.970 \[4.29\] 3.00 \[2.00, 4.00\] 14.2 \[2.79\].*“,”“,”Caption: auclast, cmax, aucinf.obs: geometric mean and geometric coefficient of variation; tmax: median and range; half.life: arithmetic mean and standard deviation",
sep = “”)), expect_match(act\(cap, enc2native(regexp), ..., info = info, label = act\)lab)), call = list(expect_output(print(summary(myresult)), paste(" start end treatment N auclast cmax tmax half.life.“,” 0 24 Trt 1 2 13.8 \[2.51\] . . ..“,” 0 Inf Trt 1 2 . 0.970 \[4.29\] 3.00 \[2.00, 4.00\] 14.2 \[2.79\].*“,”“,”Caption: auclast, cmax, aucinf.obs: geometric mean and geometric coefficient of variation; tmax: median and range; half.life: arithmetic mean and standard deviation",
sep = “”)), expect_match(act\(cap, enc2native(regexp), ..., info = info, label = act\)lab)), start_frame = 74, end_frame = 75, test = "print.summary_PKNCAresults works"))
test-class-PKNCAresults.Rptr works as a parameter101list(list(message = “ptr_result\(PPORRES[ptr_result\)PPTESTCD %in% "ptr"] not equal to c(2.9055, 2.9885).”, srcref = c(411, 3, 415, 3, 3, 3, 411, 415), expectation_calls = list(expect_equal(ptr_result\(PPORRES[ptr_result\)PPTESTCD %in% “ptr”], c(2.9055, 2.9885), tol = 1e-04)), call = list(expect_equal(ptr_result\(PPORRES[ptr_result\)PPTESTCD %in% “ptr”], c(2.9055, 2.9885), tol = 1e-04)), start_frame = 74, end_frame = 74, test = “ptr works as a parameter”))

+

+

+
Missing and BLQ data cleaners

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Testing FilenameTest DescriptionNumber of TestsNumber of Failed Testspassedresult
test-cleaners.Rclean.conc.na19019list(list(message = "“, srcref = c(5, 3, 6, 82, 3, 82, 5, 6), expectation_calls = list(expect_error(clean.conc.na(conc = 1, time = 1, conc.na =”foo“), regexp =”conc.na must either be a finite number or the text ‘drop’“)), call = list(expect_error(clean.conc.na(conc = 1, time = 1, conc.na =”foo“), regexp =”conc.na must either be a finite number or the text ‘drop’“)), start_frame = 74, end_frame = 74, test =”clean.conc.na“), list(message =”", srcref = c(9, 3, 10, 63, 3, 63, 9, 10), expectation_calls = list(
expect_warning(v1 <- clean.conc.na(conc = as.numeric(NA), time = 1, conc.na =“drop”))), call = list(expect_warning(v1 <- clean.conc.na(conc = as.numeric(NA), time = 1, conc.na = “drop”))), start_frame = 74, end_frame = 74, test = “clean.conc.na”), list(message = “v1 not equal to data.frame(conc = numeric(), time = numeric()).”, srcref = c(11, 3, 12, 58, 3, 58, 11, 12), expectation_calls = list(expect_equal(v1, data.frame(conc = numeric(), time = numeric()))), call = list(expect_equal(v1,
data.frame(conc= numeric(), time= numeric()))), start_frame = 74, end_frame= 74, test = “clean.conc.na”), list(message = "“, srcref = c(13, 3, 15, 34, 3, 34, 13, 15), expectation_calls = list(expect_warning(v2 <- clean.conc.na(conc = as.numeric(c(NA, NA)), time = 1:2, conc.na =”drop“))), call = list(expect_warning(v2 <- clean.conc.na(conc = as.numeric(c(NA, NA)), time = 1:2, conc.na =”drop“))), start_frame = 74, end_frame = 74, test =”clean.conc.na“), list(message =”v2 not equal to data.frame(conc = numeric(), time = numeric()).",
srcref = c(16,3, 17, 58, 3, 58, 16, 17), expectation_calls = list(expect_equal(v2, data.frame(conc = numeric(), time = numeric()))), call = list(expect_equal(v2, data.frame(conc = numeric(), time = numeric()))), start_frame = 74, end_frame = 74, test = “clean.conc.na”), list(message = “clean.conc.na(conc = c(1, NA), time = 1:2, conc.na = "drop") not equal to data.frame(conc = 1, time = 1).”, srcref = c(18, 3, 19, 42, 3, 42, 18, 19), expectation_calls = list(expect_equal(clean.conc.na(conc = c(1,
NA), time = 1:2, conc.na = “drop”), data.frame(conc= 1, time = 1))), call =list(expect_equal(clean.conc.na(conc = c(1, NA), time = 1:2, conc.na = “drop”), data.frame(conc = 1, time = 1))), start_frame = 74, end_frame = 74, test = “clean.conc.na”), list(message = “clean.conc.na(conc = c(1, NA, 2), time = 1:3, conc.na = "drop") not equal to data.frame(conc = 1:2, time = c(1, 3)).”, srcref = c(20, 3, 22, 38, 3, 38, 20, 22), expectation_calls = list(expect_equal(clean.conc.na(conc = c(1,
NA, 2), time =1:3, conc.na = "drop"), data.frame(conc = 1:2, time = c(1, 3)), check.attributes = FALSE)), call = list(expect_equal(clean.conc.na(conc = c(1, NA, 2), time = 1:3, conc.na = “drop”), data.frame(conc = 1:2, time = c(1, 3)), check.attributes = FALSE)), start_frame = 74, end_frame = 74, test = “clean.conc.na”), list(message = "", srcref = c(25, 3, 26, 58, 3, 58, 25, 26), expectation_calls = list(expect_warning(v3 <- clean.conc.na(conc = as.numeric(NA), time = 1, conc.na = 5))), call = list(
expect_warning(v3 <- clean.conc.na(conc = as.numeric(NA), time = 1, conc.na =5))), start_frame = 74, end_frame = 74, test = “clean.conc.na”), list(message = “v3 not equal to data.frame(conc = 5, time = 1).”, srcref = c(27, 3, 28, 42, 3, 42, 27, 28), expectation_calls = list(expect_equal(v3, data.frame(conc = 5, time = 1))), call = list(expect_equal(v3, data.frame(conc = 5, time = 1))), start_frame = 74, end_frame = 74, test = “clean.conc.na”), list(message = "", srcref = c(29, 3, 30,
55, 3, 55, 29, 30),expectation_calls= list(expect_warning(v4 <- clean.conc.na(conc = c(NA, NA), time = 1:2, conc.na = 5))), call = list(expect_warning(v4 <- clean.conc.na(conc = c(NA, NA), time = 1:2, conc.na = 5))), start_frame = 74, end_frame = 74, test = “clean.conc.na”), list(message = “v4 not equal to data.frame(conc = c(5, 5), time = 1:2).”, srcref = c(31, 3, 32, 50, 3, 50, 31, 32), expectation_calls = list(expect_equal(v4, data.frame(conc = c(5, 5), time = 1:2))), call = list(expect_equal(v4,
data.frame(conc= c(5, 5), time =1:2))), start_frame = 74, end_frame = 74, test = "clean.conc.na“), list(message =”clean.conc.na(conc = c(1, NA), time = 1:2, conc.na = 5) not equal to data.frame(conc = c(1, 5), time = 1:2).", srcref = c(33, 3, 34, 50, 3, 50, 33, 34), expectation_calls = list(expect_equal(clean.conc.na(conc = c(1, NA), time = 1:2, conc.na = 5), data.frame(conc = c(1, 5), time = 1:2))), call = list(expect_equal(clean.conc.na(conc = c(1, NA), time = 1:2, conc.na = 5), data.frame(conc = c(1,
5), time = 1:2))), start_frame = 74, end_frame = 74,test = “clean.conc.na”),list(message = “clean.conc.na(conc = c(1, NA, 2), time = 1:3, conc.na = 5) not equal to data.frame(conc = c(1, 5, 2), time = 1:3).”, srcref = c(35, 3, 36, 53, 3, 53, 35, 36), expectation_calls = list(expect_equal(clean.conc.na(conc = c(1, NA, 2), time = 1:3, conc.na = 5), data.frame(conc = c(1, 5, 2), time = 1:3))), call = list(expect_equal(clean.conc.na(conc = c(1, NA, 2), time = 1:3, conc.na = 5), data.frame(conc = c(1,
5, 2), time = 1:3))), start_frame= 74, end_frame =74, test = "clean.conc.na"), list(message = “clean.conc.na(conc = 0, time = 1, conc.na = "drop") not equal to data.frame(conc = 0, time = 1).”, srcref = c(39, 3, 40, 42, 3, 42, 39, 40), expectation_calls = list(expect_equal(clean.conc.na(conc = 0, time = 1, conc.na = “drop”), data.frame(conc = 0, time = 1))), call = list(expect_equal(clean.conc.na(conc = 0, time = 1, conc.na = “drop”), data.frame(conc = 0, time = 1))), start_frame = 74,
end_frame = 74,test = "clean.conc.na"), list(message = "clean.conc.na(conc =c(0, 0),time = 1:2, conc.na = "drop") not equal to data.frame(conc = c(0, 0), time = 1:2).“, srcref = c(41, 3, 42, 50, 3, 50, 41, 42), expectation_calls = list(expect_equal(clean.conc.na(conc = c(0, 0), time = 1:2, conc.na =”drop“), data.frame(conc = c(0, 0), time = 1:2))), call = list(expect_equal(clean.conc.na(conc = c(0, 0), time = 1:2, conc.na =”drop"), data.frame(conc = c(0, 0), time = 1:2))), start_frame = 74,
end_frame = 74,test = "clean.conc.na"), list(message = "clean.conc.na(conc =c(1, 0),time = 1:2, conc.na = "drop") not equal to data.frame(conc = c(1, 0), time = 1:2).“, srcref = c(43, 3, 44, 50, 3, 50, 43, 44), expectation_calls = list(expect_equal(clean.conc.na(conc = c(1, 0), time = 1:2, conc.na =”drop“), data.frame(conc = c(1, 0), time = 1:2))), call = list(expect_equal(clean.conc.na(conc = c(1, 0), time = 1:2, conc.na =”drop"), data.frame(conc = c(1, 0), time = 1:2))), start_frame = 74,
end_frame = 74,test = "clean.conc.na"), list(message = "clean.conc.na(conc =c(1, 0,2), time = 1:3, conc.na = "drop") not equal to data.frame(conc = c(1, 0, 2), time = 1:3).“, srcref = c(45, 3, 46, 53, 3, 53, 45, 46), expectation_calls = list(expect_equal(clean.conc.na(conc = c(1, 0, 2), time = 1:3, conc.na =”drop“), data.frame(conc = c(1, 0, 2), time = 1:3))), call = list(expect_equal(clean.conc.na(conc = c(1, 0, 2), time = 1:3, conc.na =”drop"), data.frame(conc = c(1, 0, 2), time = 1:3))),
start_frame = 74, end_frame = 74,test = "clean.conc.na“), list(message =”clean.conc.na(…) not equal to data.frame(conc = 1:3, time = 1:3, extra = c("a", "b", "c")).“, srcref = c(50, 3, 56, 50, 3, 50, 50, 56), expectation_calls = list(expect_equal(clean.conc.na(conc = 1:3, time = 1:3, extra = c(”a“,”b“,”c“), conc.na =”drop“), data.frame(conc = 1:3, time = 1:3, extra = c(”a“,”b“,”c“)))), call = list(expect_equal(clean.conc.na(conc = 1:3, time = 1:3, extra = c(”a“,”b“,”c"),
conc.na = "drop"), data.frame(conc= 1:3, time = 1:3, extra = c(“a”, “b”, “c”)))), start_frame = 74, end_frame = 74, test = “clean.conc.na”), list(message = “clean.conc.na(…) not equal to data.frame(conc = 1:2, time = c(1, 3), extra = c("a", "c")).”, srcref = c(57, 3, 64, 38, 3, 38, 57, 64), expectation_calls = list(expect_equal(clean.conc.na(conc = c(1, NA, 2), time = 1:3, extra = c(“a”, “b”, “c”), conc.na = “drop”), data.frame(conc = 1:2, time = c(1, 3), extra = c(“a”, “c”)), check.attributes = FALSE)),
call = list(expect_equal(clean.conc.na(conc = c(1, NA, 2), time = 1:3, extra= c(“a”,“b”, “c”), conc.na = “drop”), data.frame(conc = 1:2, time = c(1, 3), extra = c(“a”, “c”)), check.attributes = FALSE)), start_frame = 74, end_frame = 74, test = “clean.conc.na”))
test-cleaners.Rclean.conc.blq27027list(list(message = “clean.conc.blq(d.test\(conc, d.test\)time, conc.blq = "drop", conc.na = "drop") not equal to d.test.”, srcref = c(70, 3, 72, 22, 3, 22, 70, 72), expectation_calls = list(expect_equal(clean.conc.blq(d.test\(conc, d.test\)time, conc.blq = “drop”, conc.na = “drop”), d.test)), call = list(expect_equal(clean.conc.blq(d.test\(conc, d.test\)time, conc.blq = “drop”, conc.na = “drop”), d.test)), start_frame = 74, end_frame = 74, test = “clean.conc.blq”), list(message = “clean.conc.blq(d.test\(conc, d.test\)time, conc.blq = "drop", conc.na = "drop") not equal to clean.conc.na(d.test\(conc, d.test\)time, conc.na = "drop").”,
srcref = c(76,3, 78, 71, 3, 71, 76, 78), expectation_calls = list(expect_equal(clean.conc.blq(d.test\(conc, d.test\)time, conc.blq = “drop”, conc.na = “drop”), clean.conc.na(d.test\(conc, d.test\)time, conc.na = “drop”))), call = list(expect_equal(clean.conc.blq(d.test\(conc, d.test\)time, conc.blq = “drop”, conc.na = “drop”), clean.conc.na(d.test\(conc, d.test\)time, conc.na = “drop”))), start_frame = 74, end_frame = 74, test = “clean.conc.blq”), list(message = “clean.conc.blq(d.test\(conc, d.test\)time, conc.blq = "drop", conc.na = "drop") not equal to d.test[2, ].”,
srcref = c(83,3, 85, 26, 3, 26, 83, 85), expectation_calls = list(expect_equal(clean.conc.blq(d.test\(conc, d.test\)time, conc.blq = “drop”, conc.na = “drop”), d.test[2, ])), call = list(expect_equal(clean.conc.blq(d.test\(conc, d.test\)time, conc.blq = “drop”, conc.na = “drop”), d.test[2, ])), start_frame = 74, end_frame = 74, test = “clean.conc.blq”), list(message = “clean.conc.blq(…) not equal to d.test.”, srcref = c(88, 3, 94, 22, 3, 22, 88, 94), expectation_calls = list(expect_equal(clean.conc.blq(d.test$conc,
d.test$time, conc.blq = list(first= “keep”, middle= “drop”, last = “drop”),conc.na= “drop”), d.test)), call = list(expect_equal(clean.conc.blq(d.test\(conc, d.test\)time, conc.blq = list(first = “keep”, middle = “drop”, last = “drop”), conc.na = “drop”), d.test)), start_frame = 74, end_frame = 74, test = “clean.conc.blq”), list(message = "“, srcref = c(98, 3, 104, 93, 3, 93, 98, 104), expectation_calls = list(expect_error(clean.conc.blq(d.test\(conc, d.test\)time, conc.blq = list(first =”foo",
middle = “drop”, last = “drop”), conc.na = “drop”),regexp = "conc.blq must either bea finite number or the text ‘drop’ or ‘keep’“)), call = list(expect_error(clean.conc.blq(d.test\(conc, d.test\)time, conc.blq = list(first =”foo“, middle =”drop“, last =”drop“), conc.na =”drop“), regexp =”conc.blq must either be a finite number or the text ‘drop’ or ‘keep’“)), start_frame = 74, end_frame = 74, test =”clean.conc.blq“), list(message =”", srcref = c(105, 3, 111, 93, 3, 93, 105, 111), expectation_calls = list(
expect_error(clean.conc.blq(d.test\(conc, d.test\)time, conc.blq = list(first =“keep”,middle = “foo”, last = “drop”), conc.na = “drop”), regexp = “conc.blq must either be a finite number or the text ‘drop’ or ‘keep’”)), call = list(expect_error(clean.conc.blq(d.test\(conc, d.test\)time, conc.blq = list(first = “keep”, middle = “foo”, last = “drop”), conc.na = “drop”), regexp = “conc.blq must either be a finite number or the text ‘drop’ or ‘keep’”)), start_frame = 74, end_frame = 74, test = “clean.conc.blq”),
list(message ="", srcref = c(112,3, 118, 93, 3, 93, 112, 118), expectation_calls = list(expect_error(clean.conc.blq(d.test\(conc, d.test\)time, conc.blq = list(first = “keep”, middle = “drop”, last = “foo”), conc.na = “drop”), regexp = “conc.blq must either be a finite number or the text ‘drop’ or ‘keep’”)), call = list(expect_error(clean.conc.blq(d.test\(conc, d.test\)time, conc.blq = list(first = “keep”, middle = “drop”, last = “foo”), conc.na = “drop”), regexp = “conc.blq must either be a finite number or the text ‘drop’ or ‘keep’”)),
start_frame= 74, end_frame =74, test = "clean.conc.blq"), list(message= "clean.conc.blq(d.test\(conc, d.test\)time, conc.blq = "drop", conc.na = "drop") not equal to d.test[1, ].“, srcref = c(123, 3, 125, 26, 3, 26, 123, 125), expectation_calls = list(expect_equal(clean.conc.blq(d.test\(conc, d.test\)time, conc.blq =”drop“, conc.na =”drop“), d.test[1, ])), call = list(expect_equal(clean.conc.blq(d.test\(conc, d.test\)time, conc.blq =”drop“, conc.na =”drop"), d.test[1, ])), start_frame = 74,
end_frame =74, test = "clean.conc.blq"), list(message = "clean.conc.blq(…) notequal to d.test.“, srcref = c(128, 3, 134, 22, 3, 22, 128, 134), expectation_calls = list(expect_equal(clean.conc.blq(d.test\(conc, d.test\)time, conc.blq = list(first =”drop“, middle =”drop“, last =”keep“), conc.na =”drop“), d.test)), call = list(expect_equal(clean.conc.blq(d.test\(conc, d.test\)time, conc.blq = list(first =”drop“, middle =”drop“, last =”keep“), conc.na =”drop"), d.test)), start_frame = 74,
end_frame =74, test = "clean.conc.blq"), list(message = "clean.conc.blq(d.test$conc, d.test\(time, conc.blq = \"drop\", conc.na = \"drop\") not equal to d.test[2, ].\nTRUE", srcref = c(139, 3, 141, 26, 3, 26, 139, 141), expectation_calls = list(expect_equal(clean.conc.blq(d.test\)conc, d.test\(time, conc.blq = "drop", conc.na = "drop"), d.test[2, ])), call = list(expect_equal(clean.conc.blq(d.test\)conc, d.test$time, conc.blq = “drop”, conc.na = “drop”), d.test[2, ])), start_frame = 74, end_frame = 74,
test = "clean.conc.blq"), list(message = "clean.conc.blq(d.test$conc, d.test$time,conc.blq = "drop", conc.na = "drop") not equal to d.test[c(), ].“, srcref = c(145, 3, 147, 28, 3, 28, 145, 147), expectation_calls = list(expect_equal(clean.conc.blq(d.test\(conc, d.test\)time, conc.blq =”drop“, conc.na =”drop“), d.test[c(), ])), call = list(expect_equal(clean.conc.blq(d.test\(conc, d.test\)time, conc.blq =”drop“, conc.na =”drop"), d.test[c(), ])), start_frame = 74, end_frame = 74,
test = "clean.conc.blq"), list(message = "clean.conc.blq(d.test$conc, d.test$time,conc.blq = "drop", conc.na = "drop") not equal to d.test[-2, ].“, srcref = c(152, 3, 154, 27, 3, 27, 152, 154), expectation_calls = list(expect_equal(clean.conc.blq(d.test\(conc, d.test\)time, conc.blq =”drop“, conc.na =”drop“), d.test[-2, ])), call = list(expect_equal(clean.conc.blq(d.test\(conc, d.test\)time, conc.blq =”drop“, conc.na =”drop“), d.test[-2, ])), start_frame = 74, end_frame = 74, test =”clean.conc.blq"),
list(message ="clean.conc.blq(d.test\(conc, d.test\)time, conc.blq = "keep",conc.na= "drop") not equal to d.test.“, srcref = c(157, 3, 159, 22, 3, 22, 157, 159), expectation_calls = list(expect_equal(clean.conc.blq(d.test\(conc, d.test\)time, conc.blq =”keep“, conc.na =”drop“), d.test)), call = list(expect_equal(clean.conc.blq(d.test\(conc, d.test\)time, conc.blq =”keep“, conc.na =”drop“), d.test)), start_frame = 74, end_frame = 74, test =”clean.conc.blq“), list(message =”clean.conc.blq(d.test\(conc, d.test\)time, conc.blq = 0.5, conc.na = "drop") not equal to d.result.",
srcref = c(163, 3, 165, 24, 3,24, 163, 165), expectation_calls = list(expect_equal(clean.conc.blq(d.test\(conc, d.test\)time, conc.blq = 0.5, conc.na = “drop”), d.result)), call = list(expect_equal(clean.conc.blq(d.test\(conc, d.test\)time, conc.blq = 0.5, conc.na = “drop”), d.result)), start_frame = 74, end_frame = 74, test = “clean.conc.blq”), list(message = “clean.conc.blq(d.test\(conc, d.test\)time, conc.blq = "drop", conc.na = "drop") not equal to d.test[c(2, 4), ].”, srcref = c(170,
3, 172, 32, 3,32, 170, 172), expectation_calls = list(expect_equal(clean.conc.blq(d.test\(conc, d.test\)time, conc.blq = “drop”, conc.na = “drop”), d.test[c(2, 4), ])), call = list(expect_equal(clean.conc.blq(d.test\(conc, d.test\)time, conc.blq = “drop”, conc.na = “drop”), d.test[c(2, 4), ])), start_frame = 74, end_frame = 74, test = “clean.conc.blq”), list(message = “clean.conc.blq(…) not equal to …[].”, srcref = c(176, 9, 187, 53, 9, 53, 176, 187), expectation_calls = list(expect_equal(clean.conc.blq(d.test$conc,
d.test$time, conc.blq = list(first = first, middle = middle, last = last), conc.na= 0), d.test[c(first %in% “keep”, TRUE, middle %in% “keep”, TRUE, last %in% “keep”), ], info = paste(first, middle, last))), call = list(expect_equal(clean.conc.blq(d.test\(conc, d.test\)time, conc.blq = list(first = first, middle = middle, last = last), conc.na = 0), d.test[c(first %in% “keep”, TRUE, middle %in% “keep”, TRUE, last %in% “keep”), ], info = paste(first, middle, last))), start_frame = 74, end_frame = 74,
test = "clean.conc.blq"), list(message = "clean.conc.blq(…) not equal to …[].\nTRUE", srcref = c(176, 9, 187, 53, 9, 53, 176, 187), expectation_calls = list(expect_equal(clean.conc.blq(d.test\(conc, d.test\)time, conc.blq = list(first = first, middle = middle, last = last), conc.na = 0), d.test[c(first %in% “keep”, TRUE, middle %in% “keep”, TRUE, last %in% “keep”), ], info = paste(first, middle, last))), call = list(expect_equal(clean.conc.blq(d.test\(conc, d.test\)time, conc.blq = list(first = first,
middle = middle, last = last),conc.na = 0), d.test[c(first %in% “keep”,TRUE, middle %in% “keep”, TRUE, last %in% “keep”), ], info = paste(first, middle, last))), start_frame = 74, end_frame = 74, test = “clean.conc.blq”), list(message = “clean.conc.blq(…) not equal to …[].”, srcref = c(176, 9, 187, 53, 9, 53, 176, 187), expectation_calls = list(expect_equal(clean.conc.blq(d.test\(conc, d.test\)time, conc.blq = list(first = first, middle = middle, last = last), conc.na = 0), d.test[c(first %in%
“keep”, TRUE, middle %in% "keep", TRUE, last %in% “keep”), ], info = paste(first,middle, last))), call = list(expect_equal(clean.conc.blq(d.test\(conc, d.test\)time, conc.blq = list(first = first, middle = middle, last = last), conc.na = 0), d.test[c(first %in% “keep”, TRUE, middle %in% “keep”, TRUE, last %in% “keep”), ], info = paste(first, middle, last))), start_frame = 74, end_frame = 74, test = “clean.conc.blq”), list(message = “clean.conc.blq(…) not equal to …[].”, srcref = c(176,
9, 187, 53, 9,53, 176, 187), expectation_calls = list(expect_equal(clean.conc.blq(d.test\(conc, d.test\)time, conc.blq = list(first = first, middle = middle, last = last), conc.na = 0), d.test[c(first %in% “keep”, TRUE, middle %in% “keep”, TRUE, last %in% “keep”), ], info = paste(first, middle, last))), call = list(expect_equal(clean.conc.blq(d.test\(conc, d.test\)time, conc.blq = list(first = first, middle = middle, last = last), conc.na = 0), d.test[c(first %in% “keep”, TRUE, middle %in% “keep”,
TRUE, last%in% “keep”), ], info = paste(first,middle, last))), start_frame = 74,end_frame = 74, test = “clean.conc.blq”), list(message = “clean.conc.blq(…) not equal to …[].”, srcref = c(176, 9, 187, 53, 9, 53, 176, 187), expectation_calls = list(expect_equal(clean.conc.blq(d.test\(conc, d.test\)time, conc.blq = list(first = first, middle = middle, last = last), conc.na = 0), d.test[c(first %in% “keep”, TRUE, middle %in% “keep”, TRUE, last %in% “keep”), ], info = paste(first, middle,
last))), call = list(expect_equal(clean.conc.blq(d.test\(conc, d.test\)time, conc.blq = list(first = first, middle = middle, last = last), conc.na = 0), d.test[c(first %in% “keep”, TRUE, middle %in% “keep”, TRUE, last %in% “keep”), ], info = paste(first, middle, last))), start_frame = 74, end_frame = 74, test = “clean.conc.blq”), list(message = “clean.conc.blq(…) not equal to …[].”, srcref = c(176, 9, 187, 53, 9, 53, 176, 187), expectation_calls = list(expect_equal(clean.conc.blq(d.test$conc,
d.test$time, conc.blq = list(first = first, middle = middle, last = last), conc.na= 0), d.test[c(first %in% “keep”, TRUE, middle %in% “keep”, TRUE, last %in% “keep”), ], info = paste(first, middle, last))), call = list(expect_equal(clean.conc.blq(d.test\(conc, d.test\)time, conc.blq = list(first = first, middle = middle, last = last), conc.na = 0), d.test[c(first %in% “keep”, TRUE, middle %in% “keep”, TRUE, last %in% “keep”), ], info = paste(first, middle, last))), start_frame = 74, end_frame = 74,
test = "clean.conc.blq"), list(message = "clean.conc.blq(…) not equal to …[].\nTRUE", srcref = c(176, 9, 187, 53, 9, 53, 176, 187), expectation_calls = list(expect_equal(clean.conc.blq(d.test\(conc, d.test\)time, conc.blq = list(first = first, middle = middle, last = last), conc.na = 0), d.test[c(first %in% “keep”, TRUE, middle %in% “keep”, TRUE, last %in% “keep”), ], info = paste(first, middle, last))), call = list(expect_equal(clean.conc.blq(d.test\(conc, d.test\)time, conc.blq = list(first = first,
middle = middle, last = last),conc.na = 0), d.test[c(first %in% “keep”,TRUE, middle %in% “keep”, TRUE, last %in% “keep”), ], info = paste(first, middle, last))), start_frame = 74, end_frame = 74, test = “clean.conc.blq”), list(message = “clean.conc.blq(…) not equal to …[].”, srcref = c(176, 9, 187, 53, 9, 53, 176, 187), expectation_calls = list(expect_equal(clean.conc.blq(d.test\(conc, d.test\)time, conc.blq = list(first = first, middle = middle, last = last), conc.na = 0), d.test[c(first %in%
“keep”, TRUE, middle %in% "keep", TRUE, last %in% “keep”), ], info = paste(first,middle, last))), call = list(expect_equal(clean.conc.blq(d.test\(conc, d.test\)time, conc.blq = list(first = first, middle = middle, last = last), conc.na = 0), d.test[c(first %in% “keep”, TRUE, middle %in% “keep”, TRUE, last %in% “keep”), ], info = paste(first, middle, last))), start_frame = 74, end_frame = 74, test = “clean.conc.blq”), list(message = “clean.conc.blq(d.test\(conc, d.test\)time, conc.blq = "drop", conc.na = 0) not equal to d.test[c(2, 4), ].”,
srcref = c(194, 3, 196, 32, 3,32, 194, 196), expectation_calls = list(expect_equal(clean.conc.blq(d.test\(conc, d.test\)time, conc.blq = “drop”, conc.na = 0), d.test[c(2, 4), ])), call = list(expect_equal(clean.conc.blq(d.test\(conc, d.test\)time, conc.blq = “drop”, conc.na = 0), d.test[c(2, 4), ])), start_frame = 74, end_frame = 74, test = “clean.conc.blq”), list(message = “clean.conc.blq(d.test\(conc, d.test\)time, conc.blq = "drop", conc.na = 0.5) not equal to d.result[2:4, ].”, srcref = c(201,
3, 203, 30, 3,30, 201, 203), expectation_calls = list(expect_equal(clean.conc.blq(d.test\(conc, d.test\)time, conc.blq = “drop”, conc.na = 0.5), d.result[2:4, ])), call = list(expect_equal(clean.conc.blq(d.test\(conc, d.test\)time, conc.blq = “drop”, conc.na = 0.5), d.result[2:4, ])), start_frame = 74, end_frame = 74, test = “clean.conc.blq”), list(message = “clean.conc.blq(…) not equal to d.result[2:4, ].”, srcref = c(208, 3, 211, 30, 3, 30, 208, 211), expectation_calls = list(expect_equal(clean.conc.blq(d.test$conc,
d.test$time, more = d.test$more, conc.blq = "drop", conc.na = 0.5), d.result[2:4,])), call = list(expect_equal(clean.conc.blq(d.test\(conc, d.test\)time, more = d.test\(more, conc.blq = "drop", conc.na = 0.5), d.result[2:4, ])), start_frame = 74, end_frame = 74, test = "clean.conc.blq"), list(message = "clean.conc.blq(...) not equal to d.test[c(2, 4), ].\nTRUE", srcref = c(213, 3, 216, 31, 3, 31, 213, 216), expectation_calls = list(expect_equal(clean.conc.blq(d.test\)conc, d.test\(time, more = d.test\)more,
conc.blq =“drop”, conc.na = "drop"), d.test[c(2, 4), ])), call = list(expect_equal(clean.conc.blq(d.test\(conc, d.test\)time, more = d.test$more, conc.blq = “drop”, conc.na = “drop”), d.test[c(2, 4), ])), start_frame = 74, end_frame = 74, test = “clean.conc.blq”))

+

+

+
exclude

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Testing FilenameTest DescriptionNumber of TestsNumber of Failed Testspassedresult
test-exclude.RsetExcludeColumn14014list(list(message = “setExcludeColumn(list(data = data.frame(a = 1), exclude = "fake")) not equal to list(data = data.frame(a = 1), exclude = "fake").”, srcref = c(5, 3, 9, 90, 3, 90, 5, 9), expectation_calls = list(expect_equal(setExcludeColumn(list(data = data.frame(a = 1), exclude = “fake”)), list(data = data.frame(a = 1), exclude = “fake”), info = “setExcludeColumn does nothing if the exclude name is already given.”)), call = list(expect_equal(setExcludeColumn(list(data = data.frame(a = 1),
exclude = "fake“)), list(data = data.frame(a = 1), exclude =”fake"), info = "setExcludeColumn does nothing ifthe exclude name is already given.“)), start_frame = 74, end_frame = 74, test =”setExcludeColumn“), list(message =”setExcludeColumn(list(data = data.frame(a = 1))) not equal to list(…).", srcref = c(10, 3, 13, 67, 3, 67, 10, 13), expectation_calls = list(expect_equal(setExcludeColumn(list(data = data.frame(a = 1))), list(data = data.frame(a = 1, exclude = NA, stringsAsFactors = FALSE),
exclude = "exclude“), info =”setExcludeColumn adds a column namedexclude")), call =list(expect_equal(setExcludeColumn(list(data = data.frame(a = 1))), list(data = data.frame(a = 1, exclude = NA, stringsAsFactors = FALSE), exclude = “exclude”), info = “setExcludeColumn adds a column named exclude”)), start_frame = 74, end_frame = 74, test = “setExcludeColumn”), list(message = “setExcludeColumn(list(data = data.frame(a = 1, exclude = 2))) not equal to list(…).”, srcref = c(14, 3, 17,
107, 3, 107, 14, 17), expectation_calls = list(expect_equal(setExcludeColumn(list(data =data.frame(a = 1, exclude= 2))),list(data = data.frame(a = 1, exclude = 2, exclude.exclude = NA, stringsAsFactors = FALSE), exclude = “exclude.exclude”), info = “setExcludeColumn adds a column named exclude.exclude if ‘exclude’ is already present”)), call = list(expect_equal(setExcludeColumn(list(data = data.frame(a = 1, exclude = 2))), list(data = data.frame(a = 1, exclude = 2, exclude.exclude = NA, stringsAsFactors = FALSE),
exclude = "exclude.exclude“), info =”setExcludeColumn adds a column named exclude.exclude if ‘exclude’ is already present“)), start_frame = 74, end_frame = 74, test =”setExcludeColumn“), list(message =”setExcludeColumn(list(results = data.frame(a = 1)), dataname = "results") not equal to list(…).“, srcref = c(18, 3, 21, 72, 3, 72, 18, 21), expectation_calls = list(expect_equal(setExcludeColumn(list(results = data.frame(a = 1)), dataname =”results"), list(results = data.frame(a = 1,
exclude = NA, stringsAsFactors = FALSE), exclude = “exclude”), info= "setExcludeColumn works with an alternate dataname“)), call = list(expect_equal(setExcludeColumn(list(results = data.frame(a = 1)), dataname =”results“), list(results = data.frame(a = 1, exclude = NA, stringsAsFactors = FALSE), exclude =”exclude“), info =”setExcludeColumn works with an alternate dataname“)), start_frame = 74, end_frame = 74, test =”setExcludeColumn“), list(message =”setExcludeColumn(…) not equal to list(data = data.frame(a = 1, exclude = 2), exclude = "exclude").",
srcref = c(24,3, 29, 85, 3, 85, 24, 29), expectation_calls = list(expect_equal(setExcludeColumn(list(data = data.frame(a = 1, exclude = 2), exclude = “exclude”), exclude = “exclude”), list(data = data.frame(a = 1, exclude = 2), exclude = “exclude”), info = “setExcludeColumn does nothing if exclude is given and matching”)), call = list(expect_equal(setExcludeColumn(list(data = data.frame(a = 1, exclude = 2), exclude = “exclude”), exclude = “exclude”), list(data = data.frame(a = 1, exclude = 2),
exclude = "exclude“), info =”setExcludeColumn does nothing ifexclude is given and matching")), start_frame = 74,end_frame = 74, test = “setExcludeColumn”), list(message = "“, srcref = c(30, 3, 34, 91, 3, 91, 30, 34), expectation_calls = list(expect_error(setExcludeColumn(list(data = data.frame(a = 1, exclude = 2), exclude =”exclude“), exclude =”foo“), regexp =”exclude is already set for the object.“, info =”setExcludeColumn gives an error if exclude is given and not matching")), call = list(
expect_error(setExcludeColumn(list(data = data.frame(a = 1, exclude= 2), exclude = "exclude“), exclude =”foo"), regexp = “exclude is already set for the object.”, info = “setExcludeColumn gives an error if exclude is given and not matching”)), start_frame = 74, end_frame = 74, test = “setExcludeColumn”), list(message = "“, srcref = c(35, 3, 38, 75, 3, 75, 35, 38), expectation_calls = list(expect_error(setExcludeColumn(list(data = data.frame(a = 1)), exclude =”exclude“), regexp =”exclude, if given, must be a column name in the input data.",
info = "setExcludeColumn exclude column must be in the data.")), call = list(expect_error(setExcludeColumn(list(data =data.frame(a = 1)), exclude = “exclude”), regexp = “exclude, if given, must be a column name in the input data.”, info = “setExcludeColumn exclude column must be in the data.”)), start_frame = 74, end_frame = 74, test = “setExcludeColumn”), list(message = “setExcludeColumn(…) not equal to list(…).”, srcref = c(39, 3, 43, 75, 3, 75, 39, 43), expectation_calls = list(
expect_equal(setExcludeColumn(list(data = data.frame(a = 1, exclude= factor(“a”))),exclude = “exclude”), list(data =data.frame(a = 1, exclude = “a”, stringsAsFactors = FALSE), exclude = “exclude”), info = “setExcludeColumn converts factor column to character”)), call = list(expect_equal(setExcludeColumn(list(data = data.frame(a = 1, exclude = factor(“a”))), exclude = “exclude”), list(data = data.frame(a = 1, exclude = “a”, stringsAsFactors = FALSE), exclude = “exclude”), info = “setExcludeColumn converts factor column to character”)),
start_frame = 74, end_frame = 74, test = “setExcludeColumn”), list(message = "setExcludeColumn(…) not equalto list(...).“, srcref = c(44, 3, 48, 79, 3, 79, 44, 48), expectation_calls = list(expect_equal(setExcludeColumn(list(data = data.frame(a = 1, exclude = NA, stringsAsFactors = FALSE)), exclude =”exclude“), list(data = data.frame(a = 1, exclude = NA, stringsAsFactors = FALSE), exclude =”exclude“), info =”setExcludeColumn converts logical NA column to character")), call = list(
expect_equal(setExcludeColumn(list(data = data.frame(a = 1, exclude= NA, stringsAsFactors = FALSE)), exclude= "exclude“), list(data = data.frame(a = 1, exclude = NA, stringsAsFactors = FALSE), exclude =”exclude“), info =”setExcludeColumn converts logical NA column to character“)), start_frame = 74, end_frame = 74, test =”setExcludeColumn“), list(message =”", srcref = c(49, 3, 52, 75, 3, 75, 49, 52), expectation_calls = list(expect_error(setExcludeColumn(list(data = data.frame(a = 1, exclude = FALSE,
stringsAsFactors = FALSE)), exclude = “exclude”), regexp = "excludecolumn must be character vector or something convertable to character without loss of information.“, info =”setExcludeColumn gives error on logical non-NA value“)), call = list(expect_error(setExcludeColumn(list(data = data.frame(a = 1, exclude = FALSE, stringsAsFactors = FALSE)), exclude =”exclude“), regexp =”exclude column must be character vector or something convertable to character without loss of information.“, info =”setExcludeColumn gives error on logical non-NA value")),
start_frame = 74, end_frame = 74, test = “setExcludeColumn”), list(message = "", srcref = c(53, 3, 56, 74, 3,74, 53, 56), expectation_calls = list(expect_error(setExcludeColumn(list(data = data.frame(a = 1, exclude = 5, stringsAsFactors = FALSE)), exclude = “exclude”), regexp = “exclude column must be character vector or something convertable to character without loss of information.”, info = “setExcludeColumn gives error on non-character value”)), call = list(expect_error(setExcludeColumn(list(data = data.frame(a = 1,
exclude = 5, stringsAsFactors = FALSE)), exclude = “exclude”), regexp = "exclude column must be character vector or something convertable to character without loss of information.“, info =”setExcludeColumn gives error on non-character value“)), start_frame = 74, end_frame = 74, test =”setExcludeColumn“), list(message =”", srcref = c(59, 3, 64, 3, 3, 3, 59, 64), expectation_calls = list(expect_equal(expect_warning(setExcludeColumn(list(data = data.frame()))), list(data = data.frame(exclude = NA,
stringsAsFactors = FALSE)[-1, , drop = FALSE], exclude = “exclude”), info = "setExcludeColumn works with zero-row data"), quasi_label(enquo(object), label, arg = “object”), eval_bare(get_expr(quo), get_env(quo)), expect_warning(setExcludeColumn(list(data = data.frame())))), call = list(expect_equal(expect_warning(setExcludeColumn(list(data = data.frame()))), list(data = data.frame(exclude = NA, stringsAsFactors = FALSE)[-1, , drop = FALSE], exclude = “exclude”), info = “setExcludeColumn works with zero-row data”),
quasi_label(enquo(object), label, arg = “object”), eval_bare(get_expr(quo), get_env(quo)), expect_warning(setExcludeColumn(list(data = data.frame())))), start_frame = 74, end_frame = 77, test = “setExcludeColumn”), list(message = “expect_warning(setExcludeColumn(list(data = data.frame()))) not equal to list(…).”, srcref = c(59, 3, 64, 3, 3, 3, 59, 64), expectation_calls = list(expect_equal(expect_warning(setExcludeColumn(list(data = data.frame()))), list(data = data.frame(exclude = NA,
stringsAsFactors = FALSE)[-1, , drop = FALSE], exclude = “exclude”), info = "setExcludeColumn works with zero-row data")), call = list(expect_equal(expect_warning(setExcludeColumn(list(data = data.frame()))), list(data = data.frame(exclude = NA, stringsAsFactors = FALSE)[-1, , drop = FALSE], exclude = “exclude”), info = “setExcludeColumn works with zero-row data”)), start_frame = 74, end_frame = 74, test = “setExcludeColumn”), list(message = “setExcludeColumn(list(data = data.frame()), exclude = "foo") not equal to list(…).”,
srcref = c(65,3, 70, 3, 3, 3, 65, 70), expectation_calls = list(expect_equal(setExcludeColumn(list(data = data.frame()), exclude = “foo”), list(data = data.frame(foo = NA, stringsAsFactors = FALSE)[-1, , drop = FALSE], exclude = “foo”), info = “setExcludeColumn works with zero-row data”)), call = list(expect_equal(setExcludeColumn(list(data = data.frame()), exclude = “foo”), list(data = data.frame(foo = NA, stringsAsFactors = FALSE)[-1, , drop = FALSE], exclude = “foo”), info = “setExcludeColumn works with zero-row data”)),
start_frame = 74, end_frame = 74, test = “setExcludeColumn”))
test-exclude.Rexclude.default17017list(list(message = "“, srcref = c(79, 3, 82, 56, 3, 56, 79, 82), expectation_calls = list(expect_error(exclude.default(obj1, reason =”Just because“), regexp =”Either mask for FUN must be given \(but not both\).“, info =”One of mask and FUN must be given“)), call = list(expect_error(exclude.default(obj1, reason =”Just because“), regexp =”Either mask for FUN must be given \(but not both\).“, info =”One of mask and FUN must be given“)), start_frame = 74, end_frame = 74, test =”exclude.default"),
list(message ="", srcref = c(83, 3, 88, 57, 3, 57, 83, 88), expectation_calls = list(expect_error(exclude.default(obj1, reason = “Just because”, mask = rep(TRUE, 5), FUN = function(x) rep(TRUE, nrow(x\(data))), regexp = "Either mask for FUN must be given \\(but not both\\).", info = "Both mask and FUN may not be given")), call = list(expect_error(exclude.default(obj1, reason = "Just because", mask = rep(TRUE, 5), FUN = function(x) rep(TRUE, nrow(x\)data))), regexp = “Either mask for FUN must be given \(but not both\).”,
info = "Both mask and FUN may not be given")), start_frame = 74, end_frame = 74,test = “exclude.default”), list(message = "“, srcref = c(91, 3, 95, 50, 3, 50, 91, 95), expectation_calls = list(expect_error(exclude.default(obj2, reason =”Just because“, mask = rep(TRUE, 5)), regexp =”object must have an exclude column specified.“, info =”exclude column is required.“)), call = list(expect_error(exclude.default(obj2, reason =”Just because“, mask = rep(TRUE, 5)), regexp =”object must have an exclude column specified.",
info = "exclude column is required.")), start_frame = 74, end_frame = 74, test =“exclude.default”), list(message ="“, srcref = c(98, 3, 102, 60, 3, 60, 98, 102), expectation_calls = list(expect_error(exclude.default(obj3, reason =”Just because“, mask = rep(TRUE, 5)), regexp =”exclude column must exist in object\[\[‘data’\]\].“, info =”exclude column must exist in the data“)), call = list(expect_error(exclude.default(obj3, reason =”Just because“, mask = rep(TRUE, 5)), regexp =”exclude column must exist in object\[\[‘data’\]\].",
info = "exclude column must exist in the data")), start_frame =74, end_frame = 74, test = "exclude.default"), list(message = "“, srcref = c(103, 3, 107, 47, 3, 47, 103, 107), expectation_calls = list(expect_error(exclude.default(obj1, reason =”Just because“, mask = TRUE), regexp =”mask must match the length of the data.“, info =”mask may not be a scalar“)), call = list(expect_error(exclude.default(obj1, reason =”Just because“, mask = TRUE), regexp =”mask must match the length of the data.",
info = "mask may not be a scalar")), start_frame = 74, end_frame = 74, test = "exclude.default"), list(message = "", srcref = c(108, 3, 112, 62, 3, 62, 108, 112), expectation_calls = list(expect_error(exclude.default(obj1, reason = “Just because”, mask = rep(TRUE, 6)), regexp = “mask must match the length of the data.”, info = “mask must match the length of the data.”)), call = list(expect_error(exclude.default(obj1, reason = “Just because”, mask = rep(TRUE, 6)), regexp = “mask must match the length of the data.”,
info = "mask must match the length of the data.")), start_frame= 74, end_frame =74, test = "exclude.default"), list(message = "“, srcref = c(113, 3, 117, 71, 3, 71, 113, 117), expectation_calls = list(expect_error(exclude.default(obj1, reason = 1:2, FUN = function(x, …) TRUE), regexp =”reason must be a scalar or have the same length as the data“, info =”Interpretation of a non-scalar reason is unclear")), call = list(expect_error(exclude.default(obj1, reason = 1:2, FUN = function(x,
…) TRUE),regexp = "reason must be a scalar or have the samelength as the data“, info =”Interpretationof a non-scalar reason is unclear“)), start_frame = 74, end_frame = 74, test =”exclude.default“), list(message =”“, srcref = c(118, 3, 122, 74, 3, 74, 118, 122), expectation_calls = list(expect_error(exclude.default(obj1, reason = 1, FUN = function(x, …) TRUE), regexp =”reason must be a character string.“, info =”Interpretation of a non-character reason is unclear")), call = list(
expect_error(exclude.default(obj1, reason = 1, FUN = function(x, …) TRUE), regexp = "reason must be a character string.“, info =”Interpretation of a non-character reason is unclear“)), start_frame = 74, end_frame = 74, test =”exclude.default“), list(message =”exclude.default(…) not equal to obj4.“, srcref = c(128, 3, 132, 51, 3, 51, 128, 132), expectation_calls = list(expect_equal(exclude.default(obj1, reason =”Just because", mask = c(FALSE, rep(TRUE, nrow(obj1$data) - 1))),
obj4, info= “Mask given as a vector works”)), call = list(expect_equal(exclude.default(obj1, reason = "Just because“, mask = c(FALSE, rep(TRUE, nrow(obj1$data) - 1))), obj4, info =”Mask given as a vector works“)), start_frame = 74, end_frame = 74, test =”exclude.default“), list(message =”exclude.default(…) not equal to obj5.“, srcref = c(137, 3, 141, 58, 3, 58, 137, 141), expectation_calls = list(expect_equal(exclude.default(obj1, reason =”Just because", FUN = function(x, …) c(FALSE,
rep(TRUE, nrow(x) - 1))), obj5, info = "A function returning avector works")), call = list(expect_equal(exclude.default(obj1, reason = “Just because”, FUN = function(x, …) c(FALSE, rep(TRUE, nrow(x) - 1))), obj5, info = “A function returning a vector works”)), start_frame = 74, end_frame = 74, test = “exclude.default”), list(message = “exclude.default(obj1, FUN = exclude_1)\(exclude not equal to rev(exclude.default(obj7, FUN = exclude_1)\)exclude).”, srcref = c(150, 3, 155, 62, 3,
62, 150, 155),expectation_calls = list(expect_equal(exclude.default(obj1, FUN = exclude_1)$exclude, rev(exclude.default(obj7, FUN = exclude_1)\(exclude), info = "Function application is order-invariant")), call = list(expect_equal(exclude.default(obj1, FUN = exclude_1)\)exclude, rev(exclude.default(obj7, FUN = exclude_1)$exclude), info = “Function application is order-invariant”)), start_frame = 74, end_frame = 74, test = “exclude.default”), list(message = “exclude.default(…) not equal to obj5.”,
srcref = c(157, 3, 160, 68, 3, 68, 157, 160), expectation_calls= list(expect_equal(exclude.default(obj1,FUN = function(x, …) c(NA, rep(“Just because”, nrow(x) - 1))), obj5, info = “A function returning a character vector works”)), call = list(expect_equal(exclude.default(obj1, FUN = function(x, …) c(NA, rep(“Just because”, nrow(x) - 1))), obj5, info = “A function returning a character vector works”)), start_frame = 74, end_frame = 74, test = “exclude.default”), list(message = “exclude.default(…) not equal to obj6.”,
srcref = c(165, 3, 173, 41, 3, 41, 165, 173), expectation_calls= list(expect_equal(exclude.default(exclude.default(obj1, reason = “Just because”, FUN = function(x, …) c(FALSE, rep(TRUE, nrow(x) - 1))), reason = “really”, mask = c(TRUE, TRUE, rep(FALSE, nrow(obj1$data) - 2))), obj6, info = “Multiple reasons are tracked.”)), call = list(expect_equal(exclude.default(exclude.default(obj1, reason = “Just because”, FUN = function(x, …) c(FALSE, rep(TRUE, nrow(x) - 1))), reason = “really”,
mask =c(TRUE, TRUE, rep(FALSE, nrow(obj1$data) - 2))), obj6, info = "Multiple reasons are tracked.")), start_frame = 74, end_frame = 74, test = “exclude.default”), list(message = “exclude(…) not equal to dose_obj_ex1.”, srcref = c(180, 3, 182, 75, 3, 75, 180, 182), expectation_calls = list(expect_equal(exclude(dose_obj, reason = “Not 1”, FUN = function(x, …) x$ID == 1), dose_obj_ex1, info = “exclude works for PKNCAdose objects (with functions)”)), call = list(expect_equal(exclude(dose_obj,
reason = "Not 1", FUN = function(x, …) x$ID == 1), dose_obj_ex1, info = "exclude works for PKNCAdose objects (with functions)“)), start_frame = 74, end_frame = 74, test =”exclude.default“), list(message =”…[] not equal to rep(NA_real_, 2).“, srcref = c(190, 3, 193, 51, 3, 51, 190, 193), expectation_calls = list(expect_equal(result_obj_ex1\(result\)PPORRES[result_obj_ex1\(result\)ID == 1 & result_obj_ex1\(result\)PPTESTCD == "cl.last"], rep(NA, 2), info =”exclude of dose is respected")),
call = list(expect_equal(result_obj_ex1\(result\)PPORRES[result_obj_ex1\(result\)ID == 1 & result_obj_ex1$result$PPTESTCD == “cl.last”], rep(NA, 2), info = “exclude of dose is respected”)), start_frame = 74, end_frame = 74, test = “exclude.default”), list(message = “exclude(…) not equal to result_obj_not_1.”, srcref = c(198, 3, 200, 60, 3, 60, 198, 200), expectation_calls = list(expect_equal(exclude(result_obj, reason = “Not 1”, FUN = function(x, …) x$ID == 1), result_obj_not_1, info = “exclude works for PKNCAresults object”)),
call = list(expect_equal(exclude(result_obj, reason = “Not 1”,FUN = function(x,…) x$ID == 1), result_obj_not_1,info = “exclude works for PKNCAresults object”)), start_frame = 74, end_frame = 74, test = “exclude.default”), list(message = “any(summary(result_obj)\(cl.last == summary(result_obj_not_1)\)cl.last) isn’t false.”, srcref = c(202, 3, 203, 60, 3, 60, 202, 203), expectation_calls = list(expect_false(any(summary(result_obj)\(cl.last == summary(result_obj_not_1)\)cl.last), info = “summary.PKNCAresults respects exclude”)),
call = list(expect_false(any(summary(result_obj)$cl.last == summary(result_obj_not_1)$cl.last), info = "summary.PKNCAresults respects exclude“)), start_frame = 74, end_frame = 74, test =”exclude.default"))
test-exclude.Rnormalize_exclude makes blanks into NA_character_303list(list(message = “normalize_exclude(obj1) not equal to rep(NA_character_, nrow(my_conc)).”, srcref = c(214, 3, 216, 72, 3, 72, 214, 216), expectation_calls = list(expect_equal(normalize_exclude(obj1), rep(NA, nrow(my_conc)), info = “normalize_exclude makes blanks into NA_character_”)), call = list(expect_equal(normalize_exclude(obj1), rep(NA, nrow(my_conc)), info = “normalize_exclude makes blanks into NA_character_”)), start_frame = 74, end_frame = 74, test = “normalize_exclude makes blanks into NA_character_”),
list(message ="normalize_exclude(obj2) not equal to c(NA_character_, "foo", rep(NAcharacter, nrow(my_conc) - 2)).\nEqual“, srcref = c(219, 3, 221, 100, 3, 100, 219, 221), expectation_calls = list(expect_equal(normalize_exclude(obj2), c(NA,”foo“, rep(NA, nrow(my_conc) - 2)), info =”normalize_exclude makes blanks into NA_character_ and leaves non-blank alone.“)), call = list(expect_equal(normalize_exclude(obj2), c(NA,”foo“, rep(NA, nrow(my_conc) - 2)), info =”normalize_exclude makes blanks into NA_character_ and leaves non-blank alone.")),
start_frame= 74, end_frame = 74, test = "normalize_exclude makes blanks into NA_character_"), list(message = "normalize_exclude(1:5) not equal to 1:5.“, srcref = c(222, 3, 223, 94, 3, 94, 222, 223), expectation_calls = list(expect_equal(normalize_exclude(1:5), 1:5, info =”normalize_exclude works with bare vectors (as opposed to PKNCA objects)“)), call = list(expect_equal(normalize_exclude(1:5), 1:5, info =”normalize_exclude works with bare vectors (as opposed to PKNCA objects)")),
start_frame= 74, end_frame = 74, test = "normalize_exclude makes blanks into NA_character_"))

+

+

+
exclude_nca

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Testing FilenameTest DescriptionNumber of TestsNumber of Failed Testspassedresult
test-exclude_nca.Rexclude_nca909list(list(message = “as.data.frame(my_result_excluded)\(exclude not equal to c(...).\nEqual", srcref = c(9, 3, 11, 58, 3, 58, 9, 11), expectation_calls = list(expect_equal(as.data.frame(my_result_excluded)\)exclude, c(rep(NA, nrow(my_result_excluded\(result) - 2), rep("AUC percent extrapolated > 20", 2)))), call = list(expect_equal(as.data.frame(my_result_excluded)\)exclude, c(rep(NA, nrow(my_result_excluded$result) - 2), rep(”AUC percent extrapolated > 20“, 2)))), start_frame = 74, end_frame = 74, test =”exclude_nca"),
list(message = "as.data.frame(my_result_excluded)$exclude not equal to c(…).\nEqual",srcref = c(14, 3, 16, 58, 3, 58, 14, 16), expectation_calls = list(expect_equal(as.data.frame(my_result_excluded)\(exclude, c(rep(NA, nrow(my_result_excluded\)result) - 2), rep(“AUC percent extrapolated > 50”, 2)))), call = list(expect_equal(as.data.frame(my_result_excluded)\(exclude, c(rep(NA, nrow(my_result_excluded\)result) - 2), rep(“AUC percent extrapolated > 50”, 2)))), start_frame = 74, end_frame = 74,
test = "exclude_nca"), list(message = "as.data.frame(my_result_excluded)$exclude notequal to c(rep(NA_character_, 4), rep("Span ratio < 2", 10)).“, srcref = c(19, 3, 21, 44, 3, 44, 19, 21), expectation_calls = list(expect_equal(as.data.frame(my_result_excluded)\(exclude, c(rep(NA, 4), rep("Span ratio < 2", 10)))), call = list(expect_equal(as.data.frame(my_result_excluded)\)exclude, c(rep(NA, 4), rep(”Span ratio < 2“, 10)))), start_frame = 74, end_frame = 74, test =”exclude_nca"),
list(message = "as.data.frame(my_result_excluded)$exclude not equal to c(rep(NA_character_, 4), rep("Span ratio < 1", 10)).“, srcref = c(23, 3, 25, 44, 3, 44, 23, 25), expectation_calls = list(expect_equal(as.data.frame(my_result_excluded)\(exclude, c(rep(NA, 4), rep("Span ratio < 1", 10)))), call = list(expect_equal(as.data.frame(my_result_excluded)\)exclude, c(rep(NA, 4), rep(”Span ratio < 1“, 10)))), start_frame = 74, end_frame = 74, test =”exclude_nca“), list(message =”as.data.frame(my_result_excluded)$exclude not equal to c(rep(NA_character_, 4), rep("Half-life r-squared < 0.9", 10)).",
srcref = c(28, 3, 30, 55, 3, 55,28, 30), expectation_calls = list(expect_equal(as.data.frame(my_result_excluded)\(exclude, c(rep(NA, 4), rep("Half-life r-squared < 0.9", 10)))), call = list(expect_equal(as.data.frame(my_result_excluded)\)exclude, c(rep(NA, 4), rep(“Half-life r-squared < 0.9”, 10)))), start_frame = 74, end_frame = 74, test = “exclude_nca”), list(message = “as.data.frame(my_result_excluded)$exclude not equal to c(rep(NA_character_, 4), rep("Half-life r-squared < 0.95", 10)).”,
srcref = c(32, 3, 34, 56, 3, 56,32, 34), expectation_calls = list(expect_equal(as.data.frame(my_result_excluded)\(exclude, c(rep(NA, 4), rep("Half-life r-squared < 0.95", 10)))), call = list(expect_equal(as.data.frame(my_result_excluded)\)exclude, c(rep(NA, 4), rep(“Half-life r-squared < 0.95”, 10)))), start_frame = 74, end_frame = 74, test = “exclude_nca”), list(message = “my_result not equal to exclude(my_result, FUN = exclude_nca_max.aucinf.pext()).”, srcref = c(38, 3, 40, 60, 3,
60, 38, 40), expectation_calls = list(expect_equal(my_result, exclude(my_result, FUN = exclude_nca_max.aucinf.pext()), info = “Result is ignored when not calculated”)), call = list(expect_equal(my_result, exclude(my_result, FUN = exclude_nca_max.aucinf.pext()), info = “Result is ignored when not calculated”)), start_frame = 74, end_frame = 74, test = “exclude_nca”), list(message = “my_result not equal to exclude(my_result, FUN = exclude_nca_span.ratio()).”, srcref = c(41, 3, 43, 60, 3,
60, 41, 43), expectation_calls = list(expect_equal(my_result, exclude(my_result, FUN = exclude_nca_span.ratio()), info = “Result is ignored when not calculated”)), call = list(expect_equal(my_result, exclude(my_result, FUN = exclude_nca_span.ratio()), info = “Result is ignored when not calculated”)), start_frame = 74, end_frame = 74, test = “exclude_nca”), list(message = “my_result not equal to exclude(my_result, FUN = exclude_nca_min.hl.r.squared()).”, srcref = c(44, 3, 46, 60, 3, 60,
44, 46), expectation_calls = list(expect_equal(my_result, exclude(my_result, FUN = exclude_nca_min.hl.r.squared()), info = “Result is ignored when not calculated”)), call = list(expect_equal(my_result, exclude(my_result, FUN = exclude_nca_min.hl.r.squared()), info = “Result is ignored when not calculated”)), start_frame = 74, end_frame = 74, test = “exclude_nca”))

+

+

+
Check Conversion

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Testing FilenameTest DescriptionNumber of TestsNumber of Failed Testspassedresult
test-general.functions.Rcheck.conversion303list(list(message = “check.conversion(good, as.character) not equal to good.”, srcref = c(5, 3, 5, 58, 3, 58, 5, 5), expectation_calls = list(expect_equal(check.conversion(good, as.character), good)), call = list(expect_equal(check.conversion(good, as.character), good)), start_frame = 74, end_frame = 74, test = “check.conversion”), list(message = "“, srcref = c(6, 3, 11, 3, 3, 3, 6, 11), expectation_calls = list(expect_error(expect_warning(check.conversion(good, as.numeric)), regexp =”26 new NA value\(s\) created during conversion")),
call = list(expect_error(expect_warning(check.conversion(good, as.numeric)), regexp ="26 newNA value\(s\) created during conversion“)), start_frame = 74, end_frame = 74, test =”check.conversion“), list(message =”check.conversion(good, as.character) not equal to as.character(good).", srcref = c(13, 3, 14, 34, 3, 34, 13, 14), expectation_calls = list(expect_equal(check.conversion(good, as.character), as.character(good))), call = list(expect_equal(check.conversion(good, as.character),
as.character(good))), start_frame = 74, end_frame = 74, test= “check.conversion”))

+

+

+
Check concentration and time inputs

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Testing FilenameTest DescriptionNumber of TestsNumber of Failed Testspassedresult
test-general.functions.Rcheck.conc.time13013list(list(message = "“, srcref = c(21, 3, 22, 56, 3, 56, 21, 22), expectation_calls = list(expect_warning(check.conc.time(conc = -1), regexp =”Negative concentrations found“)), call = list(expect_warning(check.conc.time(conc = -1), regexp =”Negative concentrations found“)), start_frame = 74, end_frame = 74, test =”check.conc.time“), list(message =”“, srcref = c(23, 3, 24, 56, 3, 56, 23, 24), expectation_calls = list(expect_warning(check.conc.time(conc = c(NA, -1)), regexp =”Negative concentrations found")),
call = list(expect_warning(check.conc.time(conc = c(NA, -1)), regexp = "Negative concentrations found“)), start_frame = 74, end_frame = 74, test =”check.conc.time“), list(message =”“, srcref = c(25, 3, 26, 56, 3, 56, 25, 26), expectation_calls = list(expect_warning(check.conc.time(conc = c(NA, -1, 1)), regexp =”Negative concentrations found“)), call = list(expect_warning(check.conc.time(conc = c(NA, -1, 1)), regexp =”Negative concentrations found“)), start_frame = 74, end_frame = 74, test =”check.conc.time"),
list(message = "", srcref = c(27, 3, 28, 60, 3, 60, 27, 28),expectation_calls = list(expect_warning(check.conc.time(conc = NA), regexp = “All concentration data is missing”)), call = list(expect_warning(check.conc.time(conc = NA), regexp = “All concentration data is missing”)), start_frame = 74, end_frame = 74, test = “check.conc.time”), list(message = "“, srcref = c(29, 3, 30, 43, 3, 43, 29, 30), expectation_calls = list(expect_error(check.conc.time(time = NA), regexp =”Time may not be NA")),
call = list(expect_error(check.conc.time(time = NA), regexp = "Time may not be NA")), start_frame = 74, end_frame = 74, test = “check.conc.time”), list(message = "“, srcref = c(31, 3, 32, 62, 3, 62, 31, 32), expectation_calls = list(expect_error(check.conc.time(time = c(0, 0)), regexp =”Time must be monotonically increasing“)), call = list(expect_error(check.conc.time(time = c(0, 0)), regexp =”Time must be monotonically increasing“)), start_frame = 74, end_frame = 74, test =”check.conc.time"),
list(message = "", srcref = c(33, 3, 34, 62, 3, 62, 33, 34),expectation_calls = list(expect_error(check.conc.time(time = c(1, 0)), regexp = “Time must be monotonically increasing”)), call = list(expect_error(check.conc.time(time = c(1, 0)), regexp = “Time must be monotonically increasing”)), start_frame = 74, end_frame = 74, test = “check.conc.time”), list(message = "“, srcref = c(35, 3, 36, 62, 3, 62, 35, 36), expectation_calls = list(expect_error(check.conc.time(conc = 1, time = 1:2), regexp =”Conc and time must be the same length")),
call = list(expect_error(check.conc.time(conc = 1, time= 1:2), regexp = "Conc and time must be the same length“)), start_frame = 74, end_frame = 74, test =”check.conc.time“), list(message =”“, srcref = c(37, 3, 38, 62, 3, 62, 37, 38), expectation_calls = list(expect_error(check.conc.time(conc = 1:2, time = 2), regexp =”Conc and time must be the same length“)), call = list(expect_error(check.conc.time(conc = 1:2, time = 2), regexp =”Conc and time must be the same length")), start_frame = 74,
end_frame = 74, test = "check.conc.time"), list(message= "", srcref = c(39, 3, 40, 76, 3,76, 39, 40), expectation_calls = list(expect_error(check.conc.time(conc = “A”), regexp = “Concentration data must be numeric and not a factor”)), call = list(expect_error(check.conc.time(conc = “A”), regexp = “Concentration data must be numeric and not a factor”)), start_frame = 74, end_frame = 74, test = “check.conc.time”), list(message = "", srcref = c(41, 3, 42, 76, 3, 76, 41, 42), expectation_calls = list(
expect_error(check.conc.time(conc = factor(“A”)), regexp= "Concentration data must be numeric and not a factor“)), call = list(expect_error(check.conc.time(conc = factor(”A“)), regexp =”Concentration data must be numeric and not a factor“)), start_frame = 74, end_frame = 74, test =”check.conc.time“), list(message =”“, srcref = c(43, 3, 44, 67, 3, 67, 43, 44), expectation_calls = list(expect_error(check.conc.time(time =”A“), regexp =”Time data must be numeric and not a factor")), call = list(
expect_error(check.conc.time(time = "A“), regexp =”Timedata must be numeric andnot a factor“)), start_frame = 74, end_frame = 74, test =”check.conc.time“), list(message =”“, srcref = c(45, 3, 46, 67, 3, 67, 45, 46), expectation_calls = list(expect_error(check.conc.time(time = factor(”A“)), regexp =”Time data must be numeric and not a factor“)), call = list(expect_error(check.conc.time(time = factor(”A“)), regexp =”Time data must be numeric and not a factor")), start_frame = 74, end_frame = 74,
test = "check.conc.time"))

+

+

+
Rounding to string values

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Testing FilenameTest DescriptionNumber of TestsNumber of Failed Testspassedresult
test-general.functions.RRounding21021list(list(message = "“, srcref = c(52, 3, 53, 79, 3, 79, 52, 53), expectation_calls = list(expect_error(roundString(1, c(2, 3)), regexp =”digits must either be a scalar or the same length as x“)), call = list(expect_error(roundString(1, c(2, 3)), regexp =”digits must either be a scalar or the same length as x“)), start_frame = 74, end_frame = 74, test =”Rounding“), list(message =”roundString(11) not equal to "11".", srcref = c(54, 3, 54, 37, 3, 37, 54, 54), expectation_calls = list(expect_equal(roundString(11),
“11”)), call = list(expect_equal(roundString(11), “11”)), start_frame = 74, end_frame = 74,test = “Rounding”), list(message =“roundString(5) not equal to "5".”, srcref = c(55, 3, 55, 35, 3, 35, 55, 55), expectation_calls = list(expect_equal(roundString(5), “5”)), call = list(expect_equal(roundString(5), “5”)), start_frame = 74, end_frame = 74, test = “Rounding”), list(message = “roundString(0.05) not equal to "0".”, srcref = c(56, 3, 56, 38, 3, 38, 56, 56), expectation_calls = list(
expect_equal(roundString(0.05), “0”)), call = list(expect_equal(roundString(0.05), “0”)), start_frame = 74, end_frame= 74, test = “Rounding”), list(message = “roundString(NA) not equal to "NA".”, srcref = c(57, 3, 57, 37, 3, 37, 57, 57), expectation_calls = list(expect_equal(roundString(NA), “NA”)), call = list(expect_equal(roundString(NA), “NA”)), start_frame = 74, end_frame = 74, test = “Rounding”), list(message = “roundString(NaN) not equal to "NaN".”, srcref = c(58, 3,
58, 39, 3, 39, 58, 58), expectation_calls = list(expect_equal(roundString(NaN), “NaN”)), call =list(expect_equal(roundString(NaN), “NaN”)), start_frame = 74, end_frame = 74, test = “Rounding”), list(message = “roundString(Inf) not equal to "Inf".”, srcref = c(59, 3, 59, 39, 3, 39, 59, 59), expectation_calls = list(expect_equal(roundString(Inf), “Inf”)), call = list(expect_equal(roundString(Inf), “Inf”)), start_frame = 74, end_frame = 74, test = “Rounding”), list(message = “roundString(-Inf) not equal to "-Inf".”,
srcref = c(60, 3, 60, 41, 3, 41, 60, 60), expectation_calls = list(expect_equal(roundString(-Inf), “-Inf”)), call = list(expect_equal(roundString(-Inf), “-Inf”)), start_frame = 74, end_frame = 74, test = “Rounding”), list(message = “roundString(0.05, 3) not equal to "0.050".”, srcref = c(62, 3, 62, 45, 3, 45, 62, 62), expectation_calls = list(expect_equal(roundString(0.05, 3), “0.050”)), call = list(expect_equal(roundString(0.05, 3), “0.050”)), start_frame = 74, end_frame = 74, test = “Rounding”),
list(message = "roundString(123.05, 3) not equal to "123.050".",srcref = c(63, 3,63, 49, 3, 49, 63, 63), expectation_calls = list(expect_equal(roundString(123.05, 3), “123.050”)), call = list(expect_equal(roundString(123.05, 3), “123.050”)), start_frame = 74, end_frame = 74, test = “Rounding”), list(message = “roundString(c(100, 0.1), 3) not equal to c("100.000", "0.100").”, srcref = c(64, 3, 65, 75, 3, 75, 64, 65), expectation_calls = list(expect_equal(roundString(c(100,
0.1), 3), c("100.000“,”0.100“), info =”Vectors work with different orders of magnitudework")), call = list(expect_equal(roundString(c(100, 0.1), 3), c(“100.000”, “0.100”), info = “Vectors work with different orders of magnitude work”)), start_frame = 74, end_frame = 74, test = “Rounding”), list(message = “roundString(c(100, 0.1), c(0, 3)) not equal to c("100", "0.100").”, srcref = c(66, 3, 67, 45, 3, 45, 66, 67), expectation_calls = list(expect_equal(roundString(c(100, 0.1),
c(0, 3)), c(“100”,“0.100”), info = “Vectors of digits work”)), call =list(expect_equal(roundString(c(100, 0.1),c(0, 3)), c(“100”, “0.100”), info = “Vectors of digits work”)), start_frame = 74, end_frame = 74, test = “Rounding”), list(message = “roundString(c(0.1, NA), digits = 3) not equal to c("0.100", "NA").”, srcref = c(68, 3, 69, 65, 3, 65, 68, 69), expectation_calls = list(expect_equal(roundString(c(0.1, NA), digits = 3), c(“0.100”, “NA”), info = “Mixed inputs (NA, NaN, Inf or numeric), NA”)),
call = list(expect_equal(roundString(c(0.1, NA), digits = 3), c("0.100“,”NA“), info =”Mixed inputs (NA, NaN, Inf or numeric), NA“)), start_frame = 74, end_frame = 74, test =”Rounding“), list(message =”roundString(c(0.1, NA, NaN, Inf, -Inf), digits = 3) not equal to c("0.100", "NA", "NaN", "Inf", "-Inf").“, srcref = c(70, 3, 72, 61, 3, 61, 70, 72), expectation_calls = list(expect_equal(roundString(c(0.1, NA, NaN, Inf, -Inf), digits = 3), c(”0.100“,”NA“,”NaN“,”Inf",
“-Inf”), info = "Mixed inputs (NA, NaN, Inf or numeric)")), call = list(expect_equal(roundString(c(0.1, NA, NaN,Inf, -Inf), digits = 3), c(“0.100”, “NA”, “NaN”, “Inf”, “-Inf”), info = “Mixed inputs (NA, NaN, Inf or numeric)”)), start_frame = 74, end_frame = 74, test = “Rounding”), list(message = “roundString(0, digits = 3) not equal to "0.000".”, srcref = c(74, 3, 74, 49, 3, 49, 74, 74), expectation_calls = list(expect_equal(roundString(0, digits = 3), “0.000”)), call = list(expect_equal(roundString(0,
digits = 3), "0.000“)), start_frame = 74, end_frame = 74, test =”Rounding"), list(message = "roundString(c(0, NA), digits= 3) not equal to c("0.000", "NA").“, srcref = c(75, 3, 75, 65, 3, 65, 75, 75), expectation_calls = list(expect_equal(roundString(c(0, NA), digits = 3), c(”0.000“,”NA“))), call = list(expect_equal(roundString(c(0, NA), digits = 3), c(”0.000“,”NA“))), start_frame = 74, end_frame = 74, test =”Rounding“), list(message =”roundString(1234567, digits = 3, sci_range = 5) not equal to "1.234567000e6".",
srcref = c(77, 3, 78, 78, 3, 78, 77, 78), expectation_calls = list(expect_equal(roundString(1234567, digits = 3,sci_range= 5), “1.234567000e6”, info = “sci_range works with roundString (even if it looks odd)”)), call = list(expect_equal(roundString(1234567, digits = 3, sci_range = 5), “1.234567000e6”, info = “sci_range works with roundString (even if it looks odd)”)), start_frame = 74, end_frame = 74, test = “Rounding”), list(message = "", srcref = c(79, 3, 80, 84, 3, 84, 79, 80), expectation_calls = list(
expect_warning(roundString(1234567, digits = 3, si_range = 5), regexp= "The si_range argument is deprecated, please use sci_range“)), call = list(expect_warning(roundString(1234567, digits = 3, si_range = 5), regexp =”The si_range argument is deprecated, please use sci_range“)), start_frame = 74, end_frame = 74, test =”Rounding“), list(message =”roundString(1234567, digits = 3, sci_range = 5) not equal to roundString(1234567, digits = 3, sci_range = 5).", srcref = c(81, 3, 83,
78, 3, 78, 81, 83), expectation_calls = list(expect_equal(roundString(1234567, digits = 3, sci_range = 5), roundString(1234567, digits = 3, sci_range = 5), info = “sci_range works with roundString (even if it looks odd)”)), call = list(expect_equal(roundString(1234567, digits = 3, sci_range = 5), roundString(1234567, digits = 3, sci_range = 5), info = “sci_range works with roundString (even if it looks odd)”)), start_frame = 74, end_frame = 74, test = “Rounding”), list(message = “roundString(1234567, digits = 3, sci_range = 5, sci_sep = "x10^") not equal to "1.234567000x10^6".”,
srcref = c(84, 3, 86, 44, 3, 44, 84, 86), expectation_calls = list(expect_equal(roundString(1234567, digits = 3,sci_range= 5, sci_sep = “x10^”), “1.234567000x10^6”, info = “sci_sep is respected.”)), call = list(expect_equal(roundString(1234567, digits = 3, sci_range = 5, sci_sep = “x10^”), “1.234567000x10^6”, info = “sci_sep is respected.”)), start_frame = 74, end_frame = 74, test = “Rounding”), list(message = “roundString(c(1e+07, 1e+10), digits = c(-3, -9), sci_range = 5) not equal to c("1.0000e7", "1.0e10").”,
srcref = c(87, 3, 89, 85, 3, 85, 87, 89), expectation_calls = list(expect_equal(roundString(c(1e+07, 1e+10), digits = c(-3, -9), sci_range = 5), c(“1.0000e7”, “1.0e10”), info = “Different numbers of digits for rounding work with roundString”)), call = list(expect_equal(roundString(c(1e+07, 1e+10), digits = c(-3, -9), sci_range = 5), c(“1.0000e7”, “1.0e10”), info = “Different numbers of digits for rounding work with roundString”)), start_frame = 74, end_frame = 74, test = “Rounding”))
test-general.functions.RSignificance33033list(list(message = “signifString(11) not equal to "11.0000".”, srcref = c(93, 3, 93, 43, 3, 43, 93, 93), expectation_calls = list(expect_equal(signifString(11), “11.0000”)), call = list(expect_equal(signifString(11), “11.0000”)), start_frame = 74, end_frame = 74, test = “Significance”), list(message = “signifString(5) not equal to "5.00000".”, srcref = c(94, 3, 94, 42, 3, 42, 94, 94), expectation_calls = list(expect_equal(signifString(5), “5.00000”)), call = list(expect_equal(signifString(5),
“5.00000”)), start_frame = 74, end_frame = 74, test = “Significance”), list(message = "signifString(0.05) not equal to "0.0500000".“, srcref = c(95, 3, 95, 47, 3, 47, 95, 95), expectation_calls = list(expect_equal(signifString(0.05),”0.0500000“)), call = list(expect_equal(signifString(0.05),”0.0500000“)), start_frame = 74, end_frame = 74, test =”Significance“), list(message =”signifString(NA) not equal to "NA".", srcref = c(96, 3, 96, 38, 3, 38, 96, 96), expectation_calls = list(
expect_equal(signifString(NA), “NA”)), call = list(expect_equal(signifString(NA), “NA”)), start_frame = 74, end_frame= 74, test = “Significance”), list(message = “signifString(NaN) not equal to "NaN".”, srcref = c(97, 3, 97, 40, 3, 40, 97, 97), expectation_calls = list(expect_equal(signifString(NaN), “NaN”)), call = list(expect_equal(signifString(NaN), “NaN”)), start_frame = 74, end_frame = 74, test = “Significance”), list(message = “signifString(Inf) not equal to "Inf".”,
srcref = c(98, 3, 98, 40, 3, 40, 98, 98), expectation_calls = list(expect_equal(signifString(Inf), “Inf”)), call = list(expect_equal(signifString(Inf), “Inf”)), start_frame = 74, end_frame = 74, test = “Significance”), list(message = “signifString(-Inf) not equal to "-Inf".”, srcref = c(99, 3, 99, 42, 3, 42, 99, 99), expectation_calls = list(expect_equal(signifString(-Inf), “-Inf”)), call = list(expect_equal(signifString(-Inf), “-Inf”)), start_frame = 74, end_frame = 74, test = “Significance”),
list(message = "signifString(0.05, 3) not equal to "0.0500".", srcref = c(101, 3, 101, 47, 3, 47, 101, 101),expectation_calls = list(expect_equal(signifString(0.05, 3), “0.0500”)), call = list(expect_equal(signifString(0.05, 3), “0.0500”)), start_frame = 74, end_frame = 74, test = “Significance”), list(message = “signifString(123.05, 3) not equal to "123".”, srcref = c(102, 3, 102, 46, 3, 46, 102, 102), expectation_calls = list(expect_equal(signifString(123.05, 3), “123”)),
call = list(expect_equal(signifString(123.05, 3), “123”)), start_frame= 74, end_frame =74, test = "Significance"), list(message = “signifString(123456.05, 3) not equal to "123000".”, srcref = c(103, 3, 103, 52, 3, 52, 103, 103), expectation_calls = list(expect_equal(signifString(123456.05, 3), “123000”)), call = list(expect_equal(signifString(123456.05, 3), “123000”)), start_frame = 74, end_frame = 74, test = “Significance”), list(message = "", srcref = c(104, 3, 105, 83, 3, 83,
104, 105), expectation_calls = list(expect_warning(signifString(123456.05,3, si_range = 6),regexp = "The si_range argument is deprecated, please use sci_range“)), call = list(expect_warning(signifString(123456.05, 3, si_range = 6), regexp =”The si_range argument is deprecated, please use sci_range“)), start_frame = 74, end_frame = 74, test =”Significance“), list(message =”", srcref = c(106, 3, 108, 76, 3, 76, 106, 108), expectation_calls = list(expect_equal(signifString(123456.05, 3, sci_range = 6),
expect_warning(signifString(123456.05, 3, si_range = 6)), info = "si_range and sci_rangearguments are treated equally."),quasi_label(enquo(expected), expected.label, arg = “expected”), eval_bare(get_expr(quo), get_env(quo)), expect_warning(signifString(123456.05, 3, si_range = 6))), call = list(expect_equal(signifString(123456.05, 3, sci_range = 6), expect_warning(signifString(123456.05, 3, si_range = 6)), info = “si_range and sci_range arguments are treated equally.”), quasi_label(enquo(expected),
expected.label, arg= “expected”), eval_bare(get_expr(quo), get_env(quo)), expect_warning(signifString(123456.05,3, si_range = 6))), start_frame = 74, end_frame = 77, test = “Significance”), list(message = “signifString(123456.05, 3, sci_range = 6) not equal to expect_warning(signifString(123456.05, 3, si_range = 6)).”, srcref = c(106, 3, 108, 76, 3, 76, 106, 108), expectation_calls = list(expect_equal(signifString(123456.05, 3, sci_range = 6), expect_warning(signifString(123456.05,
3, si_range = 6)),info = "si_range and sci_range arguments are treated equally.")), call = list(expect_equal(signifString(123456.05, 3, sci_range = 6), expect_warning(signifString(123456.05, 3, si_range = 6)), info = “si_range and sci_range arguments are treated equally.”)), start_frame = 74, end_frame = 74, test = “Significance”), list(message = “signifString(123456.05, 3, sci_range = 6) not equal to "123000".”, srcref = c(109, 3, 109, 65, 3, 65, 109, 109), expectation_calls = list(
expect_equal(signifString(123456.05, 3, sci_range = 6), “123000”)), call = list(expect_equal(signifString(123456.05, 3, sci_range = 6), “123000”)), start_frame = 74, end_frame = 74, test = “Significance”), list(message = “signifString(123456.05, 3, sci_range = 5) not equal to "1.23e5".”, srcref = c(110, 3, 110, 65, 3, 65, 110, 110), expectation_calls = list(expect_equal(signifString(123456.05, 3, sci_range = 5), “1.23e5”)), call = list(expect_equal(signifString(123456.05, 3, sci_range = 5),
“1.23e5”)), start_frame = 74, end_frame = 74, test = “Significance”),list(message = "signifString(-123000.05, 3,sci_range = 5) not equal to "-1.23e5".“, srcref = c(111, 3, 111, 67, 3, 67, 111, 111), expectation_calls = list(expect_equal(signifString(-123000.05, 3, sci_range = 5),”-1.23e5“)), call = list(expect_equal(signifString(-123000.05, 3, sci_range = 5),”-1.23e5“)), start_frame = 74, end_frame = 74, test =”Significance“), list(message =”signifString(999999, 3, sci_range = 6) not equal to "1.00e6".",
srcref = c(112, 3,113, 91, 3, 91, 112, 113), expectation_calls = list(expect_equal(signifString(999999, 3, sci_range = 6), “1.00e6”, info = “Rounding around the edge of the sci_range works correctly (going up)”)), call = list(expect_equal(signifString(999999, 3, sci_range = 6), “1.00e6”, info = “Rounding around the edge of the sci_range works correctly (going up)”)), start_frame = 74, end_frame = 74, test = “Significance”), list(message = “signifString(999999, 7, sci_range = 6) not equal to "999999.0".”,
srcref = c(114, 3,115, 105, 3, 105, 114, 115), expectation_calls = list(expect_equal(signifString(999999, 7, sci_range =6), “999999.0”, info = “Rounding around the edge of the sci_range works correctly (going staying the same)”)), call = list(expect_equal(signifString(999999, 7, sci_range = 6), “999999.0”, info = “Rounding around the edge of the sci_range works correctly (going staying the same)”)), start_frame = 74, end_frame = 74, test = “Significance”), list(message = “signifString(-0.05, 3) not equal to "-0.0500".”,
srcref = c(116, 3,116, 48, 3, 48, 116, 116), expectation_calls = list(expect_equal(signifString(-0.05, 3), "-0.0500")), call = list(expect_equal(signifString(-0.05, 3), “-0.0500”)), start_frame = 74, end_frame = 74, test = “Significance”), list(message = “signifString(0.01, 3) not equal to "0.0100".”, srcref = c(118, 3, 118, 47, 3, 47, 118, 118), expectation_calls = list(expect_equal(signifString(0.01, 3), “0.0100”)), call = list(expect_equal(signifString(0.01, 3), “0.0100”)), start_frame = 74,
end_frame = 74, test = “Significance”), list(message = "signifString(1, 3) not equal to"1.00".", srcref= c(119,3, 119, 42, 3, 42, 119, 119), expectation_calls = list(expect_equal(signifString(1, 3), “1.00”)), call = list(expect_equal(signifString(1, 3), “1.00”)), start_frame = 74, end_frame = 74, test = “Significance”), list(message = “signifString(100, 3) not equal to "100".”, srcref = c(120, 3, 120, 43, 3, 43, 120, 120), expectation_calls = list(expect_equal(signifString(100,
3), “100”)), call =list(expect_equal(signifString(100, 3), “100”)), start_frame = 74, end_frame = 74, test = "Significance“), list(message =”signifString(c(100, 0.1), 3) not equal to c("100", "0.100").“, srcref = c(122, 3, 122, 63, 3, 63, 122, 122), expectation_calls = list(expect_equal(signifString(c(100, 0.1), 3), c(”100“,”0.100“))), call = list(expect_equal(signifString(c(100, 0.1), 3), c(”100“,”0.100“))), start_frame = 74, end_frame = 74, test =”Significance“), list(message =”signifString(0.9999999, 3) not equal to "1.00".",
srcref = c(124, 3,124, 50, 3, 50, 124, 124), expectation_calls = list(expect_equal(signifString(0.9999999, 3), "1.00")),call = list(expect_equal(signifString(0.9999999, 3), “1.00”)), start_frame = 74, end_frame = 74, test = “Significance”), list(message = “signifString(NA) not equal to "NA".”, srcref = c(126, 3, 126, 38, 3, 38, 126, 126), expectation_calls = list(expect_equal(signifString(NA), “NA”)), call = list(expect_equal(signifString(NA), “NA”)), start_frame = 74, end_frame = 74,
test = "Significance“), list(message =”signifString(c(0.1, NA), digits = 3) not equal to c("0.100", "NA").Equal", srcref = c(127, 3, 127, 68, 3, 68, 127, 127), expectation_calls = list(expect_equal(signifString(c(0.1, NA), digits = 3), c(“0.100”, “NA”))), call = list(expect_equal(signifString(c(0.1, NA), digits = 3), c(“0.100”, “NA”))), start_frame = 74, end_frame = 74, test = “Significance”), list(message = “signifString(c(0.1, NA, NaN, Inf, -Inf), digits = 3) not equal to c("0.100", "NA", "NaN", "Inf", "-Inf").”,
srcref = c(128, 3,129, 54, 3, 54, 128, 129), expectation_calls = list(expect_equal(signifString(c(0.1, NA, NaN,Inf, -Inf), digits = 3), c(“0.100”, “NA”, “NaN”, “Inf”, “-Inf”))), call = list(expect_equal(signifString(c(0.1, NA, NaN, Inf, -Inf), digits = 3), c(“0.100”, “NA”, “NaN”, “Inf”, “-Inf”))), start_frame = 74, end_frame = 74, test = “Significance”), list(message = “signifString(0, digits = 3) not equal to "0.000".”, srcref = c(131, 3, 131, 50, 3, 50, 131, 131), expectation_calls = list(
expect_equal(signifString(0, digits = 3), “0.000”)), call = list(expect_equal(signifString(0, digits = 3), "0.000")), start_frame = 74, end_frame = 74, test = “Significance”), list(message = “signifString(c(0, NA), digits = 3) not equal to c("0.000", "NA").”, srcref = c(132, 3, 132, 66, 3, 66, 132, 132), expectation_calls = list(expect_equal(signifString(c(0, NA), digits = 3), c(“0.000”, “NA”))), call = list(expect_equal(signifString(c(0, NA), digits = 3), c(“0.000”, “NA”))), start_frame = 74,
end_frame = 74, test = “Significance”), list(message = "signifString(1234567, digits = 3, sci_range = 5, sci_sep= "x10^\“) not equal to "1.23x10^6".”, srcref = c(134, 3, 136, 44, 3, 44, 134, 136), expectation_calls = list(expect_equal(signifString(1234567, digits = 3, sci_range = 5, sci_sep = “x10^”), “1.23x10^6”, info = “sci_sep is respected.”)), call = list(expect_equal(signifString(1234567, digits = 3, sci_range = 5, sci_sep = “x10^”), “1.23x10^6”, info = “sci_sep is respected.”)),
start_frame = 74, end_frame = 74, test = “Significance”), list(message= "signifString(c(1e+07, 1e+10), digits =3) not equal to c("1.00e7", "1.00e10").“, srcref = c(137, 3, 139, 86, 3, 86, 137, 139), expectation_calls = list(expect_equal(signifString(c(1e+07, 1e+10), digits = 3), c(”1.00e7“,”1.00e10“), info =”Different numbers of digits for rounding work with signifString“)), call = list(expect_equal(signifString(c(1e+07, 1e+10), digits = 3), c(”1.00e7“,”1.00e10“), info =”Different numbers of digits for rounding work with signifString")),
start_frame = 74, end_frame = 74, test = “Significance”), list(message= "signifString(...) not equal to data.frame(…).\nTRUE“, srcref = c(142, 3, 152, 70, 3, 70, 142, 152), expectation_calls = list(expect_equal(signifString(data.frame(A = c(0, 1.111111), B = factor(LETTERS[1:2]), C = LETTERS[1:2], stringsAsFactors = FALSE), digits = 3), data.frame(A = c(”0.000“,”1.11“), B = factor(LETTERS[1:2]), C = LETTERS[1:2], stringsAsFactors = FALSE), check.attributes = FALSE, info =”Data frame significance is calculated correctly")),
call = list(expect_equal(signifString(data.frame(A = c(0, 1.111111), B= factor(LETTERS[1:2]), C = LETTERS[1:2],stringsAsFactors = FALSE), digits = 3), data.frame(A = c(“0.000”, “1.11”), B = factor(LETTERS[1:2]), C = LETTERS[1:2], stringsAsFactors = FALSE), check.attributes = FALSE, info = “Data frame significance is calculated correctly”)), start_frame = 74, end_frame = 74, test = “Significance”), list(message = “signifString(…) not equal to data.frame(…).”, srcref = c(153, 3,
163, 54, 3, 54, 153, 163), expectation_calls = list(expect_equal(signifString(data.frame(A =c(0, 1.111111), B = factor(LETTERS[1:2]), C = LETTERS[1:2], stringsAsFactors = FALSE), digits = 4), data.frame(A = c(“0.0000”, “1.111”), B = factor(LETTERS[1:2]), C = LETTERS[1:2], stringsAsFactors = FALSE), check.attributes = FALSE, info = “Data frame digits are respected”)), call = list(expect_equal(signifString(data.frame(A = c(0, 1.111111), B = factor(LETTERS[1:2]), C = LETTERS[1:2], stringsAsFactors = FALSE),
digits = 4), data.frame(A = c(“0.0000”, “1.111”), B = factor(LETTERS[1:2]), C = LETTERS[1:2], stringsAsFactors =FALSE), check.attributes = FALSE, info = “Data frame digits are respected”)), start_frame = 74, end_frame = 74, test = “Significance”))
test-general.functions.RsignifString stops when bad arguments are passed101list(list(message = "“, srcref = c(167, 3, 171, 3, 3, 3, 167, 171), expectation_calls = list(expect_error(signifString(1, foo = 1), regexp =”Additional, unsupported arguments were passed“, fixed = TRUE)), call = list(expect_error(signifString(1, foo = 1), regexp =”Additional, unsupported arguments were passed“, fixed = TRUE)), start_frame = 74, end_frame = 74, test =”signifString stops when bad arguments are passed"))

+

+

+
Half-life

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Testing FilenameTest DescriptionNumber of TestsNumber of Failed Testspassedresult
test-half.life.Rpk.calc.half.life13013list(list(message = "", srcref = c(6, 3, 12, 77, 3, 77, 6, 12), expectation_calls = list(expect_warning(v1 <- pk.calc.half.life(conc = c(1, 0.5, 0.25), time = c(0, 1, 2), min.hl.points = 3, allow.tmax.in.half.life = TRUE, adj.r.squared.factor = 1e-04)\(half.life, regexp = "essentially perfect fit: summary may be unreliable")), call = list(expect_warning(v1 <- pk.calc.half.life(conc = c(1, 0.5, 0.25), time = c(0, 1, 2), min.hl.points = 3, allow.tmax.in.half.life = TRUE, adj.r.squared.factor = 1e-04)\)half.life,
regexp = "essentially perfect fit: summary may beunreliable")), start_frame = 74, end_frame= 74, test = “pk.calc.half.life”), list(message = “v1 not equal to 1.”, srcref = c(13, 3, 13, 21, 3, 21, 13, 13), expectation_calls = list(expect_equal(v1, 1)), call = list(expect_equal(v1, 1)), start_frame = 74, end_frame = 74, test = “pk.calc.half.life”), list(message = "", srcref = c(17, 3, 24, 77, 3, 77, 17, 24), expectation_calls = list(expect_warning(v2 <- pk.calc.half.life(conc = c(1,
0.5, 0.25), time = c(0, 1, 2), min.hl.points = 3,allow.tmax.in.half.life = TRUE, adj.r.squared.factor= 1e-04, check = FALSE)\(half.life, regexp = "essentially perfect fit: summary may be unreliable")), call = list(expect_warning(v2 <- pk.calc.half.life(conc = c(1, 0.5, 0.25), time = c(0, 1, 2), min.hl.points = 3, allow.tmax.in.half.life = TRUE, adj.r.squared.factor = 1e-04, check = FALSE)\)half.life, regexp = “essentially perfect fit: summary may be unreliable”)), start_frame = 74, end_frame = 74,
test = "pk.calc.half.life“), list(message =”v2not equal to 1.qual", srcref = c(26, 3,26, 21, 3, 21, 26, 26), expectation_calls = list(expect_equal(v2, 1)), call = list(expect_equal(v2, 1)), start_frame = 74, end_frame = 74, test = “pk.calc.half.life”), list(message = "“, srcref = c(29, 3, 32, 67, 3, 67, 29, 32), expectation_calls = list(expect_warning(pk.calc.half.life(conc = c(1, 0.5, 0.25), time = c(0, 1, 2), min.hl.points = 4), regexp =”Too few points for half-life calculation")),
call = list(expect_warning(pk.calc.half.life(conc= c(1, 0.5, 0.25),time = c(0, 1, 2), min.hl.points= 4), regexp = “Too few points for half-life calculation”)), start_frame = 74, end_frame = 74, test = “pk.calc.half.life”), list(message = “…$NULL not equal to 1.000346.”, srcref = c(36, 3, 44, 35, 3, 35, 36, 44), expectation_calls = list(expect_warning(expect_equal(pk.calc.half.life(conc = c(1, 0.5, 0.25, 0.1251), time = c(0, 1, 2, 3), min.hl.points = 3, allow.tmax.in.half.life = TRUE,
adj.r.squared.factor = 0.1, check = FALSE)$half.life, 1.000346, tolerance = 1e-04)), quasi_capture(enquo(object), label, capture_warnings), .capture(act$val <- eval_bare(get_expr(.quo), get_env(.quo)), …), withCallingHandlers(code, warning = function(condition) {
out$push(condition)
invokeRestart("muffleWarning")
}), eval_bare(get_expr(.quo), get_env(.quo)), expect_equal(pk.calc.half.life(conc = c(1, 0.5, 0.25, 0.1251), time = c(0, 1, 2, 3), min.hl.points = 3, allow.tmax.in.half.life = TRUE, adj.r.squared.factor = 0.1, check = FALSE)\(half.life, 1.000346, tolerance = 1e-04)), call = list(expect_warning(expect_equal(pk.calc.half.life(conc = c(1, 0.5, 0.25, 0.1251), time = c(0, 1, 2, 3), min.hl.points = 3, allow.tmax.in.half.life = TRUE, adj.r.squared.factor = 0.1, check = FALSE)\)half.life, 1.000346, tolerance = 1e-04)),
quasi_capture(enquo(object), label, capture_warnings), .capture(act$val <- eval_bare(get_expr(.quo), get_env(.quo)), …), withCallingHandlers(code, warning = function(condition) {
out$push(condition)
invokeRestart(“muffleWarning”)
}), eval_bare(get_expr(.quo), get_env(.quo)), expect_equal(pk.calc.half.life(conc = c(1, 0.5,0.25, 0.1251), time = c(0, 1, 2, 3), min.hl.points = 3, allow.tmax.in.half.life = TRUE, adj.r.squared.factor = 0.1, check = FALSE)$half.life, 1.000346, tolerance = 1e-04)), start_frame = 74, end_frame = 79, test = “pk.calc.half.life”), list(message = "", srcref = c(36, 3, 44, 35, 3, 35, 36, 44), expectation_calls = list(expect_warning(expect_equal(pk.calc.half.life(conc = c(1, 0.5, 0.25, 0.1251), time = c(0,
1, 2, 3), min.hl.points = 3, allow.tmax.in.half.life = TRUE, adj.r.squared.factor = 0.1, check = FALSE)\(half.life, 1.000346, tolerance = 1e-04))), call = list(expect_warning(expect_equal(pk.calc.half.life(conc = c(1, 0.5, 0.25, 0.1251), time = c(0, 1, 2, 3), min.hl.points = 3, allow.tmax.in.half.life = TRUE, adj.r.squared.factor = 0.1, check = FALSE)\)half.life, 1.000346, tolerance = 1e-04))), start_frame = 74, end_frame = 74, test = “pk.calc.half.life”), list(message = “…$NULL not equal to 1.000577.”,
srcref = c(47,3, 53, 33, 3, 33, 47, 53), expectation_calls = list(expect_equal(pk.calc.half.life(conc= c(1, 0.5, 0.25, 0.1251), time = c(0, 1, 2, 3), min.hl.points = 3, allow.tmax.in.half.life = FALSE, check = FALSE)\(half.life, 1.000577, tolerance = 1e-05)), call = list(expect_equal(pk.calc.half.life(conc = c(1, 0.5, 0.25, 0.1251), time = c(0, 1, 2, 3), min.hl.points = 3, allow.tmax.in.half.life = FALSE, check = FALSE)\)half.life, 1.000577, tolerance = 1e-05)), start_frame = 74, end_frame = 74,
test = "pk.calc.half.life“), list(message =”…$NULL not equal to 1.000346.", srcref= c(54, 3, 62, 36, 3, 36, 54, 62), expectation_calls = list(expect_warning(expect_equal(pk.calc.half.life(conc = c(1, 0.5, 0.25, 0.1251), time = c(0, 1, 2, 3), min.hl.points = 3, allow.tmax.in.half.life = TRUE, adj.r.squared.factor = 0.1, check = FALSE)\(half.life, 1.000346, tolerance = 1e-05)), quasi_capture(enquo(object), label, capture_warnings), .capture(act\)val <- eval_bare(get_expr(.quo), get_env(.quo)),
…), withCallingHandlers(code, warning = function(condition) {
out$push(condition)
invokeRestart("muffleWarning")
}), eval_bare(get_expr(.quo), get_env(.quo)), expect_equal(pk.calc.half.life(conc = c(1, 0.5, 0.25, 0.1251), time = c(0, 1, 2, 3), min.hl.points = 3, allow.tmax.in.half.life = TRUE, adj.r.squared.factor = 0.1, check = FALSE)\(half.life, 1.000346, tolerance = 1e-05)), call = list(expect_warning(expect_equal(pk.calc.half.life(conc = c(1, 0.5, 0.25, 0.1251), time = c(0, 1, 2, 3), min.hl.points = 3, allow.tmax.in.half.life = TRUE, adj.r.squared.factor = 0.1, check = FALSE)\)half.life, 1.000346, tolerance = 1e-05)),
quasi_capture(enquo(object), label, capture_warnings), .capture(act$val <- eval_bare(get_expr(.quo), get_env(.quo)), …), withCallingHandlers(code, warning = function(condition) {
out$push(condition)
invokeRestart(“muffleWarning”)
}), eval_bare(get_expr(.quo), get_env(.quo)), expect_equal(pk.calc.half.life(conc = c(1, 0.5,0.25, 0.1251), time = c(0, 1, 2, 3), min.hl.points = 3, allow.tmax.in.half.life = TRUE, adj.r.squared.factor = 0.1, check = FALSE)$half.life, 1.000346, tolerance = 1e-05)), start_frame = 74, end_frame = 79, test = “pk.calc.half.life”), list(message = "", srcref = c(54, 3, 62, 36, 3, 36, 54, 62), expectation_calls = list(expect_warning(expect_equal(pk.calc.half.life(conc = c(1, 0.5, 0.25, 0.1251), time = c(0,
1, 2, 3), min.hl.points = 3, allow.tmax.in.half.life = TRUE, adj.r.squared.factor = 0.1, check = FALSE)\(half.life, 1.000346, tolerance = 1e-05))), call = list(expect_warning(expect_equal(pk.calc.half.life(conc = c(1, 0.5, 0.25, 0.1251), time = c(0, 1, 2, 3), min.hl.points = 3, allow.tmax.in.half.life = TRUE, adj.r.squared.factor = 0.1, check = FALSE)\)half.life, 1.000346, tolerance = 1e-05))), start_frame = 74, end_frame = 74, test = “pk.calc.half.life”), list(message = “pk.calc.half.life(…) not equal to data.frame(…).”,
srcref = c(67,3, 83, 32, 3, 32, 67, 83), expectation_calls = list(expect_equal(pk.calc.half.life(conc= c(1, 0.5, 0.25, 0.1251), time = c(0, 1, 2, 3), min.hl.points = 3, tmax = 0, tlast = 3, allow.tmax.in.half.life = TRUE, adj.r.squared.factor = 0.01, check = FALSE), data.frame(lambda.z = 0.6929073, r.squared = 0.9999999, adj.r.squared = 0.9999999, lambda.z.time.first = 0, lambda.z.n.points = 4, clast.pred = 0.12507, half.life = 1.000346, span.ratio = 2.998962), tolerance = 1e-04)), call = list(
expect_equal(pk.calc.half.life(conc = c(1, 0.5, 0.25, 0.1251), time = c(0, 1, 2, 3), min.hl.points= 3, tmax = 0, tlast = 3, allow.tmax.in.half.life = TRUE, adj.r.squared.factor = 0.01, check = FALSE), data.frame(lambda.z = 0.6929073, r.squared = 0.9999999, adj.r.squared = 0.9999999, lambda.z.time.first = 0, lambda.z.n.points = 4, clast.pred = 0.12507, half.life = 1.000346, span.ratio = 2.998962), tolerance = 1e-04)), start_frame = 74, end_frame = 74, test = “pk.calc.half.life”), list(message = “pk.calc.half.life(…) not equal to data.frame(…).”,
srcref = c(85,3, 101, 32, 3, 32, 85, 101), expectation_calls = list(expect_equal(pk.calc.half.life(conc = c(1, 0.5, 0.25, 0.1251), time = c(0, 1, 2, 3), min.hl.points = 3, tlast = 3, allow.tmax.in.half.life = TRUE, adj.r.squared.factor = 0.01, check = FALSE), data.frame(lambda.z = 0.6929073, r.squared = 0.9999999, adj.r.squared = 0.9999999, lambda.z.time.first = 0, lambda.z.n.points = 4, clast.pred = 0.12507, half.life = 1.000346, span.ratio = 2.998962, tmax = 0), tolerance = 1e-04)), call = list(
expect_equal(pk.calc.half.life(conc = c(1, 0.5, 0.25, 0.1251), time = c(0, 1, 2, 3), min.hl.points= 3, tlast = 3, allow.tmax.in.half.life = TRUE, adj.r.squared.factor = 0.01, check = FALSE), data.frame(lambda.z = 0.6929073, r.squared = 0.9999999, adj.r.squared = 0.9999999, lambda.z.time.first = 0, lambda.z.n.points = 4, clast.pred = 0.12507, half.life = 1.000346, span.ratio = 2.998962, tmax = 0), tolerance = 1e-04)), start_frame = 74, end_frame = 74, test = “pk.calc.half.life”), list(message = “pk.calc.half.life(…) not equal to data.frame(…).”,
srcref = c(102,5, 118, 32, 5, 32, 102, 118), expectation_calls = list(expect_equal(pk.calc.half.life(conc = c(1, 0.5, 0.25, 0.1251), time = c(0, 1, 2, 3), min.hl.points = 3, tmax = 0, allow.tmax.in.half.life = TRUE, adj.r.squared.factor = 0.01, check = FALSE), data.frame(lambda.z = 0.6929073, r.squared = 0.9999999, adj.r.squared = 0.9999999, lambda.z.time.first = 0, lambda.z.n.points = 4, clast.pred = 0.12507, half.life = 1.000346, span.ratio = 2.998962, tlast = 3), tolerance = 1e-04)), call = list(
expect_equal(pk.calc.half.life(conc = c(1, 0.5, 0.25, 0.1251), time = c(0, 1, 2, 3), min.hl.points= 3, tmax = 0, allow.tmax.in.half.life = TRUE, adj.r.squared.factor = 0.01, check = FALSE), data.frame(lambda.z = 0.6929073, r.squared = 0.9999999, adj.r.squared = 0.9999999, lambda.z.time.first = 0, lambda.z.n.points = 4, clast.pred = 0.12507, half.life = 1.000346, span.ratio = 2.998962, tlast = 3), tolerance = 1e-04)), start_frame = 74, end_frame = 74, test = “pk.calc.half.life”))
test-half.life.Rhalf-life manual point selection505list(list(message = “…\(NULL not equal to 1.00653.\nEqual", srcref = c(123, 3, 132, 58, 3, 58, 123, 132), expectation_calls = list(expect_equal(pk.calc.half.life(conc = c(3, 1, 0.5, 0.13, 0.12, 0.113), time = c(0, 1, 2, 3, 4, 5), manually.selected.points = TRUE, min.hl.points = 3, allow.tmax.in.half.life = FALSE, check = FALSE)\)half.life, 1.00653, tolerance = 1e-04, info =”manual selection uses the given points as is")), call = list(expect_equal(pk.calc.half.life(conc = c(3, 1, 0.5, 0.13, 0.12,
0.113), time =c(0, 1, 2, 3, 4, 5), manually.selected.points = TRUE,min.hl.points = 3, allow.tmax.in.half.life = FALSE, check = FALSE)$half.life, 1.00653, tolerance = 1e-04, info = “manual selection uses the given points as is”)), start_frame = 74, end_frame = 74, test = “half-life manual point selection”), list(message = “!=… isn’t true.”, srcref = c(133, 3, 145, 66, 3, 66, 133, 145), expectation_calls = list(expect_true(pk.calc.half.life(conc = c(3, 1, 0.5, 0.13, 0.12, 0.113), time = c(0,
1, 2, 3, 4, 5),manually.selected.points = TRUE, min.hl.points = 3,allow.tmax.in.half.life =FALSE, check = FALSE)\(half.life != pk.calc.half.life(conc = c(3, 1, 0.5, 0.13, 0.12, 0.113), time = c(0, 1, 2, 3, 4, 5), min.hl.points = 3, allow.tmax.in.half.life = FALSE, check = FALSE)\)half.life, info = “manual selection is different than automatic selection”)), call = list(expect_true(pk.calc.half.life(conc = c(3, 1, 0.5, 0.13, 0.12, 0.113), time = c(0, 1, 2, 3, 4, 5), manually.selected.points = TRUE,
min.hl.points =3, allow.tmax.in.half.life = FALSE, check = FALSE)$half.life != pk.calc.half.life(conc= c(3, 1, 0.5, 0.13, 0.12, 0.113), time = c(0, 1, 2, 3, 4, 5), min.hl.points = 3, allow.tmax.in.half.life = FALSE, check = FALSE)$half.life, info = “manual selection is different than automatic selection”)), start_frame = 74, end_frame = 74, test = “half-life manual point selection”), list(message = “<… isn’t true.”, srcref = c(146, 3, 160, 91, 3, 91, 146, 160), expectation_calls = list(expect_true(pk.calc.half.life(conc = c(3,
1, 0.5, 0.13, 0.12, 0.113), time = c(0, 1, 2, 3, 4, 5), manually.selected.points = TRUE, min.hl.points= 3, tlast = 20, allow.tmax.in.half.life = FALSE, check = FALSE)\(clast.pred < pk.calc.half.life(conc = c(3, 1, 0.5, 0.13, 0.12, 0.113), time = c(0, 1, 2, 3, 4, 5), manually.selected.points = TRUE, min.hl.points = 3, allow.tmax.in.half.life = FALSE, check = FALSE)\)clast.pred, info = “manually-selected half-life respects tlast and generates a different clast.pred”)), call = list(expect_true(pk.calc.half.life(conc = c(3,
1, 0.5, 0.13, 0.12, 0.113), time = c(0, 1, 2, 3, 4, 5), manually.selected.points = TRUE, min.hl.points= 3, tlast = 20, allow.tmax.in.half.life = FALSE, check = FALSE)\(clast.pred < pk.calc.half.life(conc = c(3, 1, 0.5, 0.13, 0.12, 0.113), time = c(0, 1, 2, 3, 4, 5), manually.selected.points = TRUE, min.hl.points = 3, allow.tmax.in.half.life = FALSE, check = FALSE)\)clast.pred, info = “manually-selected half-life respects tlast and generates a different clast.pred”)), start_frame = 74, end_frame = 74,
test = "half-life manual point selection"), list(message = "", srcref = c(161, 3, 171, 76, 3,76, 161,171), expectation_calls = list(expect_warning(manual_blq <- pk.calc.half.life(conc = rep(0, 6), time = c(0, 1, 2, 3, 4, 5), manually.selected.points = TRUE, min.hl.points = 3, tlast = 20, allow.tmax.in.half.life = FALSE, check = FALSE), regexp = “No data to manually fit for half-life (all concentrations may be 0)”, fixed = TRUE, info = “All BLQ with manual point selection gives a warning”)),
call = list(expect_warning(manual_blq <- pk.calc.half.life(conc = rep(0, 6), time = c(0, 1, 2, 3, 4, 5), manually.selected.points = TRUE, min.hl.points = 3, tlast = 20, allow.tmax.in.half.life = FALSE, check = FALSE), regexp = “No data to manually fit for half-life (all concentrations may be 0)”, fixed = TRUE, info = “All BLQ with manual point selection gives a warning”)), start_frame = 74, end_frame = 74, test = “half-life manual point selection”), list(message = “all(is.na(unlist(manual_blq))) isn’t true.”,
srcref = c(172,3, 173, 78, 3, 78, 172, 173), expectation_calls = list(expect_true(all(is.na(unlist(manual_blq))), info = “All BLQ with manual point selection gives all NA results”)), call = list(expect_true(all(is.na(unlist(manual_blq))), info = “All BLQ with manual point selection gives all NA results”)), start_frame = 74, end_frame = 74, test = “half-life manual point selection”))

+

+

+
Interpolation and extrapolation of concentration

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Testing FilenameTest DescriptionNumber of TestsNumber of Failed Testspassedresult
test-interpolate.conc.Rextrapolate.conc25025list(list(message = "“, srcref = c(5, 3, 9, 86, 3, 86, 5, 9), expectation_calls = list(expect_error(extrapolate.conc(conc = 1, time = 1, time.out = 2, extrap.method =”wrong“), regexp =”extrap.method must be one of ‘AUCinf’, ‘AUClast’, or ‘AUCall’“)), call = list(expect_error(extrapolate.conc(conc = 1, time = 1, time.out = 2, extrap.method =”wrong“), regexp =”extrap.method must be one of ‘AUCinf’, ‘AUClast’, or ‘AUCall’“)), start_frame = 74, end_frame = 74, test =”extrapolate.conc“), list(message =”",
srcref = c(12, 3, 16,74, 3, 74, 12, 16), expectation_calls = list(expect_error(extrapolate.conc(conc = 1, time = 1,time.out= c(2, 3), extrap.method = “AUCinf”), regexp = “Only one time.out value may be estimated at once.”)), call = list(expect_error(extrapolate.conc(conc = 1, time = 1, time.out = c(2, 3), extrap.method = “AUCinf”), regexp = “Only one time.out value may be estimated at once.”)), start_frame = 74, end_frame = 74, test = “extrapolate.conc”), list(message = "", srcref = c(20,
3, 24, 45, 3, 45, 20, 24),expectation_calls = list(expect_warning(v1 <- extrapolate.conc(conc =NA, time = 1, time.out =2, extrap.method = “AUCinf”))), call = list(expect_warning(v1 <- extrapolate.conc(conc = NA, time = 1, time.out = 2, extrap.method = “AUCinf”))), start_frame = 74, end_frame = 74, test = “extrapolate.conc”), list(message = “v1 not equal to NA.”, srcref = c(25, 3, 25, 22, 3, 22, 25, 25), expectation_calls = list(expect_equal(v1, NA)), call = list(expect_equal(v1, NA)),
start_frame = 74, end_frame = 74, test = “extrapolate.conc”), list(message= "", srcref = c(28, 3, 32, 148, 3, 148, 28, 32), expectation_calls = list(expect_error(extrapolate.conc(conc = 1, time = 1, time.out = 0.5, extrap.method = “AUCinf”), regexp = “extrapolate.conc can only work beyond Tlast, please use interp.extrap.conc to combine both interpolation and extrapolation.”)), call = list(expect_error(extrapolate.conc(conc = 1, time = 1, time.out = 0.5, extrap.method = “AUCinf”), regexp = “extrapolate.conc can only work beyond Tlast, please use interp.extrap.conc to combine both interpolation and extrapolation.”)),
start_frame = 74, end_frame = 74, test = “extrapolate.conc”), list(message= "", srcref = c(33, 3, 37, 148, 3, 148, 33, 37), expectation_calls = list(expect_error(extrapolate.conc(conc = 1, time = 1, time.out = 1, extrap.method = “AUCinf”), regexp = “extrapolate.conc can only work beyond Tlast, please use interp.extrap.conc to combine both interpolation and extrapolation.”)), call = list(expect_error(extrapolate.conc(conc = 1, time = 1, time.out = 1, extrap.method = “AUCinf”), regexp = “extrapolate.conc can only work beyond Tlast, please use interp.extrap.conc to combine both interpolation and extrapolation.”)),
start_frame = 74, end_frame = 74, test = “extrapolate.conc”), list(message= "extrapolate.conc(…) not equal to 0.Equal", srcref = c(40, 3, 44, 17, 3, 17, 40, 44), expectation_calls = list(expect_equal(extrapolate.conc(conc = c(0, 1, 0), time = 1:3, time.out = 4, extrap.method = “AUClast”), 0)), call = list(expect_equal(extrapolate.conc(conc = c(0, 1, 0), time = 1:3, time.out = 4, extrap.method = “AUClast”), 0)), start_frame = 74, end_frame = 74, test = “extrapolate.conc”), list(message = “extrapolate.conc(…) not equal to 0.”,
srcref = c(45, 3, 49,17, 3, 17, 45, 49), expectation_calls = list(expect_equal(extrapolate.conc(conc = c(0, 1, 0), time = 1:3, time.out = 2.5, extrap.method = “AUClast”), 0)), call = list(expect_equal(extrapolate.conc(conc = c(0, 1, 0), time = 1:3, time.out = 2.5, extrap.method = “AUClast”), 0)), start_frame = 74, end_frame = 74, test = “extrapolate.conc”), list(message = “extrapolate.conc(…) not equal to 0.”, srcref = c(52, 3, 56, 17, 3, 17, 52, 56), expectation_calls = list(expect_equal(extrapolate.conc(conc = c(0,
1, 0), time = 1:3, time.out = 4, extrap.method = “AUCall”), 0)), call = list(expect_equal(extrapolate.conc(conc = c(0, 1, 0),time = 1:3, time.out = 4, extrap.method = “AUCall”), 0)), start_frame = 74, end_frame = 74, test = “extrapolate.conc”), list(message = “extrapolate.conc(…) not equal to 0.”, srcref = c(59, 3, 64, 17, 3, 17, 59, 64), expectation_calls = list(expect_equal(extrapolate.conc(conc = c(0, 1, 1), time = 1:3, time.out = 4, lambda.z = 2, extrap.method = “AUCall”), 0)),
call = list(expect_equal(extrapolate.conc(conc = c(0, 1, 1), time = 1:3, time.out = 4, lambda.z = 2, extrap.method =“AUCall”), 0)), start_frame = 74, end_frame = 74, test = “extrapolate.conc”), list(message = “extrapolate.conc(…) not equal to 0.5.”, srcref = c(68, 3, 72, 19, 3, 19, 68, 72), expectation_calls = list(expect_equal(extrapolate.conc(conc = c(0, 1, 0), time = 1:3, time.out = 2.5, extrap.method = “AUCall”), 0.5)), call = list(expect_equal(extrapolate.conc(conc = c(0, 1, 0),
time = 1:3, time.out =2.5, extrap.method = “AUCall”), 0.5)), start_frame= 74, end_frame =74, test = "extrapolate.conc"), list(message = “extrapolate.conc(…) not equal to 1 * exp(-1 * 0.5).”, srcref = c(76, 3, 81, 29, 3, 29, 76, 81), expectation_calls = list(expect_equal(extrapolate.conc(conc = c(0, 1, 0), time = 1:3, time.out = 2.5, lambda.z = 1, extrap.method = “AUCinf”), 1 * exp(-1 * 0.5))), call = list(expect_equal(extrapolate.conc(conc = c(0, 1, 0), time = 1:3, time.out = 2.5,
lambda.z = 1, extrap.method = “AUCinf”), 1 * exp(-1 * 0.5))), start_frame= 74, end_frame =74, test = "extrapolate.conc"), list(message = “extrapolate.conc(…) not equal to 5 * exp(-3 * 0.5).”, srcref = c(84, 3, 89, 29, 3, 29, 84, 89), expectation_calls = list(expect_equal(extrapolate.conc(conc = c(0, 5, 0), time = 1:3, time.out = 2.5, lambda.z = 3, extrap.method = “AUCinf”), 5 * exp(-3 * 0.5))), call = list(expect_equal(extrapolate.conc(conc = c(0, 5, 0), time = 1:3, time.out = 2.5,
lambda.z = 3, extrap.method = “AUCinf”), 5 * exp(-3 * 0.5))), start_frame= 74, end_frame =74, test = "extrapolate.conc"), list(message = “extrapolate.conc(…) not equal to as.numeric(NA).”, srcref = c(92, 3, 97, 30, 3, 30, 92, 97), expectation_calls = list(expect_equal(extrapolate.conc(conc = c(0, 5, 0), time = 1:3, time.out = 2.5, lambda.z = NA, extrap.method = “AUCinf”), as.numeric(NA))), call = list(expect_equal(extrapolate.conc(conc = c(0, 5, 0), time = 1:3, time.out = 2.5, lambda.z = NA,
extrap.method = "AUCinf"), as.numeric(NA))), start_frame = 74, end_frame =74, test = "extrapolate.conc"), list(message = "",srcref = c(100, 3, 105, 45, 3, 45, 100, 105), expectation_calls = list(expect_warning(v1 <- extrapolate.conc(conc = rep(NA, 3), time = 1:3, time.out = 2.5, lambda.z = NA, extrap.method = “AUCinf”))), call = list(expect_warning(v1 <- extrapolate.conc(conc = rep(NA, 3), time = 1:3, time.out = 2.5, lambda.z = NA, extrap.method = “AUCinf”))), start_frame = 74, end_frame = 74,
test = "extrapolate.conc“), list(message =”v1 not equal to NA.",srcref = c(106, 3,106, 22, 3, 22, 106, 106), expectation_calls = list(expect_equal(v1, NA)), call = list(expect_equal(v1, NA)), start_frame = 74, end_frame = 74, test = “extrapolate.conc”), list(message = “extrapolate.conc(…) not equal to extrapolations[[n]].”, srcref = c(113, 3, 119, 24, 3, 24, 113, 119), expectation_calls = list(expect_equal(extrapolate.conc(conc = c(0, 1, 0.5, 1, 0), time = 0:4, 5, lambda.z = 1,
extrap.method = n), extrapolations[[n]], info = n)), call = list(expect_equal(extrapolate.conc(conc = c(0, 1, 0.5, 1,0), time= 0:4, 5, lambda.z = 1, extrap.method = n), extrapolations[[n]], info = n)), start_frame = 74, end_frame = 74, test = “extrapolate.conc”), list(message = “extrapolate.conc(…) not equal to extrapolations[[n]].”, srcref = c(113, 3, 119, 24, 3, 24, 113, 119), expectation_calls = list(expect_equal(extrapolate.conc(conc = c(0, 1, 0.5, 1, 0), time = 0:4, 5, lambda.z = 1,
extrap.method = n), extrapolations[[n]], info = n)), call = list(expect_equal(extrapolate.conc(conc = c(0, 1, 0.5, 1,0), time= 0:4, 5, lambda.z = 1, extrap.method = n), extrapolations[[n]], info = n)), start_frame = 74, end_frame = 74, test = “extrapolate.conc”), list(message = “extrapolate.conc(…) not equal to extrapolations[[n]].”, srcref = c(113, 3, 119, 24, 3, 24, 113, 119), expectation_calls = list(expect_equal(extrapolate.conc(conc = c(0, 1, 0.5, 1, 0), time = 0:4, 5, lambda.z = 1,
extrap.method = n), extrapolations[[n]], info = n)), call = list(expect_equal(extrapolate.conc(conc = c(0, 1, 0.5, 1,0), time= 0:4, 5, lambda.z = 1, extrap.method = n), extrapolations[[n]], info = n)), start_frame = 74, end_frame = 74, test = “extrapolate.conc”), list(message = “extrapolate.conc(…) not equal to extrapolations[[n]].”, srcref = c(125, 3, 131, 24, 3, 24, 125, 131), expectation_calls = list(expect_equal(extrapolate.conc(conc = c(0, 1, 0.5, 1, 0), time = 0:4, 4, lambda.z = 1,
extrap.method = n), extrapolations[[n]], info = n)), call = list(expect_equal(extrapolate.conc(conc = c(0, 1, 0.5, 1,0), time= 0:4, 4, lambda.z = 1, extrap.method = n), extrapolations[[n]], info = n)), start_frame = 74, end_frame = 74, test = “extrapolate.conc”), list(message = “extrapolate.conc(…) not equal to extrapolations[[n]].”, srcref = c(125, 3, 131, 24, 3, 24, 125, 131), expectation_calls = list(expect_equal(extrapolate.conc(conc = c(0, 1, 0.5, 1, 0), time = 0:4, 4, lambda.z = 1,
extrap.method = n), extrapolations[[n]], info = n)), call = list(expect_equal(extrapolate.conc(conc = c(0, 1, 0.5, 1,0), time= 0:4, 4, lambda.z = 1, extrap.method = n), extrapolations[[n]], info = n)), start_frame = 74, end_frame = 74, test = “extrapolate.conc”), list(message = “extrapolate.conc(…) not equal to extrapolations[[n]].”, srcref = c(125, 3, 131, 24, 3, 24, 125, 131), expectation_calls = list(expect_equal(extrapolate.conc(conc = c(0, 1, 0.5, 1, 0), time = 0:4, 4, lambda.z = 1,
extrap.method = n), extrapolations[[n]], info = n)), call = list(expect_equal(extrapolate.conc(conc = c(0, 1, 0.5, 1,0), time= 0:4, 4, lambda.z = 1, extrap.method = n), extrapolations[[n]], info = n)), start_frame = 74, end_frame = 74, test = “extrapolate.conc”), list(message = “extrapolate.conc(…) not equal to extrapolations[[n]].”, srcref = c(137, 3, 143, 24, 3, 24, 137, 143), expectation_calls = list(expect_equal(extrapolate.conc(conc = c(0, 1, 0.5, 1, 0), time = 0:4, 3.5, lambda.z = 1,
extrap.method = n), extrapolations[[n]], info = n)), call = list(expect_equal(extrapolate.conc(conc = c(0, 1, 0.5, 1,0), time= 0:4, 3.5, lambda.z = 1, extrap.method = n), extrapolations[[n]], info = n)), start_frame = 74, end_frame = 74, test = “extrapolate.conc”), list(message = “extrapolate.conc(…) not equal to extrapolations[[n]].”, srcref = c(137, 3, 143, 24, 3, 24, 137, 143), expectation_calls = list(expect_equal(extrapolate.conc(conc = c(0, 1, 0.5, 1, 0), time = 0:4, 3.5, lambda.z = 1,
extrap.method = n), extrapolations[[n]], info = n)), call = list(expect_equal(extrapolate.conc(conc = c(0, 1, 0.5, 1,0), time= 0:4, 3.5, lambda.z = 1, extrap.method = n), extrapolations[[n]], info = n)), start_frame = 74, end_frame = 74, test = “extrapolate.conc”), list(message = “extrapolate.conc(…) not equal to extrapolations[[n]].”, srcref = c(137, 3, 143, 24, 3, 24, 137, 143), expectation_calls = list(expect_equal(extrapolate.conc(conc = c(0, 1, 0.5, 1, 0), time = 0:4, 3.5, lambda.z = 1,
extrap.method = n), extrapolations[[n]], info = n)), call = list(expect_equal(extrapolate.conc(conc = c(0, 1, 0.5, 1,0), time= 0:4, 3.5, lambda.z = 1, extrap.method = n), extrapolations[[n]], info = n)), start_frame = 74, end_frame = 74, test = “extrapolate.conc”))
test-interpolate.conc.Rinterpolate.conc32032list(list(message = “interpolate.conc(conc = c(0, 1), time = 0:1, time.out = 0, interp.method = n) not equal to interpolations[[n]].”, srcref = c(151, 3, 157, 24, 3, 24, 151, 157), expectation_calls = list(expect_equal(interpolate.conc(conc = c(0, 1), time = 0:1, time.out = 0, interp.method = n), interpolations[[n]], info = n)), call = list(expect_equal(interpolate.conc(conc = c(0, 1), time = 0:1, time.out = 0, interp.method = n), interpolations[[n]], info = n)), start_frame = 74, end_frame = 74,
test = "interpolate.conc“), list(message =”interpolate.conc(conc = c(0, 1), time = 0:1, time.out = 0, interp.method= n) notequal to interpolations[[n]].", srcref = c(151, 3, 157, 24, 3, 24, 151, 157), expectation_calls = list(expect_equal(interpolate.conc(conc = c(0, 1), time = 0:1, time.out = 0, interp.method = n), interpolations[[n]], info = n)), call = list(expect_equal(interpolate.conc(conc = c(0, 1), time = 0:1, time.out = 0, interp.method = n), interpolations[[n]], info = n)),
start_frame = 74, end_frame = 74, test = “interpolate.conc”), list(message= "interpolate.conc(conc = c(0, 1), time =0:1, time.out = 1, interp.method = n) not equal to interpolations[[n]].", srcref = c(161, 3, 167, 24, 3, 24, 161, 167), expectation_calls = list(expect_equal(interpolate.conc(conc = c(0, 1), time = 0:1, time.out = 1, interp.method = n), interpolations[[n]], info = n)), call = list(expect_equal(interpolate.conc(conc = c(0, 1), time = 0:1, time.out = 1, interp.method = n),
interpolations[[n]], info = n)), start_frame = 74, end_frame = 74, test =“interpolate.conc”), list(message = "interpolate.conc(conc = c(0, 1), time = 0:1, time.out = 1, interp.method = n) not equal to interpolations[[n]].", srcref = c(161, 3, 167, 24, 3, 24, 161, 167), expectation_calls = list(expect_equal(interpolate.conc(conc = c(0, 1), time = 0:1, time.out = 1, interp.method = n), interpolations[[n]], info = n)), call = list(expect_equal(interpolate.conc(conc = c(0, 1), time = 0:1,
time.out = 1, interp.method = n), interpolations[[n]], info = n)), start_frame = 74, end_frame = 74, test = "interpolate.conc"), list(message = “interpolate.conc(…) not equal to interpolations[[n]].”, srcref = c(174, 3, 180, 24, 3, 24, 174, 180), expectation_calls = list(expect_equal(interpolate.conc(conc = c(0, 1, NA, 1), time = 0:3, time.out = 2, interp.method = n), interpolations[[n]], info = n)), call = list(expect_equal(interpolate.conc(conc = c(0, 1, NA, 1), time = 0:3, time.out = 2,
interp.method = n), interpolations[[n]], info = n)), start_frame = 74, end_frame = 74, test= “interpolate.conc”), list(message = “interpolate.conc(…) not equal to interpolations[[n]].”, srcref = c(174, 3, 180, 24, 3, 24, 174, 180), expectation_calls = list(expect_equal(interpolate.conc(conc = c(0, 1, NA, 1), time = 0:3, time.out = 2, interp.method = n), interpolations[[n]], info = n)), call = list(expect_equal(interpolate.conc(conc = c(0, 1, NA, 1), time = 0:3, time.out = 2, interp.method = n),
interpolations[[n]], info = n)), start_frame = 74, end_frame = 74, test =“interpolate.conc”), list(message = "interpolate.conc(…) not equal to interpolations[[n]].", srcref = c(185, 3, 191, 24, 3, 24, 185, 191), expectation_calls = list(expect_equal(interpolate.conc(conc = c(0, 1, 0), time = 0:2, time.out = 0.5, interp.method = n), interpolations[[n]], info = n)), call = list(expect_equal(interpolate.conc(conc = c(0, 1, 0), time = 0:2, time.out = 0.5, interp.method = n), interpolations[[n]],
info = n)), start_frame = 74, end_frame = 74, test = “interpolate.conc”),list(message = "interpolate.conc(…) not equal to interpolations[[n]].", srcref = c(185, 3, 191, 24, 3, 24, 185, 191), expectation_calls = list(expect_equal(interpolate.conc(conc = c(0, 1, 0), time = 0:2, time.out = 0.5, interp.method = n), interpolations[[n]], info = n)), call = list(expect_equal(interpolate.conc(conc = c(0, 1, 0), time = 0:2, time.out = 0.5, interp.method = n), interpolations[[n]], info = n)),
start_frame = 74, end_frame = 74, test = “interpolate.conc”), list(message= "interpolate.conc(…) not equal to interpolations[[n]].", srcref = c(195, 3, 201, 24, 3, 24, 195, 201), expectation_calls = list(expect_equal(interpolate.conc(conc = c(0, 2, 1), time = 0:2, time.out = 1.25, interp.method = n), interpolations[[n]], info = n)), call = list(expect_equal(interpolate.conc(conc = c(0, 2, 1), time = 0:2, time.out = 1.25, interp.method = n), interpolations[[n]], info = n)), start_frame = 74,
end_frame = 74, test =“interpolate.conc”), list(message = "interpolate.conc(…) not equalto interpolations[[n]].Equal", srcref = c(195, 3, 201, 24, 3, 24, 195, 201), expectation_calls = list(expect_equal(interpolate.conc(conc = c(0, 2, 1), time = 0:2, time.out = 1.25, interp.method = n), interpolations[[n]], info = n)), call = list(expect_equal(interpolate.conc(conc = c(0, 2, 1), time = 0:2, time.out = 1.25, interp.method = n), interpolations[[n]], info = n)), start_frame = 74, end_frame = 74,
test = "interpolate.conc“), list(message =”interpolate.conc(…) not equal to interpolations[[n]].", srcref =c(207, 3, 213, 24, 3, 24, 207, 213), expectation_calls = list(expect_equal(interpolate.conc(conc = c(0, 2, 1), time = seq(-10, -8, by = 1), time.out = -8.75, interp.method = n), interpolations[[n]], info = n)), call = list(expect_equal(interpolate.conc(conc = c(0, 2, 1), time = seq(-10, -8, by = 1), time.out = -8.75, interp.method = n), interpolations[[n]], info = n)), start_frame = 74,
end_frame = 74, test =“interpolate.conc”), list(message = "interpolate.conc(…) not equalto interpolations[[n]].Equal", srcref = c(207, 3, 213, 24, 3, 24, 207, 213), expectation_calls = list(expect_equal(interpolate.conc(conc = c(0, 2, 1), time = seq(-10, -8, by = 1), time.out = -8.75, interp.method = n), interpolations[[n]], info = n)), call = list(expect_equal(interpolate.conc(conc = c(0, 2, 1), time = seq(-10, -8, by = 1), time.out = -8.75, interp.method = n), interpolations[[n]], info = n)),
start_frame = 74, end_frame = 74, test = “interpolate.conc”), list(message= "interpolate.conc(…) not equal to interpolations[[n]].“, srcref = c(219, 3, 226, 24, 3, 24, 219, 226), expectation_calls = list(expect_equal(interpolate.conc(conc = c(0, 1, 0, 1, 0), time = 0:4, time.out = 2.25, conc.blq =”keep“, interp.method = n), interpolations[[n]], info = n)), call = list(expect_equal(interpolate.conc(conc = c(0, 1, 0, 1, 0), time = 0:4, time.out = 2.25, conc.blq =”keep", interp.method = n),
interpolations[[n]], info = n)), start_frame = 74, end_frame = 74, test =“interpolate.conc”), list(message = "interpolate.conc(…) not equal to interpolations[[n]].“, srcref = c(219, 3, 226, 24, 3, 24, 219, 226), expectation_calls = list(expect_equal(interpolate.conc(conc = c(0, 1, 0, 1, 0), time = 0:4, time.out = 2.25, conc.blq =”keep", interp.method = n), interpolations[[n]], info = n)), call = list(expect_equal(interpolate.conc(conc = c(0, 1, 0, 1, 0), time = 0:4, time.out = 2.25,
conc.blq = “keep”, interp.method = n), interpolations[[n]], info = n)), start_frame = 74, end_frame = 74, test = "interpolate.conc“), list(message =”interpolate.conc(…) not equal to interpolations[[n]].“, srcref = c(232, 3, 239, 24, 3, 24, 232, 239), expectation_calls = list(expect_equal(interpolate.conc(conc = c(0, 1, 0, 1, 0), time = 0:4, time.out = 1.5, conc.blq =”keep", interp.method = n), interpolations[[n]], info = n)), call = list(expect_equal(interpolate.conc(conc = c(0, 1,
0, 1, 0), time = 0:4,time.out = 1.5, conc.blq = “keep”, interp.method = n), interpolations[[n]], info = n)), start_frame = 74, end_frame = 74, test = “interpolate.conc”), list(message = “interpolate.conc(…) not equal to interpolations[[n]].”, srcref = c(232, 3, 239, 24, 3, 24, 232, 239), expectation_calls = list(expect_equal(interpolate.conc(conc = c(0, 1, 0, 1, 0), time = 0:4, time.out = 1.5, conc.blq = “keep”, interp.method = n), interpolations[[n]], info = n)), call = list(expect_equal(interpolate.conc(conc = c(0,
1, 0, 1, 0), time = 0:4, time.out = 1.5, conc.blq = “keep”, interp.method= n), interpolations[[n]], info = n)), start_frame =74, end_frame = 74, test = “interpolate.conc”), list(message = “interpolate.conc(…) not equal to interpolations[[n]].”, srcref = c(243, 3, 250, 24, 3, 24, 243, 250), expectation_calls = list(expect_equal(interpolate.conc(conc = c(0, 1, 0, 1, 0), time = 0:4, time.out = 2.5, conc.blq = “keep”, interp.method = n), interpolations[[n]], info = n)), call = list(expect_equal(interpolate.conc(conc = c(0,
1, 0, 1, 0), time = 0:4, time.out = 2.5, conc.blq = “keep”, interp.method= n), interpolations[[n]], info = n)), start_frame =74, end_frame = 74, test = “interpolate.conc”), list(message = “interpolate.conc(…) not equal to interpolations[[n]].”, srcref = c(243, 3, 250, 24, 3, 24, 243, 250), expectation_calls = list(expect_equal(interpolate.conc(conc = c(0, 1, 0, 1, 0), time = 0:4, time.out = 2.5, conc.blq = “keep”, interp.method = n), interpolations[[n]], info = n)), call = list(expect_equal(interpolate.conc(conc = c(0,
1, 0, 1, 0), time = 0:4, time.out = 2.5, conc.blq = “keep”, interp.method= n), interpolations[[n]], info = n)), start_frame =74, end_frame = 74, test = “interpolate.conc”), list(message = “interpolate.conc(…) not equal to interpolations[[n]].”, srcref = c(255, 3, 262, 24, 3, 24, 255, 262), expectation_calls = list(expect_equal(interpolate.conc(conc = c(0, 1, 0, 1, 0), time = 0:4, time.out = 2.25, conc.blq = “drop”, interp.method = n), interpolations[[n]], info = n)), call = list(expect_equal(interpolate.conc(conc = c(0,
1, 0, 1, 0), time = 0:4, time.out = 2.25, conc.blq = “drop”, interp.method= n), interpolations[[n]], info = n)), start_frame= 74, end_frame = 74, test = “interpolate.conc”), list(message = “interpolate.conc(…) not equal to interpolations[[n]].”, srcref = c(255, 3, 262, 24, 3, 24, 255, 262), expectation_calls = list(expect_equal(interpolate.conc(conc = c(0, 1, 0, 1, 0), time = 0:4, time.out = 2.25, conc.blq = “drop”, interp.method = n), interpolations[[n]], info = n)), call = list(expect_equal(interpolate.conc(conc = c(0,
1, 0, 1, 0), time = 0:4, time.out = 2.25, conc.blq = “drop”, interp.method= n), interpolations[[n]], info = n)), start_frame= 74, end_frame = 74, test = “interpolate.conc”), list(message = “interpolate.conc(…) not equal to exp(mean(log(c(1, 0.5)))).”, srcref = c(265, 3, 269, 41, 3, 41, 265, 269), expectation_calls = list(expect_equal(interpolate.conc(conc = c(0, 1, 0.5, 1, 0), time = 0:4, time.out = 1.5, interp.method = “lin up/log down”), exp(mean(log(c(1, 0.5)))))), call = list(expect_equal(interpolate.conc(conc = c(0,
1, 0.5, 1, 0), time =0:4, time.out = 1.5, interp.method = "lin up/log down"), exp(mean(log(c(1, 0.5)))))), start_frame = 74,end_frame = 74, test = “interpolate.conc”), list(message = "“, srcref = c(272, 3, 276, 150, 3, 150, 272, 276), expectation_calls = list(expect_error(interpolate.conc(conc = c(0, 1, 0.5, 1, 0), time = 0:4, time.out = 5, interp.method =”lin up/log down“), regexp =”interpolate.conc can only works through Tlast, please use interp.extrap.conc to combine both interpolation and extrapolation.")),
call = list(expect_error(interpolate.conc(conc = c(0, 1, 0.5, 1, 0), time= 0:4, time.out =5, interp.method = "lin up/log down“), regexp =”interpolate.conc can only works through Tlast, please use interp.extrap.conc to combine both interpolation and extrapolation.“)), start_frame = 74, end_frame = 74, test =”interpolate.conc“), list(message =”interpolate.conc(conc = 0:1, time = 0:1, time.out = -1) not equal to 0.", srcref = c(279, 3, 283, 51, 3, 51, 279, 283), expectation_calls = list(
expect_equal(interpolate.conc(conc = 0:1, time = 0:1, time.out = -1), 0, info = "conc.origindefaults to zero")), call = list(expect_equal(interpolate.conc(conc = 0:1, time = 0:1, time.out = -1), 0, info = “conc.origin defaults to zero”)), start_frame = 74, end_frame = 74, test = “interpolate.conc”), list(message = “interpolate.conc(conc = 0:1, time = 0:1, time.out = -1, conc.origin = NA) not equal to NA.”, srcref = c(284, 3, 289, 51, 3, 51, 284, 289), expectation_calls = list(expect_equal(interpolate.conc(conc = 0:1,
time = 0:1, time.out =-1, conc.origin = NA), NA, info = "conc.origin is honored as NA")), call = list(expect_equal(interpolate.conc(conc = 0:1, time = 0:1, time.out = -1, conc.origin = NA), NA, info = “conc.origin is honored as NA”)), start_frame = 74, end_frame = 74, test = “interpolate.conc”), list(message = “interpolate.conc(conc = 0:1, time = 0:1, time.out = -1, conc.origin = 5) not equal to 5.”, srcref = c(290, 3, 295, 57, 3, 57, 290, 295), expectation_calls = list(expect_equal(interpolate.conc(conc = 0:1,
time = 0:1, time.out =-1, conc.origin = 5), 5, info = "conc.origin is honored as a number")), call = list(expect_equal(interpolate.conc(conc = 0:1, time = 0:1, time.out = -1, conc.origin = 5), 5, info = “conc.origin is honored as a number”)), start_frame = 74, end_frame = 74, test = “interpolate.conc”), list(message = “interpolate.conc(…) not equal to NA.”, srcref = c(297, 3, 302, 89, 3, 89, 297, 302), expectation_calls = list(expect_equal(interpolate.conc(conc = c(NA, 1), time = c(0,
1), time.out = 0.5, check = FALSE), NA, info = "Skipping the checks with an NA bounding theinterpolation gives NA")), call =list(expect_equal(interpolate.conc(conc = c(NA, 1), time = c(0, 1), time.out = 0.5, check = FALSE), NA, info = “Skipping the checks with an NA bounding the interpolation gives NA”)), start_frame = 74, end_frame = 74, test = “interpolate.conc”), list(message = “interpolate.conc(…) not equal to 1.5.”, srcref = c(304, 3, 309, 115, 3, 115, 304, 309), expectation_calls = list(
expect_equal(interpolate.conc(conc = c(NA, 1, 2), time = c(0, 1, 2), time.out = 1.5, check =FALSE), 1.5, info = "Skipping thechecks with an NA, but not bounding the interpolation gives the expected value.“)), call = list(expect_equal(interpolate.conc(conc = c(NA, 1, 2), time = c(0, 1, 2), time.out = 1.5, check = FALSE), 1.5, info =”Skipping the checks with an NA, but not bounding the interpolation gives the expected value.“)), start_frame = 74, end_frame = 74, test =”interpolate.conc"), list(
message = "", srcref =c(315, 3, 319, 80, 3, 80, 315, 319), expectation_calls = list(expect_error(interpolate.conc(conc = 0:1,time = 0:1, time.out = 0:1), regexp = “Can only interpolate for one time point per function call”, info = “Confirm that more than one time.out requested is an error”)), call = list(expect_error(interpolate.conc(conc = 0:1, time = 0:1, time.out = 0:1), regexp = “Can only interpolate for one time point per function call”, info = “Confirm that more than one time.out requested is an error”)),
start_frame = 74, end_frame = 74, test = “interpolate.conc”), list(message= "", srcref = c(321, 3, 330, 79, 3, 79, 321, 330),expectation_calls = list(expect_error(interpolate.conc(conc = 0:1, time = 0:1, time.out = 0.5, interp.method = “this doesn’t work”), regexp = tryCatch(expr = {
match.arg(“foo”, choices = c(“lin up/log down”, “linear”))
}, error = function(e) e)$message, fixed = TRUE, info = "Confirm that invalidinterpolation methods are an error.")), call = list(expect_error(interpolate.conc(conc = 0:1, time = 0:1, time.out = 0.5, interp.method = “this doesn’t work”), regexp = tryCatch(expr = {
match.arg(“foo”, choices = c(“lin up/log down”, “linear”))
}, error = function(e) e)$message, fixed = TRUE, info = "Confirm that invalidinterpolation methods are an error.")), start_frame= 74, end_frame = 74, test = “interpolate.conc”), list(message = "“, srcref = c(332, 3, 337, 51, 3, 51, 332, 337), expectation_calls = list(expect_error(interpolate.conc(conc = 0:1, time = 0:1, time.out = 0.5, conc.origin = 1:2), regexp =”conc.origin must be a scalar“, info =”conc.origin must be a scalar")), call = list(expect_error(interpolate.conc(conc = 0:1, time = 0:1,
time.out = 0.5, conc.origin = 1:2), regexp = "conc.origin must be a scalar“, info =”conc.origin must be a scalar")),start_frame = 74, end_frame = 74, test = “interpolate.conc”), list(message = "“, srcref = c(338, 3, 343, 80, 3, 80, 338, 343), expectation_calls = list(expect_error(interpolate.conc(conc = 0:1, time = 0:1, time.out = 0.5, conc.origin =”A“), regexp =”conc.origin must be NA or a number \(and not a factor\)“, info =”conc.origin must be a number and not a factor (character)")),
call = list(expect_error(interpolate.conc(conc = 0:1, time = 0:1, time.out= 0.5, conc.origin = “A”), regexp = "conc.origin must be NA or a number \(and not a factor\)“, info =”conc.origin must be a number and not a factor (character)“)), start_frame = 74, end_frame = 74, test =”interpolate.conc“), list(message =”“, srcref = c(344, 3, 349, 77, 3, 77, 344, 349), expectation_calls = list(expect_error(interpolate.conc(conc = 0:1, time = 0:1, time.out = 0.5, conc.origin = factor(”A“)), regexp =”conc.origin must be NA or a number \(and not a factor\)",
info = "conc.origin must be a number and not a factor (factor)")), call =list(expect_error(interpolate.conc(conc = 0:1, time= 0:1, time.out = 0.5, conc.origin = factor(“A”)), regexp = “conc.origin must be NA or a number \(and not a factor\)”, info = “conc.origin must be a number and not a factor (factor)”)), start_frame = 74, end_frame = 74, test = “interpolate.conc”))
test-interpolate.conc.Rinterp.extrap.conc505list(list(message = “interp.extrap.conc(…) not equal to exp(mean(log(c(1, 0.5)))).”, srcref = c(354, 3, 359, 30, 3, 30, 354, 359), expectation_calls = list(expect_equal(interp.extrap.conc(conc = c(0, 1, 0.5, 1, 0), time = 0:4, time.out = 1.5, interp.method = “lin up/log down”), exp(mean(log(c(1, 0.5)))))), call = list(expect_equal(interp.extrap.conc(conc = c(0, 1, 0.5, 1, 0), time = 0:4, time.out = 1.5, interp.method = “lin up/log down”), exp(mean(log(c(1, 0.5)))))), start_frame = 74, end_frame = 74,
test = "interp.extrap.conc“), list(message =”", srcref = c(362, 3, 366, 56, 3, 56, 362, 366), expectation_calls = list(expect_warning(v1 <- interp.extrap.conc(conc = c(0, 1, 0.5, 1, 0), time = 0:4, time.out = c(1.5, NA), interp.method = “lin up/log down”))), call = list(expect_warning(v1 <- interp.extrap.conc(conc = c(0, 1, 0.5, 1, 0), time = 0:4, time.out = c(1.5, NA), interp.method = “lin up/log down”))), start_frame = 74, end_frame = 74, test = “interp.extrap.conc”), list(message = “v1 not equal to c(exp(mean(log(c(1, 0.5)))), NA).”,
srcref = c(367, 3, 367, 52, 3, 52, 367, 367), expectation_calls = list(expect_equal(v1, c(exp(mean(log(c(1, 0.5)))),NA))), call = list(expect_equal(v1, c(exp(mean(log(c(1, 0.5)))), NA))), start_frame = 74, end_frame = 74, test = “interp.extrap.conc”), list(message = "“, srcref = c(370, 3, 375, 55, 3, 55, 370, 375), expectation_calls = list(expect_warning(interp.extrap.conc(conc = c(0, 1, 0.5, 1, 0), time = 0:4, time.out = c(1.5, NA), interp.method =”lin up/log down“), regexp =”An interpolation/extrapolation time is NA")),
call = list(expect_warning(interp.extrap.conc(conc = c(0, 1, 0.5, 1, 0), time = 0:4, time.out = c(1.5, NA), interp.method = "lin up/log down“), regexp =”An interpolation/extrapolation time is NA“)), start_frame = 74, end_frame = 74, test =”interp.extrap.conc“), list(message =”“, srcref = c(378, 3, 383, 65, 3, 65, 378, 383), expectation_calls = list(expect_error(interp.extrap.conc(conc = c(0, 1, 0.5, 1, 0), time = 0:4, time.out = c(), interp.method =”lin up/log down“), regexp =”time.out must be a vector with at least one element")),
call = list(expect_error(interp.extrap.conc(conc = c(0, 1, 0.5, 1, 0), time = 0:4, time.out= c(), interp.method = "lin up/logdown“), regexp =”time.out must be a vector with at least one element“)), start_frame = 74, end_frame = 74, test =”interp.extrap.conc"))
test-interpolate.conc.Rinterp.extrap.conc.dose handles all eventualities25025list(list(message = “any(mask_selected) isn’t true.”, srcref = c(395, 5, 396, 106, 5, 106, 395, 396), expectation_calls = list(expect_true(any(mask_selected), info = sprintf(“interp.extrap.conc.dose.select[[%s]] matched at least one eventuality”, nm))), call = list(expect_true(any(mask_selected), info = sprintf(“interp.extrap.conc.dose.select[[%s]] matched at least one eventuality”, nm))), start_frame = 74, end_frame = 74, test = “interp.extrap.conc.dose handles all eventualities”), list(message = “!any(mask_selected & !is.na(eventualities$method)) isn’t true.”,
srcref = c(397, 5, 398, 105, 5, 105, 397, 398), expectation_calls = list(expect_true(!any(mask_selected & !is.na(eventualities\(method)), info = sprintf("interp.extrap.conc.dose.select[[%s]] overlapped with another method.", nm))), call = list(expect_true(!any(mask_selected & !is.na(eventualities\)method)), info = sprintf(“interp.extrap.conc.dose.select[[%s]] overlapped with another method.”, nm))), start_frame = 74, end_frame = 74, test = “interp.extrap.conc.dose handles all eventualities”), list(
message = "any(mask_selected) isn’t true.", srcref = c(395, 5, 396, 106, 5, 106, 395, 396),expectation_calls = list(expect_true(any(mask_selected), info = sprintf(“interp.extrap.conc.dose.select[[%s]] matched at least one eventuality”, nm))), call = list(expect_true(any(mask_selected), info = sprintf(“interp.extrap.conc.dose.select[[%s]] matched at least one eventuality”, nm))), start_frame = 74, end_frame = 74, test = “interp.extrap.conc.dose handles all eventualities”), list(message = “!any(mask_selected & !is.na(eventualities$method)) isn’t true.”,
srcref = c(397, 5, 398, 105, 5, 105, 397, 398), expectation_calls = list(expect_true(!any(mask_selected & !is.na(eventualities\(method)), info = sprintf("interp.extrap.conc.dose.select[[%s]] overlapped with another method.", nm))), call = list(expect_true(!any(mask_selected & !is.na(eventualities\)method)), info = sprintf(“interp.extrap.conc.dose.select[[%s]] overlapped with another method.”, nm))), start_frame = 74, end_frame = 74, test = “interp.extrap.conc.dose handles all eventualities”), list(
message = "any(mask_selected) isn’t true.", srcref = c(395, 5, 396, 106, 5, 106, 395, 396),expectation_calls = list(expect_true(any(mask_selected), info = sprintf(“interp.extrap.conc.dose.select[[%s]] matched at least one eventuality”, nm))), call = list(expect_true(any(mask_selected), info = sprintf(“interp.extrap.conc.dose.select[[%s]] matched at least one eventuality”, nm))), start_frame = 74, end_frame = 74, test = “interp.extrap.conc.dose handles all eventualities”), list(message = “!any(mask_selected & !is.na(eventualities$method)) isn’t true.”,
srcref = c(397, 5, 398, 105, 5, 105, 397, 398), expectation_calls = list(expect_true(!any(mask_selected & !is.na(eventualities\(method)), info = sprintf("interp.extrap.conc.dose.select[[%s]] overlapped with another method.", nm))), call = list(expect_true(!any(mask_selected & !is.na(eventualities\)method)), info = sprintf(“interp.extrap.conc.dose.select[[%s]] overlapped with another method.”, nm))), start_frame = 74, end_frame = 74, test = “interp.extrap.conc.dose handles all eventualities”), list(
message = "any(mask_selected) isn’t true.", srcref = c(395, 5, 396, 106, 5, 106, 395, 396),expectation_calls = list(expect_true(any(mask_selected), info = sprintf(“interp.extrap.conc.dose.select[[%s]] matched at least one eventuality”, nm))), call = list(expect_true(any(mask_selected), info = sprintf(“interp.extrap.conc.dose.select[[%s]] matched at least one eventuality”, nm))), start_frame = 74, end_frame = 74, test = “interp.extrap.conc.dose handles all eventualities”), list(message = “!any(mask_selected & !is.na(eventualities$method)) isn’t true.”,
srcref = c(397, 5, 398, 105, 5, 105, 397, 398), expectation_calls = list(expect_true(!any(mask_selected & !is.na(eventualities\(method)), info = sprintf("interp.extrap.conc.dose.select[[%s]] overlapped with another method.", nm))), call = list(expect_true(!any(mask_selected & !is.na(eventualities\)method)), info = sprintf(“interp.extrap.conc.dose.select[[%s]] overlapped with another method.”, nm))), start_frame = 74, end_frame = 74, test = “interp.extrap.conc.dose handles all eventualities”), list(
message = "any(mask_selected) isn’t true.", srcref = c(395, 5, 396, 106, 5, 106, 395, 396),expectation_calls = list(expect_true(any(mask_selected), info = sprintf(“interp.extrap.conc.dose.select[[%s]] matched at least one eventuality”, nm))), call = list(expect_true(any(mask_selected), info = sprintf(“interp.extrap.conc.dose.select[[%s]] matched at least one eventuality”, nm))), start_frame = 74, end_frame = 74, test = “interp.extrap.conc.dose handles all eventualities”), list(message = “!any(mask_selected & !is.na(eventualities$method)) isn’t true.”,
srcref = c(397, 5, 398, 105, 5, 105, 397, 398), expectation_calls = list(expect_true(!any(mask_selected & !is.na(eventualities\(method)), info = sprintf("interp.extrap.conc.dose.select[[%s]] overlapped with another method.", nm))), call = list(expect_true(!any(mask_selected & !is.na(eventualities\)method)), info = sprintf(“interp.extrap.conc.dose.select[[%s]] overlapped with another method.”, nm))), start_frame = 74, end_frame = 74, test = “interp.extrap.conc.dose handles all eventualities”), list(
message = "any(mask_selected) isn’t true.", srcref = c(395, 5, 396, 106, 5, 106, 395, 396),expectation_calls = list(expect_true(any(mask_selected), info = sprintf(“interp.extrap.conc.dose.select[[%s]] matched at least one eventuality”, nm))), call = list(expect_true(any(mask_selected), info = sprintf(“interp.extrap.conc.dose.select[[%s]] matched at least one eventuality”, nm))), start_frame = 74, end_frame = 74, test = “interp.extrap.conc.dose handles all eventualities”), list(message = “!any(mask_selected & !is.na(eventualities$method)) isn’t true.”,
srcref = c(397, 5, 398, 105, 5, 105, 397, 398), expectation_calls = list(expect_true(!any(mask_selected & !is.na(eventualities\(method)), info = sprintf("interp.extrap.conc.dose.select[[%s]] overlapped with another method.", nm))), call = list(expect_true(!any(mask_selected & !is.na(eventualities\)method)), info = sprintf(“interp.extrap.conc.dose.select[[%s]] overlapped with another method.”, nm))), start_frame = 74, end_frame = 74, test = “interp.extrap.conc.dose handles all eventualities”), list(
message = "any(mask_selected) isn’t true.", srcref = c(395, 5, 396, 106, 5, 106, 395, 396),expectation_calls = list(expect_true(any(mask_selected), info = sprintf(“interp.extrap.conc.dose.select[[%s]] matched at least one eventuality”, nm))), call = list(expect_true(any(mask_selected), info = sprintf(“interp.extrap.conc.dose.select[[%s]] matched at least one eventuality”, nm))), start_frame = 74, end_frame = 74, test = “interp.extrap.conc.dose handles all eventualities”), list(message = “!any(mask_selected & !is.na(eventualities$method)) isn’t true.”,
srcref = c(397, 5, 398, 105, 5, 105, 397, 398), expectation_calls = list(expect_true(!any(mask_selected & !is.na(eventualities\(method)), info = sprintf("interp.extrap.conc.dose.select[[%s]] overlapped with another method.", nm))), call = list(expect_true(!any(mask_selected & !is.na(eventualities\)method)), info = sprintf(“interp.extrap.conc.dose.select[[%s]] overlapped with another method.”, nm))), start_frame = 74, end_frame = 74, test = “interp.extrap.conc.dose handles all eventualities”), list(
message = "any(mask_selected) isn’t true.", srcref = c(395, 5, 396, 106, 5, 106, 395, 396),expectation_calls = list(expect_true(any(mask_selected), info = sprintf(“interp.extrap.conc.dose.select[[%s]] matched at least one eventuality”, nm))), call = list(expect_true(any(mask_selected), info = sprintf(“interp.extrap.conc.dose.select[[%s]] matched at least one eventuality”, nm))), start_frame = 74, end_frame = 74, test = “interp.extrap.conc.dose handles all eventualities”), list(message = “!any(mask_selected & !is.na(eventualities$method)) isn’t true.”,
srcref = c(397, 5, 398, 105, 5, 105, 397, 398), expectation_calls = list(expect_true(!any(mask_selected & !is.na(eventualities\(method)), info = sprintf("interp.extrap.conc.dose.select[[%s]] overlapped with another method.", nm))), call = list(expect_true(!any(mask_selected & !is.na(eventualities\)method)), info = sprintf(“interp.extrap.conc.dose.select[[%s]] overlapped with another method.”, nm))), start_frame = 74, end_frame = 74, test = “interp.extrap.conc.dose handles all eventualities”), list(
message = "any(mask_selected) isn’t true.", srcref = c(395, 5, 396, 106, 5, 106, 395, 396),expectation_calls = list(expect_true(any(mask_selected), info = sprintf(“interp.extrap.conc.dose.select[[%s]] matched at least one eventuality”, nm))), call = list(expect_true(any(mask_selected), info = sprintf(“interp.extrap.conc.dose.select[[%s]] matched at least one eventuality”, nm))), start_frame = 74, end_frame = 74, test = “interp.extrap.conc.dose handles all eventualities”), list(message = “!any(mask_selected & !is.na(eventualities$method)) isn’t true.”,
srcref = c(397, 5, 398, 105, 5, 105, 397, 398), expectation_calls = list(expect_true(!any(mask_selected & !is.na(eventualities\(method)), info = sprintf("interp.extrap.conc.dose.select[[%s]] overlapped with another method.", nm))), call = list(expect_true(!any(mask_selected & !is.na(eventualities\)method)), info = sprintf(“interp.extrap.conc.dose.select[[%s]] overlapped with another method.”, nm))), start_frame = 74, end_frame = 74, test = “interp.extrap.conc.dose handles all eventualities”), list(
message = "any(mask_selected) isn’t true.", srcref = c(395, 5, 396, 106, 5, 106, 395, 396),expectation_calls = list(expect_true(any(mask_selected), info = sprintf(“interp.extrap.conc.dose.select[[%s]] matched at least one eventuality”, nm))), call = list(expect_true(any(mask_selected), info = sprintf(“interp.extrap.conc.dose.select[[%s]] matched at least one eventuality”, nm))), start_frame = 74, end_frame = 74, test = “interp.extrap.conc.dose handles all eventualities”), list(message = “!any(mask_selected & !is.na(eventualities$method)) isn’t true.”,
srcref = c(397, 5, 398, 105, 5, 105, 397, 398), expectation_calls = list(expect_true(!any(mask_selected & !is.na(eventualities\(method)), info = sprintf("interp.extrap.conc.dose.select[[%s]] overlapped with another method.", nm))), call = list(expect_true(!any(mask_selected & !is.na(eventualities\)method)), info = sprintf(“interp.extrap.conc.dose.select[[%s]] overlapped with another method.”, nm))), start_frame = 74, end_frame = 74, test = “interp.extrap.conc.dose handles all eventualities”), list(
message = "any(mask_selected) isn’t true.", srcref = c(395, 5, 396, 106, 5, 106, 395, 396),expectation_calls = list(expect_true(any(mask_selected), info = sprintf(“interp.extrap.conc.dose.select[[%s]] matched at least one eventuality”, nm))), call = list(expect_true(any(mask_selected), info = sprintf(“interp.extrap.conc.dose.select[[%s]] matched at least one eventuality”, nm))), start_frame = 74, end_frame = 74, test = “interp.extrap.conc.dose handles all eventualities”), list(message = “!any(mask_selected & !is.na(eventualities$method)) isn’t true.”,
srcref = c(397, 5, 398, 105, 5, 105, 397, 398), expectation_calls = list(expect_true(!any(mask_selected & !is.na(eventualities\(method)), info = sprintf("interp.extrap.conc.dose.select[[%s]] overlapped with another method.", nm))), call = list(expect_true(!any(mask_selected & !is.na(eventualities\)method)), info = sprintf(“interp.extrap.conc.dose.select[[%s]] overlapped with another method.”, nm))), start_frame = 74, end_frame = 74, test = “interp.extrap.conc.dose handles all eventualities”), list(
message = "any(mask_selected) isn’t true.", srcref = c(395, 5, 396, 106, 5, 106, 395, 396),expectation_calls = list(expect_true(any(mask_selected), info = sprintf(“interp.extrap.conc.dose.select[[%s]] matched at least one eventuality”, nm))), call = list(expect_true(any(mask_selected), info = sprintf(“interp.extrap.conc.dose.select[[%s]] matched at least one eventuality”, nm))), start_frame = 74, end_frame = 74, test = “interp.extrap.conc.dose handles all eventualities”), list(message = “!any(mask_selected & !is.na(eventualities$method)) isn’t true.”,
srcref = c(397, 5, 398, 105, 5, 105, 397, 398), expectation_calls = list(expect_true(!any(mask_selected & !is.na(eventualities\(method)), info = sprintf("interp.extrap.conc.dose.select[[%s]] overlapped with another method.", nm))), call = list(expect_true(!any(mask_selected & !is.na(eventualities\)method)), info = sprintf(“interp.extrap.conc.dose.select[[%s]] overlapped with another method.”, nm))), start_frame = 74, end_frame = 74, test = “interp.extrap.conc.dose handles all eventualities”), list(
message = "any(is.na(eventualities$method)) isn’t false.", srcref = c(404,3, 405, 79, 3, 79, 404, 405), expectation_calls = list(expect_false(any(is.na(eventualities\(method)), info = "interp.extrap.conc.dose.select matched all eventualities")), call = list(expect_false(any(is.na(eventualities\)method)), info = “interp.extrap.conc.dose.select matched all eventualities”)), start_frame = 74, end_frame = 74, test = “interp.extrap.conc.dose handles all eventualities”))
test-interpolate.conc.Rinterp.extrap.conc.dose26026list(list(message = "“, srcref = c(410, 3, 415, 42, 3, 42, 410, 415), expectation_calls = list(expect_error(interp.extrap.conc.dose(conc = c(0, 1, 2, 1, 0.5, 0.25), time = c(-1, 1:5), time.dose = 0, route =”foo“, duration.dose = NA, time.out = c(-1, -0.1, 0, 0.1, 7), out.after = FALSE), regexp =”route.dose must be either ‘extravascular’ or ‘intravascular’“, info =”Route must be valid")), call = list(expect_error(interp.extrap.conc.dose(conc = c(0, 1, 2, 1, 0.5, 0.25), time = c(-1, 1:5), time.dose = 0,
route = “foo”, duration.dose = NA, time.out = c(-1, -0.1, 0, 0.1, 7), out.after = FALSE), regexp = "route.dose must be either‘extravascular’ or ‘intravascular’“, info =”Route must be valid“)), start_frame = 74, end_frame = 74, test =”interp.extrap.conc.dose“), list(message =”“, srcref = c(416, 3, 421, 57, 3, 57, 416, 421), expectation_calls = list(expect_error(interp.extrap.conc.dose(conc = c(0, 1, 2, 1, 0.5, 0.25), time = c(-1, 1:5), time.dose = 0, route = c(”extravascular“,”extravascular"),
duration.dose = NA, time.out = c(-1, -0.1, 0, 0.1, 7), out.after = FALSE),regexp = "route.dose must either be a scalar or thesame length as time.dose“, info =”Route must have the correct length“)), call = list(expect_error(interp.extrap.conc.dose(conc = c(0, 1, 2, 1, 0.5, 0.25), time = c(-1, 1:5), time.dose = 0, route = c(”extravascular“,”extravascular“), duration.dose = NA, time.out = c(-1, -0.1, 0, 0.1, 7), out.after = FALSE), regexp =”route.dose must either be a scalar or the same length as time.dose",
info = "Route must have the correct length")), start_frame = 74, end_frame= 74, test = "interp.extrap.conc.dose"), list(message = "“, srcref = c(422, 3, 427, 72, 3, 72, 422, 427), expectation_calls = list(expect_error(interp.extrap.conc.dose(conc = c(0, 1, 2, 1, 0.5, 0.25), time = c(-1, 1:5), time.dose = 0, route =”extravascular“, duration.dose =”A“, time.out = c(-1, -0.1, 0, 0.1, 7), out.after = FALSE), regexp =”duration.dose must be NA or a number.“, info =”duration.dose must be NA or a number (character).")),
call = list(expect_error(interp.extrap.conc.dose(conc = c(0, 1, 2, 1, 0.5,0.25), time = c(-1, 1:5), time.dose = 0, route = "extravascular“, duration.dose =”A“, time.out = c(-1, -0.1, 0, 0.1, 7), out.after = FALSE), regexp =”duration.dose must be NA or a number.“, info =”duration.dose must be NA or a number (character).“)), start_frame = 74, end_frame = 74, test =”interp.extrap.conc.dose“), list(message =”", srcref = c(428, 3, 433, 69, 3, 69, 428, 433), expectation_calls = list(expect_error(interp.extrap.conc.dose(conc = c(0,
1, 2, 1, 0.5, 0.25), time = c(-1, 1:5), time.dose = 0, route = "extravascular", duration.dose = factor(“A”), time.out= c(-1,-0.1, 0, 0.1, 7), out.after = FALSE), regexp = “duration.dose must be NA or a number.”, info = “duration.dose must be NA or a number (factor).”)), call = list(expect_error(interp.extrap.conc.dose(conc = c(0, 1, 2, 1, 0.5, 0.25), time = c(-1, 1:5), time.dose = 0, route = “extravascular”, duration.dose = factor(“A”), time.out = c(-1, -0.1, 0, 0.1, 7), out.after = FALSE),
regexp = "duration.dose must be NA or a number.“, info =”duration.dose must be NA or a number (factor).")), start_frame = 74,end_frame = 74, test = “interp.extrap.conc.dose”), list(message = "“, srcref = c(434, 3, 439, 87, 3, 87, 434, 439), expectation_calls = list(expect_error(interp.extrap.conc.dose(conc = c(0, 1, 2, 1, 0.5, 0.25), time = c(-1, 1:5), time.dose = 0, route =”extravascular“, duration.dose = c(1, NA), time.out = c(-1, -0.1, 0, 0.1, 7), out.after = FALSE), regexp =”duration.dose must either be a scalar or the same length as time.dose",
info = "duration.dosemust match the length of time.dose or be a scalar.")), call = list(expect_error(interp.extrap.conc.dose(conc = c(0, 1, 2, 1, 0.5, 0.25), time = c(-1, 1:5), time.dose = 0, route = “extravascular”, duration.dose = c(1, NA), time.out = c(-1, -0.1, 0, 0.1, 7), out.after = FALSE), regexp = “duration.dose must either be a scalar or the same length as time.dose”, info = “duration.dose must match the length of time.dose or be a scalar.”)), start_frame = 74, end_frame = 74, test = “interp.extrap.conc.dose”),
list(message = "interp.extrap.conc.dose(…) not equal to interp.extrap.conc.dose(…).al", srcref = c(441, 3, 450, 41, 3, 41, 441, 450), expectation_calls = list(expect_equal(interp.extrap.conc.dose(conc = c(0, 1, 2, 1, 0.5, 0.25), time = c(-1, 1:5), time.dose = 0, time.out = -2, check = FALSE), interp.extrap.conc.dose(conc = c(0, 1, 2, 1, 0.5, 0.25), time = c(-1, 1:5), time.dose = 0, time.out = -2), info = “Check is respected”)), call = list(expect_equal(interp.extrap.conc.dose(conc = c(0,
1, 2, 1, 0.5, 0.25), time = c(-1, 1:5), time.dose = 0, time.out = -2,check = FALSE), interp.extrap.conc.dose(conc = c(0,1, 2, 1, 0.5, 0.25), time = c(-1, 1:5), time.dose = 0, time.out = -2), info = “Check is respected”)), start_frame = 74, end_frame = 74, test = “interp.extrap.conc.dose”), list(message = “interp.extrap.conc.dose(…) not equal to structure(0, Method = "Before all events").”, srcref = c(452, 3, 457, 97, 3, 97, 452, 457), expectation_calls = list(expect_equal(interp.extrap.conc.dose(conc = c(0,
1, 2, 1, 0.5, 0.25), time = c(-1, 1:5), time.dose = 0, time.out = -2),structure(0, Method = “Before all events”), info =“Interpolation before all events yields conc.origin which defaults to zero.”)), call = list(expect_equal(interp.extrap.conc.dose(conc = c(0, 1, 2, 1, 0.5, 0.25), time = c(-1, 1:5), time.dose = 0, time.out = -2), structure(0, Method = “Before all events”), info = “Interpolation before all events yields conc.origin which defaults to zero.”)), start_frame = 74, end_frame = 74,
test = "interp.extrap.conc.dose“), list(message =”interp.extrap.conc.dose(…) not equal to structure(NA_real_,Method ="Before all events").“, srcref = c(459, 3, 465, 95, 3, 95, 459, 465), expectation_calls = list(expect_equal(interp.extrap.conc.dose(conc = c(0, 1, 2, 1, 0.5, 0.25), time = c(-1, 1:5), time.dose = 0, conc.origin = NA, time.out = -2), structure(NA, Method =”Before all events“), info =”Interpolation before all events yields conc.origin respecting its input.")),
call = list(expect_equal(interp.extrap.conc.dose(conc = c(0, 1, 2, 1,0.5, 0.25), time =c(-1, 1:5), time.dose =0, conc.origin = NA, time.out = -2), structure(NA, Method = “Before all events”), info = “Interpolation before all events yields conc.origin respecting its input.”)), start_frame = 74, end_frame = 74, test = “interp.extrap.conc.dose”), list(message = “interp.extrap.conc.dose(…) not equal to structure(0, Method = "Observed concentration").”, srcref = c(467, 3, 472, 97,
3, 97, 467, 472), expectation_calls = list(expect_equal(interp.extrap.conc.dose(conc = c(0,1, 2, 1, 0.5, 0.25), time= c(-1,1:5), time.dose = 0, time.out = -1), structure(0, Method = “Observed concentration”), info = “When there is a concentration measurement at a time point, it is returned.”)), call = list(expect_equal(interp.extrap.conc.dose(conc = c(0, 1, 2, 1, 0.5, 0.25), time = c(-1, 1:5), time.dose = 0, time.out = -1), structure(0, Method = “Observed concentration”), info = “When there is a concentration measurement at a time point, it is returned.”)),
start_frame = 74,end_frame = 74, test = “interp.extrap.conc.dose”), list(message = "interp.extrap.conc.dose(…)not equal to structure(0, Method = "Extrapolation").“, srcref = c(474, 3, 479, 106, 3, 106, 474, 479), expectation_calls = list(expect_equal(interp.extrap.conc.dose(conc = c(0, 1, 2, 1, 0.5, 0.25), time = c(-1, 1:5), time.dose = 0, time.out = -0.1), structure(0, Method =”Extrapolation“), info =”When the previous measurement is zero and there is no dose between, it is returned.")),
call = list(expect_equal(interp.extrap.conc.dose(conc = c(0, 1, 2, 1,0.5, 0.25), time =c(-1, 1:5), time.dose =0, time.out = -0.1), structure(0, Method = “Extrapolation”), info = “When the previous measurement is zero and there is no dose between, it is returned.”)), start_frame = 74, end_frame = 74, test = “interp.extrap.conc.dose”), list(message = “interp.extrap.conc.dose(…) not equal to structure(0, Method = "Extrapolation").”, srcref = c(481, 3, 486, 109, 3, 109, 481, 486
), expectation_calls =list(expect_equal(interp.extrap.conc.dose(conc = c(0, 1, 2, 1, 0.5, 0.25), time = c(-1, 1:5),time.dose= 0, time.out = 0), structure(0, Method = “Extrapolation”), info = “When the previous measurement is zero it is at the time of the dose, zero is returned.”)), call = list(expect_equal(interp.extrap.conc.dose(conc = c(0, 1, 2, 1, 0.5, 0.25), time = c(-1, 1:5), time.dose = 0, time.out = 0), structure(0, Method = “Extrapolation”), info = “When the previous measurement is zero it is at the time of the dose, zero is returned.”)),
start_frame = 74,end_frame = 74, test = “interp.extrap.conc.dose”), list(message = "interp.extrap.conc.dose(…)not equal to structure(0.1, Method = "Dose before, concentration after without a dose").“, srcref = c(488, 3, 493, 107, 3, 107, 488, 493), expectation_calls = list(expect_equal(interp.extrap.conc.dose(conc = c(0, 1, 2, 1, 0.5, 0.25), time = c(-1, 1:5), time.dose = 0, time.out = 0.1), structure(0.1, Method =”Dose before, concentration after without a dose“), info =”Extrapolation to a dose then interpolation between the dose and the next time works.")),
call = list(expect_equal(interp.extrap.conc.dose(conc = c(0, 1, 2, 1,0.5, 0.25), time =c(-1, 1:5), time.dose =0, time.out = 0.1), structure(0.1, Method = “Dose before, concentration after without a dose”), info = “Extrapolation to a dose then interpolation between the dose and the next time works.”)), start_frame = 74, end_frame = 74, test = “interp.extrap.conc.dose”), list(message = "", srcref = c(495, 3, 502, 63, 3, 63, 495, 502), expectation_calls = list(expect_warning(r_double_dose <- interp.extrap.conc.dose(conc = c(0,
1, 2, 1, 0.5, 0.25), time = c(-1, 1:5), time.dose = c(0, 0.1), time.out = 0.2), regexp ="Cannot interpolate between two doses or after a dose without a concentration after the first dose.“, fixed = TRUE, info =”Two doses in a row generates a warning“)), call = list(expect_warning(r_double_dose <- interp.extrap.conc.dose(conc = c(0, 1, 2, 1, 0.5, 0.25), time = c(-1, 1:5), time.dose = c(0, 0.1), time.out = 0.2), regexp =”Cannot interpolate between two doses or after a dose without a concentration after the first dose.",
fixed = TRUE, info= “Two doses in a row generates a warning”)), start_frame = 74, end_frame = 74, test = "interp.extrap.conc.dose“), list(message =”r_double_dose not equal to structure(NA_real_, Method = "Dose before, concentration after without a dose").“, srcref = c(504, 3, 506, 130, 3, 130, 504, 506), expectation_calls = list(expect_equal(r_double_dose, structure(NA, Method =”Dose before, concentration after without a dose“), info =”Extrapolation to a dose then interpolation between the dose and the next time gives NA when the dose is NA.")),
call = list(expect_equal(r_double_dose, structure(NA, Method = "Dose before, concentration after without a dose"), info =“Extrapolation to a dose then interpolation between the dose and the next time gives NA when the dose is NA.”)), start_frame = 74, end_frame = 74, test = “interp.extrap.conc.dose”), list(message = “interp.extrap.conc.dose(…) not equal to structure(0.25, Method = "Observed concentration").”, srcref = c(508, 3, 513, 48, 3, 48, 508, 513), expectation_calls = list(
expect_equal(interp.extrap.conc.dose(conc = c(0, 1, 2, 1, 0.5, 0.25),time = c(-1, 1:5),time.dose = 0, time.out= 5), structure(0.25, Method = “Observed concentration”), info = “Copy from after the dose.”)), call = list(expect_equal(interp.extrap.conc.dose(conc = c(0, 1, 2, 1, 0.5, 0.25), time = c(-1, 1:5), time.dose = 0, time.out = 5), structure(0.25, Method = “Observed concentration”), info = “Copy from after the dose.”)), start_frame = 74, end_frame = 74, test = “interp.extrap.conc.dose”),
list(message = "interp.extrap.conc.dose(…) not equal to structure(NA_real_, Method = "Extrapolation").", srcref = c(515, 3, 520, 69, 3, 69, 515, 520), expectation_calls = list(expect_equal(interp.extrap.conc.dose(conc = c(0, 1, 2, 1, 0.5, 0.25), time = c(-1, 1:5), time.dose = 0, time.out = 7), structure(NA, Method = “Extrapolation”), info = “Extrapolation without lambda.z gives NA result”)), call = list(expect_equal(interp.extrap.conc.dose(conc = c(0, 1, 2, 1, 0.5, 0.25), time = c(-1,
1:5), time.dose =0, time.out = 7), structure(NA, Method = "Extrapolation“), info =”Extrapolation without lambda.z givesNA result“)), start_frame = 74, end_frame = 74, test =”interp.extrap.conc.dose“), list(message =”interp.extrap.conc.dose(…) not equal to structure(0.0625, Method = "Extrapolation").", srcref = c(522, 3, 528, 63, 3, 63, 522, 528), expectation_calls = list(expect_equal(interp.extrap.conc.dose(conc = c(0, 1, 2, 1, 0.5, 0.25), time = c(-1, 1:5), time.dose = 0,
time.out = 7, lambda.z = log(2)), structure(0.0625, Method = "Extrapolation“), info =”Extrapolation with lambda.z gives result“)), call = list(expect_equal(interp.extrap.conc.dose(conc = c(0, 1, 2, 1, 0.5, 0.25), time = c(-1, 1:5), time.dose = 0, time.out = 7, lambda.z = log(2)), structure(0.0625, Method =”Extrapolation“), info =”Extrapolation with lambda.z gives result“)), start_frame = 74, end_frame = 74, test =”interp.extrap.conc.dose“), list(message =”interp.extrap.conc.dose(…) not equal to structure(0.5, Method = "Interpolation").",
srcref = c(530, 3,535, 42, 3, 42, 530, 535), expectation_calls = list(expect_equal(interp.extrap.conc.dose(conc= 0:2, time = 0:2, time.dose = 0, time.out = 0.5), structure(0.5, Method = “Interpolation”), info = “Interpolation works”)), call = list(expect_equal(interp.extrap.conc.dose(conc = 0:2, time = 0:2, time.dose = 0, time.out = 0.5), structure(0.5, Method = “Interpolation”), info = “Interpolation works”)), start_frame = 74, end_frame = 74, test = “interp.extrap.conc.dose”), list(message = “interp.extrap.conc.dose(…) not equal to structure(sqrt(2), Method = "Interpolation").”,
srcref = c(537, 3,543, 52, 3, 52, 537, 543), expectation_calls = list(expect_equal(interp.extrap.conc.dose(conc= c(0:2,1), time = 0:3, time.dose = 0, time.out = 2.5, method = “linear”), structure(sqrt(2), Method = “Interpolation”), info = “Interpolation respects method”)), call = list(expect_equal(interp.extrap.conc.dose(conc = c(0:2, 1), time = 0:3, time.dose = 0, time.out = 2.5, method = “linear”), structure(sqrt(2), Method = “Interpolation”), info = “Interpolation respects method”)),
start_frame = 74,end_frame = 74, test = “interp.extrap.conc.dose”), list(message = "interp.extrap.conc.dose(…)not equal to structure(0, Method = "Observed concentration").“, srcref = c(545, 3, 553, 47, 3, 47, 545, 553), expectation_calls = list(expect_equal(interp.extrap.conc.dose(conc = 0:2, time = 0:2, time.dose = 0, route.dose =”intravascular“, time.out = 0, duration.dose = 0, out.after = FALSE), structure(0, Method =”Observed concentration“), info =”Observed before IV bolus")),
call = list(expect_equal(interp.extrap.conc.dose(conc = 0:2, time = 0:2, time.dose = 0,route.dose = "intravascular", time.out = 0, duration.dose = 0, out.after = FALSE), structure(0, Method = “Observed concentration”), info = “Observed before IV bolus”)), start_frame = 74, end_frame = 74, test = “interp.extrap.conc.dose”), list(message = “interp.extrap.conc.dose(…) not equal to structure(1, Method = "Immediately after an IV bolus with a concentration next").”, srcref = c(555,
3, 563, 65, 3, 65, 555, 563), expectation_calls = list(expect_equal(interp.extrap.conc.dose(conc = 0:2, time = 0:2, time.dose= 0, route.dose = “intravascular”, time.out = 0, duration.dose = 0, out.after = TRUE), structure(1, Method = “Immediately after an IV bolus with a concentration next”), info = “Observed after IV bolus, one concentration”)), call = list(expect_equal(interp.extrap.conc.dose(conc = 0:2, time = 0:2, time.dose = 0, route.dose = “intravascular”, time.out = 0, duration.dose = 0,
out.after = TRUE),structure(1, Method = "Immediately after an IV bolus with a concentration next“), info =”Observed after IV bolus, one concentration“)), start_frame = 74, end_frame = 74, test =”interp.extrap.conc.dose“), list(message =”interp.extrap.conc.dose(…) not equal to structure(4, Method = "Immediately after an IV bolus with a concentration next").", srcref = c(565, 3, 573, 66, 3, 66, 565, 573), expectation_calls = list(expect_equal(interp.extrap.conc.dose(conc = c(0,
2, 1), time = 0:2,time.dose = 0, route.dose = “intravascular”, time.out = 0, duration.dose = 0, out.after = TRUE), structure(4, Method = “Immediately after an IV bolus with a concentration next”), info = “Observed after IV bolus, two concentrations”)), call = list(expect_equal(interp.extrap.conc.dose(conc = c(0, 2, 1), time = 0:2, time.dose = 0, route.dose = “intravascular”, time.out = 0, duration.dose = 0, out.after = TRUE), structure(4, Method = “Immediately after an IV bolus with a concentration next”),
info = "Observed after IV bolus, two concentrations")), start_frame =74, end_frame = 74, test = "interp.extrap.conc.dose"), list(message = “interp.extrap.conc.dose(…) not equal to structure(2 * sqrt(2), Method = "After an IV bolus with a concentration next").”, srcref = c(575, 3, 582, 57, 3, 57, 575, 582), expectation_calls = list(expect_equal(interp.extrap.conc.dose(conc = c(2, 1), time = 1:2, time.dose = 0, route.dose = “intravascular”, time.out = 0.5, duration.dose = 0), structure(2 *
sqrt(2), Method =“After an IV bolus with a concentration next”), info= "After IV bolus, two concentrations")),call = list(expect_equal(interp.extrap.conc.dose(conc = c(2, 1), time = 1:2, time.dose = 0, route.dose = “intravascular”, time.out = 0.5, duration.dose = 0), structure(2 * sqrt(2), Method = “After an IV bolus with a concentration next”), info = “After IV bolus, two concentrations”)), start_frame = 74, end_frame = 74, test = “interp.extrap.conc.dose”), list(message = “interp.extrap.conc.dose(…) not equal to structure(2, Method = "After an IV bolus with a concentration next").”,
srcref = c(584, 3,591, 56, 3, 56, 584, 591), expectation_calls = list(expect_equal(interp.extrap.conc.dose(conc= 2, time= 1, time.dose = 0, route.dose = “intravascular”, time.out = 0.5, duration.dose = 0), structure(2, Method = “After an IV bolus with a concentration next”), info = “After IV bolus, one concentration”)), call = list(expect_equal(interp.extrap.conc.dose(conc = 2, time = 1, time.dose = 0, route.dose = “intravascular”, time.out = 0.5, duration.dose = 0), structure(2, Method = “After an IV bolus with a concentration next”),
info = "AfterIV bolus, one concentration")), start_frame = 74, end_frame = 74, test= "interp.extrap.conc.dose"), list(message = “interp.extrap.conc.dose(…) not equal to structure(c(0, 2), Method = c("Before all events", "Observed concentration")).”, srcref = c(593, 3, 599, 81, 3, 81, 593, 599), expectation_calls = list(expect_equal(interp.extrap.conc.dose(conc = c(0, 1, 2, 1, 0.5, 0.25), time = c(-1, 1:5), time.dose = 0, time.out = c(-2, 2)), structure(c(0, 2), Method = c(“Before all events”,
"Observed concentration“)), info =”Outputs are in the same order as inputs (initially sorted)")), call = list(expect_equal(interp.extrap.conc.dose(conc = c(0, 1, 2, 1, 0.5, 0.25), time = c(-1, 1:5), time.dose = 0, time.out = c(-2, 2)), structure(c(0, 2), Method = c(“Before all events”, “Observed concentration”)), info = “Outputs are in the same order as inputs (initially sorted)”)), start_frame = 74, end_frame = 74, test = “interp.extrap.conc.dose”), list(message = “interp.extrap.conc.dose(…) not equal to structure(c(2, 0), Method = c("Observed concentration", "Before all events")).”,
srcref = c(601, 3,607, 88, 3, 88, 601, 607), expectation_calls = list(expect_equal(interp.extrap.conc.dose(conc= c(0, 1,2, 1, 0.5, 0.25), time = c(-1, 1:5), time.dose = 0, time.out = c(2, -2)), structure(c(2, 0), Method = c(“Observed concentration”, “Before all events”)), info = “Outputs are in the same order as inputs (reverse sorted time.out)”)), call = list(expect_equal(interp.extrap.conc.dose(conc = c(0, 1, 2, 1, 0.5, 0.25), time = c(-1, 1:5), time.dose = 0, time.out = c(2, -2)), structure(c(2,
0), Method = c(“Observed concentration”, “Before all events”)), info = "Outputs arein the same order as inputs (reverse sorted time.out)“)), start_frame = 74, end_frame = 74, test =”interp.extrap.conc.dose"))

+

+

+
merging lists

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Testing FilenameTest DescriptionNumber of TestsNumber of Failed Testspassedresult
test-merge.Rmerge.splitlist808list(list(message = “merge.splitlist(d1a, d1b) not equal to r1.”, srcref = c(12, 3, 13, 66, 3, 66, 12, 13), expectation_calls = list(expect_equal(merge.splitlist(d1a, d1b), r1, info = “merging splitlists in the simple form works”)), call = list(expect_equal(merge.splitlist(d1a, d1b), r1, info = “merging splitlists in the simple form works”)), start_frame = 74, end_frame = 74, test = “merge.splitlist”), list(message = "", srcref = c(15, 3, 17, 61, 3, 61, 15, 17), expectation_calls = list(expect_error(merge.splitlist(d1a),
regexp = "At least two lists mustbe given", info ="merging splitlists requires >=2 inputs“)), call = list(expect_error(merge.splitlist(d1a), regexp =”At least two lists must be given“, info =”merging splitlists requires >=2 inputs“)), start_frame = 74, end_frame = 74, test =”merge.splitlist“), list(message =”“, srcref = c(19, 3, 21, 62, 3, 62, 19, 21), expectation_calls = list(expect_error(merge.splitlist(d1a, 1), regexp =”All arguments must be lists“, info =”merging splitlists requires list inputs")),
call = list(expect_error(merge.splitlist(d1a, 1), regexp = "All arguments must be lists“, info =”merging splitlists requires list inputs“)), start_frame = 74, end_frame = 74, test =”merge.splitlist“), list(message =”“, srcref = c(24, 3, 26, 58, 3, 58, 24, 26), expectation_calls = list(expect_error(merge.splitlist(d1a, d2), regexp =”All arguments must have a ‘groupid’ attribute“, info =”merging splitlists requires groupid“)), call = list(expect_error(merge.splitlist(d1a, d2), regexp =”All arguments must have a ‘groupid’ attribute",
info = "mergingsplitlists requires groupid")), start_frame = 74, end_frame =74, test= “merge.splitlist”), list(message = "“, srcref = c(28, 3, 30, 80, 3, 80, 28, 30), expectation_calls = list(expect_error(merge.splitlist(d1a, d2), regexp =”The number of rows in the ‘groupid’ attribute must match the length of the list.“, info =”merging splitlists requires groupid that matches the list“)), call = list(expect_error(merge.splitlist(d1a, d2), regexp =”The number of rows in the ‘groupid’ attribute must match the length of the list.",
info = "mergingsplitlists requires groupid that matches the list")), start_frame = 74, end_frame = 74, test = “merge.splitlist”), list(message = “merge.splitlist(d3a, d3b) not equal to r3.”, srcref = c(45, 3, 46, 71, 3, 71, 45, 46), expectation_calls = list(expect_equal(merge.splitlist(d3a, d3b), r3, info = “Missing values give a NULL output (second value)”)), call = list(expect_equal(merge.splitlist(d3a, d3b), r3, info = “Missing values give a NULL output (second value)”)), start_frame = 74,
end_frame = 74,test = "merge.splitlist"), list(message = "merge.splitlist(d3b, d3a) not equal to r4.“, srcref = c(47, 3, 48, 70, 3, 70, 47, 48), expectation_calls = list(expect_equal(merge.splitlist(d3b, d3a), r4, info =”Missing values give a NULL output (first value)“)), call = list(expect_equal(merge.splitlist(d3b, d3a), r4, info =”Missing values give a NULL output (first value)“)), start_frame = 74, end_frame = 74, test =”merge.splitlist“), list(message =”merge.splitlist(D = d3a, E = d3b) not equal to r5.",
srcref = c(53,3, 54, 42, 3, 42, 53, 54), expectation_calls = list(expect_equal(merge.splitlist(D = d3a, E = d3b), r5, info = “Names are preserved”)), call = list(expect_equal(merge.splitlist(D = d3a, E = d3b), r5, info = “Names are preserved”)), start_frame = 74, end_frame = 74, test = “merge.splitlist”))

+

+

+
Formula parsing

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Testing FilenameTest DescriptionNumber of TestsNumber of Failed Testspassedresult
test-parseFormula.RparseFormula14014list(list(message = “parseFormula(f1) not equal to r1.”, srcref = c(14, 3, 16, 38, 3, 38, 14, 16), expectation_calls = list(expect_equal(parseFormula(f1), r1, check.attributes = FALSE)), call = list(expect_equal(parseFormula(f1), r1, check.attributes = FALSE)), start_frame = 74, end_frame = 74, test = “parseFormula”), list(message = “parseFormula(f2) not equal to r2.”, srcref = c(26, 3, 28, 38, 3, 38, 26, 28), expectation_calls = list(expect_equal(parseFormula(f2), r2, check.attributes = FALSE)),
call = list(expect_equal(parseFormula(f2), r2, check.attributes = FALSE)), start_frame = 74,end_frame = 74, test = “parseFormula”), list(message = “parseFormula(f3) not equal to r3.”, srcref = c(38, 3, 40, 38, 3, 38, 38, 40), expectation_calls = list(expect_equal(parseFormula(f3), r3, check.attributes = FALSE)), call = list(expect_equal(parseFormula(f3), r3, check.attributes = FALSE)), start_frame = 74, end_frame = 74, test = “parseFormula”), list(message = “parseFormula(f4) not equal to r4.”,
srcref = c(50, 3,52, 38, 3, 38, 50, 52),expectation_calls= list(expect_equal(parseFormula(f4), r4, check.attributes = FALSE)), call = list(expect_equal(parseFormula(f4), r4, check.attributes = FALSE)), start_frame = 74, end_frame = 74, test = “parseFormula”), list(message = “parseFormula(f5) not equal to r5.”, srcref = c(62, 3, 64, 38, 3, 38, 62, 64), expectation_calls = list(expect_equal(parseFormula(f5), r5, check.attributes = FALSE)), call = list(expect_equal(parseFormula(f5), r5,
check.attributes =FALSE)), start_frame =74, end_frame = 74, test = “parseFormula”), list(message = “parseFormula(f6) not equal to r6.”, srcref = c(76, 3, 78, 38, 3, 38, 76, 78), expectation_calls = list(expect_equal(parseFormula(f6), r6, check.attributes = FALSE)), call = list(expect_equal(parseFormula(f6), r6, check.attributes = FALSE)), start_frame = 74, end_frame = 74, test = “parseFormula”), list(message = “parseFormula(f7) not equal to r7.”, srcref = c(90, 3, 92, 38, 3,
38, 90, 92), expectation_calls = list(expect_equal(parseFormula(f7), r7, check.attributes = FALSE)), call = list(expect_equal(parseFormula(f7), r7, check.attributes = FALSE)), start_frame = 74, end_frame = 74, test = “parseFormula”), list(message = “{…} not equal to r8.”, srcref = c(102, 3, 106, 38, 3, 38, 102, 106), expectation_calls = list(expect_equal({
t1 <- parseFormula(f8)
t1$env <- NULL
t1
}, r8, check.attributes = FALSE)), call = list(expect_equal({
t1 <- parseFormula(f8)
t1$env <- NULL
t1
}, r8, check.attributes = FALSE)), start_frame = 74, end_frame= 74, test = "parseFormula"), list(message = "“, srcref = c(109, 3, 110, 76, 3, 76, 109, 110), expectation_calls = list(expect_error(parseFormula(5), regexp =”form must be a formula object or coercable into one“)), call = list(expect_error(parseFormula(5), regexp =”form must be a formula object or coercable into one“)), start_frame = 74, end_frame = 74, test =”parseFormula“), list(message =”parseFormula(f7, require.groups = TRUE) not equal to r7.",
srcref = c(113, 3,115, 38, 3, 38, 113, 115), expectation_calls = list(expect_equal(parseFormula(f7, require.groups = TRUE), r7, check.attributes = FALSE)), call = list(expect_equal(parseFormula(f7, require.groups = TRUE), r7, check.attributes = FALSE)), start_frame = 74, end_frame = 74, test = “parseFormula”), list(message = “parseFormula(f7, require.two.sided = TRUE) not equal to r7.”, srcref = c(116, 3, 118, 38, 3, 38, 116, 118), expectation_calls = list(expect_equal(parseFormula(f7,
require.two.sided= TRUE), r7, check.attributes = FALSE)),call = list(expect_equal(parseFormula(f7, require.two.sided = TRUE), r7, check.attributes = FALSE)), start_frame = 74, end_frame = 74, test = “parseFormula”), list(message = “parseFormula(f7, require.groups = TRUE, require.two.sided = TRUE) not equal to r7.”, srcref = c(119, 3, 123, 38, 3, 38, 119, 123), expectation_calls = list(expect_equal(parseFormula(f7, require.groups = TRUE, require.two.sided = TRUE), r7, check.attributes = FALSE)),
call = list(expect_equal(parseFormula(f7,require.groups =TRUE, require.two.sided =TRUE), r7, check.attributes = FALSE)), start_frame = 74, end_frame = 74, test = “parseFormula”), list(message = "“, srcref = c(124, 3, 125, 72, 3, 72, 124, 125), expectation_calls = list(expect_error(parseFormula(f2, require.groups = TRUE), regex =”rhs of formula must be a conditioning expression“)), call = list(expect_error(parseFormula(f2, require.groups = TRUE), regex =”rhs of formula must be a conditioning expression")),
start_frame = 74,end_frame = 74, test =“parseFormula”), list(message = "", srcref= c(126,3, 127, 79, 3, 79, 126, 127), expectation_calls = list(expect_error(parseFormula(f1, require.two.sided = TRUE), regex = “formula is one-sided with require.two.sided set to TRUE”)), call = list(expect_error(parseFormula(f1, require.two.sided = TRUE), regex = “formula is one-sided with require.two.sided set to TRUE”)), start_frame = 74, end_frame = 74, test = “parseFormula”))
test-parseFormula.Rformula.parseFormula11011list(list(message = “formula(parseFormula(f1)) not equal to f1.”, srcref = c(133, 3, 133, 45, 3, 45, 133, 133), expectation_calls = list(expect_equal(formula(parseFormula(f1)), f1)), call = list(expect_equal(formula(parseFormula(f1)), f1)), start_frame = 74, end_frame = 74, test = “formula.parseFormula”), list(message = “formula(parseFormula(f2)) not equal to f2.”, srcref = c(135, 3, 135, 45, 3, 45, 135, 135), expectation_calls = list(expect_equal(formula(parseFormula(f2)), f2)),
call = list(expect_equal(formula(parseFormula(f2)), f2)), start_frame = 74, end_frame = 74, test = “formula.parseFormula”), list(message = “formula(parseFormula(f3)) not equal to f3.”, srcref = c(137, 3, 137, 45, 3, 45, 137, 137), expectation_calls = list(expect_equal(formula(parseFormula(f3)), f3)), call = list(expect_equal(formula(parseFormula(f3)), f3)), start_frame = 74, end_frame = 74, test = “formula.parseFormula”), list(message = “formula(parseFormula(f4)) not equal to f4.”,
srcref = c(139, 3,139, 45, 3, 45, 139, 139), expectation_calls = list(expect_equal(formula(parseFormula(f4)), f4)), call = list(expect_equal(formula(parseFormula(f4)), f4)), start_frame = 74, end_frame = 74, test = “formula.parseFormula”), list(message = “formula(parseFormula(f5)) not equal to f5.”, srcref = c(141, 3, 141, 45, 3, 45, 141, 141), expectation_calls = list(expect_equal(formula(parseFormula(f5)), f5)), call = list(expect_equal(formula(parseFormula(f5)), f5)), start_frame = 74,
end_frame = 74, test = "formula.parseFormula"), list(message = "formula(parseFormula(f6)) notequal to f6.“, srcref = c(143, 3, 143, 45, 3, 45, 143, 143), expectation_calls = list(expect_equal(formula(parseFormula(f6)), f6)), call = list(expect_equal(formula(parseFormula(f6)), f6)), start_frame = 74, end_frame = 74, test =”formula.parseFormula“), list(message =”formula(parseFormula(f7)) not equal to f7.", srcref = c(145, 3, 145, 45, 3, 45, 145, 145), expectation_calls = list(
expect_equal(formula(parseFormula(f7)), f7)), call = list(expect_equal(formula(parseFormula(f7)), f7)), start_frame = 74, end_frame = 74, test = “formula.parseFormula”), list(message = “formula(parseFormula(f7), drop.lhs = TRUE) not equal to r7rhs.”, srcref = c(149, 3, 150, 21, 3, 21, 149, 150), expectation_calls = list(expect_equal(formula(parseFormula(f7), drop.lhs = TRUE), r7rhs)), call = list(expect_equal(formula(parseFormula(f7), drop.lhs = TRUE), r7rhs)), start_frame = 74, end_frame = 74,
test = "formula.parseFormula"), list(message = "formula(parseFormula(f7), drop.groups = TRUE)not equal to r7g.“, srcref = c(152, 3, 153, 19, 3, 19, 152, 153), expectation_calls = list(expect_equal(formula(parseFormula(f7), drop.groups = TRUE), r7g)), call = list(expect_equal(formula(parseFormula(f7), drop.groups = TRUE), r7g)), start_frame = 74, end_frame = 74, test =”formula.parseFormula“), list(message =”formula(parseFormula(f7), drop.lhs = TRUE, drop.groups = TRUE) not equal to r7rhsg.",
srcref = c(155, 3,158, 22, 3, 22, 155, 158), expectation_calls = list(expect_equal(formula(parseFormula(f7), drop.lhs = TRUE, drop.groups = TRUE), r7rhsg)), call = list(expect_equal(formula(parseFormula(f7), drop.lhs = TRUE, drop.groups = TRUE), r7rhsg)), start_frame = 74, end_frame = 74, test = “formula.parseFormula”), list(message = “identical(formula(parseFormula("~a")), f1) isn’t false.”, srcref = c(161, 3, 161, 58, 3, 58, 161, 161), expectation_calls = list(expect_false(identical(formula(parseFormula(“~a”)),
f1))), call = list(expect_false(identical(formula(parseFormula(“~a”)), f1))), start_frame = 74, end_frame = 74, test = “formula.parseFormula”))
test-parseFormula.Rprint.parseFormula404list(list(message = “print\\(parseFormula\\(\"~a\"\\)\\) does not match "A one-sided formula without groups[. \n]+~a".value: "A one-sided formula without groups\.\\n ~a "”, srcref = c(165, 3, 166, 69, 3, 69, 165, 166), expectation_calls = list(expect_output(print(parseFormula(“~a”)), regexp = “A one-sided formula without groups[. ]+~a”), expect_match(act\(cap, enc2native(regexp), ..., info = info, label = act\)lab)), call = list(expect_output(print(parseFormula(“~a”)), regexp = “A one-sided formula without groups[. ]+~a”),
expect_match(act$cap, enc2native(regexp),…, info = info,label = act$lab)), start_frame =74, end_frame = 75, test = “print.parseFormula”), list(message = “print\\(parseFormula\\(\"~a\\|b\"\\)\\) does not match "A one-sided formula with groups[. \n]+~a \\| b".value: "A one-sided formula with groups\.\\n ~a \| b "”, srcref = c(167, 3, 168, 72, 3, 72, 167, 168), expectation_calls = list(expect_output(print(parseFormula(“~a|b”)), regexp = “A one-sided formula with groups[. ]+~a \| b”),
expect_match(act$cap, enc2native(regexp),…, info = info,label = act$lab)), call= list(expect_output(print(parseFormula(“~a|b”)), regexp = “A one-sided formula with groups[. ]+~a \| b”), expect_match(act\(cap, enc2native(regexp), ..., info = info, label = act\)lab)), start_frame = 74, end_frame = 75, test = “print.parseFormula”), list(message = “print\\(parseFormula\\(\"a~b\"\\)\\) does not match "A two-sided formula without groups[. \n]+a ~ b".value: "A two-sided formula without groups\.\\n a ~ b "”,
srcref = c(169, 3,170, 72, 3, 72, 169, 170), expectation_calls = list(expect_output(print(parseFormula(“a~b”)), regexp = “A two-sided formula without groups[. ]+a ~ b”), expect_match(act\(cap, enc2native(regexp), ..., info = info, label = act\)lab)), call = list(expect_output(print(parseFormula(“a~b”)), regexp = “A two-sided formula without groups[. ]+a ~ b”), expect_match(act\(cap, enc2native(regexp), ..., info = info, label = act\)lab)), start_frame = 74, end_frame = 75, test = “print.parseFormula”),
list(message = "`print\(parseFormula\(\"a~b\|c"\)\)`does not match "A two-sided formula with groups[. \n]+a ~ b \\| c".value: "A two-sided formula with groups\.\\n a ~ b \| c "“, srcref = c(171, 3, 172, 75, 3, 75, 171, 172), expectation_calls = list(expect_output(print(parseFormula(”a~b|c“)), regexp =”A two-sided formula with groups[. ]+a ~ b \| c“), expect_match(act\(cap, enc2native(regexp), ..., info = info, label = act\)lab)), call = list(expect_output(print(parseFormula(”a~b|c")),
regexp = "A two-sided formula with groups[. ]+a ~ b \| c"), expect_match(act$cap, enc2native(regexp), …, info = info, label = act$lab)), start_frame = 74, end_frame = 75, test = “print.parseFormula”))
test-parseFormula.RfindOperator31031list(list(message = “findOperator(f1, "~", "both") not equal to f1.”, srcref = c(178, 3, 178, 49, 3, 49, 178, 178), expectation_calls = list(expect_equal(findOperator(f1, “~”, “both”), f1)), call = list(expect_equal(findOperator(f1, “~”, “both”), f1)), start_frame = 74, end_frame = 74, test = “findOperator”), list(message = “findOperator(f1, "~", "left") not equal to as.name("a").”, srcref = c(179, 3, 179, 59, 3, 59, 179, 179), expectation_calls = list(expect_equal(findOperator(f1,
“~”, “left”), as.name(“a”))), call = list(expect_equal(findOperator(f1, “~”, “left”), as.name(“a”))), start_frame = 74, end_frame = 74, test = “findOperator”), list(message = “findOperator(f1, "~", "right") not equal to as.name("b").”, srcref = c(180, 3, 180, 60, 3, 60, 180, 180), expectation_calls = list(expect_equal(findOperator(f1, “~”, “right”), as.name(“b”))), call = list(expect_equal(findOperator(f1, “~”, “right”), as.name(“b”))), start_frame = 74, end_frame = 74, test = “findOperator”),
list(message = "findOperator(f2, "+", \"both") not equalto call("+", as.name(\"b"), as.name("c")).“, srcref = c(183, 3, 184, 53, 3, 53, 183, 184), expectation_calls = list(expect_equal(findOperator(f2,”+“,”both“), call(”+“, as.name(”b“), as.name(”c“)))), call = list(expect_equal(findOperator(f2,”+“,”both“), call(”+“, as.name(”b“), as.name(”c“)))), start_frame = 74, end_frame = 74, test =”findOperator“), list(message =”findOperator(f2, "+", "left") not equal to as.name("b").",
srcref = c(185, 3, 186, 28, 3, 28, 185, 186), expectation_calls = list(expect_equal(findOperator(f2, “+”, “left”), as.name(“b”))), call = list(expect_equal(findOperator(f2, “+”, “left”), as.name(“b”))), start_frame = 74, end_frame = 74, test = “findOperator”), list(message = “findOperator(f2, "+", "right") not equal to as.name("c").”, srcref = c(187, 3, 188, 28, 3, 28, 187, 188), expectation_calls = list(expect_equal(findOperator(f2, “+”, “right”), as.name(“c”))), call = list(
expect_equal(findOperator(f2, “+”, "right“), as.name(”c"))), start_frame = 74, end_frame= 74, test = “findOperator”), list(message = “findOperator(f3, "+", "both") not equal to call("+", as.name("a"), as.name("b")).”, srcref = c(191, 3, 192, 53, 3, 53, 191, 192), expectation_calls = list(expect_equal(findOperator(f3, “+”, “both”), call(“+”, as.name(“a”), as.name(“b”)))), call = list(expect_equal(findOperator(f3, “+”, “both”), call(“+”, as.name(“a”), as.name(“b”)))), start_frame = 74,
end_frame = 74, test = “findOperator”), list(message ="findOperator(f3, "+","left")not equal to as.name("a").“, srcref = c(193, 3, 194, 28, 3, 28, 193, 194), expectation_calls = list(expect_equal(findOperator(f3,”+“,”left“), as.name(”a“))), call = list(expect_equal(findOperator(f3,”+“,”left“), as.name(”a“))), start_frame = 74, end_frame = 74, test =”findOperator“), list(message =”findOperator(f3, "+", "right") not equal to as.name("b").", srcref = c(195, 3,
196, 28, 3, 28, 195, 196), expectation_calls = list(expect_equal(findOperator(f3, "+“,”right“), as.name(”b“))), call = list(expect_equal(findOperator(f3,”+“,”right“), as.name(”b“))), start_frame = 74, end_frame = 74, test =”findOperator“), list(message =”findOperator(f4, "~", "both") not equal to f4.“, srcref = c(199, 3, 199, 49, 3, 49, 199, 199), expectation_calls = list(expect_equal(findOperator(f4,”“,”both“), f4)), call = list(expect_equal(findOperator(f4,”“,”both"),
f4)), start_frame = 74, end_frame = 74, test = "findOperator“), list(message =”findOperator(f4, "~", "left") not equal to NA.“, srcref = c(200, 3, 200, 49, 3, 49, 200, 200), expectation_calls = list(expect_equal(findOperator(f4,”“,”left“), NA)), call = list(expect_equal(findOperator(f4,”“,”left“), NA)), start_frame = 74, end_frame = 74, test =”findOperator“), list(message =”findOperator(f4, "~", "right") not equal to as.name("b").", srcref = c(201, 3, 201, 60,
3, 60, 201, 201),expectation_calls = list(expect_equal(findOperator(f4, “~”, "right"), as.name(“b”))), call = list(expect_equal(findOperator(f4, “~”, “right”), as.name(“b”))), start_frame = 74, end_frame = 74, test = “findOperator”), list(message = “findOperator(f5, "+", "left") not equal to as.name("a").”, srcref = c(205, 3, 205, 59, 3, 59, 205, 205), expectation_calls = list(expect_equal(findOperator(f5, “+”, “left”), as.name(“a”))), call = list(expect_equal(findOperator(f5, “+”,
“left”), as.name(“a”))), start_frame= 74, end_frame =74, test = “findOperator”), list(message = “findOperator(f5, "+", "right") not equal to as.name("b").”, srcref = c(206, 3, 206, 60, 3, 60, 206, 206), expectation_calls = list(expect_equal(findOperator(f5, “+”, “right”), as.name(“b”))), call = list(expect_equal(findOperator(f5, “+”, “right”), as.name(“b”))), start_frame = 74, end_frame = 74, test = “findOperator”), list(message = “findOperator(f6, "~", "both") not equal to f6.”,
srcref = c(209, 3, 209, 49, 3, 49, 209, 209), expectation_calls = list(expect_equal(findOperator(f6, “~”, “both”), f6)), call = list(expect_equal(findOperator(f6, “~”, “both”), f6)), start_frame = 74, end_frame = 74, test = “findOperator”), list(message = “findOperator(f6, "+", "left") not equal to as.name("c").”, srcref = c(210, 3, 210, 59, 3, 59, 210, 210), expectation_calls = list(expect_equal(findOperator(f6, “+”, “left”), as.name(“c”))), call = list(expect_equal(findOperator(f6,
“+”, “left”),as.name(“c”))), start_frame = 74, end_frame = 74, test = "findOperator"), list(message = “findOperator(f6, "+", "right") not equal to as.name("d").”, srcref = c(211, 3, 211, 60, 3, 60, 211, 211), expectation_calls = list(expect_equal(findOperator(f6, “+”, “right”), as.name(“d”))), call = list(expect_equal(findOperator(f6, “+”, “right”), as.name(“d”))), start_frame = 74, end_frame = 74, test = “findOperator”), list(message = “findOperator(f6, "(", "left") not equal to NA.”,
srcref = c(212, 3, 212, 49, 3, 49, 212, 212), expectation_calls = list(expect_equal(findOperator(f6, “(”, “left”), NA)), call = list(expect_equal(findOperator(f6, “(”, “left”), NA)), start_frame = 74, end_frame = 74, test = “findOperator”), list(message = “findOperator(f6, "(", "right") not equal to call("+", as.name("c"), as.name("d")).”, srcref = c(213, 3, 214, 53, 3, 53, 213, 214), expectation_calls = list(expect_equal(findOperator(f6, “(”, “right”), call(“+”, as.name(“c”),
as.name(“d”)))), call = list(expect_equal(findOperator(f6, “(”, “right”), call("+", as.name(“c”), as.name(“d”)))), start_frame = 74, end_frame = 74, test = “findOperator”), list(message = “findOperator(f7, "~", "both") not equal to f7.”, srcref = c(218, 3, 218, 49, 3, 49, 218, 218), expectation_calls = list(expect_equal(findOperator(f7, “~”, “both”), f7)), call = list(expect_equal(findOperator(f7, “~”, “both”), f7)), start_frame = 74, end_frame = 74, test = “findOperator”), list(
message = "findOperator(f7, "|", "both") not equalto call("|", call("+", as.name("c"), as.name("d")), as.name("e")).“, srcref = c(219, 3, 223, 34, 3, 34, 219, 223), expectation_calls = list(expect_equal(findOperator(f7,”|“,”both“), call(”|“, call(”+“, as.name(”c“), as.name(”d“)), as.name(”e“)))), call = list(expect_equal(findOperator(f7,”|“,”both“), call(”|“, call(”+“, as.name(”c“), as.name(”d“)), as.name(”e“)))), start_frame = 74, end_frame = 74, test =”findOperator"),
list(message = "findOperator(f8, "~", \"both") not equalto f8.", srcref= c(228,3, 228, 49, 3, 49, 228, 228), expectation_calls = list(expect_equal(findOperator(f8, “~”, “both”), f8)), call = list(expect_equal(findOperator(f8, “~”, “both”), f8)), start_frame = 74, end_frame = 74, test = “findOperator”), list(message = “findOperator(f8, "|", "both") not equal to call("|", as.name("d"), as.name("e")).”, srcref = c(229, 3, 232, 34, 3, 34, 229, 232), expectation_calls = list(
expect_equal(findOperator(f8, “|”, "both“), call(”|", as.name(“d”), as.name(“e”)))), call= list(expect_equal(findOperator(f8, “|”, “both”), call(“|”, as.name(“d”), as.name(“e”)))), start_frame = 74, end_frame = 74, test = “findOperator”), list(message = “findOperator(…) not equal to call("|", as.name("f"), call("/", as.name("g"), as.name("h"))).”, srcref = c(235, 3, 243, 48, 3, 48, 235, 243), expectation_calls = list(expect_equal(findOperator(findOperator(findOperator(f8,
“~”, “right”),“+”, “right”), “|”, "both“), call(”|", as.name(“f”), call(“/”, as.name(“g”), as.name(“h”))))), call = list(expect_equal(findOperator(findOperator(findOperator(f8, “~”, “right”), “+”, “right”), “|”, “both”), call(“|”, as.name(“f”), call(“/”, as.name(“g”), as.name(“h”))))), start_frame = 74, end_frame = 74, test = “findOperator”), list(message = “findOperator(f9, "+", "left") not equal to NULL.”, srcref = c(247, 3, 247, 51, 3, 51, 247, 247), expectation_calls = list(
expect_equal(findOperator(f9, “+”, "left"), NULL)), call = list(expect_equal(findOperator(f9, “+”, “left”), NULL)), start_frame = 74, end_frame = 74, test = “findOperator”), list(message = “findOperator(f10, "-", "left") not equal to NA.”, srcref = c(250, 3, 250, 50, 3, 50, 250, 250), expectation_calls = list(expect_equal(findOperator(f10, “-”, “left”), NA)), call = list(expect_equal(findOperator(f10, “-”, “left”), NA)), start_frame = 74, end_frame = 74, test = “findOperator”),
list(message = "findOperator(f11, "!","left") not equal to NA.", srcref =c(252, 3, 252, 50, 3, 50, 252, 252), expectation_calls = list(expect_equal(findOperator(f11, “!”, “left”), NA)), call = list(expect_equal(findOperator(f11, “!”, “left”), NA)), start_frame = 74, end_frame = 74, test = “findOperator”), list(message = “findOperator(f12, "+", "left") not equal to NA.”, srcref = c(254, 3, 254, 50, 3, 50, 254, 254), expectation_calls = list(expect_equal(findOperator(f12,
“+”, “left”),NA)), call = list(expect_equal(findOperator(f12, “+”, “left”), NA)), start_frame = 74, end_frame = 74, test = “findOperator”), list(message = “findOperator(f13, "(", "left") not equal to NA.”, srcref = c(256, 3, 256, 50, 3, 50, 256, 256), expectation_calls = list(expect_equal(findOperator(f13, “(”, “left”), NA)), call = list(expect_equal(findOperator(f13, “(”, “left”), NA)), start_frame = 74, end_frame = 74, test = “findOperator”), list(message = "", srcref = c(259,
3, 259, 48, 3, 48,259, 259), expectation_calls = list(expect_error(findOperator(f1,“~”, "neither“))), call = list(expect_error(findOperator(f1,”~“,”neither“))), start_frame = 74, end_frame = 74, test =”findOperator“), list(message =”“, srcref = c(262, 3, 263, 49, 3, 49, 262, 263), expectation_calls = list(expect_error(findOperator(list(), side =”both“), regexp =”Cannot handle class list“)), call = list(expect_error(findOperator(list(), side =”both“), regexp =”Cannot handle class list")),
start_frame =74, end_frame = 74, test = “findOperator”))

+

+

+
Business rule functions

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Testing FilenameTest DescriptionNumber of TestsNumber of Failed Testspassedresult
test-pk.business.rules.Rgeomean10010list(list(message = “geomean(5) not equal to 5.”, srcref = c(5, 3, 5, 29, 3, 29, 5, 5), expectation_calls = list(expect_equal(geomean(5), 5)), call = list(expect_equal(geomean(5), 5)), start_frame = 74, end_frame = 74, test = “geomean”), list(message = “geomean(c(5, 5)) not equal to 5.”, srcref = c(6, 3, 6, 35, 3, 35, 6, 6), expectation_calls = list(expect_equal(geomean(c(5, 5)), 5)), call = list(expect_equal(geomean(c(5, 5)), 5)), start_frame = 74, end_frame = 74, test = “geomean”),
list(message = "geomean(c(10, 1000)) not equal to 100.l", srcref = c(7, 3, 7, 41, 3, 41,7, 7), expectation_calls = list(expect_equal(geomean(c(10, 1000)), 100)), call = list(expect_equal(geomean(c(10, 1000)), 100)), start_frame = 74, end_frame = 74, test = “geomean”), list(message = “geomean(0) not equal to 0.”, srcref = c(9, 3, 9, 29, 3, 29, 9, 9), expectation_calls = list(expect_equal(geomean(0), 0)), call = list(expect_equal(geomean(0), 0)), start_frame = 74, end_frame = 74,
test = “geomean”),list(message = "geomean(c(0, 1)) notequal to 0.", srcref = c(10, 3, 10, 35, 3, 35, 10, 10), expectation_calls = list(expect_equal(geomean(c(0, 1)), 0)), call = list(expect_equal(geomean(c(0, 1)), 0)), start_frame = 74, end_frame = 74, test = “geomean”), list(message = “geomean(c(-1, 2)) not equal to -geomean(c(1, 2)).”, srcref = c(12, 3, 12, 52, 3, 52, 12, 12), expectation_calls = list(expect_equal(geomean(c(-1, 2)), -geomean(c(1, 2)))), call = list(expect_equal(geomean(c(-1,
2)), -geomean(c(1,2)))), start_frame= 74, end_frame =74, test = “geomean”), list(message = “geomean(NA) not equal to as.numeric(NA).”, srcref = c(14, 3, 14, 43, 3, 43, 14, 14), expectation_calls = list(expect_equal(geomean(NA), as.numeric(NA))), call = list(expect_equal(geomean(NA), as.numeric(NA))), start_frame = 74, end_frame = 74, test = “geomean”), list(message = “geomean(c(NA, 0)) not equal to as.numeric(NA).”, srcref = c(15, 3, 15, 49, 3, 49, 15, 15), expectation_calls = list(
expect_equal(geomean(c(NA, 0)), as.numeric(NA))), call =list(expect_equal(geomean(c(NA, 0)), as.numeric(NA))), start_frame = 74, end_frame = 74, test = “geomean”), list(message = “geomean(c(NA, 5), na.rm = TRUE) not equal to 5.”, srcref = c(16, 3, 16, 48, 3, 48, 16, 16), expectation_calls = list(expect_equal(geomean(c(NA, 5), na.rm = TRUE), 5)), call = list(expect_equal(geomean(c(NA, 5), na.rm = TRUE), 5)), start_frame = 74, end_frame = 74, test = “geomean”), list(message = “geomean(c(NA, NA), na.rm = TRUE) not equal to NaN.”,
srcref = c(17, 3, 17, 51, 3, 51, 17, 17), expectation_calls = list(expect_equal(geomean(c(NA, NA), na.rm = TRUE), NaN)), call = list(expect_equal(geomean(c(NA, NA), na.rm = TRUE), NaN)), start_frame = 74, end_frame = 74, test = “geomean”))
test-pk.business.rules.Rgeosd202list(list(message = “geosd(c(1, 2)) not equal to exp(sd(log(c(1, 2)))).”, srcref = c(21, 3, 21, 53, 3, 53, 21, 21), expectation_calls = list(expect_equal(geosd(c(1, 2)), exp(sd(log(c(1, 2)))))), call = list(expect_equal(geosd(c(1, 2)), exp(sd(log(c(1, 2)))))), start_frame = 74, end_frame = 74, test = “geosd”), list(message = “geosd(c(NA, 1, 2)) not equal to as.numeric(NA).”, srcref = c(22, 3, 22, 50, 3, 50, 22, 22), expectation_calls = list(expect_equal(geosd(c(NA, 1, 2)), as.numeric(NA))),
call = list(expect_equal(geosd(c(NA, 1, 2)), as.numeric(NA))), start_frame = 74, end_frame = 74, test = “geosd”))
test-pk.business.rules.Rgeocv202list(list(message = “geocv(c(1, 2)) not equal to sqrt(exp(sd(log(c(1, 2)))^2) - 1) * 100.”, srcref = c(26, 3, 27, 51, 3, 51, 26, 27), expectation_calls = list(expect_equal(geocv(c(1, 2)), sqrt(exp(sd(log(c(1, 2)))^2) - 1) * 100)), call = list(expect_equal(geocv(c(1, 2)), sqrt(exp(sd(log(c(1, 2)))^2) - 1) * 100)), start_frame = 74, end_frame = 74, test = “geocv”), list(message = “geocv(c(NA, 1, 2)) not equal to as.numeric(NA).”, srcref = c(28, 3, 28, 50, 3, 50, 28, 28), expectation_calls = list(
expect_equal(geocv(c(NA, 1, 2)), as.numeric(NA))), call = list(expect_equal(geocv(c(NA, 1, 2)), as.numeric(NA))), start_frame = 74, end_frame = 74, test = “geocv”))
test-pk.business.rules.Rbusiness.mean606list(list(message = “business.mean(1) not equal to 1.”, srcref = c(35, 3, 35, 35, 3, 35, 35, 35), expectation_calls = list(expect_equal(business.mean(1), 1)), call = list(expect_equal(business.mean(1), 1)), start_frame = 74, end_frame = 74, test = “business.mean”), list(message = “business.mean(c(1, 2)) not equal to 1.5.”, srcref = c(36, 3, 36, 43, 3, 43, 36, 36), expectation_calls = list(expect_equal(business.mean(c(1, 2)), 1.5)), call = list(expect_equal(business.mean(c(1, 2)), 1.5)),
start_frame = 74, end_frame = 74, test = "business.mean"), list(message = "business.mean(c(NA,NA, 1, 2)) not equal to 1.5.“, srcref = c(39, 3, 39, 51, 3, 51, 39, 39), expectation_calls = list(expect_equal(business.mean(c(NA, NA, 1, 2)), 1.5)), call = list(expect_equal(business.mean(c(NA, NA, 1, 2)), 1.5)), start_frame = 74, end_frame = 74, test =”business.mean“), list(message =”business.mean(c(NA, NA, NA, 2)) not equal to NA.", srcref = c(40, 3, 40, 51, 3, 51, 40, 40), expectation_calls = list(
expect_equal(business.mean(c(NA, NA, NA, 2)), NA)), call = list(expect_equal(business.mean(c(NA, NA, NA, 2)), NA)), start_frame = 74, end_frame = 74, test = “business.mean”), list(message = “business.mean(c(NA, 1, 2, 3)) not equal to 2.”, srcref = c(43, 3, 43, 48, 3, 48, 43, 43), expectation_calls = list(expect_equal(business.mean(c(NA, 1, 2, 3)), 2)), call = list(expect_equal(business.mean(c(NA, 1, 2, 3)), 2)), start_frame = 74, end_frame = 74, test = “business.mean”), list(message = “business.mean(c(NA, NA, 1, 2)) not equal to NA.”,
srcref = c(44, 3, 44, 50, 3, 50, 44, 44),expectation_calls= list(expect_equal(business.mean(c(NA, NA, 1, 2)), NA)), call = list(expect_equal(business.mean(c(NA, NA, 1, 2)), NA)), start_frame = 74, end_frame = 74, test = “business.mean”))
test-pk.business.rules.Rpk.business505list(list(message = “b.mean(c(1, 2)) not equal to 1.5.”, srcref = c(51, 3, 51, 36, 3, 36, 51, 51), expectation_calls = list(expect_equal(b.mean(c(1, 2)), 1.5)), call = list(expect_equal(b.mean(c(1, 2)), 1.5)), start_frame = 74, end_frame = 74, test = “pk.business”), list(message = “b.mean(c(1, NA)) not equal to 1.”, srcref = c(53, 3, 53, 35, 3, 35, 53, 53), expectation_calls = list(expect_equal(b.mean(c(1, NA)), 1)), call = list(expect_equal(b.mean(c(1, NA)), 1)), start_frame = 74,
end_frame = 74, test =“pk.business”), list(message = "b.mean(c(1, NA, NA)) not equalto NA.TRUE“, srcref = c(55, 3, 55, 40, 3, 40, 55, 55), expectation_calls = list(expect_equal(b.mean(c(1, NA, NA)), NA)), call = list(expect_equal(b.mean(c(1, NA, NA)), NA)), start_frame = 74, end_frame = 74, test =”pk.business“), list(message =”b.mean(c(0, 1)) not equal to 0.5.", srcref = c(58, 3, 58, 36, 3, 36, 58, 58), expectation_calls = list(expect_equal(b.mean(c(0, 1)), 0.5)), call = list(expect_equal(b.mean(c(0,
1)), 0.5)), start_frame= 74, end_frame =74, test = "pk.business“), list(message =”b.mean.2(c(0, 1)) not equal to 1.“, srcref = c(59, 3, 59, 36, 3, 36, 59, 59), expectation_calls = list(expect_equal(b.mean.2(c(0, 1)), 1)), call = list(expect_equal(b.mean.2(c(0, 1)), 1)), start_frame = 74, end_frame = 74, test =”pk.business"))

+

+

+
All NCA calculations

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Testing FilenameTest DescriptionNumber of TestsNumber of Failed Testspassedresult
test-pk.calc.all.Rpk.nca14014list(list(message = “names(myresult) not equal to c("result", "data", "exclude").”, srcref = c(16, 3, 18, 108, 3, 108, 16, 18), expectation_calls = list(expect_equal(names(myresult), c(“result”, “data”, “exclude”), info = “Make sure that the result has the expected names (and only the expected names) in it.”)), call = list(expect_equal(names(myresult), c(“result”, “data”, “exclude”), info = “Make sure that the result has the expected names (and only the expected names) in it.”)), start_frame = 74,
end_frame = 74, test = “pk.nca”), list(message = “checkProvenance(myresult) isn’t true.”, srcref = c(19, 3,20, 49, 3, 49, 19, 20), expectation_calls= list(expect_true(checkProvenance(myresult), info = “Provenance works on results”)), call = list(expect_true(checkProvenance(myresult), info = “Provenance works on results”)), start_frame = 74, end_frame = 74, test = “pk.nca”), list(message = "", srcref = c(27, 3, 29, 78, 3, 78, 27, 29), expectation_calls = list(expect_warning(myresult.failure <- pk.nca(mydata.failure),
regexp = "No intervals given; no calculations done.“, info =”An empty result is returned if there are no intervals")), call= list(expect_warning(myresult.failure <- pk.nca(mydata.failure), regexp = “No intervals given; no calculations done.”, info = “An empty result is returned if there are no intervals”)), start_frame = 74, end_frame = 74, test = “pk.nca”), list(message = “pk.nca(mydata.nodose)\(result not equal to myresult\)result.”, srcref = c(36, 3, 38, 75, 3, 75, 36, 38), expectation_calls = list(
expect_equal(pk.nca(mydata.nodose)\(result, myresult\)result, info = "missing dose information is handled without an issue")),call = list(expect_equal(pk.nca(mydata.nodose)\(result, myresult\)result, info = “missing dose information is handled without an issue”)), start_frame = 74, end_frame = 74, test = “pk.nca”), list(message = "myresult\(data not equal to {\n ...\n}.\nTRUE", srcref = c(43, 3, 49, 97, 3, 97, 43, 49), expectation_calls = list(expect_equal(myresult\)data, {
tmp <- mydata
tmp$options <- PKNCA.options()
tmp
}, info = "The data is just a copy of the input data plus an instantiation of the PKNCA.options")), call = list(expect_equal(myresult$data, {
tmp <- mydata
tmp$options <- PKNCA.options()
tmp
}, info = "The data is just a copy of the input data plus an instantiation of the PKNCA.options")), start_frame= 74, end_frame =74, test = “pk.nca”), list(message = “myresult\(result not equal to `verify.result`.\nTRUE", srcref = c(73, 3, 77, 58, 3, 58, 73, 77), expectation_calls = list(expect_equal(myresult\)result, verify.result, tol = 0.001, info = paste(”The specific order of the levels isn’t important–“,”the fact that they are factors and that the set“,”doesn’t change is important."))), call = list(
expect_equal(myresult$result, verify.result, tol = 0.001, info = paste("The specific order of the levels isn’t important–","the fact that they are factors and that the set“,”doesn’t change is important.“))), start_frame = 74, end_frame = 74, test =”pk.nca“), list(message =”myresult.newinterval\(result not equal to myresult\)result.“, srcref = c(89, 3, 91, 126, 3, 126, 89, 91), expectation_calls = list(expect_equal(myresult.newinterval\(result, myresult\)result, info =”Intervals can be specified manually, and will apply across appropriate parts of the grouping variables.")),
call = list(expect_equal(myresult.newinterval\(result, myresult\)result, info = "Intervals can be specified manually, and willapply across appropriateparts ofthe grouping variables.“)), start_frame = 74, end_frame = 74, test =”pk.nca“), list(message =”myresult.multi\(result not equal to `verify.result.multi`.\nTRUE", srcref = c(107, 3, 109, 159, 3, 159, 107, 109), expectation_calls = list(expect_equal(myresult.multi\)result, verify.result.multi, tol = 0.001, info = “Shifted dosing works the same as un-shifted where time parameters like tmax and tlast are reported relative to the start of the interval”)),
call = list(expect_equal(myresult.multi$result, verify.result.multi, tol = 0.001, info = "Shifted dosing works the same as un-shifted where time parameters like tmax and tlast are reported relative to the start of the interval“)), start_frame = 74, end_frame = 74, test =”pk.nca“), list(message =”myresult\(result\)PPORRES not equal to c(0.99981, 0.94097).", srcref = c(118, 3, 120, 104, 3, 104, 118, 120), expectation_calls = list(expect_equal(myresult\(result\)PPORRES, c(0.99981, 0.94097),
tol = 1e-05, info= “Calculations work with a single row of intervals and a single parameter requested”)),call = list(expect_equal(myresult\(result\)PPORRES, c(0.99981, 0.94097), tol = 1e-05, info = “Calculations work with a single row of intervals and a single parameter requested”)), start_frame = 74, end_frame = 74, test = “pk.nca”), list(message = “subset(myresult\(result, PPTESTCD %in% \"cl.obs\")\)PPORRES not equal to c(0.0464, 0.05111).”, srcref = c(125, 3, 127, 76, 3, 76, 125, 127),
expectation_calls= list(expect_equal(subset(myresult\(result, PPTESTCD %in% "cl.obs")\)PPORRES, c(0.0464, 0.05111), tol = 1e-04, info = "PK intervals work withpassing in dose as a parameter“)), call = list(expect_equal(subset(myresult\(result, PPTESTCD %in% "cl.obs")\)PPORRES, c(0.0464, 0.05111), tol = 1e-04, info =”PK intervals work with passing in dose as a parameter“)), start_frame = 74, end_frame = 74, test =”pk.nca“), list(message =”subset(myresult\(result, PPTESTCD %in% \"cav\")\)PPORRES not equal to c(0.5642, 0.5846).",
srcref = c(136, 3, 138, 84, 3, 84, 136, 138), expectation_calls = list(expect_equal(subset(myresult$result,PPTESTCD %in% "cav")$PPORRES, c(0.5642, 0.5846), tol = 1e-04, info = “PK intervals work with passing in start and end as parameters”)), call = list(expect_equal(subset(myresult\(result, PPTESTCD %in% "cav")\)PPORRES, c(0.5642, 0.5846), tol = 1e-04, info = “PK intervals work with passing in start and end as parameters”)), start_frame = 74, end_frame = 74, test = “pk.nca”), list(message = “myresult\(result\)PPORRES[myresult\(result\)PPTESTCD %in% "cl.obs"] not equal to 4/myresult\(result\)PPORRES[myresult\(result\)PPTESTCD %in% "aucinf.obs"].”,
srcref = c(150, 3, 153, 116, 3, 116, 150, 153), expectation_calls = list(expect_equal(myresult\(result\)PPORRES[myresult$result$PPTESTCD %in% “cl.obs”],4/myresult\(result\)PPORRES[myresult\(result\)PPTESTCD %in% “aucinf.obs”], tol = 1e-04, info = “The correct number of doses is selected for an interval (>=start and <end), 4 doses and not 5”)), call = list(expect_equal(myresult\(result\)PPORRES[myresult\(result\)PPTESTCD %in% “cl.obs”], 4/myresult\(result\)PPORRES[myresult\(result\)PPTESTCD %in% “aucinf.obs”],
tol = 1e-04,info = "The correct number of doses is selected for an interval (>=start and <end), 4 doses and not 5")), start_frame = 74, end_frame= 74, test = “pk.nca”), list(message = “myresult\(result\)PPORRES[myresult\(result\)PPTESTCD %in% "cl.last"] not equal to 1/myresult\(result\)PPORRES[myresult\(result\)PPTESTCD %in% "auclast"].”, srcref = c(158, 3, 161, 115, 3, 115, 158, 161), expectation_calls = list(expect_equal(myresult\(result\)PPORRES[myresult\(result\)PPTESTCD %in% “cl.last”],
1/myresult$result\(PPORRES[myresult\)result$PPTESTCD %in% “auclast”], tol = 1e-04, info = "The correct numberof doses is selected for an interval (>=start and <end), 1 dose and not 5“)), call = list(expect_equal(myresult\(result\)PPORRES[myresult\(result\)PPTESTCD %in% "cl.last"], 1/myresult\(result\)PPORRES[myresult\(result\)PPTESTCD %in% "auclast"], tol = 1e-04, info =”The correct number of doses is selected for an interval (>=start and <end), 1 dose and not 5")), start_frame = 74, end_frame = 74,
test = “pk.nca”),list(message = "myresult\(result\)PPORRES[myresult\(result\)PPTESTCD %in% "cl.last"] not equal to NA/myresult\(result\)PPORRES[myresult$result$PPTESTCD %in% "auclast"].“, srcref = c(166, 3, 169, 116, 3, 116, 166, 169), expectation_calls = list(expect_equal(myresult\(result\)PPORRES[myresult\(result\)PPTESTCD %in% "cl.last"], NA/myresult\(result\)PPORRES[myresult\(result\)PPTESTCD %in% "auclast"], tol = 1e-04, info =”The correct number of doses is selected for an interval (>=start and <end), no doses selected")),
call = list(expect_equal(myresult\(result\)PPORRES[myresult\(result\)PPTESTCD %in% “cl.last”], NA/myresult$result$PPORRES[myresult\(result\)PPTESTCD %in% "auclast"],tol = 1e-04, info = “The correct number of doses is selected for an interval (>=start and <end), no doses selected”)), start_frame = 74, end_frame = 74, test = “pk.nca”))
test-pk.calc.all.RCalculations when dose time is missing101list(list(message = “myresult\(result\)PPORRES[myresult\(result\)PPTESTCD %in% "cl.obs"] not equal to 1/myresult\(result\)PPORRES[myresult\(result\)PPTESTCD %in% "aucinf.obs"].”, srcref = c(182, 3, 184, 116, 3, 116, 182, 184), expectation_calls = list(expect_equal(myresult\(result\)PPORRES[myresult\(result\)PPTESTCD %in% “cl.obs”], 1/myresult\(result\)PPORRES[myresult\(result\)PPTESTCD %in% “aucinf.obs”], info = “The correct number of doses is selected for an interval (>=start and <end), 4 doses and not 5”)),
call = list(expect_equal(myresult\(result\)PPORRES[myresult\(result\)PPTESTCD %in% “cl.obs”], 1/myresult$result\(PPORRES[myresult\)result$PPTESTCD %in% "aucinf.obs"], info = “The correct number of doses is selected for an interval (>=start and <end), 4 doses and not 5”)), start_frame = 74, end_frame = 74, test = “Calculations when dose time is missing”))
test-pk.calc.all.RCalculations when no dose info is given202list(list(message = "“, srcref = c(194, 3, 196, 57, 3, 57, 194, 196), expectation_calls = list(expect_message(myresult <- pk.nca(mydata), regexp =”No dose information provided, calculations requiring dose will return NA.“, info =”Dosing information not required.“)), call = list(expect_message(myresult <- pk.nca(mydata), regexp =”No dose information provided, calculations requiring dose will return NA.“, info =”Dosing information not required.“)), start_frame = 74, end_frame = 74, test =”Calculations when no dose info is given"),
list(message = "myresult$result not equal to data.frame(…).", srcref = c(197, 3, 206, 50, 3, 50, 197, 206), expectation_calls = list(expect_equal(myresult\(result, data.frame(start = 0, end = 24, treatment = "Trt 1", ID = rep(1:2, each = 3), PPTESTCD = rep(c("auclast", "cmax", "cl.last"), 2), PPORRES = c(13.5417297156528, 0.999812606062292, NA, 14.0305397438242, 0.94097296083447, NA), exclude = NA, stringsAsFactors = FALSE))), call = list(expect_equal(myresult\)result, data.frame(start = 0,
end = 24, treatment = “Trt 1”, ID = rep(1:2, each = 3), PPTESTCD = rep(c(“auclast”, “cmax”, “cl.last”),2), PPORRES = c(13.5417297156528, 0.999812606062292, NA, 14.0305397438242, 0.94097296083447, NA), exclude = NA, stringsAsFactors = FALSE))), start_frame = 74, end_frame = 74, test = “Calculations when no dose info is given”))
test-pk.calc.all.Rpk.nca with exclusions303list(list(message = “identical(…) isn’t true.”, srcref = c(226, 3, 228, 82, 3, 82, 226, 228), expectation_calls = list(expect_true(identical(myresult\(result[myresult\)result\(ID %in% 2, ], myresult.excl\)result[myresult.excl\(result\)ID %in% 2, ]), info = “Results are unchanged for the subject who has the same data”)), call = list(expect_true(identical(myresult\(result[myresult\)result\(ID %in% 2, ], myresult.excl\)result[myresult.excl\(result\)ID %in% 2, ]), info = “Results are unchanged for the subject who has the same data”)),
start_frame = 74,end_frame = 74, test = “pk.nca with exclusions”), list(message = "identical(…) isn’t false.", srcref = c(229, 3, 231, 80, 3, 80, 229, 231),expectation_calls = list(expect_false(identical(myresult\(result[myresult\)result\(ID %in% 1, ], myresult.excl\)result[myresult.excl\(result\)ID %in% 1, ]), info = “Results are changed for the subject who has the same data”)), call = list(expect_false(identical(myresult\(result[myresult\)result\(ID %in% 1, ], myresult.excl\)result[myresult.excl\(result\)ID %in%
1, ]), info = "Results are changed for the subject who has the same data")), start_frame = 74, end_frame =74, test = "pk.ncawith exclusions"), list(message ="…[] not equal to max(tmpconc.excl\(conc[tmpconc.excl\)ID %in% 1 & is.na(tmpconc.excl\(excl)]).\nEqual", srcref = c(232, 3, 234, 56, 3, 56, 232, 234), expectation_calls = list(expect_equal(myresult.excl\)result\(PPORRES[myresult.excl\)result\(ID %in% 1 & myresult.excl\)result\(PPTESTCD %in% "cmax"], max(tmpconc.excl\)conc[tmpconc.excl$ID %in%
1 & is.na(tmpconc.excl$excl)]), info = “Cmax is affected by the exclusion”)), call = list(expect_equal(myresult.excl\(result\)PPORRES[myresult.excl$result$ID %in% 1 & myresult.excl\(result\)PPTESTCD %in% “cmax”], max(tmpconc.excl\(conc[tmpconc.excl\)ID %in% 1 & is.na(tmpconc.excl$excl)]), info = “Cmax is affected by the exclusion”)), start_frame = 74, end_frame = 74, test = “pk.nca with exclusions”))
test-pk.calc.all.Rpk.calc.all with duration.dose required101list(list(message = “myresult\(result\)PPORRES[myresult\(result\)PPTESTCD %in% "mrt.iv.last"] not equal to c(10.36263, 10.12515).”, srcref = c(247, 3, 250, 59, 3, 59, 247, 250), expectation_calls = list(expect_equal(myresult\(result\)PPORRES[myresult\(result\)PPTESTCD %in% “mrt.iv.last”], c(10.36263, 10.12515), tol = 1e-05, info = “duration.dose is used when requested”)), call = list(expect_equal(myresult\(result\)PPORRES[myresult\(result\)PPTESTCD %in% “mrt.iv.last”], c(10.36263, 10.12515), tol = 1e-05,
info = "duration.dose is used when requested“)), start_frame = 74, end_frame = 74, test =”pk.calc.all withduration.dose required"))
test-pk.calc.all.Rhalf life inclusion and exclusion202list(list(message = “identical(myresult\(result, myresult_excl\)result) isn’t false.”, srcref = c(273, 3, 273, 64, 3, 64, 273, 273), expectation_calls = list(expect_false(identical(myresult\(result, myresult_excl\)result))), call = list(expect_false(identical(myresult\(result, myresult_excl\)result))), start_frame = 74, end_frame = 74, test = “half life inclusion and exclusion”), list(message = “identical(myresult\(result, myresult_incl\)result) isn’t false.”, srcref = c(274, 3, 274, 64, 3, 64, 274, 274),
expectation_calls= list(expect_false(identical(myresult\(result, myresult_incl\)result))), call = list(expect_false(identical(myresult$result, myresult_incl$result))), start_frame = 74, end_frame = 74, test = “half life inclusion and exclusion”))
test-pk.calc.all.RNo interval requested (e.g. for placebo)202list(list(message = "“, srcref = c(285, 3, 287, 74, 3, 74, 285, 287), expectation_calls = list(expect_message(myresult <- pk.nca(mydata), regexp =”2 groups have no interval calculations requested.“, info =”No intervals apply to a group provides a message.“)), call = list(expect_message(myresult <- pk.nca(mydata), regexp =”2 groups have no interval calculations requested.“, info =”No intervals apply to a group provides a message.“)), start_frame = 74, end_frame = 74, test =”No interval requested (e.g. for placebo)"),
list(message = "nrow(as.data.frame(myresult)) not equal to 0.", srcref = c(288, 3, 289, 71, 3, 71, 288, 289), expectation_calls = list(expect_equal(nrow(as.data.frame(myresult)), 0, info = “No rows were generated when no intervals applied”)), call = list(expect_equal(nrow(as.data.frame(myresult)), 0, info = “No rows were generated when no intervals applied”)), start_frame = 74, end_frame = 74, test = “No interval requested (e.g. for placebo)”))
test-pk.calc.all.RVolume-related calculations202list(list(message = “as.data.frame(myresult)[["PPORRES"]] not equal to c(12, 12, 30, 30).”, srcref = c(304, 3, 305, 56, 3, 56, 304, 305), expectation_calls = list(expect_equal(as.data.frame(myresult)[[“PPORRES”]], c(12, 12, 30, 30), info = “ae and fe are correctly calculated”)), call = list(expect_equal(as.data.frame(myresult)[[“PPORRES”]], c(12, 12, 30, 30), info = “ae and fe are correctly calculated”)), start_frame = 74, end_frame = 74, test = “Volume-related calculations”), list(message = “as.data.frame(myresult2)[["PPORRES"]] not equal to c(12, 6, 30, 15).”,
srcref = c(314, 3, 315, 39, 3, 39, 314, 315), expectation_calls = list(expect_equal(as.data.frame(myresult2)[[“PPORRES”]], c(12, 6, 30, 15), info = "fe respects dose“)), call = list(expect_equal(as.data.frame(myresult2)[["PPORRES"]], c(12, 6, 30, 15), info =”fe respects dose“)), start_frame = 74, end_frame = 74, test =”Volume-related calculations"))
test-pk.calc.all.Rpk.nca can calculate values with group-level data101list(list(message = “as.data.frame(myres_impute)\(PPORRES not equal to as.data.frame(myres_observe)\)PPORRES.”, srcref = c(343, 3, 345, 79, 3, 79, 343, 345), expectation_calls = list(expect_equal(as.data.frame(myres_impute)\(PPORRES, as.data.frame(myres_observe)\)PPORRES, info = “Manually imputing values gives the same result as aucint”)), call = list(expect_equal(as.data.frame(myres_impute)\(PPORRES, as.data.frame(myres_observe)\)PPORRES, info = “Manually imputing values gives the same result as aucint”)),
start_frame = 74,end_frame = 74, test = “pk.nca can calculate values with group-level data”))
test-pk.calc.all.RMissing dose info for some subjects gives a warning, not a difficult-to-interpret error202list(list(message = "“, srcref = c(356, 3, 359, 113, 3, 113, 356, 359), expectation_calls = list(expect_warning(myresult <- pk.nca(mydata), regexp =”The following intervals are missing dosing data:“, fixed = TRUE, info =”Warning is issued when dose data are missing for an interval but provided for some data.“)), call = list(expect_warning(myresult <- pk.nca(mydata), regexp =”The following intervals are missing dosing data:“, fixed = TRUE, info =”Warning is issued when dose data are missing for an interval but provided for some data.")),
start_frame = 74,end_frame = 74, test = "Missing dose info for some subjects gives a warning, not a difficult-to-interpret error“), list(message =”&… isn’ttrue.“, srcref = c(360, 3, 362, 134, 3, 134, 360, 362), expectation_calls = list(expect_true(all(is.na(myresult\(result[["PPORRES"]]) == c(FALSE, FALSE, FALSE, TRUE)) & all(myresult\)result[["PPTESTCD"]] == rep(c(”auclast“,”cl.last“), 2)), info =”cl.last is not calculated when dose information is missing, but only for the subject where dose info is missing.")),
call = list(expect_true(all(is.na(myresult$result[[“PPORRES”]]) == c(FALSE, FALSE, FALSE, TRUE)) & all(myresult$result[["PPTESTCD“]] == rep(c(”auclast“,”cl.last“), 2)), info =”cl.last is not calculated when dose information is missing, but only for the subject where dose info is missing.“)), start_frame = 74, end_frame = 74, test =”Missing dose info for some subjects gives a warning, not a difficult-to-interpret error"))
test-pk.calc.all.REnsure that options are respected during pk.nca call101list(list(message = “&… isn’t true.”, srcref = c(392, 3, 402, 78, 3, 78, 392, 402), expectation_calls = list(expect_true(all.equal(linear.results\(result\)PPORRES[linear.results\(result\)PPTESTCD %in% “aucinf.obs” & linear.results\(result\)ID %in% 1 & linear.results\(result\)end %in% Inf], 24.54319, tolerance = 1e-04) & all.equal(linlog.results\(result\)PPORRES[linlog.results\(result\)PPTESTCD %in% “aucinf.obs” & linlog.results\(result\)ID %in% 1 & linlog.results\(result\)end %in% Inf], 23.68317, tolerance = 1e-04),
info = "linear and loglinear effects are calculated differently.")), call = list(expect_true(all.equal(linear.results\(result\)PPORRES[linear.results$result$PPTESTCD %in% “aucinf.obs” & linear.results\(result\)ID %in% 1 & linear.results\(result\)end %in% Inf], 24.54319, tolerance = 1e-04) & all.equal(linlog.results\(result\)PPORRES[linlog.results\(result\)PPTESTCD %in% “aucinf.obs” & linlog.results\(result\)ID %in% 1 & linlog.results\(result\)end %in% Inf], 23.68317, tolerance = 1e-04), info = “linear and loglinear effects are calculated differently.”)),
start_frame = 74,end_frame = 74, test = “Ensure that options are respected during pk.nca call”))

+

+

+
C0 Calculations

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Testing FilenameTest DescriptionNumber of TestsNumber of Failed Testspassedresult
test-pk.calc.c0.Rpk.calc.c010010list(list(message = "“, srcref = c(5, 3, 7, 52, 3, 52, 5, 7), expectation_calls = list(expect_error(pk.calc.c0(5:1, 4:0), regexp =”Time must be monotonically increasing“, info =”conc, time inputs are checked“)), call = list(expect_error(pk.calc.c0(5:1, 4:0), regexp =”Time must be monotonically increasing“, info =”conc, time inputs are checked“)), start_frame = 74, end_frame = 74, test =”pk.calc.c0“), list(message =”", srcref = c(8, 3, 9, 51, 3, 51, 8, 9), expectation_calls = list(expect_error(pk.calc.c0(5:1,
0:4, time.dose =1:2), regexp = "time.dose must be a scalar")),call = list(expect_error(pk.calc.c0(5:1, 0:4, time.dose = 1:2), regexp = “time.dose must be a scalar”)), start_frame = 74, end_frame = 74, test = “pk.calc.c0”), list(message = "“, srcref = c(10, 3, 11, 51, 3, 51, 10, 11), expectation_calls = list(expect_error(pk.calc.c0(5:1, 0:4, time.dose =”1“), regexp =”time.dose must be a number“)), call = list(expect_error(pk.calc.c0(5:1, 0:4, time.dose =”1“), regexp =”time.dose must be a number")),
start_frame = 74, end_frame = 74, test = "pk.calc.c0"), list(message = "", srcref = c(12, 3, 14,43, 3, 43, 12, 14), expectation_calls = list(expect_error(pk.calc.c0(5:1, 0:4, method = “blah”), regexp = “should be one of”, info = “method must be valid”)), call = list(expect_error(pk.calc.c0(5:1, 0:4, method = “blah”), regexp = “should be one of”, info = “method must be valid”)), start_frame = 74, end_frame = 74, test = “pk.calc.c0”), list(message = "", srcref = c(15, 3, 16, 64, 3, 64, 15, 16),
expectation_calls = list(expect_warning(pk.calc.c0(5:1, 0:4, time.dose = 30), regexp = "time.doseis after all available data“)), call = list(expect_warning(pk.calc.c0(5:1, 0:4, time.dose = 30), regexp =”time.dose is after all available data“)), start_frame = 74, end_frame = 74, test =”pk.calc.c0“), list(message =”pk.calc.c0(1:5, 0:4) not equal to 1.“, srcref = c(19, 3, 20, 90, 3, 90, 19, 20), expectation_calls = list(expect_equal(pk.calc.c0(1:5, 0:4), 1, info =”When there is a nonzero concentration at the default time of dosing")),
call = list(expect_equal(pk.calc.c0(1:5, 0:4), 1, info = "Whenthere is a nonzero concentration at the default time of dosing“)), start_frame = 74, end_frame = 74, test =”pk.calc.c0“), list(message =”pk.calc.c0(1:5, 0:4, time.dose = 1) not equal to 2.“, srcref = c(21, 3, 22, 93, 3, 93, 21, 22), expectation_calls = list(expect_equal(pk.calc.c0(1:5, 0:4, time.dose = 1), 2, info =”When there is a nonzero concentration at the nondefault time of dosing")), call = list(expect_equal(pk.calc.c0(1:5,
0:4, time.dose =1), 2, info = "When there isa nonzero concentration at the nondefaulttime of dosing“)), start_frame = 74, end_frame = 74, test =”pk.calc.c0“), list(message =”pk.calc.c0(c(0, 2, 1, 0.5), 0:3) not equal to pk.calc.c0.method.logslope(c(0, 2, 1, 0.5), 0:3).“, srcref = c(24, 3, 26, 53, 3, 53, 24, 26), expectation_calls = list(expect_equal(pk.calc.c0(c(0, 2, 1, 0.5), 0:3), pk.calc.c0.method.logslope(c(0, 2, 1, 0.5), 0:3), info =”Falls through to second method")), call = list(
expect_equal(pk.calc.c0(c(0, 2, 1, 0.5), 0:3), pk.calc.c0.method.logslope(c(0, 2, 1, 0.5), 0:3),info = “Falls through to second method”)), start_frame = 74, end_frame = 74, test = “pk.calc.c0”), list(message = “pk.calc.c0(c(0, 2, 0, 0), 0:3) not equal to pk.calc.c0.method.c1(c(0, 2, 0, 0), 0:3).”, srcref = c(27, 3, 29, 52, 3, 52, 27, 29), expectation_calls = list(expect_equal(pk.calc.c0(c(0, 2, 0, 0), 0:3), pk.calc.c0.method.c1(c(0, 2, 0, 0), 0:3), info = “Falls through to third method”)),
call = list(expect_equal(pk.calc.c0(c(0, 2, 0, 0), 0:3), pk.calc.c0.method.c1(c(0, 2, 0,0), 0:3), info = “Falls through to third method”)), start_frame = 74, end_frame = 74, test = “pk.calc.c0”), list(message = “pk.calc.c0(c(0, 2, 1, 0.5), 0:3, method = "c1") not equal to pk.calc.c0.method.c1(c(0, 2, 1, 0.5), 0:3).”, srcref = c(30, 3, 32, 44, 3, 44, 30, 32), expectation_calls = list(expect_equal(pk.calc.c0(c(0, 2, 1, 0.5), 0:3, method = “c1”), pk.calc.c0.method.c1(c(0, 2, 1, 0.5), 0:3),
info = "Respectsmethod order")), call = list(expect_equal(pk.calc.c0(c(0, 2, 1, 0.5), 0:3, method = “c1”), pk.calc.c0.method.c1(c(0, 2, 1, 0.5), 0:3), info = “Respects method order”)), start_frame = 74, end_frame = 74, test = “pk.calc.c0”))
test-pk.calc.c0.Rpk.calc.c0.method.logslope606list(list(message = “pk.calc.c0.method.logslope(c(0, 2, 1, 0.5), 0:3) not equal to 4.”, srcref = c(37, 3, 37, 67, 3, 67, 37, 37), expectation_calls = list(expect_equal(pk.calc.c0.method.logslope(c(0, 2, 1, 0.5), 0:3), 4)), call = list(expect_equal(pk.calc.c0.method.logslope(c(0, 2, 1, 0.5), 0:3), 4)), start_frame = 74, end_frame = 74, test = “pk.calc.c0.method.logslope”), list(message = “pk.calc.c0.method.logslope(c(0, 2, 0, 0), 0:3) not equal to NA.”, srcref = c(38, 3, 39, 46, 3, 46,
38, 39), expectation_calls = list(expect_equal(pk.calc.c0.method.logslope(c(0, 2, 0, 0), 0:3), NA, info = “returns NA when C2 is 0”)), call = list(expect_equal(pk.calc.c0.method.logslope(c(0, 2, 0, 0), 0:3), NA, info = “returns NA when C2 is 0”)), start_frame = 74, end_frame = 74, test = “pk.calc.c0.method.logslope”), list(message = “pk.calc.c0.method.logslope(c(0, 2, 0, 0.5), 0:3) not equal to NA.”, srcref = c(40, 3, 41, 76, 3, 76, 40, 41), expectation_calls = list(expect_equal(pk.calc.c0.method.logslope(c(0,
2, 0, 0.5), 0:3), NA, info = "returns NA whenC2 is 0, even when subsequent are > 0")),call = list(expect_equal(pk.calc.c0.method.logslope(c(0, 2, 0, 0.5), 0:3), NA, info = “returns NA when C2 is 0, even when subsequent are > 0”)), start_frame = 74, end_frame = 74, test = “pk.calc.c0.method.logslope”), list(message = “pk.calc.c0.method.logslope(c(0, 2, NA, 0.5), 0:3) not equal to 4.”, srcref = c(42, 3, 43, 53, 3, 53, 42, 43), expectation_calls = list(expect_equal(pk.calc.c0.method.logslope(c(0,
2, NA, 0.5), 0:3), 4, info = "ignores missingconcentrations")), call = list(expect_equal(pk.calc.c0.method.logslope(c(0, 2, NA, 0.5), 0:3), 4, info = “ignores missing concentrations”)), start_frame = 74, end_frame = 74, test = “pk.calc.c0.method.logslope”), list(message = “pk.calc.c0.method.logslope(c(0, 2, NA, 0.5), 2:5, time.dose = 2) not equal to 4.”, srcref = c(44, 3, 45, 48, 3, 48, 44, 45), expectation_calls = list(expect_equal(pk.calc.c0.method.logslope(c(0, 2, NA, 0.5), 2:5, time.dose = 2),
4, info = "handles nonzero time.dose")), call= list(expect_equal(pk.calc.c0.method.logslope(c(0,2, NA, 0.5), 2:5, time.dose = 2), 4, info = “handles nonzero time.dose”)), start_frame = 74, end_frame = 74, test = “pk.calc.c0.method.logslope”), list(message = “pk.calc.c0.method.logslope(c(2, NA, 0.5), 3:5, time.dose = 2) not equal to 4.”, srcref = c(46, 3, 47, 66, 3, 66, 46, 47), expectation_calls = list(expect_equal(pk.calc.c0.method.logslope(c(2, NA, 0.5), 3:5, time.dose = 2), 4, info = “works when time.dose isn’t an observed time”)),
call = list(expect_equal(pk.calc.c0.method.logslope(c(2, NA, 0.5), 3:5, time.dose = 2),4, info =“works when time.dose isn’t an observed time”)), start_frame = 74, end_frame = 74, test = “pk.calc.c0.method.logslope”))
test-pk.calc.c0.Rpk.calc.c0.method.c0202list(list(message = “pk.calc.c0.method.c0(c(0, 2, 1, 0.5), 0:3) not equal to NA.”, srcref = c(51, 3, 51, 62, 3, 62, 51, 51), expectation_calls = list(expect_equal(pk.calc.c0.method.c0(c(0, 2, 1, 0.5), 0:3), NA)), call = list(expect_equal(pk.calc.c0.method.c0(c(0, 2, 1, 0.5), 0:3), NA)), start_frame = 74, end_frame = 74, test = “pk.calc.c0.method.c0”), list(message = “pk.calc.c0.method.c0(c(2, NA, 0.5), 3:5, time.dose = 3) not equal to 2.”, srcref = c(52, 3, 53, 66, 3, 66, 52, 53), expectation_calls = list(
expect_equal(pk.calc.c0.method.c0(c(2, NA, 0.5), 3:5, time.dose= 3), 2, info = "works when time.dose matches a nonzero conc“)), call = list(expect_equal(pk.calc.c0.method.c0(c(2, NA, 0.5), 3:5, time.dose = 3), 2, info =”works when time.dose matches a nonzero conc“)), start_frame = 74, end_frame = 74, test =”pk.calc.c0.method.c0"))
test-pk.calc.c0.Rpk.calc.c0.method.c1505list(list(message = “pk.calc.c0.method.c1(c(0, 2, 1, 0.5), 0:3) not equal to 2.”, srcref = c(57, 3, 57, 61, 3, 61, 57, 57), expectation_calls = list(expect_equal(pk.calc.c0.method.c1(c(0, 2, 1, 0.5), 0:3), 2)), call = list(expect_equal(pk.calc.c0.method.c1(c(0, 2, 1, 0.5), 0:3), 2)), start_frame = 74, end_frame = 74, test = “pk.calc.c0.method.c1”), list(message = “pk.calc.c0.method.c1(c(2, NA, 0.5), 3:5, time.dose = 3) not equal to 0.5.”, srcref = c(58, 3, 59, 84, 3, 84, 58, 59), expectation_calls = list(
expect_equal(pk.calc.c0.method.c1(c(2, NA, 0.5), 3:5, time.dose= 3), 0.5, info = "workswhen time.dose matches a nonzero conc and skips over NA“)), call = list(expect_equal(pk.calc.c0.method.c1(c(2, NA, 0.5), 3:5, time.dose = 3), 0.5, info =”works when time.dose matches a nonzero conc and skips over NA“)), start_frame = 74, end_frame = 74, test =”pk.calc.c0.method.c1“), list(message =”pk.calc.c0.method.c1(c(2, NA, 0.5), 3:5, time.dose = 30) not equal to NA.", srcref = c(60, 3, 61, 78,
3, 78, 60, 61), expectation_calls = list(expect_equal(pk.calc.c0.method.c1(c(2, NA, 0.5), 3:5, time.dose = 30), NA, info = “returns NA when time.dose is after the last measurement”)), call = list(expect_equal(pk.calc.c0.method.c1(c(2, NA, 0.5), 3:5, time.dose = 30), NA, info = “returns NA when time.dose is after the last measurement”)), start_frame = 74, end_frame = 74, test = “pk.calc.c0.method.c1”), list(message = "", srcref = c(62, 3, 63, 60, 3, 60, 62, 63), expectation_calls = list(expect_warning(v1 <- pk.calc.c0.method.c1(rep(NA,
3), 3:5, time.dose = 1), regexp = "All concentration data is missing")), call = list(expect_warning(v1 <- pk.calc.c0.method.c1(rep(NA, 3), 3:5, time.dose = 1), regexp = “All concentration data is missing”)), start_frame = 74, end_frame = 74, test = “pk.calc.c0.method.c1”), list(message = “v1 not equal to NA.”, srcref = c(64, 3, 65, 56, 3, 56, 64, 65), expectation_calls = list(expect_equal(v1, NA, info = “returns NA when all inputs are NA”)), call = list(expect_equal(v1, NA, info = “returns NA when all inputs are NA”)),
start_frame = 74, end_frame = 74, test = "pk.calc.c0.method.c1"))
test-pk.calc.c0.Rpk.calc.c0.method.set0202list(list(message = “pk.calc.c0.method.set0() not equal to 0.”, srcref = c(69, 3, 69, 43, 3, 43, 69, 69), expectation_calls = list(expect_equal(pk.calc.c0.method.set0(), 0)), call = list(expect_equal(pk.calc.c0.method.set0(), 0)), start_frame = 74, end_frame = 74, test = “pk.calc.c0.method.set0”), list(message = “pk.calc.c0.method.set0(1, 1) not equal to 0.”, srcref = c(70, 3, 70, 47, 3, 47, 70, 70), expectation_calls = list(expect_equal(pk.calc.c0.method.set0(1, 1), 0)), call = list(
expect_equal(pk.calc.c0.method.set0(1, 1), 0)), start_frame = 74, end_frame = 74, test ="pk.calc.c0.method.set0"))
test-pk.calc.c0.Rpk.calc.c0.method.cmin202list(list(message = “pk.calc.c0.method.cmin(c(0, 2, 1, 0.5), 0:3) not equal to 0.”, srcref = c(74, 3, 74, 63, 3, 63, 74, 74), expectation_calls = list(expect_equal(pk.calc.c0.method.cmin(c(0, 2, 1, 0.5), 0:3), 0)), call = list(expect_equal(pk.calc.c0.method.cmin(c(0, 2, 1, 0.5), 0:3), 0)), start_frame = 74, end_frame = 74, test = “pk.calc.c0.method.cmin”), list(message = “pk.calc.c0.method.cmin(c(2, NA, 0.5), 3:5, time.dose = 3) not equal to 0.5.”, srcref = c(75, 3, 75, 76, 3, 76, 75,
75), expectation_calls = list(expect_equal(pk.calc.c0.method.cmin(c(2, NA, 0.5), 3:5, time.dose = 3),0.5)), call = list(expect_equal(pk.calc.c0.method.cmin(c(2, NA, 0.5), 3:5, time.dose = 3), 0.5)), start_frame = 74, end_frame = 74, test = “pk.calc.c0.method.cmin”))

+

+

+
Dose-normalized NCA functions

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Testing FilenameTest DescriptionNumber of TestsNumber of Failed Testspassedresult
test-pk.calc.dn.Rpk.calc.dn303list(list(message = “pk.calc.dn(1, 5) not equal to 0.2.”, srcref = c(5, 3, 5, 37, 3, 37, 5, 5), expectation_calls = list(expect_equal(pk.calc.dn(1, 5), 0.2)), call = list(expect_equal(pk.calc.dn(1, 5), 0.2)), start_frame = 74, end_frame = 74, test = “pk.calc.dn”), list(message = “pk.calc.dn(NA, 5) not equal to NA.”, srcref = c(6, 3, 6, 43, 3, 43, 6, 6), expectation_calls = list(expect_equal(pk.calc.dn(NA, 5), NA)), call = list(expect_equal(pk.calc.dn(NA, 5), NA)), start_frame = 74,
end_frame = 74,test = “pk.calc.dn”), list(message ="pk.calc.dn(1, NA) not equal to NA.“, srcref = c(7, 3, 7, 43, 3, 43, 7, 7), expectation_calls = list(expect_equal(pk.calc.dn(1, NA), NA)), call = list(expect_equal(pk.calc.dn(1, NA), NA)), start_frame = 74, end_frame = 74, test =”pk.calc.dn"))
test-pk.calc.dn.Rpk.calc.cmax101list(list(message = “/(…) not equal to myres\(result\)dose[myres\(result\)PPTESTCD %in% "auclast"].”, srcref = c(23, 3, 26, 87, 3, 87, 23, 26), expectation_calls = list(expect_equal(myres\(result\)PPORRES[myres\(result\)PPTESTCD %in% “auclast”]/myres\(result\)PPORRES[myres\(result\)PPTESTCD %in% “auclast.dn”], myres\(result\)dose[myres\(result\)PPTESTCD %in% “auclast”], info = “Dose normalization works when requested as a parameter in pk.nca”)), call = list(expect_equal(myres\(result\)PPORRES[myres\(result\)PPTESTCD %in%
“auclast”]/myres\(result\)PPORRES[myres\(result\)PPTESTCD%in% “auclast.dn”], myres\(result\)dose[myres\(result\)PPTESTCD %in% “auclast”], info = “Dose normalization works when requested as a parameter in pk.nca”)), start_frame = 74, end_frame = 74, test = “pk.calc.cmax”))

+

+

+
Simple NCA functions

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Testing FilenameTest DescriptionNumber of TestsNumber of Failed Testspassedresult
test-pk.calc.simple.Radj.r.squared303list(list(message = “adj.r.squared(1, 5) not equal to 1.”, srcref = c(5, 3, 5, 38, 3, 38, 5, 5), expectation_calls = list(expect_equal(adj.r.squared(1, 5), 1)), call = list(expect_equal(adj.r.squared(1, 5), 1)), start_frame = 74, end_frame = 74, test = “adj.r.squared”), list(message = “adj.r.squared(0.5, 5) not equal to 1 - 0.5 * 4/3.”, srcref = c(6, 3, 6, 48, 3, 48, 6, 6), expectation_calls = list(expect_equal(adj.r.squared(0.5, 5), 1 - 0.5 * 4/3)), call = list(expect_equal(adj.r.squared(0.5,
5), 1 - 0.5 * 4/3)),start_frame = 74, end_frame =74, test = "adj.r.squared"), list(message ="", srcref = c(9, 3, 10, 38, 3, 38, 9, 10), expectation_calls = list(expect_error(adj.r.squared(1, 2), regexp = “n must be > 2”)), call = list(expect_error(adj.r.squared(1, 2), regexp = “n must be > 2”)), start_frame = 74, end_frame = 74, test = “adj.r.squared”))
test-pk.calc.simple.Rpk.calc.cmax12012list(list(message = "“, srcref = c(15, 3, 15, 40, 3, 40, 15, 15), expectation_calls = list(expect_warning(v1 <- pk.calc.cmax(NA))), call = list(expect_warning(v1 <- pk.calc.cmax(NA))), start_frame = 74, end_frame = 74, test =”pk.calc.cmax“), list(message =”v1 not equal to NA.“, srcref = c(16, 3, 16, 22, 3, 22, 16, 16), expectation_calls = list(expect_equal(v1, NA)), call = list(expect_equal(v1, NA)), start_frame = 74, end_frame = 74, test =”pk.calc.cmax“), list(message =”", srcref = c(17,
3, 17, 47, 3, 47, 17, 17), expectation_calls = list(expect_warning(v2 <-pk.calc.cmax(c(NA, NA)))), call =list(expect_warning(v2 <- pk.calc.cmax(c(NA, NA)))), start_frame = 74, end_frame = 74, test = “pk.calc.cmax”), list(message = “v2 not equal to NA.”, srcref = c(18, 3, 18, 22, 3, 22, 18, 18), expectation_calls = list(expect_equal(v2, NA)), call = list(expect_equal(v2, NA)), start_frame = 74, end_frame = 74, test = “pk.calc.cmax”), list(message = “pk.calc.cmax(c(1, 2)) not equal to 2.”,
srcref = c(21, 3, 21, 40, 3, 40, 21, 21), expectation_calls = list(expect_equal(pk.calc.cmax(c(1, 2)),2)), call = list(expect_equal(pk.calc.cmax(c(1, 2)), 2)), start_frame = 74, end_frame = 74, test = “pk.calc.cmax”), list(message = “pk.calc.cmax(c(1, 2, 3)) not equal to 3.”, srcref = c(22, 3, 22, 43, 3, 43, 22, 22), expectation_calls = list(expect_equal(pk.calc.cmax(c(1, 2, 3)), 3)), call = list(expect_equal(pk.calc.cmax(c(1, 2, 3)), 3)), start_frame = 74, end_frame = 74, test = “pk.calc.cmax”),
list(message = "pk.calc.cmax(c(1, NA, 3)) not equalto 3.", srcref = c(25, 3, 25, 44, 3, 44, 25,25), expectation_calls = list(expect_equal(pk.calc.cmax(c(1, NA, 3)), 3)), call = list(expect_equal(pk.calc.cmax(c(1, NA, 3)), 3)), start_frame = 74, end_frame = 74, test = “pk.calc.cmax”), list(message = “pk.calc.cmax(c(NA, NA, 3)) not equal to 3.”, srcref = c(26, 3, 26, 45, 3, 45, 26, 26), expectation_calls = list(expect_equal(pk.calc.cmax(c(NA, NA, 3)), 3)), call = list(expect_equal(pk.calc.cmax(c(NA,
NA, 3)), 3)), start_frame = 74, end_frame = 74,test = "pk.calc.cmax“), list(message =”pk.calc.cmax(c(1, NA, NA)) not equal to 1.“, srcref = c(27, 3, 27, 45, 3, 45, 27, 27), expectation_calls = list(expect_equal(pk.calc.cmax(c(1, NA, NA)), 1)), call = list(expect_equal(pk.calc.cmax(c(1, NA, NA)), 1)), start_frame = 74, end_frame = 74, test =”pk.calc.cmax“), list(message =”pk.calc.cmax(c(1, NA, 3, NA)) not equal to 3.", srcref = c(28, 3, 28, 48, 3, 48, 28, 28), expectation_calls = list(
expect_equal(pk.calc.cmax(c(1, NA, 3, NA)), 3)), call = list(expect_equal(pk.calc.cmax(c(1, NA, 3,NA)), 3)), start_frame = 74, end_frame = 74, test = “pk.calc.cmax”), list(message = "“, srcref = c(31, 3, 31, 41, 3, 41, 31, 31), expectation_calls = list(expect_warning(v3 <- pk.calc.cmax(c()))), call = list(expect_warning(v3 <- pk.calc.cmax(c()))), start_frame = 74, end_frame = 74, test =”pk.calc.cmax“), list(message =”v3 not equal to NA.", srcref = c(32, 3, 32, 22, 3, 22, 32, 32
), expectation_calls= list(expect_equal(v3, NA)),call = list(expect_equal(v3, NA)), start_frame = 74,end_frame = 74, test = “pk.calc.cmax”))
test-pk.calc.simple.Rpk.calc.cmin12012list(list(message = "“, srcref = c(37, 3, 37, 40, 3, 40, 37, 37), expectation_calls = list(expect_warning(v1 <- pk.calc.cmin(NA))), call = list(expect_warning(v1 <- pk.calc.cmin(NA))), start_frame = 74, end_frame = 74, test =”pk.calc.cmin“), list(message =”v1 not equal to NA.“, srcref = c(38, 3, 38, 22, 3, 22, 38, 38), expectation_calls = list(expect_equal(v1, NA)), call = list(expect_equal(v1, NA)), start_frame = 74, end_frame = 74, test =”pk.calc.cmin“), list(message =”", srcref = c(39,
3, 39, 47, 3, 47, 39, 39), expectation_calls = list(expect_warning(v2 <-pk.calc.cmin(c(NA, NA)))), call =list(expect_warning(v2 <- pk.calc.cmin(c(NA, NA)))), start_frame = 74, end_frame = 74, test = “pk.calc.cmin”), list(message = “v2 not equal to NA.”, srcref = c(40, 3, 40, 22, 3, 22, 40, 40), expectation_calls = list(expect_equal(v2, NA)), call = list(expect_equal(v2, NA)), start_frame = 74, end_frame = 74, test = “pk.calc.cmin”), list(message = “pk.calc.cmin(c(1, 2)) not equal to 1.”,
srcref = c(43, 3, 43, 40, 3, 40, 43, 43), expectation_calls = list(expect_equal(pk.calc.cmin(c(1, 2)),1)), call = list(expect_equal(pk.calc.cmin(c(1, 2)), 1)), start_frame = 74, end_frame = 74, test = “pk.calc.cmin”), list(message = “pk.calc.cmin(c(1, 2, 3)) not equal to 1.”, srcref = c(44, 3, 44, 43, 3, 43, 44, 44), expectation_calls = list(expect_equal(pk.calc.cmin(c(1, 2, 3)), 1)), call = list(expect_equal(pk.calc.cmin(c(1, 2, 3)), 1)), start_frame = 74, end_frame = 74, test = “pk.calc.cmin”),
list(message = "pk.calc.cmin(c(1, NA, 3)) not equalto 1.", srcref = c(47, 3, 47, 44, 3, 44, 47,47), expectation_calls = list(expect_equal(pk.calc.cmin(c(1, NA, 3)), 1)), call = list(expect_equal(pk.calc.cmin(c(1, NA, 3)), 1)), start_frame = 74, end_frame = 74, test = “pk.calc.cmin”), list(message = “pk.calc.cmin(c(NA, NA, 3)) not equal to 3.”, srcref = c(48, 3, 48, 45, 3, 45, 48, 48), expectation_calls = list(expect_equal(pk.calc.cmin(c(NA, NA, 3)), 3)), call = list(expect_equal(pk.calc.cmin(c(NA,
NA, 3)), 3)), start_frame = 74, end_frame = 74,test = "pk.calc.cmin“), list(message =”pk.calc.cmin(c(1, NA, NA)) not equal to 1.“, srcref = c(49, 3, 49, 45, 3, 45, 49, 49), expectation_calls = list(expect_equal(pk.calc.cmin(c(1, NA, NA)), 1)), call = list(expect_equal(pk.calc.cmin(c(1, NA, NA)), 1)), start_frame = 74, end_frame = 74, test =”pk.calc.cmin“), list(message =”pk.calc.cmin(c(1, NA, 3, NA)) not equal to 1.", srcref = c(50, 3, 50, 48, 3, 48, 50, 50), expectation_calls = list(
expect_equal(pk.calc.cmin(c(1, NA, 3, NA)), 1)), call = list(expect_equal(pk.calc.cmin(c(1, NA, 3,NA)), 1)), start_frame = 74, end_frame = 74, test = “pk.calc.cmin”), list(message = "“, srcref = c(53, 3, 53, 41, 3, 41, 53, 53), expectation_calls = list(expect_warning(v3 <- pk.calc.cmin(c()))), call = list(expect_warning(v3 <- pk.calc.cmin(c()))), start_frame = 74, end_frame = 74, test =”pk.calc.cmin“), list(message =”v3 not equal to NA.", srcref = c(54, 3, 54, 22, 3, 22, 54, 54
), expectation_calls= list(expect_equal(v3, NA)),call = list(expect_equal(v3, NA)), start_frame = 74,end_frame = 74, test = “pk.calc.cmin”))
test-pk.calc.simple.Rpk.calc.tmax808list(list(message = "“, srcref = c(59, 3, 59, 46, 3, 46, 59, 59), expectation_calls = list(expect_warning(v1 <- pk.calc.tmax(c(), c()))), call = list(expect_warning(v1 <- pk.calc.tmax(c(), c()))), start_frame = 74, end_frame = 74, test =”pk.calc.tmax“), list(message =”v1 not equal to NA.“, srcref = c(60, 3, 60, 22, 3, 22, 60, 60), expectation_calls = list(expect_equal(v1, NA)), call = list(expect_equal(v1, NA)), start_frame = 74, end_frame = 74, test =”pk.calc.tmax“), list(message =”",
srcref = c(63, 3, 64, 43, 3, 43, 63, 64), expectation_calls = list(expect_error(pk.calc.tmax(conc = c()), regexp = “time must be given”)), call = list(expect_error(pk.calc.tmax(conc = c()), regexp = “time must be given”)), start_frame = 74, end_frame = 74, test = “pk.calc.tmax”), list(message = "“, srcref = c(65, 3, 66, 43, 3, 43, 65, 66), expectation_calls = list(expect_error(pk.calc.tmax(time = c()), regexp =”conc must be given“)), call = list(expect_error(pk.calc.tmax(time = c()), regexp =”conc must be given")),
start_frame = 74, end_frame = 74, test = "pk.calc.tmax"), list(message = "pk.calc.tmax(c(1, 2), c(0, 1), first.tmax = TRUE) not equal to 1.“, srcref = c(69, 3, 70, 17, 3, 17, 69, 70), expectation_calls = list(expect_equal(pk.calc.tmax(c(1, 2), c(0, 1), first.tmax = TRUE), 1)), call = list(expect_equal(pk.calc.tmax(c(1, 2), c(0, 1), first.tmax = TRUE), 1)), start_frame = 74, end_frame = 74, test =”pk.calc.tmax“), list(message =”pk.calc.tmax(c(1, 2), c(0, 1), first.tmax = FALSE) not equal to 1.",
srcref = c(71, 3, 72, 17, 3, 17, 71, 72), expectation_calls = list(expect_equal(pk.calc.tmax(c(1, 2), c(0, 1), first.tmax = FALSE), 1)), call = list(expect_equal(pk.calc.tmax(c(1, 2), c(0, 1), first.tmax = FALSE), 1)), start_frame = 74, end_frame = 74, test = “pk.calc.tmax”), list(message = “pk.calc.tmax(c(1, 1), c(0, 1), first.tmax = TRUE) not equal to 0.”, srcref = c(73, 3, 74, 17, 3, 17, 73, 74), expectation_calls = list(expect_equal(pk.calc.tmax(c(1, 1), c(0, 1), first.tmax = TRUE),
0)), call = list(expect_equal(pk.calc.tmax(c(1, 1),c(0, 1), first.tmax = TRUE), 0)), start_frame = 74,end_frame = 74, test = “pk.calc.tmax”), list(message = “pk.calc.tmax(c(1, 1), c(0, 1), first.tmax = FALSE) not equal to 1.”, srcref = c(75, 3, 76, 17, 3, 17, 75, 76), expectation_calls = list(expect_equal(pk.calc.tmax(c(1, 1), c(0, 1), first.tmax = FALSE), 1)), call = list(expect_equal(pk.calc.tmax(c(1, 1), c(0, 1), first.tmax = FALSE), 1)), start_frame = 74, end_frame = 74, test = “pk.calc.tmax”))
test-pk.calc.simple.Rpk.calc.tlast707list(list(message = "“, srcref = c(81, 3, 82, 43, 3, 43, 81, 82), expectation_calls = list(expect_error(pk.calc.tlast(conc = c()), regexp =”time must be given“)), call = list(expect_error(pk.calc.tlast(conc = c()), regexp =”time must be given“)), start_frame = 74, end_frame = 74, test =”pk.calc.tlast“), list(message =”“, srcref = c(83, 3, 84, 43, 3, 43, 83, 84), expectation_calls = list(expect_error(pk.calc.tlast(time = c()), regexp =”conc must be given")), call = list(expect_error(pk.calc.tlast(time = c()),
regexp = "conc mustbe given")), start_frame = 74,end_frame = 74, test = “pk.calc.tlast”), list(message = “pk.calc.tlast(c(1, 2), c(0, 1)) not equal to 1.”, srcref = c(87, 3, 88, 17, 3, 17, 87, 88), expectation_calls = list(expect_equal(pk.calc.tlast(c(1, 2), c(0, 1)), 1)), call = list(expect_equal(pk.calc.tlast(c(1, 2), c(0, 1)), 1)), start_frame = 74, end_frame = 74, test = “pk.calc.tlast”), list(message = “pk.calc.tlast(c(0, 0), c(0, 1)) not equal to NA.”, srcref = c(89, 3, 90,
18, 3, 18, 89, 90), expectation_calls = list(expect_equal(pk.calc.tlast(c(0, 0), c(0, 1)), NA)), call = list(expect_equal(pk.calc.tlast(c(0, 0), c(0, 1)), NA)), start_frame = 74, end_frame = 74, test = “pk.calc.tlast”), list(message = “pk.calc.tlast(c(0, 1), c(0, 1)) not equal to 1.”, srcref = c(91, 3, 92, 17, 3, 17, 91, 92), expectation_calls = list(expect_equal(pk.calc.tlast(c(0, 1), c(0, 1)), 1)), call = list(expect_equal(pk.calc.tlast(c(0, 1), c(0, 1)), 1)), start_frame = 74, end_frame = 74,
test = "pk.calc.tlast“), list(message =”pk.calc.tlast(c(1, 0), c(0,1)) not equal to 0.l", srcref = c(93, 3, 94, 17, 3, 17, 93, 94), expectation_calls = list(expect_equal(pk.calc.tlast(c(1, 0), c(0, 1)), 0)), call = list(expect_equal(pk.calc.tlast(c(1, 0), c(0, 1)), 0)), start_frame = 74, end_frame = 74, test = “pk.calc.tlast”), list(message = “pk.calc.tlast(c(1, 1), c(0, 1)) not equal to 1.”, srcref = c(95, 3, 96, 17, 3, 17, 95, 96), expectation_calls = list(expect_equal(pk.calc.tlast(c(1,
1), c(0, 1)), 1)), call = list(expect_equal(pk.calc.tlast(c(1, 1), c(0, 1)), 1)), start_frame= 74, end_frame = 74, test = “pk.calc.tlast”))
test-pk.calc.simple.Rpk.calc.clast.obs707list(list(message = “pk.calc.clast.obs(c1, t1) not equal to 2.”, srcref = c(103, 3, 103, 44, 3, 44, 103, 103), expectation_calls = list(expect_equal(pk.calc.clast.obs(c1, t1), 2)), call = list(expect_equal(pk.calc.clast.obs(c1, t1), 2)), start_frame = 74, end_frame = 74, test = “pk.calc.clast.obs”), list(message = “pk.calc.clast.obs(c1, t1) not equal to 3.”, srcref = c(108, 3, 108, 44, 3, 44, 108, 108), expectation_calls = list(expect_equal(pk.calc.clast.obs(c1, t1), 3)), call = list(
expect_equal(pk.calc.clast.obs(c1, t1), 3)), start_frame = 74, end_frame = 74, test = "pk.calc.clast.obs“), list(message =”pk.calc.clast.obs(c1, t1) not equal to 2.“, srcref = c(113, 3, 113, 44, 3, 44, 113, 113), expectation_calls = list(expect_equal(pk.calc.clast.obs(c1, t1), 2)), call = list(expect_equal(pk.calc.clast.obs(c1, t1), 2)), start_frame = 74, end_frame = 74, test =”pk.calc.clast.obs“), list(message =”pk.calc.clast.obs(c1, t1) not equal to 3.", srcref = c(117, 3,
117, 44, 3, 44, 117, 117), expectation_calls = list(expect_equal(pk.calc.clast.obs(c1, t1), 3)), call = list(expect_equal(pk.calc.clast.obs(c1, t1), 3)), start_frame = 74, end_frame = 74, test = “pk.calc.clast.obs”), list(message = "“, srcref = c(121, 3, 121, 49, 3, 49, 121, 121), expectation_calls = list(expect_warning(v1 <- pk.calc.clast.obs(c1, t1))), call = list(expect_warning(v1 <- pk.calc.clast.obs(c1, t1))), start_frame = 74, end_frame = 74, test =”pk.calc.clast.obs“), list(message =”v1 not equal to NA.",
srcref = c(122, 3, 122, 22, 3, 22, 122, 122), expectation_calls = list(expect_equal(v1, NA)),call = list(expect_equal(v1, NA)), start_frame = 74, end_frame = 74, test = “pk.calc.clast.obs”), list(message = “pk.calc.clast.obs(c1, t1) not equal to NA.”, srcref = c(126, 3, 126, 45, 3, 45, 126, 126), expectation_calls = list(expect_equal(pk.calc.clast.obs(c1, t1), NA)), call = list(expect_equal(pk.calc.clast.obs(c1, t1), NA)), start_frame = 74, end_frame = 74, test = “pk.calc.clast.obs”))
test-pk.calc.simple.Rpk.calc.thalf.eff303list(list(message = “pk.calc.thalf.eff(c()) not equal to numeric().”, srcref = c(131, 3, 132, 25, 3, 25, 131, 132), expectation_calls = list(expect_equal(pk.calc.thalf.eff(c()), numeric())), call = list(expect_equal(pk.calc.thalf.eff(c()), numeric())), start_frame = 74, end_frame = 74, test = “pk.calc.thalf.eff”), list(message = “pk.calc.thalf.eff(NA) not equal to as.numeric(NA).”, srcref = c(135, 3, 136, 30, 3, 30, 135, 136), expectation_calls = list(expect_equal(pk.calc.thalf.eff(NA),
as.numeric(NA))), call = list(expect_equal(pk.calc.thalf.eff(NA), as.numeric(NA))), start_frame = 74, end_frame = 74, test = “pk.calc.thalf.eff”), list(message = “pk.calc.thalf.eff(d1) not equal to r1.”, srcref = c(141, 3, 142, 18, 3, 18, 141, 142), expectation_calls = list(expect_equal(pk.calc.thalf.eff(d1), r1)), call = list(expect_equal(pk.calc.thalf.eff(d1), r1)), start_frame = 74, end_frame = 74, test = “pk.calc.thalf.eff”))
test-pk.calc.simple.Rpk.calc.kel303list(list(message = “pk.calc.kel(c()) not equal to numeric().”, srcref = c(147, 3, 148, 25, 3, 25, 147, 148), expectation_calls = list(expect_equal(pk.calc.kel(c()), numeric())), call = list(expect_equal(pk.calc.kel(c()), numeric())), start_frame = 74, end_frame = 74, test = “pk.calc.kel”), list(message = “pk.calc.kel(NA) not equal to as.numeric(NA).”, srcref = c(151, 3, 152, 30, 3, 30, 151, 152), expectation_calls = list(expect_equal(pk.calc.kel(NA), as.numeric(NA))), call = list(expect_equal(pk.calc.kel(NA),
as.numeric(NA))), start_frame = 74, end_frame = 74,test = "pk.calc.kel“), list(message =”pk.calc.kel(d1) not equal to r1.“, srcref = c(157, 3, 157, 35, 3, 35, 157, 157), expectation_calls = list(expect_equal(pk.calc.kel(d1), r1)), call = list(expect_equal(pk.calc.kel(d1), r1)), start_frame = 74, end_frame = 74, test =”pk.calc.kel"))
test-pk.calc.simple.Rpk.calc.cl707list(list(message = "“, srcref = c(162, 3, 163, 65, 3, 65, 162, 163), expectation_calls = list(expect_error(pk.calc.cl(auc = NA), info =”dose is required for clearance calculation“)), call = list(expect_error(pk.calc.cl(auc = NA), info =”dose is required for clearance calculation“)), start_frame = 74, end_frame = 74, test =”pk.calc.cl“), list(message =”“, srcref = c(164, 3, 165, 64, 3, 64, 164, 165), expectation_calls = list(expect_error(pk.calc.cl(dose = NA), info =”auc is required for clearance calculation")),
call = list(expect_error(pk.calc.cl(dose = NA), info = "auc is required for clearance calculation")), start_frame = 74, end_frame = 74, test = “pk.calc.cl”), list(message = “pk.calc.cl(dose = 10, auc = 100) not equal to 0.1.”, srcref = c(167, 3, 168, 57, 3, 57, 167, 168), expectation_calls = list(expect_equal(pk.calc.cl(dose = 10, auc = 100), 0.1, info = “Normal clearance calculation works”)), call = list(expect_equal(pk.calc.cl(dose = 10, auc = 100), 0.1, info = “Normal clearance calculation works”)),
start_frame = 74, end_frame = 74, test = "pk.calc.cl"), list(message= "pk.calc.cl(dose = c(10, 10, 10), auc = c(10, NA, 100)) not equal to c(1, NA, 0.1).“, srcref = c(169, 3, 171, 90, 3, 90, 169, 171), expectation_calls = list(expect_equal(pk.calc.cl(dose = c(10, 10, 10), auc = c(10, NA, 100)), c(1, NA, 0.1), info =”Vectors for both dose and auc give vectors for clearance (with NAs)“)), call = list(expect_equal(pk.calc.cl(dose = c(10, 10, 10), auc = c(10, NA, 100)), c(1, NA, 0.1), info =”Vectors for both dose and auc give vectors for clearance (with NAs)")),
start_frame = 74, end_frame = 74, test = "pk.calc.cl"), list(message= "pk.calc.cl(dose = c(50, 50), auc = 100) not equal to 1.“, srcref = c(172, 3, 174, 93, 3, 93, 172, 174), expectation_calls = list(expect_equal(pk.calc.cl(dose = c(50, 50), auc = 100), 1, info =”Vector for dose and scalar for auc scalar output with the sum of doses“)), call = list(expect_equal(pk.calc.cl(dose = c(50, 50), auc = 100), 1, info =”Vector for dose and scalar for auc scalar output with the sum of doses")),
start_frame = 74, end_frame = 74, test = "pk.calc.cl"), list(message= "pk.calc.cl(dose = c(50, 50), auc = c(NA, 100)) not equal to c(NA_real_, 0.5).“, srcref = c(175, 3, 177, 74, 3, 74, 175, 177), expectation_calls = list(expect_equal(pk.calc.cl(dose = c(50, 50), auc = c(NA, 100)), c(NA, 0.5), info =”NA generation works with NA, including for a vector“)), call = list(expect_equal(pk.calc.cl(dose = c(50, 50), auc = c(NA, 100)), c(NA, 0.5), info =”NA generation works with NA, including for a vector")),
start_frame = 74, end_frame = 74, test = "pk.calc.cl"), list(message= "pk.calc.cl(dose = c(50, 50), auc = c(0, 100)) not equal to c(NA_real_, 0.5).“, srcref = c(178, 3, 180, 76, 3, 76, 178, 180), expectation_calls = list(expect_equal(pk.calc.cl(dose = c(50, 50), auc = c(0, 100)), c(NA, 0.5), info =”NA generation works with zero, including for a vector“)), call = list(expect_equal(pk.calc.cl(dose = c(50, 50), auc = c(0, 100)), c(NA, 0.5), info =”NA generation works with zero, including for a vector")),
start_frame = 74, end_frame = 74, test = "pk.calc.cl"))
test-pk.calc.simple.Rpk.calc.f909list(list(message = “pk.calc.f(1, 1, 1, 2) not equal to 2.”, srcref = c(184, 3, 185, 59, 3, 59, 184, 185), expectation_calls = list(expect_equal(pk.calc.f(1, 1, 1, 2), 2, info = “Standard bioavailability calculation”)), call = list(expect_equal(pk.calc.f(1, 1, 1, 2), 2, info = “Standard bioavailability calculation”)), start_frame = 74, end_frame = 74, test = “pk.calc.f”), list(message = “pk.calc.f(NA, 1, 1, 1) not equal to NA.”, srcref = c(186, 3, 187, 71, 3, 71, 186, 187), expectation_calls = list(
expect_equal(pk.calc.f(NA, 1, 1, 1), NA, info = "NAhandling per parameter in bioavailability(1)")), call = list(expect_equal(pk.calc.f(NA, 1, 1, 1), NA, info = “NA handling per parameter in bioavailability (1)”)), start_frame = 74, end_frame = 74, test = “pk.calc.f”), list(message = “pk.calc.f(1, NA, 1, 1) not equal to NA.”, srcref = c(188, 3, 189, 71, 3, 71, 188, 189), expectation_calls = list(expect_equal(pk.calc.f(1, NA, 1, 1), NA, info = “NA handling per parameter in bioavailability (2)”)),
call = list(expect_equal(pk.calc.f(1, NA, 1, 1), NA, info = "NA handling per parameter in bioavailability (2)“)), start_frame = 74, end_frame = 74, test =”pk.calc.f“), list(message =”pk.calc.f(1, 1, NA, 1) not equal to NA.“, srcref = c(190, 3, 191, 71, 3, 71, 190, 191), expectation_calls = list(expect_equal(pk.calc.f(1, 1, NA, 1), NA, info =”NA handling per parameter in bioavailability (3)“)), call = list(expect_equal(pk.calc.f(1, 1, NA, 1), NA, info =”NA handling per parameter in bioavailability (3)")),
start_frame = 74, end_frame = 74, test = "pk.calc.f"), list(message ="pk.calc.f(1, 1, 1, NA)not equalto NA.“, srcref = c(192, 3, 193, 71, 3, 71, 192, 193), expectation_calls = list(expect_equal(pk.calc.f(1, 1, 1, NA), NA, info =”NA handling per parameter in bioavailability (4)“)), call = list(expect_equal(pk.calc.f(1, 1, 1, NA), NA, info =”NA handling per parameter in bioavailability (4)“)), start_frame = 74, end_frame = 74, test =”pk.calc.f“), list(message =”pk.calc.f(0, 1, 1, 1) not equal to NA.",
srcref = c(194, 3, 195, 73, 3, 73, 194, 195), expectation_calls = list(expect_equal(pk.calc.f(0, 1, 1,1), NA, info = “Zero handling per parameter in bioavailability (1)”)), call = list(expect_equal(pk.calc.f(0, 1, 1, 1), NA, info = “Zero handling per parameter in bioavailability (1)”)), start_frame = 74, end_frame = 74, test = “pk.calc.f”), list(message = “pk.calc.f(1, 0, 1, 1) not equal to NA.”, srcref = c(196, 3, 197, 73, 3, 73, 196, 197), expectation_calls = list(expect_equal(pk.calc.f(1,
0, 1, 1), NA, info ="Zero handling per parameter in bioavailability(2)")), call = list(expect_equal(pk.calc.f(1, 0, 1, 1), NA, info = “Zero handling per parameter in bioavailability (2)”)), start_frame = 74, end_frame = 74, test = “pk.calc.f”), list(message = “pk.calc.f(1, 1, 0, 1) not equal to NA.”, srcref = c(198, 3, 199, 73, 3, 73, 198, 199), expectation_calls = list(expect_equal(pk.calc.f(1, 1, 0, 1), NA, info = “Zero handling per parameter in bioavailability (3)”)), call = list(
expect_equal(pk.calc.f(1, 1, 0, 1), NA, info = "Zero handling per parameter in bioavailability(3)")),start_frame = 74, end_frame = 74, test = “pk.calc.f”), list(message = “pk.calc.f(1, 1, 1, 0) not equal to 0.”, srcref = c(200, 3, 201, 73, 3, 73, 200, 201), expectation_calls = list(expect_equal(pk.calc.f(1, 1, 1, 0), 0, info = “Zero handling per parameter in bioavailability (4)”)), call = list(expect_equal(pk.calc.f(1, 1, 1, 0), 0, info = “Zero handling per parameter in bioavailability (4)”)),
start_frame = 74, end_frame = 74, test = "pk.calc.f"))
test-pk.calc.simple.Rpk.calc.aucpext13013list(list(message = “pk.calc.aucpext(1, 2) not equal to 50.”, srcref = c(205, 3, 205, 41, 3, 41, 205, 205), expectation_calls = list(expect_equal(pk.calc.aucpext(1, 2), 50)), call = list(expect_equal(pk.calc.aucpext(1, 2), 50)), start_frame = 74, end_frame = 74, test = “pk.calc.aucpext”), list(message = “pk.calc.aucpext(1.8, 2) not equal to 10.”, srcref = c(206, 3, 206, 43, 3, 43, 206, 206), expectation_calls = list(expect_equal(pk.calc.aucpext(1.8, 2), 10)), call = list(expect_equal(pk.calc.aucpext(1.8,
2), 10)), start_frame = 74, end_frame = 74, test =“pk.calc.aucpext”), list(message = "", srcref = c(207, 3, 208, 100, 3, 100, 207, 208), expectation_calls = list(expect_warning(v1 <- pk.calc.aucpext(2, 1), regexp = “aucpext is typically only calculated when aucinf is greater than auclast.”)), call = list(expect_warning(v1 <- pk.calc.aucpext(2, 1), regexp = “aucpext is typically only calculated when aucinf is greater than auclast.”)), start_frame = 74, end_frame = 74, test = “pk.calc.aucpext”),
list(message = "v1not equal to -100.", srcref = c(209, 3, 209, 24, 3, 24, 209, 209),expectation_calls = list(expect_equal(v1, -100)), call = list(expect_equal(v1, -100)), start_frame = 74, end_frame = 74, test = “pk.calc.aucpext”), list(message = "“, srcref = c(210, 3, 211, 100, 3, 100, 210, 211), expectation_calls = list(expect_warning(v2 <- pk.calc.aucpext(auclast = 0, aucinf = 0), regexp =”aucpext is typically only calculated when aucinf is greater than auclast.")), call = list(
expect_warning(v2 <- pk.calc.aucpext(auclast =0, aucinf = 0), regexp = "aucpext is typically onlycalculated when aucinf is greater than auclast.“)), start_frame = 74, end_frame = 74, test =”pk.calc.aucpext“), list(message =”v2 not equal to NA.“, srcref = c(212, 3, 213, 62, 3, 62, 212, 213), expectation_calls = list(expect_equal(v2, NA, info =”aucinf<=0 gives NA_real_ (not infinity)“)), call = list(expect_equal(v2, NA, info =”aucinf<=0 gives NA_real_ (not infinity)")), start_frame = 74,
end_frame = 74,test = “pk.calc.aucpext”), list(message = "pk.calc.aucpext(NA, NA) not equal to NA.“, srcref = c(214, 3, 216, 74, 3, 74, 214, 216), expectation_calls = list(expect_equal(pk.calc.aucpext(NA, NA), NA, info =”Percent extrapolated is NA when both inputs are NA.“)), call = list(expect_equal(pk.calc.aucpext(NA, NA), NA, info =”Percent extrapolated is NA when both inputs are NA.“)), start_frame = 74, end_frame = 74, test =”pk.calc.aucpext“), list(message =”pk.calc.aucpext(NA, 1) not equal to NA.",
srcref = c(217,3, 219, 75, 3, 75, 217, 219), expectation_calls =list(expect_equal(pk.calc.aucpext(NA, 1), NA, info = “Percent extrapolated is NA when input auclast is NA.”)), call = list(expect_equal(pk.calc.aucpext(NA, 1), NA, info = “Percent extrapolated is NA when input auclast is NA.”)), start_frame = 74, end_frame = 74, test = “pk.calc.aucpext”), list(message = “pk.calc.aucpext(1, NA) not equal to NA.”, srcref = c(220, 3, 222, 74, 3, 74, 220, 222), expectation_calls = list(expect_equal(pk.calc.aucpext(1,
NA), NA, info ="Percent extrapolated is NA when input aucinf isNA.")), call = list(expect_equal(pk.calc.aucpext(1, NA), NA, info = “Percent extrapolated is NA when input aucinf is NA.”)), start_frame = 74, end_frame = 74, test = “pk.calc.aucpext”), list(message = "“, srcref = c(223, 3, 225, 71, 3, 71, 223, 225), expectation_calls = list(expect_error(pk.calc.aucpext(1:2, 1:3), regexp =”auclast and aucinf must either be a scalar or the same length.“, info =”aucpext input length checks require consistency.")),
call = list(expect_error(pk.calc.aucpext(1:2, 1:3), regexp = "auclast and aucinf must either be a scalar or the same length.“, info =”aucpext input length checks require consistency.“)), start_frame = 74, end_frame = 74, test =”pk.calc.aucpext“), list(message =”pk.calc.aucpext(c(1, NA), 2) not equal to c(50, NA_real_).“, srcref = c(226, 3, 228, 75, 3, 75, 226, 228), expectation_calls = list(expect_equal(pk.calc.aucpext(c(1, NA), 2), c(50, NA), info =”Percent extrapolated works with vector/scalar input.")),
call = list(expect_equal(pk.calc.aucpext(c(1, NA), 2), c(50, NA),info = "Percent extrapolated works with vector/scalar input.“)), start_frame = 74, end_frame = 74, test =”pk.calc.aucpext“), list(message =”pk.calc.aucpext(1, c(2, NA)) not equal to c(50, NA_real_).“, srcref = c(229, 3, 231, 75, 3, 75, 229, 231), expectation_calls = list(expect_equal(pk.calc.aucpext(1, c(2, NA)), c(50, NA), info =”Percent extrapolated works with scalar/vector input.")), call = list(expect_equal(pk.calc.aucpext(1,
c(2, NA)), c(50,NA), info = "Percent extrapolated works with scalar/vector input.")), start_frame= 74, end_frame = 74, test = “pk.calc.aucpext”), list(message = “pk.calc.aucpext(c(1, 1), c(2, NA)) not equal to c(50, NA_real_).”, srcref = c(232, 3, 234, 75, 3, 75, 232, 234), expectation_calls = list(expect_equal(pk.calc.aucpext(c(1, 1), c(2, NA)), c(50, NA), info = “Percent extrapolated works with vector/vector input.”)), call = list(expect_equal(pk.calc.aucpext(c(1, 1), c(2, NA)),
c(50, NA), info= "Percent extrapolated works with vector/vectorinput.")), start_frame =74, end_frame = 74, test = “pk.calc.aucpext”))
test-pk.calc.simple.Rpk.calc.mrt101list(list(message = “pk.calc.mrt(auc = 1, aumc = 2) not equal to 2.”, srcref = c(238, 3, 240, 50, 3, 50, 238, 240), expectation_calls = list(expect_equal(pk.calc.mrt(auc = 1, aumc = 2), 2, info = “MRT is calculated correctly”)), call = list(expect_equal(pk.calc.mrt(auc = 1, aumc = 2), 2, info = “MRT is calculated correctly”)), start_frame = 74, end_frame = 74, test = “pk.calc.mrt”))
test-pk.calc.simple.Rpk.calc.mrt.iv404list(list(message = “pk.calc.mrt.iv(auc = 1, aumc = 2, duration.dose = 1) not equal to 1.5.”, srcref = c(244, 3, 246, 53, 3, 53, 244, 246), expectation_calls = list(expect_equal(pk.calc.mrt.iv(auc = 1, aumc = 2, duration.dose = 1), 1.5, info = “MRT.iv is calculated correctly”)), call = list(expect_equal(pk.calc.mrt.iv(auc = 1, aumc = 2, duration.dose = 1), 1.5, info = “MRT.iv is calculated correctly”)), start_frame = 74, end_frame = 74, test = “pk.calc.mrt.iv”), list(message = “pk.calc.mrt.iv(auc = 1, aumc = 2, duration.dose = 0) not equal to 2.”,
srcref = c(247, 3, 249, 72, 3, 72, 247, 249), expectation_calls = list(expect_equal(pk.calc.mrt.iv(auc= 1, aumc = 2, duration.dose = 0), 2, info = “MRT.iv is calculated correctly when duration is 0”)), call = list(expect_equal(pk.calc.mrt.iv(auc = 1, aumc = 2, duration.dose = 0), 2, info = “MRT.iv is calculated correctly when duration is 0”)), start_frame = 74, end_frame = 74, test = “pk.calc.mrt.iv”), list(message = “pk.calc.mrt.iv(auc = 1, aumc = 2, duration.dose = NA) not equal to NA.”,
srcref = c(250, 3, 252, 78, 3, 78, 250, 252), expectation_calls = list(expect_equal(pk.calc.mrt.iv(auc= 1, aumc = 2, duration.dose = NA), NA, info = “MRT.iv is calculated correctly when duration is missing”)), call = list(expect_equal(pk.calc.mrt.iv(auc = 1, aumc = 2, duration.dose = NA), NA, info = “MRT.iv is calculated correctly when duration is missing”)), start_frame = 74, end_frame = 74, test = “pk.calc.mrt.iv”), list(message = “pk.calc.mrt.iv(auc = 0, aumc = 2, duration.dose = NA) not equal to NA.”,
srcref = c(253, 3, 255, 70, 3, 70, 253, 255), expectation_calls = list(expect_equal(pk.calc.mrt.iv(auc= 0, aumc = 2, duration.dose = NA), NA, info = “MRT.iv is calculated correctly when auc is zero”)), call = list(expect_equal(pk.calc.mrt.iv(auc = 0, aumc = 2, duration.dose = NA), NA, info = “MRT.iv is calculated correctly when auc is zero”)), start_frame = 74, end_frame = 74, test = “pk.calc.mrt.iv”))
test-pk.calc.simple.Rpk.calc.mrt.md202list(list(message = “pk.calc.mrt.md(1, 2, 1.5, 24) not equal to 2 + 24 * 0.5.”, srcref = c(259, 3, 259, 57, 3, 57, 259, 259), expectation_calls = list(expect_equal(pk.calc.mrt.md(1, 2, 1.5, 24), 2 + 24 * 0.5)), call = list(expect_equal(pk.calc.mrt.md(1, 2, 1.5, 24), 2 + 24 * 0.5)), start_frame = 74, end_frame = 74, test = “pk.calc.mrt.md”), list(message = “pk.calc.mrt.md(0, 2, 1.5, 24) not equal to NA.”, srcref = c(260, 3, 261, 55, 3, 55, 260, 261), expectation_calls = list(expect_equal(pk.calc.mrt.md(0,
2, 1.5, 24), NA, info = "auctau <= 0 becomes NA (not Inf)")), call =list(expect_equal(pk.calc.mrt.md(0, 2, 1.5, 24), NA, info = “auctau <= 0 becomes NA (not Inf)”)), start_frame = 74, end_frame = 74, test = “pk.calc.mrt.md”))
test-pk.calc.simple.Rpk.calc.vz13013list(list(message = “pk.calc.vz(cl = NA, lambda.z = NA) not equal to NA.”, srcref = c(266, 3, 266, 59, 3, 59, 266, 266), expectation_calls = list(expect_equal(pk.calc.vz(cl = NA, lambda.z = NA), NA)), call = list(expect_equal(pk.calc.vz(cl = NA, lambda.z = NA), NA)), start_frame = 74, end_frame = 74, test = “pk.calc.vz”), list(message = "“, srcref = c(267, 3, 268, 59, 3, 59, 267, 268), expectation_calls = list(expect_error(pk.calc.vz(cl = NA), info =”lambda.z required for Vz calculation")),
call = list(expect_error(pk.calc.vz(cl = NA), info= "lambda.z required for Vz calculation")),start_frame = 74, end_frame = 74, test = “pk.calc.vz”), list(message = "“, srcref = c(269, 3, 270, 53, 3, 53, 269, 270), expectation_calls = list(expect_error(pk.calc.vz(lambda.z = NA), info =”CL required for Vz calculation“)), call = list(expect_error(pk.calc.vz(lambda.z = NA), info =”CL required for Vz calculation“)), start_frame = 74, end_frame = 74, test =”pk.calc.vz“), list(message =”", srcref = c(273,
3, 275, 75, 3, 75, 273,275), expectation_calls = list(expect_error(pk.calc.vz(cl = 1:2, lambda.z= 1:3), regexp = “‘cl’ and ‘lambda.z’ must be the same length”, info = “CL and lambda.z must be the same length (CL shorter)”)), call = list(expect_error(pk.calc.vz(cl = 1:2, lambda.z = 1:3), regexp = “‘cl’ and ‘lambda.z’ must be the same length”, info = “CL and lambda.z must be the same length (CL shorter)”)), start_frame = 74, end_frame = 74, test = “pk.calc.vz”), list(message = "", srcref = c(276,
3, 278, 81, 3, 81, 276,278), expectation_calls = list(expect_error(pk.calc.vz(cl = 1:3, lambda.z= 1:2), regexp = “‘cl’ and ‘lambda.z’ must be the same length”, info = “CL and lambda.z must be the same length (lambda.z shorter)”)), call = list(expect_error(pk.calc.vz(cl = 1:3, lambda.z = 1:2), regexp = “‘cl’ and ‘lambda.z’ must be the same length”, info = “CL and lambda.z must be the same length (lambda.z shorter)”)), start_frame = 74, end_frame = 74, test = “pk.calc.vz”), list(message = “pk.calc.vz(cl = 1, lambda.z = 1) not equal to 1.”,
srcref = c(282, 3, 283, 37, 3, 37, 282, 283), expectation_calls = list(expect_equal(pk.calc.vz(cl = 1,lambda.z = 1), 1, info = “vz math test 1”)), call = list(expect_equal(pk.calc.vz(cl = 1, lambda.z = 1), 1, info = “vz math test 1”)), start_frame = 74, end_frame = 74, test = “pk.calc.vz”), list(message = “pk.calc.vz(cl = 1, lambda.z = 2) not equal to 0.5.”, srcref = c(284, 3, 285, 37, 3, 37, 284, 285), expectation_calls = list(expect_equal(pk.calc.vz(cl = 1, lambda.z = 2), 0.5, info = “vz math test 2”)),
call = list(expect_equal(pk.calc.vz(cl = 1, lambda.z = 2), 0.5, info= “vz math test 2”)), start_frame= 74, end_frame = 74, test = “pk.calc.vz”), list(message = “pk.calc.vz(cl = 2, lambda.z = 1) not equal to 2.”, srcref = c(286, 3, 287, 37, 3, 37, 286, 287), expectation_calls = list(expect_equal(pk.calc.vz(cl = 2, lambda.z = 1), 2, info = “vz math test 3”)), call = list(expect_equal(pk.calc.vz(cl = 2, lambda.z = 1), 2, info = “vz math test 3”)), start_frame = 74, end_frame = 74, test = “pk.calc.vz”),
list(message = "pk.calc.vz(cl = 2, lambda.z = 2) not equal to 1.al", srcref = c(288, 3, 289, 37, 3, 37, 288, 289), expectation_calls = list(expect_equal(pk.calc.vz(cl = 2, lambda.z = 2), 1, info = “vz math test 4”)), call = list(expect_equal(pk.calc.vz(cl = 2, lambda.z = 2), 1, info = “vz math test 4”)), start_frame = 74, end_frame = 74, test = “pk.calc.vz”), list(message = “pk.calc.vz(cl = NA, lambda.z = 1) not equal to NA.”, srcref = c(292, 3, 293, 46, 3, 46, 292, 293), expectation_calls = list(
expect_equal(pk.calc.vz(cl = NA, lambda.z = 1),NA, info = "Vz with missing (NA) cl")), call = list(expect_equal(pk.calc.vz(cl = NA, lambda.z = 1), NA, info = “Vz with missing (NA) cl”)), start_frame = 74, end_frame = 74, test = “pk.calc.vz”), list(message = “pk.calc.vz(cl = 1, lambda.z = NA) not equal to NA.”, srcref = c(294, 3, 295, 52, 3, 52, 294, 295), expectation_calls = list(expect_equal(pk.calc.vz(cl = 1, lambda.z = NA), NA, info = “Vz with missing (NA) lambda.z”)), call = list(
expect_equal(pk.calc.vz(cl = 1, lambda.z = NA),NA, info = "Vz with missing (NA) lambda.z")), start_frame = 74, end_frame = 74, test = “pk.calc.vz”), list(message = “pk.calc.vz(cl = NA, lambda.z = NA) not equal to NA.”, srcref = c(296, 3, 297, 59, 3, 59, 296, 297), expectation_calls = list(expect_equal(pk.calc.vz(cl = NA, lambda.z = NA), NA, info = “Vz with missing (NA) lambda.z and cl”)), call = list(expect_equal(pk.calc.vz(cl = NA, lambda.z = NA), NA, info = “Vz with missing (NA) lambda.z and cl”)),
start_frame = 74, end_frame = 74, test = "pk.calc.vz"), list(message = "pk.calc.vz(…) not equal to c(1, 0.5, NA, 2, 1, NA, NA, NA, NA).“, srcref = c(300, 3, 305, 107, 3, 107, 300, 305), expectation_calls = list(expect_equal(pk.calc.vz(cl = c(1, 1, 1, 2, 2, 2, NA, NA, NA), lambda.z = c(1, 2, NA, 1, 2, NA, 1, 2, NA)), c(1, 0.5, NA, 2, 1, NA, NA, NA, NA), info =”Vz with vector inputs including missing values for both parameters (cl and lambda.z)")), call = list(expect_equal(pk.calc.vz(cl = c(1,
1, 1, 2, 2, 2, NA, NA, NA), lambda.z = c(1, 2,NA, 1, 2, NA, 1, 2, NA)), c(1, 0.5, NA, 2,1, NA, NA, NA, NA), info = “Vz with vector inputs including missing values for both parameters (cl and lambda.z)”)), start_frame = 74, end_frame = 74, test = “pk.calc.vz”))
test-pk.calc.simple.Rpk.calc.vss and its wrappers303list(list(message = “pk.calc.vss(1, 1) not equal to 1.”, srcref = c(309, 3, 309, 36, 3, 36, 309, 309), expectation_calls = list(expect_equal(pk.calc.vss(1, 1), 1)), call = list(expect_equal(pk.calc.vss(1, 1), 1)), start_frame = 74, end_frame = 74, test = “pk.calc.vss and its wrappers”), list(message = “pk.calc.vss(2, 1) not equal to 2.”, srcref = c(310, 3, 310, 36, 3, 36, 310, 310), expectation_calls = list(expect_equal(pk.calc.vss(2, 1), 2)), call = list(expect_equal(pk.calc.vss(2,
1), 2)), start_frame= 74, end_frame = 74, test = "pk.calc.vss and its wrappers"), list(message = "pk.calc.vss(1, 2) not equal to 2.“, srcref = c(311, 3, 311, 36, 3, 36, 311, 311), expectation_calls = list(expect_equal(pk.calc.vss(1, 2), 2)), call = list(expect_equal(pk.calc.vss(1, 2), 2)), start_frame = 74, end_frame = 74, test =”pk.calc.vss and its wrappers"))
test-pk.calc.simple.Rpk.calc.vd and its wrappers808list(list(message = “pk.calc.vd(1, 2, 3) not equal to 1/6.”, srcref = c(315, 3, 316, 50, 3, 50, 315, 316), expectation_calls = list(expect_equal(pk.calc.vd(1, 2, 3), 1/6, info = “Normal Vd calculation works”)), call = list(expect_equal(pk.calc.vd(1, 2, 3), 1/6, info = “Normal Vd calculation works”)), start_frame = 74, end_frame = 74, test = “pk.calc.vd and its wrappers”), list(message = “pk.calc.vd(NA, 2, 3) not equal to NA.”, srcref = c(317, 3, 318, 64, 3, 64, 317, 318), expectation_calls = list(
expect_equal(pk.calc.vd(NA, 2, 3), NA, info = "Vd calculation returnsNA when dose is NA")), call = list(expect_equal(pk.calc.vd(NA, 2, 3), NA, info = “Vd calculation returns NA when dose is NA”)), start_frame = 74, end_frame = 74, test = “pk.calc.vd and its wrappers”), list(message = “pk.calc.vd(1, NA, 3) not equal to NA.”, srcref = c(319, 3, 320, 66, 3, 66, 319, 320), expectation_calls = list(expect_equal(pk.calc.vd(1, NA, 3), NA, info = “Vd calculation returns NA when aucinf is NA”)),
call = list(expect_equal(pk.calc.vd(1, NA, 3), NA,info = "Vd calculation returns NA when aucinf is NA")), start_frame = 74, end_frame = 74, test = “pk.calc.vd and its wrappers”), list(message = “pk.calc.vd(1, 2, NA) not equal to NA.”, srcref = c(321, 3, 322, 68, 3, 68, 321, 322), expectation_calls = list(expect_equal(pk.calc.vd(1, 2, NA), NA, info = “Vd calculation returns NA when lambda.z is NA”)), call = list(expect_equal(pk.calc.vd(1, 2, NA), NA, info = “Vd calculation returns NA when lambda.z is NA”)),
start_frame = 74, end_frame = 74, test = "pk.calc.vd and its wrappers“), list(message =”pk.calc.vd(c(1, 2), c(2, 4), c(3, 6)) not equal to c(1/6, 1/12).“, srcref = c(324, 3, 325, 87, 3, 87, 324, 325), expectation_calls = list(expect_equal(pk.calc.vd(c(1, 2), c(2, 4), c(3, 6)), c(1/6, 1/12), info =”Vd calculation works with three vector inputs returning a vector“)), call = list(expect_equal(pk.calc.vd(c(1, 2), c(2, 4), c(3, 6)), c(1/6, 1/12), info =”Vd calculation works with three vector inputs returning a vector")),
start_frame = 74, end_frame = 74, test = "pk.calc.vd and its wrappers“), list(message =”pk.calc.vd(c(1, 2), 2, 3) not equal to 0.5.“, srcref = c(326, 3, 327, 145, 3, 145, 326, 327), expectation_calls = list(expect_equal(pk.calc.vd(c(1, 2), 2, 3), 0.5, info =”Vd calculation works with vector dose and scalar aucinf and lambda.z inputs returning a scalar with the sum of doses used.“)), call = list(expect_equal(pk.calc.vd(c(1, 2), 2, 3), 0.5, info =”Vd calculation works with vector dose and scalar aucinf and lambda.z inputs returning a scalar with the sum of doses used.")),
start_frame = 74, end_frame = 74, test = "pk.calc.vd and its wrappers“), list(message =”pk.calc.vd(dose = 1, aucinf = 0, lambda.z = 1) not equal to NA.“, srcref = c(329, 3, 331, 43, 3, 43, 329, 331), expectation_calls = list(expect_equal(pk.calc.vd(dose = 1, aucinf = 0, lambda.z = 1), NA, info =”aucinf<=0 becomes NA“)), call = list(expect_equal(pk.calc.vd(dose = 1, aucinf = 0, lambda.z = 1), NA, info =”aucinf<=0 becomes NA“)), start_frame = 74, end_frame = 74, test =”pk.calc.vd and its wrappers"),
list(message = "pk.calc.vd(dose = 1, aucinf = 1, lambda.z = 0) not equal to NA.", srcref = c(332, 3, 334, 45, 3, 45, 332, 334), expectation_calls = list(expect_equal(pk.calc.vd(dose = 1, aucinf = 1, lambda.z = 0), NA, info = “lambda.z<=0 becomes NA”)), call = list(expect_equal(pk.calc.vd(dose = 1, aucinf = 1, lambda.z = 0), NA, info = “lambda.z<=0 becomes NA”)), start_frame = 74, end_frame = 74, test = “pk.calc.vd and its wrappers”))
test-pk.calc.simple.Rpk.calc.cav303list(list(message = “pk.calc.cav(2, 0, 1) not equal to 2.”, srcref = c(338, 3, 338, 39, 3, 39, 338, 338), expectation_calls = list(expect_equal(pk.calc.cav(2, 0, 1), 2)), call = list(expect_equal(pk.calc.cav(2, 0, 1), 2)), start_frame = 74, end_frame = 74, test = “pk.calc.cav”), list(message = “pk.calc.cav(NA, 0, 1) not equal to NA.”, srcref = c(339, 3, 339, 47, 3, 47, 339, 339), expectation_calls = list(expect_equal(pk.calc.cav(NA, 0, 1), NA)), call = list(expect_equal(pk.calc.cav(NA,
0, 1), NA)), start_frame = 74, end_frame = 74, test= “pk.calc.cav”),list(message = "pk.calc.cav(2, 1,1) not equal to NA.“, srcref = c(340, 3, 341, 55, 3, 55, 340, 341), expectation_calls = list(expect_equal(pk.calc.cav(2, 1, 1), NA, info =”If end == start, return NA_real_“)), call = list(expect_equal(pk.calc.cav(2, 1, 1), NA, info =”If end == start, return NA_real_“)), start_frame = 74, end_frame = 74, test =”pk.calc.cav"))
test-pk.calc.simple.Rpk.calc.ctrough404list(list(message = “pk.calc.ctrough(1:5, 0:4, 0) not equal to 1.”, srcref = c(345, 3, 346, 52, 3, 52, 345, 346), expectation_calls = list(expect_equal(pk.calc.ctrough(1:5, 0:4, 0), 1, info = “Found and it’s the first time”)), call = list(expect_equal(pk.calc.ctrough(1:5, 0:4, 0), 1, info = “Found and it’s the first time”)), start_frame = 74, end_frame = 74, test = “pk.calc.ctrough”), list(message = “pk.calc.ctrough(1:5, 0:4, 1) not equal to 2.”, srcref = c(347, 3, 348, 56, 3, 56, 347,
348), expectation_calls= list(expect_equal(pk.calc.ctrough(1:5, 0:4, 1),2, info = "Found and it’s not thefirst time“)), call = list(expect_equal(pk.calc.ctrough(1:5, 0:4, 1), 2, info =”Found and it’s not the first time“)), start_frame = 74, end_frame = 74, test =”pk.calc.ctrough“), list(message =”pk.calc.ctrough(1:5, 0:4, 1.5) not equal to NA.“, srcref = c(349, 3, 350, 32, 3, 32, 349, 350), expectation_calls = list(expect_equal(pk.calc.ctrough(1:5, 0:4, 1.5), NA, info =”Not found")),
call = list(expect_equal(pk.calc.ctrough(1:5, 0:4,1.5), NA, info = "Not found")), start_frame= 74, end_frame = 74, test = “pk.calc.ctrough”), list(message = "“, srcref = c(351, 3, 352, 62, 3, 62, 351, 352), expectation_calls = list(expect_error(pk.calc.ctrough(1:5, c(0, 0:3), 0), regexp =”Time must be monotonically increasing“)), call = list(expect_error(pk.calc.ctrough(1:5, c(0, 0:3), 0), regexp =”Time must be monotonically increasing“)), start_frame = 74, end_frame = 74, test =”pk.calc.ctrough"))
test-pk.calc.simple.Rpk.calc.ptr202list(list(message = “pk.calc.ptr(cmax = 2, ctrough = 1) not equal to 2.”, srcref = c(356, 3, 357, 64, 3, 64, 356, 357), expectation_calls = list(expect_equal(pk.calc.ptr(cmax = 2, ctrough = 1), 2, info = “Confirm that the ratio goes the right way”)), call = list(expect_equal(pk.calc.ptr(cmax = 2, ctrough = 1), 2, info = “Confirm that the ratio goes the right way”)), start_frame = 74, end_frame = 74, test = “pk.calc.ptr”), list(message = “pk.calc.ptr(2, 0) not equal to NA.”, srcref = c(358,
3, 359, 50, 3, 50, 358,359), expectation_calls = list(expect_equal(pk.calc.ptr(2, 0), NA, info ="Divisionby zero returns NA“)), call = list(expect_equal(pk.calc.ptr(2, 0), NA, info =”Division by zero returns NA“)), start_frame = 74, end_frame = 74, test =”pk.calc.ptr"))
test-pk.calc.simple.Rpk.calc.tlag404list(list(message = “pk.calc.tlag(1:5, 0:4) not equal to 0.”, srcref = c(363, 3, 364, 43, 3, 43, 363, 364), expectation_calls = list(expect_equal(pk.calc.tlag(1:5, 0:4), 0, info = “find the first point”)), call = list(expect_equal(pk.calc.tlag(1:5, 0:4), 0, info = “find the first point”)), start_frame = 74, end_frame = 74, test = “pk.calc.tlag”), list(message = “pk.calc.tlag(c(0, 0, 0, 0, 1), 0:4) not equal to 3.”, srcref = c(365, 3, 366, 50, 3, 50, 365, 366), expectation_calls = list(
expect_equal(pk.calc.tlag(c(0, 0, 0, 0, 1), 0:4), 3, info = "find thenext to last point")), call = list(expect_equal(pk.calc.tlag(c(0, 0, 0, 0, 1), 0:4), 3, info = “find the next to last point”)), start_frame = 74, end_frame = 74, test = “pk.calc.tlag”), list(message = “pk.calc.tlag(c(0, 0, 0, 0, 0), 0:4) not equal to NA.”, srcref = c(367, 3, 368, 43, 3, 43, 367, 368), expectation_calls = list(expect_equal(pk.calc.tlag(c(0, 0, 0, 0, 0), 0:4), NA, info = “No increase gives NA”)), call = list(
expect_equal(pk.calc.tlag(c(0, 0, 0, 0, 0), 0:4), NA, info = "No increase gives NA")), start_frame = 74, end_frame = 74, test = “pk.calc.tlag”), list(message = “pk.calc.tlag(5:1, 0:4) not equal to NA.”, srcref = c(369, 3, 370, 43, 3, 43, 369, 370), expectation_calls = list(expect_equal(pk.calc.tlag(5:1, 0:4), NA, info = “No increase gives NA”)), call = list(expect_equal(pk.calc.tlag(5:1, 0:4), NA, info = “No increase gives NA”)), start_frame = 74, end_frame = 74, test = “pk.calc.tlag”))
test-pk.calc.simple.Rpk.calc.deg.fluc202list(list(message = “pk.calc.deg.fluc(cmax = 100, cmin = 10, cav = 45) not equal to 200.”, srcref = c(374, 3, 375, 55, 3, 55, 374, 375), expectation_calls = list(expect_equal(pk.calc.deg.fluc(cmax = 100, cmin = 10, cav = 45), 200, info = “Degree of fluctuation math works”)), call = list(expect_equal(pk.calc.deg.fluc(cmax = 100, cmin = 10, cav = 45), 200, info = “Degree of fluctuation math works”)), start_frame = 74, end_frame = 74, test = “pk.calc.deg.fluc”), list(message = “pk.calc.deg.fluc(cmax = 100, cmin = 10, cav = 0) not equal to NA.”,
srcref = c(376, 3, 377, 66, 3, 66, 376, 377), expectation_calls = list(expect_equal(pk.calc.deg.fluc(cmax = 100, cmin = 10, cav = 0), NA, info = “Degree of fluctuation returns NA when cav=0”)), call = list(expect_equal(pk.calc.deg.fluc(cmax = 100, cmin = 10, cav = 0), NA, info = “Degree of fluctuation returns NA when cav=0”)), start_frame = 74, end_frame = 74, test = “pk.calc.deg.fluc”))
test-pk.calc.simple.Rpk.calc.swing303list(list(message = “pk.calc.swing(100, 10) not equal to 900.”, srcref = c(381, 3, 382, 39, 3, 39, 381, 382), expectation_calls = list(expect_equal(pk.calc.swing(100, 10), 900, info = “Swing math works”)), call = list(expect_equal(pk.calc.swing(100, 10), 900, info = “Swing math works”)), start_frame = 74, end_frame = 74, test = “pk.calc.swing”), list(message = “pk.calc.swing(100, 0) not equal to Inf.”, srcref = c(383, 3, 384, 45, 3, 45, 383, 384), expectation_calls = list(expect_equal(pk.calc.swing(100,
0), Inf, info = "Swing handle Ctrough=0")), call =list(expect_equal(pk.calc.swing(100, 0), Inf, info =“Swing handle Ctrough=0”)), start_frame = 74, end_frame = 74, test = “pk.calc.swing”), list(message = “pk.calc.swing(100, -1) not equal to Inf.”, srcref = c(385, 3, 386, 45, 3, 45, 385, 386), expectation_calls = list(expect_equal(pk.calc.swing(100, -1), Inf, info = “Swing handle Ctrough<0”)), call = list(expect_equal(pk.calc.swing(100, -1), Inf, info = “Swing handle Ctrough<0”)), start_frame = 74,
end_frame = 74, test= “pk.calc.swing”))
test-pk.calc.simple.Rpk.calc.ceoi303list(list(message = “pk.calc.ceoi(conc = 0:5, time = 0:5, duration.dose = 1) not equal to 1.”, srcref = c(390, 3, 392, 87, 3, 87, 390, 392), expectation_calls = list(expect_equal(pk.calc.ceoi(conc = 0:5, time = 0:5, duration.dose = 1), 1, info = “Ceoi returns the concentration at the end of the dosing duration”)), call = list(expect_equal(pk.calc.ceoi(conc = 0:5, time = 0:5, duration.dose = 1), 1, info = “Ceoi returns the concentration at the end of the dosing duration”)), start_frame = 74,
end_frame = 74, test= “pk.calc.ceoi”), list(message = "pk.calc.ceoi(conc = 0:5, time = 0:5, duration.dose = 1.5) not equal to NA.“, srcref = c(393, 3, 395, 99, 3, 99, 393, 395), expectation_calls = list(expect_equal(pk.calc.ceoi(conc = 0:5, time = 0:5, duration.dose = 1.5), NA, info =”Ceoi returns NA if there is no measurement at the end of the dosing duration“)), call = list(expect_equal(pk.calc.ceoi(conc = 0:5, time = 0:5, duration.dose = 1.5), NA, info =”Ceoi returns NA if there is no measurement at the end of the dosing duration")),
start_frame = 74, end_frame = 74, test = "pk.calc.ceoi"), list(message = "pk.calc.ceoi(conc =0:5, time= 0:5, duration.dose = NA) not equal to NA.“, srcref = c(396, 3, 398, 69, 3, 69, 396, 398), expectation_calls = list(expect_equal(pk.calc.ceoi(conc = 0:5, time = 0:5, duration.dose = NA), NA, info =”Ceoi returns NA if there is no dosing duration“)), call = list(expect_equal(pk.calc.ceoi(conc = 0:5, time = 0:5, duration.dose = NA), NA, info =”Ceoi returns NA if there is no dosing duration")),
start_frame = 74, end_frame = 74, test = "pk.calc.ceoi"))

+

+

+
Urine

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Testing FilenameTest DescriptionNumber of TestsNumber of Failed Testspassedresult
test-pk.calc.urine.Rpk.calc.ae101list(list(message = “pk.calc.ae(conc = 1:5, volume = 1:5) not equal to sum((1:5)^2).”, srcref = c(4, 3, 7, 64, 3, 64, 4, 7), expectation_calls = list(expect_equal(pk.calc.ae(conc = 1:5, volume = 1:5), sum((1:5)^2), info = “Ae is the sum of concentration and volume”)), call = list(expect_equal(pk.calc.ae(conc = 1:5, volume = 1:5), sum((1:5)^2), info = “Ae is the sum of concentration and volume”)), start_frame = 74, end_frame = 74, test = “pk.calc.ae”))
test-pk.calc.urine.Rpk.calc.clr303list(list(message = “pk.calc.clr(ae = 1, auc = 10) not equal to 0.1.”, srcref = c(11, 3, 13, 68, 3, 68, 11, 13), expectation_calls = list(expect_equal(pk.calc.clr(ae = 1, auc = 10), 0.1, info = “CLr is calculated correctly with both scalars”)), call = list(expect_equal(pk.calc.clr(ae = 1, auc = 10), 0.1, info = “CLr is calculated correctly with both scalars”)), start_frame = 74, end_frame = 74, test = “pk.calc.clr”), list(message = “pk.calc.clr(ae = c(1, 2), auc = 10) not equal to 0.3.”,
srcref = c(14, 3, 16, 84, 3, 84, 14, 16), expectation_calls = list(expect_equal(pk.calc.clr(ae = c(1, 2), auc = 10), 0.3, info = “CLr is calculated correctly with a vector Ae and a scalar AUC”)), call = list(expect_equal(pk.calc.clr(ae = c(1, 2), auc = 10), 0.3, info = “CLr is calculated correctly with a vector Ae and a scalar AUC”)), start_frame = 74, end_frame = 74, test = “pk.calc.clr”), list(message = “pk.calc.clr(ae = c(1, 2), auc = c(1, 10)) not equal to c(3, 0.3).”, srcref = c(17,
3, 19, 116, 3, 116, 17,19), expectation_calls = list(expect_equal(pk.calc.clr(ae = c(1, 2), auc = c(1, 10)), c(3, 0.3), info = “CLr is calculated correctly with both vectors (but that is not the likely calculation method)”)), call = list(expect_equal(pk.calc.clr(ae = c(1, 2), auc = c(1, 10)), c(3, 0.3), info = “CLr is calculated correctly with both vectors (but that is not the likely calculation method)”)), start_frame = 74, end_frame = 74, test = “pk.calc.clr”))
test-pk.calc.urine.Rpk.calc.fe202list(list(message = “pk.calc.fe(1, 10) not equal to 0.1.”, srcref = c(23, 3, 25, 67, 3, 67, 23, 25), expectation_calls = list(expect_equal(pk.calc.fe(1, 10), 0.1, info = “fe is calculated correctly with both scalars”)), call = list(expect_equal(pk.calc.fe(1, 10), 0.1, info = “fe is calculated correctly with both scalars”)), start_frame = 74, end_frame = 74, test = “pk.calc.fe”), list(message = “pk.calc.fe(c(1, 2), 10) not equal to 0.3.”, srcref = c(26, 3, 28, 73, 3, 73, 26, 28), expectation_calls = list(
expect_equal(pk.calc.fe(c(1, 2), 10),0.3, info = "fe iscalculated correctly with both vector/scalar“)), call = list(expect_equal(pk.calc.fe(c(1, 2), 10), 0.3, info =”fe is calculated correctly with both vector/scalar“)), start_frame = 74, end_frame = 74, test =”pk.calc.fe"))

+

+

+
PKNCA option setting

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Testing FilenameTest DescriptionNumber of TestsNumber of Failed Testspassedresult
test-PKNCA.options.RPKNCA.options92092list(list(message = "“, srcref = c(6, 3, 7, 74, 3, 74, 6, 7), expectation_calls = list(expect_error(PKNCA.options(”foo“), regexp =”PKNCA.options does not have value\(s\) for foo.“)), call = list(expect_error(PKNCA.options(”foo“), regexp =”PKNCA.options does not have value\(s\) for foo.“)), start_frame = 74, end_frame = 74, test =”PKNCA.options“), list(message =”“, srcref = c(8, 3, 9, 79, 3, 79, 8, 9), expectation_calls = list(expect_error(PKNCA.options(”foo“,”bar“), regexp =”PKNCA.options does not have value\(s\) for foo, bar.")),
call = list(expect_error(PKNCA.options("foo“,”bar"), regexp = "PKNCA.options does not have value\(s\) for foo, bar.“)), start_frame = 74, end_frame = 74, test =”PKNCA.options“), list(message =”“, srcref = c(11, 3, 12, 79, 3, 79, 11, 12), expectation_calls = list(expect_error(PKNCA.options(”foo“,”bar“,”tau.choices“), regexp =”PKNCA.options does not have value\(s\) for foo, bar.“)), call = list(expect_error(PKNCA.options(”foo“,”bar“,”tau.choices“), regexp =”PKNCA.options does not have value\(s\) for foo, bar.")),
start_frame = 74, end_frame = 74, test =“PKNCA.options”),list(message = "PKNCA.options("min.hl.points") not equal to 3.“, srcref = c(15, 3, 15, 49, 3, 49, 15, 15), expectation_calls = list(expect_equal(PKNCA.options(”min.hl.points“), 3)), call = list(expect_equal(PKNCA.options(”min.hl.points“), 3)), start_frame = 74, end_frame = 74, test =”PKNCA.options“), list(message =”PKNCA.options("min.hl.points", "min.hl.r.squared") not equal to list(min.hl.points = 3, min.hl.r.squared = 0.9).",
srcref = c(18, 3, 20, 42, 3, 42, 18, 20),expectation_calls= list(expect_equal(PKNCA.options(“min.hl.points”, “min.hl.r.squared”), list(min.hl.points = 3, min.hl.r.squared = 0.9))), call = list(expect_equal(PKNCA.options(“min.hl.points”, “min.hl.r.squared”), list(min.hl.points = 3, min.hl.r.squared = 0.9))), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = “PKNCA.options("min.hl.points", "min.hl.r.squared") not equal to list(min.hl.points = 3, min.hl.r.squared = 0.9).”,
srcref = c(22, 3, 24, 42, 3, 42, 22, 24),expectation_calls= list(expect_equal(PKNCA.options(“min.hl.points”, “min.hl.r.squared”), list(min.hl.points = 3, min.hl.r.squared = 0.9))), call = list(expect_equal(PKNCA.options(“min.hl.points”, “min.hl.r.squared”), list(min.hl.points = 3, min.hl.r.squared = 0.9))), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = “PKNCA.options(name = "single.dose.aucs") not equal to PKNCA.options("single.dose.aucs").”, srcref = c(28,
3, 29, 49, 3, 49, 28, 29), expectation_calls= list(expect_equal(PKNCA.options(name = "single.dose.aucs“), PKNCA.options(”single.dose.aucs“))), call = list(expect_equal(PKNCA.options(name =”single.dose.aucs“), PKNCA.options(”single.dose.aucs“))), start_frame = 74, end_frame = 74, test =”PKNCA.options“), list(message =”PKNCA.options("first.tmax", name = "single.dose.aucs") not equal to PKNCA.options("first.tmax", name = "single.dose.aucs").", srcref = c(32, 3, 33, 68, 3, 68, 32, 33
), expectation_calls =list(expect_equal(PKNCA.options("first.tmax“, name =”single.dose.aucs"),PKNCA.options(“first.tmax”, name = “single.dose.aucs”))), call = list(expect_equal(PKNCA.options(“first.tmax”, name = “single.dose.aucs”), PKNCA.options(“first.tmax”, name = “single.dose.aucs”))), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = "“, srcref = c(35, 3, 36, 104, 3, 104, 35, 36), expectation_calls = list(expect_error(PKNCA.options(foo =”var“, name =”foo“, value =”bar"),
regexp = "Cannot give an option name bothwith the name argument and as a named argument.")),call = list(expect_error(PKNCA.options(foo = “var”, name = “foo”, value = “bar”), regexp = “Cannot give an option name both with the name argument and as a named argument.”)), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = "“, srcref = c(39, 3, 40, 50, 3, 50, 39, 40), expectation_calls = list(expect_error(PKNCA.options(”first.tmax“, name =”min.span.ratio“, value = 2), regexp =”Invalid setting for PKNCA")),
call = list(expect_error(PKNCA.options("first.tmax", name =“min.span.ratio”, value= 2), regexp = “Invalid setting for PKNCA”)), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = "“, srcref = c(42, 3, 43, 59, 3, 59, 42, 43), expectation_calls = list(expect_error(PKNCA.options(value = 5), regexp =”Cannot have a value without a name“)), call = list(expect_error(PKNCA.options(value = 5), regexp =”Cannot have a value without a name")), start_frame = 74, end_frame = 74,
test = "PKNCA.options“), list(message =”", srcref = c(45,3, 46, 62, 3, 62, 45, 46), expectation_calls = list(expect_error(PKNCA.options(“adj.r.squared.factor”, default = TRUE, check = TRUE), regexp = “Cannot request both default and check”)), call = list(expect_error(PKNCA.options(“adj.r.squared.factor”, default = TRUE, check = TRUE), regexp = “Cannot request both default and check”)), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = "", srcref = c(48, 3, 49, 62, 3,
62, 48, 49), expectation_calls = list(expect_error(PKNCA.options(adj.r.squared.factor =0.1, default = TRUE, check = TRUE), regexp = “Cannot request both default and check”)), call = list(expect_error(PKNCA.options(adj.r.squared.factor = 0.1, default = TRUE, check = TRUE), regexp = “Cannot request both default and check”)), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = "", srcref = c(51, 3, 52, 62, 3, 62, 51, 52), expectation_calls = list(expect_error(PKNCA.options(adj.r.squared.factor = 0.1,
max.aucinf.pext = 15, check = TRUE), regexp = "Must give exactly one option to check")), call= list(expect_error(PKNCA.options(adj.r.squared.factor = 0.1, max.aucinf.pext = 15, check = TRUE), regexp = “Must give exactly one option to check”)), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = “PKNCA.options() not equal to list(…).”, srcref = c(57, 3, 81, 47, 3, 47, 57, 81), expectation_calls = list(expect_equal(PKNCA.options(), list(adj.r.squared.factor = 1e-04,
max.missing = 0.5,auc.method = "lin up/log down", conc.na= “drop”, conc.blq = list(first =“keep”, middle = “drop”, last = “keep”), first.tmax = TRUE, allow.tmax.in.half.life = FALSE, min.hl.points = 3, min.span.ratio = 2, max.aucinf.pext = 20, min.hl.r.squared = 0.9, tau.choices = NA, single.dose.aucs = check.interval.specification(data.frame(start = 0, end = c(24, Inf), auclast = c(TRUE, FALSE), aucinf.obs = c(FALSE, TRUE), half.life = c(FALSE, TRUE), tmax = c(FALSE, TRUE), cmax = c(FALSE,
TRUE)))))), call = list(expect_equal(PKNCA.options(), list(adj.r.squared.factor= 1e-04,max.missing = 0.5, auc.method = “lin up/log down”, conc.na = “drop”, conc.blq = list(first = “keep”, middle = “drop”, last = “keep”), first.tmax = TRUE, allow.tmax.in.half.life = FALSE, min.hl.points = 3, min.span.ratio = 2, max.aucinf.pext = 20, min.hl.r.squared = 0.9, tau.choices = NA, single.dose.aucs = check.interval.specification(data.frame(start = 0, end = c(24, Inf), auclast = c(TRUE, FALSE), aucinf.obs = c(FALSE,
TRUE), half.life =c(FALSE, TRUE), tmax =c(FALSE, TRUE), cmax = c(FALSE, TRUE)))))), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = "“, srcref = c(86, 3, 87, 62, 3, 62, 86, 87), expectation_calls = list(expect_error(PKNCA.options(adj.r.squared.factor = c(0.1, 0.9), check = TRUE), regexp =”adj.r.squared.factor must be a scalar“)), call = list(expect_error(PKNCA.options(adj.r.squared.factor = c(0.1, 0.9), check = TRUE), regexp =”adj.r.squared.factor must be a scalar")),
start_frame = 74, end_frame = 74, test =“PKNCA.options”),list(message = "", srcref= c(88,3, 89, 80, 3, 80, 88, 89), expectation_calls = list(expect_error(PKNCA.options(adj.r.squared.factor = 1, check = TRUE), regexp = “adj.r.squared.factor must be between 0 and 1, exclusive”)), call = list(expect_error(PKNCA.options(adj.r.squared.factor = 1, check = TRUE), regexp = “adj.r.squared.factor must be between 0 and 1, exclusive”)), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(
message = "", srcref = c(90, 3, 91, 80, 3, 80, 90, 91), expectation_calls = list(expect_error(PKNCA.options(adj.r.squared.factor = 0, check = TRUE), regexp = “adj.r.squared.factor must be between 0 and 1, exclusive”)), call = list(expect_error(PKNCA.options(adj.r.squared.factor = 0, check = TRUE), regexp = “adj.r.squared.factor must be between 0 and 1, exclusive”)), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = "", srcref = c(92, 3, 93, 84, 3, 84, 92, 93), expectation_calls = list(
expect_error(PKNCA.options(adj.r.squared.factor = “A”, check = TRUE), regexp = "adj.r.squared.factor must be numeric \(and not a factor\)“)), call = list(expect_error(PKNCA.options(adj.r.squared.factor =”A“, check = TRUE), regexp =”adj.r.squared.factor must be numeric \(and not a factor\)“)), start_frame = 74, end_frame = 74, test =”PKNCA.options“), list(message =”", srcref = c(94, 3, 94, 75, 3, 75, 94, 94), expectation_calls = list(expect_warning(v1 <- PKNCA.options(adj.r.squared.factor = 0.9,
check = TRUE))), call = list(expect_warning(v1 <- PKNCA.options(adj.r.squared.factor= 0.9, check = TRUE))), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = “v1 not equal to 0.9.”, srcref = c(95, 3, 95, 23, 3, 23, 95, 95), expectation_calls = list(expect_equal(v1, 0.9)), call = list(expect_equal(v1, 0.9)), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = "", srcref = c(96, 3, 97, 64, 3, 64, 96, 97), expectation_calls = list(expect_warning(PKNCA.options(adj.r.squared.factor = 0.9,
check = TRUE), regexp = "adj.r.squared.factor is usually <0.01")), call = list(expect_warning(PKNCA.options(adj.r.squared.factor = 0.9, check = TRUE), regexp = “adj.r.squared.factor is usually <0.01”)), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = "“, srcref = c(100, 3, 101, 53, 3, 53, 100, 101), expectation_calls = list(expect_error(PKNCA.options(max.missing = c(1, 2), check = TRUE), regexp =”max.missing must be a scalar")), call = list(expect_error(PKNCA.options(max.missing = c(1,
2), check = TRUE),regexp = "max.missingmust be a scalar")), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = "“, srcref = c(102, 3, 103, 75, 3, 75, 102, 103), expectation_calls = list(expect_error(PKNCA.options(max.missing =”A“, check = TRUE), regexp =”max.missing must be numeric \(and not a factor\)“)), call = list(expect_error(PKNCA.options(max.missing =”A“, check = TRUE), regexp =”max.missing must be numeric \(and not a factor\)")), start_frame = 74, end_frame = 74,
test = "PKNCA.options“), list(message =”", srcref = c(104,3, 105, 60, 3, 60, 104,105), expectation_calls = list(expect_error(PKNCA.options(max.missing = -1, check = TRUE), regexp = “max.missing must be between 0 and 1”)), call = list(expect_error(PKNCA.options(max.missing = -1, check = TRUE), regexp = “max.missing must be between 0 and 1”)), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = "", srcref = c(106, 3, 107, 60, 3, 60, 106, 107), expectation_calls = list(expect_error(PKNCA.options(max.missing = 1,
check = TRUE), regexp = "max.missing mustbe between 0 and1")), call = list(expect_error(PKNCA.options(max.missing = 1, check = TRUE), regexp = “max.missing must be between 0 and 1”)), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = “PKNCA.options(max.missing = 0, check = TRUE) not equal to 0.”, srcref = c(108, 3, 109, 17, 3, 17, 108, 109), expectation_calls = list(expect_equal(PKNCA.options(max.missing = 0, check = TRUE), 0)), call = list(expect_equal(PKNCA.options(max.missing = 0,
check = TRUE), 0)),start_frame = 74, end_frame = 74, test= “PKNCA.options”), list(message =“PKNCA.options(max.missing = 0.2, check = TRUE) not equal to 0.2.”, srcref = c(110, 3, 111, 19, 3, 19, 110, 111), expectation_calls = list(expect_equal(PKNCA.options(max.missing = 0.2, check = TRUE), 0.2)), call = list(expect_equal(PKNCA.options(max.missing = 0.2, check = TRUE), 0.2)), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = "", srcref = c(112, 3, 113, 56, 3,
56, 112, 113), expectation_calls = list(expect_warning(PKNCA.options(max.missing = 0.6,check = TRUE), regexp = “max.missing is usually <= 0.5”)), call = list(expect_warning(PKNCA.options(max.missing = 0.6, check = TRUE), regexp = “max.missing is usually <= 0.5”)), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = “PKNCA.options(auc.method = "linear", check = TRUE) not equal to "linear".”, srcref = c(117, 3, 119, 60, 3, 60, 117, 119), expectation_calls = list(expect_equal(PKNCA.options(auc.method = “linear”,
check = TRUE), "linear“, info =”auc.method selection worksfor linear")), call = list(expect_equal(PKNCA.options(auc.method = “linear”, check = TRUE), “linear”, info = “auc.method selection works for linear”)), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = “PKNCA.options(auc.method = "lin up/log down", check = TRUE) not equal to "lin up/log down".”, srcref = c(120, 3, 122, 69, 3, 69, 120, 122), expectation_calls = list(expect_equal(PKNCA.options(auc.method = “lin up/log down”,
check = TRUE), "linup/log down", info ="auc.method selection works for lin up/logdown")),call = list(expect_equal(PKNCA.options(auc.method = “lin up/log down”, check = TRUE), “lin up/log down”, info = “auc.method selection works for lin up/log down”)), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = "“, srcref = c(123, 3, 125, 51, 3, 51, 123, 125), expectation_calls = list(expect_error(PKNCA.options(auc.method =”foo“, check = TRUE), regex =”should be one of“, info =”auc.method is a valid method")),
call = list(expect_error(PKNCA.options(auc.method = “foo”,check = TRUE), regex = "should beone of“, info =”auc.method is a valid method“)), start_frame = 74, end_frame = 74, test =”PKNCA.options“), list(message =”PKNCA.options(conc.na = "drop", check = TRUE) not equal to "drop".“, srcref = c(128, 3, 129, 22, 3, 22, 128, 129), expectation_calls = list(expect_equal(PKNCA.options(conc.na =”drop“, check = TRUE),”drop“)), call = list(expect_equal(PKNCA.options(conc.na =”drop", check = TRUE),
“drop”)), start_frame = 74, end_frame = 74, test = "PKNCA.options"), list(message ="", srcref = c(130, 3, 131, 77, 3, 77, 130, 131), expectation_calls = list(expect_warning(v1 <- PKNCA.options(conc.na = factor(“drop”), check = TRUE), regexp = “conc.na may not be a factor; attempting conversion”)), call = list(expect_warning(v1 <- PKNCA.options(conc.na = factor(“drop”), check = TRUE), regexp = “conc.na may not be a factor; attempting conversion”)), start_frame = 74, end_frame = 74, test = “PKNCA.options”),
list(message = "`v1` not equal to "drop\“.”, srcref= c(132, 3, 132, 26, 3,26, 132,132), expectation_calls = list(expect_equal(v1, “drop”)), call = list(expect_equal(v1, “drop”)), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = "“, srcref = c(133, 3, 134, 77, 3, 77, 133, 134), expectation_calls = list(expect_warning(PKNCA.options(conc.na = factor(”drop“), check = TRUE), regexp =”conc.na may not be a factor; attempting conversion“)), call = list(expect_warning(PKNCA.options(conc.na = factor(”drop"),
check = TRUE),regexp = "conc.na maynot be a factor; attempting conversion")),start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = “PKNCA.options(conc.na = 1, check = TRUE) not equal to 1.”, srcref = c(135, 3, 136, 17, 3, 17, 135, 136), expectation_calls = list(expect_equal(PKNCA.options(conc.na = 1, check = TRUE), 1)), call = list(expect_equal(PKNCA.options(conc.na = 1, check = TRUE), 1)), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = "",
srcref = c(137,3, 138, 53, 3, 53, 137, 138), expectation_calls = list(expect_warning(v1<- PKNCA.options(conc.na = -1, check = TRUE), regexp = “conc.na is usually not < 0”)), call = list(expect_warning(v1 <- PKNCA.options(conc.na = -1, check = TRUE), regexp = “conc.na is usually not < 0”)), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = “v1 not equal to -1.”, srcref = c(139, 3, 139, 22, 3, 22, 139, 139), expectation_calls = list(expect_equal(v1, -1)),
call = list(expect_equal(v1, -1)), start_frame = 74, end_frame = 74, test = "PKNCA.options“), list(message =”“, srcref = c(140, 3, 141, 53, 3, 53, 140, 141), expectation_calls = list(expect_warning(PKNCA.options(conc.na = -1, check = TRUE), regexp =”conc.na is usually not < 0“)), call = list(expect_warning(PKNCA.options(conc.na = -1, check = TRUE), regexp =”conc.na is usually not < 0“)), start_frame = 74, end_frame = 74, test =”PKNCA.options“), list(message =”", srcref = c(142, 3, 143,
62, 3, 62, 142, 143), expectation_calls =list(expect_error(PKNCA.options(conc.na =Inf, check = TRUE), regexp = “When a number, conc.na must be finite”)), call = list(expect_error(PKNCA.options(conc.na = Inf, check = TRUE), regexp = “When a number, conc.na must be finite”)), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = "“, srcref = c(144, 3, 145, 82, 3, 82, 144, 145), expectation_calls = list(expect_error(PKNCA.options(conc.na =”foo“, check = TRUE), regexp =”conc.na must either be a finite number or the text ‘drop’")),
call = list(expect_error(PKNCA.options(conc.na = “foo”,check = TRUE), regexp ="conc.namust either be a finite number or the text ‘drop’“)), start_frame = 74, end_frame = 74, test =”PKNCA.options“), list(message =”PKNCA.options(conc.blq = "drop", check = TRUE) not equal to "drop".“, srcref = c(149, 3, 150, 22, 3, 22, 149, 150), expectation_calls = list(expect_equal(PKNCA.options(conc.blq =”drop“, check = TRUE),”drop“)), call = list(expect_equal(PKNCA.options(conc.blq =”drop",
check = TRUE),“drop”)), start_frame= 74, end_frame =74, test = "PKNCA.options"), list(message = “PKNCA.options(conc.blq = "keep", check = TRUE) not equal to "keep".”, srcref = c(151, 3, 152, 22, 3, 22, 151, 152), expectation_calls = list(expect_equal(PKNCA.options(conc.blq = “keep”, check = TRUE), “keep”)), call = list(expect_equal(PKNCA.options(conc.blq = “keep”, check = TRUE), “keep”)), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = “PKNCA.options(conc.blq = 0, check = TRUE) not equal to 0.”,
srcref = c(153,3, 154, 17, 3, 17, 153, 154), expectation_calls = list(expect_equal(PKNCA.options(conc.blq = 0, check = TRUE), 0)), call = list(expect_equal(PKNCA.options(conc.blq = 0, check = TRUE), 0)), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = “PKNCA.options(conc.blq = 1, check = TRUE) not equal to 1.”, srcref = c(155, 3, 156, 17, 3, 17, 155, 156), expectation_calls = list(expect_equal(PKNCA.options(conc.blq = 1, check = TRUE), 1)), call = list(expect_equal(PKNCA.options(conc.blq = 1,
check = TRUE),1)), start_frame = 74,end_frame = 74, test = “PKNCA.options”), list(message = "“, srcref = c(157, 3, 158, 71, 3, 71, 157, 158), expectation_calls = list(expect_warning(v1 <- PKNCA.options(conc.blq = factor(”drop“), check = TRUE),”conc.blq may not be a factor; attempting conversion“)), call = list(expect_warning(v1 <- PKNCA.options(conc.blq = factor(”drop“), check = TRUE),”conc.blq may not be a factor; attempting conversion“)), start_frame = 74, end_frame = 74, test =”PKNCA.options"),
list(message = "`v1` not equal to "drop\“.”, srcref= c(159, 3, 159, 26, 3,26, 159,159), expectation_calls = list(expect_equal(v1, “drop”)), call = list(expect_equal(v1, “drop”)), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = "“, srcref = c(160, 3, 161, 93, 3, 93, 160, 161), expectation_calls = list(expect_error(PKNCA.options(conc.blq =”foo“, check = TRUE), regexp =”conc.blq must either be a finite number or the text ‘drop’ or ‘keep’“)), call = list(expect_error(PKNCA.options(conc.blq =”foo",
check = TRUE),regexp = "conc.blq must either be a finite number or the text ’drop’ or ’keep’“)), start_frame = 74, end_frame = 74, test =”PKNCA.options“), list(message =”“, srcref = c(162, 3, 163, 50, 3, 50, 162, 163), expectation_calls = list(expect_error(PKNCA.options(conc.blq = c(1, 2), check = TRUE), regexp =”conc.blq must be a scalar“)), call = list(expect_error(PKNCA.options(conc.blq = c(1, 2), check = TRUE), regexp =”conc.blq must be a scalar")), start_frame = 74, end_frame = 74,
test = "PKNCA.options"), list(message= "", srcref = c(164, 3, 165, 48, 3, 48, 164, 165),expectation_calls = list(expect_error(PKNCA.options(conc.blq = NA, check = TRUE), regexp = “conc.blq must not be NA”)), call = list(expect_error(PKNCA.options(conc.blq = NA, check = TRUE), regexp = “conc.blq must not be NA”)), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = “PKNCA.options(…) not equal to list(first = "drop", middle = 5, last = "keep").”, srcref = c(168,
3, 170, 57, 3, 57,168, 170), expectation_calls = list(expect_equal(PKNCA.options(conc.blq =list(first = “drop”, middle = 5, last = “keep”), check = TRUE), list(first = “drop”, middle = 5, last = “keep”))), call = list(expect_equal(PKNCA.options(conc.blq = list(first = “drop”, middle = 5, last = “keep”), check = TRUE), list(first = “drop”, middle = 5, last = “keep”))), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = "", srcref = c(171, 3, 174, 116, 3, 116, 171, 174),
expectation_calls = list(expect_error(PKNCA.options(conc.blq = list(first = "drop", middle = 5, last = “keep”, foo = 5), check = TRUE), regexp = “When given as a list, conc.blq must only have elements named ‘first’, ‘middle’, and ‘last’.”)), call = list(expect_error(PKNCA.options(conc.blq = list(first = “drop”, middle = 5, last = “keep”, foo = 5), check = TRUE), regexp = “When given as a list, conc.blq must only have elements named ‘first’, ‘middle’, and ‘last’.”)), start_frame = 74, end_frame = 74,
test = "PKNCA.options"), list(message= "", srcref = c(175, 3, 177, 114, 3, 114,175, 177), expectation_calls = list(expect_error(PKNCA.options(conc.blq = list(first = “drop”, middle = 5), check = TRUE), regexp = “When given as a list, conc.blq must include elements named ‘first’, ‘middle’, and ‘last’.”)), call = list(expect_error(PKNCA.options(conc.blq = list(first = “drop”, middle = 5), check = TRUE), regexp = “When given as a list, conc.blq must include elements named ‘first’, ‘middle’, and ‘last’.”)),
start_frame = 74, end_frame = 74, test = "PKNCA.options“), list(message =”PKNCA.options(first.tmax = FALSE, check = TRUE) not equal to FALSE.“, srcref = c(180, 3, 181, 21, 3, 21, 180, 181), expectation_calls = list(expect_equal(PKNCA.options(first.tmax = FALSE, check = TRUE), FALSE)), call = list(expect_equal(PKNCA.options(first.tmax = FALSE, check = TRUE), FALSE)), start_frame = 74, end_frame = 74, test =”PKNCA.options“), list(message =”", srcref = c(182, 3, 183, 52, 3, 52, 182,
183), expectation_calls = list(expect_error(PKNCA.options(first.tmax = c(FALSE, TRUE), check= TRUE), regexp = “first.tmax must be a scalar”)), call = list(expect_error(PKNCA.options(first.tmax = c(FALSE, TRUE), check = TRUE), regexp = “first.tmax must be a scalar”)), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = "“, srcref = c(185, 3, 186, 73, 3, 73, 185, 186), expectation_calls = list(expect_warning(v1 <- PKNCA.options(first.tmax =”T“, check = TRUE), regexp =”Converting first.tmax to a logical value: TRUE")),
call = list(expect_warning(v1 <- PKNCA.options(first.tmax = “T”, check = TRUE),regexp =“Converting first.tmax to a logical value: TRUE”)), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = “v1 not equal to TRUE.”, srcref = c(187, 3, 187, 24, 3, 24, 187, 187), expectation_calls = list(expect_equal(v1, TRUE)), call = list(expect_equal(v1, TRUE)), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = "", srcref = c(188, 3, 189, 73, 3, 73,
188, 189), expectation_calls = list(expect_warning(v1 <- PKNCA.options(first.tmax =1, check= TRUE), regexp = “Converting first.tmax to a logical value: TRUE”)), call = list(expect_warning(v1 <- PKNCA.options(first.tmax = 1, check = TRUE), regexp = “Converting first.tmax to a logical value: TRUE”)), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = “v1 not equal to TRUE.”, srcref = c(190, 3, 190, 24, 3, 24, 190, 190), expectation_calls = list(expect_equal(v1,
TRUE)), call =list(expect_equal(v1,TRUE)), start_frame = 74, end_frame = 74, test = "PKNCA.options“), list(message =”“, srcref = c(191, 3, 192, 49, 3, 49, 191, 192), expectation_calls = list(expect_error(PKNCA.options(first.tmax = NA, check = TRUE), regexp =”first.tmax may not be NA“)), call = list(expect_error(PKNCA.options(first.tmax = NA, check = TRUE), regexp =”first.tmax may not be NA“)), start_frame = 74, end_frame = 74, test =”PKNCA.options“), list(message =”", srcref = c(193,
3, 194, 72, 3, 72,193, 194), expectation_calls = list(expect_error(PKNCA.options(first.tmax= “x”, check = TRUE), regexp = “Could not convert first.tmax to a logical value”)), call = list(expect_error(PKNCA.options(first.tmax = “x”, check = TRUE), regexp = “Could not convert first.tmax to a logical value”)), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = “PKNCA.options(min.hl.points = 3, check = TRUE) not equal to 3.”, srcref = c(197, 3, 198, 17, 3, 17, 197,
198), expectation_calls = list(expect_equal(PKNCA.options(min.hl.points = 3, check =TRUE), 3)), call = list(expect_equal(PKNCA.options(min.hl.points = 3, check = TRUE), 3)), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = "“, srcref = c(199, 3, 200, 55, 3, 55, 199, 200), expectation_calls = list(expect_error(PKNCA.options(min.hl.points = c(3, 4), check = TRUE), regexp =”min.hl.points must be a scalar")), call = list(expect_error(PKNCA.options(min.hl.points = c(3, 4),
check = TRUE),regexp = "min.hl.points must be a scalar")), start_frame = 74, end_frame =74, test = “PKNCA.options”), list(message = "“, srcref = c(201, 3, 202, 57, 3, 57, 201, 202), expectation_calls = list(expect_error(PKNCA.options(min.hl.points = factor(3), check = TRUE), regexp =”min.hl.points cannot be a factor“)), call = list(expect_error(PKNCA.options(min.hl.points = factor(3), check = TRUE), regexp =”min.hl.points cannot be a factor“)), start_frame = 74, end_frame = 74, test =”PKNCA.options"),
list(message = "",srcref = c(203, 3, 204, 55, 3, 55, 203,204), expectation_calls =list(expect_error(PKNCA.options(min.hl.points = “a”, check = TRUE), regexp = “min.hl.points must be a number”)), call = list(expect_error(PKNCA.options(min.hl.points = “a”, check = TRUE), regexp = “min.hl.points must be a number”)), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = "", srcref = c(205, 3, 206, 50, 3, 50, 205, 206), expectation_calls = list(expect_error(PKNCA.options(min.hl.points = 1.5,
check = TRUE),regexp = "min.hl.points must be >=2")),call = list(expect_error(PKNCA.options(min.hl.points = 1.5, check = TRUE), regexp = “min.hl.points must be >=2”)), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = "“, srcref = c(207, 3, 208, 91, 3, 91, 207, 208), expectation_calls = list(expect_warning(v1 <- PKNCA.options(min.hl.points = 2.5, check = TRUE), regexp =”Non-integer given for min.hl.points; rounding to nearest integer")), call = list(expect_warning(v1 <- PKNCA.options(min.hl.points = 2.5,
check = TRUE),regexp = "Non-integergiven for min.hl.points; rounding to nearest integer“)), start_frame = 74, end_frame = 74, test =”PKNCA.options“), list(message =”v1 not equal to 2.“, srcref = c(210, 3, 210, 21, 3, 21, 210, 210), expectation_calls = list(expect_equal(v1, 2)), call = list(expect_equal(v1, 2)), start_frame = 74, end_frame = 74, test =”PKNCA.options“), list(message =”PKNCA.options(min.span.ratio = 2, check = TRUE) not equal to 2.", srcref = c(213, 3,
214, 17, 3, 17, 213, 214), expectation_calls = list(expect_equal(PKNCA.options(min.span.ratio= 2, check = TRUE), 2)), call = list(expect_equal(PKNCA.options(min.span.ratio = 2, check = TRUE), 2)), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = "“, srcref = c(215, 3, 216, 51, 3, 51, 215, 216), expectation_calls = list(expect_error(PKNCA.options(min.span.ratio = 0, check = TRUE), regexp =”min.span.ratio must be > 0")), call = list(expect_error(PKNCA.options(min.span.ratio = 0,
check = TRUE),regexp = "min.span.ratio must be > 0")),start_frame = 74, end_frame = 74,test = “PKNCA.options”), list(message = "“, srcref = c(217, 3, 218, 56, 3, 56, 217, 218), expectation_calls = list(expect_error(PKNCA.options(min.span.ratio = c(2, 1), check = TRUE), regexp =”min.span.ratio must be a scalar“)), call = list(expect_error(PKNCA.options(min.span.ratio = c(2, 1), check = TRUE), regexp =”min.span.ratio must be a scalar“)), start_frame = 74, end_frame = 74, test =”PKNCA.options"),
list(message = "",srcref = c(219, 3, 220, 58, 3, 58, 219,220), expectation_calls =list(expect_error(PKNCA.options(min.span.ratio = factor(1), check = TRUE), regexp = “min.span.ratio cannot be a factor”)), call = list(expect_error(PKNCA.options(min.span.ratio = factor(1), check = TRUE), regexp = “min.span.ratio cannot be a factor”)), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = "“, srcref = c(221, 3, 222, 56, 3, 56, 221, 222), expectation_calls = list(expect_error(PKNCA.options(min.span.ratio =”a",
check = TRUE),regexp = "min.span.ratio must be a number")), call = list(expect_error(PKNCA.options(min.span.ratio = “a”, check = TRUE), regexp = “min.span.ratio must be a number”)), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = "“, srcref = c(223, 3, 224, 57, 3, 57, 223, 224), expectation_calls = list(expect_warning(PKNCA.options(min.span.ratio = 1, check = TRUE), regexp =”min.span.ratio is usually >= 2")), call = list(expect_warning(PKNCA.options(min.span.ratio = 1,
check = TRUE),regexp = "min.span.ratio is usually >= 2")), start_frame = 74, end_frame =74, test = “PKNCA.options”), list(message = “PKNCA.options(max.aucinf.pext = 20, check = TRUE) not equal to 20.”, srcref = c(227, 3, 228, 18, 3, 18, 227, 228), expectation_calls = list(expect_equal(PKNCA.options(max.aucinf.pext = 20, check = TRUE), 20)), call = list(expect_equal(PKNCA.options(max.aucinf.pext = 20, check = TRUE), 20)), start_frame = 74, end_frame = 74, test = “PKNCA.options”),
list(message = "",srcref = c(229, 3, 230, 52, 3, 52, 229,230), expectation_calls =list(expect_error(PKNCA.options(max.aucinf.pext = 0, check = TRUE), regexp = “max.aucinf.pext must be > 0”)), call = list(expect_error(PKNCA.options(max.aucinf.pext = 0, check = TRUE), regexp = “max.aucinf.pext must be > 0”)), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = "", srcref = c(231, 3, 232, 57, 3, 57, 231, 232), expectation_calls = list(expect_error(PKNCA.options(max.aucinf.pext = c(2,
1), check = TRUE), regexp = "max.aucinf.pext must be ascalar")), call = list(expect_error(PKNCA.options(max.aucinf.pext = c(2, 1), check = TRUE), regexp = “max.aucinf.pext must be a scalar”)), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = "“, srcref = c(233, 3, 234, 59, 3, 59, 233, 234), expectation_calls = list(expect_error(PKNCA.options(max.aucinf.pext = factor(1), check = TRUE), regexp =”max.aucinf.pext cannot be a factor")), call = list(expect_error(PKNCA.options(max.aucinf.pext = factor(1),
check = TRUE),regexp = "max.aucinf.pext cannot be a factor")), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = "“, srcref = c(235, 3, 236, 57, 3, 57, 235, 236), expectation_calls = list(expect_error(PKNCA.options(max.aucinf.pext =”a“, check = TRUE), regexp =”max.aucinf.pext must be a number“)), call = list(expect_error(PKNCA.options(max.aucinf.pext =”a“, check = TRUE), regexp =”max.aucinf.pext must be a number“)), start_frame = 74, end_frame = 74, test =”PKNCA.options"),
list(message = "",srcref = c(237, 3, 238, 58, 3, 58, 237,238), expectation_calls =list(expect_warning(PKNCA.options(max.aucinf.pext = 25.1, check = TRUE), regexp = “max.aucinf.pext is usually <=25”)), call = list(expect_warning(PKNCA.options(max.aucinf.pext = 25.1, check = TRUE), regexp = “max.aucinf.pext is usually <=25”)), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = "", srcref = c(239, 3, 240, 96, 3, 96, 239, 240), expectation_calls = list(expect_warning(PKNCA.options(max.aucinf.pext = 0.1,
check = TRUE),regexp = "max.aucinf.pext is on the percent not ratio scale, value given is <1%“)), call = list(expect_warning(PKNCA.options(max.aucinf.pext = 0.1, check = TRUE), regexp =”max.aucinf.pext is on the percent not ratio scale, value given is <1%“)), start_frame = 74, end_frame = 74, test =”PKNCA.options“), list(message =”PKNCA.options(min.hl.r.squared = 0.9, check = TRUE) not equal to 0.9.", srcref = c(243, 3, 244, 19, 3, 19, 243, 244), expectation_calls = list(expect_equal(PKNCA.options(min.hl.r.squared = 0.9,
check = TRUE),0.9)), call = list(expect_equal(PKNCA.options(min.hl.r.squared =0.9, check = TRUE), 0.9)), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = "“, srcref = c(245, 3, 246, 76, 3, 76, 245, 246), expectation_calls = list(expect_error(PKNCA.options(min.hl.r.squared = 0, check = TRUE), regexp =”min.hl.r.squared must be between 0 and 1, exclusive“)), call = list(expect_error(PKNCA.options(min.hl.r.squared = 0, check = TRUE), regexp =”min.hl.r.squared must be between 0 and 1, exclusive")),
start_frame = 74, end_frame = 74, test = "PKNCA.options“), list(message =”", srcref = c(247, 3, 248, 58, 3, 58, 247, 248), expectation_calls = list(expect_error(PKNCA.options(min.hl.r.squared = c(2, 1), check = TRUE), regexp = “min.hl.r.squared must be a scalar”)), call = list(expect_error(PKNCA.options(min.hl.r.squared = c(2, 1), check = TRUE), regexp = “min.hl.r.squared must be a scalar”)), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = "", srcref = c(249, 3,
250, 60, 3, 60, 249, 250), expectation_calls = list(expect_error(PKNCA.options(min.hl.r.squared = factor(1), check = TRUE), regexp = “min.hl.r.squared cannot be a factor”)), call = list(expect_error(PKNCA.options(min.hl.r.squared = factor(1), check = TRUE), regexp = “min.hl.r.squared cannot be a factor”)), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = "“, srcref = c(251, 3, 252, 58, 3, 58, 251, 252), expectation_calls = list(expect_error(PKNCA.options(min.hl.r.squared =”a",
check = TRUE),regexp = "min.hl.r.squared must be a number")), call = list(expect_error(PKNCA.options(min.hl.r.squared = “a”, check = TRUE), regexp = “min.hl.r.squared must be a number”)), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = "“, srcref = c(253, 3, 254, 61, 3, 61, 253, 254), expectation_calls = list(expect_warning(PKNCA.options(min.hl.r.squared = 0.89, check = TRUE), regexp =”min.hl.r.squared is usually >= 0.9")), call = list(expect_warning(PKNCA.options(min.hl.r.squared = 0.89,
check = TRUE),regexp = "min.hl.r.squared is usually >=0.9")), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = “PKNCA.options(tau.choices = NA, check = TRUE) not equal to NA.”, srcref = c(257, 3, 258, 18, 3, 18, 257, 258), expectation_calls = list(expect_equal(PKNCA.options(tau.choices = NA, check = TRUE), NA)), call = list(expect_equal(PKNCA.options(tau.choices = NA, check = TRUE), NA)), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = “PKNCA.options(tau.choices = c(1, 2), check = TRUE) not equal to c(1, 2).”,
srcref = c(259,3, 260, 23, 3, 23, 259, 260), expectation_calls = list(expect_equal(PKNCA.options(tau.choices = c(1, 2), check = TRUE), c(1, 2))), call = list(expect_equal(PKNCA.options(tau.choices = c(1, 2), check = TRUE), c(1, 2))), start_frame = 74, end_frame = 74, test = “PKNCA.options”), list(message = "“, srcref = c(261, 3, 262, 71, 3, 71, 261, 262), expectation_calls = list(expect_error(PKNCA.options(tau.choices = c(NA, 1), check = TRUE), regexp =”tau.choices may not include NA and be a vector")),
call = list(expect_error(PKNCA.options(tau.choices = c(NA, 1), check = TRUE), regexp = "tau.choices may not include NA and be a vector“)), start_frame = 74, end_frame = 74, test =”PKNCA.options“), list(message =”“, srcref = c(263, 3, 264, 53, 3, 53, 263, 264), expectation_calls = list(expect_error(PKNCA.options(tau.choices =”x“, check = TRUE), regexp =”tau.choices must be a number“)), call = list(expect_error(PKNCA.options(tau.choices =”x“, check = TRUE), regexp =”tau.choices must be a number")),
start_frame = 74, end_frame = 74, test = "PKNCA.options"))
test-PKNCA.options.RPKNCA.choose.option909list(list(message = “PKNCA.choose.option("conc.na") not equal to current.options[["conc.na"]].”, srcref = c(275, 3, 276, 44, 3, 44, 275, 276), expectation_calls = list(expect_equal(PKNCA.choose.option(“conc.na”), current.options[[“conc.na”]])), call = list(expect_equal(PKNCA.choose.option(“conc.na”), current.options[[“conc.na”]])), start_frame = 74, end_frame = 74, test = “PKNCA.choose.option”), list(message = "“, srcref = c(278, 3, 279, 74, 3, 74, 278, 279), expectation_calls = list(expect_error(PKNCA.choose.option(”foo"),
regexp = "PKNCA.options does not have value\(s\) for foo.")), call = list(expect_error(PKNCA.choose.option(“foo”), regexp = “PKNCA.options does not have value\(s\) for foo.”)), start_frame = 74, end_frame = 74, test = “PKNCA.choose.option”), list(message = "“, srcref = c(283, 3, 284, 55, 3, 55, 283, 284), expectation_calls = list(expect_error(PKNCA.choose.option(”foo“, options = list(foo =”bar“)), regexp =”Invalid setting for PKNCA: foo“)), call = list(expect_error(PKNCA.choose.option(”foo",
options = list(foo= “bar”)), regexp = "Invalid setting forPKNCA: foo")), start_frame = 74,end_frame = 74, test = “PKNCA.choose.option”), list(message = “PKNCA.choose.option("max.aucinf.pext", options = list(max.aucinf.pext = 10)) not equal to 10.”, srcref = c(287, 3, 289, 18, 3, 18, 287, 289), expectation_calls = list(expect_equal(PKNCA.choose.option(“max.aucinf.pext”, options = list(max.aucinf.pext = 10)), 10)), call = list(expect_equal(PKNCA.choose.option(“max.aucinf.pext”, options = list(max.aucinf.pext = 10)),
10)), start_frame =74, end_frame = 74, test = "PKNCA.choose.option"), list(message= "PKNCA.choose.option(…) not equal to 10.“, srcref = c(293, 3, 297, 18, 3, 18, 293, 297), expectation_calls = list(expect_equal(PKNCA.choose.option(”max.aucinf.pext“, options = list(foo =”bar“, max.aucinf.pext = 10)), 10)), call = list(expect_equal(PKNCA.choose.option(”max.aucinf.pext“, options = list(foo =”bar“, max.aucinf.pext = 10)), 10)), start_frame = 74, end_frame = 74, test =”PKNCA.choose.option"),
list(message = "PKNCA.choose.option("single.dose.aucs") not equal to PKNCA.options(name = \“single.dose.aucs").”, srcref = c(300, 3, 302, 94, 3, 94, 300, 302), expectation_calls = list(expect_equal(PKNCA.choose.option(“single.dose.aucs”), PKNCA.options(name = “single.dose.aucs”), info = “PKNCA.choose.option gives the default option when nothing else is given”)), call = list(expect_equal(PKNCA.choose.option(“single.dose.aucs”), PKNCA.options(name = “single.dose.aucs”), info = “PKNCA.choose.option gives the default option when nothing else is given”)),
start_frame = 74, end_frame = 74, test = "PKNCA.choose.option"), list(message ="PKNCA.choose.option(…) not equal to check.interval.specification(data.frame(start = 0, end = 1, cmax = TRUE)).“, srcref = c(303, 3, 306, 94, 3, 94, 303, 306), expectation_calls = list(expect_equal(PKNCA.choose.option(”single.dose.aucs“, options = list(single.dose.aucs = data.frame(start = 0, end = 1, cmax = TRUE))), check.interval.specification(data.frame(start = 0, end = 1, cmax = TRUE)), info =”PKNCA.choose.option gives the default option when nothing else is given")),
call = list(expect_equal(PKNCA.choose.option("single.dose.aucs", options = list(single.dose.aucs = data.frame(start = 0, end = 1, cmax = TRUE))), check.interval.specification(data.frame(start = 0, end = 1, cmax = TRUE)), info = “PKNCA.choose.option gives the default option when nothing else is given”)), start_frame = 74, end_frame = 74, test = “PKNCA.choose.option”), list(message = “PKNCA.choose.option(…) not equal to check.interval.specification(…).”, srcref = c(307, 3, 311, 94,
3, 94, 307, 311), expectation_calls = list(expect_equal(PKNCA.choose.option("single.dose.aucs“, value = data.frame(start = 0, end = 1, cmax = TRUE, tmax = TRUE), options = list(single.dose.aucs = data.frame(start = 0, end = 1, cmax = TRUE))), check.interval.specification(data.frame(start = 0, end = 1, cmax = TRUE, tmax = TRUE)), info =”PKNCA.choose.option gives the default option when nothing else is given“)), call = list(expect_equal(PKNCA.choose.option(”single.dose.aucs", value = data.frame(start = 0,
end = 1, cmax =TRUE, tmax = TRUE), options = list(single.dose.aucs = data.frame(start =0, end = 1, cmax = TRUE))), check.interval.specification(data.frame(start = 0, end = 1, cmax = TRUE, tmax = TRUE)), info = “PKNCA.choose.option gives the default option when nothing else is given”)), start_frame = 74, end_frame = 74, test = “PKNCA.choose.option”), list(message = “PKNCA.choose.option(…) not equal to check.interval.specification(data.frame(start = 0, end = 1, cmax = TRUE)).”, srcref = c(312,
3, 316, 94, 3, 94,312, 316), expectation_calls = list(expect_equal(PKNCA.choose.option("single.dose.aucs“, value = NULL, options = list(single.dose.aucs = data.frame(start = 0, end = 1, cmax = TRUE))), check.interval.specification(data.frame(start = 0, end = 1, cmax = TRUE)), info =”PKNCA.choose.option gives the default option when nothing else is given“)), call = list(expect_equal(PKNCA.choose.option(”single.dose.aucs", value = NULL, options = list(single.dose.aucs = data.frame(start = 0,
end = 1, cmax =TRUE))), check.interval.specification(data.frame(start = 0, end= 1, cmax= TRUE)), info = “PKNCA.choose.option gives the default option when nothing else is given”)), start_frame = 74, end_frame = 74, test = “PKNCA.choose.option”))

+

+

+
PKNCA summary setting

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Testing FilenameTest DescriptionNumber of TestsNumber of Failed Testspassedresult
test-PKNCA.options.RPKNCA.set.summary input checking13013list(list(message = “PKNCA.set.summary() not equal to list().”, srcref = c(326, 3, 326, 43, 3, 43, 326, 326), expectation_calls = list(expect_equal(PKNCA.set.summary(), list())), call = list(expect_equal(PKNCA.set.summary(), list())), start_frame = 74, end_frame = 74, test = “PKNCA.set.summary input checking”), list(message = "“, srcref = c(329, 3, 330, 87, 3, 87, 329, 330), expectation_calls = list(expect_error(PKNCA.set.summary(”blah“), regexp =”You must first define the parameter name with add.interval.col")),
call = list(expect_error(PKNCA.set.summary(“blah”), regexp = "You must first define the parametername with add.interval.col")), start_frame= 74, end_frame = 74, test = “PKNCA.set.summary input checking”), list(message = "“, srcref = c(332, 3, 333, 51, 3, 51, 332, 333), expectation_calls = list(expect_error(PKNCA.set.summary(”auclast“, description =”A“, point =”a“), regexp =”point must be a function“)), call = list(expect_error(PKNCA.set.summary(”auclast“, description =”A“, point =”a"),
regexp = "point must be a function“)), start_frame = 74, end_frame = 74, test =”PKNCA.set.summary input checking“), list(message =”", srcref = c(335, 3, 339, 3, 3, 3, 335, 339), expectation_calls = list(expect_error(PKNCA.set.summary(“auclast”, description = 1), regexp = “description must be a character string”, fixed = TRUE)), call = list(expect_error(PKNCA.set.summary(“auclast”, description = 1), regexp = “description must be a character string”, fixed = TRUE)), start_frame = 74, end_frame = 74,
test = "PKNCA.set.summary input checking“), list(message =”", srcref = c(340, 3, 344, 3, 3, 3, 340, 344), expectation_calls = list(expect_error(PKNCA.set.summary(“auclast”, description = c(“A”, “B”)), regexp = “description must be a scalar.”, fixed = TRUE)), call = list(expect_error(PKNCA.set.summary(“auclast”, description = c(“A”, “B”)), regexp = “description must be a scalar.”, fixed = TRUE)), start_frame = 74, end_frame = 74, test = “PKNCA.set.summary input checking”), list(message = "",
srcref = c(345, 3,345, 59, 3, 59, 345, 345), expectation_calls = list(expect_error(PKNCA.set.summary(“auclast”, description = 1))), call =list(expect_error(PKNCA.set.summary(“auclast”, description = 1))), start_frame = 74, end_frame = 74, test = “PKNCA.set.summary input checking”), list(message = "“, srcref = c(347, 3, 348, 50, 3, 50, 347, 348), expectation_calls = list(expect_error(PKNCA.set.summary(”auclast“, description =”A“, point = mean, spread =”a“), regexp =”spread must be a function")),
call = list(expect_error(PKNCA.set.summary(“auclast”, description = “A”, point = mean, spread = "a“), regexp =”spread must be a function")), start_frame = 74, end_frame = 74, test = “PKNCA.set.summary input checking”), list(message = "“, srcref = c(350, 3, 352, 69, 3, 69, 350, 352), expectation_calls = list(expect_error(PKNCA.set.summary(”auclast“, description =”A“, point = mean, spread = sd, rounding =”a“), regexp =”rounding must be either a list or a function“)), call = list(expect_error(PKNCA.set.summary(”auclast",
description = “A”,point = mean, spread = sd, rounding = “a”), regexp = "rounding must be eithera list or a function")), start_frame = 74,end_frame= 74, test = “PKNCA.set.summary input checking”), list(message = "“, srcref = c(353, 3, 355, 70, 3, 70, 353, 355), expectation_calls = list(expect_error(PKNCA.set.summary(”auclast“, description =”A“, point = mean, spread = sd, rounding = list(foo = 3, bar = 4)), regexp =”rounding must have a single value in the list“)), call = list(expect_error(PKNCA.set.summary(”auclast",
description = “A”,point = mean, spread = sd, rounding = list(foo = 3, bar = 4)), regexp = "rounding must have a single value in the list")), start_frame = 74, end_frame = 74, test = “PKNCA.set.summary input checking”), list(message = "“, srcref = c(356, 3, 358, 93, 3, 93, 356, 358), expectation_calls = list(expect_error(PKNCA.set.summary(”auclast“, description =”A“, point = mean, spread = sd, rounding = list(foo = 3)), regexp =”When a list, rounding must have a name of either ‘signif’ or ‘round’")),
call = list(expect_error(PKNCA.set.summary(“auclast”, description = “A”, point = mean, spread = sd, rounding = list(foo = 3)), regexp = "When a list,rounding must have a name of either ‘signif’ or ‘round’“)), start_frame = 74, end_frame = 74, test =”PKNCA.set.summary input checking“), list(message =”PKNCA.set.summary(…) not equal to list(…).“, srcref = c(360, 3, 372, 3, 3, 3, 360, 372), expectation_calls = list(expect_equal(PKNCA.set.summary(”auclast“, description =”A", point = mean,
spread = sd, rounding = round), list(auclast = list(description = “A”, point = mean, spread = sd,rounding = round)))), call = list(expect_equal(PKNCA.set.summary(“auclast”, description = “A”, point = mean, spread = sd, rounding = round), list(auclast = list(description = “A”, point = mean, spread = sd, rounding = round)))), start_frame = 74, end_frame = 74, test = “PKNCA.set.summary input checking”), list(message = “PKNCA.set.summary(…) not equal to list(…).”, srcref = c(374, 3, 377,
58, 3, 58, 374, 377), expectation_calls = list(expect_equal(PKNCA.set.summary(“auclast”, description= “A”, point = mean, spread = sd, rounding= list(round = 2)), list(auclast = list(description = “A”, point = mean, spread = sd, rounding = list(round = 2))))), call = list(expect_equal(PKNCA.set.summary(“auclast”, description = “A”, point = mean, spread = sd, rounding = list(round = 2)), list(auclast = list(description = “A”, point = mean, spread = sd, rounding = list(round = 2))))), start_frame = 74,
end_frame = 74, test = “PKNCA.set.summary input checking”), list(message = "PKNCA.set.summary(…) not equal to list(…).", srcref =c(380, 3,400, 3, 3, 3, 380, 400), expectation_calls = list(expect_equal(PKNCA.set.summary(name = c(“cmax”, “auclast”), description = “A”, point = mean, spread = sd, rounding = list(round = 2)), list(cmax = list(description = “A”, point = mean, spread = sd, rounding = list(round = 2)), auclast = list(description = “A”, point = mean, spread = sd, rounding = list(round = 2))))),
call = list(expect_equal(PKNCA.set.summary(name = c(“cmax”, “auclast”), description = “A”, point= mean, spread = sd, rounding = list(round= 2)), list(cmax = list(description = “A”, point = mean, spread = sd, rounding = list(round = 2)), auclast = list(description = “A”, point = mean, spread = sd, rounding = list(round = 2))))), start_frame = 74, end_frame = 74, test = “PKNCA.set.summary input checking”))
test-PKNCA.options.RPKNCA.set.summary exists for all paramters101list(list(message = “length(missing_summaries) == 0 isn’t true.”, srcref = c(416, 3, 417, 59, 3, 59, 416, 417), expectation_calls = list(expect_true(length(missing_summaries) == 0, info = “All parameters have summary functions”)), call = list(expect_true(length(missing_summaries) == 0, info = “All parameters have summary functions”)), start_frame = 74, end_frame = 74, test = “PKNCA.set.summary exists for all paramters”))
test-PKNCA.options.RPKNCA.options.describe101list(list(message = “PKNCA:::PKNCA.options.describe("adj.r.squared.factor") not equal to PKNCA:::.PKNCA.option.check["adj.r.squared.factor"].”, srcref = c(421, 3, 423, 67, 3, 67, 421, 423), expectation_calls = list(expect_equal(PKNCA:::PKNCA.options.describe(“adj.r.squared.factor”), PKNCA:::.PKNCA.option.check[“adj.r.squared.factor”], info = “Option descriptions are provided accurately.”)), call = list(expect_equal(PKNCA:::PKNCA.options.describe(“adj.r.squared.factor”),
PKNCA:::.PKNCA.option.check[“adj.r.squared.factor”], info = "Option descriptions are providedaccurately.")), start_frame = 74,end_frame = 74, test = “PKNCA.options.describe”))
test-PKNCA.options.RPKNCA.options fails when setting defaults and another option simultaneously101list(list(message = "“, srcref = c(427, 3, 431, 3, 3, 3, 427, 431), expectation_calls = list(expect_error(PKNCA.options(default = TRUE, tau.choices = 24), regexp =”Cannot set default and set new options at the same time.“, fixed = TRUE)), call = list(expect_error(PKNCA.options(default = TRUE, tau.choices = 24), regexp =”Cannot set default and set new options at the same time.“, fixed = TRUE)), start_frame = 74, end_frame = 74, test =”PKNCA.options fails when setting defaults and another option simultaneously"))

+

+

+
Provenance

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Testing FilenameTest DescriptionNumber of TestsNumber of Failed Testspassedresult
test-provenance.Rprovenance10010list(list(message = “<… isn’t true.”, srcref = c(7, 3, 8, 57, 3, 57, 7, 8), expectation_calls = list(expect_true(as.numeric(difftime(Sys.time(), attr(a, “provenance”, exact = TRUE)\(datetime, units = "secs")) < 0.1, info = "A correct time is set in provenance")), call = list(expect_true(as.numeric(difftime(Sys.time(), attr(a, "provenance", exact = TRUE)\)datetime, units = “secs”)) < 0.1, info = “A correct time is set in provenance”)), start_frame = 74, end_frame = 74, test = “provenance”), list(message = “attr(a, "provenance", exact = TRUE)$sysInfo not equal to Sys.info().”,
srcref = c(9, 3,10, 70, 3, 70, 9,10), expectation_calls = list(expect_equal(attr(a, "provenance“, exact = TRUE)\(sysInfo, Sys.info(), info = "Correct system information is set in provenance")), call = list(expect_equal(attr(a, "provenance", exact = TRUE)\)sysInfo, Sys.info(), info =”Correct system information is set in provenance“)), start_frame = 74, end_frame = 74, test =”provenance“), list(message =”attr(a, "provenance", exact = TRUE)$sessionInfo not equal to sessionInfo().", srcref = c(11,
3, 12, 71, 3, 71, 11, 12), expectation_calls = list(expect_equal(attr(a, "provenance", exact = TRUE)\(sessionInfo, sessionInfo(), info = "Correct session information is set in provenance")), call = list(expect_equal(attr(a, "provenance", exact = TRUE)\)sessionInfo, sessionInfo(), info = “Correct session information is set in provenance”)), start_frame = 74, end_frame = 74, test = “provenance”), list(message = "", srcref = c(13, 3, 15, 93, 3, 93, 13, 15), expectation_calls = list(expect_error(addProvenance(a),
regexp = "objectalready has provenance and the option to replace it was not selected.", info = “Adding provenance to an object that already has provenance is an error”)), call = list(expect_error(addProvenance(a), regexp = “object already has provenance and the option to replace it was not selected.”, info = “Adding provenance to an object that already has provenance is an error”)), start_frame = 74, end_frame = 74, test = “provenance”), list(message = “{…} isn’t true.”, srcref = c(16,
3, 23, 49, 3, 49, 16, 23), expectation_calls = list(expect_true({
Sys.sleep(0.2)
as.numeric(difftime(Sys.time(), attr(addProvenance(a,replace = TRUE), "provenance", exact = TRUE)$datetime, units = “secs”)) < 0.1
}, info = "A correcttime is reset in provenance")), call= list(expect_true({
Sys.sleep(0.2)
as.numeric(difftime(Sys.time(), attr(addProvenance(a,replace = TRUE), "provenance", exact = TRUE)$datetime, units = “secs”)) < 0.1
}, info = "A correcttime is reset in provenance")), start_frame = 74, end_frame =74, test= “provenance”), list(message = “checkProvenance(a) isn’t true.”, srcref = c(25, 3, 26, 74, 3, 74, 25, 26), expectation_calls = list(expect_true(checkProvenance(a), info = “Provenance checking works to find correct provenance”)), call = list(expect_true(checkProvenance(a), info = “Provenance checking works to find correct provenance”)), start_frame = 74, end_frame = 74, test = “provenance”), list(message = “is.na(checkProvenance(b)) isn’t true.”,
srcref = c(28, 3, 29, 74, 3, 74, 28, 29), expectation_calls = list(expect_true(is.na(checkProvenance(b)), info = “Provenance checking works to find missing provenance”)), call = list(expect_true(is.na(checkProvenance(b)), info = “Provenance checking works to find missing provenance”)), start_frame = 74, end_frame = 74, test = “provenance”), list(message = “checkProvenance(b) isn’t false.”, srcref = c(31, 3, 32, 77, 3, 77, 31, 32), expectation_calls = list(expect_false(checkProvenance(b), info = “Provenance checking works to find incorrect provenance”)),
call = list(expect_false(checkProvenance(b), info = "Provenance checking worksto findincorrect provenance“)), start_frame = 74, end_frame = 74, test =”provenance“), list(message =”print\\.provenance\\(fakeprov\\) does not match "Provenance hash a generated on b with c.".value: "Provenance hash a generated on b with c\."“, srcref = c(38, 3, 40, 51, 3, 51, 38, 40), expectation_calls = list(expect_output(print.provenance(fakeprov), regexp =”Provenance hash a generated on b with c.",
info = "Provenance prints correctly"), expect_match(act$cap, enc2native(regexp), …, info = info, label = act\(lab)), call = list(expect_output(print.provenance(fakeprov), regexp = "Provenance hash a generated on b with c.", info = "Provenance prints correctly"), expect_match(act\)cap, enc2native(regexp), …, info = info, label = act$lab)), start_frame = 74, end_frame = 75, test = “provenance”), list(message = “print.provenance(fakeprov) not equal to invisible("Provenance hash a generated on b with c.").”,
srcref = c(41, 3, 43, 98, 3, 98, 41, 43), expectation_calls = list(expect_equal(print.provenance(fakeprov), invisible(“Provenance hash a generated on b with c.”), info = “Provenance printing returns an invisible string with the information in it.”)), call = list(expect_equal(print.provenance(fakeprov), invisible(“Provenance hash a generated on b with c.”), info = “Provenance printing returns an invisible string with the information in it.”)), start_frame = 74, end_frame = 74, test = “provenance”))

+

+

+
Superposition

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Testing FilenameTest DescriptionNumber of TestsNumber of Failed Testspassedresult
test-superpostion.Rsuperposition inputs76076list(list(message = "“, srcref = c(37, 3, 38, 58, 3, 58, 37, 38), expectation_calls = list(expect_error(superposition(conc = c(1, 2), time = c(0, 1), tau = 24), regexp =”The first concentration must be 0“)), call = list(expect_error(superposition(conc = c(1, 2), time = c(0, 1), tau = 24), regexp =”The first concentration must be 0“)), start_frame = 74, end_frame = 74, test =”superposition inputs“), list(message =”", srcref = c(39, 3, 40, 58, 3, 58, 39, 40), expectation_calls = list(expect_error(superposition(conc = c(NA,
2), time = c(0, 1), tau = 24), regexp = "Thefirst concentration must be 0")), call = list(expect_error(superposition(conc = c(NA, 2), time = c(0, 1), tau = 24), regexp = “The first concentration must be 0”)), start_frame = 74, end_frame = 74, test = “superposition inputs”), list(message = "“, srcref = c(43, 3, 44, 52, 3, 52, 43, 44), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), dose.input = c(0, 1)), regexp =”dose.input must be a scalar")), call = list(
expect_error(superposition(conc = c(0, 2), time = c(0, 1), dose.input = c(0, 1)), regexp = "dose.input must be a scalar“)), start_frame = 74, end_frame = 74, test =”superposition inputs“), list(message =”“, srcref = c(46, 3, 47, 52, 3, 52, 46, 47), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), dose.input = NA), regexp =”dose.input must be a number“)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), dose.input = NA), regexp =”dose.input must be a number")),
start_frame = 74,end_frame = 74, test = "superposition inputs“), list(message =”", srcref = c(48, 3, 49, 52, 3, 52, 48, 49), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), dose.input = factor(“1”)), regexp = “dose.input must be a number”)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), dose.input = factor(“1”)), regexp = “dose.input must be a number”)), start_frame = 74, end_frame = 74, test = “superposition inputs”), list(message = "",
srcref = c(50, 3,51, 52, 3, 52, 50, 51), expectation_calls =list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), dose.input = “1”), regexp = “dose.input must be a number”)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), dose.input = “1”), regexp = “dose.input must be a number”)), start_frame = 74, end_frame = 74, test = “superposition inputs”), list(message = "", srcref = c(53, 3, 54, 47, 3, 47, 53, 54), expectation_calls = list(expect_error(superposition(conc = c(0,
2), time = c(0, 1), dose.input = -1), regexp= "dose.input must be > 0")), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), dose.input = -1), regexp = “dose.input must be > 0”)), start_frame = 74, end_frame = 74, test = “superposition inputs”), list(message = "“, srcref = c(55, 3, 56, 47, 3, 47, 55, 56), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), dose.input = 0), regexp =”dose.input must be > 0")), call = list(expect_error(superposition(conc = c(0,
2), time = c(0, 1), dose.input = 0), regexp= "dose.input mustbe > 0")), start_frame =74, end_frame = 74, test = “superposition inputs”), list(message = "“, srcref = c(59, 3, 60, 45, 3, 45, 59, 60), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = c(0, 1)), regexp =”tau must be a scalar“)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = c(0, 1)), regexp =”tau must be a scalar“)), start_frame = 74, end_frame = 74, test =”superposition inputs"),
list(message = "",srcref = c(62, 3, 63, 45,3, 45, 62, 63), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = NA), regexp = “tau must be a number”)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = NA), regexp = “tau must be a number”)), start_frame = 74, end_frame = 74, test = “superposition inputs”), list(message = "", srcref = c(64, 3, 65, 45, 3, 45, 64, 65), expectation_calls = list(expect_error(superposition(conc = c(0,
2), time = c(0, 1), tau = factor(“1”)),regexp = "tau mustbe a number")), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = factor(“1”)), regexp = “tau must be a number”)), start_frame = 74, end_frame = 74, test = “superposition inputs”), list(message = "“, srcref = c(66, 3, 67, 45, 3, 45, 66, 67), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau =”1“), regexp =”tau must be a number")), call = list(expect_error(superposition(conc = c(0,
2), time = c(0, 1), tau = “1”), regexp ="tau must be a number")), start_frame = 74, end_frame = 74, test = “superposition inputs”), list(message = "“, srcref = c(69, 3, 70, 40, 3, 40, 69, 70), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = -1), regexp =”tau must be > 0“)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = -1), regexp =”tau must be > 0“)), start_frame = 74, end_frame = 74, test =”superposition inputs"),
list(message = "",srcref = c(71, 3, 72, 40,3, 40, 71, 72), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 0), regexp = “tau must be > 0”)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 0), regexp = “tau must be > 0”)), start_frame = 74, end_frame = 74, test = “superposition inputs”), list(message = "", srcref = c(75, 3, 77, 61, 3, 61, 75, 77), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0,
1), tau = 24,dose.times = c()), regexp= "There must be at least one dose time")),call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, dose.times = c()), regexp = “There must be at least one dose time”)), start_frame = 74, end_frame = 74, test = “superposition inputs”), list(message = "“, srcref = c(79, 3, 81, 52, 3, 52, 79, 81), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, dose.times =”1“), regexp =”dose.times must be a number")),
call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, dose.times= “1”), regexp = “dose.times must be a number”)), start_frame = 74, end_frame = 74, test = “superposition inputs”), list(message = "“, srcref = c(82, 3, 84, 52, 3, 52, 82, 84), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, dose.times = factor(”1“)), regexp =”dose.times must be a number")), call = list(expect_error(superposition(conc = c(0, 2), time = c(0,
1), tau = 24,dose.times = factor(“1”)),regexp = "dose.times must be a number")),start_frame = 74, end_frame = 74, test = “superposition inputs”), list(message = "“, srcref = c(85, 3, 87, 52, 3, 52, 85, 87), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, dose.times = NA), regexp =”dose.times must be a number“)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, dose.times = NA), regexp =”dose.times must be a number")),
start_frame =74, end_frame = 74, test ="superposition inputs“), list(message =”", srcref= c(89, 3, 91, 56, 3, 56, 89, 91), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, dose.times = c(-1, 0)), regexp = “dose.times must be non-negative”)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, dose.times = c(-1, 0)), regexp = “dose.times must be non-negative”)), start_frame = 74, end_frame = 74, test = “superposition inputs”),
list(message = "",srcref = c(93, 3, 95, 49,3, 49, 93, 95), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, dose.times = c(0, 25)), regexp = “dose.times must be < tau”)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, dose.times = c(0, 25)), regexp = “dose.times must be < tau”)), start_frame = 74, end_frame = 74, test = “superposition inputs”), list(message = "", srcref = c(96, 3, 98, 49, 3, 49, 96, 98), expectation_calls = list(
expect_error(superposition(conc = c(0, 2), time = c(0, 1),tau = 24, dose.times = 25), regexp = “dose.times must be < tau”)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, dose.times = 25), regexp = “dose.times must be < tau”)), start_frame = 74, end_frame = 74, test = “superposition inputs”), list(message = "", srcref = c(101, 3, 103, 65, 3, 65, 101, 103), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, dose.times = 0,
dose.amount =1), regexp = "must give dose.input to give dose.amount")), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, dose.times = 0, dose.amount = 1), regexp = “must give dose.input to give dose.amount”)), start_frame = 74, end_frame = 74, test = “superposition inputs”), list(message = "", srcref = c(105, 3, 107, 94, 3, 94, 105, 107), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), dose.input = 1, tau = 24, dose.times = 0,
dose.amount =c(1, 2)), regexp = "dose.amount must eitherbe a scalar or match thelength ofdose.times“)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), dose.input = 1, tau = 24, dose.times = 0, dose.amount = c(1, 2)), regexp =”dose.amount must either be a scalar or match the length of dose.times“)), start_frame = 74, end_frame = 74, test =”superposition inputs“), list(message =”", srcref = c(108, 3, 110, 94, 3, 94, 108, 110), expectation_calls = list(expect_error(superposition(conc = c(0,
2), time = c(0, 1), dose.input = 1, tau= 24, dose.times =c(0, 1), dose.amount = c(1, 2, 3)), regexp = “dose.amount must either be a scalar or match the length of dose.times”)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), dose.input = 1, tau = 24, dose.times = c(0, 1), dose.amount = c(1, 2, 3)), regexp = “dose.amount must either be a scalar or match the length of dose.times”)), start_frame = 74, end_frame = 74, test = “superposition inputs”), list(message = "",
srcref = c(112, 3, 114, 53, 3, 53, 112,114), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), dose.input = 1, tau = 24, dose.times = 0, dose.amount = “1”), regexp = “dose.amount must be a number”)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), dose.input = 1, tau = 24, dose.times = 0, dose.amount = “1”), regexp = “dose.amount must be a number”)), start_frame = 74, end_frame = 74, test = “superposition inputs”), list(message = "",
srcref = c(115, 3, 117, 53, 3, 53, 115,117), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), dose.input = 1, tau = 24, dose.times = 0, dose.amount = factor(“1”)), regexp = “dose.amount must be a number”)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), dose.input = 1, tau = 24, dose.times = 0, dose.amount = factor(“1”)), regexp = “dose.amount must be a number”)), start_frame = 74, end_frame = 74, test = “superposition inputs”),
list(message = "",srcref = c(119, 3, 121, 62, 3, 62, 119, 121), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), dose.input = 1, tau = 24, dose.times = 0, dose.amount = as.numeric(NA)), regexp = “dose.amount must be finite and not NA”)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), dose.input = 1, tau = 24, dose.times = 0, dose.amount = as.numeric(NA)), regexp = “dose.amount must be finite and not NA”)), start_frame = 74, end_frame = 74,
test = "superposition inputs"), list(message = "", srcref= c(122, 3, 124, 62, 3, 62, 122, 124), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), dose.input = 1, tau = 24, dose.times = 0, dose.amount = Inf), regexp = “dose.amount must be finite and not NA”)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), dose.input = 1, tau = 24, dose.times = 0, dose.amount = Inf), regexp = “dose.amount must be finite and not NA”)), start_frame = 74,
end_frame = 74, test = "superposition inputs"), list(message = "", srcref = c(125,3, 127, 62, 3, 62, 125, 127), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), dose.input = 1, tau = 24, dose.times = 0, dose.amount = -Inf), regexp = “dose.amount must be finite and not NA”)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), dose.input = 1, tau = 24, dose.times = 0, dose.amount = -Inf), regexp = “dose.amount must be finite and not NA”)),
start_frame =74, end_frame = 74, test ="superposition inputs“), list(message =”", srcref= c(129, 3, 131, 53, 3, 53, 129, 131), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), dose.input = 1, tau = 24, dose.times = 0, dose.amount = -1), regexp = “dose.amount must be positive”)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), dose.input = 1, tau = 24, dose.times = 0, dose.amount = -1), regexp = “dose.amount must be positive”)),
start_frame =74, end_frame = 74, test ="superposition inputs“), list(message =”", srcref= c(132, 3, 134, 53, 3, 53, 132, 134), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), dose.input = 1, tau = 24, dose.times = 0, dose.amount = 0), regexp = “dose.amount must be positive”)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), dose.input = 1, tau = 24, dose.times = 0, dose.amount = 0), regexp = “dose.amount must be positive”)), start_frame = 74,
end_frame = 74, test = "superposition inputs"), list(message = "", srcref = c(137,3, 139, 47, 3, 47, 137, 139), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, n.tau = c(1, 2)), regexp = “n.tau must be a scalar”)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, n.tau = c(1, 2)), regexp = “n.tau must be a scalar”)), start_frame = 74, end_frame = 74, test = “superposition inputs”), list(message = "", srcref = c(141,
3, 143, 47, 3, 47,141, 143), expectation_calls = list(expect_error(superposition(conc= c(0, 2), time = c(0, 1), tau = 24, n.tau = “1”), regexp = “n.tau must be a number”)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, n.tau = “1”), regexp = “n.tau must be a number”)), start_frame = 74, end_frame = 74, test = “superposition inputs”), list(message = "", srcref = c(144, 3, 146, 47, 3, 47, 144, 146), expectation_calls = list(expect_error(superposition(conc = c(0,
2), time = c(0, 1), tau = 24, n.tau = factor(“1”)), regexp= "n.tau must be a number")), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, n.tau = factor(“1”)), regexp = “n.tau must be a number”)), start_frame = 74, end_frame = 74, test = “superposition inputs”), list(message = "“, srcref = c(147, 3, 149, 47, 3, 47, 147, 149), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, n.tau = NA), regexp =”n.tau must be a number")),
call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, n.tau = NA), regexp = “n.tau must be a number”)), start_frame = 74, end_frame = 74, test = “superposition inputs”), list(message = "“, srcref = c(151, 3, 153, 43, 3, 43, 151, 153), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, n.tau = 0), regexp =”n.tau must be >= 1")), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, n.tau = 0),
regexp = "n.tau must be >= 1")), start_frame = 74, end_frame = 74, test = "superposition inputs“), list(message =”“, srcref = c(154, 3, 156, 43, 3, 43, 154, 156), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, n.tau = -Inf), regexp =”n.tau must be >= 1“)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, n.tau = -Inf), regexp =”n.tau must be >= 1“)), start_frame = 74, end_frame = 74, test =”superposition inputs"),
list(message = "",srcref = c(158, 3, 160, 56, 3, 56, 158, 160), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, n.tau = 1.1), regexp = “n.tau must be an integer or Inf”)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, n.tau = 1.1), regexp = “n.tau must be an integer or Inf”)), start_frame = 74, end_frame = 74, test = “superposition inputs”), list(message = "", srcref = c(161, 3, 163, 56, 3, 56, 161, 163), expectation_calls = list(
expect_error(superposition(conc = c(0, 2), time = c(0, 1),tau = 24, n.tau = 1.0000001), regexp = “n.tau must be an integer or Inf”)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, n.tau = 1.0000001), regexp = “n.tau must be an integer or Inf”)), start_frame = 74, end_frame = 74, test = “superposition inputs”), list(message = "", srcref = c(165, 3, 168, 48, 3, 48, 165, 168), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0,
1), tau = 24,n.tau = Inf, lambda.z = c(1, 2)), regexp = "lambda.z must be a scalar", info =“lambda.z must be a scalar”)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, n.tau = Inf, lambda.z = c(1, 2)), regexp = “lambda.z must be a scalar”, info = “lambda.z must be a scalar”)), start_frame = 74, end_frame = 74, test = “superposition inputs”), list(message = "", srcref = c(170, 3, 173, 60, 3, 60, 170, 173), expectation_calls = list(expect_error(superposition(conc = c(0,
2), time = c(0, 1), tau = 24, lambda.z =“1”), regexp = "lambda.z must be a number", info =“lambda.z must be a number (character)”)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, lambda.z = “1”), regexp = “lambda.z must be a number”, info = “lambda.z must be a number (character)”)), start_frame = 74, end_frame = 74, test = “superposition inputs”), list(message = "", srcref = c(174, 3, 177, 57, 3, 57, 174, 177), expectation_calls = list(expect_error(superposition(conc = c(0,
2), time = c(0, 1), tau = 24, lambda.z =factor(“1”)), regexp = "lambda.z must be anumber",info = “lambda.z must be a number (factor)”)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, lambda.z = factor(“1”)), regexp = “lambda.z must be a number”, info = “lambda.z must be a number (factor)”)), start_frame = 74, end_frame = 74, test = “superposition inputs”), list(message = "", srcref = c(179, 3, 196, 3, 3, 3, 179, 196), expectation_calls = list(expect_equal(expect_warning(superposition(conc = c(4,
2, 1, 0.5), time = 0:3, tau = 24, n.tau= Inf, check.blq =FALSE)), expect_warning(superposition(conc = c(4, 2, 1, 0.5), time = 0:3, tau = 24, clast.pred = TRUE, n.tau = Inf, check.blq = FALSE)), info = “clast.pred may be provided as ‘TRUE’”), quasi_label(enquo(object), label, arg = “object”), eval_bare(get_expr(quo), get_env(quo)), expect_warning(superposition(conc = c(4, 2, 1, 0.5), time = 0:3, tau = 24, n.tau = Inf, check.blq = FALSE))), call = list(expect_equal(expect_warning(superposition(conc = c(4,
2, 1, 0.5), time = 0:3, tau = 24, n.tau= Inf, check.blq =FALSE)), expect_warning(superposition(conc = c(4, 2, 1, 0.5), time = 0:3, tau = 24, clast.pred = TRUE, n.tau = Inf, check.blq = FALSE)), info = “clast.pred may be provided as ‘TRUE’”), quasi_label(enquo(object), label, arg = “object”), eval_bare(get_expr(quo), get_env(quo)), expect_warning(superposition(conc = c(4, 2, 1, 0.5), time = 0:3, tau = 24, n.tau = Inf, check.blq = FALSE))), start_frame = 74, end_frame = 77, test = “superposition inputs”),
list(message = "",srcref = c(179, 3, 196, 3, 3, 3, 179, 196),expectation_calls = list(expect_equal(expect_warning(superposition(conc = c(4, 2, 1, 0.5), time = 0:3, tau = 24, n.tau = Inf, check.blq = FALSE)), expect_warning(superposition(conc = c(4, 2, 1, 0.5), time = 0:3, tau = 24, clast.pred = TRUE, n.tau = Inf, check.blq = FALSE)), info = “clast.pred may be provided as ‘TRUE’”), quasi_label(enquo(expected), expected.label, arg = “expected”), eval_bare(get_expr(quo), get_env(quo)), expect_warning(superposition(conc = c(4,
2, 1, 0.5), time = 0:3, tau = 24, clast.pred = TRUE, n.tau= Inf, check.blq = FALSE))), call= list(expect_equal(expect_warning(superposition(conc = c(4, 2, 1, 0.5), time = 0:3, tau = 24, n.tau = Inf, check.blq = FALSE)), expect_warning(superposition(conc = c(4, 2, 1, 0.5), time = 0:3, tau = 24, clast.pred = TRUE, n.tau = Inf, check.blq = FALSE)), info = “clast.pred may be provided as ‘TRUE’”), quasi_label(enquo(expected), expected.label, arg = “expected”), eval_bare(get_expr(quo), get_env(quo)),
expect_warning(superposition(conc = c(4,2, 1, 0.5), time= 0:3, tau = 24, clast.pred = TRUE, n.tau = Inf, check.blq = FALSE))), start_frame = 74, end_frame = 77, test = “superposition inputs”), list(message = “expect_warning(…) not equal to expect_warning(…).”, srcref = c(179, 3, 196, 3, 3, 3, 179, 196), expectation_calls = list(expect_equal(expect_warning(superposition(conc = c(4, 2, 1, 0.5), time = 0:3, tau = 24, n.tau = Inf, check.blq = FALSE)), expect_warning(superposition(conc = c(4,
2, 1, 0.5), time = 0:3, tau = 24, clast.pred = TRUE, n.tau= Inf, check.blq = FALSE)), info= “clast.pred may be provided as ‘TRUE’”)), call = list(expect_equal(expect_warning(superposition(conc = c(4, 2, 1, 0.5), time = 0:3, tau = 24, n.tau = Inf, check.blq = FALSE)), expect_warning(superposition(conc = c(4, 2, 1, 0.5), time = 0:3, tau = 24, clast.pred = TRUE, n.tau = Inf, check.blq = FALSE)), info = “clast.pred may be provided as ‘TRUE’”)), start_frame = 74, end_frame = 74, test = “superposition inputs”),
list(message = "",srcref = c(198, 3, 201, 50, 3, 50, 198, 201), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, clast.pred = c(1, 2)), regexp = “clast.pred must be a scalar”, info = “clast.pred must be a scalar”)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, clast.pred = c(1, 2)), regexp = “clast.pred must be a scalar”, info = “clast.pred must be a scalar”)), start_frame = 74, end_frame = 74, test = “superposition inputs”),
list(message = "",srcref = c(203, 3, 206, 79, 3, 79, 203, 206), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, clast.pred = “1”), regexp = “clast.pred must either be a logical .* or numeric value”, info = “clast.pred must be a number or logical or NA (character)”)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, clast.pred = “1”), regexp = “clast.pred must either be a logical .* or numeric value”, info = “clast.pred must be a number or logical or NA (character)”)),
start_frame =74, end_frame = 74, test ="superposition inputs“), list(message =”", srcref= c(207, 3, 210, 76, 3, 76, 207, 210), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, clast.pred = factor(“1”)), regexp = “clast.pred must either be a logical .* or numeric value”, info = “clast.pred must be a number or logical or NA (factor)”)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, clast.pred = factor(“1”)),
regexp = "clast.pred must either be a logical .* or numeric value“, info =”clast.pred mustbe a number or logical or NA (factor)“)), start_frame = 74, end_frame = 74, test =”superposition inputs“), list(message =”“, srcref = c(213, 3, 215, 47, 3, 47, 213, 215), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, tlast = c(1, 2)), regexp =”tlast must be a scalar")), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24,
tlast = c(1, 2)), regexp = "tlast must be a scalar")), start_frame = 74, end_frame= 74, test = “superposition inputs”), list(message = "“, srcref = c(217, 3, 219, 47, 3, 47, 217, 219), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, tlast =”1“), regexp =”tlast must be a number“)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, tlast =”1“), regexp =”tlast must be a number")), start_frame = 74, end_frame = 74,
test = "superposition inputs"), list(message = "", srcref= c(220, 3, 222, 47, 3, 47, 220, 222), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, tlast = factor(“1”)), regexp = “tlast must be a number”)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, tlast = factor(“1”)), regexp = “tlast must be a number”)), start_frame = 74, end_frame = 74, test = “superposition inputs”), list(message = "", srcref = c(223, 3,
225, 47, 3, 47, 223, 225), expectation_calls= list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, tlast = NA), regexp = “tlast must be a number”)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, tlast = NA), regexp = “tlast must be a number”)), start_frame = 74, end_frame = 74, test = “superposition inputs”), list(message = "", srcref = c(229, 3, 231, 136, 3, 136, 229, 231), expectation_calls = list(expect_error(superposition(conc = c(0,
2), time = c(0, 1), tau = 24, additional.times = NA), regexp = "No additional.timesmay be NA \(to not include any additional.times, enter c\(\) as the function argument\)“)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, additional.times = NA), regexp =”No additional.times may be NA \(to not include any additional.times, enter c\(\) as the function argument\)“)), start_frame = 74, end_frame = 74, test =”superposition inputs“), list(message =”",
srcref = c(232, 3, 234, 136, 3, 136, 232, 234), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, additional.times = c(2, NA)), regexp = “No additional.times may be NA \(to not include any additional.times, enter c\(\) as the function argument\)”)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, additional.times = c(2, NA)), regexp = “No additional.times may be NA \(to not include any additional.times, enter c\(\) as the function argument\)”)),
start_frame =74, end_frame = 74, test ="superposition inputs“), list(message =”", srcref= c(236, 3, 238, 58, 3, 58, 236, 238), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, additional.times = “1”), regexp = “additional.times must be a number”)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, additional.times = “1”), regexp = “additional.times must be a number”)), start_frame = 74, end_frame = 74, test = “superposition inputs”),
list(message = "",srcref = c(239, 3, 241, 58, 3, 58, 239, 241), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, additional.times = factor(“1”)), regexp = “additional.times must be a number”)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, additional.times = factor(“1”)), regexp = “additional.times must be a number”)), start_frame = 74, end_frame = 74, test = “superposition inputs”), list(message = "", srcref = c(243,
3, 245, 65, 3, 65,243, 245), expectation_calls = list(expect_error(superposition(conc= c(0, 2), time = c(0, 1), tau = 24, additional.times = -1), regexp = “All additional.times must be nonnegative”)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, additional.times = -1), regexp = “All additional.times must be nonnegative”)), start_frame = 74, end_frame = 74, test = “superposition inputs”), list(message = "", srcref = c(246, 3, 248, 65, 3, 65, 246, 248), expectation_calls = list(
expect_error(superposition(conc = c(0, 2), time = c(0, 1),tau = 24, additional.times = c(-1, 0)), regexp = “All additional.times must be nonnegative”)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, additional.times = c(-1, 0)), regexp = “All additional.times must be nonnegative”)), start_frame = 74, end_frame = 74, test = “superposition inputs”), list(message = "", srcref = c(250, 3, 252, 60, 3, 60, 250, 252), expectation_calls = list(expect_error(superposition(conc = c(0,
2), time = c(0, 1), tau = 24, additional.times = 25), regexp = "All additional.times must be<= tau“)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, additional.times = 25), regexp =”All additional.times must be <= tau“)), start_frame = 74, end_frame = 74, test =”superposition inputs“), list(message =”", srcref = c(253, 3, 255, 60, 3, 60, 253, 255), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, additional.times = c(0,
25)), regexp ="All additional.times must be <= tau")), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, additional.times = c(0, 25)), regexp = “All additional.times must be <= tau”)), start_frame = 74, end_frame = 74, test = “superposition inputs”), list(message = "“, srcref = c(258, 3, 260, 58, 3, 58, 258, 260), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, steady.state.tol = c(1, 2)), regexp =”steady.state.tol must be a scalar")),
call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, steady.state.tol = c(1, 2)), regexp = “steady.state.tol must be a scalar”)), start_frame = 74, end_frame = 74, test = “superposition inputs”), list(message = "“, srcref = c(262, 3, 264, 58, 3, 58, 262, 264), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, steady.state.tol =”1“), regexp =”steady.state.tol must be a number")), call = list(expect_error(superposition(conc = c(0,
2), time = c(0, 1), tau = 24, steady.state.tol = “1”), regexp = "steady.state.tol must be anumber“)), start_frame = 74, end_frame = 74, test =”superposition inputs“), list(message =”“, srcref = c(265, 3, 267, 58, 3, 58, 265, 267), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, steady.state.tol =”1“), regexp =”steady.state.tol must be a number“)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, steady.state.tol =”1"),
regexp = "steady.state.tol must be a number")), start_frame = 74, end_frame = 74, test = "superposition inputs“), list(message =”“, srcref = c(268, 3, 270, 58, 3, 58, 268, 270), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, steady.state.tol = factor(”1“)), regexp =”steady.state.tol must be a number“)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, steady.state.tol = factor(”1“)), regexp =”steady.state.tol must be a number")),
start_frame =74, end_frame = 74, test ="superposition inputs“), list(message =”", srcref= c(271, 3, 273, 58, 3, 58, 271, 273), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, steady.state.tol = NA), regexp = “steady.state.tol must be a number”)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, steady.state.tol = NA), regexp = “steady.state.tol must be a number”)), start_frame = 74, end_frame = 74, test = “superposition inputs”),
list(message = "",srcref = c(275, 3, 277, 77, 3, 77, 275, 277), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, steady.state.tol = 0), regexp = “steady.state.tol must be between 0 and 1, exclusive.”)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, steady.state.tol = 0), regexp = “steady.state.tol must be between 0 and 1, exclusive.”)), start_frame = 74, end_frame = 74, test = “superposition inputs”), list(message = "",
srcref = c(278, 3, 280, 77, 3, 77, 278,280), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, steady.state.tol = 1), regexp = “steady.state.tol must be between 0 and 1, exclusive.”)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, steady.state.tol = 1), regexp = “steady.state.tol must be between 0 and 1, exclusive.”)), start_frame = 74, end_frame = 74, test = “superposition inputs”), list(message = "", srcref = c(281,
3, 283, 77, 3, 77,281, 283), expectation_calls = list(expect_error(superposition(conc= c(0, 2), time = c(0, 1), tau = 24, steady.state.tol = -1), regexp = “steady.state.tol must be between 0 and 1, exclusive.”)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, steady.state.tol = -1), regexp = “steady.state.tol must be between 0 and 1, exclusive.”)), start_frame = 74, end_frame = 74, test = “superposition inputs”), list(message = "", srcref = c(284, 3, 286, 77,
3, 77, 284, 286),expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, steady.state.tol = 2), regexp = “steady.state.tol must be between 0 and 1, exclusive.”)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, steady.state.tol = 2), regexp = “steady.state.tol must be between 0 and 1, exclusive.”)), start_frame = 74, end_frame = 74, test = “superposition inputs”), list(message = "", srcref = c(289, 3, 291, 115, 3, 115, 289,
291), expectation_calls = list(expect_error(superposition(conc= c(0, 2), time = c(0, 1), tau =24, clast.pred = 1), regexp = “Either give all or none of the values for these arguments: lambda.z, clast.pred, and tlast”)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, clast.pred = 1), regexp = “Either give all or none of the values for these arguments: lambda.z, clast.pred, and tlast”)), start_frame = 74, end_frame = 74, test = “superposition inputs”), list(message = "",
srcref = c(292, 3, 294, 115, 3, 115, 292, 294), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, lambda.z = 1), regexp = “Either give all or none of the values for these arguments: lambda.z, clast.pred, and tlast”)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, lambda.z = 1), regexp = “Either give all or none of the values for these arguments: lambda.z, clast.pred, and tlast”)), start_frame = 74, end_frame = 74,
test = "superposition inputs"), list(message = "", srcref= c(295, 3, 297, 115, 3,115, 295,297), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, tlast = 1), regexp = “Either give all or none of the values for these arguments: lambda.z, clast.pred, and tlast”)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, tlast = 1), regexp = “Either give all or none of the values for these arguments: lambda.z, clast.pred, and tlast”)),
start_frame =74, end_frame = 74, test ="superposition inputs“), list(message =”", srcref= c(298, 3, 300, 115, 3, 115, 298, 300), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, clast.pred = 1, lambda.z = 1), regexp = “Either give all or none of the values for these arguments: lambda.z, clast.pred, and tlast”)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, clast.pred = 1, lambda.z = 1), regexp = “Either give all or none of the values for these arguments: lambda.z, clast.pred, and tlast”)),
start_frame =74, end_frame = 74, test ="superposition inputs“), list(message =”", srcref= c(301, 3, 303, 115, 3, 115, 301, 303), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, clast.pred = 1, tlast = 1), regexp = “Either give all or none of the values for these arguments: lambda.z, clast.pred, and tlast”)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, clast.pred = 1, tlast = 1), regexp = “Either give all or none of the values for these arguments: lambda.z, clast.pred, and tlast”)),
start_frame =74, end_frame = 74, test ="superposition inputs“), list(message =”", srcref= c(304, 3, 306, 115, 3, 115, 304, 306), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, lambda.z = 1), regexp = “Either give all or none of the values for these arguments: lambda.z, clast.pred, and tlast”)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, lambda.z = 1), regexp = “Either give all or none of the values for these arguments: lambda.z, clast.pred, and tlast”)),
start_frame =74, end_frame = 74, test ="superposition inputs“), list(message =”", srcref= c(307, 3, 309, 115, 3, 115, 307, 309), expectation_calls = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, lambda.z = 1, tlast = 1), regexp = “Either give all or none of the values for these arguments: lambda.z, clast.pred, and tlast”)), call = list(expect_error(superposition(conc = c(0, 2), time = c(0, 1), tau = 24, lambda.z = 1, tlast = 1), regexp = “Either give all or none of the values for these arguments: lambda.z, clast.pred, and tlast”)),
start_frame =74, end_frame = 74, test ="superposition inputs"))
test-superpostion.Rsuperposition math18018list(list(message = “superposition(conc = c1, time = t1, tau = 3, n.tau = 2) not equal to data.frame(conc = c(3, 3, 3, 3.5), time = 0:3).”, srcref = c(318, 3, 320, 36, 3, 36, 318, 320), expectation_calls = list(expect_equal(superposition(conc = c1, time = t1, tau = 3, n.tau = 2), data.frame(conc = c(3, 3, 3, 3.5), time = 0:3))), call = list(expect_equal(superposition(conc = c1, time = t1, tau = 3, n.tau = 2), data.frame(conc = c(3, 3, 3, 3.5), time = 0:3))), start_frame = 74, end_frame = 74,
test = "superposition math"), list(message ="", srcref = c(322, 3, 323, 50, 3, 50, 322, 323), expectation_calls = list(expect_warning(v1 <- superposition(conc = c1, time = t1, tau = 3, n.tau = 3), regexp = “essentially perfect fit”)), call = list(expect_warning(v1 <- superposition(conc = c1, time = t1, tau = 3, n.tau = 3), regexp = “essentially perfect fit”)), start_frame = 74, end_frame = 74, test = “superposition math”), list(message = “v1 not equal to data.frame(conc = c(3.5, 3.25, 3.125, 3.5625), time = 0:3).”,
srcref = c(324, 3,326, 36, 3, 36, 324, 326), expectation_calls = list(expect_equal(v1,data.frame(conc = c(3.5, 3.25, 3.125, 3.5625), time = 0:3))), call = list(expect_equal(v1, data.frame(conc = c(3.5, 3.25, 3.125, 3.5625), time = 0:3))), start_frame = 74, end_frame = 74, test = “superposition math”), list(message = "“, srcref = c(328, 3, 329, 50, 3, 50, 328, 329), expectation_calls = list(expect_warning(v2 <- superposition(conc = c1, time = t1, tau = 3, n.tau = Inf), regexp =”essentially perfect fit")),
call = list(expect_warning(v2 <- superposition(conc = c1, time= t1, tau = 3, n.tau = Inf), regexp = “essentially perfect fit”)), start_frame = 74, end_frame = 74, test = “superposition math”), list(message = “v2 not equal to data.frame(conc = c(3.571, 3.286, 3.143, 3.571), time = 0:3).”, srcref = c(330, 3, 333, 25, 3, 25, 330, 333), expectation_calls = list(expect_equal(v2, data.frame(conc = c(3.571, 3.286, 3.143, 3.571), time = 0:3), tol = 0.001)), call = list(expect_equal(v2, data.frame(conc = c(3.571,
3.286, 3.143, 3.571), time = 0:3), tol = 0.001)), start_frame= 74, end_frame = 74, test = "superposition math“), list(message =”superposition(conc = rep(0, 6), time = 0:5, tau = 24) not equal to data.frame(conc = 0, time = c(0:5, 24)).", srcref = c(336, 3, 337, 51, 3, 51, 336, 337), expectation_calls = list(expect_equal(superposition(conc = rep(0, 6), time = 0:5, tau = 24), data.frame(conc = 0, time = c(0:5, 24)))), call = list(expect_equal(superposition(conc = rep(0, 6), time = 0:5,
tau = 24), data.frame(conc = 0, time = c(0:5, 24)))), start_frame = 74, end_frame = 74,test = "superposition math“), list(message =”superposition(conc = rep(0, 6), time = 0:5, tau = 24, additional.times = c(2.5)) not equal to data.frame(conc = 0, time = c(0, 1, 2, 2.5, 3, 4, 5, 24)).", srcref = c(342, 3, 344, 69, 3, 69, 342, 344), expectation_calls = list(expect_equal(superposition(conc = rep(0, 6), time = 0:5, tau = 24, additional.times = c(2.5)), data.frame(conc = 0, time = c(0, 1,
2, 2.5, 3, 4, 5, 24)))), call = list(expect_equal(superposition(conc = rep(0, 6), time= 0:5, tau = 24, additional.times = c(2.5)), data.frame(conc = 0, time = c(0, 1, 2, 2.5, 3, 4, 5, 24)))), start_frame = 74, end_frame = 74, test = “superposition math”), list(message = “superposition(conc = rep(0, 6), time = 0:5, tau = 25, additional.times = c(2.5)) not equal to data.frame(conc = 0, time = c(0, 1, 2, 2.5, 3, 4, 5, 25)).”, srcref = c(345, 3, 347, 69, 3, 69, 345, 347), expectation_calls = list(
expect_equal(superposition(conc = rep(0, 6),time = 0:5, tau =25, additional.times = c(2.5)), data.frame(conc = 0, time = c(0, 1, 2, 2.5, 3, 4, 5, 25)))), call = list(expect_equal(superposition(conc = rep(0, 6), time = 0:5, tau = 25, additional.times = c(2.5)), data.frame(conc = 0, time = c(0, 1, 2, 2.5, 3, 4, 5, 25)))), start_frame = 74, end_frame = 74, test = “superposition math”), list(message = “superposition(…) not equal to data.frame(conc = 0, time = c(0, 1, 2, 2.5, 3, 3.5, 4, 5, 24)).”,
srcref = c(348, 3,350, 74, 3, 74, 348, 350), expectation_calls = list(expect_equal(superposition(conc = rep(0, 6), time = 0:5, tau = 24, additional.times = c(2.5, 3.5)), data.frame(conc = 0, time = c(0, 1, 2, 2.5, 3, 3.5, 4, 5, 24)))), call = list(expect_equal(superposition(conc = rep(0, 6), time = 0:5, tau = 24, additional.times = c(2.5, 3.5)), data.frame(conc = 0, time = c(0, 1, 2, 2.5, 3, 3.5, 4, 5, 24)))), start_frame = 74, end_frame = 74, test = “superposition math”), list(message = “superposition(…) not equal to data.frame(…).”,
srcref = c(351, 3,353, 77, 3, 77, 351, 353), expectation_calls = list(expect_equal(superposition(conc = rep(0, 6), time = 0:5, tau = 24, dose.times = c(0, 1), additional.times = c(2.5, 3.5)), data.frame(conc = 0, time = c(0, 1, 2, 2.5, 3, 3.5, 4, 5, 6, 24)))), call = list(expect_equal(superposition(conc = rep(0, 6), time = 0:5, tau = 24, dose.times = c(0, 1), additional.times = c(2.5, 3.5)), data.frame(conc = 0, time = c(0, 1, 2, 2.5, 3, 3.5, 4, 5, 6, 24)))), start_frame = 74, end_frame = 74,
test = "superposition math"), list(message ="superposition(...) not equal to data.frame(…).TRUE", srcref = c(354, 3, 359, 41, 3, 41, 354, 359), expectation_calls = list(expect_equal(superposition(conc = rep(0, 6), time = 0:5, tau = 24, dose.times = c(0, 0.5), additional.times = c(2.5, 3.5)), data.frame(conc = 0, time = c(0, 0.5, 1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5, 5.5, 24)))), call = list(expect_equal(superposition(conc = rep(0, 6), time = 0:5, tau = 24, dose.times = c(0, 0.5), additional.times = c(2.5,
3.5)), data.frame(conc = 0, time = c(0, 0.5,1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5, 5.5, 24)))), start_frame = 74, end_frame = 74, test = “superposition math”), list(message = "“, srcref = c(362, 3, 366, 50, 3, 50, 362, 366), expectation_calls = list(expect_warning(v1 <- superposition(conc = c1, time = t1, dose.input = 1, tau = 24, dose.times = c(0, 0.5), dose.amount = 1, additional.times = c(2.5, 3.5)), regexp =”essentially perfect fit")), call = list(expect_warning(v1 <- superposition(conc = c1,
time = t1, dose.input = 1, tau = 24, dose.times = c(0, 0.5), dose.amount = 1, additional.times =c(2.5, 3.5)), regexp = “essentially perfect fit”)), start_frame = 74, end_frame = 74, test = “superposition math”), list(message = “v1 not equal to data.frame(…).”, srcref = c(367, 3, 387, 72, 3, 72, 367, 387), expectation_calls = list(expect_equal(v1, data.frame(conc = c(4.6047e-06, 0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 5.4495, 4.4495, 3.4142, 2.4142, 1.7071, 1.2071, 0.85355, 4.6047e-06), time = c(0,
0.5, 1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5, 5.5,6, 6.5, 24)), tol= 0.001, info = "Dose scaling with matching input and output doses“)), call = list(expect_equal(v1, data.frame(conc = c(4.6047e-06, 0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 5.4495, 4.4495, 3.4142, 2.4142, 1.7071, 1.2071, 0.85355, 4.6047e-06), time = c(0, 0.5, 1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5, 5.5, 6, 6.5, 24)), tol = 0.001, info =”Dose scaling with matching input and output doses“)), start_frame = 74, end_frame = 74, test =”superposition math"),
list(message = "",srcref = c(389, 3, 393, 50, 3, 50, 389, 393), expectation_calls = list(expect_warning(v2 <- superposition(conc = c1, time = t1, dose.input = 1, tau = 24, dose.times = c(0, 0.5), dose.amount = c(0.5, 5), additional.times = c(2.5, 3.5)), regexp = “essentially perfect fit”)), call = list(expect_warning(v2 <- superposition(conc = c1, time = t1, dose.input = 1, tau = 24, dose.times = c(0, 0.5), dose.amount = c(0.5, 5), additional.times = c(2.5, 3.5)), regexp = “essentially perfect fit”)),
start_frame =74, end_frame = 74, test ="superposition math“), list(message =”`v2` not equal to data.frame(…).“, srcref = c(394, 3, 414, 73, 3, 73, 394, 414), expectation_calls = list(expect_equal(v2, data.frame(conc = c(1.444e-05, 0.25, 3, 5.75, 8.5, 11.25, 14, 16.22, 13.25, 10.71, 7.571, 5.354, 3.786, 2.677, 1.444e-05), time = c(0, 0.5, 1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5, 5.5, 6, 6.5, 24)), tol = 0.001, info =”Dose scaling with different input and output doses")), call = list(
expect_equal(v2, data.frame(conc = c(1.444e-05, 0.25, 3, 5.75, 8.5, 11.25, 14, 16.22, 13.25,10.71, 7.571, 5.354, 3.786, 2.677, 1.444e-05), time = c(0, 0.5, 1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5, 5, 5.5, 6, 6.5, 24)), tol = 0.001, info = “Dose scaling with different input and output doses”)), start_frame = 74, end_frame = 74, test = “superposition math”), list(message = "", srcref = c(416, 3, 419, 108, 3, 108, 416, 419), expectation_calls = list(expect_warning(v3 <- superposition(conc = c(0, 2,
3, 5, 6, 3, 1,0), time = c(0, 0.5, 1, 1.5, 2, 8, 12, 24),tau = 24), regexp = "Toofew points for half-life calculation \(min.hl.points=3 with only 2 points\)“)), call = list(expect_warning(v3 <- superposition(conc = c(0, 2, 3, 5, 6, 3, 1, 0), time = c(0, 0.5, 1, 1.5, 2, 8, 12, 24), tau = 24), regexp =”Too few points for half-life calculation \(min.hl.points=3 with only 2 points\)“)), start_frame = 74, end_frame = 74, test =”superposition math“), list(message =”v3 not equal to data.frame(conc = NA, time = c(0, 0.5, 1, 1.5, 2, 8, 12, 24)).",
srcref = c(420, 3, 422, 93, 3, 93, 420,422), expectation_calls = list(expect_equal(v3, data.frame(conc = NA, time = c(0, 0.5, 1, 1.5, 2, 8, 12, 24)), info = “Uncalculable lambda.z with extrapolation to steady-state gives NA conc”)), call = list(expect_equal(v3, data.frame(conc = NA, time = c(0, 0.5, 1, 1.5, 2, 8, 12, 24)), info = “Uncalculable lambda.z with extrapolation to steady-state gives NA conc”)), start_frame = 74, end_frame = 74, test = “superposition math”), list(message = “superposition(…) not equal to data.frame(…).”,
srcref = c(424, 3, 431, 118, 3, 118, 424, 431), expectation_calls = list(expect_equal(superposition(conc = c(0, 2, 3, 5, 6, 3, 1, 0), time = c(0, 0.5, 1, 1.5, 2, 8, 12, 24), tau = 24, lambda.z = 1, clast.pred = 1, tlast = 12), data.frame(conc = c(6.144e-06, 2, 3, 5, 6, 3, 1, 6.144e-06), time = c(0, 0.5, 1, 1.5, 2, 8, 12, 24)), tol = 0.001, info = “Uncalculable lambda.z with extrapolation to steady-state with lambda.z given, gives conc values”)), call = list(expect_equal(superposition(conc = c(0,
2, 3, 5, 6, 3, 1, 0), time = c(0, 0.5, 1, 1.5, 2, 8, 12, 24), tau = 24, lambda.z = 1, clast.pred = 1, tlast = 12), data.frame(conc = c(6.144e-06, 2, 3, 5, 6, 3, 1, 6.144e-06), time = c(0, 0.5, 1, 1.5, 2, 8, 12, 24)), tol = 0.001, info = “Uncalculable lambda.z with extrapolation to steady-state with lambda.z given, gives conc values”)), start_frame = 74, end_frame = 74, test = “superposition math”))
test-superpostion.RPKNCAconc superposition101list(list(message = “superposition(myconc, tau = 3, n.tau = 2) not equal to data.frame(…).”, srcref = c(439, 3, 442, 44, 3, 44, 439, 442), expectation_calls = list(expect_equal(superposition(myconc, tau = 3, n.tau = 2), data.frame(ID = rep(1:2, each = 4), conc = rep(c(3, 3, 3, 3.5), 2), time = rep(0:3, 2)))), call = list(expect_equal(superposition(myconc, tau = 3, n.tau = 2), data.frame(ID = rep(1:2, each = 4), conc = rep(c(3, 3, 3, 3.5), 2), time = rep(0:3, 2)))), start_frame = 74, end_frame = 74,
test = "PKNCAconcsuperposition"))

+

+

+
Time to steady-state

+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
Testing FilenameTest DescriptionNumber of TestsNumber of Failed Testspassedresult
test-time.to.steady.state.Rpk.tss.data.prep11011list(list(message = "“, srcref = c(10, 3, 15, 66, 3, 66, 10, 15), expectation_calls = list(expect_error(pk.tss.data.prep(conc = conc.test, time = time.test, subject = subject.test, treatment = treatment.test, time.dosing = NA), regexp =”time.dosing may not contain any NA values“)), call = list(expect_error(pk.tss.data.prep(conc = conc.test, time = time.test, subject = subject.test, treatment = treatment.test, time.dosing = NA), regexp =”time.dosing may not contain any NA values")), start_frame = 74,
end_frame = 74, test = "pk.tss.data.prep"), list(message = "", srcref= c(17, 3, 22, 66, 3, 66, 17, 22), expectation_calls = list(expect_error(pk.tss.data.prep(conc = conc.test, time = time.test, subject = subject.test, treatment = treatment.test, time.dosing = c(0, NA)), regexp = “time.dosing may not contain any NA values”)), call = list(expect_error(pk.tss.data.prep(conc = conc.test, time = time.test, subject = subject.test, treatment = treatment.test, time.dosing = c(0, NA)), regexp = “time.dosing may not contain any NA values”)),
start_frame = 74, end_frame = 74, test = "pk.tss.data.prep"), list(message = "", srcref = c(25, 3, 30,71, 3, 71, 25, 30), expectation_calls = list(expect_error(pk.tss.data.prep(conc = conc.test, time = time.test, subject = subject.test[-1], treatment = treatment.test, time.dosing = time.dosing.test), regexp = “arguments imply differing number of rows: 5, 4”)), call = list(expect_error(pk.tss.data.prep(conc = conc.test, time = time.test, subject = subject.test[-1], treatment = treatment.test,
time.dosing = time.dosing.test), regexp = "arguments imply differingnumber of rows: 5, 4")),start_frame = 74, end_frame = 74, test = “pk.tss.data.prep”), list(message = "“, srcref = c(33, 3, 38, 71, 3, 71, 33, 38), expectation_calls = list(expect_error(pk.tss.data.prep(conc = conc.test, time = time.test, subject = subject.test, treatment = treatment.test[-1], time.dosing = time.dosing.test), regexp =”arguments imply differing number of rows: 5, 4")), call = list(expect_error(pk.tss.data.prep(conc = conc.test,
time = time.test, subject= subject.test, treatment= treatment.test[-1], time.dosing = time.dosing.test), regexp = “arguments imply differing number of rows: 5, 4”)), start_frame = 74, end_frame = 74, test = “pk.tss.data.prep”), list(message = “pk.tss.data.prep(…) not equal to data.frame(conc = 1, time = 0).”, srcref = c(42, 3, 47, 42, 3, 42, 42, 47), expectation_calls = list(expect_equal(pk.tss.data.prep(conc = conc.test, time = time.test, subject = subject.test, treatment = treatment.test,
time.dosing = time.dosing.test), data.frame(conc =1, time = 0))), call = list(expect_equal(pk.tss.data.prep(conc = conc.test, time = time.test, subject = subject.test, treatment = treatment.test, time.dosing = time.dosing.test), data.frame(conc = 1, time = 0))), start_frame = 74, end_frame = 74, test = “pk.tss.data.prep”), list(message = “pk.tss.data.prep(…) not equal to data.frame(conc = 1, time = 0).”, srcref = c(50, 3, 54, 42, 3, 42, 50, 54), expectation_calls = list(expect_equal(pk.tss.data.prep(conc = conc.test,
time = time.test, subject= subject.test, time.dosing = time.dosing.test), data.frame(conc = 1, time =0))), call = list(expect_equal(pk.tss.data.prep(conc = conc.test, time = time.test, subject = subject.test, time.dosing = time.dosing.test), data.frame(conc = 1, time = 0))), start_frame = 74, end_frame = 74, test = “pk.tss.data.prep”), list(message = “pk.tss.data.prep(…) not equal to data.frame(conc = 1, time = 0).”, srcref = c(57, 3, 61, 42, 3, 42, 57, 61), expectation_calls = list(
expect_equal(pk.tss.data.prep(conc = conc.test, time = time.test, treatment = treatment.test,time.dosing = time.dosing.test), data.frame(conc = 1, time = 0))), call = list(expect_equal(pk.tss.data.prep(conc = conc.test, time = time.test, treatment = treatment.test, time.dosing = time.dosing.test), data.frame(conc = 1, time = 0))), start_frame = 74, end_frame = 74, test = “pk.tss.data.prep”), list(message = “pk.tss.data.prep(…) not equal to data.frame(time = 0, conc = 1).”, srcref = c(65,
3, 71, 42, 3, 42, 65, 71), expectation_calls = list(expect_equal(pk.tss.data.prep(conc = conc.test, time =time.test, subject = subject.test, treatment = treatment.test, time.dosing = time.dosing.test, subject.dosing = subject.test), data.frame(time = 0, conc = 1))), call = list(expect_equal(pk.tss.data.prep(conc = conc.test, time = time.test, subject = subject.test, treatment = treatment.test, time.dosing = time.dosing.test, subject.dosing = subject.test), data.frame(time = 0, conc = 1))), start_frame = 74,
end_frame = 74, test = "pk.tss.data.prep"), list(message = "pk.tss.data.prep(…) not equal todata.frame(conc = 1, time = 0).", srcref = c(74, 3, 78, 42, 3, 42, 74, 78), expectation_calls = list(expect_equal(pk.tss.data.prep(conc = conc.test, time = time.test, subject = subject.test, time.dosing = time.dosing.test), data.frame(conc = 1, time = 0))), call = list(expect_equal(pk.tss.data.prep(conc = conc.test, time = time.test, subject = subject.test, time.dosing = time.dosing.test), data.frame(conc = 1,
time = 0))), start_frame =74, end_frame = 74, test= "pk.tss.data.prep“), list(message =”pk.tss.data.prep(…) not equal to data.frame(…).“, srcref = c(86, 3, 94, 38, 3, 38, 86, 94), expectation_calls = list(expect_equal(pk.tss.data.prep(conc = conc.test, time = time.test, subject = subject.test, treatment = treatment.test, time.dosing = time.dosing.test), data.frame(conc = c(1, 6), time = c(0, 0), subject = c(”a“,”f“), treatment = c(”A“,”F")), check.attributes = FALSE)), call = list(
expect_equal(pk.tss.data.prep(conc = conc.test, time = time.test, subject = subject.test, treatment = treatment.test, time.dosing = time.dosing.test), data.frame(conc = c(1, 6), time = c(0, 0), subject = c(“a”, “f”), treatment = c(“A”, “F”)), check.attributes = FALSE)), start_frame = 74, end_frame = 74, test = “pk.tss.data.prep”), list(message = “pk.tss.data.prep(…) not equal to data.frame(conc = c(1, 6), time = c(0, 0), subject = c("a", "f")).”, srcref = c(102, 3, 109, 38, 3, 38,
102, 109), expectation_calls =list(expect_equal(pk.tss.data.prep(conc =conc.test, time = time.test, subject = subject.test, treatment = treatment.test, time.dosing = time.dosing.test), data.frame(conc = c(1, 6), time = c(0, 0), subject = c(“a”, “f”)), check.attributes = FALSE)), call = list(expect_equal(pk.tss.data.prep(conc = conc.test, time = time.test, subject = subject.test, treatment = treatment.test, time.dosing = time.dosing.test), data.frame(conc = c(1, 6), time = c(0, 0), subject = c(“a”,
“f”)), check.attributes =FALSE)), start_frame = 74, end_frame = 74,test = “pk.tss.data.prep”))
test-time.to.steady.state.Rpk.tss.stepwise.linear15015list(list(message = “pk.tss.stepwise.linear(…) not equal to data.frame(tss.stepwise.linear = 7).”, srcref = c(142, 3, 150, 36, 3, 36, 142, 150), expectation_calls = list(expect_equal(pk.tss.stepwise.linear(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14, verbose = FALSE), data.frame(tss.stepwise.linear = 7), info = “pk.tss.stepwise.linear 1”)), call = list(expect_equal(pk.tss.stepwise.linear(conc = tmpdata\(conc, time = tmpdata\)time,
subject = tmpdata$subject,treatment = tmpdata$treatment, time.dosing= 0:14, verbose = FALSE), data.frame(tss.stepwise.linear = 7), info = “pk.tss.stepwise.linear 1”)), start_frame = 74, end_frame = 74, test = “pk.tss.stepwise.linear”), list(message = "", srcref = c(152, 3, 161, 36, 3, 36, 152, 161), expectation_calls = list(expect_warning(pk.tss.stepwise.linear(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, min.points = c(3, 4), time.dosing = 0:14,
verbose = FALSE), regex ="Only first value of min.points is used", info = "pk.tss.stepwise.linear 2")), call = list(expect_warning(pk.tss.stepwise.linear(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, min.points = c(3, 4), time.dosing = 0:14, verbose = FALSE), regex = “Only first value of min.points is used”, info = “pk.tss.stepwise.linear 2”)), start_frame = 74, end_frame = 74, test = “pk.tss.stepwise.linear”), list(message = "", srcref = c(164,
3, 173, 36, 3, 36, 164, 173),expectation_calls = list(expect_error(pk.tss.stepwise.linear(conc =tmpdata$conc, time = tmpdata\(time, subject = tmpdata\)subject, treatment = tmpdata\(treatment, time.dosing = 0:14, level = "A", verbose = FALSE), regex = "level must be a number", info = "pk.tss.stepwise.linear 3")), call = list(expect_error(pk.tss.stepwise.linear(conc = tmpdata\)conc, time = tmpdata\(time, subject = tmpdata\)subject, treatment = tmpdata$treatment, time.dosing = 0:14, level = “A”, verbose = FALSE),
regex = "level must be a number“, info =”pk.tss.stepwise.linear 3")), start_frame = 74, end_frame = 74, test = “pk.tss.stepwise.linear”), list(message = "“, srcref = c(175, 3, 184, 36, 3, 36, 175, 184), expectation_calls = list(expect_error(pk.tss.stepwise.linear(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14, level = 2, verbose = FALSE), regex =”level must be between 0 and 1, exclusive“, info =”pk.tss.stepwise.linear 4")),
call = list(expect_error(pk.tss.stepwise.linear(conc = tmpdata$conc,time = tmpdata$time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14, level = 2, verbose = FALSE), regex = “level must be between 0 and 1, exclusive”, info = “pk.tss.stepwise.linear 4”)), start_frame = 74, end_frame = 74, test = “pk.tss.stepwise.linear”), list(message = "", srcref = c(186, 3, 195, 36, 3, 36, 186, 195), expectation_calls = list(expect_error(pk.tss.stepwise.linear(conc = tmpdata$conc,
time = tmpdata$time, subject = tmpdata$subject, treatment = tmpdata$treatment, time.dosing = 0:14, level = -1, verbose = FALSE), regex = “level must be between 0 and 1, exclusive”, info = “pk.tss.stepwise.linear 5”)), call = list(expect_error(pk.tss.stepwise.linear(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14, level = -1, verbose = FALSE), regex = “level must be between 0 and 1, exclusive”, info = “pk.tss.stepwise.linear 5”)),
start_frame = 74, end_frame = 74, test = "pk.tss.stepwise.linear"), list(message = "", srcref= c(196,3, 205, 36, 3, 36, 196, 205), expectation_calls = list(expect_error(pk.tss.stepwise.linear(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14, level = 0, verbose = FALSE), regex = “level must be between 0 and 1, exclusive”, info = “pk.tss.stepwise.linear 6”)), call = list(expect_error(pk.tss.stepwise.linear(conc = tmpdata$conc,
time = tmpdata$time, subject = tmpdata$subject, treatment = tmpdata$treatment, time.dosing = 0:14, level = 0, verbose = FALSE), regex = “level must be between 0 and 1, exclusive”, info = “pk.tss.stepwise.linear 6”)), start_frame = 74, end_frame = 74, test = “pk.tss.stepwise.linear”), list(message = "", srcref = c(206, 3, 215, 36, 3, 36, 206, 215), expectation_calls = list(expect_error(pk.tss.stepwise.linear(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment,
time.dosing = 0:14, level= 1, verbose = FALSE), regex = "level mustbe between 0 and 1, exclusive", info = “pk.tss.stepwise.linear 7”)), call = list(expect_error(pk.tss.stepwise.linear(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14, level = 1, verbose = FALSE), regex = “level must be between 0 and 1, exclusive”, info = “pk.tss.stepwise.linear 7”)), start_frame = 74, end_frame = 74, test = “pk.tss.stepwise.linear”), list(
message = "", srcref = c(217, 3, 226, 36, 3, 36, 217, 226), expectation_calls = list(expect_warning(pk.tss.stepwise.linear(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14, level = c(0.95, 0.99), verbose = FALSE), regex = “Only first value of level is being used”, info = “pk.tss.stepwise.linear 8”)), call = list(expect_warning(pk.tss.stepwise.linear(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment,
time.dosing = 0:14, level = c(0.95, 0.99), verbose = FALSE), regex = "Only first value oflevel isbeing used“, info =”pk.tss.stepwise.linear 8“)), start_frame = 74, end_frame = 74, test =”pk.tss.stepwise.linear“), list(message =”", srcref = c(229, 3, 238, 36, 3, 36, 229, 238), expectation_calls = list(expect_warning(pk.tss.stepwise.linear(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14, level = c(0.95, 0.99), verbose = FALSE),
regex = "Only first valueof level is being used",info = "pk.tss.stepwise.linear 9")), call =list(expect_warning(pk.tss.stepwise.linear(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14, level = c(0.95, 0.99), verbose = FALSE), regex = “Only first value of level is being used”, info = “pk.tss.stepwise.linear 9”)), start_frame = 74, end_frame = 74, test = “pk.tss.stepwise.linear”), list(message = "", srcref = c(241, 3, 248,
42, 3, 42, 241, 248), expectation_calls = list(expect_warning(v1 <- pk.tss.stepwise.linear(conc =tmpdata$conc, time = tmpdata\(time, subject = tmpdata\)subject, treatment = tmpdata\(treatment, time.dosing = 0:14, level = c(0.8, 0.99), verbose = FALSE))), call = list(expect_warning(v1 <- pk.tss.stepwise.linear(conc = tmpdata\)conc, time = tmpdata\(time, subject = tmpdata\)subject, treatment = tmpdata$treatment, time.dosing = 0:14, level = c(0.8, 0.99), verbose = FALSE))), start_frame = 74, end_frame = 74,
test = "pk.tss.stepwise.linear“), list(message =”`v1` not equal to pk.tss.stepwise.linear(…).", srcref = c(249, 3, 258, 37, 3, 37, 249, 258), expectation_calls = list(expect_equal(v1, pk.tss.stepwise.linear(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14, level = 0.8, verbose = FALSE), info = “pk.tss.stepwise.linear 10”)), call = list(expect_equal(v1, pk.tss.stepwise.linear(conc = tmpdata\(conc, time = tmpdata\)time,
subject = tmpdata$subject,treatment = tmpdata$treatment, time.dosing= 0:14, level = 0.8, verbose = FALSE), info = “pk.tss.stepwise.linear 10”)), start_frame = 74, end_frame = 74, test = “pk.tss.stepwise.linear”), list(message = "", srcref = c(261, 3, 270, 98, 3, 98, 261, 270), expectation_calls = list(expect_warning(v1 <- pk.tss.stepwise.linear(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:1, min.points = 3, level = 0.99,
verbose = FALSE), regexp ="After removing non-dosing time points, insufficient data remains for tss calculation“)), call = list(expect_warning(v1 <- pk.tss.stepwise.linear(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:1, min.points = 3, level = 0.99, verbose = FALSE), regexp =”After removing non-dosing time points, insufficient data remains for tss calculation“)), start_frame = 74, end_frame = 74, test =”pk.tss.stepwise.linear"),
list(message = "v1 not equal to NA.", srcref = c(271, 3, 271,22, 3, 22, 271, 271), expectation_calls = list(expect_equal(v1, NA)), call = list(expect_equal(v1, NA)), start_frame = 74, end_frame = 74, test = “pk.tss.stepwise.linear”), list(message = "", srcref = c(272, 3, 281, 98, 3, 98, 272, 281), expectation_calls = list(expect_warning(pk.tss.stepwise.linear(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:1, min.points = 3,
level = 0.99, verbose= FALSE), regexp = "Afterremoving non-dosing time points, insufficient dataremains for tss calculation“)), call = list(expect_warning(pk.tss.stepwise.linear(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:1, min.points = 3, level = 0.99, verbose = FALSE), regexp =”After removing non-dosing time points, insufficient data remains for tss calculation“)), start_frame = 74, end_frame = 74, test =”pk.tss.stepwise.linear"),
list(message = "pk.tss.stepwise.linear(…) not equal to data.frame(tss.stepwise.linear = 5).\nTRUE", srcref = c(284, 3, 291, 45, 3, 45, 284, 291), expectation_calls = list(expect_equal(pk.tss.stepwise.linear(conc = tmpdata\(conc, time = tmpdata\)time, treatment = tmpdata\(treatment, time.dosing = 0:14, verbose = FALSE), data.frame(tss.stepwise.linear = 5), info = "pk.tss.stepwise.linear no subject")), call = list(expect_equal(pk.tss.stepwise.linear(conc = tmpdata\)conc, time = tmpdata\(time, treatment = tmpdata\)treatment,
time.dosing = 0:14, verbose = FALSE), data.frame(tss.stepwise.linear = 5), info = "pk.tss.stepwise.linear no subject“)), start_frame = 74, end_frame = 74, test =”pk.tss.stepwise.linear"))
test-time.to.steady.state.Rpk.tss.monoexponential909list(list(message = "", srcref = c(296, 3, 324, 36, 3, 36, 296, 324), expectation_calls = list(expect_equal(expect_warning(pk.tss.monoexponential(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14, verbose = FALSE)), data.frame(subject = factor(c(1, 10, 2:9)), tss.monoexponential.population = 4.57618156812974, tss.monoexponential.popind = c(5.14156352865421, 4.64862524830397, 4.45956707917941, 4.41492203844343, 4.6782583033301, 4.0823047621517,
4.96242115751172, 4.52424147509819, 3.70338406668837, 5.1465280219363), treatment = c(“A”, “B”, “A”, "A“,”A“,”A“,”B“,”B“,”B“,”B“), tss.monoexponential.individual = c(5.87784329336254, 4.71066285661623, 4.51882509145954, 3.91269286106442, 4.74475071729459, 3.99341726779716, 5.08737230904342, 4.50068650719192, 3.4876172020751, 5.35051537086801), tss.monoexponential.single = 4.56067603534), tolerance = 1e-04, check.attributes = FALSE, info =”pk.tss.monoexponential 1"), quasi_label(enquo(object),
label, arg = “object”), eval_bare(get_expr(quo), get_env(quo)), expect_warning(pk.tss.monoexponential(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14, verbose = FALSE))), call = list(expect_equal(expect_warning(pk.tss.monoexponential(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14, verbose = FALSE)), data.frame(subject = factor(c(1, 10, 2:9)), tss.monoexponential.population = 4.57618156812974,
tss.monoexponential.popind= c(5.14156352865421, 4.64862524830397, 4.45956707917941, 4.41492203844343,4.6782583033301, 4.0823047621517, 4.96242115751172, 4.52424147509819, 3.70338406668837, 5.1465280219363), treatment = c(“A”, “B”, “A”, “A”, “A”, “A”, “B”, “B”, “B”, “B”), tss.monoexponential.individual = c(5.87784329336254, 4.71066285661623, 4.51882509145954, 3.91269286106442, 4.74475071729459, 3.99341726779716, 5.08737230904342, 4.50068650719192, 3.4876172020751, 5.35051537086801), tss.monoexponential.single = 4.56067603534),
tolerance = 1e-04, check.attributes = FALSE, info ="pk.tss.monoexponential 1"), quasi_label(enquo(object), label, arg = “object”), eval_bare(get_expr(quo), get_env(quo)), expect_warning(pk.tss.monoexponential(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14, verbose = FALSE))), start_frame = 74, end_frame = 77, test = “pk.tss.monoexponential”), list(message = “expect_warning(…) not equal to data.frame(…).”, srcref = c(296,
3, 324, 36, 3, 36, 296, 324),expectation_calls = list(expect_equal(expect_warning(pk.tss.monoexponential(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14, verbose = FALSE)), data.frame(subject = factor(c(1, 10, 2:9)), tss.monoexponential.population = 4.57618156812974, tss.monoexponential.popind = c(5.14156352865421, 4.64862524830397, 4.45956707917941, 4.41492203844343, 4.6782583033301, 4.0823047621517, 4.96242115751172, 4.52424147509819,
3.70338406668837, 5.1465280219363), treatment = c("A“,”B“,”A“,”A",“A”, “A”, “B”, “B”, “B”,“B”), tss.monoexponential.individual = c(5.87784329336254, 4.71066285661623, 4.51882509145954, 3.91269286106442, 4.74475071729459, 3.99341726779716, 5.08737230904342, 4.50068650719192, 3.4876172020751, 5.35051537086801), tss.monoexponential.single = 4.56067603534), tolerance = 1e-04, check.attributes = FALSE, info = “pk.tss.monoexponential 1”)), call = list(expect_equal(expect_warning(pk.tss.monoexponential(conc = tmpdata$conc,
time = tmpdata$time, subject = tmpdata$subject, treatment = tmpdata$treatment, time.dosing = 0:14, verbose = FALSE)), data.frame(subject = factor(c(1, 10, 2:9)), tss.monoexponential.population = 4.57618156812974, tss.monoexponential.popind = c(5.14156352865421, 4.64862524830397, 4.45956707917941, 4.41492203844343, 4.6782583033301, 4.0823047621517, 4.96242115751172, 4.52424147509819, 3.70338406668837, 5.1465280219363), treatment = c(“A”, “B”, “A”, “A”, “A”, “A”, “B”, “B”, “B”, “B”), tss.monoexponential.individual = c(5.87784329336254,
4.71066285661623, 4.51882509145954, 3.91269286106442, 4.74475071729459, 3.99341726779716, 5.08737230904342, 4.50068650719192, 3.4876172020751, 5.35051537086801), tss.monoexponential.single = 4.56067603534), tolerance = 1e-04, check.attributes = FALSE, info = “pk.tss.monoexponential 1”)), start_frame = 74, end_frame = 74, test = “pk.tss.monoexponential”), list(message = "", srcref = c(327, 3, 334, 60, 3, 60, 327, 334), expectation_calls = list(expect_warning(pk.tss.monoexponential(conc = tmpdata$conc,
time = tmpdata$time, subject = tmpdata$subject, treatment = tmpdata$treatment, time.dosing = 0:14, tss.fraction = c(0.5, 0.8)), regexp = “Only first value of tss.fraction is being used”)), call = list(expect_warning(pk.tss.monoexponential(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14, tss.fraction = c(0.5, 0.8)), regexp = “Only first value of tss.fraction is being used”)), start_frame = 74, end_frame = 74, test = “pk.tss.monoexponential”),
list(message = "", srcref= c(335, 3, 342, 61, 3, 61, 335, 342), expectation_calls = list(expect_error(pk.tss.monoexponential(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14, tss.fraction = 0), regexp = “tss.fraction must be between 0 and 1, exclusive”)), call = list(expect_error(pk.tss.monoexponential(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14, tss.fraction = 0),
regexp = "tss.fractionmust be between 0 and 1,exclusive")), start_frame = 74, end_frame= 74, test = “pk.tss.monoexponential”), list(message = "“, srcref = c(343, 3, 350, 61, 3, 61, 343, 350), expectation_calls = list(expect_error(pk.tss.monoexponential(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14, tss.fraction = 1), regexp =”tss.fraction must be between 0 and 1, exclusive")), call = list(expect_error(pk.tss.monoexponential(conc = tmpdata$conc,
time = tmpdata$time, subject = tmpdata$subject,treatment = tmpdata$treatment, time.dosing= 0:14,tss.fraction = 1), regexp = “tss.fraction must be between 0 and 1, exclusive”)), start_frame = 74, end_frame = 74, test = “pk.tss.monoexponential”), list(message = "", srcref = c(351, 3, 358, 61, 3, 61, 351, 358), expectation_calls = list(expect_error(pk.tss.monoexponential(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14,
tss.fraction = -1), regexp = "tss.fraction mustbe between 0 and1, exclusive")), call = list(expect_error(pk.tss.monoexponential(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14, tss.fraction = -1), regexp = “tss.fraction must be between 0 and 1, exclusive”)), start_frame = 74, end_frame = 74, test = “pk.tss.monoexponential”), list(message = "", srcref = c(359, 3, 366, 61, 3, 61, 359, 366), expectation_calls = list(expect_error(pk.tss.monoexponential(conc = tmpdata$conc,
time = tmpdata$time, subject = tmpdata$subject,treatment = tmpdata$treatment, time.dosing= 0:14,tss.fraction = 2), regexp = “tss.fraction must be between 0 and 1, exclusive”)), call = list(expect_error(pk.tss.monoexponential(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14, tss.fraction = 2), regexp = “tss.fraction must be between 0 and 1, exclusive”)), start_frame = 74, end_frame = 74, test = “pk.tss.monoexponential”),
list(message = "", srcref= c(367, 3, 374, 44, 3, 44, 367, 374), expectation_calls = list(expect_warning(pk.tss.monoexponential(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14, tss.fraction = 0.5), regexp = “tss.fraction is usually >= 0.8”)), call = list(expect_warning(pk.tss.monoexponential(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14, tss.fraction = 0.5),
regexp = "tss.fractionis usually >= 0.8")), start_frame = 74, end_frame = 74, test = "pk.tss.monoexponential“), list(message =”pk.tss.monoexponential(…) not equal to data.frame(tss.monoexponential.single = NA_real_).“, srcref = c(376, 3, 385, 72, 3, 72, 376, 385), expectation_calls = list(expect_equal(pk.tss.monoexponential(conc = c(0, 1000), time = 0:1, subject = c(1, 1), treatment = c(”A“,”A“), time.dosing = 0:1, tss.fraction = 0.9, output =”single"), data.frame(tss.monoexponential.single = NA),
info = "Single-subjectdata fitting works whenit does not converge.")), call = list(expect_equal(pk.tss.monoexponential(conc = c(0, 1000), time = 0:1, subject = c(1, 1), treatment = c(“A”, “A”), time.dosing = 0:1, tss.fraction = 0.9, output = “single”), data.frame(tss.monoexponential.single = NA), info = “Single-subject data fitting works when it does not converge.”)), start_frame = 74, end_frame = 74, test = “pk.tss.monoexponential”))
test-time.to.steady.state.Rpk.tss707list(list(message = "“, srcref = c(391, 3, 409, 3, 3, 3, 391, 409), expectation_calls = list(expect_equal(expect_warning(pk.tss(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14, verbose = FALSE, type =”monoexponential")), expect_warning(pk.tss.monoexponential(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14, verbose = FALSE))), quasi_label(enquo(object), label,
arg = “object”), eval_bare(get_expr(quo), get_env(quo)), expect_warning(pk.tss(conc = tmpdata$conc, time = tmpdata\(time, subject = tmpdata\)subject, treatment = tmpdata\(treatment, time.dosing = 0:14, verbose = FALSE, type = "monoexponential"))), call = list(expect_equal(expect_warning(pk.tss(conc = tmpdata\)conc, time = tmpdata\(time, subject = tmpdata\)subject, treatment = tmpdata\(treatment, time.dosing = 0:14, verbose = FALSE, type = "monoexponential")), expect_warning(pk.tss.monoexponential(conc = tmpdata\)conc,
time = tmpdata$time, subject = tmpdata$subject, treatment = tmpdata$treatment, time.dosing = 0:14, verbose = FALSE))), quasi_label(enquo(object), label, arg = “object”), eval_bare(get_expr(quo), get_env(quo)), expect_warning(pk.tss(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14, verbose = FALSE, type = “monoexponential”))), start_frame = 74, end_frame = 77, test = “pk.tss”), list(message = "", srcref = c(391, 3, 409, 3, 3,
3, 391, 409), expectation_calls = list(expect_equal(expect_warning(pk.tss(conc = tmpdata$conc, time = tmpdata\(time, subject = tmpdata\)subject, treatment = tmpdata\(treatment, time.dosing = 0:14, verbose = FALSE, type = "monoexponential")), expect_warning(pk.tss.monoexponential(conc = tmpdata\)conc, time = tmpdata\(time, subject = tmpdata\)subject, treatment = tmpdata$treatment, time.dosing = 0:14, verbose = FALSE))), quasi_label(enquo(expected), expected.label, arg = “expected”), eval_bare(get_expr(quo),
get_env(quo)), expect_warning(pk.tss.monoexponential(conc = tmpdata$conc, time = tmpdata$time,subject= tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14, verbose = FALSE))), call = list(expect_equal(expect_warning(pk.tss(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14, verbose = FALSE, type = “monoexponential”)), expect_warning(pk.tss.monoexponential(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata$subject,
treatment = tmpdata$treatment, time.dosing = 0:14,verbose = FALSE))), quasi_label(enquo(expected), expected.label, arg = “expected”), eval_bare(get_expr(quo), get_env(quo)), expect_warning(pk.tss.monoexponential(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14, verbose = FALSE))), start_frame = 74, end_frame = 77, test = “pk.tss”), list(message = “expect_warning(…) not equal to expect_warning(…).”, srcref = c(391,
3, 409, 3, 3, 3, 391, 409), expectation_calls = list(expect_equal(expect_warning(pk.tss(conc = tmpdata$conc, time = tmpdata\(time, subject = tmpdata\)subject, treatment = tmpdata\(treatment, time.dosing = 0:14, verbose = FALSE, type = "monoexponential")), expect_warning(pk.tss.monoexponential(conc = tmpdata\)conc, time = tmpdata\(time, subject = tmpdata\)subject, treatment = tmpdata\(treatment, time.dosing = 0:14, verbose = FALSE)))), call = list(expect_equal(expect_warning(pk.tss(conc = tmpdata\)conc, time = tmpdata$time,
subject = tmpdata$subject,treatment = tmpdata$treatment, time.dosing= 0:14, verbose = FALSE,type = "monoexponential“)), expect_warning(pk.tss.monoexponential(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14, verbose = FALSE)))), start_frame = 74, end_frame = 74, test =”pk.tss“), list(message =”pk.tss(…) not equal to pk.tss.stepwise.linear(…).", srcref = c(411, 3, 424, 42, 3, 42, 411, 424), expectation_calls = list(
expect_equal(pk.tss(conc =tmpdata$conc, time = tmpdata$time, subject= tmpdata$subject, treatment = tmpdata\(treatment, time.dosing = 0:14, verbose = FALSE, type = "stepwise.linear"), pk.tss.stepwise.linear(conc = tmpdata\)conc, time = tmpdata\(time, subject = tmpdata\)subject, treatment = tmpdata\(treatment, time.dosing = 0:14, verbose = FALSE))), call = list(expect_equal(pk.tss(conc = tmpdata\)conc, time = tmpdata\(time, subject = tmpdata\)subject, treatment = tmpdata$treatment, time.dosing = 0:14,
verbose = FALSE, type = "stepwise.linear"), pk.tss.stepwise.linear(conc = tmpdata$conc, time =tmpdata$time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14, verbose = FALSE))), start_frame = 74, end_frame = 74, test = “pk.tss”), list(message = "", srcref = c(427, 3, 452, 16, 3, 16, 427, 452), expectation_calls = list(expect_equal(expect_warning(pk.tss(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14,
verbose = FALSE, type = c(“monoexponential”, "stepwise.linear"))), merge(expect_warning(pk.tss.monoexponential(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14, verbose = FALSE)), pk.tss.stepwise.linear(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14, verbose = FALSE), all = TRUE)), quasi_label(enquo(object), label, arg = “object”), eval_bare(get_expr(quo),
get_env(quo)), expect_warning(pk.tss(conc = tmpdata$conc, time = tmpdata$time, subject = tmpdata$subject, treatment = tmpdata\(treatment, time.dosing = 0:14, verbose = FALSE, type = c("monoexponential", "stepwise.linear")))), call = list(expect_equal(expect_warning(pk.tss(conc = tmpdata\)conc, time = tmpdata\(time, subject = tmpdata\)subject, treatment = tmpdata\(treatment, time.dosing = 0:14, verbose = FALSE, type = c("monoexponential", "stepwise.linear"))), merge(expect_warning(pk.tss.monoexponential(conc = tmpdata\)conc,
time = tmpdata$time, subject = tmpdata$subject, treatment = tmpdata$treatment, time.dosing = 0:14, verbose = FALSE)), pk.tss.stepwise.linear(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14, verbose = FALSE), all = TRUE)), quasi_label(enquo(object), label, arg = “object”), eval_bare(get_expr(quo), get_env(quo)), expect_warning(pk.tss(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment,
time.dosing = 0:14, verbose = FALSE, type = c("monoexponential“,”stepwise.linear")))), start_frame = 74, end_frame = 77, test = “pk.tss”), list(message = "“, srcref = c(427, 3, 452, 16, 3, 16, 427, 452), expectation_calls = list(expect_equal(expect_warning(pk.tss(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14, verbose = FALSE, type = c(”monoexponential“,”stepwise.linear"))), merge(expect_warning(pk.tss.monoexponential(conc = tmpdata$conc,
time = tmpdata$time, subject = tmpdata$subject, treatment = tmpdata$treatment, time.dosing = 0:14, verbose = FALSE)), pk.tss.stepwise.linear(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14, verbose = FALSE), all = TRUE)), quasi_label(enquo(expected), expected.label, arg = “expected”), eval_bare(get_expr(quo), get_env(quo)), merge(expect_warning(pk.tss.monoexponential(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata$subject,
treatment = tmpdata$treatment, time.dosing = 0:14,verbose = FALSE)),pk.tss.stepwise.linear(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14, verbose = FALSE), all = TRUE), expect_warning(pk.tss.monoexponential(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14, verbose = FALSE))), call = list(expect_equal(expect_warning(pk.tss(conc = tmpdata\(conc, time = tmpdata\)time,
subject = tmpdata$subject,treatment = tmpdata$treatment, time.dosing= 0:14, verbose = FALSE,type = c(“monoexponential”, “stepwise.linear”))), merge(expect_warning(pk.tss.monoexponential(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14, verbose = FALSE)), pk.tss.stepwise.linear(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14, verbose = FALSE), all = TRUE)),
quasi_label(enquo(expected), expected.label, arg =“expected”), eval_bare(get_expr(quo), get_env(quo)),merge(expect_warning(pk.tss.monoexponential(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14, verbose = FALSE)), pk.tss.stepwise.linear(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14, verbose = FALSE), all = TRUE), expect_warning(pk.tss.monoexponential(conc = tmpdata$conc,
time = tmpdata$time, subject = tmpdata$subject,treatment = tmpdata$treatment, time.dosing= 0:14,verbose = FALSE))), start_frame = 74, end_frame = 78, test = “pk.tss”), list(message = “expect_warning(…) not equal to merge(…).”, srcref = c(427, 3, 452, 16, 3, 16, 427, 452), expectation_calls = list(expect_equal(expect_warning(pk.tss(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14, verbose = FALSE, type = c(“monoexponential”,
“stepwise.linear”))), merge(expect_warning(pk.tss.monoexponential(conc = tmpdata$conc, time =tmpdata$time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14, verbose = FALSE)), pk.tss.stepwise.linear(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14, verbose = FALSE), all = TRUE))), call = list(expect_equal(expect_warning(pk.tss(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata$subject,
treatment = tmpdata$treatment, time.dosing = 0:14,verbose = FALSE, type = c(“monoexponential”, "stepwise.linear"))), merge(expect_warning(pk.tss.monoexponential(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14, verbose = FALSE)), pk.tss.stepwise.linear(conc = tmpdata\(conc, time = tmpdata\)time, subject = tmpdata\(subject, treatment = tmpdata\)treatment, time.dosing = 0:14, verbose = FALSE), all = TRUE))), start_frame = 74, end_frame = 74,
test = “pk.tss”))

+

+

+

+
Session Information

+
Sys.Date()

+
## [1] "2019-07-28"

+
sessionInfo()

+
## R version 3.6.1 (2019-07-05)
+## Platform: x86_64-w64-mingw32/x64 (64-bit)
+## Running under: Windows 10 x64 (build 18362)
+## 
+## Matrix products: default
+## 
+## locale:
+## [1] LC_COLLATE=English_United States.1252 
+## [2] LC_CTYPE=English_United States.1252   
+## [3] LC_MONETARY=English_United States.1252
+## [4] LC_NUMERIC=C                          
+## [5] LC_TIME=English_United States.1252    
+## 
+## attached base packages:
+## [1] stats     graphics  grDevices utils     datasets  methods   base     
+## 
+## other attached packages:
+## [1] testthat_2.1.1 ggplot2_3.2.0  knitr_1.23     cowplot_1.0.0 
+## [5] dplyr_0.8.3    PKNCA_0.9.0   
+## 
+## loaded via a namespace (and not attached):
+##  [1] Rcpp_1.0.1        highr_0.8         pillar_1.4.2     
+##  [4] compiler_3.6.1    prettyunits_1.0.2 remotes_2.1.0    
+##  [7] tools_3.6.1       digest_0.6.20     pkgbuild_1.0.3   
+## [10] pkgload_1.0.2     lattice_0.20-38   nlme_3.1-140     
+## [13] tibble_2.1.3      memoise_1.1.0     evaluate_0.14    
+## [16] gtable_0.3.0      pkgconfig_2.0.2   rlang_0.4.0      
+## [19] cli_1.1.0         rstudioapi_0.10   parallel_3.6.1   
+## [22] yaml_2.2.0        xfun_0.8          withr_2.1.2      
+## [25] stringr_1.4.0     desc_1.2.0        fs_1.3.1         
+## [28] devtools_2.1.0    tidyselect_0.2.5  rprojroot_1.3-2  
+## [31] grid_3.6.1        glue_1.3.1        R6_2.4.0         
+## [34] processx_3.4.1    rmarkdown_1.14    sessioninfo_1.1.1
+## [37] tidyr_0.8.3       purrr_0.3.2       callr_3.3.1      
+## [40] magrittr_1.5      MASS_7.3-51.4     backports_1.1.4  
+## [43] scales_1.0.0      ps_1.3.0          htmltools_0.3.6  
+## [46] usethis_1.5.1     assertthat_0.2.1  colorspace_1.4-1 
+## [49] labeling_0.3      stringi_1.4.3     lazyeval_0.2.2   
+## [52] munsell_0.5.0     crayon_1.3.4

+

+
+
+
+
+
+
+
+
+
+
+
diff --git a/vignettes/Selection-of-Calculation-Intervals.html b/doc/Selection-of-Calculation-Intervals.html
similarity index 100%
rename from vignettes/Selection-of-Calculation-Intervals.html
rename to doc/Selection-of-Calculation-Intervals.html
diff --git a/vignettes/Superposition.html b/doc/Superposition.html
similarity index 100%
rename from vignettes/Superposition.html
rename to doc/Superposition.html
diff --git a/vignettes/Writing-Parameter-Functions.html b/doc/Writing-Parameter-Functions.html
similarity index 100%
rename from vignettes/Writing-Parameter-Functions.html
rename to doc/Writing-Parameter-Functions.html
diff --git a/vignettes/PKNCA-validation.html b/vignettes/PKNCA-validation.html
deleted file mode 100644
index 90633fde..00000000
--- a/vignettes/PKNCA-validation.html
+++ /dev/null
@@ -1,389 +0,0 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-PKNCA Validation
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
PKNCA Validation

-
Bill Denney

-
-
-
-
-

-
Introduction

-
To run the tests, the package must be installed with its tests:

-
    
-
  • To install from CRAN:
-
      
-
    • install.packages(pkgs="PKNCA", INSTALL_opts="--install-tests")
      • 
-
    • 
-
  • To install from GitHub:
-
      
-
    • library(devtools)
      • 
-
    • install_github("billdenney/pknca", args="--install-tests")
      • 
-
    • 
-

-
Testing and validation that results match in a local environment compared to the original environment is an important part of confirmation that a package works as expected.

-
Re-running this vignette in your local environment will confirm that local results match those in the original package development. Test success is confirmed by the existence of no failed tests; warnings are expected during testing (and not shown in this vignette for that reason); and some tests may be skipped, but those are expected as well.

-

-

-
Summary of Testing

-
The following sentence is dynamically generated to summarize the testing results: Tests were not run because tests are not installed.

-

-

-
Session Information

-
Sys.Date()

-
## [1] "2019-07-21"

-
sessionInfo()

-
## R version 3.6.1 (2019-07-05)
-## Platform: x86_64-w64-mingw32/x64 (64-bit)
-## Running under: Windows 10 x64 (build 17763)
-## 
-## Matrix products: default
-## 
-## locale:
-## [1] LC_COLLATE=English_United States.1252 
-## [2] LC_CTYPE=English_United States.1252   
-## [3] LC_MONETARY=English_United States.1252
-## [4] LC_NUMERIC=C                          
-## [5] LC_TIME=English_United States.1252    
-## 
-## attached base packages:
-## [1] stats     graphics  grDevices utils     datasets  methods   base     
-## 
-## other attached packages:
-## [1] dplyr_0.8.3      testthat_2.1.1   knitr_1.23       PKNCA_0.8.5.9013
-## 
-## loaded via a namespace (and not attached):
-##  [1] Rcpp_1.0.1       magrittr_1.5     tidyselect_0.2.5 lattice_0.20-38 
-##  [5] R6_2.4.0         rlang_0.4.0      stringr_1.4.0    tools_3.6.1     
-##  [9] parallel_3.6.1   grid_3.6.1       nlme_3.1-140     xfun_0.8        
-## [13] htmltools_0.3.6  yaml_2.2.0       assertthat_0.2.1 digest_0.6.20   
-## [17] tibble_2.1.3     crayon_1.3.4     tidyr_0.8.3      purrr_0.3.2     
-## [21] glue_1.3.1       evaluate_0.14    rmarkdown_1.14   stringi_1.4.3   
-## [25] compiler_3.6.1   pillar_1.4.2     pkgconfig_2.0.2

-

-
-
-
-
-
-
-
-
-
-
-