Merged origin/main into on-cran

Author: hadley

.Rbuildignore

@@ -23,3 +23,5 @@
 ^[\.]?air\.toml$
 ^\.vscode$
 ^\.git-blame-ignore-rev$
+^CLAUDE\.md$
+^\.claude$

.claude/settings.local.json

@@ -0,0 +1,8 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(find:*)"
+    ],
+    "deny": []
+  }
+}

CLAUDE.md

@@ -0,0 +1,89 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## About This Project
+
+testthat is R's most popular unit testing framework, used by thousands of CRAN packages. It provides functions to make testing R code as fun and addictive as possible, with clear expectations, visual progress indicators, and seamless integration with R package development workflows.
+
+## Key Development Commands
+
+### Testing
+- `devtools::test()` or `Ctrl/Cmd+Shift+T` in RStudio - Run all tests
+- `devtools::test_file("tests/testthat/test-filename.R")` - Run tests in a specific file
+- `testthat::test_local()` - Run tests for local source package
+- `testthat::test_package("testthat")` - Run tests for installed package
+- `R CMD check` - Full package check including tests
+
+### Building and Installation
+- `devtools::load_all()` or `Ctrl/Cmd+Shift+L` - Load package for development
+- `devtools::document()` - Generate documentation
+- `devtools::check()` - Run R CMD check
+- `devtools::install()` - Install package locally
+
+## Core Architecture
+
+### Main Components
+
+1. **Core Testing Functions** (`R/test-that.R`, `R/test-package.R`):
+   - `test_that()` - The fundamental testing function
+   - `test_local()`, `test_package()`, `test_check()` - Different ways to run test suites
+
+2. **Expectations** (`R/expect-*.R`):
+   - Modular expectation functions (equality, conditions, types, etc.)
+   - Each expectation type has its own file following the pattern `expect-[type].R`
+
+3. **Reporters** (`R/reporter*.R`):
+   - Different output formats for test results
+   - Object-oriented design with base `Reporter` class
+   - Includes check, debug, progress, summary, JUnit, TAP formats
+
+4. **Snapshot Testing** (`R/snapshot*.R`):
+   - Value snapshots, file snapshots, output snapshots
+   - Automatic management and comparison of expected outputs
+
+5. **Parallel Testing** (`R/parallel*.R`):
+   - Multi-core test execution
+   - Configuration via `Config/testthat/parallel: true` in DESCRIPTION
+
+6. **Mocking** (`R/mock*.R`, `R/mock2*.R`):
+   - Function mocking capabilities
+   - Both legacy (`mock.R`) and modern (`mock2*.R`) implementations
+
+### Key Design Patterns
+
+- **Editions**: testthat has different "editions" with varying behavior, controlled by `Config/testthat/edition`
+- **Reporters**: Extensible reporting system using R6 classes
+- **Lazy Evaluation**: Expectations use substitute() and lazy evaluation for better error messages
+- **C++ Integration**: Core functionality implemented in C++ for performance
+
+### File Organization
+
+- `R/` - All R source code, organized by functionality
+- `src/` - C++ source code and Makevars
+- `inst/include/testthat/` - C++ headers for other packages to use
+- `tests/testthat/` - Package's own comprehensive test suite
+- `vignettes/` - Documentation on testing concepts and workflows
+
+### Important Configuration
+
+The package uses several DESCRIPTION fields for configuration:
+- `Config/testthat/edition: 3` - Sets testthat edition
+- `Config/testthat/parallel: true` - Enables parallel testing
+- `Config/testthat/start-first` - Tests to run first in parallel mode
+
+### C++ Testing Infrastructure
+
+testthat provides C++ testing capabilities via Catch framework:
+- Headers in `inst/include/testthat/`
+- Test runner infrastructure in `src/test-runner.cpp`
+- Integration with R's testing system
+
+### Snapshot Testing Workflow
+
+- Snapshots stored in `tests/testthat/_snaps/`
+- Different snapshot types: values, files, output
+- Version-specific snapshots for different R versions
+- Use `testthat::snapshot_accept()` to update snapshots
+
+This codebase prioritizes backward compatibility, comprehensive testing, and clear, descriptive error messages to help R developers write better tests.

NEWS.md

