testthat

https://testthat.r-lib.org
Admin
testthat is a popular unit testing framework for R that makes testing fun and easy with clear...
Tokens:134,769
Snippets:988
Trust Score:8.3
Update:1 week ago
Show doc for...
Tokens:
Raw
### Example: Old approach with setup()/teardown() and recommended fixture

Source: https://testthat.r-lib.org/reference/teardown.html

Shows the old approach using setup() and teardown() to create and clean up a temporary file, and the recommended alternative using a test fixture with withr::defer(). The example is wrapped in if (FALSE) to prevent execution.

```r
if (FALSE) { # \dontrun{
# Old approach
tmp <- tempfile()
setup(writeLines("some test data", tmp))
teardown(unlink(tmp))
} # }

# Now recommended:
local_test_data <- function(env = parent.frame()) {
  tmp <- tempfile()
  writeLines("some test data", tmp)
  withr::defer(unlink(tmp), env)

  tmp
}
# Then call local_test_data() in your tests
```

--------------------------------

### Usage of teardown() and setup()

Source: https://testthat.r-lib.org/reference/teardown.html

Function signatures for teardown() and setup(). Both take code to evaluate and an optional environment (expert use only).

```r
teardown(code, env = parent.frame())

setup(code, env = parent.frame())
```

--------------------------------

### Example: list and retrieve built-in test files

Source: https://testthat.r-lib.org/reference/testthat_examples.html

Lists the example test files in the testthat package and retrieves the path to a specific example file. The output shows the directory contents and the resolved path.

```r
dir(testthat_examples())
#> [1] "_snaps"         "test-failure.R" "test-success.R"
testthat_example("success")
#> [1] "/home/runner/work/_temp/Library/testthat/examples/test-success.R"
```

--------------------------------

### Install testthat from CRAN or GitHub

Source: https://testthat.r-lib.org/index.html

Install the released version from CRAN with install.packages("testthat"), or the development version from GitHub using pak::pak("r-lib/testthat"). The GitHub installation is commented out by default.

```r
# Install the released version from CRAN
install.packages("testthat")

# Or the development version from GitHub:
# install.packages("pak")
pak::pak("r-lib/testthat")
```

--------------------------------

### test_example(path, title = path)

Source: https://testthat.r-lib.org/reference/test_examples.html

Tests examples from a single Rd file. Each example counts as one test and succeeds if the code runs without an error.

```APIDOC
## test_example(path, title = path)

### Description
Tests examples from a single Rd file. Each example counts as one test and succeeds if the code runs without an error.

### Usage
```r
test_example(path, title = path)
```

### Arguments
- **path** (character) - Path to a single Rd file. Remember the working directory for tests is `tests/testthat`.
- **title** (character) - Test title to use.

```

--------------------------------

### Example: using mock_output_sequence() with local_mocked_bindings()

Source: https://testthat.r-lib.org/reference/mock_output_sequence.html

Demonstrates how to mock `readline` to return a sequence of values inside `local_mocked_bindings()`. The example is wrapped in `if (FALSE)` and `\dontrun{}` to prevent execution during package checks.

```r
if (FALSE) { # \dontrun{
local_mocked_bindings(readline = mock_output_sequence("3", "This is a note", "n"))
} # }
```

--------------------------------

### Examples of expect_true and expect_all_true

Source: https://testthat.r-lib.org/reference/logical-expectations.html

Examples showing that failed expectations throw errors contamination with show_failure(). The first example demonstrates a passing expectation; the second contrasts expect_true() with the more specific expect_equal(); the final example uses expect_all_true(), which checks every element individually. The output includes the failure messages.

