Error(s) in re-building vignettes:
  ...
--- re-building ‘atable_usage.rnw’ using knitr
Loading required package: knitr
Loading required package: Hmisc
Loading required package: lattice
Loading required package: survival
Loading required package: Formula
Loading required package: ggplot2

Attaching package: 'Hmisc'

The following objects are masked from 'package:base':

    format.pval, units

Loading required package: atable
 ----------- FAILURE REPORT -------------- 
 --- failure: the condition has length > 1 ---
 --- srcref --- 
: 
 --- package (from environment) --- 
atable
 --- call from context --- 
two_sample_htest.numeric(value, group, ...)
 --- call from argument --- 
if (class(test) == "try-error") {
    warning("Not enough values. Returning p.value=NaN.")
    test <- stats::ks.test(c(1, 2), c(3, 4, 5), alternative = c("two.sided"))
    test <- plyr::llply(test, function(x) NA)
    test$method <- "Two-sample Kolmogorov-Smirnov test"
    test$p.value <- NaN
    test$statistic <- NaN
    class(test) <- "htest"
    test
} else {
    test
}
 --- R stacktrace ---
where 1: two_sample_htest.numeric(value, group, ...)
where 2: two_sample_htest(value, group, ...)
where 3: (function (DD, group_col, value_col, ...) 
{
    stopifnot(is.character(group_col), length(group_col) == 1, 
        is.character(value_col), length(value_col) == 1, group_col %in% 
            colnames(DD), value_col %in% colnames(DD), is.factor(DD[[group_col]]))
    value <- DD[[value_col]]
    group <- DD[[group_col]]
    group_levels <- levels(DD[[group_col]])
    result <- if (length(group_levels) == 2) {
        two_sample_htest(value, group, ...)
    }
    else {
        multi_sample_htest(value, group, ...)
    }
    return(result)
})(value_col = dots[[1L]][[1L]], DD = list(len = c(4.2, 11.5, 
7.3, 5.8, 6.4, 10, 11.2, 11.2, 5.2, 7, 15.2, 21.5, 17.6, 9.7, 
14.5, 10, 8.2, 9.4, 16.5, 9.7), dose = c(1L, 1L, 1L, 1L, 1L, 
1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L), 
    supp = c(2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 2L, 1L, 1L, 
    1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L), Observations = c(0L, 0L, 
    0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 
    0L, 0L, 0L)), group_col = "supp")
where 4: mapply(test_caller, value_col = target_cols, MoreArgs = list(DD = DD, 
    group_col = group_col, ...), SIMPLIFY = FALSE)
where 5: FUN(X[[i]], ...)
where 6: lapply(pieces, .fun, ...)
where 7: structure(lapply(pieces, .fun, ...), dim = dim(pieces))
where 8: llply(.data = .data, .fun = .fun, ..., .progress = .progress, 
    .inform = .inform, .parallel = .parallel, .paropts = .paropts)
where 9: plyr::ldply(splitted, apply_tests_helper, target_cols, group_col, 
    ...)
where 10: apply_tests(DD, target_cols, group_col, split_cols, ...)
where 11: atable_splitted_grouped(DD = DD, target_cols = target_cols, group_col = group_col, 
    split_cols = split_cols, format_to = format_to, Alias_mapping = Alias_mapping, 
    blocks = blocks, indent_character = indent_character, indent = indent, 
    ...)
where 12: atable.data.frame(ToothGrowth, target_cols = "len", group_col = "supp", 
    split_cols = "dose", format_to = "Latex")
where 13: atable::atable(ToothGrowth, target_cols = "len", group_col = "supp", 
    split_cols = "dose", format_to = "Latex")
