Running 'testthat.R' [134s]
Running the tests in 'tests/testthat.R' failed.
Complete output:
  > #    Copyright 2021 Province of British Columbia
  > #
  > #    Licensed under the Apache License, Version 2.0 (the "License");
  > #    you may not use this file except in compliance with the License.
  > #    You may obtain a copy of the License at
  > #
  > #       https://www.apache.org/licenses/LICENSE-2.0
  > #
  > #    Unless required by applicable law or agreed to in writing, software
  > #    distributed under the License is distributed on an "AS IS" BASIS,
  > #    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  > #    See the License for the specific language governing permissions and
  > #    limitations under the License.
  > 
  > library(testthat)
  > library(ssdtools)
  Please replace the following in your scripts:
  - `ssdtools::boron_data` with `ssddata::ccme_boron`
  - `ssdtools::ccme_data` with `ssddata::ccme_data`
  > 
  > test_check("ssdtools")
  
  Attaching package: 'purrr'
  
  The following object is masked from 'package:testthat':
  
      is_null
  
  [ FAIL 1 | WARN 0 | SKIP 113 | PASS 931 ]
  
  ══ Skipped tests (113) ═════════════════════════════════════════════════════════
  • On CRAN (15): 'test-estimates.R:20:3', 'test-fit.R:267:3',
    'test-ggplot.R:112:3', 'test-gompertz.R:37:3', 'test-gompertz.R:54:3',
    'test-hc.R:458:3', 'test-hp.R:356:3', 'test-match-moments.R:19:3',
    'test-print.R:3:3', 'test-print.R:8:3', 'test-print.R:17:3',
    'test-print.R:26:3', 'test-print.R:40:3', 'test-utils.R:20:3',
    'test-weibull.R:20:3'
  • On Windows (97): 'test-autoplot.R:17:3', 'test-autoplot.R:22:3',
    'test-autoplot.R:28:3', 'test-burrIII3.R:28:3', 'test-burrIII3.R:39:3',
    'test-burrIII3.R:48:3', 'test-coef.R:21:3', 'test-data.R:20:3',
    'test-data.R:31:3', 'test-data.R:35:3', 'test-data.R:40:3',
    'test-data.R:45:3', 'test-fit.R:217:3', 'test-fit.R:252:3',
    'test-fit.R:361:3', 'test-fit.R:388:3', 'test-fit.R:395:3',
    'test-fit.R:402:3', 'test-fit.R:410:3', 'test-ggplot.R:24:3',
    'test-ggplot.R:36:3', 'test-ggplot.R:42:3', 'test-ggplot.R:50:3',
    'test-ggplot.R:56:3', 'test-ggplot.R:65:3', 'test-ggplot.R:71:3',
    'test-ggplot.R:77:3', 'test-ggplot.R:83:3', 'test-ggplot.R:91:3',
    'test-ggplot.R:99:3', 'test-glance.R:6:3', 'test-glance.R:55:3',
    'test-gof.R:20:3', 'test-gof.R:32:3', 'test-gompertz.R:29:3',
    'test-hc-burrlioz.R:20:3', 'test-hc-burrlioz.R:31:3',
    'test-hc-burrlioz.R:46:3', 'test-hc.R:21:3', 'test-hc.R:126:3',
    'test-hc.R:135:3', 'test-hc.R:144:3', 'test-hc.R:153:3', 'test-hc.R:161:3',
    'test-hc.R:183:3', 'test-hc.R:192:3', 'test-hc.R:200:3', 'test-hc.R:220:3',
    'test-hc.R:231:3', 'test-hc.R:394:3', 'test-hc.R:409:3', 'test-hc.R:429:3',
    'test-hc.R:447:3', 'test-hc.R:472:3', 'test-hc.R:483:3', 'test-hc.R:494:3',
    'test-hc.R:509:3', 'test-hp.R:22:3', 'test-hp.R:45:3', 'test-hp.R:54:3',
    'test-hp.R:63:3', 'test-hp.R:72:3', 'test-hp.R:81:3', 'test-hp.R:90:3',
    'test-hp.R:99:3', 'test-hp.R:109:3', 'test-hp.R:118:3', 'test-hp.R:127:3',
    'test-hp.R:162:3', 'test-hp.R:291:3', 'test-hp.R:306:3', 'test-hp.R:327:3',
    'test-hp.R:345:3', 'test-invpareto.R:27:3', 'test-invpareto.R:35:3',
    'test-lnorm-lnorm.R:53:3', 'test-plot-cdf.R:19:3', 'test-plot-cdf.R:25:3',
    'test-plot-cdf.R:29:3', 'test-plot-cdf.R:38:3', 'test-plot-cf.R:17:3',
    'test-plot-data.R:16:3', 'test-plot.R:10:3', 'test-predict.R:22:3',
    'test-predict.R:33:3', 'test-predict.R:44:3', 'test-predict.R:56:3',
    'test-schwarz-tillmans.R:24:3', 'test-ssd-plot.R:16:3',
    'test-ssd-plot.R:28:3', 'test-ssd-plot.R:37:3', 'test-ssd-plot.R:42:3',
    'test-ssd-plot.R:57:3', 'test-tidy.R:20:3', 'test-weibull.R:29:3',
    'test-weibull.R:36:3', 'test-weibull.R:43:3'
  • invpareto ABNORMAL_TERMINATION_IN_LNSRCH. (1): 'test-invpareto.R:117:3'
  
  ══ Failed tests ════════════════════════════════════════════════════════════════
  ── Error ('test-hc.R:522:3'): ssd_hc passing all boots ccme_chloride lnorm_lnorm ──
  <purrr_error_indexed/rlang_error/error/condition>
  Error in `(function (.x, .f, ..., .progress = FALSE) 
  {
      map_("list", .x, .f, ..., .progress = .progress)
  })(.x = list(lnorm_lnorm = structure(list(dist = "lnorm_lnorm", 
      model = list(par = c(meanlog1 = 5.69175792393478, log_sdlog1 = 0.0576328004057056, 
      meanlog2 = 7.65970275036418, log_sdlog2 = -0.362053197750657, 
      logit_pmix = 0), fn = function (x = last.par[lfixed()], ...) 
      {
          if (tracepar) {
              cat("par:\n")
              print(x)
          }
          if (!validpar(x)) 
              return(NaN)
          if (is.null(random)) {
              ans <- f(x, order = 0)
              if (!ADreport) {
                  if (is.finite(ans) && ans < value.best) {
                    last.par.best <<- x
                    value.best <<- ans
                  }
              }
          }
          else {
              ans <- try({
                  if (MCcontrol$doMC) {
                    ff(x, order = 0)
                    MC(last.par, n = MCcontrol$n, seed = MCcontrol$seed, 
                      order = 0)
                  }
                  else ff(x, order = 0)
              }, silent = silent)
              if (is.character(ans)) 
                  ans <- NaN
          }
          ans
      }, gr = function (x = last.par[lfixed()], ...) 
      {
          if (is.null(random)) {
              ans <- f(x, order = 1)
          }
          else {
              ans <- try({
                  if (MCcontrol$doMC) {
                    ff(x, order = 0)
                    MC(last.par, n = MCcontrol$n, seed = MCcontrol$seed, 
                      order = 1)
                  }
                  else ff(x, order = 1)
              }, silent = silent)
              if (is.character(ans)) 
                  ans <- rep(NaN, length(x))
          }
          if (tracemgc) 
              cat("outer mgc: ", max(abs(ans)), "\n")
          ans
      }, he = function (x = last.par[lfixed()], atomic = usingAtomics()) 
      {
          if (is.null(random)) {
              if (!atomic) 
                  return(f(x, order = 2))
              if (is.null(ADGrad)) 
                  retape_adgrad()
              return(f(x, type = "ADGrad", order = 1))
          }
          else {
              stop("Hessian not yet implemented for models with random effects.")
          }
      }, hessian = FALSE, method = "BFGS", retape = function (set.defaults = TRUE) 
      {
          omp <- config(DLL = DLL)
          random <<- .random
          if (atomic) {
              Fun <<- MakeDoubleFunObject(data, parameters, reportenv, 
                  DLL = DLL)
              out <- EvalDoubleFunObject(Fun, unlist(parameters), 
                  get_reportdims = TRUE)
              ADreportDims <<- attr(out, "reportdims")
          }
          if (is.character(profile)) {
              random <<- c(random, profile)
          }
          if (is.character(random)) {
              if (!regexp) {
                  if (!all(random %in% names(parameters))) {
                    cat("Some 'random' effect names does not match 'parameter' list:\n")
                    print(setdiff(random, names(parameters)))
                    cat("(Note that regular expression match is disabled by default)\n")
                    stop()
                  }
                  if (any(duplicated(random))) {
                    cat("Duplicates in 'random' - will be removed\n")
                    random <<- unique(random)
                  }
                  tmp <- lapply(parameters, function(x) x * 0)
                  tmp[random] <- lapply(tmp[random], function(x) x * 
                    0 + 1)
                  random <<- which(as.logical(unlist(tmp)))
                  if (length(random) == 0) 
                    random <<- NULL
              }
              if (regexp) {
                  random <<- grepRandomParameters(parameters, random)
                  if (length(random) == 0) {
                    cat("Selected random effects did not match any model parameters.\n")
                    random <<- NULL
                  }
              }
              if (is.character(profile)) {
                  tmp <- lapply(parameters, function(x) x * 0)
                  tmp[profile] <- lapply(tmp[profile], function(x) x * 
                    0 + 1)
                  profile <<- match(which(as.logical(unlist(tmp))), 
                    random)
                  if (length(profile) == 0) 
                    random <<- NULL
                  if (any(duplicated(profile))) 
                    stop("Profile parameter vector not unique.")
                  tmp <- rep(0L, length(random))
                  tmp[profile] <- 1L
                  profile <<- tmp
              }
              if (set.defaults) {
                  par <<- unlist(parameters)
              }
          }
          if ("ADFun" %in% type) {
              if (omp$autopar) 
                  openmp(1, DLL = DLL)
              ADFun <<- MakeADFunObject(data, parameters, reportenv, 
                  ADreport = ADreport, DLL = DLL)
              if (omp$autopar) 
                  openmp(omp$nthreads, DLL = DLL)
              if (!is.null(integrate)) {
                  nm <- sapply(parameters, length)
                  nmpar <- rep(names(nm), nm)
                  for (i in seq_along(integrate)) {
                    I <- integrate[i]
                    if (is.null(names(I)) || names(I) == "") {
                      I <- I[[1]]
                    }
                    ok <- all(names(I) %in% nmpar[random])
                    if (!ok) 
                      stop("Names to be 'integrate'd must be among the random parameters")
                    w <- which(nmpar[random] %in% names(I))
                    arg_which <- I[[1]]$which
                    if (!is.null(arg_which)) 
                      w <- w[arg_which]
                    method <- sapply(I, function(x) x$method)
                    ok <- all(duplicated(method)[-1])
                    if (!ok) 
                      stop("Grouping only allowed for identical methods")
                    method <- method[1]
                    cfg <- NULL
                    if (method == "marginal_sr") {
                      fac <- factor(nmpar[random[w]], levels = names(I))
                      cfg <- list(grid = I, random2grid = fac)
                    }
                    else {
                      cfg <- I[[1]]
                    }
                    stopifnot(is.list(cfg))
                    TransformADFunObject(ADFun, method = method, 
                      random_order = random[w], config = cfg, mustWork = 1L)
                    activeDomain <- as.logical(info(ADFun)$activeDomain)
                    random_remove <- random[w][!activeDomain[random[w]]]
                    TransformADFunObject(ADFun, method = "remove_random_parameters", 
                      random_order = random_remove, mustWork = 1L)
                    attr(ADFun$ptr, "par") <- attr(ADFun$ptr, "par")[-random_remove]
                    par_mask <- rep(FALSE, length(attr(ADFun$ptr, 
                      "par")))
                    par_mask[random] <- TRUE
                    par <<- par[-random_remove]
                    nmpar <- nmpar[-random_remove]
                    par_mask <- par_mask[-random_remove]
                    random <<- which(par_mask)
                    if (length(random) == 0) {
                      random <<- NULL
                      type <<- setdiff(type, "ADGrad")
                    }
                    if (config(DLL = DLL)$optimize.instantly) {
                      TransformADFunObject(ADFun, method = "optimize", 
                        mustWork = 1L)
                    }
                  }
              }
              if (intern) {
                  cfg <- inner.control
                  if (is.null(cfg$sparse)) 
                    cfg$sparse <- TRUE
                  cfg <- lapply(cfg, as.double)
                  TransformADFunObject(ADFun, method = "laplace", 
                    config = cfg, random_order = random, mustWork = 1L)
                  TransformADFunObject(ADFun, method = "remove_random_parameters", 
                    random_order = random, mustWork = 1L)
                  attr(ADFun$ptr, "par") <- attr(ADFun$ptr, "par")[-random]
                  par <<- par[-random]
                  random <<- NULL
                  if (config(DLL = DLL)$optimize.instantly) {
                    TransformADFunObject(ADFun, method = "optimize", 
                      mustWork = 1L)
                  }
              }
              if (set.defaults) {
                  par <<- attr(ADFun$ptr, "par")
                  last.par <<- par
                  last.par1 <<- par
                  last.par2 <<- par
                  last.par.best <<- par
                  value.best <<- Inf
              }
          }
          if (omp$autopar && !ADreport) {
              TransformADFunObject(ADFun, method = "parallel_accumulate", 
                  num_threads = as.integer(openmp(DLL = DLL)), 
                  mustWork = 0L)
          }
          if (length(random) > 0) {
              TransformADFunObject(ADFun, method = "reorder_random", 
                  random_order = random, mustWork = 0L)
          }
          if ("Fun" %in% type) {
              Fun <<- MakeDoubleFunObject(data, parameters, reportenv, 
                  DLL = DLL)
          }
          if ("ADGrad" %in% type) {
              retape_adgrad(lazy = TRUE)
          }
          env$skipFixedEffects <- !is.null(ADGrad)
          delayedAssign("spHess", sparseHessianFun(env, skipFixedEffects = skipFixedEffects), 
              assign.env = env)
      }, env = <environment>, report = function (par = last.par) 
      {
          f(par, order = 0, type = "double")
          as.list(reportenv)
      }, simulate = function (par = last.par, complete = FALSE) 
      {
          f(par, order = 0, type = "double", do_simulate = TRUE)
          sim <- as.list(reportenv)
          if (complete) {
              ans <- data
              ans[names(sim)] <- sim
          }
          else {
              ans <- sim
          }
          ans
      }), optim = list(par = c(meanlog1 = 3.45322872225588, log_sdlog1 = -1.27365236267236, 
      meanlog2 = 6.9178496184246, log_sdlog2 = -0.00080019297882199, 
      logit_pmix = -2.58856103427256), value = 231.035341081078, 
          counts = c(`function` = 39L, gradient = 39L), convergence = 0L, 
          message = "CONVERGENCE: REL_REDUCTION_OF_F <= FACTR*EPSMCH", 
          hessian = structure(c(24.4343212245894, -0.0146175077037586, 
          -0.352084007511189, 0.964659399601814, -0.114039244316153, 
          -0.0146175077037586, 3.90078563018057, -0.00441613734465312, 
          0.0107952875691186, -0.0016056057905534, -0.352084007511189, 
          -0.00441613734465312, 25.6382708896679, 1.32590495428742, 
          -0.136721618709502, 0.964659399601814, 0.0107952875691186, 
          1.32590495428742, 48.1234964360616, 0.404147717565761, 
          -0.114039244316153, -0.0016056057905534, -0.136721618709502, 
          0.404147717565761, 1.77789194599387), dim = c(5L, 5L), dimnames = list(
              c("meanlog1", "log_sdlog1", "meanlog2", "log_sdlog2", 
              "logit_pmix"), c("meanlog1", "log_sdlog1", "meanlog2", 
              "log_sdlog2", "logit_pmix")))), est = c(meanlog1 = 3.45322872225588, 
      meanlog2 = 6.9178496184246, pmix = 0.0698782509920365, sdlog1 = 0.279807793679678, 
      sdlog2 = 0.999200127090202), pars = list(meanlog1 = 3.45322872225588, 
          meanlog2 = 6.9178496184246, logit_pmix = -2.58856103427256, 
          log_sdlog1 = -1.27365236267236, log_sdlog2 = -0.00080019297882199)), class = "tmbfit"), 
      llogis_llogis = structure(list(dist = "llogis_llogis", model = list(
          par = c(locationlog1 = 5.69175792393478, log_scalelog1 = 0.653056541921051, 
          locationlog2 = 7.65970275036418, log_scalelog2 = 0.233370543764688, 
          logit_pmix = 0), fn = function (x = last.par[lfixed()], 
              ...) 
          {
              if (tracepar) {
                  cat("par:\n")
                  print(x)
              }
              if (!validpar(x)) 
                  return(NaN)
              if (is.null(random)) {
                  ans <- f(x, order = 0)
                  if (!ADreport) {
                    if (is.finite(ans) && ans < value.best) {
                      last.par.best <<- x
                      value.best <<- ans
                    }
                  }
              }
              else {
                  ans <- try({
                    if (MCcontrol$doMC) {
                      ff(x, order = 0)
                      MC(last.par, n = MCcontrol$n, seed = MCcontrol$seed, 
                        order = 0)
                    }
                    else ff(x, order = 0)
                  }, silent = silent)
                  if (is.character(ans)) 
                    ans <- NaN
              }
              ans
          }, gr = function (x = last.par[lfixed()], ...) 
          {
              if (is.null(random)) {
                  ans <- f(x, order = 1)
              }
              else {
                  ans <- try({
                    if (MCcontrol$doMC) {
                      ff(x, order = 0)
                      MC(last.par, n = MCcontrol$n, seed = MCcontrol$seed, 
                        order = 1)
                    }
                    else ff(x, order = 1)
                  }, silent = silent)
                  if (is.character(ans)) 
                    ans <- rep(NaN, length(x))
              }
              if (tracemgc) 
                  cat("outer mgc: ", max(abs(ans)), "\n")
              ans
          }, he = function (x = last.par[lfixed()], atomic = usingAtomics()) 
          {
              if (is.null(random)) {
                  if (!atomic) 
                    return(f(x, order = 2))
                  if (is.null(ADGrad)) 
                    retape_adgrad()
                  return(f(x, type = "ADGrad", order = 1))
              }
              else {
                  stop("Hessian not yet implemented for models with random effects.")
              }
          }, hessian = FALSE, method = "BFGS", retape = function (set.defaults = TRUE) 
          {
              omp <- config(DLL = DLL)
              random <<- .random
              if (atomic) {
                  Fun <<- MakeDoubleFunObject(data, parameters, 
                    reportenv, DLL = DLL)
                  out <- EvalDoubleFunObject(Fun, unlist(parameters), 
                    get_reportdims = TRUE)
                  ADreportDims <<- attr(out, "reportdims")
              }
              if (is.character(profile)) {
                  random <<- c(random, profile)
              }
              if (is.character(random)) {
                  if (!regexp) {
                    if (!all(random %in% names(parameters))) {
                      cat("Some 'random' effect names does not match 'parameter' list:\n")
                      print(setdiff(random, names(parameters)))
                      cat("(Note that regular expression match is disabled by default)\n")
                      stop()
                    }
                    if (any(duplicated(random))) {
                      cat("Duplicates in 'random' - will be removed\n")
                      random <<- unique(random)
                    }
                    tmp <- lapply(parameters, function(x) x * 0)
                    tmp[random] <- lapply(tmp[random], function(x) x * 
                      0 + 1)
                    random <<- which(as.logical(unlist(tmp)))
                    if (length(random) == 0) 
                      random <<- NULL
                  }
                  if (regexp) {
                    random <<- grepRandomParameters(parameters, 
                      random)
                    if (length(random) == 0) {
                      cat("Selected random effects did not match any model parameters.\n")
                      random <<- NULL
                    }
                  }
                  if (is.character(profile)) {
                    tmp <- lapply(parameters, function(x) x * 0)
                    tmp[profile] <- lapply(tmp[profile], function(x) x * 
                      0 + 1)
                    profile <<- match(which(as.logical(unlist(tmp))), 
                      random)
                    if (length(profile) == 0) 
                      random <<- NULL
                    if (any(duplicated(profile))) 
                      stop("Profile parameter vector not unique.")
                    tmp <- rep(0L, length(random))
                    tmp[profile] <- 1L
                    profile <<- tmp
                  }
                  if (set.defaults) {
                    par <<- unlist(parameters)
                  }
              }
              if ("ADFun" %in% type) {
                  if (omp$autopar) 
                    openmp(1, DLL = DLL)
                  ADFun <<- MakeADFunObject(data, parameters, reportenv, 
                    ADreport = ADreport, DLL = DLL)
                  if (omp$autopar) 
                    openmp(omp$nthreads, DLL = DLL)
                  if (!is.null(integrate)) {
                    nm <- sapply(parameters, length)
                    nmpar <- rep(names(nm), nm)
                    for (i in seq_along(integrate)) {
                      I <- integrate[i]
                      if (is.null(names(I)) || names(I) == "") {
                        I <- I[[1]]
                      }
                      ok <- all(names(I) %in% nmpar[random])
                      if (!ok) 
                        stop("Names to be 'integrate'd must be among the random parameters")
                      w <- which(nmpar[random] %in% names(I))
                      arg_which <- I[[1]]$which
                      if (!is.null(arg_which)) 
                        w <- w[arg_which]
                      method <- sapply(I, function(x) x$method)
                      ok <- all(duplicated(method)[-1])
                      if (!ok) 
                        stop("Grouping only allowed for identical methods")
                      method <- method[1]
                      cfg <- NULL
                      if (method == "marginal_sr") {
                        fac <- factor(nmpar[random[w]], levels = names(I))
                        cfg <- list(grid = I, random2grid = fac)
                      }
                      else {
                        cfg <- I[[1]]
                      }
                      stopifnot(is.list(cfg))
                      TransformADFunObject(ADFun, method = method, 
                        random_order = random[w], config = cfg, 
                        mustWork = 1L)
                      activeDomain <- as.logical(info(ADFun)$activeDomain)
                      random_remove <- random[w][!activeDomain[random[w]]]
                      TransformADFunObject(ADFun, method = "remove_random_parameters", 
                        random_order = random_remove, mustWork = 1L)
                      attr(ADFun$ptr, "par") <- attr(ADFun$ptr, 
                        "par")[-random_remove]
                      par_mask <- rep(FALSE, length(attr(ADFun$ptr, 
                        "par")))
                      par_mask[random] <- TRUE
                      par <<- par[-random_remove]
                      nmpar <- nmpar[-random_remove]
                      par_mask <- par_mask[-random_remove]
                      random <<- which(par_mask)
                      if (length(random) == 0) {
                        random <<- NULL
                        type <<- setdiff(type, "ADGrad")
                      }
                      if (config(DLL = DLL)$optimize.instantly) {
                        TransformADFunObject(ADFun, method = "optimize", 
                          mustWork = 1L)
                      }
                    }
                  }
                  if (intern) {
                    cfg <- inner.control
                    if (is.null(cfg$sparse)) 
                      cfg$sparse <- TRUE
                    cfg <- lapply(cfg, as.double)
                    TransformADFunObject(ADFun, method = "laplace", 
                      config = cfg, random_order = random, mustWork = 1L)
                    TransformADFunObject(ADFun, method = "remove_random_parameters", 
                      random_order = random, mustWork = 1L)
                    attr(ADFun$ptr, "par") <- attr(ADFun$ptr, "par")[-random]
                    par <<- par[-random]
                    random <<- NULL
                    if (config(DLL = DLL)$optimize.instantly) {
                      TransformADFunObject(ADFun, method = "optimize", 
                        mustWork = 1L)
                    }
                  }
                  if (set.defaults) {
                    par <<- attr(ADFun$ptr, "par")
                    last.par <<- par
                    last.par1 <<- par
                    last.par2 <<- par
                    last.par.best <<- par
                    value.best <<- Inf
                  }
              }
              if (omp$autopar && !ADreport) {
                  TransformADFunObject(ADFun, method = "parallel_accumulate", 
                    num_threads = as.integer(openmp(DLL = DLL)), 
                    mustWork = 0L)
              }
              if (length(random) > 0) {
                  TransformADFunObject(ADFun, method = "reorder_random", 
                    random_order = random, mustWork = 0L)
              }
              if ("Fun" %in% type) {
                  Fun <<- MakeDoubleFunObject(data, parameters, 
                    reportenv, DLL = DLL)
              }
              if ("ADGrad" %in% type) {
                  retape_adgrad(lazy = TRUE)
              }
              env$skipFixedEffects <- !is.null(ADGrad)
              delayedAssign("spHess", sparseHessianFun(env, skipFixedEffects = skipFixedEffects), 
                  assign.env = env)
          }, env = <environment>, report = function (par = last.par) 
          {
              f(par, order = 0, type = "double")
              as.list(reportenv)
          }, simulate = function (par = last.par, complete = FALSE) 
          {
              f(par, order = 0, type = "double", do_simulate = TRUE)
              sim <- as.list(reportenv)
              if (complete) {
                  ans <- data
                  ans[names(sim)] <- sim
              }
              else {
                  ans <- sim
              }
              ans
          }), optim = list(par = c(locationlog1 = 3.4415187965093, 
      log_scalelog1 = -1.69878131168861, locationlog2 = 6.87489323219086, 
      log_scalelog2 = -0.535066732027458, logit_pmix = -2.6639430473479
      ), value = 231.5133845404, counts = c(`function` = 36L, gradient = 36L
      ), convergence = 0L, message = "CONVERGENCE: REL_REDUCTION_OF_F <= FACTR*EPSMCH", 
          hessian = structure(c(13.7397815901994, -0.424279054288108, 
          -0.480707647224373, 1.023405694938, -0.286416713800277, 
          -0.424279054288108, 2.85418443038394, -0.0587367487173721, 
          0.0881145371418381, -0.0363182442951076, -0.480707647224373, 
          -0.0587367487173721, 24.4972515897217, 0.182540498854102, 
          -0.28188883055788, 1.023405694938, 0.0881145371418381, 
          0.182540498854102, 34.699165489759, 0.754200895626512, 
          -0.286416713800277, -0.0363182442951076, -0.28188883055788, 
          0.754200895626512, 1.53837320004628), dim = c(5L, 5L), dimnames = list(
              c("locationlog1", "log_scalelog1", "locationlog2", 
              "log_scalelog2", "logit_pmix"), c("locationlog1", 
              "log_scalelog1", "locationlog2", "log_scalelog2", 
              "logit_pmix")))), est = c(locationlog1 = 3.4415187965093, 
      locationlog2 = 6.87489323219086, pmix = 0.0651348202055833, 
      scalelog1 = 0.182906294044203, scalelog2 = 0.585630208549654
      ), pars = list(locationlog1 = 3.4415187965093, locationlog2 = 6.87489323219086, 
          logit_pmix = -2.6639430473479, log_scalelog1 = -1.69878131168861, 
          log_scalelog2 = -0.535066732027458)), class = "tmbfit")), 
      .f = function (...) 
      {
          {
              ...furrr_chunk_seeds_i <- ...furrr_chunk_seeds_env[["i"]]
              ...furrr_chunk_seeds_env[["i"]] <- ...furrr_chunk_seeds_i + 
                  1L
              assign(x = ".Random.seed", value = ...furrr_chunk_seeds[[...furrr_chunk_seeds_i]], 
                  envir = globalenv(), inherits = FALSE)
          }
          NULL
          ...furrr_out <- ...furrr_fn(...)
          ...furrr_out
      }, proportion = 0.05, ci = TRUE, level = 0.95, nboot = 1000, 
      min_pboot = 0.99, data = structure(list(Chemical = c("Chloride", 
      "Chloride", "Chloride", "Chloride", "Chloride", "Chloride", 
      "Chloride", "Chloride", "Chloride", "Chloride", "Chloride", 
      "Chloride", "Chloride", "Chloride", "Chloride", "Chloride", 
      "Chloride", "Chloride", "Chloride", "Chloride", "Chloride", 
      "Chloride", "Chloride", "Chloride", "Chloride", "Chloride", 
      "Chloride", "Chloride"), Species = c("Pimephales promelas", 
      "Salmo trutta fario", "Oncorhynchus mykiss", "Xenopus laevis", 
      "Rana pipiens", "Lampsilis fasciola", "Epioblasma torulosa rangiana", 
      "Musculium securis", "Daphnia ambigua", "Daphnia pulex", 
      "Elliptio complanata", "Daphnia magna", "Hyalella azteca", 
      "Ceriodaphnia dubia", "Tubifex tubifex", "Villosa delumbis", 
      "Villosa constricta", "Lumbriculus variegates", "Brachionus calyciflorus", 
      "Lampsilis siliquoidea", "Gammarus pseudopinmaeus", "Physa sp", 
      "Stenonema modestum", "Chironomus tentans", "Lemna minor", 
      "Chlorella minutissimo", "Chlorella zofingiensis", "Chlorella emersonii"
      ), Group = structure(c(2L, 2L, 2L, 1L, 1L, 3L, 3L, 3L, 3L, 
      3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 3L, 
      4L, 4L, 4L, 4L), levels = c("Amphibian", "Fish", "Invertebrate", 
      "Plant"), class = "factor"), Units = c("mg/L", "mg/L", "mg/L", 
      "mg/L", "mg/L", "mg/L", "mg/L", "mg/L", "mg/L", "mg/L", "mg/L", 
      "mg/L", "mg/L", "mg/L", "mg/L", "mg/L", "mg/L", "mg/L", "mg/L", 
      "mg/L", "mg/L", "mg/L", "mg/L", "mg/L", "mg/L", "mg/L", "mg/L", 
      "mg/L"), weight = c(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
      1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1), left = c(598, 
      607, 989, 1307, 3431, 24, 42, 121, 259, 368, 406, 421, 421, 
      454, 519, 716, 789, 825, 1241, 1474, 2000, 2000, 2047, 2316, 
      1171, 6066, 6066, 6824), right = c(598, 607, 989, 1307, 3431, 
      24, 42, 121, 259, 368, 406, 421, 421, 454, 519, 716, 789, 
      825, 1241, 1474, 2000, 2000, 2047, 2316, 1171, 6066, 6066, 
      6824)), row.names = c(NA, -28L), class = c("tbl_df", "tbl", 
      "data.frame")), rescale = 1, weighted = 1, censoring = c(0, 
      Inf), min_pmix = 1e-04, range_shape1 = c(0.05, 20), range_shape2 = c(0.05, 
      20), parametric = TRUE, control = list())`: i In index: 1.
  i With name: lnorm_lnorm.
  Caused by error in `quantile.default()`:
  ! missing values and NaN's not allowed if 'na.rm' is FALSE
  Backtrace:
       ▆
    1. ├─testthat::expect_warning(...) at test-hc.R:522:3
    2. │ └─testthat:::expect_condition_matching(...)
    3. │   └─testthat:::quasi_capture(...)
    4. │     ├─testthat (local) .capture(...)
    5. │     │ └─base::withCallingHandlers(...)
    6. │     └─rlang::eval_bare(quo_get_expr(.quo), quo_get_env(.quo))
    7. ├─ssdtools::ssd_hc(fits, ci = TRUE, nboot = 1000, average = FALSE)
    8. ├─ssdtools:::ssd_hc.fitdists(fits, ci = TRUE, nboot = 1000, average = FALSE)
    9. │ └─ssdtools:::.ssd_hc_fitdists(...)
   10. │   └─furrr::future_map(...)
   11. │     └─furrr:::furrr_map_template(...)
   12. │       └─furrr:::furrr_template(...)
   13. │         └─future::future(...)
   14. │           ├─future::run(future)
   15. │           └─future:::run.Future(future)
   16. │             ├─future::run(future)
   17. │             └─future:::run.UniprocessFuture(future)
   18. │               └─base::eval(expr, envir = envir, enclos = baseenv())
   19. │                 └─base::eval(expr, envir = envir, enclos = baseenv())
   20. │                   ├─base::tryCatch(...)
   21. │                   │ └─base (local) tryCatchList(expr, classes, parentenv, handlers)
   22. │                   │   └─base (local) tryCatchOne(expr, names, parentenv, handlers[[1L]])
   23. │                   │     └─base (local) doTryCatch(return(expr), name, parentenv, handler)
   24. │                   ├─base::withCallingHandlers(...)
   25. │                   ├─base::withVisible(...)
   26. │                   ├─base::local(...)
   27. │                   │ └─base::eval.parent(substitute(eval(quote(expr), envir)))
   28. │                   │   └─base::eval(expr, p)
   29. │                   │     └─base::eval(expr, p)
   30. │                   └─base::eval(...)
   31. │                     └─base::eval(...)
   32. │                       ├─base::do.call(...furrr_map_fn, args)
   33. │                       └─purrr (local) `<fn>`(...)
   34. │                         └─purrr:::map_("list", .x, .f, ..., .progress = .progress)
   35. │                           ├─purrr:::with_indexed_errors(...)
   36. │                           │ └─base::withCallingHandlers(...)
   37. │                           ├─purrr:::call_with_cleanup(...)
   38. │                           └─ssdtools (local) .f(.x[[i]], ...)
   39. │                             └─ssdtools (local) ...furrr_fn(...)
   40. │                               └─ssdtools:::cis_estimates(estimates, what, level = level, x = proportion)
   41. │                                 └─base::lapply(x, xcis_estimates, args, what, level)
   42. │                                   └─ssdtools (local) FUN(X[[i]], ...)
   43. │                                     ├─stats::quantile(samples, probs = probs(level))
   44. │                                     └─stats:::quantile.default(samples, probs = probs(level))
   45. │                                       └─base::stop("missing values and NaN's not allowed if 'na.rm' is FALSE")
   46. └─base::.handleSimpleError(...)
   47.   └─purrr (local) h(simpleError(msg, call))
   48.     └─cli::cli_abort(...)
   49.       └─rlang::abort(...)
  
  [ FAIL 1 | WARN 0 | SKIP 113 | PASS 931 ]
  Deleting unused snapshots:
  • autoplot/autoplot.png
  • autoplot/autoplot_new.png
  • autoplot/autoplot_rescale.png
  • burrIII3/hc_chloride.csv
  • burrIII3/hc_uranium.csv
  • burrIII3/tidy_anon_e.csv
  • coef/coef.csv
  • data/boron_data.csv
  • data/boron_stable.csv
  • data/boron_unstable.csv
  • data/ccme_data.csv
  • data/dist_data.csv
  • fit/min_pmix5.csv
  • fit/min_pmix_05.csv
  • fit/tidy_gamma_unstable.csv
  • fit/tidy_pmix0.csv
  • fit/tidy_stable_anon_e.csv
  • fit/tidy_stable_computable.csv
  • fit/tidy_stable_rescale.csv
  • fit/tidy_unstable_anon_e.csv
  • ggplot/geom_hcintersect.png
  • ggplot/geom_hcintersect_aes.png
  • ggplot/geom_ssd.png
  • ggplot/geom_ssdpoint.png
  • ggplot/geom_ssdpoint_identity.png
  • ggplot/geom_ssdsegment.png
  • ggplot/geom_ssdsegment_arrow.png
  • ggplot/geom_ssdsegment_identity.png
  • ggplot/geom_ssdsegment_nodata.png
  • ggplot/geom_xribbon.png
  • ggplot/geoms_all.png
  • ggplot/stat_ssd.png
  • glance/fit.csv
  • glance/fit_cens.csv
  • glance/fit_cens_n.csv
  • glance/glance.csv
  • gof/gof.csv
  • gof/gof_pvalue_mixture.csv
  • gof/gof_statistic.csv
  • gof/gof_statistic_mixture.csv
  • gompertz/hc_prob.csv
  • hc-burrlioz/hc_boron.csv
  • hc-burrlioz/hc_burrIII3.csv
  • hc-burrlioz/hc_burrIII3_parametric.csv
  • hc/hc.csv
  • hc/hc114.csv
  • hc/hc122.csv
  • hc/hc130.csv
  • hc/hc138.csv
  • hc/hc145.csv
  • hc/hc153.csv
  • hc/hc161.csv
  • hc/hc168.csv
  • hc/hc_1.csv
  • hc/hc_30.csv
  • hc/hc_boron.csv
  • hc/hc_burrIII3.csv
  • hc/hc_burrIII3_parametric.csv
  • hc/hc_cis.csv
  • hc/hc_cis_chloride50.csv
  • hc/hc_cis_level08.csv
  • hc/hc_err.csv
  • hc/hc_err_avg.csv
  • hc/hc_err_na.csv
  • hc/hc_err_two.csv
  • hc/hc_nonpara.csv
  • hc/hc_para.csv
  • hc/hc_para_small.csv
  • hp/hp.csv
  • hp/hp106.csv
  • hp/hp114.csv
  • hp/hp130.csv
  • hp/hp41.csv
  • hp/hp49.csv
  • hp/hp57.csv
  • hp/hp65.csv
  • hp/hp73.csv
  • hp/hp81.csv
  • hp/hp89.csv
  • hp/hp98.csv
  • hp/hp_1.csv
  • hp/hp_30.csv
  • hp/hp_err.csv
  • hp/hp_err_avg.csv
  • hp/hp_err_na.csv
  • hp/hp_err_two.csv
  • hp/hp_nonpara.csv
  • hp/hp_para.csv
  • invpareto/anon_a.csv
  • invpareto/hc_boron.csv
  • lnorm-lnorm/plot_anonb.png
  • lnorm-lnorm/tidy_anonb.csv
  • match-moments/cdf.png
  • plot-cdf/fits.png
  • plot-cdf/fits_average.png
  • plot-cdf/fits_delta.png
  • plot-cdf/fits_rescale.png
  • plot-cdf/list.png
  • plot-cf/ccme_boron.png
  • plot-data/ccme_boron.png
  • plot/plot.png
  • predict/pred_cis.csv
  • predict/pred_cis_burrlioz.csv
  • predict/pred_dists.csv
  • predict/pred_notaverage.csv
  • schwarz-tillmans/gof.csv
  • schwarz-tillmans/hc.csv
  • schwarz-tillmans/hc_avg.csv
  • ssd-plot/boron_breaks.png
  • ssd-plot/boron_cens_pred.png
  • ssd-plot/boron_cens_pred_ribbon.png
  • ssd-plot/boron_cens_pred_species.png
  • ssd-plot/boron_color.png
  • ssd-plot/boron_pred.png
  • ssd-plot/boron_pred_label.png
  • ssd-plot/boron_pred_ribbon.png
  • ssd-plot/boron_pred_shift_x.png
  • ssd-plot/boron_shape.png
  • ssd-plot/missing_order.png
  • tidy/tidy.csv
  • weibull/hc_anona.csv
  • weibull/tidy.csv
  • weibull/tidy_anona.csv
  Error: Test failures
  Execution halted