```r
expect_true(2 == 2)
# Failed expectations will throw an error
show_failure(expect_true(2 != 2))
#> Failed expectation:
#> Expected `2 != 2` to be TRUE.
#> Differences:
#> `actual`:   FALSE
#> `expected`: TRUE 
#> 

# where possible, use more specific expectations, to get more informative
# error messages
a <- 1:4
show_failure(expect_true(length(a) == 3))
#> Failed expectation:
#> Expected `length(a) == 3` to be TRUE.
#> Differences:
#> `actual`:   FALSE
#> `expected`: TRUE 
#> 
show_failure(expect_equal(length(a), 3))
#> Failed expectation:
#> Expected `length(a)` to equal 3.
#> Differences:
#>   `actual`: 4.0
#> `expected`: 3.0
#> 

x <- c(TRUE, TRUE, FALSE, TRUE)
show_failure(expect_true(all(x)))
#> Failed expectation:
#> Expected `all(x)` to be TRUE.
#> Differences:
#> `actual`:   FALSE
#> `expected`: TRUE 
#> 
show_failure(expect_all_true(x))
#> Failed expectation:
#> Expected every element of `x` to equal TRUE.
#> Differences:
#> `actual`:   TRUE TRUE FALSE TRUE
#> `expected`: TRUE TRUE TRUE  TRUE
#> 
```

--------------------------------

### test_path() example

Source: https://testthat.r-lib.org/reference/test_path.html

Example usage of test_path() to locate files. Wrapped in if (FALSE) and \dontrun{} to prevent execution during package checks.

```r
if (FALSE) { # \dontrun{
test_path("foo.csv")
test_path("data", "foo.csv")
} # }
```

--------------------------------

### test_examples(path = "../..")

Source: https://testthat.r-lib.org/reference/test_examples.html

Tests all examples in Rd files within a directory. Each example counts as one test and succeeds if the code runs without an error.

```APIDOC
## test_examples(path = "../..")

### Description
Tests all examples in Rd files within a directory. Each example counts as one test and succeeds if the code runs without an error.

### Usage
```r
test_examples(path = "../..")
```

### Arguments
- **path** (character) - Path to directory containing Rd files. Remember the working directory for tests is `tests/testthat`.

```

--------------------------------

### Example function calling anotherpackage::another_function()

Source: https://testthat.r-lib.org/reference/local_mocked_bindings.html

Example function that calls another_function() from another package using ::. This is harder to mock because it requires modifying the other package's namespace.

```r
some_function <- function() {
  anotherpackage::another_function()
}
```

--------------------------------

### Examples of set and mapping expectations

Source: https://testthat.r-lib.org/reference/expect_setequal.html

Demonstrates successful and failing uses of expect_setequal and expect_mapequal. The failing examples show the failure messages produced by show_failure().

```r
expect_setequal(letters, rev(letters))
show_failure(expect_setequal(letters[-1], rev(letters)))
#> Failed expectation:
#> Expected `letters[-1]` to have the same values as `rev(letters)`.
#> Actual: "b", "c", "d", "e", "f", "g", "h", "i", "j", ...
#> Expected: "z", "y", "x", "w", "v", "u", "t", "s", "r", ...
#> Absent: "a"

x <- list(b = 2, a = 1)
expect_mapequal(x, list(a = 1, b = 2))
show_failure(expect_mapequal(x, list(a = 1)))
#> Failed expectation:
#> Expected `x` to have the same names as `list(a = 1)`.
#> Actual: "b", "a"
#> Expected: "a"
#> Needs: "b"
show_failure(expect_mapequal(x, list(a = 1, b = "x")))
#> Failed expectation:
#> Expected `x` to contain the same values as `list(a = 1, b = "x")`.
#> Differences:
#> `actual$b` is a double vector (2)
#> `expected$b` is a character vector ('x')
#> 
show_failure(expect_mapequal(x, list(a = 1, b = 2, c = 3)))
#> Failed expectation:
#> Expected `x` to have the same names as `list(a = 1, b = 2, c = 3)`.
#> Actual: "b", "a"
#> Expected: "a", "b", "c"
#> Absent: "c"
```

--------------------------------

### Example: understanding mock_output_sequence() with recycling