where 14: eval(expr, envir, enclos)
where 15: eval(expr, envir, enclos)
where 16: eval_with_user_handlers(expr, envir, enclos, user_handlers)
where 17: withVisible(eval_with_user_handlers(expr, envir, enclos, user_handlers))
where 18: withCallingHandlers(withVisible(eval_with_user_handlers(expr, 
    envir, enclos, user_handlers)), warning = wHandler, error = eHandler, 
    message = mHandler)
where 19: handle(ev <- withCallingHandlers(withVisible(eval_with_user_handlers(expr, 
    envir, enclos, user_handlers)), warning = wHandler, error = eHandler, 
    message = mHandler))
where 20: timing_fn(handle(ev <- withCallingHandlers(withVisible(eval_with_user_handlers(expr, 
    envir, enclos, user_handlers)), warning = wHandler, error = eHandler, 
    message = mHandler)))
where 21: evaluate_call(expr, parsed$src[[i]], envir = envir, enclos = enclos, 
    debug = debug, last = i == length(out), use_try = stop_on_error != 
        2L, keep_warning = keep_warning, keep_message = keep_message, 
    output_handler = output_handler, include_timing = include_timing)
where 22: evaluate::evaluate(...)
where 23: evaluate(code, envir = env, new_device = FALSE, keep_warning = !isFALSE(options$warning), 
    keep_message = !isFALSE(options$message), stop_on_error = if (is.numeric(options$error)) options$error else {
        if (options$error && options$include) 
            0L
        else 2L
    }, output_handler = knit_handlers(options$render, options))
where 24: in_dir(input_dir(), evaluate(code, envir = env, new_device = FALSE, 
    keep_warning = !isFALSE(options$warning), keep_message = !isFALSE(options$message), 
    stop_on_error = if (is.numeric(options$error)) options$error else {
        if (options$error && options$include) 
            0L
        else 2L
    }, output_handler = knit_handlers(options$render, options)))
where 25: eng_r(options)
where 26: block_exec(params)
where 27: call_block(x)
where 28: process_group.block(group)
where 29: process_group(group)
where 30: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 
    error = function(e) {
        setwd(wd)
        cat(res, sep = "\n", file = output %n% "")
        message("Quitting from lines ", paste(current_lines(i), 
            collapse = "-"), " (", knit_concord$get("infile"), 
            ") ")
    })
where 31: process_file(text, output)
where 32: (if (grepl("\\.[Rr]md$", file)) knit2html else if (grepl("\\.[Rr]rst$", 
    file)) knit2pandoc else knit)(file, encoding = encoding, 
    quiet = quiet, envir = globalenv(), ...)
where 33: engine$weave(file, quiet = quiet, encoding = enc)
where 34: doTryCatch(return(expr), name, parentenv, handler)
where 35: tryCatchOne(expr, names, parentenv, handlers[[1L]])
where 36: tryCatchList(expr, classes, parentenv, handlers)
where 37: tryCatch({
    engine$weave(file, quiet = quiet, encoding = enc)
    setwd(startdir)
    output <- find_vignette_product(name, by = "weave", engine = engine)
    if (!have.makefile && vignette_is_tex(output)) {
        texi2pdf(file = output, clean = FALSE, quiet = quiet)
        output <- find_vignette_product(name, by = "texi2pdf", 
            engine = engine)
    }
    outputs <- c(outputs, output)
}, error = function(e) {
    thisOK <<- FALSE
    fails <<- c(fails, file)
    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s", 
        file, conditionMessage(e)))
})
where 38: tools:::buildVignettes(dir = "/home/hornik/tmp/R.check/r-devel-gcc/Work/PKGS/atable.Rcheck/vign_test/atable")

 --- value of length: 2 type: logical ---
[1] FALSE FALSE
 --- function from context --- 