@@ -1,6 +1,8 @@
 # testthat (development version)
 
 * New `local_on_cran(TRUE)` allows you to simulate how your tests will run on CRAN (#2112).
+* `expect_no_*()` now executes the entire code block, rather than stopping at the first message or warning (#1991).
+* `expect_no_failures()` and `expect_no_successes()` are now deprecated as `expect_success()` now test for no failures and `expect_failure()` tests for no successes (#)
 * New `pass()` function to use in place of `succeed()` (#2113).
 * `expectation()` is now a combination of `new_expectation()` and `exp_signal()` (#2125).
 * `is_null()`/`matches()` deprecated in 2.0.0 (2017-12-19) and `is_true()`/`is_false()` deprecated in 2.1.0 (2019-04-23) have been removed (#2109).

R/expect-comparison.R

@@ -19,7 +19,12 @@
 #' @name comparison-expectations
 NULL
 
-expect_compare <- function(operator = c("<", "<=", ">", ">="), act, exp) {
+expect_compare_ <- function(
+  operator = c("<", "<=", ">", ">="),
+  act,
+  exp,
+  trace_env = caller_env()
+) {
   operator <- match.arg(operator)
   op <- match.fun(operator)
 
@@ -34,26 +39,25 @@ expect_compare <- function(operator = c("<", "<=", ">", ">="), act, exp) {
   if (length(cmp) != 1 || !is.logical(cmp)) {
     abort("Result of comparison must be a single logical value")
   }
-  expect(
-    if (!is.na(cmp)) cmp else FALSE,
-    sprintf(
+  if (!isTRUE(cmp)) {
+    msg <- sprintf(
       "%s is %s %s. Difference: %.3g",
       act$lab,
       msg,
       exp$lab,
       act$val - exp$val
-    ),
-    trace_env = caller_env()
-  )
-  invisible(act$val)
+    )
+    return(fail(msg, trace_env = trace_env))
+  }
+  pass(act$val)
 }
 #' @export
 #' @rdname comparison-expectations
 expect_lt <- function(object, expected, label = NULL, expected.label = NULL) {
   act <- quasi_label(enquo(object), label, arg = "object")
   exp <- quasi_label(enquo(expected), expected.label, arg = "expected")
 
-  expect_compare("<", act, exp)
+  expect_compare_("<", act, exp)
 }
 
 #' @export
@@ -62,7 +66,7 @@ expect_lte <- function(object, expected, label = NULL, expected.label = NULL) {
   act <- quasi_label(enquo(object), label, arg = "object")
   exp <- quasi_label(enquo(expected), expected.label, arg = "expected")
 
-  expect_compare("<=", act, exp)
+  expect_compare_("<=", act, exp)
 }
 
 #' @export
@@ -71,7 +75,7 @@ expect_gt <- function(object, expected, label = NULL, expected.label = NULL) {
   act <- quasi_label(enquo(object), label, arg = "object")
   exp <- quasi_label(enquo(expected), expected.label, arg = "expected")
 
-  expect_compare(">", act, exp)
+  expect_compare_(">", act, exp)
 }
 
 #' @export
@@ -80,7 +84,7 @@ expect_gte <- function(object, expected, label = NULL, expected.label = NULL) {
   act <- quasi_label(enquo(object), label, arg = "object")
   exp <- quasi_label(enquo(expected), expected.label, arg = "expected")
 
-  expect_compare(">=", act, exp)
+  expect_compare_(">=", act, exp)
 }
 
 

R/expect-condition.R

@@ -115,7 +115,7 @@ expect_error <- function(
   label = NULL
 ) {
   if (edition_get() >= 3) {
-    expect_condition_matching(
+    expect_condition_matching_(
       "error",
       {{ object }},
       regexp = regexp,
@@ -138,8 +138,10 @@ expect_error <- function(
 
     # Access error fields with `[[` rather than `$` because the
     # `$.Throwable` from the rJava package throws with unknown fields
-    expect(is.null(msg), msg, info = info, trace = act$cap[["trace"]])
-    invisible(act$val %||% act$cap)
+    if (!is.null(msg)) {
+      return(fail(msg, info = info, trace = act$cap[["trace"]]))
+    }
+    pass(act$val %||% act$cap)
   }
 }
 
@@ -161,7 +163,7 @@ expect_warning <- function(
       warn("The `all` argument is deprecated")
     }
 
-    expect_condition_matching(
+    expect_condition_matching_(
       "warning",
       {{ object }},
       regexp = regexp,
@@ -186,9 +188,10 @@ expect_warning <- function(
       ...,
       cond_type = "warnings"
     )
-    expect(is.null(msg), msg, info = info)
-
-    invisible(act$val)
+    if (!is.null(msg)) {
+      return(fail(msg, info = info))
+    }
+    pass(act$val)
   }
 }
 
@@ -205,7 +208,7 @@ expect_message <- function(
   label = NULL
 ) {
   if (edition_get() >= 3) {
-    expect_condition_matching(
+    expect_condition_matching_(
       "message",
       {{ object }},
       regexp = regexp,
@@ -218,9 +221,10 @@ expect_message <- function(
   } else {
     act <- quasi_capture(enquo(object), label, capture_messages)
     msg <- compare_messages(act$cap, act$lab, regexp = regexp, all = all, ...)
-    expect(is.null(msg), msg, info = info)
-
-    invisible(act$val)
+    if (!is.null(msg)) {
+      return(fail(msg, info = info))
+    }
+    pass(act$val)
   }
 }
 
@@ -236,7 +240,7 @@ expect_condition <- function(
   label = NULL
 ) {
   if (edition_get() >= 3) {
-    expect_condition_matching(
+    expect_condition_matching_(
       "condition",
       {{ object }},
       regexp = regexp,
@@ -262,13 +266,14 @@ expect_condition <- function(
       inherit = inherit,
       cond_type = "condition"
     )
-    expect(is.null(msg), msg, info = info, trace = act$cap[["trace"]])
-
-    invisible(act$val %||% act$cap)
+    if (!is.null(msg)) {
+      return(fail(msg, info = info, trace = act$cap[["trace"]]))
+    }
+    pass(act$val %||% act$cap)
   }
 }
 
-expect_condition_matching <- function(
+expect_condition_matching_ <- function(
   base_class,
   object,
   regexp = NULL,
@@ -280,6 +285,7 @@ expect_condition_matching <- function(
   trace_env = caller_env(),
   error_call = caller_env()
 ) {
+  check_condition_dots(regexp, ..., error_call = error_call)
   matcher <- cnd_matcher(
     base_class,
     class,
@@ -302,39 +308,32 @@ expect_condition_matching <- function(
 
   # Access error fields with `[[` rather than `$` because the
   # `$.Throwable` from the rJava package throws with unknown fields
-  expect(
-    is.null(msg),
-    msg,
-    info = info,
-    trace = act$cap[["trace"]],
-    trace_env = trace_env
-  )
-
+  if (!is.null(msg)) {
+    return(fail(
+      msg,
+      info = info,
+      trace = act$cap[["trace"]],
+      trace_env = trace_env
+    ))
+  }
   # If a condition was expected, return it. Otherwise return the value
   # of the expression.
-  invisible(if (expected) act$cap else act$val)
+  pass(if (expected) act$cap else act$val)
 }
 
 # -------------------------------------------------------------------------
 
 cnd_matcher <- function(
   base_class,
   class = NULL,
-  pattern = NULL,
+  regexp = NULL,
   ...,
   inherit = TRUE,
   ignore_deprecation = FALSE,
   error_call = caller_env()
 ) {
   check_string(class, allow_null = TRUE, call = error_call)
-  check_string(pattern, allow_null = TRUE, allow_na = TRUE, call = error_call)
-
-  if (is.null(pattern) && dots_n(...) > 0) {
-    cli::cli_abort(
-      "Can't specify {.arg ...} without {.arg pattern}.",
-      call = error_call
-    )
-  }
+  check_string(regexp, allow_null = TRUE, allow_na = TRUE, call = error_call)
 
   function(cnd) {
     if (!inherit) {
@@ -352,12 +351,12 @@ cnd_matcher <- function(
       if (!is.null(class) && !inherits(x, class)) {
         return(FALSE)
       }
-      if (!is.null(pattern) && !isNA(pattern)) {
+      if (!is.null(regexp) && !isNA(regexp)) {
         withCallingHandlers(
-          grepl(pattern, conditionMessage(x), ...),
+          grepl(regexp, conditionMessage(x), ...),
           error = function(e) {
             cli::cli_abort(
-              "Failed to compare {base_class} to {.arg pattern}.",
+              "Failed to compare {base_class} to {.arg regexp}.",
               parent = e,
               call = error_call
             )
@@ -582,3 +581,29 @@ cnd_message <- function(x) {
   withr::local_options(rlang_backtrace_on_error = "none")
   conditionMessage(x)
 }
+
+check_condition_dots <- function(
+  regexp = NULL,
+  ...,
+  error_call = caller_env()
+) {
+  if (!is.null(regexp) || missing(...)) {
+    return()
+  }
+
+  dot_names <- ...names()
+  if (is.null(dot_names)) {
+    dot_names <- rep("", ...length())
+  }
+  unnamed <- dot_names == ""
+  dot_names[unnamed] <- paste0("..", seq_along(dot_names)[unnamed])
+
+  cli::cli_abort(
+    c(
+      "Can't supply {.arg ...} unless {.arg regexp} is set.",
+      "*" = "Unused arguments: {.arg {dot_names}}.",
+      i = "Did you mean to use {.arg regexp} so {.arg ...} is passed to {.fn grepl}?"
+    ),
+    call = error_call
+  )
+}