Running 'testthat.R' [447s/491s]
Running the tests in 'tests/testthat.R' failed.
Complete output:
  > library(testthat)
  > library(quickcheck)
  > test_check("quickcheck")
  [ FAIL 1 | WARN 0 | SKIP 0 | PASS 462 ]
  
  == Failed tests ================================================================
  -- Error (???): generator doesn't generate NAs by default ----------------------
  Error in ``_fn`(a)`: 'rho' must be an environment not pairlist: detected in C-level eval
  Backtrace:
        x
     1. +-quickcheck::for_all(...)
     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::gen.run(g, size)
    15. |                           \-hedgehog:::unfoldgenerator(generator, size)
    16. |                             \-generator$unGen(size)
    17. |                               \-hedgehog::gen.run(f(size), size)
    18. |                                 \-hedgehog:::unfoldgenerator(generator, size)
    19. |                                   \-generator$unGen(size)
    20. |                                     \-hedgehog:::tree.bind(...)
    21. |                                       \-hedgehog f(x$root)
    22. |                                         \-hedgehog::gen.run(f(x), size)
    23. |                                           \-hedgehog:::unfoldgenerator(generator, size)
    24. |                                             \-generator$unGen(size)
    25. |                                               +-hedgehog:::tree.expand(shrinker, gen.run(g, size))
    26. |                                               | \-hedgehog:::tree.check(x)
    27. |                                               \-hedgehog::gen.run(g, size)
    28. |                                                 \-hedgehog:::unfoldgenerator(generator, size)
    29. |                                                   \-generator$unGen(size)
    30. |                                                     \-hedgehog:::tree.replicate(...)
    31. |                                                       +-hedgehog:::tree.liftA2(...)
    32. |                                                       | \-hedgehog:::tree.check(y)
    33. |                                                       \-hedgehog:::tree.replicate(num - 1, ma, ...)
    34. |                                                         +-hedgehog:::tree.liftA2(...)
    35. |                                                         | \-hedgehog:::tree.check(x)
    36. |                                                         +-base::do.call(ma, list(...))
    37. |                                                         \-hedgehog `<fn>`()
    38. |                                                           \-hedgehog::gen.run(generator, size)
    39. |                                                             \-hedgehog:::unfoldgenerator(generator, size)
    40. |                                                               \-base::lapply(generator, function(g) unfoldgenerator(g, size))
    41. |                                                                 \-hedgehog FUN(X[[i]], ...)
    42. |                                                                   \-hedgehog:::unfoldgenerator(g, size)
    43. |                                                                     \-generator$unGen(size)
    44. |                                                                       \-hedgehog::gen.run(g, size)
    45. |                                                                         \-hedgehog:::unfoldgenerator(generator, size)
    46. |                                                                           \-base::lapply(generator, function(g) unfoldgenerator(g, size))
    47. |                                                                             \-hedgehog FUN(X[[i]], ...)
    48. |                                                                               \-hedgehog:::unfoldgenerator(g, size)
    49. |                                                                                 \-generator$unGen(size)
    50. |                                                                                   \-hedgehog:::tree.bind(...)
    51. |                                                                                     \-hedgehog f(x$root)
    52. |                                                                                       \-hedgehog::gen.run(f(x), size)
    53. |                                                                                         \-hedgehog:::unfoldgenerator(generator, size)
    54. |                                                                                           \-generator$unGen(size)
    55. |                                                                                             \-hedgehog::gen.run(g, size)
    56. |                                                                                               \-hedgehog:::unfoldgenerator(generator, size)
    57. |                                                                                                 \-generator$unGen(size)
    58. |                                                                                                   \-hedgehog::gen.run(f(size), size)
    59. |                                                                                                     \-hedgehog:::unfoldgenerator(generator, size)
    60. |                                                                                                       \-generator$unGen(size)
    61. |                                                                                                         \-hedgehog:::tree.bind(...)
    62. |                                                                                                           \-hedgehog f(x$root)
    63. |                                                                                                             \-hedgehog::gen.run(f(x), size)
    64. |                                                                                                               \-hedgehog:::unfoldgenerator(generator, size)
    65. |                                                                                                                 \-generator$unGen(size)
    66. |                                                                                                                   +-hedgehog:::tree.expand(shrinker, gen.run(g, size))
    67. |                                                                                                                   | \-hedgehog:::tree.check(x)
    68. |                                                                                                                   \-hedgehog::gen.run(g, size)
    69. |                                                                                                                     \-hedgehog:::unfoldgenerator(generator, size)
    70. |                                                                                                                       \-generator$unGen(size)
    71. |                                                                                                                         \-hedgehog:::tree.replicate(...)
    72. |                                                                                                                           +-hedgehog:::tree.liftA2(...)
    73. |                                                                                                                           | \-hedgehog:::tree.check(x)
    74. |                                                                                                                           +-base::do.call(ma, list(...))
    75. |                                                                                                                           \-hedgehog `<fn>`()
    76. |                                                                                                                             \-hedgehog::gen.run(generator, size)
    77. |                                                                                                                               \-hedgehog:::unfoldgenerator(generator, size)
    78. |                                                                                                                                 \-generator$unGen(size)
    79. |                                                                                                                                   \-hedgehog::gen.run(g, size)
    80. |                                                                                                                                     \-hedgehog:::unfoldgenerator(generator, size)
    81. |                                                                                                                                       \-generator$unGen(size)
    82. |                                                                                                                                         +-hedgehog:::tree.expand(shrinker, gen.run(g, size))
    83. |                                                                                                                                         | \-hedgehog:::tree.check(x)
    84. |                                                                                                                                         \-hedgehog::gen.run(g, size)
    85. |                                                                                                                                           \-hedgehog:::unfoldgenerator(generator, size)
    86. |                                                                                                                                             \-generator$unGen(size)
    87. |                                                                                                                                               +-hedgehog:::tree(fg(size))
    88. |                                                                                                                                               | \-base::structure(...)
    89. |                                                                                                                                               \-hedgehog fg(size)
    90. |                                                                                                                                                 \-base::sample.int(n, 1, prob = prob)
    91. |                                                                                                                                                   \-base::stopifnot(length(n) == 1L)
    92. +-base::replicate(1000L, random_string(characters))
    93. | \-base::sapply(...)
    94. |   \-base::lapply(X = X, FUN = FUN, ...)
    95. |     \-quickcheck FUN(X[[i]], ...)
    96. |       \-quickcheck:::random_string(characters)
    97. |         \-... %>% paste0(collapse = "")
    98. +-base::paste0(., collapse = "")
    99. +-quickcheck:::sample_vec(., stats::runif(1L, 1L, 10L))
   100. | \-quickcheck:::n_distinct(a)
   101. |   \-(purrr::compose(length, unique))(a)
   102. \-base `_fn`(a)
  
  [ FAIL 1 | WARN 0 | SKIP 0 | PASS 462 ]
  Error: Test failures
  Execution halted