More polishing

Author: hadley

R/expect-comparison.R

@@ -39,34 +39,30 @@ expect_compare_ <- function(
   }
   if (!isTRUE(cmp)) {
     diff <- act$val - exp$val
-    msg1 <- sprintf("Expected %s %s %s.", act$lab, operator, exp$lab)
+    msg_exp <- sprintf("Expected %s %s %s.", act$lab, operator, exp$lab)
 
     if (is.nan(diff)) {
-      msg2 <- "Actual values are incomparable."
-      msg3 <- NULL
+      msg_act <- "Actual values are incomparable."
     } else if (is.na(diff)) {
-      msg2 <- "Actual comparison is NA."
-      msg3 <- NULL
+      msg_act <- "Actual comparison is NA."
     } else {
       digits <- max(
         digits(act$val),
         digits(exp$val),
         min_digits(act$val, exp$val)
       )
 
-      msg2 <- sprintf(
-        "Actual %s %s %s",
-        num_exact(act$val, digits),
-        actual_op,
-        num_exact(exp$val, digits)
-      )
-      msg3 <- sprintf(
-        "Difference %s %s 0",
-        num_exact(act$val - exp$val, digits),
-        actual_op
+      msg_act <- c(
+        sprintf(
+          "Actual %s %s %s",
+          num_exact(act$val, digits),
+          actual_op,
+          num_exact(exp$val, digits)
+        ),
+        sprintf("Difference %s %s 0", num_exact(diff, digits), actual_op)
       )
     }
-    return(fail(c(msg1, msg2, msg3), trace_env = trace_env))
+    return(fail(c(msg_exp, msg_act), trace_env = trace_env))
   }
   pass(act$val)
 }

R/expect-condition.R

