Running ‘testthat.R’ [1s/1s]
Running the tests in ‘tests/testthat.R’ failed.
Complete output:
  > library(testthat)
  > library(errorlocate)
  Loading required package: validate
  
  Attaching package: 'validate'
  
  The following object is masked from 'package:testthat':
  
      compare
  
  > 
  > test_check("errorlocate")
  1. Failure: categorical: can detect categorical rules (@test-categorical.R#11) -
  is_categorical(v) not equal to c(TRUE, TRUE, FALSE, FALSE).
  Modes: list, logical
  Length mismatch: comparison on first 0 components
  
  
  2. Error: categorical: can derive coefficients (@test-categorical.R#17) --------
  invalid subscript type 'list'
  1: cat_coefficients(v) at testthat/test-categorical.R:17
  2: cat_as_mip_rules(x, ...)
  3: x[is_categorical(x)]
  4: x[is_categorical(x)]
  
  3. Error: categorical: can handle logical rules (@test-categorical.R#34) -------
  invalid subscript type 'list'
  1: cat_coefficients(v) at testthat/test-categorical.R:34
  2: cat_as_mip_rules(x, ...)
  3: x[is_categorical(x)]
  4: x[is_categorical(x)]
  
  4. Failure: is_condition_: can detect a complex rule (@test-conditional.R#6) ---
  is_condition_(e) isn't true.
  
  
  5. Failure: is_condition_: can use negated expression (@test-conditional.R#10) -
  is_condition_(e) isn't true.
  
  
  6. Failure: is_condition_: can use nested expression (@test-conditional.R#14) --
  is_condition_(e) isn't true.
  
  
  7. Failure: is_condition_: can use negated nested expression (@test-conditional.R#18) 
  is_condition_(e) isn't true.
  
  
  8. Failure: conditional: can detect conditional rules (@test-conditional.R#30) -
  is_conditional(v) not equal to c(TRUE, TRUE, FALSE, FALSE, FALSE).
  Modes: list, logical
  Length mismatch: comparison on first 0 components
  
  
  9. Failure: conditional: can detect more complex rules (@test-conditional.R#39) 
  is_conditional(v) not equal to c(TRUE, TRUE, TRUE, TRUE).
  Modes: list, logical
  Length mismatch: comparison on first 0 components
  
  
  10. Failure: replace_linear: can replace linear expressions (@test-conditional.R#48) 
  deparse(rl$cat) not equal to "if (.v1) A == TRUE".
  1/1 mismatches
  x[1]: "if (x > 1) A == TRUE"
  y[1]: "if (.v1) A == TRUE"
  
  
  11. Failure: replace_linear: can replace linear expressions (@test-conditional.R#49) 
  deparse(rl$linear$.v1) not equal to "x <= 1".
  1/1 mismatches
  x[1]: "NULL"
  y[1]: "x <= 1"
  
  
  12. Failure: replace_linear: can replace linear expressions (@test-conditional.R#54) 
  deparse(rl$cat) not equal to "if (.v1) !(.v2)".
  1/1 mismatches
  x[1]: "if (x > 1) !(y > 1)"
  y[1]: "if (.v1) !(.v2)"
  
  
  13. Failure: replace_linear: can replace linear expressions (@test-conditional.R#55) 
  deparse(rl$linear$.v1) not equal to "x <= 1".
  1/1 mismatches
  x[1]: "NULL"
  y[1]: "x <= 1"
  
  
  14. Failure: replace_linear: can replace linear expressions (@test-conditional.R#56) 
  deparse(rl$linear$.v2) not equal to "y <= 1".
  1/1 mismatches
  x[1]: "NULL"
  y[1]: "y <= 1"
  
  
  15. Failure: replace_linear: transforms simple rule (@test-conditional.R#61) ---
  deparse(rl$cat) not equal to "if (.v1) !.v2".
  1/1 mismatches
  x[1]: "if (x > 1) y > 2"
  y[1]: "if (.v1) !.v2"
  
  
  16. Failure: replace_linear: transforms simple rule (@test-conditional.R#62) ---
  length(rl$linear) not equal to 2.
  1/1 mismatches
  [1] 0 - 2 == -2
  
  
  17. Failure: replace_linear: transforms simple rule (@test-conditional.R#63) ---
  deparse(rl$linear$.v1) not equal to "x <= 1".
  1/1 mismatches
  x[1]: "NULL"
  y[1]: "x <= 1"
  
  
  18. Failure: replace_linear: transforms simple rule (@test-conditional.R#64) ---
  deparse(rl$linear$.v2) not equal to "y > 2".
  1/1 mismatches
  x[1]: "NULL"
  y[1]: "y > 2"
  
  
  19. Error: cond_as_mip_rules: transforms simple rule (@test-conditional.R#71) --
  invalid subscript type 'list'
  1: cond_as_mip_rules(v) at testthat/test-conditional.R:71
  2: x[is_conditional(x)]
  3: x[is_conditional(x)]
  
  20. Error: fh_localizer: can solve a trivial system (@test-errorlocalizer.R#7) -
  invalid subscript type 'list'
  1: fh_localizer(v) at testthat/test-errorlocalizer.R:7
  2: new(structure("FHLocalizer", package = "errorlocate"), ...)
  3: initialize(value, ...)
  4: initialize(value, ...)
  5: .Object$initialize(...)
  6: miprules(rules)
  7: new(structure("MipRules", package = "errorlocate"), ...)
  8: initialize(value, ...)
  9: initialize(value, ...)
  10: .Object$initialize(...)
  11: lin_as_mip_rules(rules)
  12: x[is_linear(x)]
  13: x[is_linear(x)]
  
  21. Error: fh_localizer: can solve a trivial system 2 (@test-errorlocalizer.R#13) 
  invalid subscript type 'list'
  1: fh_localizer(v) at testthat/test-errorlocalizer.R:13
  2: new(structure("FHLocalizer", package = "errorlocate"), ...)
  3: initialize(value, ...)
  4: initialize(value, ...)
  5: .Object$initialize(...)
  6: miprules(rules)
  7: new(structure("MipRules", package = "errorlocate"), ...)
  8: initialize(value, ...)
  9: initialize(value, ...)
  10: .Object$initialize(...)
  11: lin_as_mip_rules(rules)
  12: x[is_linear(x)]
  13: x[is_linear(x)]
  
  22. Error: fh_localizer: can solve a simple system (@test-errorlocalizer.R#19) -
  invalid subscript type 'list'
  1: fh_localizer(v) at testthat/test-errorlocalizer.R:19
  2: new(structure("FHLocalizer", package = "errorlocate"), ...)
  3: initialize(value, ...)
  4: initialize(value, ...)
  5: .Object$initialize(...)
  6: miprules(rules)
  7: new(structure("MipRules", package = "errorlocate"), ...)
  8: initialize(value, ...)
  9: initialize(value, ...)
  10: .Object$initialize(...)
  11: lin_as_mip_rules(rules)
  12: x[is_linear(x)]
  13: x[is_linear(x)]
  
  23. Failure: is_lin_: can detect linear expressions (@test-linear.R#6) ---------
  is_lin_(e) isn't true.
  
  
  24. Failure: is_linear: can detect linear rules (@test-linear.R#13) ------------
  is_linear(v) not equal to c(TRUE, TRUE, FALSE, FALSE).
  Modes: list, logical
  Length mismatch: comparison on first 0 components
  
  
  25. Error: lin_mip_rule: can create a linear mip_rule object (@test-linear.R#20) 
  Invalid linear statement
  1: lin_mip_rule_(e, name = "H") at testthat/test-linear.R:20
  2: stop("Invalid linear statement")
  
  26. Error: Solve editrules checks: solves first editrules mip check (@test-localize-errors.R#12) 
  invalid subscript type 'list'
  1: locate_errors(data, v) at testthat/test-localize-errors.R:12
  2: locate_errors(data, v)
  3: .local(data, x, ...)
  4: fh_localizer(x)
  5: new(structure("FHLocalizer", package = "errorlocate"), ...)
  6: initialize(value, ...)
  7: initialize(value, ...)
  8: .Object$initialize(...)
  9: miprules(rules)
  10: new(structure("MipRules", package = "errorlocate"), ...)
  11: initialize(value, ...)
  12: initialize(value, ...)
  13: .Object$initialize(...)
  14: lin_as_mip_rules(rules)
  15: x[is_linear(x)]
  16: x[is_linear(x)]
  
  27. Error: Solve editrules checks: works without specified weight (@test-localize-errors.R#18) 
  invalid subscript type 'list'
  1: expect_equivalent(locate_errors(data = data.frame(x = c(1, 1, 1), y = c(1, 1, 1), 
         z = c(1, 1, 1)), x = validator(x + y == z, x < 1))$errors, matrix(c(TRUE, FALSE, 
         FALSE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE), nrow = 3, byrow = TRUE)) at testthat/test-localize-errors.R:18
  2: compare(object, expected, check.attributes = FALSE)
  3: locate_errors(data = data.frame(x = c(1, 1, 1), y = c(1, 1, 1), z = c(1, 1, 1)), 
         x = validator(x + y == z, x < 1))
  4: locate_errors(data = data.frame(x = c(1, 1, 1), y = c(1, 1, 1), z = c(1, 1, 1)), 
         x = validator(x + y == z, x < 1))
  5: .local(data, x, ...)
  6: fh_localizer(x)
  7: new(structure("FHLocalizer", package = "errorlocate"), ...)
  8: initialize(value, ...)
  9: initialize(value, ...)
  10: .Object$initialize(...)
  11: miprules(rules)
  12: new(structure("MipRules", package = "errorlocate"), ...)
  13: initialize(value, ...)
  14: initialize(value, ...)
  15: .Object$initialize(...)
  16: lin_as_mip_rules(rules)
  17: x[is_linear(x)]
  18: x[is_linear(x)]
  
  28. Error: Solve editrules checks: works with single specified weight (@test-localize-errors.R#36) 
  invalid subscript type 'list'
  1: expect_equivalent(locate_errors(x = validator(x + y == z), data = data.frame(x = c(1, 
         1, 1), y = c(1, 1, 1), z = c(1, 1, 1)), weight = c(1, 2, 2), )$errors, matrix(c(TRUE, 
         FALSE, FALSE, TRUE, FALSE, FALSE, TRUE, FALSE, FALSE), nrow = 3, byrow = TRUE)) at testthat/test-localize-errors.R:36
  2: compare(object, expected, check.attributes = FALSE)
  3: locate_errors(x = validator(x + y == z), data = data.frame(x = c(1, 1, 1), y = c(1, 
         1, 1), z = c(1, 1, 1)), weight = c(1, 2, 2), )
  4: locate_errors(x = validator(x + y == z), data = data.frame(x = c(1, 1, 1), y = c(1, 
         1, 1), z = c(1, 1, 1)), weight = c(1, 2, 2), )
  5: .local(data, x, ...)
  6: fh_localizer(x)
  7: new(structure("FHLocalizer", package = "errorlocate"), ...)
  8: initialize(value, ...)
  9: initialize(value, ...)
  10: .Object$initialize(...)
  11: miprules(rules)
  12: new(structure("MipRules", package = "errorlocate"), ...)
  13: initialize(value, ...)
  14: initialize(value, ...)
  15: .Object$initialize(...)
  16: lin_as_mip_rules(rules)
  17: x[is_linear(x)]
  18: x[is_linear(x)]
  
  29. Error: Solve editrules checks: works with different weights per record (@test-localize-errors.R#56) 
  invalid subscript type 'list'
  1: locate_errors(x = validator(x + y == z), data = data.frame(x = c(1, 1, 1), y = c(1, 
         1, 1), z = c(1, 1, 1)), weight = matrix(c(1, 2, 2, 2, 1, 2, 2, 2, 1), nrow = 3, 
         byrow = TRUE)) at testthat/test-localize-errors.R:56
  2: locate_errors(x = validator(x + y == z), data = data.frame(x = c(1, 1, 1), y = c(1, 
         1, 1), z = c(1, 1, 1)), weight = matrix(c(1, 2, 2, 2, 1, 2, 2, 2, 1), nrow = 3, 
         byrow = TRUE))
  3: .local(data, x, ...)
  4: fh_localizer(x)
  5: new(structure("FHLocalizer", package = "errorlocate"), ...)
  6: initialize(value, ...)
  7: initialize(value, ...)
  8: .Object$initialize(...)
  9: miprules(rules)
  10: new(structure("MipRules", package = "errorlocate"), ...)
  11: initialize(value, ...)
  12: initialize(value, ...)
  13: .Object$initialize(...)
  14: lin_as_mip_rules(rules)
  15: x[is_linear(x)]
  16: x[is_linear(x)]
  
  30. Error: Solve editrules checks: works with TRUE/FALSE (@test-localize-errors.R#126) 
  invalid subscript type 'list'
  1: locate_errors(data.frame(A = c(TRUE, FALSE), B = c("c", "d")), rules) at testthat/test-localize-errors.R:126
  2: locate_errors(data.frame(A = c(TRUE, FALSE), B = c("c", "d")), rules)
  3: .local(data, x, ...)
  4: fh_localizer(x)
  5: new(structure("FHLocalizer", package = "errorlocate"), ...)
  6: initialize(value, ...)
  7: initialize(value, ...)
  8: .Object$initialize(...)
  9: miprules(rules)
  10: new(structure("MipRules", package = "errorlocate"), ...)
  11: initialize(value, ...)
  12: initialize(value, ...)
  13: .Object$initialize(...)
  14: lin_as_mip_rules(rules)
  15: x[is_linear(x)]
  16: x[is_linear(x)]
  
  31. Error: Solve editrules checks: works with mixed edit (@test-localize-errors.R#136) 
  invalid subscript type 'list'
  1: locate_errors(data.frame(married = TRUE, age = 9), rules) at testthat/test-localize-errors.R:136
  2: locate_errors(data.frame(married = TRUE, age = 9), rules)
  3: .local(data, x, ...)
  4: fh_localizer(x)
  5: new(structure("FHLocalizer", package = "errorlocate"), ...)
  6: initialize(value, ...)
  7: initialize(value, ...)
  8: .Object$initialize(...)
  9: miprules(rules)
  10: new(structure("MipRules", package = "errorlocate"), ...)
  11: initialize(value, ...)
  12: initialize(value, ...)
  13: .Object$initialize(...)
  14: lin_as_mip_rules(rules)
  15: x[is_linear(x)]
  16: x[is_linear(x)]
  
  32. Error: Solve editrules checks: works for simple numerical if-else (@test-localize-errors.R#145) 
  invalid subscript type 'list'
  1: locate_errors(data = data, x = rules) at testthat/test-localize-errors.R:145
  2: locate_errors(data = data, x = rules)
  3: .local(data, x, ...)
  4: fh_localizer(x)
  5: new(structure("FHLocalizer", package = "errorlocate"), ...)
  6: initialize(value, ...)
  7: initialize(value, ...)
  8: .Object$initialize(...)
  9: miprules(rules)
  10: new(structure("MipRules", package = "errorlocate"), ...)
  11: initialize(value, ...)
  12: initialize(value, ...)
  13: .Object$initialize(...)
  14: lin_as_mip_rules(rules)
  15: x[is_linear(x)]
  16: x[is_linear(x)]
  
  33. Error: locate_errors: works with validator (@test-locate_errors.R#7) -------
  invalid subscript type 'list'
  1: fh_localizer(v) at testthat/test-locate_errors.R:7
  2: new(structure("FHLocalizer", package = "errorlocate"), ...)
  3: initialize(value, ...)
  4: initialize(value, ...)
  5: .Object$initialize(...)
  6: miprules(rules)
  7: new(structure("MipRules", package = "errorlocate"), ...)
  8: initialize(value, ...)
  9: initialize(value, ...)
  10: .Object$initialize(...)
  11: lin_as_mip_rules(rules)
  12: x[is_linear(x)]
  13: x[is_linear(x)]
  
  34. Error: locate_errors: works with linear rules (@test-locate_errors.R#18) ---
  invalid subscript type 'list'
  1: locate_errors(data, v) at testthat/test-locate_errors.R:18
  2: locate_errors(data, v)
  3: .local(data, x, ...)
  4: fh_localizer(x)
  5: new(structure("FHLocalizer", package = "errorlocate"), ...)
  6: initialize(value, ...)
  7: initialize(value, ...)
  8: .Object$initialize(...)
  9: miprules(rules)
  10: new(structure("MipRules", package = "errorlocate"), ...)
  11: initialize(value, ...)
  12: initialize(value, ...)
  13: .Object$initialize(...)
  14: lin_as_mip_rules(rules)
  15: x[is_linear(x)]
  16: x[is_linear(x)]
  
  35. Error: locate_errors: works with categorical rules (@test-locate_errors.R#29) 
  invalid subscript type 'list'
  1: locate_errors(data, v_categorical) at testthat/test-locate_errors.R:29
  2: locate_errors(data, v_categorical)
  3: .local(data, x, ...)
  4: fh_localizer(x)
  5: new(structure("FHLocalizer", package = "errorlocate"), ...)
  6: initialize(value, ...)
  7: initialize(value, ...)
  8: .Object$initialize(...)
  9: miprules(rules)
  10: new(structure("MipRules", package = "errorlocate"), ...)
  11: initialize(value, ...)
  12: initialize(value, ...)
  13: .Object$initialize(...)
  14: lin_as_mip_rules(rules)
  15: x[is_linear(x)]
  16: x[is_linear(x)]
  
  36. Error: locate_errors: works with logical variables (@test-locate_errors.R#46) 
  invalid subscript type 'list'
  1: locate_errors(data, v_logical, weight = c(A = 2, B = 1)) at testthat/test-locate_errors.R:46
  2: locate_errors(data, v_logical, weight = c(A = 2, B = 1))
  3: .local(data, x, ...)
  4: fh_localizer(x)
  5: new(structure("FHLocalizer", package = "errorlocate"), ...)
  6: initialize(value, ...)
  7: initialize(value, ...)
  8: .Object$initialize(...)
  9: miprules(rules)
  10: new(structure("MipRules", package = "errorlocate"), ...)
  11: initialize(value, ...)
  12: initialize(value, ...)
  13: .Object$initialize(...)
  14: lin_as_mip_rules(rules)
  15: x[is_linear(x)]
  16: x[is_linear(x)]
  
  37. Error: locate_errors: works with conditional rules (@test-locate_errors.R#53) 
  invalid subscript type 'list'
  1: locate_errors(data, v, weight = c(married = 1, age = 2)) at testthat/test-locate_errors.R:53
  2: locate_errors(data, v, weight = c(married = 1, age = 2))
  3: .local(data, x, ...)
  4: fh_localizer(x)
  5: new(structure("FHLocalizer", package = "errorlocate"), ...)
  6: initialize(value, ...)
  7: initialize(value, ...)
  8: .Object$initialize(...)
  9: miprules(rules)
  10: new(structure("MipRules", package = "errorlocate"), ...)
  11: initialize(value, ...)
  12: initialize(value, ...)
  13: .Object$initialize(...)
  14: lin_as_mip_rules(rules)
  15: x[is_linear(x)]
  16: x[is_linear(x)]
  
  38. Error: locate_errors: handles NA values in categorical rules (@test-locate_errors.R#60) 
  invalid subscript type 'list'
  1: locate_errors(data, rules) at testthat/test-locate_errors.R:60
  2: locate_errors(data, rules)
  3: .local(data, x, ...)
  4: fh_localizer(x)
  5: new(structure("FHLocalizer", package = "errorlocate"), ...)
  6: initialize(value, ...)
  7: initialize(value, ...)
  8: .Object$initialize(...)
  9: miprules(rules)
  10: new(structure("MipRules", package = "errorlocate"), ...)
  11: initialize(value, ...)
  12: initialize(value, ...)
  13: .Object$initialize(...)
  14: lin_as_mip_rules(rules)
  15: x[is_linear(x)]
  16: x[is_linear(x)]
  
  39. Error: lp_solve: can translate simple lin rule (@test-mip-lpsolve.R#7) -----
  invalid subscript type 'list'
  1: lin_as_mip_rules(v) at testthat/test-mip-lpsolve.R:7
  2: x[is_linear(x)]
  3: x[is_linear(x)]
  
  40. Error: lp_solve: can translate lin rules to lpsolve object (@test-mip-lpsolve.R#19) 
  invalid subscript type 'list'
  1: lin_as_mip_rules(v) at testthat/test-mip-lpsolve.R:19
  2: x[is_linear(x)]
  3: x[is_linear(x)]
  
  41. Error: MipRules: can transform to miprules (@test-mip.R#6) -----------------
  invalid subscript type 'list'
  1: miprules(v) at testthat/test-mip.R:6
  2: new(structure("MipRules", package = "errorlocate"), ...)
  3: initialize(value, ...)
  4: initialize(value, ...)
  5: .Object$initialize(...)
  6: lin_as_mip_rules(rules)
  7: x[is_linear(x)]
  8: x[is_linear(x)]
  
  42. Error: MipRules: can set values (@test-mip.R#11) ---------------------------
  invalid subscript type 'list'
  1: miprules(v) at testthat/test-mip.R:11
  2: new(structure("MipRules", package = "errorlocate"), ...)
  3: initialize(value, ...)
  4: initialize(value, ...)
  5: .Object$initialize(...)
  6: lin_as_mip_rules(rules)
  7: x[is_linear(x)]
  8: x[is_linear(x)]
  
  43. Error: MipRules: finds errors (@test-mip.R#18) -----------------------------
  invalid subscript type 'list'
  1: miprules(v) at testthat/test-mip.R:18
  2: new(structure("MipRules", package = "errorlocate"), ...)
  3: initialize(value, ...)
  4: initialize(value, ...)
  5: .Object$initialize(...)
  6: lin_as_mip_rules(rules)
  7: x[is_linear(x)]
  8: x[is_linear(x)]
  
  44. Error: MipRules: can handle strict inequalities (@test-mip.R#29) -----------
  invalid subscript type 'list'
  1: miprules(rules) at testthat/test-mip.R:29
  2: new(structure("MipRules", package = "errorlocate"), ...)
  3: initialize(value, ...)
  4: initialize(value, ...)
  5: .Object$initialize(...)
  6: lin_as_mip_rules(rules)
  7: x[is_linear(x)]
  8: x[is_linear(x)]
  
  45. Error: get_mr_type: can return correct type (@test-miprule.R#7) ------------
  invalid subscript type 'list'
  1: cat_as_mip_rules(v) at testthat/test-miprule.R:7
  2: x[is_categorical(x)]
  3: x[is_categorical(x)]
  
  46. Error: replace errors: works with linear rules (@test-replace-errors.R#12) -
  invalid subscript type 'list'
  1: replace_errors(data, rules) at testthat/test-replace-errors.R:12
  2: replace_errors(data, rules)
  3: fh_localizer(x)
  4: new(structure("FHLocalizer", package = "errorlocate"), ...)
  5: initialize(value, ...)
  6: initialize(value, ...)
  7: .Object$initialize(...)
  8: miprules(rules)
  9: new(structure("MipRules", package = "errorlocate"), ...)
  10: initialize(value, ...)
  11: initialize(value, ...)
  12: .Object$initialize(...)
  13: lin_as_mip_rules(rules)
  14: x[is_linear(x)]
  15: x[is_linear(x)]
  
  47. Error: replace errors: works with weights (@test-replace-errors.R#24) ------
  invalid subscript type 'list'
  1: replace_errors(data, rules, weight = weight) at testthat/test-replace-errors.R:24
  2: replace_errors(data, rules, weight = weight)
  3: fh_localizer(x)
  4: new(structure("FHLocalizer", package = "errorlocate"), ...)
  5: initialize(value, ...)
  6: initialize(value, ...)
  7: .Object$initialize(...)
  8: miprules(rules)
  9: new(structure("MipRules", package = "errorlocate"), ...)
  10: initialize(value, ...)
  11: initialize(value, ...)
  12: .Object$initialize(...)
  13: lin_as_mip_rules(rules)
  14: x[is_linear(x)]
  15: x[is_linear(x)]
  
  48. Error: replace errors: works with NA values (@test-replace-errors.R#43) ----
  invalid subscript type 'list'
  1: replace_errors(data, rules) at testthat/test-replace-errors.R:43
  2: replace_errors(data, rules)
  3: fh_localizer(x)
  4: new(structure("FHLocalizer", package = "errorlocate"), ...)
  5: initialize(value, ...)
  6: initialize(value, ...)
  7: .Object$initialize(...)
  8: miprules(rules)
  9: new(structure("MipRules", package = "errorlocate"), ...)
  10: initialize(value, ...)
  11: initialize(value, ...)
  12: .Object$initialize(...)
  13: lin_as_mip_rules(rules)
  14: x[is_linear(x)]
  15: x[is_linear(x)]
  
  49. Error: replace errors: works with categorical rules (@test-replace-errors.R#56) 
  invalid subscript type 'list'
  1: locate_errors(data, rules) at testthat/test-replace-errors.R:56
  2: locate_errors(data, rules)
  3: .local(data, x, ...)
  4: fh_localizer(x)
  5: new(structure("FHLocalizer", package = "errorlocate"), ...)
  6: initialize(value, ...)
  7: initialize(value, ...)
  8: .Object$initialize(...)
  9: miprules(rules)
  10: new(structure("MipRules", package = "errorlocate"), ...)
  11: initialize(value, ...)
  12: initialize(value, ...)
  13: .Object$initialize(...)
  14: lin_as_mip_rules(rules)
  15: x[is_linear(x)]
  16: x[is_linear(x)]
  
  50. Error: soft_lin_rule: can transform a lin rule into a softrule (@test-soft-rule.R#21) 
  Invalid linear statement
  1: lin_mip_rule_(e, name = "x") at testthat/test-soft-rule.R:21
  2: stop("Invalid linear statement")
  
  51. Error: soft_lin_rule: can transform a cat rule into a softrule (@test-soft-rule.R#32) 
  invalid 'type' (list) of argument
  1: cat_mip_rule_(e, name = "A") at testthat/test-soft-rule.R:32
  
  testthat results ================================================================
  OK: 53 SKIPPED: 1 FAILED: 51
  1. Failure: categorical: can detect categorical rules (@test-categorical.R#11) 
  2. Error: categorical: can derive coefficients (@test-categorical.R#17) 
  3. Error: categorical: can handle logical rules (@test-categorical.R#34) 
  4. Failure: is_condition_: can detect a complex rule (@test-conditional.R#6) 
  5. Failure: is_condition_: can use negated expression (@test-conditional.R#10) 
  6. Failure: is_condition_: can use nested expression (@test-conditional.R#14) 
  7. Failure: is_condition_: can use negated nested expression (@test-conditional.R#18) 
  8. Failure: conditional: can detect conditional rules (@test-conditional.R#30) 
  9. Failure: conditional: can detect more complex rules (@test-conditional.R#39) 
  1. ...
  
  Error: testthat unit tests failed
  Execution halted