Always return act$val

Author: hadley

R/expect-equality.R

@@ -68,28 +68,26 @@ expect_equal <- function(
   check_number_decimal(tolerance, min = 0, allow_null = TRUE)
 
   if (edition_get() >= 3) {
-    if (
-      !expect_waldo_equal_("equal", act, exp, info, ..., tolerance = tolerance)
-    ) {
-      return()
-    }
+    expect_waldo_equal_("equal", act, exp, info, ..., tolerance = tolerance)
   } else {
     if (!is.null(tolerance)) {
       comp <- compare(act$val, exp$val, ..., tolerance = tolerance)
     } else {
       comp <- compare(act$val, exp$val, ...)
     }
 
-    if (!comp$equal) {
+    if (comp$equal) {
+      pass()
+    } else {
       msg <- c(
         sprintf("Expected %s to equal %s.", act$lab, exp$lab),
         "Differences:",
         comp$message
       )
-      return(fail(msg, info = info))
+      fail(msg, info = info)
     }
   }
-  pass(act$val)
+  invisible(act$val)
 }
 
 
@@ -107,12 +105,12 @@ expect_identical <- function(
   exp <- quasi_label(enquo(expected), expected.label)
 
   if (edition_get() >= 3) {
-    if (!expect_waldo_equal_("identical", act, exp, info, ...)) {
-      return()
-    }
+    expect_waldo_equal_("identical", act, exp, info, ...)
   } else {
     ident <- identical(act$val, exp$val, ...)
-    if (!ident) {
+    if (ident) {
+      pass()
+    } else {
       compare <- compare(act$val, exp$val)
       if (compare$equal) {
         msg_act <- "Objects equal but not identical"
@@ -129,7 +127,7 @@ expect_identical <- function(
     }
   }
 
-  pass(act$val)
+  invisible(act$val)
 }
 
 expect_waldo_equal_ <- function(
@@ -148,15 +146,17 @@ expect_waldo_equal_ <- function(
     y_arg = "expected"
   )
   if (length(comp) == 0) {
-    return(TRUE)
+    pass()
+  } else {
+    msg <- c(
+      sprintf("Expected %s to be %s to %s.", act$lab, type, exp$lab),
+      "Differences:",
+      paste0(comp, collpase = "\n")
+    )
+    fail(msg, info = info, trace_env = trace_env)
   }
 
-  msg <- c(
-    sprintf("Expected %s to be %s to %s.", act$lab, type, exp$lab),
-    "Differences:",
-    paste0(comp, collpase = "\n")
-  )
-  fail(msg, info = info, trace_env = trace_env)
+  invisible(act$val)
 }
 
 #' Is an object equal to the expected value, ignoring attributes?

R/expect-match.R

@@ -50,23 +50,17 @@ expect_match <- function(
     return(fail(msg, info = info))
   }
 
-  if (
-    !expect_match_(
-      act = act,
-      regexp = regexp,
-      perl = perl,
-      fixed = fixed,
-      ...,
-      all = all,
-      info = info,
-      label = label,
-      negate = FALSE
-    )
-  ) {
-    return()
-  }
-
-  pass(act$val)
+  expect_match_(
+    act = act,
+    regexp = regexp,
+    perl = perl,
+    fixed = fixed,
+    ...,
+    all = all,
+    info = info,
+    label = label,
+    negate = FALSE
+  )
 }
 
 #' @describeIn expect_match Check that a string doesn't match a regular
@@ -90,22 +84,17 @@ expect_no_match <- function(
   check_bool(fixed)
   check_bool(all)
 
-  if (
-    !expect_match_(
-      act = act,
-      regexp = regexp,
-      perl = perl,
-      fixed = fixed,
-      ...,
-      all = all,
-      info = info,
-      label = label,
-      negate = TRUE
-    )
-  ) {
-    return()
-  }
-  pass(act$val)
+  expect_match_(
+    act = act,
+    regexp = regexp,
+    perl = perl,
+    fixed = fixed,
+    ...,
+    all = all,
+    info = info,
+    label = label,
+    negate = TRUE
+  )
 }
 
 expect_match_ <- function(
@@ -126,27 +115,29 @@ expect_match_ <- function(
   ok <- if (all) all(condition) else any(condition)
 
   if (ok) {
-    return(TRUE)
-  }
-
-  values <- show_text(act$val, condition)
-  if (length(act$val) == 1) {
-    which <- ""
+    pass()
   } else {
-    which <- if (all) "every element of " else "some element of "
+    values <- show_text(act$val, condition)
+    if (length(act$val) == 1) {
+      which <- ""
+    } else {
+      which <- if (all) "every element of " else "some element of "
+    }
+    match <- if (negate) "not to match" else "to match"
+
+    msg_exp <- sprintf(
+      "Expected %s%s %s %s %s.",
+      which,
+      act$lab,
+      match,
+      if (fixed) "string" else "regexp",
+      encodeString(regexp, quote = '"')
+    )
+    msg_act <- c(paste0("Actual ", title, ':'), values)
+    fail(c(msg_exp, msg_act), info = info, trace_env = trace_env)
   }
-  match <- if (negate) "not to match" else "to match"
-
-  msg_exp <- sprintf(
-    "Expected %s%s %s %s %s.",
-    which,
-    act$lab,
-    match,
-    if (fixed) "string" else "regexp",
-    encodeString(regexp, quote = '"')
-  )
-  msg_act <- c(paste0("Actual ", title, ':'), values)
-  fail(c(msg_exp, msg_act), info = info, trace_env = trace_env)
+
+  invisible(act$val)
 }
 
 

R/expect-named.R

@@ -48,17 +48,13 @@ expect_named <- function(
 
   if (ignore.order) {
     act_names <- labelled_value(act_names, paste0("names(", act$lab, ")"))
-    if (!expect_setequal_(act_names, exp)) {
-      return()
-    }
+    expect_setequal_(act_names, exp)
   } else {
     act_name <- labelled_value(act_names, paste0("names(", act$lab, ")"))
-    if (!expect_waldo_equal_("equal", act_name, exp)) {
-      return()
-    }
+    expect_waldo_equal_("equal", act_name, exp)
   }
 
-  pass(act$val)
+  invisible(act$val)
 }
 
 normalise_names <- function(x, ignore.order = FALSE, ignore.case = FALSE) {

R/expect-output.R

@@ -40,18 +40,21 @@ expect_output <- function(
         sprintf("Expected %s to produce no output.", act$lab),
         sprintf("Actual output:\n%s", encodeString(act$cap))
       )
-      return(fail(msg, info = info))
+      fail(msg, info = info)
+    } else {
+      pass()
     }
   } else if (is.null(regexp) || identical(act$cap, "")) {
     if (identical(act$cap, "")) {
       msg <- sprintf("Expected %s to produce output.", act$lab)
-      return(fail(msg, info = info))
+      fail(msg, info = info)
+    } else {
+      pass()
     }
   } else {
     act_out <- labelled_value(act$cap, paste0("output from ", act$lab))
-    if (!expect_match_(act_out, enc2native(regexp), ..., title = "output")) {
-      return()
-    }
+    expect_match_(act_out, enc2native(regexp), ..., title = "output")
   }
-  pass(act$val)
+
+  invisible(act$val)
 }

R/expect-self-test.R

@@ -75,24 +75,22 @@ expect_failure <- function(expr, message = NULL, ...) {
       "Expected one failure.",
       sprintf("Actually failed %i times", status$n_failure)
     )
-    return(fail(msg))
-  }
-
-  if (status$n_success != 0) {
+    fail(msg)
+  } else if (status$n_success != 0) {
     msg <- c(
       "Expected zero successes.",
       sprintf("Actually succeeded %i times", status$n_success)
     )
-    return(fail(msg))
-  }
-
-  if (!is.null(message)) {
-    act <- labelled_value(status$last_failure$message, "failure message")
-    if (!expect_match_(act, message, ..., title = "message")) {
-      return()
+    fail(msg)
+  } else {
+    if (is.null(message)) {
+      pass()
+    } else {
+      act <- labelled_value(status$last_failure$message, "failure message")
+      expect_match_(act, message, ..., title = "message")
     }
   }
-  pass(NULL)
+  invisible()
 }
 
 #' @export

R/expect-setequal.R

@@ -34,11 +34,7 @@ expect_setequal <- function(object, expected) {
     testthat_warn("expect_setequal() ignores names")
   }
 
-  if (!expect_setequal_(act, exp)) {
-    return()
-  }
-
-  pass(act$val)
+  expect_setequal_(act, exp)
 }
 
 expect_setequal_ <- function(
@@ -50,22 +46,23 @@ expect_setequal_ <- function(
   exp_miss <- unique(exp$val[!exp$val %in% act$val])
 
   if (length(exp_miss) == 0 && length(act_miss) == 0) {
-    return(TRUE)
+    pass()
+  } else {
+    msg_exp <- sprintf(
+      "Expected %s to have the same values as %s.",
+      act$lab,
+      exp$lab
+    )
+    msg_act <- c(
+      sprintf("Actual: %s", values(act$val)),
+      sprintf("Expected: %s", values(exp$val)),
+      if (length(act_miss)) sprintf("Needs: %s", values(act_miss)),
+      if (length(exp_miss)) sprintf("Absent: %s", values(exp_miss))
+    )
+    fail(c(msg_exp, msg_act), trace_env = trace_env)
   }
 
-  msg_exp <- sprintf(
-    "Expected %s to have the same values as %s.",
-    act$lab,
-    exp$lab
-  )
-  msg_act <- c(
-    sprintf("Actual: %s", values(act$val)),
-    sprintf("Expected: %s", values(exp$val)),
-    if (length(act_miss)) sprintf("Needs: %s", values(act_miss)),
-    if (length(exp_miss)) sprintf("Absent: %s", values(exp_miss))
-  )
-
-  fail(c(msg_exp, msg_act), trace_env = trace_env)
+  invisible(act$value)
 }
 
 values <- function(x) {
@@ -92,11 +89,7 @@ expect_mapequal <- function(object, expected) {
   act <- quasi_label(enquo(object))
   exp <- quasi_label(enquo(expected))
 
-  if (!expect_waldo_equal_("equal", act, exp, list_as_map = TRUE)) {
-    return()
-  }
-
-  pass(act$val)
+  expect_waldo_equal_("equal", act, exp, list_as_map = TRUE)
 }
 
 #' @export

R/expect-that.R

@@ -67,7 +67,7 @@ capture_trace <- function(trace_env) {
 #' @param value Value to return, typically the result of evaluating the
 #'   `object` argument to the expectation.
 #' @export
-pass <- function(value) {
+pass <- function(value = NULL) {
   expectation("success", "success")
   invisible(value)
 }