function (value, group, two_sample_htest.numeric = NULL, ...) 
{
    if (is.function(two_sample_htest.numeric)) 
        return(two_sample_htest.numeric(value, group, ...))
    if (is.function(atable_options("two_sample_htest.numeric"))) 
        return(atable_options("two_sample_htest.numeric")(value, 
            group, ...))
    d <- data.frame(value = value, group = group)
    group_levels <- levels(group)
    x <- subset(d, group %in% group_levels[1], select = "value", 
        drop = TRUE)
    y <- subset(d, group %in% group_levels[2], select = "value", 
        drop = TRUE)
    test <- try(stats::ks.test(x, y, alternative = c("two.sided"), 
        ...), silent = TRUE)
    out <- if (class(test) == "try-error") {
        warning("Not enough values. Returning p.value=NaN.")
        test <- stats::ks.test(c(1, 2), c(3, 4, 5), alternative = c("two.sided"))
        test <- plyr::llply(test, function(x) NA)
        test$method <- "Two-sample Kolmogorov-Smirnov test"
        test$p.value <- NaN
        test$statistic <- NaN
        class(test) <- "htest"
        test
    }
    else {
        test
    }
    effect_size_test <- try(effsize::cohen.d(d = value, f = group, 
        na.rm = TRUE), silent = TRUE)
    effect_size <- if (class(effect_size_test) == "try-error") {
        warning("Not enough values. Returning effect size NaN.")
        list(estimate = NaN, conf.int = c(NaN, NaN))
    }
    else {
        effect_size_test
    }
    out$effect_size <- effect_size$estimate
    out$effect_size_CI_lower <- effect_size$conf.int[1]
    out$effect_size_CI_upper <- effect_size$conf.int[2]
    class(out) <- c("htest_with_effect_size", class(out))
    return(out)
}
<bytecode: 0x5574c9f322e8>
<environment: namespace:atable>
 --- function search by body ---
Function two_sample_htest.numeric in namespace atable has this body.
 ----------- END OF FAILURE REPORT -------------- 
Quitting from lines 88-105 (atable_usage.rnw) 
Error: processing vignette ‘atable_usage.rnw’ failed with diagnostics:
the condition has length > 1
--- failed re-building ‘atable_usage.rnw’

--- re-building ‘extending.Rnw’ using knitr
Warning in wilcox.test.default(x = DATA[[1L]], y = DATA[[2L]], ...) :
  cannot compute exact p-value with ties
 ----------- FAILURE REPORT -------------- 
 --- failure: the condition has length > 1 ---
 --- srcref --- 
: 
 --- package (from environment) --- 
atable
 --- call from context --- 
two_sample_htest.numeric(value, group, ...)
 --- call from argument --- 
if (class(test) == "try-error") {
    warning("Not enough values. Returning p.value=NaN.")
    test <- stats::ks.test(c(1, 2), c(3, 4, 5), alternative = c("two.sided"))
    test <- plyr::llply(test, function(x) NA)
    test$method <- "Two-sample Kolmogorov-Smirnov test"
    test$p.value <- NaN
    test$statistic <- NaN
    class(test) <- "htest"
    test
} else {
    test
}
 --- R stacktrace ---
