Push through more expectations

Author: hadley

R/expect-inheritance.R

@@ -74,9 +74,11 @@ expect_type <- function(object, type) {
       sprintf("Expected %s to have type %s.", act$lab, format_class(type)),
       sprintf("Actual type: %s", format_class(act_type))
     )
-    return(fail(msg))
+    fail(msg)
+  } else {
+    pass()
   }
-  pass(act$val)
+  invisible(act$val)
 }
 
 #' @export

R/expect-invisible.R

@@ -29,9 +29,11 @@ expect_invisible <- function(call, label = NULL) {
       sprintf("Expected %s to return invisibly.", lab),
       "Actual visibility: visible."
     )
-    return(fail(msg))
+    fail(msg)
+  } else {
+    pass()
   }
-  pass(vis$value)
+  invisible(vis$value)
 }
 
 #' @export
@@ -45,7 +47,9 @@ expect_visible <- function(call, label = NULL) {
       sprintf("Expected %s to return visibly.", lab),
       "Actual visibility: invisible."
     )
-    return(fail(msg))
+    fail(msg)
+  } else {
+    pass()
   }
-  pass(vis$value)
+  invisible(vis$value)
 }

R/expect-known.R

@@ -73,15 +73,22 @@ expect_known_output <- function(
   act$lab <- label %||% quo_label(act$quo)
   act <- append(act, eval_with_output(object, print = print, width = width))
 
-  compare_file(file, act$out, update = update, info = info, ...)
+  expect_file_unchanged_(file, act$out, update = update, info = info, ...)
   invisible(act$val)
 }
 
-compare_file <- function(path, lines, ..., update = TRUE, info = NULL) {
+expect_file_unchanged_ <- function(
+  path,
+  lines,
+  ...,
+  update = TRUE,
+  info = NULL
+) {
   if (!file.exists(path)) {
     cli::cli_warn("Creating reference output.")
     brio::write_lines(lines, path)
-    return(pass(NULL))
+    pass()
+    return()
   }
 
   old_lines <- brio::read_lines(path)
@@ -108,9 +115,10 @@ compare_file <- function(path, lines, ..., update = TRUE, info = NULL) {
       encodeString(path, quote = "'"),
       paste0(comp, collapse = "\n\n")
     )
-    return(fail(msg, info = info, trace_env = caller_env()))
+    fail(msg, info = info, trace_env = caller_env())
+  } else {
+    pass()
   }
-  pass(NULL)
 }
 
 #' Do you expect the output/result to equal a known good value?
@@ -151,7 +159,7 @@ expect_output_file <- function(
   act$lab <- label %||% quo_label(act$quo)
   act <- append(act, eval_with_output(object, print = print, width = width))
 
-  compare_file(file, act$out, update = update, info = info, ...)
+  expect_file_unchanged_(file, act$out, update = update, info = info, ...)
   invisible(act$val)
 }
 
@@ -180,6 +188,7 @@ expect_known_value <- function(
   if (!file.exists(file)) {
     cli::cli_warn("Creating reference value.")
     saveRDS(object, file, version = version)
+    pass()
   } else {
     ref_val <- readRDS(file)
     comp <- compare(act$val, ref_val, ...)
@@ -194,11 +203,13 @@ expect_known_value <- function(
         encodeString(file, quote = "'"),
         comp$message
       )
-      return(fail(msg, info = info))
+      fail(msg, info = info)
+    } else {
+      pass()
     }
   }
 
-  pass(act$value)
+  invisible(act$val)
 }
 
 #' @export
@@ -233,18 +244,21 @@ expect_known_hash <- function(object, hash = NULL) {
 
   if (is.null(hash)) {
     cli::cli_warn("No recorded hash: use {substr(act_hash, 1, 10)}.")
+    pass()
   } else {
     if (hash != act_hash) {
       msg <- sprintf(
         "Expected value to hash to %s.\nActual hash: %s",
         hash,
         act_hash
       )
-      return(fail(msg))
+      fail(msg)
+    } else {
+      pass()
     }
   }
 
-  pass(act$value)
+  invisible(act$val)
 }
 
 all_utf8 <- function(x) {

R/expect-named.R

@@ -74,9 +74,11 @@ normalise_names <- function(x, ignore.order = FALSE, ignore.case = FALSE) {
 
 expect_has_names_ <- function(act, trace_env = caller_env()) {
   act_names <- names(act$val)
-  if (identical(act_names, NULL)) {
+  if (is.null(act_names)) {
     msg <- sprintf("Expected %s to have names.", act$lab)
-    return(fail(msg, trace_env = trace_env))
+    fail(msg, trace_env = trace_env)
+  } else {
+    pass()
   }
-  return(pass(act$val))
+  invisible(act$val)
 }

R/expect-no-condition.R

@@ -119,10 +119,12 @@ expect_no_ <- function(
       "."
     )
     msg_act <- actual_condition(first_match)
-    return(fail(c(msg_exp, msg_act), trace_env = trace_env))
+    fail(c(msg_exp, msg_act), trace_env = trace_env)
+  } else {
+    pass()
   }
 
-  pass(act$val)
+  invisible(act$val)
 }
 
 indent_lines <- function(x) {

R/expect-reference.R

@@ -28,9 +28,11 @@ expect_reference <- function(
 
   if (!is_reference(act$val, exp$val)) {
     msg <- sprintf("Expected %s to be a reference to %s.", act$lab, exp$lab)
-    return(fail(msg, info = info))
+    fail(msg, info = info)
+  } else {
+    pass()
   }
-  pass(act$val)
+  invisible(act$val)
 }
 
 # expect_reference() needs dev version of rlang

R/expect-self-test.R

@@ -51,18 +51,18 @@ expect_success <- function(expr) {
       "Expected one success.",
       sprintf("Actually succeeded %i times", status$n_success)
     )
-    return(fail(msg))
-  }
-
-  if (status$n_failure > 0) {
+    fail(msg)
+  } else if (status$n_failure > 0) {
     msg <- c(
       "Expected zero failures.",
       sprintf("Actually failed %i times", status$n_failure)
     )
-    return(fail(msg))
+    fail(msg)
+  } else {
+    pass()
   }
 
-  pass(NULL)
+  invisible()
 }
 
 #' @export
