Running 'testthat.R' [30s]
Running the tests in 'tests/testthat.R' failed.
Complete output:
  > library(testthat)
  > library(migrbc)
  > 
  > test_check("migrbc")
  INFO [2020-08-28 02:41:51] entering 'pre_process' :
  INFO [2020-08-28 02:41:51] leaving 'pre_process' : 
                return 1 groups of raw data.
  INFO [2020-08-28 02:41:51] entering 'resolve_data' :
  INFO [2020-08-28 02:41:51] Running without parallel
  INFO [2020-08-28 02:41:51] entering 'resolve_data, chunk =1':
                 window_size=487, 
                 threshold_year=365
  -- 1. Failure: Run RBC with a single non-resident person should succeed: Scenari
  `migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)
    7. dplyr::bind_rows
    8. base::getExportedValue(pkg, name)
    9. base::asNamespace(ns)
   10. base::getNamespace(ns)
   11. base::loadNamespace(name)
   12. base::library.dynam(lib, package, package.lib)
  
  -- 2. Failure: Run RBC with a single non-resident person should succeed: Scenari
  identical(as.numeric(res$res_status_before[[1]]), 0) isn't true.
  
  -- 3. Failure: Run RBC with a single non-resident person should succeed: Scenari
  identical(as.numeric(res$res_status_after[[1]]), 0) isn't true.
  
  -- 4. Failure: Run RBC with a single non-resident person should succeed: Scenari
  identical(as.numeric(res$is_long_term_mig[[1]]), 0) isn't true.
  
  -- 5. Failure: Run RBC with a single non-resident person should succeed: Scenari
  days_RB == 0 isn't true.
  
  -- 6. Failure: Run RBC with a single non-resident person should succeed: Scenari
  days_RA == 0 isn't true.
  
  -- 7. Failure: Run RBC with a single non-resident person should succeed: Scenari
  days_LTM == 0 isn't true.
  
  INFO [2020-08-28 02:41:52] entering 'pre_process' :
  INFO [2020-08-28 02:41:52] leaving 'pre_process' : 
                return 1 groups of raw data.
  INFO [2020-08-28 02:41:52] entering 'resolve_data' :
  INFO [2020-08-28 02:41:52] Running without parallel
  INFO [2020-08-28 02:41:52] entering 'resolve_data, chunk =1':
                 window_size=487, 
                 threshold_year=365
  -- 8. Failure: Run RBC with a single non-resident person should succeed: Scenari
  `migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)
    7. dplyr::bind_rows
    8. base::getExportedValue(pkg, name)
    9. base::asNamespace(ns)
   10. base::getNamespace(ns)
   11. base::loadNamespace(name)
   12. base::library.dynam(lib, package, package.lib)
  
  -- 9. Failure: Run RBC with a single non-resident person should succeed: Scenari
  identical(as.numeric(res$res_status_before[[1]]), 0) isn't true.
  
  -- 10. Failure: Run RBC with a single non-resident person should succeed: Scenar
  identical(as.numeric(res$res_status_after[[1]]), 1) isn't true.
  
  -- 11. Failure: Run RBC with a single non-resident person should succeed: Scenar
  identical(as.numeric(res$is_long_term_mig[[1]]), 1) isn't true.
  
  -- 12. Failure: Run RBC with a single non-resident person should succeed: Scenar
  ==... isn't true.
  
  -- 13. Failure: Run RBC with a single non-resident person should succeed: Scenar
  ==... isn't true.
  
  -- 14. Failure: Run RBC with a single non-resident person should succeed: Scenar
  ==... isn't true.
  
  INFO [2020-08-28 02:41:52] entering 'pre_process' :
  INFO [2020-08-28 02:41:52] leaving 'pre_process' : 
                return 1 groups of raw data.
  INFO [2020-08-28 02:41:52] entering 'resolve_data' :
  INFO [2020-08-28 02:41:52] Running without parallel
  INFO [2020-08-28 02:41:52] entering 'resolve_data, chunk =1':
                 window_size=487, 
                 threshold_year=365
  -- 15. Failure: Run RBC with a single non-resident person should succeed: Scenar
  `migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)
    7. dplyr::bind_rows
    8. base::getExportedValue(pkg, name)
    9. base::asNamespace(ns)
   10. base::getNamespace(ns)
   11. base::loadNamespace(name)
   12. base::library.dynam(lib, package, package.lib)
  
  -- 16. Failure: Run RBC with a single non-resident person should succeed: Scenar
  identical(as.numeric(res$res_status_before[[1]]), 0) isn't true.
  
  -- 17. Failure: Run RBC with a single non-resident person should succeed: Scenar
  identical(as.numeric(res$res_status_after[[1]]), 0) isn't true.
  
  -- 18. Failure: Run RBC with a single non-resident person should succeed: Scenar
  identical(as.numeric(res$is_long_term_mig[[1]]), 0) isn't true.
  
  -- 19. Failure: Run RBC with a single non-resident person should succeed: Scenar
  ==... isn't true.
  
  -- 20. Failure: Run RBC with a single non-resident person should succeed: Scenar
  ==... isn't true.
  
  -- 21. Failure: Run RBC with a single non-resident person should succeed: Scenar
  ==... isn't true.
  
  -- 22. Failure: Run RBC with a single non-resident person should succeed: Scenar
  identical(as.numeric(res$res_status_before[[2]]), 0) isn't true.
  
  -- 23. Failure: Run RBC with a single non-resident person should succeed: Scenar
  identical(as.numeric(res$res_status_after[[2]]), 0) isn't true.
  
  -- 24. Failure: Run RBC with a single non-resident person should succeed: Scenar
  identical(as.numeric(res$is_long_term_mig[[2]]), 0) isn't true.
  
  -- 25. Failure: Run RBC with a single non-resident person should succeed: Scenar
  ==... isn't true.
  
  -- 26. Failure: Run RBC with a single non-resident person should succeed: Scenar
  ==... isn't true.
  
  -- 27. Failure: Run RBC with a single non-resident person should succeed: Scenar
  ==... isn't true.
  
  INFO [2020-08-28 02:41:52] entering 'pre_process' :
  INFO [2020-08-28 02:41:52] leaving 'pre_process' : 
                return 1 groups of raw data.
  INFO [2020-08-28 02:41:52] entering 'resolve_data' :
  INFO [2020-08-28 02:41:52] Running without parallel
  INFO [2020-08-28 02:41:52] entering 'resolve_data, chunk =1':
                 window_size=487, 
                 threshold_year=365
  -- 28. Failure: Run RBC with a single non-resident person should succeed: Scenar
  `migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)
    7. dplyr::bind_rows
    8. base::getExportedValue(pkg, name)
    9. base::asNamespace(ns)
   10. base::getNamespace(ns)
   11. base::loadNamespace(name)
   12. base::library.dynam(lib, package, package.lib)
  
  -- 29. Failure: Run RBC with a single non-resident person should succeed: Scenar
  identical(as.numeric(res$res_status_before[[1]]), 0) isn't true.
  
  -- 30. Failure: Run RBC with a single non-resident person should succeed: Scenar
  identical(as.numeric(res$res_status_after[[1]]), 0) isn't true.
  
  -- 31. Failure: Run RBC with a single non-resident person should succeed: Scenar
  identical(as.numeric(res$is_long_term_mig[[1]]), 0) isn't true.
  
  -- 32. Failure: Run RBC with a single non-resident person should succeed: Scenar
  ==... isn't true.
  
  -- 33. Failure: Run RBC with a single non-resident person should succeed: Scenar
  ==... isn't true.
  
  -- 34. Failure: Run RBC with a single non-resident person should succeed: Scenar
  ==... isn't true.
  
  -- 35. Failure: Run RBC with a single non-resident person should succeed: Scenar
  identical(as.numeric(res$res_status_before[[2]]), 0) isn't true.
  
  -- 36. Failure: Run RBC with a single non-resident person should succeed: Scenar
  identical(as.numeric(res$res_status_after[[2]]), 0) isn't true.
  
  -- 37. Failure: Run RBC with a single non-resident person should succeed: Scenar
  identical(as.numeric(res$is_long_term_mig[[2]]), 0) isn't true.
  
  -- 38. Failure: Run RBC with a single non-resident person should succeed: Scenar
  ==... isn't true.
  
  -- 39. Failure: Run RBC with a single non-resident person should succeed: Scenar
  ==... isn't true.
  
  -- 40. Failure: Run RBC with a single non-resident person should succeed: Scenar
  ==... isn't true.
  
  -- 41. Failure: Run RBC with a single non-resident person should succeed: Scenar
  identical(as.numeric(res$res_status_before[[3]]), 0) isn't true.
  
  -- 42. Failure: Run RBC with a single non-resident person should succeed: Scenar
  identical(as.numeric(res$res_status_after[[3]]), 0) isn't true.
  
  -- 43. Failure: Run RBC with a single non-resident person should succeed: Scenar
  identical(as.numeric(res$is_long_term_mig[[3]]), 0) isn't true.
  
  -- 44. Failure: Run RBC with a single non-resident person should succeed: Scenar
  ==... isn't true.
  
  -- 45. Failure: Run RBC with a single non-resident person should succeed: Scenar
  ==... isn't true.
  
  -- 46. Failure: Run RBC with a single non-resident person should succeed: Scenar
  ==... isn't true.
  
  -- 47. Failure: Run RBC with a single non-resident person should succeed: Scenar
  identical(as.numeric(res$res_status_before[[4]]), 0) isn't true.
  
  -- 48. Failure: Run RBC with a single non-resident person should succeed: Scenar
  identical(as.numeric(res$res_status_after[[4]]), 0) isn't true.
  
  -- 49. Failure: Run RBC with a single non-resident person should succeed: Scenar
  identical(as.numeric(res$is_long_term_mig[[4]]), 0) isn't true.
  
  -- 50. Failure: Run RBC with a single non-resident person should succeed: Scenar
  ==... isn't true.
  
  -- 51. Failure: Run RBC with a single non-resident person should succeed: Scenar
  ==... isn't true.
  
  -- 52. Failure: Run RBC with a single non-resident person should succeed: Scenar
  ==... isn't true.
  
  INFO [2020-08-28 02:41:52] entering 'pre_process' :
  INFO [2020-08-28 02:41:52] leaving 'pre_process' : 
                return 1 groups of raw data.
  INFO [2020-08-28 02:41:52] entering 'resolve_data' :
  INFO [2020-08-28 02:41:52] Running without parallel
  INFO [2020-08-28 02:41:52] entering 'resolve_data, chunk =1':
                 window_size=487, 
                 threshold_year=365
  -- 53. Failure: Run RBC with a single non-resident person should succeed: Scenar
  `migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)
    7. dplyr::bind_rows
    8. base::getExportedValue(pkg, name)
    9. base::asNamespace(ns)
   10. base::getNamespace(ns)
   11. base::loadNamespace(name)
   12. base::library.dynam(lib, package, package.lib)
  
  -- 54. Failure: Run RBC with a single non-resident person should succeed: Scenar
  identical(as.numeric(res$res_status_before[[1]]), 0) isn't true.
  
  -- 55. Failure: Run RBC with a single non-resident person should succeed: Scenar
  identical(as.numeric(res$res_status_after[[1]]), 0) isn't true.
  
  -- 56. Failure: Run RBC with a single non-resident person should succeed: Scenar
  identical(as.numeric(res$is_long_term_mig[[1]]), 0) isn't true.
  
  -- 57. Failure: Run RBC with a single non-resident person should succeed: Scenar
  ==... isn't true.
  
  -- 58. Failure: Run RBC with a single non-resident person should succeed: Scenar
  ==... isn't true.
  
  -- 59. Failure: Run RBC with a single non-resident person should succeed: Scenar
  ==... isn't true.
  
  -- 60. Failure: Run RBC with a single non-resident person should succeed: Scenar
  identical(as.numeric(res$res_status_before[[2]]), 0) isn't true.
  
  -- 61. Failure: Run RBC with a single non-resident person should succeed: Scenar
  identical(as.numeric(res$res_status_after[[2]]), 0) isn't true.
  
  -- 62. Failure: Run RBC with a single non-resident person should succeed: Scenar
  identical(as.numeric(res$is_long_term_mig[[2]]), 0) isn't true.
  
  -- 63. Failure: Run RBC with a single non-resident person should succeed: Scenar
  ==... isn't true.
  
  -- 64. Failure: Run RBC with a single non-resident person should succeed: Scenar
  ==... isn't true.
  
  -- 65. Failure: Run RBC with a single non-resident person should succeed: Scenar
  ==... isn't true.
  
  INFO [2020-08-28 02:41:53] entering 'pre_process' :
  INFO [2020-08-28 02:41:53] leaving 'pre_process' : 
                return 1 groups of raw data.
  INFO [2020-08-28 02:41:53] entering 'resolve_data' :
  INFO [2020-08-28 02:41:53] Running without parallel
  INFO [2020-08-28 02:41:53] entering 'resolve_data, chunk =1':
                 window_size=487, 
                 threshold_year=365
  -- 66. Failure: Run RBC with a single non-resident person should succeed: Scenar
  `migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)
    7. dplyr::bind_rows
    8. base::getExportedValue(pkg, name)
    9. base::asNamespace(ns)
   10. base::getNamespace(ns)
   11. base::loadNamespace(name)
   12. base::library.dynam(lib, package, package.lib)
  
  -- 67. Failure: Run RBC with a single non-resident person should succeed: Scenar
  identical(as.numeric(res$res_status_before[[1]]), 0) isn't true.
  
  -- 68. Failure: Run RBC with a single non-resident person should succeed: Scenar
  identical(as.numeric(res$res_status_after[[1]]), 0) isn't true.
  
  -- 69. Failure: Run RBC with a single non-resident person should succeed: Scenar
  identical(as.numeric(res$is_long_term_mig[[1]]), 0) isn't true.
  
  -- 70. Failure: Run RBC with a single non-resident person should succeed: Scenar
  ==... isn't true.
  
  -- 71. Failure: Run RBC with a single non-resident person should succeed: Scenar
  ==... isn't true.
  
  -- 72. Failure: Run RBC with a single non-resident person should succeed: Scenar
  ==... isn't true.
  
  -- 73. Failure: Run RBC with a single non-resident person should succeed: Scenar
  identical(as.numeric(res$res_status_before[[2]]), 0) isn't true.
  
  -- 74. Failure: Run RBC with a single non-resident person should succeed: Scenar
  identical(as.numeric(res$res_status_after[[2]]), 0) isn't true.
  
  -- 75. Failure: Run RBC with a single non-resident person should succeed: Scenar
  identical(as.numeric(res$is_long_term_mig[[2]]), 0) isn't true.
  
  -- 76. Failure: Run RBC with a single non-resident person should succeed: Scenar
  ==... isn't true.
  
  -- 77. Failure: Run RBC with a single non-resident person should succeed: Scenar
  ==... isn't true.
  
  -- 78. Failure: Run RBC with a single non-resident person should succeed: Scenar
  ==... isn't true.
  
  INFO [2020-08-28 02:41:53] entering 'pre_process' :
  INFO [2020-08-28 02:41:53] leaving 'pre_process' : 
                return 1 groups of raw data.
  INFO [2020-08-28 02:41:53] entering 'resolve_data' :
  INFO [2020-08-28 02:41:53] Running without parallel
  INFO [2020-08-28 02:41:53] entering 'resolve_data, chunk =1':
                 window_size=487, 
                 threshold_year=365
  -- 79. Failure: Run RBC with a single non-resident person should succeed: Scenar
  `migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)
    7. dplyr::bind_rows
    8. base::getExportedValue(pkg, name)
    9. base::asNamespace(ns)
   10. base::getNamespace(ns)
   11. base::loadNamespace(name)
   12. base::library.dynam(lib, package, package.lib)
  
  -- 80. Failure: Run RBC with a single non-resident person should succeed: Scenar
  identical(as.numeric(res$res_status_before[[1]]), 0) isn't true.
  
  -- 81. Failure: Run RBC with a single non-resident person should succeed: Scenar
  identical(as.numeric(res$res_status_after[[1]]), 1) isn't true.
  
  -- 82. Failure: Run RBC with a single non-resident person should succeed: Scenar
  identical(as.numeric(res$is_long_term_mig[[1]]), 1) isn't true.
  
  -- 83. Failure: Run RBC with a single non-resident person should succeed: Scenar
  ==... isn't true.
  
  -- 84. Failure: Run RBC with a single non-resident person should succeed: Scenar
  ==... isn't true.
  
  -- 85. Failure: Run RBC with a single non-resident person should succeed: Scenar
  ==... isn't true.
  
  -- 86. Failure: Run RBC with a single non-resident person should succeed: Scenar
  identical(as.numeric(res$res_status_before[[2]]), 1) isn't true.
  
  -- 87. Failure: Run RBC with a single non-resident person should succeed: Scenar
  identical(as.numeric(res$res_status_after[[2]]), 1) isn't true.
  
  -- 88. Failure: Run RBC with a single non-resident person should succeed: Scenar
  identical(as.numeric(res$is_long_term_mig[[2]]), 0) isn't true.
  
  -- 89. Failure: Run RBC with a single non-resident person should succeed: Scenar
  ==... isn't true.
  
  -- 90. Failure: Run RBC with a single non-resident person should succeed: Scenar
  ==... isn't true.
  
  -- 91. Failure: Run RBC with a single non-resident person should succeed: Scenar
  ==... isn't true.
  
  -- 92. Failure: Run RBC with a single non-resident person should succeed: Scenar
  identical(as.numeric(res$res_status_before[[3]]), 1) isn't true.
  
  -- 93. Failure: Run RBC with a single non-resident person should succeed: Scenar
  identical(as.numeric(res$res_status_after[[3]]), 1) isn't true.
  
  -- 94. Failure: Run RBC with a single non-resident person should succeed: Scenar
  identical(as.numeric(res$is_long_term_mig[[3]]), 0) isn't true.
  
  -- 95. Failure: Run RBC with a single non-resident person should succeed: Scenar
  ==... isn't true.
  
  -- 96. Failure: Run RBC with a single non-resident person should succeed: Scenar
  ==... isn't true.
  
  -- 97. Failure: Run RBC with a single non-resident person should succeed: Scenar
  ==... isn't true.
  
  INFO [2020-08-28 02:41:53] entering 'pre_process' :
  INFO [2020-08-28 02:41:53] leaving 'pre_process' : 
                return 1 groups of raw data.
  INFO [2020-08-28 02:41:53] entering 'resolve_data' :
  INFO [2020-08-28 02:41:53] Running without parallel
  INFO [2020-08-28 02:41:53] entering 'resolve_data, chunk =1':
                 window_size=487, 
                 threshold_year=365
  -- 98. Failure: Run RBC with a single non-resident person should succeed: Scenar
  `migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)
    7. dplyr::bind_rows
    8. base::getExportedValue(pkg, name)
    9. base::asNamespace(ns)
   10. base::getNamespace(ns)
   11. base::loadNamespace(name)
   12. base::library.dynam(lib, package, package.lib)
  
  -- 99. Failure: Run RBC with a single non-resident person should succeed: Scenar
  identical(as.numeric(res$res_status_before[[1]]), 0) isn't true.
  
  -- 100. Failure: Run RBC with a single non-resident person should succeed: Scena
  identical(as.numeric(res$res_status_after[[1]]), 1) isn't true.
  
  -- 101. Failure: Run RBC with a single non-resident person should succeed: Scena
  identical(as.numeric(res$is_long_term_mig[[1]]), 1) isn't true.
  
  -- 102. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  -- 103. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  -- 104. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  -- 105. Failure: Run RBC with a single non-resident person should succeed: Scena
  identical(as.numeric(res$res_status_before[[2]]), 1) isn't true.
  
  -- 106. Failure: Run RBC with a single non-resident person should succeed: Scena
  identical(as.numeric(res$res_status_after[[2]]), 0) isn't true.
  
  -- 107. Failure: Run RBC with a single non-resident person should succeed: Scena
  identical(as.numeric(res$is_long_term_mig[[2]]), 1) isn't true.
  
  -- 108. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  -- 109. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  -- 110. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  INFO [2020-08-28 02:41:53] entering 'pre_process' :
  INFO [2020-08-28 02:41:53] leaving 'pre_process' : 
                return 1 groups of raw data.
  INFO [2020-08-28 02:41:53] entering 'resolve_data' :
  INFO [2020-08-28 02:41:53] Running without parallel
  INFO [2020-08-28 02:41:53] entering 'resolve_data, chunk =1':
                 window_size=487, 
                 threshold_year=365
  -- 111. Failure: Run RBC with a single non-resident person should succeed: Scena
  `migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)
    7. dplyr::bind_rows
    8. base::getExportedValue(pkg, name)
    9. base::asNamespace(ns)
   10. base::getNamespace(ns)
   11. base::loadNamespace(name)
   12. base::library.dynam(lib, package, package.lib)
  
  -- 112. Failure: Run RBC with a single non-resident person should succeed: Scena
  identical(as.numeric(res$res_status_before[[1]]), 0) isn't true.
  
  -- 113. Failure: Run RBC with a single non-resident person should succeed: Scena
  identical(as.numeric(res$res_status_after[[1]]), 1) isn't true.
  
  -- 114. Failure: Run RBC with a single non-resident person should succeed: Scena
  identical(as.numeric(res$is_long_term_mig[[1]]), 1) isn't true.
  
  -- 115. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  -- 116. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  -- 117. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  -- 118. Failure: Run RBC with a single non-resident person should succeed: Scena
  identical(as.numeric(res$res_status_before[[2]]), 1) isn't true.
  
  -- 119. Failure: Run RBC with a single non-resident person should succeed: Scena
  identical(as.numeric(res$res_status_after[[2]]), 1) isn't true.
  
  -- 120. Failure: Run RBC with a single non-resident person should succeed: Scena
  identical(as.numeric(res$is_long_term_mig[[2]]), 0) isn't true.
  
  -- 121. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  -- 122. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  -- 123. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  -- 124. Failure: Run RBC with a single non-resident person should succeed: Scena
  identical(as.numeric(res$res_status_before[[3]]), 1) isn't true.
  
  -- 125. Failure: Run RBC with a single non-resident person should succeed: Scena
  identical(as.numeric(res$res_status_after[[3]]), 1) isn't true.
  
  -- 126. Failure: Run RBC with a single non-resident person should succeed: Scena
  identical(as.numeric(res$is_long_term_mig[[3]]), 0) isn't true.
  
  -- 127. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  -- 128. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  -- 129. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  -- 130. Failure: Run RBC with a single non-resident person should succeed: Scena
  identical(as.numeric(res$res_status_before[[4]]), 1) isn't true.
  
  -- 131. Failure: Run RBC with a single non-resident person should succeed: Scena
  identical(as.numeric(res$res_status_after[[4]]), 1) isn't true.
  
  -- 132. Failure: Run RBC with a single non-resident person should succeed: Scena
  identical(as.numeric(res$is_long_term_mig[[4]]), 0) isn't true.
  
  -- 133. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  -- 134. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  -- 135. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  -- 136. Failure: Run RBC with a single non-resident person should succeed: Scena
  identical(as.numeric(res$res_status_before[[5]]), 1) isn't true.
  
  -- 137. Failure: Run RBC with a single non-resident person should succeed: Scena
  identical(as.numeric(res$res_status_after[[5]]), 1) isn't true.
  
  -- 138. Failure: Run RBC with a single non-resident person should succeed: Scena
  identical(as.numeric(res$is_long_term_mig[[5]]), 0) isn't true.
  
  -- 139. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  -- 140. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  -- 141. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  INFO [2020-08-28 02:41:53] entering 'pre_process' :
  INFO [2020-08-28 02:41:53] leaving 'pre_process' : 
                return 1 groups of raw data.
  INFO [2020-08-28 02:41:53] entering 'resolve_data' :
  INFO [2020-08-28 02:41:53] Running without parallel
  INFO [2020-08-28 02:41:53] entering 'resolve_data, chunk =1':
                 window_size=487, 
                 threshold_year=365
  -- 142. Failure: Run RBC with a single non-resident person should succeed: Scena
  `migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)
    7. dplyr::bind_rows
    8. base::getExportedValue(pkg, name)
    9. base::asNamespace(ns)
   10. base::getNamespace(ns)
   11. base::loadNamespace(name)
   12. base::library.dynam(lib, package, package.lib)
  
  -- 143. Failure: Run RBC with a single non-resident person should succeed: Scena
  identical(as.numeric(res$res_status_before[[1]]), 0) isn't true.
  
  -- 144. Failure: Run RBC with a single non-resident person should succeed: Scena
  identical(as.numeric(res$res_status_after[[1]]), 0) isn't true.
  
  -- 145. Failure: Run RBC with a single non-resident person should succeed: Scena
  identical(as.numeric(res$is_long_term_mig[[1]]), 0) isn't true.
  
  -- 146. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  -- 147. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  -- 148. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  -- 149. Failure: Run RBC with a single non-resident person should succeed: Scena
  identical(as.numeric(res$res_status_before[[2]]), 0) isn't true.
  
  -- 150. Failure: Run RBC with a single non-resident person should succeed: Scena
  identical(as.numeric(res$res_status_after[[2]]), 0) isn't true.
  
  -- 151. Failure: Run RBC with a single non-resident person should succeed: Scena
  identical(as.numeric(res$is_long_term_mig[[2]]), 0) isn't true.
  
  -- 152. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  -- 153. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  -- 154. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  -- 155. Failure: Run RBC with a single non-resident person should succeed: Scena
  identical(as.numeric(res$res_status_before[[3]]), 0) isn't true.
  
  -- 156. Failure: Run RBC with a single non-resident person should succeed: Scena
  identical(as.numeric(res$res_status_after[[3]]), 0) isn't true.
  
  -- 157. Failure: Run RBC with a single non-resident person should succeed: Scena
  identical(as.numeric(res$is_long_term_mig[[3]]), 0) isn't true.
  
  -- 158. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  -- 159. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  -- 160. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  -- 161. Failure: Run RBC with a single non-resident person should succeed: Scena
  identical(as.numeric(res$res_status_before[[4]]), 0) isn't true.
  
  -- 162. Failure: Run RBC with a single non-resident person should succeed: Scena
  identical(as.numeric(res$res_status_after[[4]]), 0) isn't true.
  
  -- 163. Failure: Run RBC with a single non-resident person should succeed: Scena
  identical(as.numeric(res$is_long_term_mig[[4]]), 0) isn't true.
  
  -- 164. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  -- 165. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  -- 166. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  INFO [2020-08-28 02:41:53] entering 'pre_process' :
  INFO [2020-08-28 02:41:53] leaving 'pre_process' : 
                return 1 groups of raw data.
  INFO [2020-08-28 02:41:53] entering 'resolve_data' :
  INFO [2020-08-28 02:41:53] Running without parallel
  INFO [2020-08-28 02:41:53] entering 'resolve_data, chunk =1':
                 window_size=487, 
                 threshold_year=365
  -- 167. Failure: Run RBC with a single non-resident person should succeed: Scena
  `migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)
    7. dplyr::bind_rows
    8. base::getExportedValue(pkg, name)
    9. base::asNamespace(ns)
   10. base::getNamespace(ns)
   11. base::loadNamespace(name)
   12. base::library.dynam(lib, package, package.lib)
  
  -- 168. Failure: Run RBC with a single non-resident person should succeed: Scena
  identical(as.numeric(res$res_status_before[[1]]), 0) isn't true.
  
  -- 169. Failure: Run RBC with a single non-resident person should succeed: Scena
  identical(as.numeric(res$res_status_after[[1]]), 1) isn't true.
  
  -- 170. Failure: Run RBC with a single non-resident person should succeed: Scena
  identical(as.numeric(res$is_long_term_mig[[1]]), 1) isn't true.
  
  -- 171. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  -- 172. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  -- 173. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  -- 174. Failure: Run RBC with a single non-resident person should succeed: Scena
  identical(as.numeric(res$res_status_before[[2]]), 1) isn't true.
  
  -- 175. Failure: Run RBC with a single non-resident person should succeed: Scena
  identical(as.numeric(res$res_status_after[[2]]), 1) isn't true.
  
  -- 176. Failure: Run RBC with a single non-resident person should succeed: Scena
  identical(as.numeric(res$is_long_term_mig[[2]]), 0) isn't true.
  
  -- 177. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  -- 178. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  -- 179. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  -- 180. Failure: Run RBC with a single non-resident person should succeed: Scena
  identical(as.numeric(res$res_status_before[[3]]), 1) isn't true.
  
  -- 181. Failure: Run RBC with a single non-resident person should succeed: Scena
  identical(as.numeric(res$res_status_after[[3]]), 1) isn't true.
  
  -- 182. Failure: Run RBC with a single non-resident person should succeed: Scena
  identical(as.numeric(res$is_long_term_mig[[3]]), 0) isn't true.
  
  -- 183. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  -- 184. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  -- 185. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  -- 186. Failure: Run RBC with a single non-resident person should succeed: Scena
  identical(as.numeric(res$res_status_before[[4]]), 1) isn't true.
  
  -- 187. Failure: Run RBC with a single non-resident person should succeed: Scena
  identical(as.numeric(res$res_status_after[[4]]), 1) isn't true.
  
  -- 188. Failure: Run RBC with a single non-resident person should succeed: Scena
  identical(as.numeric(res$is_long_term_mig[[4]]), 0) isn't true.
  
  -- 189. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  -- 190. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  -- 191. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  -- 192. Failure: Run RBC with a single non-resident person should succeed: Scena
  identical(as.numeric(res$res_status_before[[5]]), 1) isn't true.
  
  -- 193. Failure: Run RBC with a single non-resident person should succeed: Scena
  identical(as.numeric(res$res_status_after[[5]]), 1) isn't true.
  
  -- 194. Failure: Run RBC with a single non-resident person should succeed: Scena
  identical(as.numeric(res$is_long_term_mig[[5]]), 0) isn't true.
  
  -- 195. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  -- 196. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  -- 197. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  -- 198. Failure: Run RBC with a single non-resident person should succeed: Scena
  ==... isn't true.
  
  INFO [2020-08-28 02:41:54] entering 'pre_process' :
  INFO [2020-08-28 02:41:54] leaving 'pre_process' : 
                return 1 groups of raw data.
  INFO [2020-08-28 02:41:54] entering 'resolve_data' :
  INFO [2020-08-28 02:41:54] Running without parallel
  INFO [2020-08-28 02:41:54] entering 'resolve_data, chunk =1':
                 window_size=487, 
                 threshold_year=365
  -- 199. Failure: Run RBC with a single resident person should succeed: Scenario:
  `migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)
    7. dplyr::bind_rows
    8. base::getExportedValue(pkg, name)
    9. base::asNamespace(ns)
   10. base::getNamespace(ns)
   11. base::loadNamespace(name)
   12. base::library.dynam(lib, package, package.lib)
  
  -- 200. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_before[[1]]), 1) isn't true.
  
  -- 201. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_after[[1]]), 1) isn't true.
  
  -- 202. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$is_long_term_mig[[1]]), 0) isn't true.
  
  -- 203. Failure: Run RBC with a single resident person should succeed: Scenario:
  days_RB == 0 isn't true.
  
  -- 204. Failure: Run RBC with a single resident person should succeed: Scenario:
  days_RA == 0 isn't true.
  
  -- 205. Failure: Run RBC with a single resident person should succeed: Scenario:
  days_LTM == 0 isn't true.
  
  INFO [2020-08-28 02:41:54] entering 'pre_process' :
  INFO [2020-08-28 02:41:54] leaving 'pre_process' : 
                return 1 groups of raw data.
  INFO [2020-08-28 02:41:54] entering 'resolve_data' :
  INFO [2020-08-28 02:41:54] Running without parallel
  INFO [2020-08-28 02:41:54] entering 'resolve_data, chunk =1':
                 window_size=487, 
                 threshold_year=365
  -- 206. Failure: Run RBC with a single resident person should succeed: Scenario:
  `migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)
    7. dplyr::bind_rows
    8. base::getExportedValue(pkg, name)
    9. base::asNamespace(ns)
   10. base::getNamespace(ns)
   11. base::loadNamespace(name)
   12. base::library.dynam(lib, package, package.lib)
  
  -- 207. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_before[[1]]), 1) isn't true.
  
  -- 208. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_after[[1]]), 0) isn't true.
  
  -- 209. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$is_long_term_mig[[1]]), 1) isn't true.
  
  -- 210. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 211. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 212. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  INFO [2020-08-28 02:41:54] entering 'pre_process' :
  INFO [2020-08-28 02:41:54] leaving 'pre_process' : 
                return 1 groups of raw data.
  INFO [2020-08-28 02:41:54] entering 'resolve_data' :
  INFO [2020-08-28 02:41:54] Running without parallel
  INFO [2020-08-28 02:41:54] entering 'resolve_data, chunk =1':
                 window_size=487, 
                 threshold_year=365
  -- 213. Failure: Run RBC with a single resident person should succeed: Scenario:
  `migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)
    7. dplyr::bind_rows
    8. base::getExportedValue(pkg, name)
    9. base::asNamespace(ns)
   10. base::getNamespace(ns)
   11. base::loadNamespace(name)
   12. base::library.dynam(lib, package, package.lib)
  
  -- 214. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_before[[1]]), 1) isn't true.
  
  -- 215. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_after[[1]]), 1) isn't true.
  
  -- 216. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$is_long_term_mig[[1]]), 0) isn't true.
  
  -- 217. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 218. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 219. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 220. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_before[[2]]), 1) isn't true.
  
  -- 221. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_after[[2]]), 1) isn't true.
  
  -- 222. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$is_long_term_mig[[2]]), 0) isn't true.
  
  -- 223. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 224. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 225. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  INFO [2020-08-28 02:41:54] entering 'pre_process' :
  INFO [2020-08-28 02:41:54] leaving 'pre_process' : 
                return 1 groups of raw data.
  INFO [2020-08-28 02:41:54] entering 'resolve_data' :
  INFO [2020-08-28 02:41:54] Running without parallel
  INFO [2020-08-28 02:41:54] entering 'resolve_data, chunk =1':
                 window_size=487, 
                 threshold_year=365
  -- 226. Failure: Run RBC with a single resident person should succeed: Scenario:
  `migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)
    7. dplyr::bind_rows
    8. base::getExportedValue(pkg, name)
    9. base::asNamespace(ns)
   10. base::getNamespace(ns)
   11. base::loadNamespace(name)
   12. base::library.dynam(lib, package, package.lib)
  
  -- 227. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_before[[1]]), 1) isn't true.
  
  -- 228. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_after[[1]]), 1) isn't true.
  
  -- 229. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$is_long_term_mig[[1]]), 0) isn't true.
  
  -- 230. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 231. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 232. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 233. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_before[[2]]), 1) isn't true.
  
  -- 234. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_after[[2]]), 1) isn't true.
  
  -- 235. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$is_long_term_mig[[2]]), 0) isn't true.
  
  -- 236. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 237. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 238. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 239. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_before[[3]]), 1) isn't true.
  
  -- 240. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_after[[3]]), 1) isn't true.
  
  -- 241. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$is_long_term_mig[[3]]), 0) isn't true.
  
  -- 242. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 243. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 244. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 245. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_before[[4]]), 1) isn't true.
  
  -- 246. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_after[[4]]), 1) isn't true.
  
  -- 247. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$is_long_term_mig[[4]]), 0) isn't true.
  
  -- 248. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 249. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 250. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  INFO [2020-08-28 02:41:54] entering 'pre_process' :
  INFO [2020-08-28 02:41:54] leaving 'pre_process' : 
                return 1 groups of raw data.
  INFO [2020-08-28 02:41:54] entering 'resolve_data' :
  INFO [2020-08-28 02:41:54] Running without parallel
  INFO [2020-08-28 02:41:54] entering 'resolve_data, chunk =1':
                 window_size=487, 
                 threshold_year=365
  -- 251. Failure: Run RBC with a single resident person should succeed: Scenario:
  `migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)
    7. dplyr::bind_rows
    8. base::getExportedValue(pkg, name)
    9. base::asNamespace(ns)
   10. base::getNamespace(ns)
   11. base::loadNamespace(name)
   12. base::library.dynam(lib, package, package.lib)
  
  -- 252. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_before[[1]]), 1) isn't true.
  
  -- 253. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_after[[1]]), 1) isn't true.
  
  -- 254. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$is_long_term_mig[[1]]), 0) isn't true.
  
  -- 255. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 256. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 257. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 258. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_before[[2]]), 1) isn't true.
  
  -- 259. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_after[[2]]), 1) isn't true.
  
  -- 260. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$is_long_term_mig[[2]]), 0) isn't true.
  
  -- 261. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 262. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 263. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  INFO [2020-08-28 02:41:54] entering 'pre_process' :
  INFO [2020-08-28 02:41:54] leaving 'pre_process' : 
                return 1 groups of raw data.
  INFO [2020-08-28 02:41:54] entering 'resolve_data' :
  INFO [2020-08-28 02:41:54] Running without parallel
  INFO [2020-08-28 02:41:54] entering 'resolve_data, chunk =1':
                 window_size=487, 
                 threshold_year=365
  -- 264. Failure: Run RBC with a single resident person should succeed: Scenario:
  `migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)
    7. dplyr::bind_rows
    8. base::getExportedValue(pkg, name)
    9. base::asNamespace(ns)
   10. base::getNamespace(ns)
   11. base::loadNamespace(name)
   12. base::library.dynam(lib, package, package.lib)
  
  -- 265. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_before[[1]]), 1) isn't true.
  
  -- 266. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_after[[1]]), 1) isn't true.
  
  -- 267. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$is_long_term_mig[[1]]), 0) isn't true.
  
  -- 268. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 269. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 270. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 271. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_before[[2]]), 1) isn't true.
  
  -- 272. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_after[[2]]), 1) isn't true.
  
  -- 273. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$is_long_term_mig[[2]]), 0) isn't true.
  
  -- 274. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 275. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 276. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  INFO [2020-08-28 02:41:54] entering 'pre_process' :
  INFO [2020-08-28 02:41:54] leaving 'pre_process' : 
                return 1 groups of raw data.
  INFO [2020-08-28 02:41:54] entering 'resolve_data' :
  INFO [2020-08-28 02:41:54] Running without parallel
  INFO [2020-08-28 02:41:54] entering 'resolve_data, chunk =1':
                 window_size=487, 
                 threshold_year=365
  -- 277. Failure: Run RBC with a single resident person should succeed: Scenario:
  `migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)
    7. dplyr::bind_rows
    8. base::getExportedValue(pkg, name)
    9. base::asNamespace(ns)
   10. base::getNamespace(ns)
   11. base::loadNamespace(name)
   12. base::library.dynam(lib, package, package.lib)
  
  -- 278. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_before[[1]]), 1) isn't true.
  
  -- 279. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_after[[1]]), 0) isn't true.
  
  -- 280. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$is_long_term_mig[[1]]), 1) isn't true.
  
  -- 281. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 282. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 283. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 284. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_before[[2]]), 0) isn't true.
  
  -- 285. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_after[[2]]), 0) isn't true.
  
  -- 286. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$is_long_term_mig[[2]]), 0) isn't true.
  
  -- 287. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 288. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 289. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 290. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_before[[3]]), 0) isn't true.
  
  -- 291. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_after[[3]]), 0) isn't true.
  
  -- 292. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$is_long_term_mig[[3]]), 0) isn't true.
  
  -- 293. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 294. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 295. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  INFO [2020-08-28 02:41:55] entering 'pre_process' :
  INFO [2020-08-28 02:41:55] leaving 'pre_process' : 
                return 1 groups of raw data.
  INFO [2020-08-28 02:41:55] entering 'resolve_data' :
  INFO [2020-08-28 02:41:55] Running without parallel
  INFO [2020-08-28 02:41:55] entering 'resolve_data, chunk =1':
                 window_size=487, 
                 threshold_year=365
  -- 296. Failure: Run RBC with a single resident person should succeed: Scenario:
  `migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)
    7. dplyr::bind_rows
    8. base::getExportedValue(pkg, name)
    9. base::asNamespace(ns)
   10. base::getNamespace(ns)
   11. base::loadNamespace(name)
   12. base::library.dynam(lib, package, package.lib)
  
  -- 297. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_before[[1]]), 1) isn't true.
  
  -- 298. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_after[[1]]), 0) isn't true.
  
  -- 299. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$is_long_term_mig[[1]]), 1) isn't true.
  
  -- 300. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 301. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 302. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 303. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_before[[2]]), 0) isn't true.
  
  -- 304. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_after[[2]]), 1) isn't true.
  
  -- 305. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$is_long_term_mig[[2]]), 1) isn't true.
  
  -- 306. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 307. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 308. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  INFO [2020-08-28 02:41:55] entering 'pre_process' :
  INFO [2020-08-28 02:41:55] leaving 'pre_process' : 
                return 1 groups of raw data.
  INFO [2020-08-28 02:41:55] entering 'resolve_data' :
  INFO [2020-08-28 02:41:55] Running without parallel
  INFO [2020-08-28 02:41:55] entering 'resolve_data, chunk =1':
                 window_size=487, 
                 threshold_year=365
  -- 309. Failure: Run RBC with a single resident person should succeed: Scenario:
  `migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)
    7. dplyr::bind_rows
    8. base::getExportedValue(pkg, name)
    9. base::asNamespace(ns)
   10. base::getNamespace(ns)
   11. base::loadNamespace(name)
   12. base::library.dynam(lib, package, package.lib)
  
  -- 310. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_before[[1]]), 1) isn't true.
  
  -- 311. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_after[[1]]), 0) isn't true.
  
  -- 312. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$is_long_term_mig[[1]]), 1) isn't true.
  
  -- 313. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 314. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 315. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 316. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_before[[2]]), 0) isn't true.
  
  -- 317. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_after[[2]]), 0) isn't true.
  
  -- 318. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$is_long_term_mig[[2]]), 0) isn't true.
  
  -- 319. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 320. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 321. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 322. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_before[[3]]), 0) isn't true.
  
  -- 323. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_after[[3]]), 0) isn't true.
  
  -- 324. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$is_long_term_mig[[3]]), 0) isn't true.
  
  -- 325. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 326. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 327. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 328. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_before[[4]]), 0) isn't true.
  
  -- 329. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_after[[4]]), 0) isn't true.
  
  -- 330. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$is_long_term_mig[[4]]), 0) isn't true.
  
  -- 331. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 332. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 333. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 334. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_before[[5]]), 0) isn't true.
  
  -- 335. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_after[[5]]), 0) isn't true.
  
  -- 336. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$is_long_term_mig[[5]]), 0) isn't true.
  
  -- 337. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 338. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 339. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  INFO [2020-08-28 02:41:55] entering 'pre_process' :
  INFO [2020-08-28 02:41:55] leaving 'pre_process' : 
                return 1 groups of raw data.
  INFO [2020-08-28 02:41:55] entering 'resolve_data' :
  INFO [2020-08-28 02:41:55] Running without parallel
  INFO [2020-08-28 02:41:55] entering 'resolve_data, chunk =1':
                 window_size=487, 
                 threshold_year=365
  -- 340. Failure: Run RBC with a single resident person should succeed: Scenario:
  `migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)
    7. dplyr::bind_rows
    8. base::getExportedValue(pkg, name)
    9. base::asNamespace(ns)
   10. base::getNamespace(ns)
   11. base::loadNamespace(name)
   12. base::library.dynam(lib, package, package.lib)
  
  -- 341. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_before[[1]]), 1) isn't true.
  
  -- 342. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_after[[1]]), 1) isn't true.
  
  -- 343. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$is_long_term_mig[[1]]), 0) isn't true.
  
  -- 344. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 345. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 346. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 347. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_before[[2]]), 1) isn't true.
  
  -- 348. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_after[[2]]), 1) isn't true.
  
  -- 349. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$is_long_term_mig[[2]]), 0) isn't true.
  
  -- 350. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 351. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 352. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 353. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_before[[3]]), 1) isn't true.
  
  -- 354. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_after[[3]]), 1) isn't true.
  
  -- 355. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$is_long_term_mig[[3]]), 0) isn't true.
  
  -- 356. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 357. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 358. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 359. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_before[[4]]), 1) isn't true.
  
  -- 360. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_after[[4]]), 1) isn't true.
  
  -- 361. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$is_long_term_mig[[4]]), 0) isn't true.
  
  -- 362. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 363. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 364. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  INFO [2020-08-28 02:41:55] entering 'pre_process' :
  INFO [2020-08-28 02:41:55] leaving 'pre_process' : 
                return 1 groups of raw data.
  INFO [2020-08-28 02:41:55] entering 'resolve_data' :
  INFO [2020-08-28 02:41:55] Running without parallel
  INFO [2020-08-28 02:41:55] entering 'resolve_data, chunk =1':
                 window_size=487, 
                 threshold_year=365
  -- 365. Failure: Run RBC with a single resident person should succeed: Scenario:
  `migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)
    7. dplyr::bind_rows
    8. base::getExportedValue(pkg, name)
    9. base::asNamespace(ns)
   10. base::getNamespace(ns)
   11. base::loadNamespace(name)
   12. base::library.dynam(lib, package, package.lib)
  
  -- 366. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_before[[1]]), 1) isn't true.
  
  -- 367. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_after[[1]]), 0) isn't true.
  
  -- 368. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$is_long_term_mig[[1]]), 1) isn't true.
  
  -- 369. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 370. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 371. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 372. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_before[[2]]), 0) isn't true.
  
  -- 373. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_after[[2]]), 0) isn't true.
  
  -- 374. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$is_long_term_mig[[2]]), 0) isn't true.
  
  -- 375. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 376. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 377. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 378. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_before[[3]]), 0) isn't true.
  
  -- 379. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_after[[3]]), 0) isn't true.
  
  -- 380. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$is_long_term_mig[[3]]), 0) isn't true.
  
  -- 381. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 382. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 383. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 384. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_before[[4]]), 0) isn't true.
  
  -- 385. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_after[[4]]), 0) isn't true.
  
  -- 386. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$is_long_term_mig[[4]]), 0) isn't true.
  
  -- 387. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 388. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 389. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 390. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_before[[5]]), 0) isn't true.
  
  -- 391. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$res_status_after[[5]]), 0) isn't true.
  
  -- 392. Failure: Run RBC with a single resident person should succeed: Scenario:
  identical(as.numeric(res$is_long_term_mig[[5]]), 0) isn't true.
  
  -- 393. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 394. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 395. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  -- 396. Failure: Run RBC with a single resident person should succeed: Scenario:
  ==... isn't true.
  
  INFO [2020-08-28 02:41:55] entering 'pre_process' :
  INFO [2020-08-28 02:41:55] entering 'pre_process' :
  INFO [2020-08-28 02:41:55] leaving 'pre_process' : 
                return 1 groups of raw data.
  INFO [2020-08-28 02:41:55] entering 'resolve_data' :
  INFO [2020-08-28 02:41:55] Running without parallel
  INFO [2020-08-28 02:41:55] entering 'resolve_data, chunk =1':
                 window_size=487, 
                 threshold_year=365
  -- 397. Failure: Run RBC with a single resident person should fail: A person wit
  `migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)
    7. dplyr::bind_rows
    8. base::getExportedValue(pkg, name)
    9. base::asNamespace(ns)
   10. base::getNamespace(ns)
   11. base::loadNamespace(name)
   12. base::library.dynam(lib, package, package.lib)
  
  -- 398. Failure: Run RBC with a single resident person should fail: A person wit
  nrow(res$journeys) not equal to 0.
  target is NULL, current is numeric
  
  -- 399. Failure: Run RBC with a single resident person should fail: A person wit
  nrow(res$error_data) not equal to 1.
  target is NULL, current is numeric
  
  -- 400. Failure: Run RBC with a single resident person should fail: A person wit
  `is.null(res$error_data["error_code"])` did not throw an error.
  
  -- 401. Failure: Run RBC with a single resident person should fail: A person wit
  `is.null(res$error_data["error_message"])` did not throw an error.
  
  INFO [2020-08-28 02:41:55] entering 'resolve_data' :
  INFO [2020-08-28 02:41:55] Running without parallel
  INFO [2020-08-28 02:41:55] entering 'resolve_data, chunk =1':
                 window_size=487, 
                 threshold_year=365
  -- 402. Failure: Run RBC with a single resident person should fail: A person wit
  `migrbc::resolve_data(...)` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::resolve_data(...)
    7. dplyr::bind_rows
    8. base::getExportedValue(pkg, name)
    9. base::asNamespace(ns)
   10. base::getNamespace(ns)
   11. base::loadNamespace(name)
   12. base::library.dynam(lib, package, package.lib)
  
  -- 403. Failure: Run RBC with a single resident person should fail: A person wit
  nrow(res$journeys) not equal to 0.
  target is NULL, current is numeric
  
  -- 404. Failure: Run RBC with a single resident person should fail: A person wit
  nrow(res$error_data) not equal to 1.
  target is NULL, current is numeric
  
  -- 405. Failure: Run RBC with a single resident person should fail: A person wit
  !is.null(res$error_data["error_code"]) isn't true.
  
  -- 406. Failure: Run RBC with a single resident person should fail: A person wit
  !is.null(res$error_data["error_message"]) isn't true.
  
  -- 407. Failure: Run RBC with a single resident person should fail: A person wit
  res$error_data[1, "days_to_next_crossing"] == 487 isn't true.
  
  INFO [2020-08-28 02:41:56] entering 'pre_process' :
  INFO [2020-08-28 02:41:56] leaving 'pre_process' : 
                return 1 groups of raw data.
  INFO [2020-08-28 02:41:56] entering 'resolve_data' :
  INFO [2020-08-28 02:41:56] Running without parallel
  INFO [2020-08-28 02:41:56] entering 'resolve_data, chunk =1':
                 window_size=487, 
                 threshold_year=365
  -- 408. Failure: Run RBC with a single resident person should fail: A person wit
  `migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)
    7. dplyr::bind_rows
    8. base::getExportedValue(pkg, name)
    9. base::asNamespace(ns)
   10. base::getNamespace(ns)
   11. base::loadNamespace(name)
   12. base::library.dynam(lib, package, package.lib)
  
  INFO [2020-08-28 02:41:56] entering 'pre_process' :
  INFO [2020-08-28 02:41:56] leaving 'pre_process' : 
                return 1 groups of raw data.
  INFO [2020-08-28 02:41:56] entering 'resolve_data' :
  INFO [2020-08-28 02:41:56] Running without parallel
  INFO [2020-08-28 02:41:56] entering 'resolve_data, chunk =1':
                 window_size=487, 
                 threshold_year=365
  -- 409. Failure: Run RBC with a single resident person should fail: A person wit
  `migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)
    7. dplyr::bind_rows
    8. base::getExportedValue(pkg, name)
    9. base::asNamespace(ns)
   10. base::getNamespace(ns)
   11. base::loadNamespace(name)
   12. base::library.dynam(lib, package, package.lib)
  
  INFO [2020-08-28 02:41:56] entering 'pre_process' :
  INFO [2020-08-28 02:41:56] leaving 'pre_process' : 
                return 1 groups of raw data.
  INFO [2020-08-28 02:41:56] entering 'resolve_data' :
  INFO [2020-08-28 02:41:56] Running without parallel
  INFO [2020-08-28 02:41:56] entering 'resolve_data, chunk =1':
                 window_size=487, 
                 threshold_year=365
  -- 410. Failure: Run RBC with a single resident person should fail: A person wit
  `migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)
    7. dplyr::bind_rows
    8. base::getExportedValue(pkg, name)
    9. base::asNamespace(ns)
   10. base::getNamespace(ns)
   11. base::loadNamespace(name)
   12. base::library.dynam(lib, package, package.lib)
  
  INFO [2020-08-28 02:41:56] entering 'pre_process' :
  INFO [2020-08-28 02:41:56] leaving 'pre_process' : 
                return 1 groups of raw data.
  INFO [2020-08-28 02:41:56] entering 'resolve_data' :
  INFO [2020-08-28 02:41:56] Running without parallel
  INFO [2020-08-28 02:41:56] entering 'resolve_data, chunk =1':
                 window_size=487, 
                 threshold_year=365
  -- 411. Failure: Run RBC with a single resident person should fail: A person wit
  `migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)
    7. dplyr::bind_rows
    8. base::getExportedValue(pkg, name)
    9. base::asNamespace(ns)
   10. base::getNamespace(ns)
   11. base::loadNamespace(name)
   12. base::library.dynam(lib, package, package.lib)
  
  INFO [2020-08-28 02:41:56] entering 'pre_process' :
  INFO [2020-08-28 02:41:56] leaving 'pre_process' : 
                return 1 groups of raw data.
  INFO [2020-08-28 02:41:56] entering 'resolve_data' :
  INFO [2020-08-28 02:41:56] Running without parallel
  INFO [2020-08-28 02:41:56] entering 'resolve_data, chunk =1':
                 window_size=487, 
                 threshold_year=365
  -- 412. Failure: Run RBC with a single resident person should fail: A person wit
  `migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)
    7. dplyr::bind_rows
    8. base::getExportedValue(pkg, name)
    9. base::asNamespace(ns)
   10. base::getNamespace(ns)
   11. base::loadNamespace(name)
   12. base::library.dynam(lib, package, package.lib)
  
  INFO [2020-08-28 02:41:56] entering 'pre_process' :
  INFO [2020-08-28 02:41:56] leaving 'pre_process' : 
                return 1 groups of raw data.
  INFO [2020-08-28 02:41:56] entering 'resolve_data' :
  INFO [2020-08-28 02:41:56] Running without parallel
  INFO [2020-08-28 02:41:56] entering 'resolve_data, chunk =1':
                 window_size=487, 
                 threshold_year=365
  -- 413. Failure: Run RBC with a single resident person should fail: A person wit
  `migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)
    7. dplyr::bind_rows
    8. base::getExportedValue(pkg, name)
    9. base::asNamespace(ns)
   10. base::getNamespace(ns)
   11. base::loadNamespace(name)
   12. base::library.dynam(lib, package, package.lib)
  
  -- 414. Failure: Run RBC with a single resident person should fail: A person wit
  nrow(res$journeys) not equal to 0.
  target is NULL, current is numeric
  
  -- 415. Failure: Run RBC with a single resident person should fail: A person wit
  nrow(res$error_data) not equal to 2.
  target is NULL, current is numeric
  
  INFO [2020-08-28 02:41:56] entering 'pre_process' :
  INFO [2020-08-28 02:41:56] leaving 'pre_process' : 
                return 1 groups of raw data.
  INFO [2020-08-28 02:41:56] entering 'resolve_data' :
  INFO [2020-08-28 02:41:56] Running without parallel
  INFO [2020-08-28 02:41:56] entering 'resolve_data, chunk =1':
                 window_size=487, 
                 threshold_year=365
  -- 416. Failure: Run RBC with a single resident person should fail: A person wit
  `migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)
    7. dplyr::bind_rows
    8. base::getExportedValue(pkg, name)
    9. base::asNamespace(ns)
   10. base::getNamespace(ns)
   11. base::loadNamespace(name)
   12. base::library.dynam(lib, package, package.lib)
  
  -- 417. Failure: Run RBC with a single resident person should fail: A person wit
  nrow(res$journeys) not equal to 0.
  target is NULL, current is numeric
  
  -- 418. Failure: Run RBC with a single resident person should fail: A person wit
  nrow(res$error_data) not equal to 2.
  target is NULL, current is numeric
  
  -- 419. Failure: Run RBC with a single resident person should fail: A person wit
  ==... isn't true.
  
  INFO [2020-08-28 02:41:56] entering 'pre_process' :
  INFO [2020-08-28 02:41:56] leaving 'pre_process' : 
                return 1 groups of raw data.
  INFO [2020-08-28 02:41:56] entering 'resolve_data' :
  INFO [2020-08-28 02:41:56] Running without parallel
  INFO [2020-08-28 02:41:56] entering 'resolve_data, chunk =1':
                 window_size=487, 
                 threshold_year=365
  -- 420. Failure: Run RBC with a single resident person should fail: A person wit
  `migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)
    7. dplyr::bind_rows
    8. base::getExportedValue(pkg, name)
    9. base::asNamespace(ns)
   10. base::getNamespace(ns)
   11. base::loadNamespace(name)
   12. base::library.dynam(lib, package, package.lib)
  
  -- 421. Failure: Run RBC with a single resident person should fail: A person wit
  nrow(res$journeys) not equal to 0.
  target is NULL, current is numeric
  
  -- 422. Failure: Run RBC with a single resident person should fail: A person wit
  nrow(res$error_data) not equal to 2.
  target is NULL, current is numeric
  
  -- 423. Failure: Run RBC with a single resident person should fail: A person wit
  ==... isn't true.
  
  INFO [2020-08-28 02:41:56] entering 'resolve_data' :
  INFO [2020-08-28 02:41:56] entering 'resolve_data' :
  INFO [2020-08-28 02:41:56] entering 'resolve_data' :
  INFO [2020-08-28 02:41:56] entering 'resolve_data_with_error' :
  -- 424. Failure: Test exceptions: Scenario 6: resolve custom error (@test-RBC_al
  `... <- NULL` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::resolve_data_with_error(...)
    8. base::with.default(...)
    9. [ base::eval(...) ] with 1 more call
   11. dplyr::filter
   12. base::getExportedValue(pkg, name)
   13. base::asNamespace(ns)
   14. base::getNamespace(ns)
   15. base::loadNamespace(name)
   16. base::library.dynam(lib, package, package.lib)
  
  -- 425. Error: Test exceptions: Scenario 6: resolve custom error (@test-RBC_algo
  object 'res' not found
  Backtrace:
   1. testthat::expect_true(res[1, "error_code"] == 99)
   2. testthat::quasi_label(enquo(object), label, arg = "object")
   3. rlang::eval_bare(expr, quo_get_env(quo))
  
  INFO [2020-08-28 02:41:57] entering 'pre_process' :
  INFO [2020-08-28 02:41:57] leaving 'pre_process' : 
                return 1 groups of raw data.
  INFO [2020-08-28 02:41:57] entering 'resolve_data' :
  INFO [2020-08-28 02:41:57] Running without parallel
  INFO [2020-08-28 02:41:57] entering 'resolve_data, chunk =1':
                 window_size=487, 
                 threshold_year=365
  -- 426. Failure: Run RBC with a single person should succeed: Scenario 1: with I
  `migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)
    7. dplyr::bind_rows
    8. base::getExportedValue(pkg, name)
    9. base::asNamespace(ns)
   10. base::getNamespace(ns)
   11. base::loadNamespace(name)
   12. base::library.dynam(lib, package, package.lib)
  
  -- 427. Failure: Run RBC with a single person should succeed: Scenario 1: with I
  identical(as.numeric(res$res_status_before[[1]]), 1) isn't true.
  
  -- 428. Failure: Run RBC with a single person should succeed: Scenario 1: with I
  identical(as.numeric(res$res_status_after[[1]]), 0) isn't true.
  
  -- 429. Failure: Run RBC with a single person should succeed: Scenario 1: with I
  identical(as.numeric(res$is_long_term_mig[[1]]), 1) isn't true.
  
  -- 430. Failure: Run RBC with a single person should succeed: Scenario 1: with I
  ==... isn't true.
  
  -- 431. Failure: Run RBC with a single person should succeed: Scenario 1: with I
  ==... isn't true.
  
  -- 432. Failure: Run RBC with a single person should succeed: Scenario 1: with I
  ==... isn't true.
  
  -- 433. Failure: Run RBC with a single person should succeed: Scenario 1: with I
  identical(as.numeric(res$res_status_before[[2]]), 0) isn't true.
  
  -- 434. Failure: Run RBC with a single person should succeed: Scenario 1: with I
  identical(as.numeric(res$res_status_after[[2]]), 0) isn't true.
  
  -- 435. Failure: Run RBC with a single person should succeed: Scenario 1: with I
  identical(as.numeric(res$is_long_term_mig[[2]]), 0) isn't true.
  
  -- 436. Failure: Run RBC with a single person should succeed: Scenario 1: with I
  ==... isn't true.
  
  -- 437. Failure: Run RBC with a single person should succeed: Scenario 1: with I
  ==... isn't true.
  
  -- 438. Failure: Run RBC with a single person should succeed: Scenario 1: with I
  ==... isn't true.
  
  -- 439. Failure: Run RBC with a single person should succeed: Scenario 1: with I
  identical(as.numeric(res$res_status_before[[3]]), 0) isn't true.
  
  -- 440. Failure: Run RBC with a single person should succeed: Scenario 1: with I
  identical(as.numeric(res$res_status_after[[3]]), 0) isn't true.
  
  -- 441. Failure: Run RBC with a single person should succeed: Scenario 1: with I
  identical(as.numeric(res$is_long_term_mig[[3]]), 0) isn't true.
  
  -- 442. Failure: Run RBC with a single person should succeed: Scenario 1: with I
  ==... isn't true.
  
  -- 443. Failure: Run RBC with a single person should succeed: Scenario 1: with I
  ==... isn't true.
  
  -- 444. Failure: Run RBC with a single person should succeed: Scenario 1: with I
  ==... isn't true.
  
  -- 445. Failure: Run RBC with a single person should succeed: Scenario 1: with I
  identical(as.numeric(res$res_status_before[[4]]), 0) isn't true.
  
  -- 446. Failure: Run RBC with a single person should succeed: Scenario 1: with I
  identical(as.numeric(res$res_status_after[[4]]), 0) isn't true.
  
  -- 447. Failure: Run RBC with a single person should succeed: Scenario 1: with I
  identical(as.numeric(res$is_long_term_mig[[4]]), 0) isn't true.
  
  -- 448. Failure: Run RBC with a single person should succeed: Scenario 1: with I
  ==... isn't true.
  
  -- 449. Failure: Run RBC with a single person should succeed: Scenario 1: with I
  ==... isn't true.
  
  -- 450. Failure: Run RBC with a single person should succeed: Scenario 1: with I
  ==... isn't true.
  
  -- 451. Failure: Run RBC with a single person should succeed: Scenario 1: with I
  identical(as.numeric(res$res_status_before[[5]]), 0) isn't true.
  
  -- 452. Failure: Run RBC with a single person should succeed: Scenario 1: with I
  identical(as.numeric(res$res_status_after[[5]]), 0) isn't true.
  
  -- 453. Failure: Run RBC with a single person should succeed: Scenario 1: with I
  identical(as.numeric(res$is_long_term_mig[[5]]), 0) isn't true.
  
  -- 454. Failure: Run RBC with a single person should succeed: Scenario 1: with I
  ==... isn't true.
  
  -- 455. Failure: Run RBC with a single person should succeed: Scenario 1: with I
  ==... isn't true.
  
  -- 456. Failure: Run RBC with a single person should succeed: Scenario 1: with I
  ==... isn't true.
  
  INFO [2020-08-28 02:41:57] entering 'pre_process' :
  INFO [2020-08-28 02:41:57] leaving 'pre_process' : 
                return 1 groups of raw data.
  INFO [2020-08-28 02:41:57] entering 'resolve_data' :
  INFO [2020-08-28 02:41:57] Running without parallel
  INFO [2020-08-28 02:41:57] entering 'resolve_data, chunk =1':
                 window_size=487, 
                 threshold_year=365
  -- 457. Failure: Run RBC with a single person should succeed: Scenario 2: with I
  `migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)
    7. dplyr::bind_rows
    8. base::getExportedValue(pkg, name)
    9. base::asNamespace(ns)
   10. base::getNamespace(ns)
   11. base::loadNamespace(name)
   12. base::library.dynam(lib, package, package.lib)
  
  -- 458. Failure: Run RBC with a single person should succeed: Scenario 2: with I
  identical(as.numeric(res$res_status_before[[1]]), 1) isn't true.
  
  -- 459. Failure: Run RBC with a single person should succeed: Scenario 2: with I
  identical(as.numeric(res$res_status_after[[1]]), 0) isn't true.
  
  -- 460. Failure: Run RBC with a single person should succeed: Scenario 2: with I
  identical(as.numeric(res$is_long_term_mig[[1]]), 1) isn't true.
  
  -- 461. Failure: Run RBC with a single person should succeed: Scenario 2: with I
  ==... isn't true.
  
  -- 462. Failure: Run RBC with a single person should succeed: Scenario 2: with I
  ==... isn't true.
  
  -- 463. Failure: Run RBC with a single person should succeed: Scenario 2: with I
  ==... isn't true.
  
  -- 464. Failure: Run RBC with a single person should succeed: Scenario 2: with I
  identical(as.numeric(res$res_status_before[[2]]), 0) isn't true.
  
  -- 465. Failure: Run RBC with a single person should succeed: Scenario 2: with I
  identical(as.numeric(res$res_status_after[[2]]), 0) isn't true.
  
  -- 466. Failure: Run RBC with a single person should succeed: Scenario 2: with I
  identical(as.numeric(res$is_long_term_mig[[2]]), 0) isn't true.
  
  -- 467. Failure: Run RBC with a single person should succeed: Scenario 2: with I
  ==... isn't true.
  
  -- 468. Failure: Run RBC with a single person should succeed: Scenario 2: with I
  ==... isn't true.
  
  -- 469. Failure: Run RBC with a single person should succeed: Scenario 2: with I
  ==... isn't true.
  
  -- 470. Failure: Run RBC with a single person should succeed: Scenario 2: with I
  identical(as.numeric(res$res_status_before[[3]]), 1) isn't true.
  
  -- 471. Failure: Run RBC with a single person should succeed: Scenario 2: with I
  identical(as.numeric(res$res_status_after[[3]]), 0) isn't true.
  
  -- 472. Failure: Run RBC with a single person should succeed: Scenario 2: with I
  identical(as.numeric(res$is_long_term_mig[[3]]), 1) isn't true.
  
  -- 473. Failure: Run RBC with a single person should succeed: Scenario 2: with I
  ==... isn't true.
  
  -- 474. Failure: Run RBC with a single person should succeed: Scenario 2: with I
  ==... isn't true.
  
  -- 475. Failure: Run RBC with a single person should succeed: Scenario 2: with I
  ==... isn't true.
  
  -- 476. Failure: Run RBC with a single person should succeed: Scenario 2: with I
  identical(as.numeric(res$res_status_before[[4]]), 0) isn't true.
  
  -- 477. Failure: Run RBC with a single person should succeed: Scenario 2: with I
  identical(as.numeric(res$res_status_after[[4]]), 0) isn't true.
  
  -- 478. Failure: Run RBC with a single person should succeed: Scenario 2: with I
  identical(as.numeric(res$is_long_term_mig[[4]]), 0) isn't true.
  
  -- 479. Failure: Run RBC with a single person should succeed: Scenario 2: with I
  ==... isn't true.
  
  -- 480. Failure: Run RBC with a single person should succeed: Scenario 2: with I
  ==... isn't true.
  
  -- 481. Failure: Run RBC with a single person should succeed: Scenario 2: with I
  ==... isn't true.
  
  -- 482. Failure: Run RBC with a single person should succeed: Scenario 2: with I
  identical(as.numeric(res$res_status_before[[5]]), 0) isn't true.
  
  -- 483. Failure: Run RBC with a single person should succeed: Scenario 2: with I
  identical(as.numeric(res$res_status_after[[5]]), 0) isn't true.
  
  -- 484. Failure: Run RBC with a single person should succeed: Scenario 2: with I
  identical(as.numeric(res$is_long_term_mig[[5]]), 0) isn't true.
  
  -- 485. Failure: Run RBC with a single person should succeed: Scenario 2: with I
  ==... isn't true.
  
  -- 486. Failure: Run RBC with a single person should succeed: Scenario 2: with I
  ==... isn't true.
  
  -- 487. Failure: Run RBC with a single person should succeed: Scenario 2: with I
  ==... isn't true.
  
  INFO [2020-08-28 02:41:57] entering 'pre_process' :
  INFO [2020-08-28 02:41:57] leaving 'pre_process' : 
                return 1 groups of raw data.
  INFO [2020-08-28 02:41:57] entering 'resolve_data' :
  INFO [2020-08-28 02:41:57] Running without parallel
  INFO [2020-08-28 02:41:57] entering 'resolve_data, chunk =1':
                 window_size=487, 
                 threshold_year=365
  -- 488. Failure: Run RBC with a single person should succeed: Scenario 3: with I
  `migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)
    7. dplyr::bind_rows
    8. base::getExportedValue(pkg, name)
    9. base::asNamespace(ns)
   10. base::getNamespace(ns)
   11. base::loadNamespace(name)
   12. base::library.dynam(lib, package, package.lib)
  
  -- 489. Failure: Run RBC with a single person should succeed: Scenario 3: with I
  identical(as.numeric(res$res_status_before[[1]]), 0) isn't true.
  
  -- 490. Failure: Run RBC with a single person should succeed: Scenario 3: with I
  identical(as.numeric(res$res_status_after[[1]]), 1) isn't true.
  
  -- 491. Failure: Run RBC with a single person should succeed: Scenario 3: with I
  identical(as.numeric(res$is_long_term_mig[[1]]), 1) isn't true.
  
  -- 492. Failure: Run RBC with a single person should succeed: Scenario 3: with I
  ==... isn't true.
  
  -- 493. Failure: Run RBC with a single person should succeed: Scenario 3: with I
  ==... isn't true.
  
  -- 494. Failure: Run RBC with a single person should succeed: Scenario 3: with I
  ==... isn't true.
  
  -- 495. Failure: Run RBC with a single person should succeed: Scenario 3: with I
  identical(as.numeric(res$res_status_before[[2]]), 1) isn't true.
  
  -- 496. Failure: Run RBC with a single person should succeed: Scenario 3: with I
  identical(as.numeric(res$res_status_after[[2]]), 1) isn't true.
  
  -- 497. Failure: Run RBC with a single person should succeed: Scenario 3: with I
  identical(as.numeric(res$is_long_term_mig[[2]]), 0) isn't true.
  
  -- 498. Failure: Run RBC with a single person should succeed: Scenario 3: with I
  ==... isn't true.
  
  -- 499. Failure: Run RBC with a single person should succeed: Scenario 3: with I
  ==... isn't true.
  
  -- 500. Failure: Run RBC with a single person should succeed: Scenario 3: with I
  ==... isn't true.
  
  -- 501. Failure: Run RBC with a single person should succeed: Scenario 3: with I
  identical(as.numeric(res$res_status_before[[3]]), 1) isn't true.
  
  -- 502. Failure: Run RBC with a single person should succeed: Scenario 3: with I
  identical(as.numeric(res$res_status_after[[3]]), 1) isn't true.
  
  -- 503. Failure: Run RBC with a single person should succeed: Scenario 3: with I
  identical(as.numeric(res$is_long_term_mig[[3]]), 0) isn't true.
  
  -- 504. Failure: Run RBC with a single person should succeed: Scenario 3: with I
  ==... isn't true.
  
  -- 505. Failure: Run RBC with a single person should succeed: Scenario 3: with I
  ==... isn't true.
  
  -- 506. Failure: Run RBC with a single person should succeed: Scenario 3: with I
  ==... isn't true.
  
  -- 507. Failure: Run RBC with a single person should succeed: Scenario 3: with I
  identical(as.numeric(res$res_status_before[[4]]), 1) isn't true.
  
  -- 508. Failure: Run RBC with a single person should succeed: Scenario 3: with I
  identical(as.numeric(res$res_status_after[[4]]), 1) isn't true.
  
  -- 509. Failure: Run RBC with a single person should succeed: Scenario 3: with I
  identical(as.numeric(res$is_long_term_mig[[4]]), 0) isn't true.
  
  -- 510. Failure: Run RBC with a single person should succeed: Scenario 3: with I
  ==... isn't true.
  
  -- 511. Failure: Run RBC with a single person should succeed: Scenario 3: with I
  ==... isn't true.
  
  -- 512. Failure: Run RBC with a single person should succeed: Scenario 3: with I
  ==... isn't true.
  
  -- 513. Failure: Run RBC with a single person should succeed: Scenario 3: with I
  identical(as.numeric(res$res_status_before[[5]]), 1) isn't true.
  
  -- 514. Failure: Run RBC with a single person should succeed: Scenario 3: with I
  identical(as.numeric(res$res_status_after[[5]]), 1) isn't true.
  
  -- 515. Failure: Run RBC with a single person should succeed: Scenario 3: with I
  identical(as.numeric(res$is_long_term_mig[[5]]), 0) isn't true.
  
  -- 516. Failure: Run RBC with a single person should succeed: Scenario 3: with I
  ==... isn't true.
  
  -- 517. Failure: Run RBC with a single person should succeed: Scenario 3: with I
  ==... isn't true.
  
  -- 518. Failure: Run RBC with a single person should succeed: Scenario 3: with I
  ==... isn't true.
  
  INFO [2020-08-28 02:41:57] entering 'pre_process' :
  INFO [2020-08-28 02:41:57] leaving 'pre_process' : 
                return 1 groups of raw data.
  INFO [2020-08-28 02:41:57] entering 'resolve_data' :
  INFO [2020-08-28 02:41:57] Running without parallel
  INFO [2020-08-28 02:41:57] entering 'resolve_data, chunk =1':
                 window_size=487, 
                 threshold_year=365
  -- 519. Failure: Run RBC with a single person should succeed: Scenario 4: with I
  `migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)
    7. dplyr::bind_rows
    8. base::getExportedValue(pkg, name)
    9. base::asNamespace(ns)
   10. base::getNamespace(ns)
   11. base::loadNamespace(name)
   12. base::library.dynam(lib, package, package.lib)
  
  -- 520. Failure: Run RBC with a single person should succeed: Scenario 4: with I
  identical(as.numeric(res$res_status_before[[1]]), 0) isn't true.
  
  -- 521. Failure: Run RBC with a single person should succeed: Scenario 4: with I
  identical(as.numeric(res$res_status_after[[1]]), 1) isn't true.
  
  -- 522. Failure: Run RBC with a single person should succeed: Scenario 4: with I
  identical(as.numeric(res$is_long_term_mig[[1]]), 1) isn't true.
  
  -- 523. Failure: Run RBC with a single person should succeed: Scenario 4: with I
  ==... isn't true.
  
  -- 524. Failure: Run RBC with a single person should succeed: Scenario 4: with I
  ==... isn't true.
  
  -- 525. Failure: Run RBC with a single person should succeed: Scenario 4: with I
  ==... isn't true.
  
  -- 526. Failure: Run RBC with a single person should succeed: Scenario 4: with I
  identical(as.numeric(res$res_status_before[[2]]), 1) isn't true.
  
  -- 527. Failure: Run RBC with a single person should succeed: Scenario 4: with I
  identical(as.numeric(res$res_status_after[[2]]), 1) isn't true.
  
  -- 528. Failure: Run RBC with a single person should succeed: Scenario 4: with I
  identical(as.numeric(res$is_long_term_mig[[2]]), 0) isn't true.
  
  -- 529. Failure: Run RBC with a single person should succeed: Scenario 4: with I
  ==... isn't true.
  
  -- 530. Failure: Run RBC with a single person should succeed: Scenario 4: with I
  ==... isn't true.
  
  -- 531. Failure: Run RBC with a single person should succeed: Scenario 4: with I
  ==... isn't true.
  
  -- 532. Failure: Run RBC with a single person should succeed: Scenario 4: with I
  identical(as.numeric(res$res_status_before[[3]]), 0) isn't true.
  
  -- 533. Failure: Run RBC with a single person should succeed: Scenario 4: with I
  identical(as.numeric(res$res_status_after[[3]]), 1) isn't true.
  
  -- 534. Failure: Run RBC with a single person should succeed: Scenario 4: with I
  identical(as.numeric(res$is_long_term_mig[[3]]), 1) isn't true.
  
  -- 535. Failure: Run RBC with a single person should succeed: Scenario 4: with I
  ==... isn't true.
  
  -- 536. Failure: Run RBC with a single person should succeed: Scenario 4: with I
  ==... isn't true.
  
  -- 537. Failure: Run RBC with a single person should succeed: Scenario 4: with I
  ==... isn't true.
  
  -- 538. Failure: Run RBC with a single person should succeed: Scenario 4: with I
  identical(as.numeric(res$res_status_before[[4]]), 1) isn't true.
  
  -- 539. Failure: Run RBC with a single person should succeed: Scenario 4: with I
  identical(as.numeric(res$res_status_after[[4]]), 1) isn't true.
  
  -- 540. Failure: Run RBC with a single person should succeed: Scenario 4: with I
  identical(as.numeric(res$is_long_term_mig[[4]]), 0) isn't true.
  
  -- 541. Failure: Run RBC with a single person should succeed: Scenario 4: with I
  ==... isn't true.
  
  -- 542. Failure: Run RBC with a single person should succeed: Scenario 4: with I
  ==... isn't true.
  
  -- 543. Failure: Run RBC with a single person should succeed: Scenario 4: with I
  ==... isn't true.
  
  -- 544. Failure: Run RBC with a single person should succeed: Scenario 4: with I
  identical(as.numeric(res$res_status_before[[5]]), 1) isn't true.
  
  -- 545. Failure: Run RBC with a single person should succeed: Scenario 4: with I
  identical(as.numeric(res$res_status_after[[5]]), 1) isn't true.
  
  -- 546. Failure: Run RBC with a single person should succeed: Scenario 4: with I
  identical(as.numeric(res$is_long_term_mig[[5]]), 0) isn't true.
  
  -- 547. Failure: Run RBC with a single person should succeed: Scenario 4: with I
  ==... isn't true.
  
  -- 548. Failure: Run RBC with a single person should succeed: Scenario 4: with I
  ==... isn't true.
  
  -- 549. Failure: Run RBC with a single person should succeed: Scenario 4: with I
  ==... isn't true.
  
  INFO [2020-08-28 02:41:58] entering 'pre_process' :
  INFO [2020-08-28 02:41:58] leaving 'pre_process' : 
                return 1 groups of raw data.
  INFO [2020-08-28 02:41:58] entering 'resolve_data' :
  INFO [2020-08-28 02:41:58] Running without parallel
  INFO [2020-08-28 02:41:58] entering 'resolve_data, chunk =1':
                 window_size=487, 
                 threshold_year=365
  -- 550. Failure: Run RBC with a single person should succeed: Scenario 5: withou
  `migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)
    7. dplyr::bind_rows
    8. base::getExportedValue(pkg, name)
    9. base::asNamespace(ns)
   10. base::getNamespace(ns)
   11. base::loadNamespace(name)
   12. base::library.dynam(lib, package, package.lib)
  
  -- 551. Failure: Run RBC with a single person should succeed: Scenario 5: withou
  identical(as.numeric(res$res_status_before[[1]]), 1) isn't true.
  
  -- 552. Failure: Run RBC with a single person should succeed: Scenario 5: withou
  identical(as.numeric(res$res_status_after[[1]]), 0) isn't true.
  
  -- 553. Failure: Run RBC with a single person should succeed: Scenario 5: withou
  identical(as.numeric(res$is_long_term_mig[[1]]), 1) isn't true.
  
  -- 554. Failure: Run RBC with a single person should succeed: Scenario 5: withou
  ==... isn't true.
  
  -- 555. Failure: Run RBC with a single person should succeed: Scenario 5: withou
  ==... isn't true.
  
  -- 556. Failure: Run RBC with a single person should succeed: Scenario 5: withou
  ==... isn't true.
  
  -- 557. Failure: Run RBC with a single person should succeed: Scenario 5: withou
  identical(as.numeric(res$res_status_before[[2]]), 0) isn't true.
  
  -- 558. Failure: Run RBC with a single person should succeed: Scenario 5: withou
  identical(as.numeric(res$res_status_after[[2]]), 0) isn't true.
  
  -- 559. Failure: Run RBC with a single person should succeed: Scenario 5: withou
  identical(as.numeric(res$is_long_term_mig[[2]]), 0) isn't true.
  
  -- 560. Failure: Run RBC with a single person should succeed: Scenario 5: withou
  ==... isn't true.
  
  -- 561. Failure: Run RBC with a single person should succeed: Scenario 5: withou
  ==... isn't true.
  
  -- 562. Failure: Run RBC with a single person should succeed: Scenario 5: withou
  ==... isn't true.
  
  -- 563. Failure: Run RBC with a single person should succeed: Scenario 5: withou
  identical(as.numeric(res$res_status_before[[3]]), 0) isn't true.
  
  -- 564. Failure: Run RBC with a single person should succeed: Scenario 5: withou
  identical(as.numeric(res$res_status_after[[3]]), 0) isn't true.
  
  -- 565. Failure: Run RBC with a single person should succeed: Scenario 5: withou
  identical(as.numeric(res$is_long_term_mig[[3]]), 0) isn't true.
  
  -- 566. Failure: Run RBC with a single person should succeed: Scenario 5: withou
  ==... isn't true.
  
  -- 567. Failure: Run RBC with a single person should succeed: Scenario 5: withou
  ==... isn't true.
  
  -- 568. Failure: Run RBC with a single person should succeed: Scenario 5: withou
  ==... isn't true.
  
  -- 569. Failure: Run RBC with a single person should succeed: Scenario 5: withou
  identical(as.numeric(res$res_status_before[[4]]), 0) isn't true.
  
  -- 570. Failure: Run RBC with a single person should succeed: Scenario 5: withou
  identical(as.numeric(res$res_status_after[[4]]), 0) isn't true.
  
  -- 571. Failure: Run RBC with a single person should succeed: Scenario 5: withou
  identical(as.numeric(res$is_long_term_mig[[4]]), 0) isn't true.
  
  -- 572. Failure: Run RBC with a single person should succeed: Scenario 5: withou
  ==... isn't true.
  
  -- 573. Failure: Run RBC with a single person should succeed: Scenario 5: withou
  ==... isn't true.
  
  -- 574. Failure: Run RBC with a single person should succeed: Scenario 5: withou
  ==... isn't true.
  
  -- 575. Failure: Run RBC with a single person should succeed: Scenario 5: withou
  identical(as.numeric(res$res_status_before[[5]]), 0) isn't true.
  
  -- 576. Failure: Run RBC with a single person should succeed: Scenario 5: withou
  identical(as.numeric(res$res_status_after[[5]]), 0) isn't true.
  
  -- 577. Failure: Run RBC with a single person should succeed: Scenario 5: withou
  identical(as.numeric(res$is_long_term_mig[[5]]), 0) isn't true.
  
  -- 578. Failure: Run RBC with a single person should succeed: Scenario 5: withou
  ==... isn't true.
  
  -- 579. Failure: Run RBC with a single person should succeed: Scenario 5: withou
  ==... isn't true.
  
  -- 580. Failure: Run RBC with a single person should succeed: Scenario 5: withou
  ==... isn't true.
  
  INFO [2020-08-28 02:41:58] entering 'pre_process' :
  INFO [2020-08-28 02:41:58] leaving 'pre_process' : 
                return 1 groups of raw data.
  INFO [2020-08-28 02:41:58] entering 'resolve_data' :
  INFO [2020-08-28 02:41:58] Running without parallel
  INFO [2020-08-28 02:41:58] entering 'resolve_data, chunk =1':
                 window_size=487, 
                 threshold_year=365
  -- 581. Failure: Run RBC with a single person should succeed: Scenario 6: withou
  `migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)
    7. dplyr::bind_rows
    8. base::getExportedValue(pkg, name)
    9. base::asNamespace(ns)
   10. base::getNamespace(ns)
   11. base::loadNamespace(name)
   12. base::library.dynam(lib, package, package.lib)
  
  -- 582. Failure: Run RBC with a single person should succeed: Scenario 6: withou
  identical(as.numeric(res$res_status_before[[1]]), 0) isn't true.
  
  -- 583. Failure: Run RBC with a single person should succeed: Scenario 6: withou
  identical(as.numeric(res$res_status_after[[1]]), 1) isn't true.
  
  -- 584. Failure: Run RBC with a single person should succeed: Scenario 6: withou
  identical(as.numeric(res$is_long_term_mig[[1]]), 1) isn't true.
  
  -- 585. Failure: Run RBC with a single person should succeed: Scenario 6: withou
  ==... isn't true.
  
  -- 586. Failure: Run RBC with a single person should succeed: Scenario 6: withou
  ==... isn't true.
  
  -- 587. Failure: Run RBC with a single person should succeed: Scenario 6: withou
  ==... isn't true.
  
  -- 588. Failure: Run RBC with a single person should succeed: Scenario 6: withou
  identical(as.numeric(res$res_status_before[[2]]), 1) isn't true.
  
  -- 589. Failure: Run RBC with a single person should succeed: Scenario 6: withou
  identical(as.numeric(res$res_status_after[[2]]), 1) isn't true.
  
  -- 590. Failure: Run RBC with a single person should succeed: Scenario 6: withou
  identical(as.numeric(res$is_long_term_mig[[2]]), 0) isn't true.
  
  -- 591. Failure: Run RBC with a single person should succeed: Scenario 6: withou
  ==... isn't true.
  
  -- 592. Failure: Run RBC with a single person should succeed: Scenario 6: withou
  ==... isn't true.
  
  -- 593. Failure: Run RBC with a single person should succeed: Scenario 6: withou
  ==... isn't true.
  
  -- 594. Failure: Run RBC with a single person should succeed: Scenario 6: withou
  identical(as.numeric(res$res_status_before[[3]]), 1) isn't true.
  
  -- 595. Failure: Run RBC with a single person should succeed: Scenario 6: withou
  identical(as.numeric(res$res_status_after[[3]]), 1) isn't true.
  
  -- 596. Failure: Run RBC with a single person should succeed: Scenario 6: withou
  identical(as.numeric(res$is_long_term_mig[[3]]), 0) isn't true.
  
  -- 597. Failure: Run RBC with a single person should succeed: Scenario 6: withou
  ==... isn't true.
  
  -- 598. Failure: Run RBC with a single person should succeed: Scenario 6: withou
  ==... isn't true.
  
  -- 599. Failure: Run RBC with a single person should succeed: Scenario 6: withou
  ==... isn't true.
  
  -- 600. Failure: Run RBC with a single person should succeed: Scenario 6: withou
  identical(as.numeric(res$res_status_before[[4]]), 1) isn't true.
  
  -- 601. Failure: Run RBC with a single person should succeed: Scenario 6: withou
  identical(as.numeric(res$res_status_after[[4]]), 1) isn't true.
  
  -- 602. Failure: Run RBC with a single person should succeed: Scenario 6: withou
  identical(as.numeric(res$is_long_term_mig[[4]]), 0) isn't true.
  
  -- 603. Failure: Run RBC with a single person should succeed: Scenario 6: withou
  ==... isn't true.
  
  -- 604. Failure: Run RBC with a single person should succeed: Scenario 6: withou
  ==... isn't true.
  
  -- 605. Failure: Run RBC with a single person should succeed: Scenario 6: withou
  ==... isn't true.
  
  -- 606. Failure: Run RBC with a single person should succeed: Scenario 6: withou
  identical(as.numeric(res$res_status_before[[5]]), 1) isn't true.
  
  -- 607. Failure: Run RBC with a single person should succeed: Scenario 6: withou
  identical(as.numeric(res$res_status_after[[5]]), 1) isn't true.
  
  -- 608. Failure: Run RBC with a single person should succeed: Scenario 6: withou
  identical(as.numeric(res$is_long_term_mig[[5]]), 0) isn't true.
  
  -- 609. Failure: Run RBC with a single person should succeed: Scenario 6: withou
  ==... isn't true.
  
  -- 610. Failure: Run RBC with a single person should succeed: Scenario 6: withou
  ==... isn't true.
  
  -- 611. Failure: Run RBC with a single person should succeed: Scenario 6: withou
  ==... isn't true.
  
  INFO [2020-08-28 02:41:58] entering 'pre_process' :
  INFO [2020-08-28 02:41:58] leaving 'pre_process' : 
                return 1 groups of raw data.
  INFO [2020-08-28 02:41:58] entering 'resolve_data' :
  INFO [2020-08-28 02:41:58] Running without parallel
  INFO [2020-08-28 02:41:58] entering 'resolve_data, chunk =1':
                 window_size=487, 
                 threshold_year=365
  -- 612. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  `migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::resolve_data(crossings, window_size = 487, threshold_year = 365)
    7. dplyr::bind_rows
    8. base::getExportedValue(pkg, name)
    9. base::asNamespace(ns)
   10. base::getNamespace(ns)
   11. base::loadNamespace(name)
   12. base::library.dynam(lib, package, package.lib)
  
  -- 613. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  identical(as.numeric(res$res_status_before[[1]]), 0) isn't true.
  
  -- 614. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  identical(as.numeric(res$res_status_after[[1]]), 1) isn't true.
  
  -- 615. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  identical(as.numeric(res$is_long_term_mig[[1]]), 1) isn't true.
  
  -- 616. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  ==... isn't true.
  
  -- 617. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  ==... isn't true.
  
  -- 618. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  ==... isn't true.
  
  -- 619. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  identical(as.numeric(res$res_status_before[[2]]), 1) isn't true.
  
  -- 620. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  identical(as.numeric(res$res_status_after[[2]]), 1) isn't true.
  
  -- 621. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  identical(as.numeric(res$is_long_term_mig[[2]]), 0) isn't true.
  
  -- 622. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  ==... isn't true.
  
  -- 623. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  ==... isn't true.
  
  -- 624. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  ==... isn't true.
  
  -- 625. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  identical(as.numeric(res$res_status_before[[3]]), 1) isn't true.
  
  -- 626. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  identical(as.numeric(res$res_status_after[[3]]), 1) isn't true.
  
  -- 627. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  identical(as.numeric(res$is_long_term_mig[[3]]), 0) isn't true.
  
  -- 628. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  ==... isn't true.
  
  -- 629. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  ==... isn't true.
  
  -- 630. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  ==... isn't true.
  
  -- 631. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  identical(as.numeric(res$res_status_before[[4]]), 1) isn't true.
  
  -- 632. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  identical(as.numeric(res$res_status_after[[4]]), 1) isn't true.
  
  -- 633. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  identical(as.numeric(res$is_long_term_mig[[4]]), 0) isn't true.
  
  -- 634. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  ==... isn't true.
  
  -- 635. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  ==... isn't true.
  
  -- 636. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  ==... isn't true.
  
  -- 637. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  identical(as.numeric(res$res_status_before[[5]]), 1) isn't true.
  
  -- 638. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  identical(as.numeric(res$res_status_after[[5]]), 1) isn't true.
  
  -- 639. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  identical(as.numeric(res$is_long_term_mig[[5]]), 0) isn't true.
  
  -- 640. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  ==... isn't true.
  
  -- 641. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  ==... isn't true.
  
  -- 642. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  ==... isn't true.
  
  -- 643. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  identical(as.numeric(res$res_status_before[[6]]), 1) isn't true.
  
  -- 644. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  identical(as.numeric(res$res_status_after[[6]]), 1) isn't true.
  
  -- 645. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  identical(as.numeric(res$is_long_term_mig[[6]]), 0) isn't true.
  
  -- 646. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  ==... isn't true.
  
  -- 647. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  ==... isn't true.
  
  -- 648. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  ==... isn't true.
  
  -- 649. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  identical(as.numeric(res$res_status_before[[7]]), 1) isn't true.
  
  -- 650. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  identical(as.numeric(res$res_status_after[[7]]), 1) isn't true.
  
  -- 651. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  identical(as.numeric(res$is_long_term_mig[[7]]), 0) isn't true.
  
  -- 652. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  ==... isn't true.
  
  -- 653. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  ==... isn't true.
  
  -- 654. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  ==... isn't true.
  
  -- 655. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  identical(as.numeric(res$res_status_before[[8]]), 1) isn't true.
  
  -- 656. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  identical(as.numeric(res$res_status_after[[8]]), 1) isn't true.
  
  -- 657. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  identical(as.numeric(res$is_long_term_mig[[8]]), 0) isn't true.
  
  -- 658. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  ==... isn't true.
  
  -- 659. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  ==... isn't true.
  
  -- 660. Failure: Run RBC with a single person should succeed: Scenario 7: one wi
  ==... isn't true.
  
  INFO [2020-08-28 02:42:00] entering 'pre_process' :
  INFO [2020-08-28 02:42:00] leaving 'pre_process' : 
                return 1 groups of raw data.
  INFO [2020-08-28 02:42:00] entering 'run_rbc' :
                             window_size = 487, 
                             threshold_year = 365, 
                             parallel = FALSE, 
                             n_core = 2,
                             max_ram = 2,
                             include_error_columns = FALSE,
                             mc.cleanup = FALSE
  INFO [2020-08-28 02:42:00] entering 'resolve_data' :
  INFO [2020-08-28 02:42:00] Running without parallel
  INFO [2020-08-28 02:42:00] entering 'resolve_data, chunk =1':
                 window_size=487, 
                 threshold_year=365
  ERROR [2020-08-28 02:42:01] error in 'run_rbc' : DLL 'dplyr' not found: maybe not installed for this architecture?
  -- 661. Error: (unknown) (@test-plot_mig_hist.R#22)  ---------------------------
  DLL 'dplyr' not found: maybe not installed for this architecture?
  Backtrace:
   1. testthat::describe(...)
   2. [ base::eval(...) ] with 1 more call
   4. migrbc:::setup_data()
   5. migrbc::run_rbc(...)
   6. base::tryCatch(...)
   7. base:::tryCatchList(expr, classes, parentenv, handlers)
   8. base:::tryCatchOne(...)
   9. value[[3L]](cond)
  
  INFO [2020-08-28 02:42:01] entering 'pre_process' :
  INFO [2020-08-28 02:42:01] leaving 'pre_process' : 
                return 10 groups of raw data.
  INFO [2020-08-28 02:42:01] entering 'pre_process' :
  INFO [2020-08-28 02:42:01] leaving 'pre_process' : 
                return 13 groups of raw data.
  INFO [2020-08-28 02:42:01] entering 'pre_process' :
  INFO [2020-08-28 02:42:01] leaving 'pre_process' : 
                return 18 groups of raw data.
  INFO [2020-08-28 02:42:01] entering 'pre_process' :
  INFO [2020-08-28 02:42:02] leaving 'pre_process' : 
                return 1000 groups of raw data.
  INFO [2020-08-28 02:42:02] entering 'pre_process' :
  INFO [2020-08-28 02:42:03] leaving 'pre_process' : 
                return 1000 groups of raw data.
  INFO [2020-08-28 02:42:04] entering 'pre_process' :
  INFO [2020-08-28 02:42:04] leaving 'pre_process' : 
                return 10 groups of raw data.
  INFO [2020-08-28 02:42:04] entering 'pre_process' :
  INFO [2020-08-28 02:42:04] leaving 'pre_process' : 
                return 13 groups of raw data.
  INFO [2020-08-28 02:42:04] entering 'pre_process' :
  INFO [2020-08-28 02:42:04] leaving 'pre_process' : 
                return 18 groups of raw data.
  INFO [2020-08-28 02:42:04] entering 'pre_process' :
  INFO [2020-08-28 02:42:05] leaving 'pre_process' : 
                return 617 groups of raw data.
  INFO [2020-08-28 02:42:05] entering 'pre_process' :
  INFO [2020-08-28 02:42:05] leaving 'pre_process' : 
                return 1234 groups of raw data.
  INFO [2020-08-28 02:42:05] entering 'pre_process' :
  INFO [2020-08-28 02:42:05] entering 'pre_process' :
  INFO [2020-08-28 02:42:05] entering 'pre_process' :
  INFO [2020-08-28 02:42:05] entering 'pre_process' :
  INFO [2020-08-28 02:42:05] entering 'pre_process' :
  INFO [2020-08-28 02:42:05] entering 'pre_process' :
  ERROR [2020-08-28 02:42:05] error in 'pre_process' : invalid 'envir' argument of type 'logical'
  INFO [2020-08-28 02:42:05] entering 'pre_process' :
  ERROR [2020-08-28 02:42:05] error in 'pre_process' : invalid 'envir' argument of type 'character'
  INFO [2020-08-28 02:42:06] entering 'pre_process' :
  INFO [2020-08-28 02:42:06] leaving 'pre_process' : 
                return 10 groups of raw data.
  logger  'migrbc' has log_level=1 and writes to the console 
  [ERROR] [2020-08-28 02:42:07] [testthat.test_check] error in 'run_rbc' : DLL 'dplyr' not found: maybe not installed for this architecture?
  -- 662. Failure: test initialize_logger: Successful cases (@test-run_rbc.R#25)  
  `... <- NULL` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::run_rbc(...)
    7. base::tryCatch(...)
    8. base:::tryCatchList(expr, classes, parentenv, handlers)
    9. base:::tryCatchOne(...)
   10. value[[3L]](cond)
  
  logger  'migrbc' has log_level=2 and writes to the console 
  [ERROR] [2020-08-28 02:42:08] [testthat.test_check] error in 'run_rbc' : DLL 'dplyr' not found: maybe not installed for this architecture?
  -- 663. Failure: test initialize_logger: Successful cases (@test-run_rbc.R#30)  
  `... <- NULL` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::run_rbc(...)
    7. base::tryCatch(...)
    8. base:::tryCatchList(expr, classes, parentenv, handlers)
    9. base:::tryCatchOne(...)
   10. value[[3L]](cond)
  
  logger  'migrbc' has log_level=4 and writes to the console 
  [ERROR] [2020-08-28 02:42:10] [testthat.test_check] error in 'run_rbc' : DLL 'dplyr' not found: maybe not installed for this architecture?
  -- 664. Failure: test initialize_logger: Successful cases (@test-run_rbc.R#35)  
  `... <- NULL` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::run_rbc(...)
    7. base::tryCatch(...)
    8. base:::tryCatchList(expr, classes, parentenv, handlers)
    9. base:::tryCatchOne(...)
   10. value[[3L]](cond)
  
  logger  'migrbc' has log_level=6 and writes to the console 
  INFO [2020-08-28 02:42:10] entering 'run_rbc' :
                             window_size = 487, 
                             threshold_year = 365, 
                             parallel = FALSE, 
                             n_core = 2,
                             max_ram = 2,
                             include_error_columns = FALSE,
                             mc.cleanup = FALSE
  INFO [2020-08-28 02:42:10] entering 'resolve_data' :
  INFO [2020-08-28 02:42:10] Running without parallel
  INFO [2020-08-28 02:42:10] entering 'resolve_data, chunk =1':
                 window_size=487, 
                 threshold_year=365
  INFO [2020-08-28 02:42:11] entering 'resolve_data, chunk =2':
                 window_size=487, 
                 threshold_year=365
  INFO [2020-08-28 02:42:11] entering 'resolve_data, chunk =3':
                 window_size=487, 
                 threshold_year=365
  INFO [2020-08-28 02:42:11] entering 'resolve_data, chunk =4':
                 window_size=487, 
                 threshold_year=365
  INFO [2020-08-28 02:42:11] entering 'resolve_data, chunk =5':
                 window_size=487, 
                 threshold_year=365
  INFO [2020-08-28 02:42:11] entering 'resolve_data, chunk =6':
                 window_size=487, 
                 threshold_year=365
  INFO [2020-08-28 02:42:11] entering 'resolve_data, chunk =7':
                 window_size=487, 
                 threshold_year=365
  INFO [2020-08-28 02:42:11] entering 'resolve_data, chunk =8':
                 window_size=487, 
                 threshold_year=365
  INFO [2020-08-28 02:42:11] entering 'resolve_data, chunk =9':
                 window_size=487, 
                 threshold_year=365
  INFO [2020-08-28 02:42:11] entering 'resolve_data, chunk =10':
                 window_size=487, 
                 threshold_year=365
  [ERROR] [2020-08-28 02:42:12] [testthat.test_check] error in 'run_rbc' : DLL 'dplyr' not found: maybe not installed for this architecture?
  -- 665. Failure: test initialize_logger: Successful cases (@test-run_rbc.R#40)  
  `... <- NULL` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::run_rbc(...)
    7. base::tryCatch(...)
    8. base:::tryCatchList(expr, classes, parentenv, handlers)
    9. base:::tryCatchOne(...)
   10. value[[3L]](cond)
  
  logger  'migrbc' has log_level=8 and writes to the console 
  INFO [2020-08-28 02:42:12] entering 'run_rbc' :
                             window_size = 487, 
                             threshold_year = 365, 
                             parallel = FALSE, 
                             n_core = 2,
                             max_ram = 2,
                             include_error_columns = FALSE,
                             mc.cleanup = FALSE
  INFO [2020-08-28 02:42:12] entering 'resolve_data' :
  INFO [2020-08-28 02:42:12] Running without parallel
  INFO [2020-08-28 02:42:12] entering 'resolve_data, chunk =1':
                 window_size=487, 
                 threshold_year=365
  INFO [2020-08-28 02:42:12] entering 'resolve_data, chunk =2':
                 window_size=487, 
                 threshold_year=365
  INFO [2020-08-28 02:42:12] entering 'resolve_data, chunk =3':
                 window_size=487, 
                 threshold_year=365
  INFO [2020-08-28 02:42:12] entering 'resolve_data, chunk =4':
                 window_size=487, 
                 threshold_year=365
  INFO [2020-08-28 02:42:12] entering 'resolve_data, chunk =5':
                 window_size=487, 
                 threshold_year=365
  INFO [2020-08-28 02:42:12] entering 'resolve_data, chunk =6':
                 window_size=487, 
                 threshold_year=365
  INFO [2020-08-28 02:42:12] entering 'resolve_data, chunk =7':
                 window_size=487, 
                 threshold_year=365
  INFO [2020-08-28 02:42:13] entering 'resolve_data, chunk =8':
                 window_size=487, 
                 threshold_year=365
  INFO [2020-08-28 02:42:13] entering 'resolve_data, chunk =9':
                 window_size=487, 
                 threshold_year=365
  INFO [2020-08-28 02:42:13] entering 'resolve_data, chunk =10':
                 window_size=487, 
                 threshold_year=365
  [ERROR] [2020-08-28 02:42:13] [testthat.test_check] error in 'run_rbc' : DLL 'dplyr' not found: maybe not installed for this architecture?
  -- 666. Failure: test initialize_logger: Successful cases (@test-run_rbc.R#45)  
  `... <- NULL` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::run_rbc(...)
    7. base::tryCatch(...)
    8. base:::tryCatchList(expr, classes, parentenv, handlers)
    9. base:::tryCatchOne(...)
   10. value[[3L]](cond)
  
  logger  'migrbc' has log_level=9 and writes to the console 
  INFO [2020-08-28 02:42:13] entering 'run_rbc' :
                             window_size = 487, 
                             threshold_year = 365, 
                             parallel = FALSE, 
                             n_core = 2,
                             max_ram = 2,
                             include_error_columns = FALSE,
                             mc.cleanup = FALSE
  INFO [2020-08-28 02:42:13] entering 'resolve_data' :
  INFO [2020-08-28 02:42:13] Running without parallel
  INFO [2020-08-28 02:42:13] entering 'resolve_data, chunk =1':
                 window_size=487, 
                 threshold_year=365
  INFO [2020-08-28 02:42:13] entering 'resolve_data, chunk =2':
                 window_size=487, 
                 threshold_year=365
  INFO [2020-08-28 02:42:13] entering 'resolve_data, chunk =3':
                 window_size=487, 
                 threshold_year=365
  INFO [2020-08-28 02:42:13] entering 'resolve_data, chunk =4':
                 window_size=487, 
                 threshold_year=365
  INFO [2020-08-28 02:42:14] entering 'resolve_data, chunk =5':
                 window_size=487, 
                 threshold_year=365
  INFO [2020-08-28 02:42:14] entering 'resolve_data, chunk =6':
                 window_size=487, 
                 threshold_year=365
  INFO [2020-08-28 02:42:14] entering 'resolve_data, chunk =7':
                 window_size=487, 
                 threshold_year=365
  INFO [2020-08-28 02:42:14] entering 'resolve_data, chunk =8':
                 window_size=487, 
                 threshold_year=365
  INFO [2020-08-28 02:42:14] entering 'resolve_data, chunk =9':
                 window_size=487, 
                 threshold_year=365
  INFO [2020-08-28 02:42:14] entering 'resolve_data, chunk =10':
                 window_size=487, 
                 threshold_year=365
  [ERROR] [2020-08-28 02:42:15] [testthat.test_check] error in 'run_rbc' : DLL 'dplyr' not found: maybe not installed for this architecture?
  -- 667. Failure: test initialize_logger: Successful cases (@test-run_rbc.R#50)  
  `... <- NULL` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::run_rbc(...)
    7. base::tryCatch(...)
    8. base:::tryCatchList(expr, classes, parentenv, handlers)
    9. base:::tryCatchOne(...)
   10. value[[3L]](cond)
  
  INFO [2020-08-28 02:42:15] entering 'pre_process' :
  INFO [2020-08-28 02:42:15] leaving 'pre_process' : 
                return 10 groups of raw data.
  INFO [2020-08-28 02:42:15] entering 'run_rbc' :
                             window_size = 487, 
                             threshold_year = 365, 
                             parallel = FALSE, 
                             n_core = 2,
                             max_ram = 2,
                             include_error_columns = FALSE,
                             mc.cleanup = FALSE
  INFO [2020-08-28 02:42:15] entering 'resolve_data' :
  INFO [2020-08-28 02:42:15] Running without parallel
  INFO [2020-08-28 02:42:15] entering 'resolve_data, chunk =1':
                 window_size=487, 
                 threshold_year=365
  INFO [2020-08-28 02:42:15] entering 'resolve_data, chunk =2':
                 window_size=487, 
                 threshold_year=365
  INFO [2020-08-28 02:42:15] entering 'resolve_data, chunk =3':
                 window_size=487, 
                 threshold_year=365
  INFO [2020-08-28 02:42:15] entering 'resolve_data, chunk =4':
                 window_size=487, 
                 threshold_year=365
  INFO [2020-08-28 02:42:15] entering 'resolve_data, chunk =5':
                 window_size=487, 
                 threshold_year=365
  INFO [2020-08-28 02:42:15] entering 'resolve_data, chunk =6':
                 window_size=487, 
                 threshold_year=365
  INFO [2020-08-28 02:42:16] entering 'resolve_data, chunk =7':
                 window_size=487, 
                 threshold_year=365
  INFO [2020-08-28 02:42:16] entering 'resolve_data, chunk =8':
                 window_size=487, 
                 threshold_year=365
  INFO [2020-08-28 02:42:16] entering 'resolve_data, chunk =9':
                 window_size=487, 
                 threshold_year=365
  INFO [2020-08-28 02:42:16] entering 'resolve_data, chunk =10':
                 window_size=487, 
                 threshold_year=365
  [ERROR] [2020-08-28 02:42:16] [testthat.test_check] error in 'run_rbc' : DLL 'dplyr' not found: maybe not installed for this architecture?
  -- 668. Failure: run rbc of happy cases: Without parallel (@test-run_rbc.R#70)  
  `... <- NULL` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::run_rbc(...)
    7. base::tryCatch(...)
    8. base:::tryCatchList(expr, classes, parentenv, handlers)
    9. base:::tryCatchOne(...)
   10. value[[3L]](cond)
  
  INFO [2020-08-28 02:42:16] entering 'run_rbc' :
                             window_size = 487, 
                             threshold_year = 365, 
                             parallel = TRUE, 
                             n_core = 1,
                             max_ram = 2,
                             include_error_columns = FALSE,
                             mc.cleanup = FALSE
  INFO [2020-08-28 02:42:16] entering 'resolve_data' :
  WARN [2020-08-28 02:42:16] Parallel using mclapply not supported on 
                     Windows R server
  INFO [2020-08-28 02:42:16] Running without parallel
  INFO [2020-08-28 02:42:16] entering 'resolve_data, chunk =1':
                 window_size=487, 
                 threshold_year=365
  INFO [2020-08-28 02:42:16] entering 'resolve_data, chunk =2':
                 window_size=487, 
                 threshold_year=365
  INFO [2020-08-28 02:42:16] entering 'resolve_data, chunk =3':
                 window_size=487, 
                 threshold_year=365
  INFO [2020-08-28 02:42:17] entering 'resolve_data, chunk =4':
                 window_size=487, 
                 threshold_year=365
  INFO [2020-08-28 02:42:17] entering 'resolve_data, chunk =5':
                 window_size=487, 
                 threshold_year=365
  INFO [2020-08-28 02:42:17] entering 'resolve_data, chunk =6':
                 window_size=487, 
                 threshold_year=365
  INFO [2020-08-28 02:42:17] entering 'resolve_data, chunk =7':
                 window_size=487, 
                 threshold_year=365
  INFO [2020-08-28 02:42:17] entering 'resolve_data, chunk =8':
                 window_size=487, 
                 threshold_year=365
  INFO [2020-08-28 02:42:17] entering 'resolve_data, chunk =9':
                 window_size=487, 
                 threshold_year=365
  INFO [2020-08-28 02:42:17] entering 'resolve_data, chunk =10':
                 window_size=487, 
                 threshold_year=365
  [ERROR] [2020-08-28 02:42:17] [testthat.test_check] error in 'run_rbc' : DLL 'dplyr' not found: maybe not installed for this architecture?
  -- 669. Failure: run rbc of happy cases: With parallel (@test-run_rbc.R#77)  ---
  `... <- NULL` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::run_rbc(...)
    7. base::tryCatch(...)
    8. base:::tryCatchList(expr, classes, parentenv, handlers)
    9. base:::tryCatchOne(...)
   10. value[[3L]](cond)
  
  INFO [2020-08-28 02:42:17] entering 'run_rbc' :
                             window_size = 487, 
                             threshold_year = 365, 
                             parallel = FALSE, 
                             n_core = 2,
                             max_ram = 2,
                             include_error_columns = FALSE,
                             mc.cleanup = FALSE
  INFO [2020-08-28 02:42:17] entering 'pre_process' :
  INFO [2020-08-28 02:42:17] leaving 'pre_process' : 
                return 2 groups of raw data.
  INFO [2020-08-28 02:42:17] entering 'resolve_data' :
  INFO [2020-08-28 02:42:17] Running without parallel
  INFO [2020-08-28 02:42:17] entering 'resolve_data, chunk =1':
                 window_size=487, 
                 threshold_year=365
  INFO [2020-08-28 02:42:18] entering 'resolve_data, chunk =2':
                 window_size=487, 
                 threshold_year=365
  [ERROR] [2020-08-28 02:42:19] [testthat.test_check] error in 'run_rbc' : DLL 'dplyr' not found: maybe not installed for this architecture?
  -- 670. Failure: run rbc of happy cases: Without pre_process (@test-run_rbc.R#86
  `res <- run_rbc(test_data$data, window_size = 487, threshold_year = 365)` threw an error.
  Message: DLL 'dplyr' not found: maybe not installed for this architecture?
  Class:   simpleError/error/condition
  Backtrace:
    1. testthat::expect_error(...)
    6. migrbc::run_rbc(test_data$data, window_size = 487, threshold_year = 365)
    7. base::tryCatch(...)
    8. base:::tryCatchList(expr, classes, parentenv, handlers)
    9. base:::tryCatchOne(...)
   10. value[[3L]](cond)
  
  INFO [2020-08-28 02:42:19] entering 'pre_process' :
  INFO [2020-08-28 02:42:19] leaving 'pre_process' : 
                return 10 groups of raw data.
  INFO [2020-08-28 02:42:19] entering 'run_rbc' :
                             window_size = 487, 
                             threshold_year = 365, 
                             parallel = FALSE, 
                             n_core = 2,
                             max_ram = 2,
                             include_error_columns = FALSE,
                             mc.cleanup = FALSE
  INFO [2020-08-28 02:42:19] entering 'run_rbc' :
                             window_size = 487, 
                             threshold_year = 365, 
                             parallel = FALSE, 
                             n_core = 2,
                             max_ram = 2,
                             include_error_columns = FALSE,
                             mc.cleanup = FALSE
  INFO [2020-08-28 02:42:19] entering 'run_rbc' :
                             window_size = 487, 
                             threshold_year = 365, 
                             parallel = FALSE, 
                             n_core = 2,
                             max_ram = 2,
                             include_error_columns = FALSE,
                             mc.cleanup = FALSE
  == testthat results  ===========================================================
  [ OK: 100 | SKIPPED: 0 | WARNINGS: 0 | FAILED: 670 ]
  1. Failure: Run RBC with a single non-resident person should succeed: Scenario:  1. start of backseries - 
     a resident who is returning is nonmigrating (@test-RBC_algorithm_non_residence_rcpp.R#22) 
  2. Failure: Run RBC with a single non-resident person should succeed: Scenario:  1. start of backseries - 
     a resident who is returning is nonmigrating (@test-RBC_algorithm_non_residence_rcpp.R#27) 
  3. Failure: Run RBC with a single non-resident person should succeed: Scenario:  1. start of backseries - 
     a resident who is returning is nonmigrating (@test-RBC_algorithm_non_residence_rcpp.R#28) 
  4. Failure: Run RBC with a single non-resident person should succeed: Scenario:  1. start of backseries - 
     a resident who is returning is nonmigrating (@test-RBC_algorithm_non_residence_rcpp.R#29) 
  5. Failure: Run RBC with a single non-resident person should succeed: Scenario:  1. start of backseries - 
     a resident who is returning is nonmigrating (@test-RBC_algorithm_non_residence_rcpp.R#38) 
  6. Failure: Run RBC with a single non-resident person should succeed: Scenario:  1. start of backseries - 
     a resident who is returning is nonmigrating (@test-RBC_algorithm_non_residence_rcpp.R#39) 
  7. Failure: Run RBC with a single non-resident person should succeed: Scenario:  1. start of backseries - 
     a resident who is returning is nonmigrating (@test-RBC_algorithm_non_residence_rcpp.R#40) 
  8. Failure: Run RBC with a single non-resident person should succeed: Scenario: 2. a non-resident who migrates (@test-RBC_algorithm_non_residence_rcpp.R#58) 
  9. Failure: Run RBC with a single non-resident person should succeed: Scenario: 2. a non-resident who migrates (@test-RBC_algorithm_non_residence_rcpp.R#64) 
  1. ...
  
  Error: testthat unit tests failed
  Execution halted