Running ‘testthat.R’ [31s/51s]
Running the tests in ‘tests/testthat.R’ failed.
Complete output:
  > library(testthat)
  > library(set6)
  
  -----------------------------
  	set6 v0.1.7
  
  Get started:	?set6
  Changelog:	set6News()
  -----------------------------
  
  > 
  > test_check("set6")
  # set6 0.1.7
  
  * Critical patch - Added variable `ExponentSet` to solve
  
  # set6 0.1.6
  
  * Bugfix in set operation cleaner
  * Bugfix causing `Interval$contains` to return `TRUE` for tuples
  * Bugfix in union sets incorrectly unwrapping products
  * Added variable length `ExponentSet`s
  
  # set6 0.1.5
  
  * Added `LogicalSet`, the set of $\{TRUE, FALSE\}$
  * Added `as.Set.numeric` and `as.Tuple.numeric`
  
  # set6 0.1.4
  
  * Speed performance improvements for `$contains` method for `Interval` and `Set`. `Rcpp` now used for `Interval`.
  * Now for any `Interval` if not bounded above and `upper` is $Inf$ then `max = .Machine$double.xmax`, analogously for `lower`.
  * Default universe of `Interval` is now `ExtendedReals`
  * Added default `as.Set` and `as.Interval` S3 methods
  
  # set6 0.1.3
  
  * Added assertion for testing if a set is countably finite
  * Slight speed improvements to operations - still require a lot of work
  * Fixed bug in `UnionSet` cardinality calculation
  * Fixed bug in `UniversalSet` countability
  
  # set6 0.1.2
  
  ### Patches
  - Updated documentation to be compatible with roxygen2
  - Fixed bug in typed Complex sets
  - Added universe assertion check to `Set` constructor
  - Bug fix in `setunion` causing some intervals not to be combined correctly
  - `Interval$isSubset` now compares sets using `max` and `min` instead of `upper` and `lower`
  - Calculation of `min` and `max` in `Interval` now uses `1e-15` instead of `.Machine$double.xmin`
  - `$elements` now always returns a `list`
  
  ### Added classes, methods, and functions
  - Add `$add` public method to sets, which mutates sets by adding given elements, and coercing to the typed-set class if appropriate
  - Add `$remove` public method to sets, which mutates sets by removing given elements.
  - Add assertion for checking if elements contained in a set, `test/check/assertContains`.
  - Add assertion for checking if sets are subsets of another, `test/check/assertSubset`.
  
  # set6 0.1.1
  
  ### Patches
  - `absComplement` method is now deprecated, instead use `setcomplement` and omit the `y` argument
  - Fixed error in `contains` default caused by `%inset%`
  - Improved printing of `SpecialSet`s when `zero == TRUE`
  - Added `UniversalSet` for the set containing all elements
  - Changed default `universe` of sets to `UniversalSet`
  - Coercions now error instead of producing a message when they fail
  - On construction, `Set`s no longer guess the set class, instead an extra `class` argument is added to give a set the `typed` property
  - The internal `Set` structure is slightly changed so that set elements are now stored in lists by default, which is only changed if the set is `typed`
  - Added `element` argument to `Set` constructor, which takes a `list`. This is more efficient if passing lists of lists or lists of multiple types, and in line with the `FuzzySet` constructor
  - Improved printing of `ConditionalSet`s
  - Updated `powerset` to always return a `Set` of `Set`s (even if input is `Tuple`)
  - Fixed bug in `Properties` causing an error if cardinality was too large
  - Updated documentation
  - Reduced `Set` constructor bottleneck by adding 'typed' sets
  - Changed `use_unicode` default to `l10n_info()$UTF-8`
  
  # set6 0.1.0
  
  - `set6` upgrades the `sets` package to R6. Many forms of mathematical sets are implemented, including (countably finite) sets, tuples, intervals (countably infinite or uncountable), and fuzzy variants. Wrappers extend functionality by allowing symbolic representations of complex operations on sets, including unions, (cartesian) products, exponentiation, and differences (asymmetric and symmetric).
  - See [the website](https://xoopR.github.io/set6/) for more details and the project readme
  - See [getting started vignette](https://xoopR.github.io/set6/articles/set6.html) for a short tutorial and introduction
  - `set6` is currently 'maturing', so whilst no major updates are planned they may happen. Constant minor updates should be expected.
   ----------- FAILURE REPORT -------------- 
   --- failure: the condition has length > 1 ---
   --- srcref --- 
  : 
   --- package (from environment) --- 
  set6
   --- call from context --- 
  (function () 
  {
      if (self$class %in% c("numeric", "integer", "complex")) {
          return(self$upper - self$lower)
      }
      else {
          return(NaN)
      }
  })()
   --- call from argument --- 
  if (self$class %in% c("numeric", "integer", "complex")) {
      return(self$upper - self$lower)
  } else {
      return(NaN)
  }
   --- R stacktrace ---
  where 1: (function () 
  {
      if (self$class %in% c("numeric", "integer", "complex")) {
          return(self$upper - self$lower)
      }
      else {
          return(NaN)
      }
  })()
  where 2: as.list.environment(target, all.names = all.names, sorted = TRUE)
  where 3: mode(target)
  where 4: attr.all.equal(target, current, ...)
  where 5: all.equal.list(as.list.environment(target, all.names = all.names, 
      sorted = TRUE), as.list.environment(current, all.names = all.names, 
      sorted = TRUE), ...)
  where 6: all.equal.environment(target, current, ...)
  where 7: all.equal.default(x, y, ...)
  where 8: all.equal(x, y, ...)
  where 9: compare.default(act$val, exp$val, ...)
  where 10: compare(act$val, exp$val, ...)
  where 11 at testthat/test_operations_setcomplement.R#77: expect_equal(ConditionalSet$new(function(x) x == 0) - ConditionalSet$new(function(y) y > 
      0), ConditionalSet$new(function(x, y) x == 0 & !(y > 0)))
  where 12: eval(code, test_env)
  where 13: eval(code, test_env)
  where 14: withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error)
  where 15: doTryCatch(return(expr), name, parentenv, handler)
  where 16: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  where 17: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  where 18: doTryCatch(return(expr), name, parentenv, handler)
  where 19: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), 
      names[nh], parentenv, handlers[[nh]])
  where 20: tryCatchList(expr, classes, parentenv, handlers)
  where 21: tryCatch(withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error), error = handle_fatal, 
      skip = function(e) {
      })
  where 22: test_code(desc, code, env = parent.frame())
  where 23 at testthat/test_operations_setcomplement.R#76: test_that("conditional", {
      expect_equal(ConditionalSet$new(function(x) x == 0) - ConditionalSet$new(function(y) y > 
          0), ConditionalSet$new(function(x, y) x == 0 & !(y > 
          0)))
      useUnicode(FALSE)
      expect_equal((ConditionalSet$new(function(x) TRUE) - Set$new(1))$strprint(), 
          "{TRUE : x in V} \\ {1}")
      useUnicode(TRUE)
  })
  where 24: eval(code, test_env)
  where 25: eval(code, test_env)
  where 26: withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error)
  where 27: doTryCatch(return(expr), name, parentenv, handler)
  where 28: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  where 29: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  where 30: doTryCatch(return(expr), name, parentenv, handler)
  where 31: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), 
      names[nh], parentenv, handlers[[nh]])
  where 32: tryCatchList(expr, classes, parentenv, handlers)
  where 33: tryCatch(withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error), error = handle_fatal, 
      skip = function(e) {
      })
  where 34: test_code(NULL, exprs, env)
  where 35: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
  where 36: force(code)
  where 37: doWithOneRestart(return(expr), restart)
  where 38: withOneRestart(expr, restarts[[1L]])
  where 39: withRestarts(testthat_abort_reporter = function() NULL, force(code))
  where 40: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter, 
      {
          reporter$start_file(basename(path))
          lister$start_file(basename(path))
          source_file(path, new.env(parent = env), chdir = TRUE, 
              wrap = wrap)
          reporter$.end_context()
          reporter$end_file()
      })
  where 41: FUN(X[[i]], ...)
  where 42: lapply(paths, test_file, env = env, reporter = current_reporter, 
      start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
  where 43: force(code)
  where 44: doWithOneRestart(return(expr), restart)
  where 45: withOneRestart(expr, restarts[[1L]])
  where 46: withRestarts(testthat_abort_reporter = function() NULL, force(code))
  where 47: with_reporter(reporter = current_reporter, results <- lapply(paths, 
      test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE, 
      load_helpers = FALSE, wrap = wrap))
  where 48: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure, 
      stop_on_warning = stop_on_warning, wrap = wrap)
  where 49: test_dir(path = test_path, reporter = reporter, env = env, filter = filter, 
      ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning, 
      wrap = wrap)
  where 50: test_package_dir(package = package, test_path = test_path, filter = filter, 
      reporter = reporter, ..., stop_on_failure = stop_on_failure, 
      stop_on_warning = stop_on_warning, wrap = wrap)
  where 51: test_check("set6")
  
   --- value of length: 2 type: logical ---
  [1] FALSE FALSE
   --- function from context --- 
  function () 
  {
      if (self$class %in% c("numeric", "integer", "complex")) {
          return(self$upper - self$lower)
      }
      else {
          return(NaN)
      }
  }
  <environment: 0x55e7f2fcbbf8>
   --- function search by body ---
   ----------- END OF FAILURE REPORT -------------- 
  ── 1. Error: conditional (@test_operations_setcomplement.R#77)  ────────────────
  the condition has length > 1
  Backtrace:
  
   ----------- FAILURE REPORT -------------- 
   --- failure: the condition has length > 1 ---
   --- srcref --- 
  : 
   --- package (from environment) --- 
  set6
   --- call from context --- 
  (function () 
  {
      if (self$class %in% c("numeric", "integer", "complex")) {
          return(self$upper - self$lower)
      }
      else {
          return(NaN)
      }
  })()
   --- call from argument --- 
  if (self$class %in% c("numeric", "integer", "complex")) {
      return(self$upper - self$lower)
  } else {
      return(NaN)
  }
   --- R stacktrace ---
  where 1: (function () 
  {
      if (self$class %in% c("numeric", "integer", "complex")) {
          return(self$upper - self$lower)
      }
      else {
          return(NaN)
      }
  })()
  where 2: as.list.environment(target, all.names = all.names, sorted = TRUE)
  where 3: mode(target)
  where 4: attr.all.equal(target, current, ...)
  where 5: all.equal.list(as.list.environment(target, all.names = all.names, 
      sorted = TRUE), as.list.environment(current, all.names = all.names, 
      sorted = TRUE), ...)
  where 6: all.equal.environment(target, current, ...)
  where 7: all.equal.default(x, y, ...)
  where 8: all.equal(x, y, ...)
  where 9: compare.default(act$val, exp$val, ...)
  where 10: compare(act$val, exp$val, ...)
  where 11 at testthat/test_operations_setintersect.R#16: expect_equal(ConditionalSet$new(function(x) x == 1) & ConditionalSet$new(function(y) y > 
      1), ConditionalSet$new(function(x, y) x == 1 & y > 1))
  where 12: eval(code, test_env)
  where 13: eval(code, test_env)
  where 14: withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error)
  where 15: doTryCatch(return(expr), name, parentenv, handler)
  where 16: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  where 17: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  where 18: doTryCatch(return(expr), name, parentenv, handler)
  where 19: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), 
      names[nh], parentenv, handlers[[nh]])
  where 20: tryCatchList(expr, classes, parentenv, handlers)
  where 21: tryCatch(withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error), error = handle_fatal, 
      skip = function(e) {
      })
  where 22: test_code(desc, code, env = parent.frame())
  where 23 at testthat/test_operations_setintersect.R#15: test_that("conditionalset", {
      expect_equal(ConditionalSet$new(function(x) x == 1) & ConditionalSet$new(function(y) y > 
          1), ConditionalSet$new(function(x, y) x == 1 & y > 1))
      expect_equal(ConditionalSet$new(function(x) x == 1) & ConditionalSet$new(function(y) y == 
          1), ConditionalSet$new(function(x) x == 1))
      expect_true((ConditionalSet$new(function(x) x == 0) & Set$new(elements = -2:2))$equals(Set$new(0)))
  })
  where 24: eval(code, test_env)
  where 25: eval(code, test_env)
  where 26: withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error)
  where 27: doTryCatch(return(expr), name, parentenv, handler)
  where 28: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  where 29: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  where 30: doTryCatch(return(expr), name, parentenv, handler)
  where 31: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), 
      names[nh], parentenv, handlers[[nh]])
  where 32: tryCatchList(expr, classes, parentenv, handlers)
  where 33: tryCatch(withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error), error = handle_fatal, 
      skip = function(e) {
      })
  where 34: test_code(NULL, exprs, env)
  where 35: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
  where 36: force(code)
  where 37: doWithOneRestart(return(expr), restart)
  where 38: withOneRestart(expr, restarts[[1L]])
  where 39: withRestarts(testthat_abort_reporter = function() NULL, force(code))
  where 40: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter, 
      {
          reporter$start_file(basename(path))
          lister$start_file(basename(path))
          source_file(path, new.env(parent = env), chdir = TRUE, 
              wrap = wrap)
          reporter$.end_context()
          reporter$end_file()
      })
  where 41: FUN(X[[i]], ...)
  where 42: lapply(paths, test_file, env = env, reporter = current_reporter, 
      start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
  where 43: force(code)
  where 44: doWithOneRestart(return(expr), restart)
  where 45: withOneRestart(expr, restarts[[1L]])
  where 46: withRestarts(testthat_abort_reporter = function() NULL, force(code))
  where 47: with_reporter(reporter = current_reporter, results <- lapply(paths, 
      test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE, 
      load_helpers = FALSE, wrap = wrap))
  where 48: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure, 
      stop_on_warning = stop_on_warning, wrap = wrap)
  where 49: test_dir(path = test_path, reporter = reporter, env = env, filter = filter, 
      ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning, 
      wrap = wrap)
  where 50: test_package_dir(package = package, test_path = test_path, filter = filter, 
      reporter = reporter, ..., stop_on_failure = stop_on_failure, 
      stop_on_warning = stop_on_warning, wrap = wrap)
  where 51: test_check("set6")
  
   --- value of length: 2 type: logical ---
  [1] FALSE FALSE
   --- function from context --- 
  function () 
  {
      if (self$class %in% c("numeric", "integer", "complex")) {
          return(self$upper - self$lower)
      }
      else {
          return(NaN)
      }
  }
  <environment: 0x55e8048abe70>
   --- function search by body ---
   ----------- END OF FAILURE REPORT -------------- 
  ── 2. Error: conditionalset (@test_operations_setintersect.R#16)  ──────────────
  the condition has length > 1
  Backtrace:
  
   ----------- FAILURE REPORT -------------- 
   --- failure: the condition has length > 1 ---
   --- srcref --- 
  : 
   --- package (from environment) --- 
  set6
   --- call from context --- 
  (function () 
  {
      if (self$class %in% c("numeric", "integer", "complex")) {
          return(self$upper - self$lower)
      }
      else {
          return(NaN)
      }
  })()
   --- call from argument --- 
  if (self$class %in% c("numeric", "integer", "complex")) {
      return(self$upper - self$lower)
  } else {
      return(NaN)
  }
   --- R stacktrace ---
  where 1: (function () 
  {
      if (self$class %in% c("numeric", "integer", "complex")) {
          return(self$upper - self$lower)
      }
      else {
          return(NaN)
      }
  })()
  where 2: as.list.environment(target, all.names = all.names, sorted = TRUE)
  where 3: mode(target)
  where 4: attr.all.equal(target, current, ...)
  where 5: all.equal.list(as.list.environment(target, all.names = all.names, 
      sorted = TRUE), as.list.environment(current, all.names = all.names, 
      sorted = TRUE), ...)
  where 6: all.equal.environment(target, current, ...)
  where 7: all.equal.default(x, y, ...)
  where 8: all.equal(x, y, ...)
  where 9: compare.default(act$val, exp$val, ...)
  where 10: compare(act$val, exp$val, ...)
  where 11 at testthat/test_operations_setunion.R#54: expect_equal(ConditionalSet$new(function(x) x == 0) + ConditionalSet$new(function(y) y > 
      0), ConditionalSet$new(function(x, y) x == 0 | y > 0))
  where 12: eval(code, test_env)
  where 13: eval(code, test_env)
  where 14: withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error)
  where 15: doTryCatch(return(expr), name, parentenv, handler)
  where 16: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  where 17: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  where 18: doTryCatch(return(expr), name, parentenv, handler)
  where 19: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), 
      names[nh], parentenv, handlers[[nh]])
  where 20: tryCatchList(expr, classes, parentenv, handlers)
  where 21: tryCatch(withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error), error = handle_fatal, 
      skip = function(e) {
      })
  where 22: test_code(desc, code, env = parent.frame())
  where 23 at testthat/test_operations_setunion.R#53: test_that("conditional", {
      expect_equal(ConditionalSet$new(function(x) x == 0) + ConditionalSet$new(function(y) y > 
          0), ConditionalSet$new(function(x, y) x == 0 | y > 0))
      expect_equal(setunion(ConditionalSet$new(function(x) x == 
          0), ConditionalSet$new(function(y) y > 0), ConditionalSet$new(function(z) z == 
          2)), ConditionalSet$new(function(x, y, z) x == 0 | y > 
          0 | z == 2))
      expect_equal(ConditionalSet$new(function(x) x == 0) + ConditionalSet$new(function(y) y > 
          0) + ConditionalSet$new(function(z) z == 2), ConditionalSet$new(function(x, 
          y, z) x == 0 | y > 0 | z == 2))
  })
  where 24: eval(code, test_env)
  where 25: eval(code, test_env)
  where 26: withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error)
  where 27: doTryCatch(return(expr), name, parentenv, handler)
  where 28: tryCatchOne(expr, names, parentenv, handlers[[1L]])
  where 29: tryCatchList(expr, names[-nh], parentenv, handlers[-nh])
  where 30: doTryCatch(return(expr), name, parentenv, handler)
  where 31: tryCatchOne(tryCatchList(expr, names[-nh], parentenv, handlers[-nh]), 
      names[nh], parentenv, handlers[[nh]])
  where 32: tryCatchList(expr, classes, parentenv, handlers)
  where 33: tryCatch(withCallingHandlers({
      eval(code, test_env)
      if (!handled && !is.null(test)) {
          skip_empty()
      }
  }, expectation = handle_expectation, skip = handle_skip, warning = handle_warning, 
      message = handle_message, error = handle_error), error = handle_fatal, 
      skip = function(e) {
      })
  where 34: test_code(NULL, exprs, env)
  where 35: source_file(path, new.env(parent = env), chdir = TRUE, wrap = wrap)
  where 36: force(code)
  where 37: doWithOneRestart(return(expr), restart)
  where 38: withOneRestart(expr, restarts[[1L]])
  where 39: withRestarts(testthat_abort_reporter = function() NULL, force(code))
  where 40: with_reporter(reporter = reporter, start_end_reporter = start_end_reporter, 
      {
          reporter$start_file(basename(path))
          lister$start_file(basename(path))
          source_file(path, new.env(parent = env), chdir = TRUE, 
              wrap = wrap)
          reporter$.end_context()
          reporter$end_file()
      })
  where 41: FUN(X[[i]], ...)
  where 42: lapply(paths, test_file, env = env, reporter = current_reporter, 
      start_end_reporter = FALSE, load_helpers = FALSE, wrap = wrap)
  where 43: force(code)
  where 44: doWithOneRestart(return(expr), restart)
  where 45: withOneRestart(expr, restarts[[1L]])
  where 46: withRestarts(testthat_abort_reporter = function() NULL, force(code))
  where 47: with_reporter(reporter = current_reporter, results <- lapply(paths, 
      test_file, env = env, reporter = current_reporter, start_end_reporter = FALSE, 
      load_helpers = FALSE, wrap = wrap))
  where 48: test_files(paths, reporter = reporter, env = env, stop_on_failure = stop_on_failure, 
      stop_on_warning = stop_on_warning, wrap = wrap)
  where 49: test_dir(path = test_path, reporter = reporter, env = env, filter = filter, 
      ..., stop_on_failure = stop_on_failure, stop_on_warning = stop_on_warning, 
      wrap = wrap)
  where 50: test_package_dir(package = package, test_path = test_path, filter = filter, 
      reporter = reporter, ..., stop_on_failure = stop_on_failure, 
      stop_on_warning = stop_on_warning, wrap = wrap)
  where 51: test_check("set6")
  
   --- value of length: 2 type: logical ---
  [1] FALSE FALSE
   --- function from context --- 
  function () 
  {
      if (self$class %in% c("numeric", "integer", "complex")) {
          return(self$upper - self$lower)
      }
      else {
          return(NaN)
      }
  }
  <environment: 0x55e802af1840>
   --- function search by body ---
   ----------- END OF FAILURE REPORT -------------- 
  ── 3. Error: conditional (@test_operations_setunion.R#54)  ─────────────────────
  the condition has length > 1
  Backtrace:
  
  ══ testthat results  ═══════════════════════════════════════════════════════════
  [ OK: 771 | SKIPPED: 0 | WARNINGS: 0 | FAILED: 3 ]
  1. Error: conditional (@test_operations_setcomplement.R#77) 
  2. Error: conditionalset (@test_operations_setintersect.R#16) 
  3. Error: conditional (@test_operations_setunion.R#54) 
  
  Error: testthat unit tests failed
  Execution halted