where 1: two_sample_htest.numeric(value, group, ...)
where 2: two_sample_htest(value, group, ...)
where 3: (function (DD, group_col, value_col, ...) 
{
    stopifnot(is.character(group_col), length(group_col) == 1, 
        is.character(value_col), length(value_col) == 1, group_col %in% 
            colnames(DD), value_col %in% colnames(DD), is.factor(DD[[group_col]]))
    value <- DD[[value_col]]
    group <- DD[[group_col]]
    group_levels <- levels(DD[[group_col]])
    result <- if (length(group_levels) == 2) {
        two_sample_htest(value, group, ...)
    }
    else {
        multi_sample_htest(value, group, ...)
    }
    return(result)
})(value_col = dots[[1L]][[3L]], DD = list(vs = c(1L, 1L, 2L, 
2L, 1L, 2L, 1L, 2L, 2L, 2L, 2L, 1L, 1L, 1L, 1L, 1L, 1L, 2L, 2L, 
2L, 2L, 1L, 1L, 1L, 1L, 2L, 1L, 2L, 1L, 1L, 1L, 2L), cyl = c(2L, 
2L, 1L, 2L, 3L, 2L, 3L, 1L, 1L, 2L, 2L, 3L, 3L, 3L, 3L, 3L, 3L, 
1L, 1L, 1L, 1L, 3L, 3L, 3L, 3L, 1L, 1L, 1L, 3L, 2L, 3L, 1L), 
    hp = c(110, 110, 93, 110, 175, 105, 245, 62, 95, 123, 123, 
    180, 180, 180, 205, 215, 230, 66, 52, 65, 97, 150, 150, 245, 
    175, 66, 91, 113, 264, 175, 335, 109), disp = c(160, 160, 
    108, 258, 360, 225, 360, 146.7, 140.8, 167.6, 167.6, 275.8, 
    275.8, 275.8, 472, 460, 440, 78.7, 75.7, 71.1, 120.1, 318, 
    304, 350, 400, 79, 120.3, 95.1, 351, 145, 301, 121), am = c(2L, 
    2L, 2L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 
    1L, 2L, 2L, 2L, 1L, 1L, 1L, 1L, 1L, 2L, 2L, 2L, 2L, 2L, 2L, 
    2L), Observations = c(0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 
    0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 
    0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L)), group_col = "am")
where 4: mapply(test_caller, value_col = target_cols, MoreArgs = list(DD = DD, 
    group_col = group_col, ...), SIMPLIFY = FALSE)
where 5: apply_tests_helper(DD, target_cols, group_col, ...)
where 6: atable_unsplitted_grouped(DD = DD, target_cols = target_cols, 
    group_col = group_col, Alias_mapping = Alias_mapping, split_cols = split_cols, 
    format_to = format_to, blocks = blocks, indent_character = indent_character, 
    indent = indent, ...)
where 7: atable.data.frame(x = data, target_cols = target_cols, group_col = group_col, 
    split_cols = split_cols, ...)
where 8: atable(x = data, target_cols = target_cols, group_col = group_col, 
    split_cols = split_cols, ...)
where 9: atable.formula(vs + cyl + hp + disp ~ am, mtcars)
where 10: atable(vs + cyl + hp + disp ~ am, mtcars)
where 11: Hmisc::latex(atable(vs + cyl + hp + disp ~ am, mtcars), file = "", 
    title = "", rowname = NULL, table.env = FALSE)
where 12: eval(expr, envir, enclos)
where 13: eval(expr, envir, enclos)
where 14: eval_with_user_handlers(expr, envir, enclos, user_handlers)
where 15: withVisible(eval_with_user_handlers(expr, envir, enclos, user_handlers))
where 16: withCallingHandlers(withVisible(eval_with_user_handlers(expr, 
    envir, enclos, user_handlers)), warning = wHandler, error = eHandler, 
    message = mHandler)
where 17: handle(ev <- withCallingHandlers(withVisible(eval_with_user_handlers(expr, 
    envir, enclos, user_handlers)), warning = wHandler, error = eHandler, 
    message = mHandler))
where 18: timing_fn(handle(ev <- withCallingHandlers(withVisible(eval_with_user_handlers(expr, 
    envir, enclos, user_handlers)), warning = wHandler, error = eHandler, 
    message = mHandler)))
where 19: evaluate_call(expr, parsed$src[[i]], envir = envir, enclos = enclos, 
    debug = debug, last = i == length(out), use_try = stop_on_error != 
        2L, keep_warning = keep_warning, keep_message = keep_message, 
    output_handler = output_handler, include_timing = include_timing)
where 20: evaluate::evaluate(...)
where 21: evaluate(code, envir = env, new_device = FALSE, keep_warning = !isFALSE(options$warning), 
    keep_message = !isFALSE(options$message), stop_on_error = if (is.numeric(options$error)) options$error else {
        if (options$error && options$include) 
            0L
        else 2L
    }, output_handler = knit_handlers(options$render, options))
