Running ‘testthat.R’ [148s/215s]
Running the tests in ‘tests/testthat.R’ failed.
Complete output:
  > library(testthat)
  > library(maybe)
  > 
  > test_check("maybe")
  [ FAIL 1 | WARN 0 | SKIP 0 | PASS 93 ]
  
  ══ Failed tests ════════════════════════════════════════════════════════════════
  ── Error (test-with_default.R:9:3): with_default unwraps a just value ──────────
  Error in `unfoldgenerator(generator, size)`: 'rho' must be an environment not pairlist: detected in C-level eval
  Backtrace:
        ▆
     1. └─quickcheck::for_all(...) at test-with_default.R:9:2
     2.   └─hedgehog::forall(...)
     3.     └─hedgehog::gen.run(generator, size)
     4.       └─hedgehog:::unfoldgenerator(generator, size)
     5.         └─base::lapply(generator, function(g) unfoldgenerator(g, size))
     6.           └─hedgehog FUN(X[[i]], ...)
     7.             └─hedgehog:::unfoldgenerator(g, size)
     8.               └─generator$unGen(size)
     9.                 └─hedgehog:::tree.bind(...)
    10.                   └─hedgehog f(x$root)
    11.                     └─hedgehog::gen.run(f(x), size)
    12.                       └─hedgehog:::unfoldgenerator(generator, size)
    13.                         └─generator$unGen(size)
    14.                           └─hedgehog:::tree.bind(...)
    15.                             └─hedgehog f(x$root)
    16.                               └─hedgehog::gen.run(f(x), size)
    17.                                 └─hedgehog:::unfoldgenerator(generator, size)
    18.                                   └─generator$unGen(size)
    19.                                     └─hedgehog::gen.run(g, size)
    20.                                       └─hedgehog:::unfoldgenerator(generator, size)
    21.                                         └─base::lapply(generator, function(g) unfoldgenerator(g, size))
    22.                                           └─hedgehog FUN(X[[i]], ...)
    23.                                             └─hedgehog:::unfoldgenerator(g, size)
    24.                                               └─generator$unGen(size)
    25.                                                 └─hedgehog:::tree.bind(...)
    26.                                                   └─hedgehog f(x$root)
    27.                                                     └─hedgehog::gen.run(f(x), size)
    28.                                                       └─hedgehog:::unfoldgenerator(generator, size)
    29.                                                         └─generator$unGen(size)
    30.                                                           └─hedgehog:::tree.bind(...)
    31.                                                             └─hedgehog f(x$root)
    32.                                                               └─hedgehog::gen.run(f(x), size)
    33.                                                                 └─hedgehog:::unfoldgenerator(generator, size)
    34.                                                                   └─generator$unGen(size)
    35.                                                                     └─hedgehog::gen.run(g, size)
    36.                                                                       └─hedgehog:::unfoldgenerator(generator, size)
    37.                                                                         └─generator$unGen(size)
    38.                                                                           └─hedgehog:::tree.replicate(...)
    39.                                                                             ├─hedgehog:::tree.liftA2(...)
    40.                                                                             │ └─hedgehog:::tree.check(y)
    41.                                                                             └─hedgehog:::tree.replicate(num - 1, ma, ...)
    42.                                                                               ├─hedgehog:::tree.liftA2(...)
    43.                                                                               │ └─hedgehog:::tree.check(y)
    44.                                                                               └─hedgehog:::tree.replicate(num - 1, ma, ...)
    45.                                                                                 ├─hedgehog:::tree.liftA2(...)
    46.                                                                                 │ └─hedgehog:::tree.check(y)
    47.                                                                                 └─hedgehog:::tree.replicate(num - 1, ma, ...)
    48.                                                                                   ├─hedgehog:::tree.liftA2(...)
    49.                                                                                   │ └─hedgehog:::tree.check(y)
    50.                                                                                   └─hedgehog:::tree.replicate(num - 1, ma, ...)
    51.                                                                                     ├─hedgehog:::tree.liftA2(...)
    52.                                                                                     │ └─hedgehog:::tree.check(y)
    53.                                                                                     └─hedgehog:::tree.replicate(num - 1, ma, ...)
    54.                                                                                       ├─hedgehog:::tree.liftA2(...)
    55.                                                                                       │ └─hedgehog:::tree.check(y)
    56.                                                                                       └─hedgehog:::tree.replicate(num - 1, ma, ...)
    57.                                                                                         ├─hedgehog:::tree.liftA2(...)
    58.                                                                                         │ └─hedgehog:::tree.check(y)
    59.                                                                                         └─hedgehog:::tree.replicate(num - 1, ma, ...)
    60.                                                                                           ├─hedgehog:::tree.liftA2(...)
    61.                                                                                           │ └─hedgehog:::tree.check(y)
    62.                                                                                           └─hedgehog:::tree.replicate(num - 1, ma, ...)
    63.                                                                                             ├─hedgehog:::tree.liftA2(...)
    64.                                                                                             │ └─hedgehog:::tree.check(x)
    65.                                                                                             ├─base::do.call(ma, list(...))
    66.                                                                                             └─hedgehog `<fn>`()
    67.                                                                                               └─hedgehog::gen.run(generator, size)
    68.                                                                                                 └─hedgehog:::unfoldgenerator(generator, size)
    69.                                                                                                   └─base::lapply(generator, function(g) unfoldgenerator(g, size))
    70.                                                                                                     └─hedgehog FUN(X[[i]], ...)
    71.                                                                                                       └─hedgehog:::unfoldgenerator(g, size)
    72.                                                                                                         └─generator$unGen(size)
    73.                                                                                                           └─hedgehog:::tree.bind(...)
    74.                                                                                                             └─hedgehog f(x$root)
    75.                                                                                                               └─hedgehog::gen.run(f(x), size)
    76.                                                                                                                 └─hedgehog:::unfoldgenerator(generator, size)
    77.                                                                                                                   └─generator$unGen(size)
    78.                                                                                                                     └─hedgehog::gen.run(g, size)
    79.                                                                                                                       └─hedgehog:::unfoldgenerator(generator, size)
    80.                                                                                                                         └─generator$unGen(size)
    81.                                                                                                                           └─hedgehog::gen.run(f(size), size)
    82.                                                                                                                             └─hedgehog:::unfoldgenerator(generator, size)
    83.                                                                                                                               └─generator$unGen(size)
    84.                                                                                                                                 └─hedgehog:::tree.bind(...)
    85.                                                                                                                                   └─hedgehog f(x$root)
    86.                                                                                                                                     └─hedgehog::gen.run(f(x), size)
    87.                                                                                                                                       └─hedgehog:::unfoldgenerator(generator, size)
    88.                                                                                                                                         └─generator$unGen(size)
    89.                                                                                                                                           ├─hedgehog:::tree.expand(shrinker, gen.run(g, size))
    90.                                                                                                                                           │ └─hedgehog:::tree.check(x)
    91.                                                                                                                                           └─hedgehog::gen.run(g, size)
    92.                                                                                                                                             └─hedgehog:::unfoldgenerator(generator, size)
    93.                                                                                                                                               └─generator$unGen(size)
    94.                                                                                                                                                 └─hedgehog:::tree.replicate(...)
    95.                                                                                                                                                   ├─hedgehog:::tree.liftA2(...)
    96.                                                                                                                                                   │ └─hedgehog:::tree.check(x)
    97.                                                                                                                                                   ├─base::do.call(ma, list(...))
    98.                                                                                                                                                   └─hedgehog `<fn>`()
    99.                                                                                                                                                     └─hedgehog::gen.run(generator, size)
   100.                                                                                                                                                       └─hedgehog:::unfoldgenerator(generator, size)
  
  [ FAIL 1 | WARN 0 | SKIP 0 | PASS 93 ]
  Error: Test failures
  Execution halted