Source: https://testthat.r-lib.org/reference/mock_output_sequence.html

Shows that when `recycle = TRUE`, the sequence repeats after exhaustion. The example demonstrates the returned values cycling back to the first value.

```r
recycled_mocked_sequence <- mock_output_sequence(
  "3", "This is a note", "n",
  recycle = TRUE
)
recycled_mocked_sequence()
#> [1] "3"
recycled_mocked_sequence()
#> [1] "This is a note"
recycled_mocked_sequence()
#> [1] "n"
recycled_mocked_sequence()
#> [1] "3"
```

--------------------------------

### source_test_setup()

Source: https://testthat.r-lib.org/reference/source_file.html

Sources setup files in the testthat directory. It evaluates the code in the specified environment.

```APIDOC
## source_test_setup()

### Description
Sources setup files in the testthat directory. It evaluates the code in the specified environment.

### Usage
```r
source_test_setup(path = "tests/testthat", env = test_env())
```

### Arguments
- **path** - Path to files.
- **env** - Environment in which to evaluate code.

```

--------------------------------

### expect_null() example with failure output

Source: https://testthat.r-lib.org/reference/expect_null.html

Example showing how to use expect_null() to test for NULL. It demonstrates a passing case with x and a failing case with y, displaying the failure message that includes the actual value and type.

```r
x <- NULL
y <- 10

expect_null(x)
show_failure(expect_null(y))
#> Failed expectation:
#> Expected `y` to be NULL.
#> Differences:
#> `actual` is a double vector (10)
#> `expected` is NULL
#> 
```

--------------------------------

### Example: Using expect_equal() and expect_identical()

Source: https://testthat.r-lib.org/reference/equality-expectations.html

Demonstrates basic usage of expect_equal() and expect_identical(). The example shows that expect_equal() is used for numeric equality, and that expect_identical() would fail for sqrt(2)^2 == 2 due to floating point differences, so it is wrapped in \dontrun{}.

```r
a <- 10
expect_equal(a, 10)

# Use expect_equal() when testing for numeric equality
if (FALSE) { # \dontrun{
expect_identical(sqrt(2) ^ 2, 2)
} # }
expect_equal(sqrt(2) ^ 2, 2)
```

--------------------------------

### context_start_file(name)

Source: https://testthat.r-lib.org/reference/context_start_file.html

Starts a test context from a file name. This function is intended for use in external reporters.

```APIDOC
## context_start_file(name)

### Description
Starts a test context from a file name. For use in external reporters.

### Usage
context_start_file(name)

### Arguments
- **name** - file name

```

--------------------------------

### Example: Using expect_known_output() with mtcars

Source: https://testthat.r-lib.org/reference/expect_known_output.html

Shows the typical workflow: the first run always succeeds and creates the reference file, subsequent runs succeed only if the output is unchanged, and a different input fails. The example uses print = TRUE and a temporary file. Deprecation warnings are shown in the output.

```r
tmp <- tempfile()

# The first run always succeeds
expect_known_output(mtcars[1:10, ], tmp, print = TRUE)
#> Warning: `expect_known_output()` was deprecated in the 3rd edition.
#> ℹ Please use `expect_snapshot_output()` instead
#> Warning: Creating reference output.

# Subsequent runs will succeed only if the file is unchanged
# This will succeed:
expect_known_output(mtcars[1:10, ], tmp, print = TRUE)
#> Warning: `expect_known_output()` was deprecated in the 3rd edition.
#> ℹ Please use `expect_snapshot_output()` instead

if (FALSE) { # \dontrun{
# This will fail
expect_known_output(mtcars[1:9, ], tmp, print = TRUE)
} # }
```

--------------------------------

### expect_silent() examples

Source: https://testthat.r-lib.org/reference/expect_silent.html

These examples show basic usage of expect_silent(). The first checks a simple value, the second demonstrates a function that produces output, messages, and warnings, and is wrapped in a \dontrun block.