where 22: in_dir(input_dir(), evaluate(code, envir = env, new_device = FALSE, 
    keep_warning = !isFALSE(options$warning), keep_message = !isFALSE(options$message), 
    stop_on_error = if (is.numeric(options$error)) options$error else {
        if (options$error && options$include) 
            0L
        else 2L
    }, output_handler = knit_handlers(options$render, options)))
where 23: eng_r(options)
where 24: block_exec(params)
where 25: call_block(x)
where 26: process_group.block(group)
where 27: process_group(group)
where 28: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 
    error = function(e) {
        setwd(wd)
        cat(res, sep = "\n", file = output %n% "")
        message("Quitting from lines ", paste(current_lines(i), 
            collapse = "-"), " (", knit_concord$get("infile"), 
            ") ")
    })
where 29: process_file(text, output)
where 30: (if (grepl("\\.[Rr]md$", file)) knit2html else if (grepl("\\.[Rr]rst$", 
    file)) knit2pandoc else knit)(file, encoding = encoding, 
    quiet = quiet, envir = globalenv(), ...)
where 31: engine$weave(file, quiet = quiet, encoding = enc)
where 32: doTryCatch(return(expr), name, parentenv, handler)
where 33: tryCatchOne(expr, names, parentenv, handlers[[1L]])
where 34: tryCatchList(expr, classes, parentenv, handlers)
where 35: tryCatch({
    engine$weave(file, quiet = quiet, encoding = enc)
    setwd(startdir)
    output <- find_vignette_product(name, by = "weave", engine = engine)
    if (!have.makefile && vignette_is_tex(output)) {
        texi2pdf(file = output, clean = FALSE, quiet = quiet)
        output <- find_vignette_product(name, by = "texi2pdf", 
            engine = engine)
    }
    outputs <- c(outputs, output)
}, error = function(e) {
    thisOK <<- FALSE
    fails <<- c(fails, file)
    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s", 
        file, conditionMessage(e)))
})
where 36: tools:::buildVignettes(dir = "/home/hornik/tmp/R.check/r-devel-gcc/Work/PKGS/atable.Rcheck/vign_test/atable")

 --- value of length: 2 type: logical ---
[1] FALSE FALSE
 --- function from context --- 
function (value, group, two_sample_htest.numeric = NULL, ...) 
{
    if (is.function(two_sample_htest.numeric)) 
        return(two_sample_htest.numeric(value, group, ...))
    if (is.function(atable_options("two_sample_htest.numeric"))) 
        return(atable_options("two_sample_htest.numeric")(value, 
            group, ...))
    d <- data.frame(value = value, group = group)
    group_levels <- levels(group)
    x <- subset(d, group %in% group_levels[1], select = "value", 
        drop = TRUE)
    y <- subset(d, group %in% group_levels[2], select = "value", 
        drop = TRUE)
    test <- try(stats::ks.test(x, y, alternative = c("two.sided"), 
        ...), silent = TRUE)
    out <- if (class(test) == "try-error") {
        warning("Not enough values. Returning p.value=NaN.")
        test <- stats::ks.test(c(1, 2), c(3, 4, 5), alternative = c("two.sided"))
        test <- plyr::llply(test, function(x) NA)
        test$method <- "Two-sample Kolmogorov-Smirnov test"
        test$p.value <- NaN
        test$statistic <- NaN
        class(test) <- "htest"
        test
    }
    else {
        test
    }
    effect_size_test <- try(effsize::cohen.d(d = value, f = group, 
        na.rm = TRUE), silent = TRUE)
    effect_size <- if (class(effect_size_test) == "try-error") {
        warning("Not enough values. Returning effect size NaN.")
        list(estimate = NaN, conf.int = c(NaN, NaN))
    }
    else {
        effect_size_test
    }
    out$effect_size <- effect_size$estimate
    out$effect_size_CI_lower <- effect_size$conf.int[1]
    out$effect_size_CI_upper <- effect_size$conf.int[2]
    class(out) <- c("htest_with_effect_size", class(out))
    return(out)
}
<bytecode: 0x5574c9f322e8>
<environment: namespace:atable>
 --- function search by body ---