@@ -116,9 +116,11 @@ expect_no_success <- function(expr) {
   status <- capture_success_failure(expr)
 
   if (status$n_success > 0) {
-    return(fail("Expectation succeeded"))
+    fail("Expectation succeeded")
+  } else {
+    pass()
   }
-  pass(NULL)
+  invisible()
 }
 
 #' @export
@@ -128,9 +130,11 @@ expect_no_failure <- function(expr) {
   status <- capture_success_failure(expr)
 
   if (status$n_failure > 0) {
-    return(fail("Expectation failed"))
+    fail("Expectation failed")
+  } else {
+    pass()
   }
-  pass(NULL)
+  invisible()
 }
 
 expect_snapshot_skip <- function(x, cran = FALSE) {

R/expect-setequal.R

@@ -114,9 +114,11 @@ expect_contains <- function(object, expected) {
       sprintf("Missing: %s", values(exp$val[exp_miss]))
     )
     fail(c(msg_exp, msg_act))
+  } else {
+    pass()
   }
 
-  pass(act$val)
+  invisible(act$val)
 }
 
 #' @export
@@ -141,9 +143,11 @@ expect_in <- function(object, expected) {
       sprintf("Invalid: %s", values(act$val[act_miss]))
     )
     fail(c(msg_exp, msg_act))
+  } else {
+    pass()
   }
 
-  pass(act$val)
+  invisible(act$val)
 }
 
 # Helpers ----------------------------------------------------------------------

R/expect-shape.R

@@ -32,9 +32,11 @@ expect_length <- function(object, n) {
       sprintf("Expected %s to have length %i.", act$lab, n),
       sprintf("Actual length: %i.", act$n)
     )
-    return(fail(msg))
+    fail(msg)
+  } else {
+    pass()
   }
-  pass(act$val)
+  invisible(act$val)
 }
 
 #' @param nrow,ncol Expected [nrow()]/[ncol()] of `object`.
@@ -61,14 +63,17 @@ expect_shape = function(object, ..., nrow, ncol, dim) {
         sprintf("Expected %s to have %i rows.", act$lab, nrow),
         sprintf("Actual rows: %i.", act$nrow)
       )
-      return(fail(msg))
+      fail(msg)
+    } else {
+      pass()
     }
   } else if (!missing(ncol)) {
     check_number_whole(ncol, allow_na = TRUE)
 
     if (length(dim_object) == 1L) {
       msg <- sprintf("Expected %s to have two or more dimensions.", act$lab)
-      return(fail(msg))
+      fail(msg)
+      return(invisible(act$val))
     }
 
     act$ncol <- dim_object[2L]
@@ -78,7 +83,9 @@ expect_shape = function(object, ..., nrow, ncol, dim) {
         sprintf("Expected %s to have %i columns.", act$lab, ncol),
         sprintf("Actual columns: %i.", act$ncol)
       )
-      return(fail(msg))
+      fail(msg)
+    } else {
+      pass()
     }
   } else {
     # !missing(dim)
@@ -92,16 +99,17 @@ expect_shape = function(object, ..., nrow, ncol, dim) {
         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))) {
+      fail(msg)
+    } else if (!identical(as.integer(act$dim), as.integer(dim))) {
       msg <- c(
         sprintf("Expected %s to have dim (%s).", act$lab, toString(dim)),
         sprintf("Actual dim: (%s).", toString(act$dim))
       )
-      return(fail(msg))
+      fail(msg)
+    } else {
+      pass()
     }
   }
 
-  pass(act$val)
+  invisible(act$val)
 }

R/expect-silent.R

@@ -31,7 +31,9 @@ expect_silent <- function(object) {
       sprintf("Expected %s to run silently.", act$lab),
       sprintf("Actual noise: %s.", paste(outputs, collapse = ", "))
     )
-    return(fail(msg))
+    fail(msg)
+  } else {
+    pass()
   }
-  pass(act$cap$result)
+  invisible(act$cap$result)
 }