```r
expect_silent("123")
```

```r
f <- function() {
  message("Hi!")
  warning("Hey!!")
  print("OY!!!")
}
if (FALSE) { # \dontrun{
expect_silent(f())
} # }
```

--------------------------------

### try_again() example with flaky function

Source: https://testthat.r-lib.org/reference/try_again.html

Defines a function that returns 0 with 10% probability, then shows how to use `try_again()` to reduce the chance of failure. The example is wrapped in `if (FALSE)` to avoid running during package checks.

```r
usually_return_1 <- function(i) {
  if (runif(1) < 0.1) 0 else 1
}

if (FALSE) { # \dontrun{
# 10% chance of failure:
expect_equal(usually_return_1(), 1)

# 1% chance of failure:
try_again(1, expect_equal(usually_return_1(), 1))

# 0.1% chance of failure:
try_again(2, expect_equal(usually_return_1(), 1))
} # }
```

--------------------------------

### Examples of expect_lt and expect_gt

Source: https://testthat.r-lib.org/reference/comparison-expectations.html

Example showing passing and failing cases for expect_lt and expect_gt. The failing calls are wrapped in if (FALSE) { # \dontrun{ ... } # } to prevent execution during package checks.

```R
a <- 9
expect_lt(a, 10)

if (FALSE) { # \dontrun{
expect_lt(11, 10)
} # }

a <- 11
expect_gt(a, 10)
if (FALSE) { # \dontrun{
expect_gt(9, 10)
} # }
```

--------------------------------

### Example: Checking visibility and value with expect_invisible

Source: https://testthat.r-lib.org/reference/expect_invisible.html

Demonstrates using expect_invisible() to check that a function returns invisibly, and then checking the returned value with expect_equal(). The example defines a function greet() that returns its argument invisibly.

```r
expect_invisible(x <- 10)
expect_visible(x)

# Typically you'll assign the result of the expectation so you can
# also check that the value is as you expect.
greet <- function(name) {
  message("Hi ", name)
  invisible(name)
}
out <- expect_invisible(greet("Hadley"))
#> Hi Hadley
expect_equal(out, "Hadley")
```

--------------------------------

### testthat test for check_installed() minimum version check

Source: https://testthat.r-lib.org/articles/mocking.html

Test that verifies check_installed() with the min_version argument: a version below the installed version passes, while a version above the installed version fails with an error snapshot. Shows the error message from the version check.

```r
test_that("check_installed() checks minimum version", {
  expect_no_error(check_installed("testthat", "1.0.0"))
  expect_snapshot(check_installed("testthat", "99.99.999"), error = TRUE)
})
```

--------------------------------

### Example of expect_no_warning() with message matching

Source: https://testthat.r-lib.org/reference/expect_no_error.html

Example showing how `expect_no_warning()` behaves. A warning that does not match the `message` pattern bubbles up, while a matching warning causes a failure with an error message that includes the pattern and the actual warning.

```r
expect_no_warning(1 + 1)

foo <- function(x) {
  warning("This is a problem!")
}

# warning doesn't match so bubbles up:
expect_no_warning(foo(), message = "bananas")
#> Warning: This is a problem!

# warning does match so causes a failure:
try(expect_no_warning(foo(), message = "problem"))
#> Error : Expected `foo()` not to throw any warnings matching pattern 'problem'.
#> Actually got a <simpleWarning> with message:
#>   This is a problem!
```

--------------------------------

### Examples: expect_s3_class and expect_type with data frames and factors

Source: https://testthat.r-lib.org/reference/inheritance-expectations.html

Comprehensive example of `expect_s3_class()`, `expect_type()`, `expect_s4_class()` and their `exact` argument. Expected failures are shown with `show_failure()` and the resulting error messages. Demonstrates that `data.frame()` converts strings to factors by default, so `x$y` is an integer type via factor storage.

```r
x <- data.frame(x = 1:10, y = "x", stringsAsFactors = TRUE)
# A data frame is an S3 object with class data.frame
expect_s3_class(x, "data.frame")
show_failure(expect_s4_class(x, "data.frame"))
#> Failed expectation:
#> Expected `x` to be an S4 object.
#> Actual OO type: S3.
# A data frame is built from a list:
expect_type(x, "list")

f <- factor(c("a", "b", "c"))
o <- ordered(f)

# Using multiple class names tests if the object inherits from any of them
expect_s3_class(f, c("ordered", "factor"))
# Use exact = TRUE to test for exact match
show_failure(expect_s3_class(f, c("ordered", "factor"), exact = TRUE))
#> Failed expectation:
#> Expected `f` to have class "ordered"/"factor".
#> Actual class: "factor".
expect_s3_class(o, c("ordered", "factor"), exact = TRUE)

# An integer vector is an atomic vector of type "integer"
expect_type(x$x, "integer")
# It is not an S3 object
show_failure(expect_s3_class(x$x, "integer"))
#> Failed expectation:
#> Expected `x$x` to be an S3 object.
#> Actual OO type: none.

# Above, we requested data.frame() converts strings to factors:
show_failure(expect_type(x$y, "character"))
#> Failed expectation:
#> Expected `x$y` to have type "character".
#> Actual type: "integer"
expect_s3_class(x$y, "factor")
expect_type(x$y, "integer")
```

--------------------------------

### setup(code, env = parent.frame())

Source: https://testthat.r-lib.org/reference/teardown.html

Runs code immediately in a clean environment. This function is no longer recommended; use test fixtures instead.

```APIDOC
## setup(code, env = parent.frame())

### Description
Runs code immediately in a clean environment. This function is no longer recommended; use test fixtures instead.

### Usage
```r
setup(code, env = parent.frame())
```

### Arguments
- **code** - Code to evaluate.
- **env** - Environment in which code will be evaluated. For expert use only.

### Details
Code in a setup() block is run immediately in a clean environment.

### Examples
```r
if (FALSE) { # \dontrun{
# Old approach
tmp <- tempfile()
setup(writeLines("some test data", tmp))
teardown(unlink(tmp))
} # }
```
```

--------------------------------

### Mock requireNamespace to test package installation

Source: https://testthat.r-lib.org/articles/mocking.html

Mocks `requireNamespace()` to test both the success and failure of `check_installed()` for package installation, making the test independent of the system's installed packages. The snapshot validates the error message when the package is not installed.

```r
test_that("check_installed() checks package is installed", {
  local_mocked_bindings(requireNamespace = function(...) TRUE)
  expect_no_error(check_installed("package-name"))

  local_mocked_bindings(requireNamespace = function(...) FALSE)
  expect_snapshot(check_installed("package-name"), error = TRUE)
})
#> ── Warning: check_installed() checks package is installed ─────────────
#> Adding new snapshot:
#> Code
#>   check_installed("package-name")
#> Condition
#>   Error in `check_installed()`:
#>   ! {package-name} is not installed.
#> Test passed with 2 successes 🎊.
```

--------------------------------

### setup.R: Turn off clipboard and HTML preview with withr::local_options()

Source: https://testthat.r-lib.org/articles/special-files.html

More concise alternative to the previous setup.R example. Uses withr::local_options() with .local_envir = teardown_env() to set the same options and automatically restore them after tests.

```r
withr::local_options(
  list(reprex.clipboard = FALSE, reprex.html_preview = FALSE),
  .local_envir = teardown_env()
)

```

--------------------------------

### expect_that() examples with equals()

Source: https://testthat.r-lib.org/reference/expect_that.html

Example calls to expect_that() using equals() as the condition. Each call triggers a deprecation warning in the 3rd edition. The second example is wrapped in a \dontrun block and uses is_identical_to().

```r
expect_that(5 * 2, equals(10))
#> Warning: `expect_that()` was deprecated in the 3rd edition.
expect_that(sqrt(2) ^ 2, equals(2))
#> Warning: `expect_that()` was deprecated in the 3rd edition.
if (FALSE) { # \dontrun{
expect_that(sqrt(2) ^ 2, is_identical_to(2))
} # }
```

--------------------------------

### Usage of testthat_examples() and testthat_example()

Source: https://testthat.r-lib.org/reference/testthat_examples.html

Shows the function signatures for testthat_examples() and testthat_example(filename).

```r
testthat_examples()

testthat_example(filename)
```

--------------------------------

### Example: expect_all_true and expect_all_false with show_failure

Source: https://testthat.r-lib.org/reference/expect_all_equal.html

Demonstrates the helpers for common cases. Uses set.seed(1016) for reproducibility and shows failure output for both expectations.

```r
# expect_all_true() and expect_all_false() are helpers for common cases
set.seed(1016)
show_failure(expect_all_true(rpois(100, 10) < 20))
#> Failed expectation:
#> Expected every element of `rpois(100, 10) < 20` to equal TRUE.
#> Differences:
#> `actual[58:64]`:   TRUE TRUE TRUE FALSE TRUE TRUE TRUE
#> `expected[58:64]`: TRUE TRUE TRUE TRUE  TRUE TRUE TRUE
#> 
#> `actual[91:97]`:   TRUE TRUE TRUE FALSE TRUE TRUE TRUE
#> `expected[91:97]`: TRUE TRUE TRUE TRUE  TRUE TRUE TRUE
#> 
show_failure(expect_all_false(rpois(100, 10) > 20))
#> Failed expectation:
#> Expected every element of `rpois(100, 10) > 20` to equal FALSE.
#> Differences:
#> `actual[38:44]`:   FALSE FALSE FALSE TRUE  FALSE FALSE FALSE
#> `expected[38:44]`: FALSE FALSE FALSE FALSE FALSE FALSE FALSE
#> 
```

--------------------------------

### expect_named() examples

Source: https://testthat.r-lib.org/reference/expect_named.html

Example usage of expect_named(). It checks that a named vector has any names, then checks for specific names. The ignore.order and ignore.case options allow case-insensitive and order-insensitive comparisons. The final example verifies that a vector has no names by passing NULL.

```r
x <- c(a = 1, b = 2, c = 3)
expect_named(x)
expect_named(x, c("a", "b", "c"))

# Use options to control sensitivity
expect_named(x, c("B", "C", "A"), ignore.order = TRUE, ignore.case = TRUE)

# Can also check for the absence of names with NULL
z <- 1:4
expect_named(z, NULL)
```

--------------------------------

### setup.R: Turn off clipboard and HTML preview with options() and withr::defer()

Source: https://testthat.r-lib.org/articles/special-files.html

Example from the reprex package's setup.R. It turns off clipboard and HTML preview functionality during testing by setting options and deferring their restoration until teardown_env().

```r
op <- options(reprex.clipboard = FALSE, reprex.html_preview = FALSE)

withr::defer(options(op), teardown_env())

```

--------------------------------

### test_package(package, reporter = check_reporter(), ...)

Source: https://testthat.r-lib.org/reference/test_package.html

Tests an installed package. This function runs all tests in an installed package using the specified reporter.

```APIDOC
## test_package(package, reporter = check_reporter(), ...)

### Description
Tests an installed package. This function runs all tests in an installed package using the specified reporter.

### Usage
```r
test_package(package, reporter = check_reporter(), ...)
```

### Arguments
- **package** - If these tests belong to a package, the name of the package.
- **reporter** - Reporter to use to summarise output. Can be supplied as a string (e.g. "summary") or as an R6 object (e.g. `SummaryReporter$new()`). See Reporter for more details and a list of built-in reporters.
- **...** - Additional arguments passed to `test_dir()`.

### Value
A list (invisibly) containing data about the test results.
```

--------------------------------

### Example function calling another_function()

Source: https://testthat.r-lib.org/reference/local_mocked_bindings.html

Example function that calls another_function(), which may be internal or imported. This is the target for mocking internal and imported functions.

```r
some_function <- function() {
  another_function()
}
```

--------------------------------

### setup.R: Run before any test and clean up with teardown_env()

Source: https://testthat.r-lib.org/articles/test-fixtures.html

Package-level setup code placed in `tests/testthat/setup.R`. The `withr::defer()` call with `teardown_env()` ensures cleanup runs after all tests.

```r
# Run before any test
write.csv(mtcars, "mtcars.csv")

# Run after all tests
withr::defer(unlink("mtcars.csv"), teardown_env())
```

--------------------------------

### Prioritize test files in DESCRIPTION

Source: https://testthat.r-lib.org/articles/parallel.html

Use the Config/testthat/start-first field in your DESCRIPTION file to specify glob patterns for tests that should run first to improve performance.

```text
Config/testthat/start-first: watcher, parallel*
```

--------------------------------

### Usage of test_examples, test_rd, and test_example

Source: https://testthat.r-lib.org/reference/test_examples.html

Shows the usage of the three helper functions: test_examples(), test_rd(), and test_example(). The path argument for test_examples() is a directory containing Rd files, while for test_example() it is a single Rd file. The working directory for tests is tests/testthat.

```r
test_examples(path = "../..")

test_rd(rd, title = attr(rd, "Rdfile"))

test_example(path, title = path)
```

--------------------------------

### Quasiquotation example: for loop with expect_equal

Source: https://testthat.r-lib.org/news/index.html

This example shows a for loop that tests a function f() with expect_equal(). Without unquoting, the failure message is generic and hard to diagnose.

```r
f <- function(i) if (i > 3) i * 9 else i * 10

for (i in 1:5) {
  expect_equal(f(i), i * 10)
}
```

--------------------------------

### test_that() example with failing expectation (dontrun)

Source: https://testthat.r-lib.org/reference/test_that.html

Example test that would fail because sin(pi/4) is not equal to 1. Wrapped in if (FALSE) and # \dontrun{ to prevent execution during package checks.

```r
if (FALSE) { # \dontrun{
test_that("trigonometric functions match identities", {
  expect_equal(sin(pi / 4), 1)
})
} # }
```

--------------------------------

### Example: extract_test() with a failure location

Source: https://testthat.r-lib.org/reference/extract_test.html

Illustrates how to call extract_test() with a file:line:column location to reproduce a test failure. The example is wrapped in if (FALSE) because it is not run during package checks.

```r
# If you see a test failure like this:
# -- Failure (test-extract.R:46:3): errors if can't find test -------------
# Expected FALSE to be TRUE.
# Differences:
# `actual`:   FALSE
# `expected`: TRUE

# You can run this:
if (FALSE) extract_test("test-extract.R:46:3") # \dontrun{}
# to see just the code needed to reproduce the failure
```

--------------------------------

### context() examples with deprecation warnings

Source: https://testthat.r-lib.org/reference/context.html

Demonstrates calling context() with two different descriptions. Each call triggers a deprecation warning in the third edition.

```r
context("String processing")
#> Warning: `context()` was deprecated in the 3rd edition.
context("Remote procedure calls")
#> Warning: `context()` was deprecated in the 3rd edition.
```

--------------------------------

### local_create_package() - test fixture for usethis

Source: https://testthat.r-lib.org/articles/test-fixtures.html

Creates a temporary package, changes working directory and project, and restores state on exit. Used in usethis to test package-specific functions.

```R
local_create_package <- function(dir = file_temp(), env = parent.frame()) {
  old_project <- proj_get_()
  
  # create new folder and package
  create_package(dir, open = FALSE) # A
  withr::defer(fs::dir_delete(dir), envir = env) # -A
  
  # change working directory
  withr::local_dir(dir, .local_envir = env) # B + -B
  
  # switch to new usethis project
  proj_set(dir) # C
  withr::defer(proj_set(old_project, force = TRUE), envir = env) # -C
  
  dir
}
```

--------------------------------

### Expect length and shape examples with failure messages

Source: https://testthat.r-lib.org/reference/expect_length.html

Examples using `expect_length()` and `expect_shape()` with passing and failing assertions, showing the exact failure messages produced via `show_failure()`.

```r
expect_length(1, 1)
expect_length(1:10, 10)
show_failure(expect_length(1:10, 1))
#> Failed expectation:
#> Expected `1:10` to have length 1.
#> Actual length: 10.

x <- matrix(1:9, nrow = 3)
expect_shape(x, nrow = 3)
show_failure(expect_shape(x, nrow = 4))
#> Failed expectation:
#> Expected `x` to have 4 rows.
#> Actual rows: 3.
expect_shape(x, ncol = 3)
show_failure(expect_shape(x, ncol = 4))
#> Failed expectation:
#> Expected `x` to have 4 columns.
#> Actual columns: 3.
expect_shape(x, dim = c(3, 3))
show_failure(expect_shape(x, dim = c(3, 4, 5)))
#> Failed expectation:
#> Expected `x` to have 3 dimensions.
#> Actual dimensions: 2.

```

--------------------------------

### expect_vector_length() function definition start

Source: https://testthat.r-lib.org/articles/custom-expectation.html

Start of a stricter expectation function that checks the input is a vector (atomic vector or list) before checking its length. This snippet begins the definition of expect_vector_length().

```r
expect_vector_length <- function(object, n) {  
  act <- quasi_label(rlang::enquo(object))
```

--------------------------------

### Example: testing str(mtcars) output with expect_output()

Source: https://testthat.r-lib.org/reference/expect_output.html

Shows how to use expect_output() to check that str(mtcars) prints a data frame with 32 observations and 11 variables. Also demonstrates using ignore.case and fixed arguments to control matching.

```r
str(mtcars)
#> 'data.frame':	32 obs. of  11 variables:
#>  $ mpg : num  21 21 22.8 21.4 18.7 18.1 14.3 24.4 22.8 19.2 ...
#>  $ cyl : num  6 6 4 6 8 6 8 4 4 6 ...
#>  $ disp: num  160 160 108 258 360 ...
#>  $ hp  : num  110 110 93 110 175 105 245 62 95 123 ...
#>  $ drat: num  3.9 3.9 3.85 3.08 3.15 2.76 3.21 3.69 3.92 3.92 ...
#>  $ wt  : num  2.62 2.88 2.32 3.21 3.44 ...
#>  $ qsec: num  16.5 17 18.6 19.4 17 ...
#>  $ vs  : num  0 0 1 1 0 1 0 1 1 1 ...
#>  $ am  : num  1 1 1 0 0 0 0 0 0 0 ...
#>  $ gear: num  4 4 4 3 3 3 3 4 4 4 ...
#>  $ carb: num  4 4 1 1 2 1 4 2 2 4 ...
expect_output(str(mtcars), "32 obs")
expect_output(str(mtcars), "11 variables")

# You can use the arguments of grepl to control the matching
expect_output(str(mtcars), "11 VARIABLES", ignore.case = TRUE)
expect_output(str(mtcars), "$ mpg", fixed = TRUE)
```

--------------------------------

### Mock system_os() to test skip_on_os() across platforms

Source: https://testthat.r-lib.org/articles/mocking.html

Uses local_mocked_bindings() to simulate the Windows operating system by overriding the internal system_os(), enabling tests that skip_on_os() works correctly across multiple OSes.

```R
test_that("can skip on multiple oses", {
  local_mocked_bindings(system_os = function() "windows")

  expect_skip(skip_on_os("windows"))
  expect_skip(skip_on_os(c("windows", "linux")))
  expect_no_skip(skip_on_os("linux"))
})
```
Tokens:
Raw