Function two_sample_htest.numeric in namespace atable has this body.
 ----------- END OF FAILURE REPORT -------------- 
Quitting from lines 63-68 (extending.Rnw) 
Error: processing vignette ‘extending.Rnw’ failed with diagnostics:
the condition has length > 1
--- failed re-building ‘extending.Rnw’

--- re-building ‘modifying.Rnw’ using knitr
Warning in wilcox.test.default(x = DATA[[1L]], y = DATA[[2L]], ...) :
  cannot compute exact p-value with ties
 ----------- FAILURE REPORT -------------- 
 --- failure: the condition has length > 1 ---
 --- srcref --- 
: 
 --- package (from environment) --- 
atable
 --- call from context --- 
two_sample_htest.numeric(value, group, ...)
 --- call from argument --- 
if (class(test) == "try-error") {
    warning("Not enough values. Returning p.value=NaN.")
    test <- stats::ks.test(c(1, 2), c(3, 4, 5), alternative = c("two.sided"))
    test <- plyr::llply(test, function(x) NA)
    test$method <- "Two-sample Kolmogorov-Smirnov test"
    test$p.value <- NaN
    test$statistic <- NaN
    class(test) <- "htest"
    test
} else {
    test
}
 --- R stacktrace ---
where 1: two_sample_htest.numeric(value, group, ...)
where 2: two_sample_htest(value, group, ...)
where 3: (function (DD, group_col, value_col, ...) 
{
    stopifnot(is.character(group_col), length(group_col) == 1, 
        is.character(value_col), length(value_col) == 1, group_col %in% 
            colnames(DD), value_col %in% colnames(DD), is.factor(DD[[group_col]]))
    value <- DD[[value_col]]
    group <- DD[[group_col]]
    group_levels <- levels(DD[[group_col]])
    result <- if (length(group_levels) == 2) {
        two_sample_htest(value, group, ...)
    }
    else {
        multi_sample_htest(value, group, ...)
    }
    return(result)
})(value_col = dots[[1L]][[3L]], DD = list(vs = c(1L, 1L, 2L, 
2L, 1L, 2L, 1L, 2L, 2L, 2L, 2L, 1L, 1L, 1L, 1L, 1L, 1L, 2L, 2L, 
2L, 2L, 1L, 1L, 1L, 1L, 2L, 1L, 2L, 1L, 1L, 1L, 2L), cyl = c(2L, 
2L, 1L, 2L, 3L, 2L, 3L, 1L, 1L, 2L, 2L, 3L, 3L, 3L, 3L, 3L, 3L, 
1L, 1L, 1L, 1L, 3L, 3L, 3L, 3L, 1L, 1L, 1L, 3L, 2L, 3L, 1L), 
    hp = c(110, 110, 93, 110, 175, 105, 245, 62, 95, 123, 123, 
    180, 180, 180, 205, 215, 230, 66, 52, 65, 97, 150, 150, 245, 
    175, 66, 91, 113, 264, 175, 335, 109), disp = c(160, 160, 
    108, 258, 360, 225, 360, 146.7, 140.8, 167.6, 167.6, 275.8, 
    275.8, 275.8, 472, 460, 440, 78.7, 75.7, 71.1, 120.1, 318, 
    304, 350, 400, 79, 120.3, 95.1, 351, 145, 301, 121), am = c(2L, 
    2L, 2L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 1L, 
    1L, 2L, 2L, 2L, 1L, 1L, 1L, 1L, 1L, 2L, 2L, 2L, 2L, 2L, 2L, 
    2L), Observations = c(0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 
    0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L, 
    0L, 0L, 0L, 0L, 0L, 0L, 0L, 0L)), group_col = "am")