@@ -454,12 +454,9 @@ compare_condition_3e <- function(cond_type, cond_class, cond, lab, expected) {
     }
   } else {
     if (!is.null(cond)) {
-      sprintf(
-        "Expected %s to not throw a %s.\nActual <%s>:\n%s",
-        lab,
-        cond_type,
-        paste(class(cond), collapse = "/"),
-        cnd_message(cond)
+      c(
+        sprintf("Expected %s to not throw a %s.", lab, cond_type),
+        actual_condition(cond)
       )
     } else {
       NULL
@@ -630,3 +627,11 @@ check_condition_dots <- function(
     call = error_call
   )
 }
+
+actual_condition <- function(cond) {
+  sprintf(
+    "Actual <%s>:\n%s",
+    paste(class(cond), collapse = "/"),
+    cnd_message(cond)
+  )
+}

R/expect-no-condition.R

@@ -108,24 +108,23 @@ expect_no_ <- function(
   act <- quasi_capture(enquo(object), NULL, capture)
 
   if (!is.null(first_match)) {
-    expected <- paste0(
+    exp_msg <- paste0(
       "Expected ",
-      quo_label(enquo(object)),
+      act$lab,
       " to run without any ",
       base_class,
       "s",
       if (!is.null(class)) paste0(" of class '", class, "'"),
       if (!is.null(regexp)) paste0(" matching pattern '", regexp, "'"),
       "."
     )
-    actual <- paste0(
+    act_msg <- paste0(
       "Actually got a <",
       class(first_match)[[1]],
-      "> with text:\n",
+      "> with message:\n",
       indent_lines(rlang::cnd_message(first_match))
     )
-    message <- format_error_bullets(c(expected, i = actual))
-    return(fail(message, trace_env = trace_env))
+    return(fail(c(exp_msg, act_msg), trace_env = trace_env))
   }
 
   pass(act$val)

R/expect-output.R

@@ -52,6 +52,6 @@ expect_output <- function(
     pass(act$val)
   } else {
     act <- labelled_value(act$cap, act$lab)
-    expect_match_(act, enc2native(regexp), ..., title = "Output")
+    expect_match_(act, enc2native(regexp), ..., title = "output")
   }
 }

R/expect-setequal.R

@@ -46,19 +46,17 @@ expect_setequal_ <- function(
   exp_miss <- unique(exp$val[!exp$val %in% act$val])
 
   if (length(exp_miss) || length(act_miss)) {
-    msg <- paste0(
+    msg_exp <- sprintf(
+      "Expected %s to have the same values as %s.",
       act$lab,
-      " doesn't have the same values as ",
-      exp$lab,
-      ".\n",
-      if (length(act_miss)) {
-        paste0("* Only in `actual`: ", values(act_miss), "\n")
-      },
-      if (length(exp_miss)) {
-        paste0("* Only in `expected`: ", values(exp_miss), "\n")
-      }
+      exp$lab
     )
-    return(fail(msg, trace_env = trace_env))
+    msg_act <- c(
+      if (length(act_miss)) sprintf("Needs: %s", values(act_miss)),
+      if (length(exp_miss)) sprintf("Extra: %s", values(exp_miss))
+    )
+
+    return(fail(c(msg_exp, msg_act), trace_env = trace_env))
   }
   pass(act$val)
 }
@@ -101,14 +99,13 @@ expect_contains <- function(object, expected) {
 
   exp_miss <- !exp$val %in% act$val
   if (any(exp_miss)) {
-    return(fail(paste0(
+    msg_exp <- sprintf(
+      "Expected %s to contain all values in %s.",
       act$lab,
-      " doesn't fully contain all the values in ",
-      exp$lab,
-      ".\n",
-      paste0("* Missing from ", act$lab, ": ", values(exp$val[exp_miss]), "\n"),
-      paste0("* Present in ", act$lab, ":   ", values(act$val), "\n")
-    )))
+      exp$lab
+    )
+    msg_act <- sprintf("Missing: %s", values(exp$val[exp_miss]))
+    fail(c(msg_exp, msg_act))
   }
 
   pass(act$val)
@@ -125,14 +122,13 @@ expect_in <- function(object, expected) {
 
   act_miss <- !act$val %in% exp$val
   if (any(act_miss)) {
-    return(fail(paste0(
+    msg_exp <- sprintf(
+      "Expected all values in %s to be in %s.",
       act$lab,
-      " isn't fully contained within ",
-      exp$lab,
-      ".\n",
-      paste0("* Missing from ", act$lab, ": ", values(act$val[act_miss]), "\n"),
-      paste0("* Present in ", act$lab, ":   ", values(exp$val), "\n")
-    )))
+      exp$lab
+    )
+    msg_act <- sprintf("Extra: %s", values(act$val[act_miss]))
+    fail(c(msg_exp, msg_act))
   }
 
   pass(act$val)

R/expect-shape.R

@@ -28,11 +28,9 @@ expect_length <- function(object, n) {
   act$n <- length(act$val)
 
   if (act$n != n) {
-    msg <- sprintf(
-      "Expected %s to have length %i.\nActual length: %i",
-      act$lab,
-      n,
-      act$n
+    msg <- c(
+      sprintf("Expected %s to have length %i.", act$lab, n),
+      sprintf("Actual length: %i.", act$n)
     )
     return(fail(msg))
   }
@@ -59,32 +57,26 @@ expect_shape = function(object, ..., nrow, ncol, dim) {
     act$nrow <- dim_object[1L]
 
     if (!identical(as.integer(act$nrow), as.integer(nrow))) {
-      msg <- sprintf(
-        "Expected %s to have %i rows.\nActual rows: %i",
-        act$lab,
-        nrow,
-        act$nrow
+      msg <- c(
+        sprintf("Expected %s to have %i rows.", act$lab, nrow),
+        sprintf("Actual rows: %i.", act$nrow)
       )
       return(fail(msg))
     }
   } else if (!missing(ncol)) {
     check_number_whole(ncol, allow_na = TRUE)
 
     if (length(dim_object) == 1L) {
-      return(fail(sprintf(
-        "Expected %s to have more than one dimension.",
-        act$lab
-      )))
+      msg <- sprintf("Expected %s to have more than one dimension.", act$lab)
+      return(fail(msg))
     }
 
     act$ncol <- dim_object[2L]
 
     if (!identical(as.integer(act$ncol), as.integer(ncol))) {
-      msg <- sprintf(
-        "Expected %s to have %i columns.\nActual columns: %i",
-        act$lab,
-        ncol,
-        act$ncol
+      msg <- c(
+        sprintf("Expected %s to have %i columns.", act$lab, ncol),
+        sprintf("Actual columns: %i.", act$ncol)
       )
       return(fail(msg))
     }
@@ -96,20 +88,16 @@ expect_shape = function(object, ..., nrow, ncol, dim) {
     act$dim <- dim_object
 
     if (length(act$dim) != length(dim)) {
-      return(fail(sprintf(
-        "Expected %s to have %i dimensions.\nActual dimensions: %i",
-        act$lab,
-        length(dim),
-        length(act$dim)
-      )))
+      msg <- c(
+        sprintf("Expected %s to have %i dimensions.", act$lab, length(dim)),
+        sprintf("Actual dimensions: %i.", length(act$dim))
+      )
     }
 
     if (!identical(as.integer(act$dim), as.integer(dim))) {
-      msg <- sprintf(
-        "Expected %s to have dim (%s).\nActual dim: (%s)",
-        act$lab,
-        toString(dim),
-        toString(act$dim)
+      msg <- c(
+        sprintf("Expected %s to have dim (%s).", act$lab, toString(dim)),
+        sprintf("Actual dim: (%s).", toString(act$dim))
       )
       return(fail(msg))
     }

R/expect-silent.R

@@ -27,10 +27,9 @@ expect_silent <- function(object) {
   )
 
   if (length(outputs) != 0) {
-    msg <- sprintf(
-      "Expected %s to run silently.\nActually produced: %s",
-      act$lab,
-      paste(outputs, collapse = ", ")
+    msg <- c(
+      sprintf("Expected %s to run silently.", act$lab),
+      sprintf("Actually produced: %s.", paste(outputs, collapse = ", "))
     )
     return(fail(msg))
   }

tests/testthat/_snaps/expect-no-condition.md

@@ -1,50 +1,50 @@
 # expect_no_* conditions behave as expected
 
     Expected `stop("error")` to run without any errors.
-    i Actually got a <simpleError> with text:
+    Actually got a <simpleError> with text:
       error
 
 ---
 
     Expected `warning("warning")` to run without any warnings.
-    i Actually got a <simpleWarning> with text:
+    Actually got a <simpleWarning> with text:
       warning
 
 ---
 
     Expected `message("message")` to run without any messages.
-    i Actually got a <simpleMessage> with text:
+    Actually got a <simpleMessage> with text:
       message
       
 
 ---
 
     Expected `abort("error")` to run without any errors.
-    i Actually got a <rlang_error> with text:
+    Actually got a <rlang_error> with text:
       error
 
 ---
 
     Expected `warn("warning")` to run without any warnings.
-    i Actually got a <rlang_warning> with text:
+    Actually got a <rlang_warning> with text:
       warning
 
 ---
 
     Expected `inform("message")` to run without any messages.
-    i Actually got a <rlang_message> with text:
+    Actually got a <rlang_message> with text:
       message
 
 # expect_no_ continues execution
 
     Expected `{ ... }` to run without any warnings.
-    i Actually got a <simpleWarning> with text:
+    Actually got a <simpleWarning> with text:
       x
 
 # expect_no_* don't emit success when they fail
 
     Expected `stop("!")` to run without any errors.
-    i Actually got a <simpleError> with text:
+    Actually got a <simpleError> with text:
       !
 
 # matched conditions give informative message
@@ -54,27 +54,27 @@
     Condition
       Error:
       ! Expected `foo()` to run without any warnings.
-      i Actually got a <test> with text:
+      Actually got a <test> with text:
         This is a problem!
     Code
       expect_no_warning(foo(), message = "problem")
     Condition
       Error:
       ! Expected `foo()` to run without any warnings matching pattern 'problem'.
-      i Actually got a <test> with text:
+      Actually got a <test> with text:
         This is a problem!
     Code
       expect_no_warning(foo(), class = "test")
     Condition
       Error:
       ! Expected `foo()` to run without any warnings of class 'test'.
-      i Actually got a <test> with text:
+      Actually got a <test> with text:
         This is a problem!
     Code
       expect_no_warning(foo(), message = "problem", class = "test")
     Condition
       Error:
       ! Expected `foo()` to run without any warnings of class 'test' matching pattern 'problem'.
-      i Actually got a <test> with text:
+      Actually got a <test> with text:
         This is a problem!