R: Expectation: does code produce output/message/warning/error?

output-expectations {testthat} | R Documentation

## Expectation: does code produce output/message/warning/error?

### Description

Use `expect_output()`, `expect_message()` and `expect_warning()` to match specified outputs. Use `expect_error()` or `expect_condition()` to match individual errors or conditions. Use `expect_silent()` to assert that there should be no output of any type.

### Usage

    expect_output(object, regexp = NULL, ..., info = NULL, label = NULL,
      width = 80)

    expect_error(object, regexp = NULL, class = NULL, ..., info = NULL,
      label = NULL)

    expect_condition(object, regexp = NULL, class = NULL, ...,
      info = NULL, label = NULL)

    expect_message(object, regexp = NULL, ..., all = FALSE, info = NULL,
      label = NULL)

    expect_warning(object, regexp = NULL, ..., all = FALSE, info = NULL,
      label = NULL)

    expect_silent(object)

### Arguments

`object` | Object to test. Supports limited unquoting to make it easier to generate readable failures within a function or for loop. See quasi_label for more details.
`regexp` | regular expression to test against. If `NULL`, the default, asserts that there should be an output, a messsage, a warning, or an error, but does not test for specific value. If `NA`, asserts that there should be no output, messages, warnings, or errors.
`...` | Arguments passed on to `expect_match` all Should all elements of actual value match `regexp` (TRUE), or does only one need to match (FALSE) perl logical. Should Perl-compatible regexps be used? fixed logical. If `TRUE`, `pattern` is a string to be matched as is. Overrides all conflicting arguments.
`info` | Extra information to be included in the message. This argument is soft-deprecated and should not be used in new code. Instead see alternatives in quasi_label.
`label` | Used to customise failure messages. For expert use only.
`width` | Number of characters per line of output. This does not inherit from `getOption("width")` so that tests always use the same output width, minimising spurious differences.
`class` | Instead of supplying a regular expression, you can also supply a class name. This is useful for "classed" conditions.
`all` | For messages and warnings, do all need to match the `regexp` (TRUE), or does only one need to match (FALSE)

### Details

Note that warnings are captured by a custom signal handler: this means that `options(warn)` has no effect.

### Value

The first argument, invisibly. If `expect_error()` captures an error, that is returned instead of the value.

### See Also

Other expectations: `comparison-expectations`, `equality-expectations`, `expect_length`, `expect_match`, `expect_named`, `expect_null`, `inheritance-expectations`, `logical-expectations`

### Examples

    # Output --------------------------------------------------------------------
    str(mtcars)
    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)

    # Messages ------------------------------------------------------------------

    f <- function(x) {
      if (x < 0) message("*x* is already negative")
      -x
    }
    expect_message(f(-1))
    expect_message(f(-1), "already negative")
    expect_message(f(1), NA)

    # You can use the arguments of grepl to control the matching
    expect_message(f(-1), "*x*", fixed = TRUE)
    expect_message(f(-1), "NEGATIVE", ignore.case = TRUE)

    # Warnings --------------------------------------------------------------------
    f <- function(x) {
      if (x < 0) warning("*x* is already negative")
      -x
    }
    expect_warning(f(-1))
    expect_warning(f(-1), "already negative")
    expect_warning(f(1), NA)

    # You can use the arguments of grepl to control the matching
    expect_warning(f(-1), "*x*", fixed = TRUE)
    expect_warning(f(-1), "NEGATIVE", ignore.case = TRUE)

    # Errors --------------------------------------------------------------------
    f <- function() stop("My error!")
    expect_error(f())
    expect_error(f(), "My error!")

    # You can use the arguments of grepl to control the matching
    expect_error(f(), "my error!", ignore.case = TRUE)

    # Silent --------------------------------------------------------------------
    expect_silent("123")

    f <- function() {
      message("Hi!")
      warning("Hey!!")
      print("OY!!!")
    }
    ## Not run:
    expect_silent(f())

    ## End(Not run)

[Package testthat version 2.1.1 Index]