where 4: mapply(test_caller, value_col = target_cols, MoreArgs = list(DD = DD, 
    group_col = group_col, ...), SIMPLIFY = FALSE)
where 5: apply_tests_helper(DD, target_cols, group_col, ...)
where 6: atable_unsplitted_grouped(DD = DD, target_cols = target_cols, 
    group_col = group_col, Alias_mapping = Alias_mapping, split_cols = split_cols, 
    format_to = format_to, blocks = blocks, indent_character = indent_character, 
    indent = indent, ...)
where 7: atable.data.frame(x = data, target_cols = target_cols, group_col = group_col, 
    split_cols = split_cols, ...)
where 8: atable(x = data, target_cols = target_cols, group_col = group_col, 
    split_cols = split_cols, ...)
where 9: atable.formula(vs + cyl + hp + disp ~ am, mtcars, format_to = "Latex")
where 10: atable(vs + cyl + hp + disp ~ am, mtcars, format_to = "Latex")
where 11: Hmisc::latex(atable(vs + cyl + hp + disp ~ am, mtcars, format_to = "Latex"), 
    file = "", title = "", rowname = NULL, table.env = FALSE)
where 12: eval(expr, envir, enclos)
where 13: eval(expr, envir, enclos)
where 14: eval_with_user_handlers(expr, envir, enclos, user_handlers)
where 15: withVisible(eval_with_user_handlers(expr, envir, enclos, user_handlers))
where 16: withCallingHandlers(withVisible(eval_with_user_handlers(expr, 
    envir, enclos, user_handlers)), warning = wHandler, error = eHandler, 
    message = mHandler)
where 17: handle(ev <- withCallingHandlers(withVisible(eval_with_user_handlers(expr, 
    envir, enclos, user_handlers)), warning = wHandler, error = eHandler, 
    message = mHandler))
where 18: timing_fn(handle(ev <- withCallingHandlers(withVisible(eval_with_user_handlers(expr, 
    envir, enclos, user_handlers)), warning = wHandler, error = eHandler, 
    message = mHandler)))
where 19: evaluate_call(expr, parsed$src[[i]], envir = envir, enclos = enclos, 
    debug = debug, last = i == length(out), use_try = stop_on_error != 
        2L, keep_warning = keep_warning, keep_message = keep_message, 
    output_handler = output_handler, include_timing = include_timing)
where 20: evaluate::evaluate(...)
where 21: evaluate(code, envir = env, new_device = FALSE, keep_warning = !isFALSE(options$warning), 
    keep_message = !isFALSE(options$message), stop_on_error = if (is.numeric(options$error)) options$error else {
        if (options$error && options$include) 
            0L
        else 2L
    }, output_handler = knit_handlers(options$render, options))
where 22: in_dir(input_dir(), evaluate(code, envir = env, new_device = FALSE, 
    keep_warning = !isFALSE(options$warning), keep_message = !isFALSE(options$message), 
    stop_on_error = if (is.numeric(options$error)) options$error else {
        if (options$error && options$include) 
            0L
        else 2L
    }, output_handler = knit_handlers(options$render, options)))
where 23: eng_r(options)
where 24: block_exec(params)
where 25: call_block(x)
where 26: process_group.block(group)
where 27: process_group(group)
where 28: withCallingHandlers(if (tangle) process_tangle(group) else process_group(group), 
    error = function(e) {
        setwd(wd)
        cat(res, sep = "\n", file = output %n% "")
        message("Quitting from lines ", paste(current_lines(i), 
            collapse = "-"), " (", knit_concord$get("infile"), 
            ") ")
    })
where 29: process_file(text, output)
where 30: (if (grepl("\\.[Rr]md$", file)) knit2html else if (grepl("\\.[Rr]rst$", 
    file)) knit2pandoc else knit)(file, encoding = encoding, 
    quiet = quiet, envir = globalenv(), ...)
where 31: engine$weave(file, quiet = quiet, encoding = enc)
where 32: doTryCatch(return(expr), name, parentenv, handler)
where 33: tryCatchOne(expr, names, parentenv, handlers[[1L]])
where 34: tryCatchList(expr, classes, parentenv, handlers)
where 35: tryCatch({
    engine$weave(file, quiet = quiet, encoding = enc)
    setwd(startdir)
    output <- find_vignette_product(name, by = "weave", engine = engine)
    if (!have.makefile && vignette_is_tex(output)) {
        texi2pdf(file = output, clean = FALSE, quiet = quiet)
        output <- find_vignette_product(name, by = "texi2pdf", 
            engine = engine)
    }
    outputs <- c(outputs, output)
}, error = function(e) {
    thisOK <<- FALSE
    fails <<- c(fails, file)
    message(gettextf("Error: processing vignette '%s' failed with diagnostics:\n%s", 
        file, conditionMessage(e)))
})
where 36: tools:::buildVignettes(dir = "/home/hornik/tmp/R.check/r-devel-gcc/Work/PKGS/atable.Rcheck/vign_test/atable")

 --- value of length: 2 type: logical ---
[1] FALSE FALSE
 --- function from context --- 
function (value, group, two_sample_htest.numeric = NULL, ...) 
{
    if (is.function(two_sample_htest.numeric)) 
        return(two_sample_htest.numeric(value, group, ...))
    if (is.function(atable_options("two_sample_htest.numeric"))) 
        return(atable_options("two_sample_htest.numeric")(value, 
            group, ...))
    d <- data.frame(value = value, group = group)
    group_levels <- levels(group)
    x <- subset(d, group %in% group_levels[1], select = "value", 
        drop = TRUE)
    y <- subset(d, group %in% group_levels[2], select = "value", 
        drop = TRUE)
    test <- try(stats::ks.test(x, y, alternative = c("two.sided"), 
        ...), silent = TRUE)
    out <- if (class(test) == "try-error") {
        warning("Not enough values. Returning p.value=NaN.")
        test <- stats::ks.test(c(1, 2), c(3, 4, 5), alternative = c("two.sided"))
        test <- plyr::llply(test, function(x) NA)
        test$method <- "Two-sample Kolmogorov-Smirnov test"
        test$p.value <- NaN
        test$statistic <- NaN
        class(test) <- "htest"
        test
    }
    else {
        test
    }
    effect_size_test <- try(effsize::cohen.d(d = value, f = group, 
        na.rm = TRUE), silent = TRUE)
    effect_size <- if (class(effect_size_test) == "try-error") {
        warning("Not enough values. Returning effect size NaN.")
        list(estimate = NaN, conf.int = c(NaN, NaN))
    }
    else {
        effect_size_test
    }
    out$effect_size <- effect_size$estimate
    out$effect_size_CI_lower <- effect_size$conf.int[1]
    out$effect_size_CI_upper <- effect_size$conf.int[2]
    class(out) <- c("htest_with_effect_size", class(out))
    return(out)
}
<bytecode: 0x5574c9f322e8>
<environment: namespace:atable>
 --- function search by body ---
Function two_sample_htest.numeric in namespace atable has this body.
 ----------- END OF FAILURE REPORT -------------- 
Quitting from lines 62-69 (modifying.Rnw) 
Error: processing vignette ‘modifying.Rnw’ failed with diagnostics:
the condition has length > 1
--- failed re-building ‘modifying.Rnw’

SUMMARY: processing the following files failed:
  ‘atable_usage.rnw’ ‘extending.Rnw’ ‘modifying.Rnw’

Error: Vignette re-building failed.
Execution halted