CRAN Package Check Results for Package llama

Last updated on 2020-04-11 09:49:58 CEST.

Check Details

Version: 0.9.2
Check: tests
Result: ERROR
     Running 'run-all.R' [19s/22s]
    Running the tests in 'tests/run-all.R' failed.
    Complete output:
     > library(testthat)
     > library(ParamHelpers)
     >
     > test_check("llama")
     Loading required package: llama
     Loading required package: mlr
     'mlr' is in maintenance mode since July 2019. Future development
     efforts will go into its successor 'mlr3' (<https://mlr3.mlr-org.com>).
     -- 1. Failure: classify classifies (@test.classify.R#4) -----------------------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 2. Failure: classify classifies (@test.classify.R#4) -----------------------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 3. Failure: classify classifies (@test.classify.R#4) -----------------------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 4. Failure: classify classifies (@test.classify.R#4) -----------------------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 5. Failure: classify classifies (@test.classify.R#4) -----------------------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 6. Failure: classify classifies (@test.classify.R#4) -----------------------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 7. Failure: classify classifies (@test.classify.R#4) -----------------------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 8. Failure: classify classifies (@test.classify.R#4) -----------------------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 9. Failure: classify classifies (@test.classify.R#4) -----------------------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 10. Failure: classify classifies (@test.classify.R#4) ----------------------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 11. Failure: classify returns predictor (@test.classify.R#15) --------------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 12. Failure: classify returns predictor (@test.classify.R#15) --------------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 13. Failure: classify returns predictor (@test.classify.R#15) --------------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 14. Failure: classify returns predictor (@test.classify.R#15) --------------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 15. Failure: classify returns predictor (@test.classify.R#15) --------------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 16. Failure: classify returns predictor (@test.classify.R#15) --------------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 17. Failure: classify returns predictor (@test.classify.R#15) --------------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 18. Failure: classify returns predictor (@test.classify.R#15) --------------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 19. Failure: classify returns predictor (@test.classify.R#15) --------------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 20. Failure: classify returns predictor (@test.classify.R#15) --------------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 21. Failure: classify returns predictor that works without IDs (@test.classif
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 22. Failure: classify returns predictor that works without IDs (@test.classif
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 23. Failure: classify returns predictor that works without IDs (@test.classif
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 24. Failure: classify returns predictor that works without IDs (@test.classif
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 25. Failure: classify returns predictor that works without IDs (@test.classif
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 26. Failure: classify returns predictor that works without IDs (@test.classif
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 27. Failure: classify returns predictor that works without IDs (@test.classif
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 28. Failure: classify returns predictor that works without IDs (@test.classif
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 29. Failure: classify returns predictor that works without IDs (@test.classif
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 30. Failure: classify returns predictor that works without IDs (@test.classif
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 31. Failure: classify takes list of classifiers (@test.classify.R#47) ------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 32. Failure: classify takes list of classifiers (@test.classify.R#47) ------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 33. Failure: classify takes list of classifiers (@test.classify.R#47) ------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 34. Failure: classify takes list of classifiers (@test.classify.R#47) ------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 35. Failure: classify takes list of classifiers (@test.classify.R#47) ------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 36. Failure: classify takes list of classifiers (@test.classify.R#47) ------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 37. Failure: classify takes list of classifiers (@test.classify.R#47) ------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 38. Failure: classify takes list of classifiers (@test.classify.R#47) ------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 39. Failure: classify takes list of classifiers (@test.classify.R#47) ------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 40. Failure: classify takes list of classifiers (@test.classify.R#47) ------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 41. Failure: classify takes list of classifiers (@test.classify.R#55) ------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 42. Failure: classify takes list of classifiers (@test.classify.R#55) ------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 43. Failure: classify takes list of classifiers (@test.classify.R#55) ------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 44. Failure: classify takes list of classifiers (@test.classify.R#55) ------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 45. Failure: classify takes list of classifiers (@test.classify.R#55) ------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 46. Failure: classify takes list of classifiers (@test.classify.R#55) ------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 47. Failure: classify takes list of classifiers (@test.classify.R#55) ------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 48. Failure: classify takes list of classifiers (@test.classify.R#55) ------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 49. Failure: classify takes list of classifiers (@test.classify.R#55) ------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 50. Failure: classify takes list of classifiers (@test.classify.R#55) ------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 51. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 52. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 53. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 54. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 55. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 56. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 57. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 58. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 59. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 60. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 61. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 62. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 63. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 64. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 65. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 66. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 67. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 68. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 69. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 70. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 71. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 72. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 73. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 74. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 75. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 76. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 77. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 78. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 79. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 80. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 81. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 82. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 83. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 84. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 85. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 86. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 87. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 88. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 89. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 90. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 91. Failure: classify works with NA predictions (@test.classify.R#98) ------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 92. Failure: classify works with NA predictions (@test.classify.R#98) ------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 93. Failure: classify works with NA predictions (@test.classify.R#98) ------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 94. Failure: classify works with NA predictions (@test.classify.R#98) ------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 95. Failure: classify works with NA predictions (@test.classify.R#98) ------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 96. Failure: classify works with NA predictions (@test.classify.R#98) ------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 97. Failure: classify works with NA predictions (@test.classify.R#98) ------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 98. Failure: classify works with NA predictions (@test.classify.R#98) ------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 99. Failure: classify works with NA predictions (@test.classify.R#98) ------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 100. Failure: classify works with NA predictions (@test.classify.R#98) -----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 101. Failure: classify works with NA predictions (@test.classify.R#105) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 102. Failure: classify works with NA predictions (@test.classify.R#105) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 103. Failure: classify works with NA predictions (@test.classify.R#105) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 104. Failure: classify works with NA predictions (@test.classify.R#105) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 105. Failure: classify works with NA predictions (@test.classify.R#105) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 106. Failure: classify works with NA predictions (@test.classify.R#105) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 107. Failure: classify works with NA predictions (@test.classify.R#105) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 108. Failure: classify works with NA predictions (@test.classify.R#105) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 109. Failure: classify works with NA predictions (@test.classify.R#105) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 110. Failure: classify works with NA predictions (@test.classify.R#105) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 111. Failure: classify works with NA predictions (@test.classify.R#112) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 112. Failure: classify works with NA predictions (@test.classify.R#112) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 113. Failure: classify works with NA predictions (@test.classify.R#112) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 114. Failure: classify works with NA predictions (@test.classify.R#112) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 115. Failure: classify works with NA predictions (@test.classify.R#112) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 116. Failure: classify works with NA predictions (@test.classify.R#112) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 117. Failure: classify works with NA predictions (@test.classify.R#112) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 118. Failure: classify works with NA predictions (@test.classify.R#112) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 119. Failure: classify works with NA predictions (@test.classify.R#112) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 120. Failure: classify works with NA predictions (@test.classify.R#112) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 121. Failure: classify works with NA predictions (@test.classify.R#119) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 122. Failure: classify works with NA predictions (@test.classify.R#119) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 123. Failure: classify works with NA predictions (@test.classify.R#119) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 124. Failure: classify works with NA predictions (@test.classify.R#119) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 125. Failure: classify works with NA predictions (@test.classify.R#119) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 126. Failure: classify works with NA predictions (@test.classify.R#119) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 127. Failure: classify works with NA predictions (@test.classify.R#119) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 128. Failure: classify works with NA predictions (@test.classify.R#119) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 129. Failure: classify works with NA predictions (@test.classify.R#119) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 130. Failure: classify works with NA predictions (@test.classify.R#119) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 131. Failure: classify works with NA predictions (@test.classify.R#126) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 132. Failure: classify works with NA predictions (@test.classify.R#126) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 133. Failure: classify works with NA predictions (@test.classify.R#126) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 134. Failure: classify works with NA predictions (@test.classify.R#126) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 135. Failure: classify works with NA predictions (@test.classify.R#126) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 136. Failure: classify works with NA predictions (@test.classify.R#126) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 137. Failure: classify works with NA predictions (@test.classify.R#126) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 138. Failure: classify works with NA predictions (@test.classify.R#126) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 139. Failure: classify works with NA predictions (@test.classify.R#126) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 140. Failure: classify works with NA predictions (@test.classify.R#126) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 141. Failure: classify works with NA predictions (@test.classify.R#133) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 142. Failure: classify works with NA predictions (@test.classify.R#133) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 143. Failure: classify works with NA predictions (@test.classify.R#133) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 144. Failure: classify works with NA predictions (@test.classify.R#133) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 145. Failure: classify works with NA predictions (@test.classify.R#133) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 146. Failure: classify works with NA predictions (@test.classify.R#133) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 147. Failure: classify works with NA predictions (@test.classify.R#133) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 148. Failure: classify works with NA predictions (@test.classify.R#133) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 149. Failure: classify works with NA predictions (@test.classify.R#133) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 150. Failure: classify works with NA predictions (@test.classify.R#133) ----
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 151. Failure: classify works with probabilities (@test.classify.R#160) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 152. Failure: classify works with probabilities (@test.classify.R#160) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 153. Failure: classify works with probabilities (@test.classify.R#160) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 154. Failure: classify works with probabilities (@test.classify.R#160) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 155. Failure: classify works with probabilities (@test.classify.R#160) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 156. Failure: classify works with probabilities (@test.classify.R#160) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 157. Failure: classify works with probabilities (@test.classify.R#160) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 158. Failure: classify works with probabilities (@test.classify.R#160) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 159. Failure: classify works with probabilities (@test.classify.R#160) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 160. Failure: classify works with probabilities (@test.classify.R#160) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 161. Failure: classify works with probabilities (@test.classify.R#167) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 162. Failure: classify works with probabilities (@test.classify.R#167) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 163. Failure: classify works with probabilities (@test.classify.R#167) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 164. Failure: classify works with probabilities (@test.classify.R#167) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 165. Failure: classify works with probabilities (@test.classify.R#167) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 166. Failure: classify works with probabilities (@test.classify.R#167) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 167. Failure: classify works with probabilities (@test.classify.R#167) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 168. Failure: classify works with probabilities (@test.classify.R#167) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 169. Failure: classify works with probabilities (@test.classify.R#167) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 170. Failure: classify works with probabilities (@test.classify.R#167) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 171. Failure: classify works with probabilities (@test.classify.R#174) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 172. Failure: classify works with probabilities (@test.classify.R#174) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 173. Failure: classify works with probabilities (@test.classify.R#174) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 174. Failure: classify works with probabilities (@test.classify.R#174) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 175. Failure: classify works with probabilities (@test.classify.R#174) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 176. Failure: classify works with probabilities (@test.classify.R#174) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 177. Failure: classify works with probabilities (@test.classify.R#174) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 178. Failure: classify works with probabilities (@test.classify.R#174) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 179. Failure: classify works with probabilities (@test.classify.R#174) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 180. Failure: classify works with probabilities (@test.classify.R#174) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 181. Failure: classify works with probabilities (@test.classify.R#181) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 182. Failure: classify works with probabilities (@test.classify.R#181) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 183. Failure: classify works with probabilities (@test.classify.R#181) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 184. Failure: classify works with probabilities (@test.classify.R#181) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 185. Failure: classify works with probabilities (@test.classify.R#181) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 186. Failure: classify works with probabilities (@test.classify.R#181) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 187. Failure: classify works with probabilities (@test.classify.R#181) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 188. Failure: classify works with probabilities (@test.classify.R#181) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 189. Failure: classify works with probabilities (@test.classify.R#181) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 190. Failure: classify works with probabilities (@test.classify.R#181) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 191. Failure: classify works with probabilities (@test.classify.R#188) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 192. Failure: classify works with probabilities (@test.classify.R#188) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 193. Failure: classify works with probabilities (@test.classify.R#188) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 194. Failure: classify works with probabilities (@test.classify.R#188) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 195. Failure: classify works with probabilities (@test.classify.R#188) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 196. Failure: classify works with probabilities (@test.classify.R#188) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 197. Failure: classify works with probabilities (@test.classify.R#188) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 198. Failure: classify works with probabilities (@test.classify.R#188) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 199. Failure: classify works with probabilities (@test.classify.R#188) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 200. Failure: classify works with probabilities (@test.classify.R#188) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 201. Failure: classify works with probabilities (@test.classify.R#195) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 202. Failure: classify works with probabilities (@test.classify.R#195) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 203. Failure: classify works with probabilities (@test.classify.R#195) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 204. Failure: classify works with probabilities (@test.classify.R#195) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 205. Failure: classify works with probabilities (@test.classify.R#195) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 206. Failure: classify works with probabilities (@test.classify.R#195) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 207. Failure: classify works with probabilities (@test.classify.R#195) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 208. Failure: classify works with probabilities (@test.classify.R#195) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 209. Failure: classify works with probabilities (@test.classify.R#195) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 210. Failure: classify works with probabilities (@test.classify.R#195) -----
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 211. Failure: classifyPairs classifies (@test.classifyPairs.R#4) -----------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 212. Failure: classifyPairs classifies (@test.classifyPairs.R#4) -----------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 213. Failure: classifyPairs classifies (@test.classifyPairs.R#4) -----------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 214. Failure: classifyPairs classifies (@test.classifyPairs.R#4) -----------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 215. Failure: classifyPairs classifies (@test.classifyPairs.R#4) -----------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 216. Failure: classifyPairs classifies (@test.classifyPairs.R#4) -----------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 217. Failure: classifyPairs classifies (@test.classifyPairs.R#4) -----------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 218. Failure: classifyPairs classifies (@test.classifyPairs.R#4) -----------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 219. Failure: classifyPairs classifies (@test.classifyPairs.R#4) -----------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 220. Failure: classifyPairs classifies (@test.classifyPairs.R#4) -----------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 221. Failure: classifyPairs returns predictor (@test.classifyPairs.R#15) ---
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 222. Failure: classifyPairs returns predictor (@test.classifyPairs.R#15) ---
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 223. Failure: classifyPairs returns predictor (@test.classifyPairs.R#15) ---
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 224. Failure: classifyPairs returns predictor (@test.classifyPairs.R#15) ---
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 225. Failure: classifyPairs returns predictor (@test.classifyPairs.R#15) ---
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 226. Failure: classifyPairs returns predictor (@test.classifyPairs.R#15) ---
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 227. Failure: classifyPairs returns predictor (@test.classifyPairs.R#15) ---
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 228. Failure: classifyPairs returns predictor (@test.classifyPairs.R#15) ---
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 229. Failure: classifyPairs returns predictor (@test.classifyPairs.R#15) ---
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 230. Failure: classifyPairs returns predictor (@test.classifyPairs.R#15) ---
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 231. Failure: classifyPairs returns predictor that works without IDs (@test.c
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 232. Failure: classifyPairs returns predictor that works without IDs (@test.c
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 233. Failure: classifyPairs returns predictor that works without IDs (@test.c
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 234. Failure: classifyPairs returns predictor that works without IDs (@test.c
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 235. Failure: classifyPairs returns predictor that works without IDs (@test.c
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 236. Failure: classifyPairs returns predictor that works without IDs (@test.c
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 237. Failure: classifyPairs returns predictor that works without IDs (@test.c
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 238. Failure: classifyPairs returns predictor that works without IDs (@test.c
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 239. Failure: classifyPairs returns predictor that works without IDs (@test.c
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 240. Failure: classifyPairs returns predictor that works without IDs (@test.c
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 241. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     -- 242. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     -- 243. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     -- 244. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     -- 245. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     -- 246. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     -- 247. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     -- 248. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     -- 249. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     -- 250. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     -- 251. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     -- 252. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     -- 253. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     -- 254. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     -- 255. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     -- 256. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     -- 257. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     -- 258. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     -- 259. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     -- 260. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     -- 261. Failure: classifyPairs respects minimize (@test.classifyPairs.R#64) ---
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 262. Failure: classifyPairs respects minimize (@test.classifyPairs.R#64) ---
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 263. Failure: classifyPairs respects minimize (@test.classifyPairs.R#64) ---
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 264. Failure: classifyPairs respects minimize (@test.classifyPairs.R#64) ---
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 265. Failure: classifyPairs respects minimize (@test.classifyPairs.R#64) ---
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 266. Failure: classifyPairs respects minimize (@test.classifyPairs.R#64) ---
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 267. Failure: classifyPairs respects minimize (@test.classifyPairs.R#64) ---
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 268. Failure: classifyPairs respects minimize (@test.classifyPairs.R#64) ---
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 269. Failure: classifyPairs respects minimize (@test.classifyPairs.R#64) ---
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 270. Failure: classifyPairs respects minimize (@test.classifyPairs.R#64) ---
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 271. Failure: classifyPairs respects minimize (@test.classifyPairs.R#72) ---
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 272. Failure: classifyPairs respects minimize (@test.classifyPairs.R#72) ---
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 273. Failure: classifyPairs respects minimize (@test.classifyPairs.R#72) ---
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 274. Failure: classifyPairs respects minimize (@test.classifyPairs.R#72) ---
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 275. Failure: classifyPairs respects minimize (@test.classifyPairs.R#72) ---
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 276. Failure: classifyPairs respects minimize (@test.classifyPairs.R#72) ---
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 277. Failure: classifyPairs respects minimize (@test.classifyPairs.R#72) ---
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 278. Failure: classifyPairs respects minimize (@test.classifyPairs.R#72) ---
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 279. Failure: classifyPairs respects minimize (@test.classifyPairs.R#72) ---
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 280. Failure: classifyPairs respects minimize (@test.classifyPairs.R#72) ---
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 281. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 282. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 283. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 284. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 285. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 286. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 287. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 288. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 289. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 290. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 291. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 292. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 293. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 294. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 295. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 296. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 297. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 298. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 299. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 300. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     -- 301. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 302. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 303. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 304. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 305. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 306. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 307. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 308. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 309. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 310. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 311. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 312. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 313. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 314. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 315. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 316. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 317. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 318. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 319. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 320. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 321. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 322. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 323. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 324. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 325. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 326. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 327. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 328. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 329. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 330. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 331. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 332. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 333. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 334. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 335. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 336. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 337. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 338. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 339. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 340. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 341. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 342. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 343. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 344. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 345. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 346. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 347. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 348. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 349. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 350. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 351. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 352. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 353. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 354. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 355. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 356. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 357. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 358. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 359. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 360. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 361. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 362. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 363. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 364. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 365. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 366. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 367. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 368. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 369. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 370. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 371. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     -- 372. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     -- 373. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     -- 374. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     -- 375. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     -- 376. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     -- 377. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     -- 378. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     -- 379. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     -- 380. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     -- 381. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     -- 382. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     -- 383. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     -- 384. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     -- 385. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     -- 386. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     -- 387. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     -- 388. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     -- 389. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     -- 390. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     -- 391. Failure: virtual best returns the vbs (@test.misc.R#6) ----------------
     ss$algorithm not equal to factor(bests[ss$id], levels = unique(bests)).
     Types not compatible: character is not integer
    
     -- 392. Failure: virtual best returns the vbs (@test.misc.R#6) ----------------
     ss$algorithm not equal to factor(bests[ss$id], levels = unique(bests)).
     Types not compatible: character is not integer
    
     -- 393. Failure: virtual best returns the vbs (@test.misc.R#6) ----------------
     ss$algorithm not equal to factor(bests[ss$id], levels = unique(bests)).
     Types not compatible: character is not integer
    
     -- 394. Failure: virtual best returns the vbs (@test.misc.R#6) ----------------
     ss$algorithm not equal to factor(bests[ss$id], levels = unique(bests)).
     Types not compatible: character is not integer
    
     -- 395. Failure: virtual best returns the vbs (@test.misc.R#6) ----------------
     ss$algorithm not equal to factor(bests[ss$id], levels = unique(bests)).
     Types not compatible: character is not integer
    
     -- 396. Failure: virtual best works with best list (@test.misc.R#17) ----------
     ss$algorithm not equal to factor(algs, levels = c("a", "b")).
     Types not compatible: character is not integer
    
     -- 397. Failure: virtual best works with best list (@test.misc.R#17) ----------
     ss$algorithm not equal to factor(algs, levels = c("a", "b")).
     Types not compatible: character is not integer
    
     -- 398. Failure: virtual best works with best list (@test.misc.R#17) ----------
     ss$algorithm not equal to factor(algs, levels = c("a", "b")).
     Types not compatible: character is not integer
    
     -- 399. Failure: single best returns the single best (@test.misc.R#52) --------
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 400. Failure: single best returns the single best (@test.misc.R#52) --------
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 401. Failure: single best returns the single best (@test.misc.R#52) --------
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 402. Failure: single best returns the single best (@test.misc.R#52) --------
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 403. Failure: single best returns the single best (@test.misc.R#52) --------
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 404. Failure: single best returns the single best (@test.misc.R#52) --------
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 405. Failure: single best returns the single best (@test.misc.R#52) --------
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 406. Failure: single best returns the single best (@test.misc.R#52) --------
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 407. Failure: single best returns the single best (@test.misc.R#52) --------
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 408. Failure: single best returns the single best (@test.misc.R#52) --------
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 409. Failure: single best returns the single best (@test.misc.R#57) --------
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     -- 410. Failure: single best returns the single best (@test.misc.R#57) --------
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     -- 411. Failure: single best returns the single best (@test.misc.R#57) --------
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     -- 412. Failure: single best returns the single best (@test.misc.R#57) --------
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     -- 413. Failure: single best returns the single best (@test.misc.R#57) --------
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     -- 414. Failure: single best returns the single best (@test.misc.R#57) --------
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     -- 415. Failure: single best returns the single best (@test.misc.R#57) --------
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     -- 416. Failure: single best returns the single best (@test.misc.R#57) --------
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     -- 417. Failure: single best returns the single best (@test.misc.R#57) --------
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     -- 418. Failure: single best returns the single best (@test.misc.R#57) --------
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     -- 419. Failure: single best works with best list (@test.misc.R#73) -----------
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 420. Failure: single best works with best list (@test.misc.R#73) -----------
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 421. Failure: single best works with best list (@test.misc.R#73) -----------
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 422. Failure: single best works with best list (@test.misc.R#73) -----------
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 423. Failure: single best works with best list (@test.misc.R#73) -----------
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 424. Failure: single best works with best list (@test.misc.R#73) -----------
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 425. Failure: single best works with best list (@test.misc.R#73) -----------
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 426. Failure: single best works with best list (@test.misc.R#73) -----------
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 427. Failure: single best works with best list (@test.misc.R#73) -----------
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 428. Failure: single best works with best list (@test.misc.R#73) -----------
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 429. Failure: single best works with best list (@test.misc.R#78) -----------
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     -- 430. Failure: single best works with best list (@test.misc.R#78) -----------
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     -- 431. Failure: single best works with best list (@test.misc.R#78) -----------
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     -- 432. Failure: single best works with best list (@test.misc.R#78) -----------
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     -- 433. Failure: single best works with best list (@test.misc.R#78) -----------
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     -- 434. Failure: single best works with best list (@test.misc.R#78) -----------
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     -- 435. Failure: single best works with best list (@test.misc.R#78) -----------
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     -- 436. Failure: single best works with best list (@test.misc.R#78) -----------
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     -- 437. Failure: single best works with best list (@test.misc.R#78) -----------
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     -- 438. Failure: single best works with best list (@test.misc.R#78) -----------
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     -- 439. Failure: single best by count returns the single best (@test.misc.R#91)
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     -- 440. Failure: single best by count returns the single best (@test.misc.R#91)
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     -- 441. Failure: single best by count returns the single best (@test.misc.R#91)
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     -- 442. Failure: single best by count works with best list (@test.misc.R#104) -
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     -- 443. Failure: single best by count works with best list (@test.misc.R#104) -
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     -- 444. Failure: single best by count works with best list (@test.misc.R#104) -
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     -- 445. Failure: single best by par returns the single best (@test.misc.R#117)
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 446. Failure: single best by par returns the single best (@test.misc.R#117)
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 447. Failure: single best by par returns the single best (@test.misc.R#117)
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 448. Failure: single best by par returns the single best (@test.misc.R#117)
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 449. Failure: single best by par returns the single best (@test.misc.R#117)
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 450. Failure: single best by par returns the single best (@test.misc.R#117)
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 451. Failure: single best by par returns the single best (@test.misc.R#117)
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 452. Failure: single best by par returns the single best (@test.misc.R#117)
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 453. Failure: single best by par returns the single best (@test.misc.R#117)
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 454. Failure: single best by par returns the single best (@test.misc.R#117)
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 455. Failure: single best by par works with best list (@test.misc.R#131) ---
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 456. Failure: single best by par works with best list (@test.misc.R#131) ---
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 457. Failure: single best by par works with best list (@test.misc.R#131) ---
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 458. Failure: single best by par works with best list (@test.misc.R#131) ---
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 459. Failure: single best by par works with best list (@test.misc.R#131) ---
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 460. Failure: single best by par works with best list (@test.misc.R#131) ---
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 461. Failure: single best by par works with best list (@test.misc.R#131) ---
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 462. Failure: single best by par works with best list (@test.misc.R#131) ---
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 463. Failure: single best by par works with best list (@test.misc.R#131) ---
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 464. Failure: single best by par works with best list (@test.misc.R#131) ---
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 465. Failure: single best by par works with train/test split (@test.misc.R#14
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 466. Failure: single best by par works with train/test split (@test.misc.R#14
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 467. Failure: single best by par works with train/test split (@test.misc.R#14
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 468. Failure: single best by par works with train/test split (@test.misc.R#14
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 469. Failure: single best by par works with train/test split (@test.misc.R#14
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 470. Failure: single best by par works with train/test split (@test.misc.R#14
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 471. Failure: single best by par works with train/test split (@test.misc.R#14
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 472. Failure: single best by par works with train/test split (@test.misc.R#14
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 473. Failure: single best by par works with train/test split (@test.misc.R#14
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 474. Failure: single best by par works with train/test split (@test.misc.R#14
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 475. Failure: single best by successes returns the single best (@test.misc.R#
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 476. Failure: single best by successes returns the single best (@test.misc.R#
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 477. Failure: single best by successes returns the single best (@test.misc.R#
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 478. Failure: single best by successes returns the single best (@test.misc.R#
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 479. Failure: single best by successes returns the single best (@test.misc.R#
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 480. Failure: single best by successes returns the single best (@test.misc.R#
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 481. Failure: single best by successes returns the single best (@test.misc.R#
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 482. Failure: single best by successes returns the single best (@test.misc.R#
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 483. Failure: single best by successes returns the single best (@test.misc.R#
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 484. Failure: single best by successes returns the single best (@test.misc.R#
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 485. Failure: single best by successes works with best list (@test.misc.R#177
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 486. Failure: single best by successes works with best list (@test.misc.R#177
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 487. Failure: single best by successes works with best list (@test.misc.R#177
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 488. Failure: single best by successes works with best list (@test.misc.R#177
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 489. Failure: single best by successes works with best list (@test.misc.R#177
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 490. Failure: single best by successes works with best list (@test.misc.R#177
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 491. Failure: single best by successes works with best list (@test.misc.R#177
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 492. Failure: single best by successes works with best list (@test.misc.R#177
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 493. Failure: single best by successes works with best list (@test.misc.R#177
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 494. Failure: single best by successes works with best list (@test.misc.R#177
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     -- 495. Failure: predTable tabulates (@test.misc.R#211) -----------------------
     as.vector(tab1) not equal to c(2, 1).
     Lengths differ: 0 is not 2
    
     -- 496. Failure: predTable tabulates (@test.misc.R#212) -----------------------
     names(tab1) not equal to c("a", "b").
     target is NULL, current is character
    
     -- 497. Failure: predTable tabulates (@test.misc.R#220) -----------------------
     as.vector(tab3) not equal to c(2, 1).
     Lengths differ: 0 is not 2
    
     -- 498. Failure: predTable tabulates (@test.misc.R#221) -----------------------
     names(tab3) not equal to c("a", "b").
     target is NULL, current is character
    
     -- 499. Failure: predTable tabulates (@test.misc.R#225) -----------------------
     as.vector(tab4) not equal to 3.
     Lengths differ: 0 is not 1
    
     -- 500. Failure: predTable tabulates (@test.misc.R#226) -----------------------
     names(tab4) not equal to "a".
     target is NULL, current is character
    
     -- 501. Failure: predTable tabulates (@test.misc.R#248) -----------------------
     as.vector(tab6) not equal to 6.
     Lengths differ: 0 is not 1
    
     -- 502. Failure: predTable tabulates (@test.misc.R#249) -----------------------
     names(tab6) not equal to "a".
     target is NULL, current is character
    
     -- 503. Failure: regression predicts (@test.regression.R#4) -------------------
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 504. Failure: regression predicts (@test.regression.R#4) -------------------
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 505. Failure: regression predicts (@test.regression.R#4) -------------------
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 506. Failure: regression predicts (@test.regression.R#4) -------------------
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 507. Failure: regression predicts (@test.regression.R#4) -------------------
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 508. Failure: regression predicts (@test.regression.R#4) -------------------
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 509. Failure: regression predicts (@test.regression.R#4) -------------------
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 510. Failure: regression predicts (@test.regression.R#4) -------------------
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 511. Failure: regression predicts (@test.regression.R#4) -------------------
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 512. Failure: regression predicts (@test.regression.R#4) -------------------
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 513. Failure: regression returns predictor (@test.regression.R#15) ---------
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 514. Failure: regression returns predictor (@test.regression.R#15) ---------
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 515. Failure: regression returns predictor (@test.regression.R#15) ---------
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 516. Failure: regression returns predictor (@test.regression.R#15) ---------
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 517. Failure: regression returns predictor (@test.regression.R#15) ---------
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 518. Failure: regression returns predictor (@test.regression.R#15) ---------
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 519. Failure: regression returns predictor (@test.regression.R#15) ---------
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 520. Failure: regression returns predictor (@test.regression.R#15) ---------
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 521. Failure: regression returns predictor (@test.regression.R#15) ---------
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 522. Failure: regression returns predictor (@test.regression.R#15) ---------
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 523. Failure: regression returns predictor that works without IDs (@test.regr
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 524. Failure: regression returns predictor that works without IDs (@test.regr
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 525. Failure: regression returns predictor that works without IDs (@test.regr
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 526. Failure: regression returns predictor that works without IDs (@test.regr
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 527. Failure: regression returns predictor that works without IDs (@test.regr
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 528. Failure: regression returns predictor that works without IDs (@test.regr
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 529. Failure: regression returns predictor that works without IDs (@test.regr
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 530. Failure: regression returns predictor that works without IDs (@test.regr
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 531. Failure: regression returns predictor that works without IDs (@test.regr
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 532. Failure: regression returns predictor that works without IDs (@test.regr
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 533. Failure: regression allows to combine by max (@test.regression.R#56) --
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     -- 534. Failure: regression allows to combine by max (@test.regression.R#56) --
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     -- 535. Failure: regression allows to combine by max (@test.regression.R#56) --
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     -- 536. Failure: regression allows to combine by max (@test.regression.R#56) --
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     -- 537. Failure: regression allows to combine by max (@test.regression.R#56) --
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     -- 538. Failure: regression allows to combine by max (@test.regression.R#56) --
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     -- 539. Failure: regression allows to combine by max (@test.regression.R#56) --
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     -- 540. Failure: regression allows to combine by max (@test.regression.R#56) --
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     -- 541. Failure: regression allows to combine by max (@test.regression.R#56) --
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     -- 542. Failure: regression allows to combine by max (@test.regression.R#56) --
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     -- 543. Failure: regression allows to combine by max (@test.regression.R#64) --
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     -- 544. Failure: regression allows to combine by max (@test.regression.R#64) --
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     -- 545. Failure: regression allows to combine by max (@test.regression.R#64) --
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     -- 546. Failure: regression allows to combine by max (@test.regression.R#64) --
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     -- 547. Failure: regression allows to combine by max (@test.regression.R#64) --
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     -- 548. Failure: regression allows to combine by max (@test.regression.R#64) --
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     -- 549. Failure: regression allows to combine by max (@test.regression.R#64) --
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     -- 550. Failure: regression allows to combine by max (@test.regression.R#64) --
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     -- 551. Failure: regression allows to combine by max (@test.regression.R#64) --
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     -- 552. Failure: regression allows to combine by max (@test.regression.R#64) --
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     -- 553. Failure: regression allows stacking (@test.regression.R#73) -----------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 554. Failure: regression allows stacking (@test.regression.R#73) -----------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 555. Failure: regression allows stacking (@test.regression.R#73) -----------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 556. Failure: regression allows stacking (@test.regression.R#73) -----------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 557. Failure: regression allows stacking (@test.regression.R#73) -----------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 558. Failure: regression allows stacking (@test.regression.R#73) -----------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 559. Failure: regression allows stacking (@test.regression.R#73) -----------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 560. Failure: regression allows stacking (@test.regression.R#73) -----------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 561. Failure: regression allows stacking (@test.regression.R#73) -----------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 562. Failure: regression allows stacking (@test.regression.R#73) -----------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 563. Failure: regression allows stacking (@test.regression.R#81) -----------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 564. Failure: regression allows stacking (@test.regression.R#81) -----------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 565. Failure: regression allows stacking (@test.regression.R#81) -----------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 566. Failure: regression allows stacking (@test.regression.R#81) -----------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 567. Failure: regression allows stacking (@test.regression.R#81) -----------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 568. Failure: regression allows stacking (@test.regression.R#81) -----------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 569. Failure: regression allows stacking (@test.regression.R#81) -----------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 570. Failure: regression allows stacking (@test.regression.R#81) -----------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 571. Failure: regression allows stacking (@test.regression.R#81) -----------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 572. Failure: regression allows stacking (@test.regression.R#81) -----------
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 573. Failure: regression works with single algorithm (@test.regression.R#122)
     ss$algorithm not equal to factor(c("b")).
     Types not compatible: character is not integer
    
     -- 574. Failure: regression works with single algorithm (@test.regression.R#122)
     ss$algorithm not equal to factor(c("b")).
     Types not compatible: character is not integer
    
     -- 575. Failure: regression works with single algorithm (@test.regression.R#122)
     ss$algorithm not equal to factor(c("b")).
     Types not compatible: character is not integer
    
     -- 576. Failure: regression works with single algorithm (@test.regression.R#122)
     ss$algorithm not equal to factor(c("b")).
     Types not compatible: character is not integer
    
     -- 577. Failure: regression works with single algorithm (@test.regression.R#122)
     ss$algorithm not equal to factor(c("b")).
     Types not compatible: character is not integer
    
     -- 578. Failure: regression works with single algorithm (@test.regression.R#122)
     ss$algorithm not equal to factor(c("b")).
     Types not compatible: character is not integer
    
     -- 579. Failure: regression works with single algorithm (@test.regression.R#122)
     ss$algorithm not equal to factor(c("b")).
     Types not compatible: character is not integer
    
     -- 580. Failure: regression works with single algorithm (@test.regression.R#122)
     ss$algorithm not equal to factor(c("b")).
     Types not compatible: character is not integer
    
     -- 581. Failure: regression works with single algorithm (@test.regression.R#122)
     ss$algorithm not equal to factor(c("b")).
     Types not compatible: character is not integer
    
     -- 582. Failure: regression works with single algorithm (@test.regression.R#122)
     ss$algorithm not equal to factor(c("b")).
     Types not compatible: character is not integer
    
     -- 583. Failure: regressionPairs predicts (@test.regressionPairs.R#4) ---------
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 584. Failure: regressionPairs predicts (@test.regressionPairs.R#4) ---------
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 585. Failure: regressionPairs predicts (@test.regressionPairs.R#4) ---------
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 586. Failure: regressionPairs predicts (@test.regressionPairs.R#4) ---------
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 587. Failure: regressionPairs predicts (@test.regressionPairs.R#4) ---------
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 588. Failure: regressionPairs predicts (@test.regressionPairs.R#4) ---------
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 589. Failure: regressionPairs predicts (@test.regressionPairs.R#4) ---------
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 590. Failure: regressionPairs predicts (@test.regressionPairs.R#4) ---------
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 591. Failure: regressionPairs predicts (@test.regressionPairs.R#4) ---------
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 592. Failure: regressionPairs predicts (@test.regressionPairs.R#4) ---------
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 593. Failure: regressionPairs returns predictor (@test.regressionPairs.R#15)
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 594. Failure: regressionPairs returns predictor (@test.regressionPairs.R#15)
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 595. Failure: regressionPairs returns predictor (@test.regressionPairs.R#15)
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 596. Failure: regressionPairs returns predictor (@test.regressionPairs.R#15)
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 597. Failure: regressionPairs returns predictor (@test.regressionPairs.R#15)
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 598. Failure: regressionPairs returns predictor (@test.regressionPairs.R#15)
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 599. Failure: regressionPairs returns predictor (@test.regressionPairs.R#15)
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 600. Failure: regressionPairs returns predictor (@test.regressionPairs.R#15)
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 601. Failure: regressionPairs returns predictor (@test.regressionPairs.R#15)
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 602. Failure: regressionPairs returns predictor (@test.regressionPairs.R#15)
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 603. Failure: regressionPairs returns predictor that works without IDs (@test
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 604. Failure: regressionPairs returns predictor that works without IDs (@test
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 605. Failure: regressionPairs returns predictor that works without IDs (@test
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 606. Failure: regressionPairs returns predictor that works without IDs (@test
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 607. Failure: regressionPairs returns predictor that works without IDs (@test
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 608. Failure: regressionPairs returns predictor that works without IDs (@test
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 609. Failure: regressionPairs returns predictor that works without IDs (@test
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 610. Failure: regressionPairs returns predictor that works without IDs (@test
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 611. Failure: regressionPairs returns predictor that works without IDs (@test
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 612. Failure: regressionPairs returns predictor that works without IDs (@test
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     -- 613. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     -- 614. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     -- 615. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     -- 616. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     -- 617. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     -- 618. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     -- 619. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     -- 620. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     -- 621. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     -- 622. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     -- 623. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     -- 624. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     -- 625. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     -- 626. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     -- 627. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     -- 628. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     -- 629. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     -- 630. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     -- 631. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     -- 632. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     -- 633. Failure: regressionPairs respects minimize (@test.regressionPairs.R#73)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     -- 634. Failure: regressionPairs respects minimize (@test.regressionPairs.R#73)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     -- 635. Failure: regressionPairs respects minimize (@test.regressionPairs.R#73)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     -- 636. Failure: regressionPairs respects minimize (@test.regressionPairs.R#73)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     -- 637. Failure: regressionPairs respects minimize (@test.regressionPairs.R#73)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     -- 638. Failure: regressionPairs respects minimize (@test.regressionPairs.R#73)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     -- 639. Failure: regressionPairs respects minimize (@test.regressionPairs.R#73)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     -- 640. Failure: regressionPairs respects minimize (@test.regressionPairs.R#73)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     -- 641. Failure: regressionPairs respects minimize (@test.regressionPairs.R#73)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     -- 642. Failure: regressionPairs respects minimize (@test.regressionPairs.R#73)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     -- 643. Failure: regressionPairs respects minimize (@test.regressionPairs.R#81)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     -- 644. Failure: regressionPairs respects minimize (@test.regressionPairs.R#81)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     -- 645. Failure: regressionPairs respects minimize (@test.regressionPairs.R#81)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     -- 646. Failure: regressionPairs respects minimize (@test.regressionPairs.R#81)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     -- 647. Failure: regressionPairs respects minimize (@test.regressionPairs.R#81)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     -- 648. Failure: regressionPairs respects minimize (@test.regressionPairs.R#81)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     -- 649. Failure: regressionPairs respects minimize (@test.regressionPairs.R#81)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     -- 650. Failure: regressionPairs respects minimize (@test.regressionPairs.R#81)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     -- 651. Failure: regressionPairs respects minimize (@test.regressionPairs.R#81)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     -- 652. Failure: regressionPairs respects minimize (@test.regressionPairs.R#81)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     -- 653. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 654. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 655. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 656. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 657. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 658. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 659. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 660. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 661. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 662. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 663. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 664. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 665. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 666. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 667. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 668. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 669. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 670. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 671. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     -- 672. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     == testthat results ===========================================================
     [ OK: 1417 | SKIPPED: 10 | WARNINGS: 2 | FAILED: 672 ]
     1. Failure: classify classifies (@test.classify.R#4)
     2. Failure: classify classifies (@test.classify.R#4)
     3. Failure: classify classifies (@test.classify.R#4)
     4. Failure: classify classifies (@test.classify.R#4)
     5. Failure: classify classifies (@test.classify.R#4)
     6. Failure: classify classifies (@test.classify.R#4)
     7. Failure: classify classifies (@test.classify.R#4)
     8. Failure: classify classifies (@test.classify.R#4)
     9. Failure: classify classifies (@test.classify.R#4)
     1. ...
    
     Error: testthat unit tests failed
     Execution halted
Flavor: r-devel-linux-x86_64-debian-clang

Version: 0.9.2
Check: tests
Result: ERROR
     Running ‘run-all.R’ [15s/21s]
    Running the tests in ‘tests/run-all.R’ failed.
    Complete output:
     > library(testthat)
     > library(ParamHelpers)
     >
     > test_check("llama")
     Loading required package: llama
     Loading required package: mlr
     'mlr' is in maintenance mode since July 2019. Future development
     efforts will go into its successor 'mlr3' (<https://mlr3.mlr-org.com>).
     ── 1. Failure: classify classifies (@test.classify.R#4) ───────────────────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 2. Failure: classify classifies (@test.classify.R#4) ───────────────────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 3. Failure: classify classifies (@test.classify.R#4) ───────────────────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 4. Failure: classify classifies (@test.classify.R#4) ───────────────────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 5. Failure: classify classifies (@test.classify.R#4) ───────────────────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 6. Failure: classify classifies (@test.classify.R#4) ───────────────────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 7. Failure: classify classifies (@test.classify.R#4) ───────────────────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 8. Failure: classify classifies (@test.classify.R#4) ───────────────────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 9. Failure: classify classifies (@test.classify.R#4) ───────────────────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 10. Failure: classify classifies (@test.classify.R#4) ──────────────────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 11. Failure: classify returns predictor (@test.classify.R#15) ──────────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 12. Failure: classify returns predictor (@test.classify.R#15) ──────────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 13. Failure: classify returns predictor (@test.classify.R#15) ──────────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 14. Failure: classify returns predictor (@test.classify.R#15) ──────────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 15. Failure: classify returns predictor (@test.classify.R#15) ──────────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 16. Failure: classify returns predictor (@test.classify.R#15) ──────────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 17. Failure: classify returns predictor (@test.classify.R#15) ──────────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 18. Failure: classify returns predictor (@test.classify.R#15) ──────────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 19. Failure: classify returns predictor (@test.classify.R#15) ──────────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 20. Failure: classify returns predictor (@test.classify.R#15) ──────────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 21. Failure: classify returns predictor that works without IDs (@test.classif
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 22. Failure: classify returns predictor that works without IDs (@test.classif
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 23. Failure: classify returns predictor that works without IDs (@test.classif
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 24. Failure: classify returns predictor that works without IDs (@test.classif
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 25. Failure: classify returns predictor that works without IDs (@test.classif
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 26. Failure: classify returns predictor that works without IDs (@test.classif
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 27. Failure: classify returns predictor that works without IDs (@test.classif
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 28. Failure: classify returns predictor that works without IDs (@test.classif
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 29. Failure: classify returns predictor that works without IDs (@test.classif
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 30. Failure: classify returns predictor that works without IDs (@test.classif
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 31. Failure: classify takes list of classifiers (@test.classify.R#47) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 32. Failure: classify takes list of classifiers (@test.classify.R#47) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 33. Failure: classify takes list of classifiers (@test.classify.R#47) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 34. Failure: classify takes list of classifiers (@test.classify.R#47) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 35. Failure: classify takes list of classifiers (@test.classify.R#47) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 36. Failure: classify takes list of classifiers (@test.classify.R#47) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 37. Failure: classify takes list of classifiers (@test.classify.R#47) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 38. Failure: classify takes list of classifiers (@test.classify.R#47) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 39. Failure: classify takes list of classifiers (@test.classify.R#47) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 40. Failure: classify takes list of classifiers (@test.classify.R#47) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 41. Failure: classify takes list of classifiers (@test.classify.R#55) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 42. Failure: classify takes list of classifiers (@test.classify.R#55) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 43. Failure: classify takes list of classifiers (@test.classify.R#55) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 44. Failure: classify takes list of classifiers (@test.classify.R#55) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 45. Failure: classify takes list of classifiers (@test.classify.R#55) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 46. Failure: classify takes list of classifiers (@test.classify.R#55) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 47. Failure: classify takes list of classifiers (@test.classify.R#55) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 48. Failure: classify takes list of classifiers (@test.classify.R#55) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 49. Failure: classify takes list of classifiers (@test.classify.R#55) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 50. Failure: classify takes list of classifiers (@test.classify.R#55) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 51. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 52. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 53. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 54. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 55. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 56. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 57. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 58. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 59. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 60. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 61. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 62. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 63. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 64. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 65. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 66. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 67. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 68. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 69. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 70. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 71. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 72. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 73. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 74. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 75. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 76. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 77. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 78. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 79. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 80. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 81. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 82. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 83. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 84. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 85. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 86. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 87. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 88. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 89. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 90. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 91. Failure: classify works with NA predictions (@test.classify.R#98) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 92. Failure: classify works with NA predictions (@test.classify.R#98) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 93. Failure: classify works with NA predictions (@test.classify.R#98) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 94. Failure: classify works with NA predictions (@test.classify.R#98) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 95. Failure: classify works with NA predictions (@test.classify.R#98) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 96. Failure: classify works with NA predictions (@test.classify.R#98) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 97. Failure: classify works with NA predictions (@test.classify.R#98) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 98. Failure: classify works with NA predictions (@test.classify.R#98) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 99. Failure: classify works with NA predictions (@test.classify.R#98) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 100. Failure: classify works with NA predictions (@test.classify.R#98) ─────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 101. Failure: classify works with NA predictions (@test.classify.R#105) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 102. Failure: classify works with NA predictions (@test.classify.R#105) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 103. Failure: classify works with NA predictions (@test.classify.R#105) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 104. Failure: classify works with NA predictions (@test.classify.R#105) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 105. Failure: classify works with NA predictions (@test.classify.R#105) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 106. Failure: classify works with NA predictions (@test.classify.R#105) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 107. Failure: classify works with NA predictions (@test.classify.R#105) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 108. Failure: classify works with NA predictions (@test.classify.R#105) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 109. Failure: classify works with NA predictions (@test.classify.R#105) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 110. Failure: classify works with NA predictions (@test.classify.R#105) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 111. Failure: classify works with NA predictions (@test.classify.R#112) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 112. Failure: classify works with NA predictions (@test.classify.R#112) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 113. Failure: classify works with NA predictions (@test.classify.R#112) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 114. Failure: classify works with NA predictions (@test.classify.R#112) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 115. Failure: classify works with NA predictions (@test.classify.R#112) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 116. Failure: classify works with NA predictions (@test.classify.R#112) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 117. Failure: classify works with NA predictions (@test.classify.R#112) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 118. Failure: classify works with NA predictions (@test.classify.R#112) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 119. Failure: classify works with NA predictions (@test.classify.R#112) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 120. Failure: classify works with NA predictions (@test.classify.R#112) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 121. Failure: classify works with NA predictions (@test.classify.R#119) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 122. Failure: classify works with NA predictions (@test.classify.R#119) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 123. Failure: classify works with NA predictions (@test.classify.R#119) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 124. Failure: classify works with NA predictions (@test.classify.R#119) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 125. Failure: classify works with NA predictions (@test.classify.R#119) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 126. Failure: classify works with NA predictions (@test.classify.R#119) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 127. Failure: classify works with NA predictions (@test.classify.R#119) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 128. Failure: classify works with NA predictions (@test.classify.R#119) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 129. Failure: classify works with NA predictions (@test.classify.R#119) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 130. Failure: classify works with NA predictions (@test.classify.R#119) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 131. Failure: classify works with NA predictions (@test.classify.R#126) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 132. Failure: classify works with NA predictions (@test.classify.R#126) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 133. Failure: classify works with NA predictions (@test.classify.R#126) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 134. Failure: classify works with NA predictions (@test.classify.R#126) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 135. Failure: classify works with NA predictions (@test.classify.R#126) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 136. Failure: classify works with NA predictions (@test.classify.R#126) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 137. Failure: classify works with NA predictions (@test.classify.R#126) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 138. Failure: classify works with NA predictions (@test.classify.R#126) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 139. Failure: classify works with NA predictions (@test.classify.R#126) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 140. Failure: classify works with NA predictions (@test.classify.R#126) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 141. Failure: classify works with NA predictions (@test.classify.R#133) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 142. Failure: classify works with NA predictions (@test.classify.R#133) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 143. Failure: classify works with NA predictions (@test.classify.R#133) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 144. Failure: classify works with NA predictions (@test.classify.R#133) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 145. Failure: classify works with NA predictions (@test.classify.R#133) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 146. Failure: classify works with NA predictions (@test.classify.R#133) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 147. Failure: classify works with NA predictions (@test.classify.R#133) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 148. Failure: classify works with NA predictions (@test.classify.R#133) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 149. Failure: classify works with NA predictions (@test.classify.R#133) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 150. Failure: classify works with NA predictions (@test.classify.R#133) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 151. Failure: classify works with probabilities (@test.classify.R#160) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 152. Failure: classify works with probabilities (@test.classify.R#160) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 153. Failure: classify works with probabilities (@test.classify.R#160) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 154. Failure: classify works with probabilities (@test.classify.R#160) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 155. Failure: classify works with probabilities (@test.classify.R#160) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 156. Failure: classify works with probabilities (@test.classify.R#160) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 157. Failure: classify works with probabilities (@test.classify.R#160) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 158. Failure: classify works with probabilities (@test.classify.R#160) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 159. Failure: classify works with probabilities (@test.classify.R#160) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 160. Failure: classify works with probabilities (@test.classify.R#160) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 161. Failure: classify works with probabilities (@test.classify.R#167) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 162. Failure: classify works with probabilities (@test.classify.R#167) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 163. Failure: classify works with probabilities (@test.classify.R#167) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 164. Failure: classify works with probabilities (@test.classify.R#167) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 165. Failure: classify works with probabilities (@test.classify.R#167) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 166. Failure: classify works with probabilities (@test.classify.R#167) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 167. Failure: classify works with probabilities (@test.classify.R#167) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 168. Failure: classify works with probabilities (@test.classify.R#167) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 169. Failure: classify works with probabilities (@test.classify.R#167) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 170. Failure: classify works with probabilities (@test.classify.R#167) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 171. Failure: classify works with probabilities (@test.classify.R#174) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 172. Failure: classify works with probabilities (@test.classify.R#174) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 173. Failure: classify works with probabilities (@test.classify.R#174) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 174. Failure: classify works with probabilities (@test.classify.R#174) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 175. Failure: classify works with probabilities (@test.classify.R#174) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 176. Failure: classify works with probabilities (@test.classify.R#174) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 177. Failure: classify works with probabilities (@test.classify.R#174) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 178. Failure: classify works with probabilities (@test.classify.R#174) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 179. Failure: classify works with probabilities (@test.classify.R#174) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 180. Failure: classify works with probabilities (@test.classify.R#174) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 181. Failure: classify works with probabilities (@test.classify.R#181) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 182. Failure: classify works with probabilities (@test.classify.R#181) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 183. Failure: classify works with probabilities (@test.classify.R#181) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 184. Failure: classify works with probabilities (@test.classify.R#181) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 185. Failure: classify works with probabilities (@test.classify.R#181) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 186. Failure: classify works with probabilities (@test.classify.R#181) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 187. Failure: classify works with probabilities (@test.classify.R#181) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 188. Failure: classify works with probabilities (@test.classify.R#181) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 189. Failure: classify works with probabilities (@test.classify.R#181) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 190. Failure: classify works with probabilities (@test.classify.R#181) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 191. Failure: classify works with probabilities (@test.classify.R#188) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 192. Failure: classify works with probabilities (@test.classify.R#188) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 193. Failure: classify works with probabilities (@test.classify.R#188) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 194. Failure: classify works with probabilities (@test.classify.R#188) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 195. Failure: classify works with probabilities (@test.classify.R#188) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 196. Failure: classify works with probabilities (@test.classify.R#188) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 197. Failure: classify works with probabilities (@test.classify.R#188) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 198. Failure: classify works with probabilities (@test.classify.R#188) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 199. Failure: classify works with probabilities (@test.classify.R#188) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 200. Failure: classify works with probabilities (@test.classify.R#188) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 201. Failure: classify works with probabilities (@test.classify.R#195) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 202. Failure: classify works with probabilities (@test.classify.R#195) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 203. Failure: classify works with probabilities (@test.classify.R#195) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 204. Failure: classify works with probabilities (@test.classify.R#195) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 205. Failure: classify works with probabilities (@test.classify.R#195) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 206. Failure: classify works with probabilities (@test.classify.R#195) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 207. Failure: classify works with probabilities (@test.classify.R#195) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 208. Failure: classify works with probabilities (@test.classify.R#195) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 209. Failure: classify works with probabilities (@test.classify.R#195) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 210. Failure: classify works with probabilities (@test.classify.R#195) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 211. Failure: classifyPairs classifies (@test.classifyPairs.R#4) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 212. Failure: classifyPairs classifies (@test.classifyPairs.R#4) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 213. Failure: classifyPairs classifies (@test.classifyPairs.R#4) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 214. Failure: classifyPairs classifies (@test.classifyPairs.R#4) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 215. Failure: classifyPairs classifies (@test.classifyPairs.R#4) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 216. Failure: classifyPairs classifies (@test.classifyPairs.R#4) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 217. Failure: classifyPairs classifies (@test.classifyPairs.R#4) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 218. Failure: classifyPairs classifies (@test.classifyPairs.R#4) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 219. Failure: classifyPairs classifies (@test.classifyPairs.R#4) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 220. Failure: classifyPairs classifies (@test.classifyPairs.R#4) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 221. Failure: classifyPairs returns predictor (@test.classifyPairs.R#15) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 222. Failure: classifyPairs returns predictor (@test.classifyPairs.R#15) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 223. Failure: classifyPairs returns predictor (@test.classifyPairs.R#15) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 224. Failure: classifyPairs returns predictor (@test.classifyPairs.R#15) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 225. Failure: classifyPairs returns predictor (@test.classifyPairs.R#15) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 226. Failure: classifyPairs returns predictor (@test.classifyPairs.R#15) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 227. Failure: classifyPairs returns predictor (@test.classifyPairs.R#15) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 228. Failure: classifyPairs returns predictor (@test.classifyPairs.R#15) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 229. Failure: classifyPairs returns predictor (@test.classifyPairs.R#15) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 230. Failure: classifyPairs returns predictor (@test.classifyPairs.R#15) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 231. Failure: classifyPairs returns predictor that works without IDs (@test.c
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 232. Failure: classifyPairs returns predictor that works without IDs (@test.c
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 233. Failure: classifyPairs returns predictor that works without IDs (@test.c
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 234. Failure: classifyPairs returns predictor that works without IDs (@test.c
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 235. Failure: classifyPairs returns predictor that works without IDs (@test.c
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 236. Failure: classifyPairs returns predictor that works without IDs (@test.c
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 237. Failure: classifyPairs returns predictor that works without IDs (@test.c
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 238. Failure: classifyPairs returns predictor that works without IDs (@test.c
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 239. Failure: classifyPairs returns predictor that works without IDs (@test.c
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 240. Failure: classifyPairs returns predictor that works without IDs (@test.c
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 241. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     ── 242. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     ── 243. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     ── 244. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     ── 245. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     ── 246. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     ── 247. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     ── 248. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     ── 249. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     ── 250. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     ── 251. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     ── 252. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     ── 253. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     ── 254. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     ── 255. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     ── 256. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     ── 257. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     ── 258. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     ── 259. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     ── 260. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     ── 261. Failure: classifyPairs respects minimize (@test.classifyPairs.R#64) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 262. Failure: classifyPairs respects minimize (@test.classifyPairs.R#64) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 263. Failure: classifyPairs respects minimize (@test.classifyPairs.R#64) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 264. Failure: classifyPairs respects minimize (@test.classifyPairs.R#64) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 265. Failure: classifyPairs respects minimize (@test.classifyPairs.R#64) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 266. Failure: classifyPairs respects minimize (@test.classifyPairs.R#64) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 267. Failure: classifyPairs respects minimize (@test.classifyPairs.R#64) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 268. Failure: classifyPairs respects minimize (@test.classifyPairs.R#64) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 269. Failure: classifyPairs respects minimize (@test.classifyPairs.R#64) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 270. Failure: classifyPairs respects minimize (@test.classifyPairs.R#64) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 271. Failure: classifyPairs respects minimize (@test.classifyPairs.R#72) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 272. Failure: classifyPairs respects minimize (@test.classifyPairs.R#72) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 273. Failure: classifyPairs respects minimize (@test.classifyPairs.R#72) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 274. Failure: classifyPairs respects minimize (@test.classifyPairs.R#72) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 275. Failure: classifyPairs respects minimize (@test.classifyPairs.R#72) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 276. Failure: classifyPairs respects minimize (@test.classifyPairs.R#72) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 277. Failure: classifyPairs respects minimize (@test.classifyPairs.R#72) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 278. Failure: classifyPairs respects minimize (@test.classifyPairs.R#72) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 279. Failure: classifyPairs respects minimize (@test.classifyPairs.R#72) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 280. Failure: classifyPairs respects minimize (@test.classifyPairs.R#72) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 281. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 282. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 283. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 284. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 285. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 286. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 287. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 288. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 289. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 290. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 291. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 292. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 293. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 294. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 295. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 296. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 297. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 298. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 299. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 300. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 301. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 302. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 303. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 304. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 305. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 306. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 307. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 308. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 309. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 310. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 311. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 312. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 313. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 314. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 315. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 316. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 317. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 318. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 319. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 320. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 321. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 322. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 323. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 324. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 325. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 326. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 327. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 328. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 329. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 330. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 331. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 332. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 333. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 334. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 335. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 336. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 337. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 338. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 339. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 340. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 341. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 342. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 343. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 344. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 345. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 346. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 347. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 348. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 349. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 350. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 351. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 352. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 353. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 354. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 355. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 356. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 357. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 358. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 359. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 360. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 361. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 362. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 363. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 364. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 365. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 366. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 367. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 368. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 369. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 370. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 371. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     ── 372. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     ── 373. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     ── 374. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     ── 375. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     ── 376. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     ── 377. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     ── 378. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     ── 379. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     ── 380. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     ── 381. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     ── 382. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     ── 383. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     ── 384. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     ── 385. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     ── 386. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     ── 387. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     ── 388. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     ── 389. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     ── 390. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     ── 391. Failure: virtual best returns the vbs (@test.misc.R#6) ────────────────
     ss$algorithm not equal to factor(bests[ss$id], levels = unique(bests)).
     Types not compatible: character is not integer
    
     ── 392. Failure: virtual best returns the vbs (@test.misc.R#6) ────────────────
     ss$algorithm not equal to factor(bests[ss$id], levels = unique(bests)).
     Types not compatible: character is not integer
    
     ── 393. Failure: virtual best returns the vbs (@test.misc.R#6) ────────────────
     ss$algorithm not equal to factor(bests[ss$id], levels = unique(bests)).
     Types not compatible: character is not integer
    
     ── 394. Failure: virtual best returns the vbs (@test.misc.R#6) ────────────────
     ss$algorithm not equal to factor(bests[ss$id], levels = unique(bests)).
     Types not compatible: character is not integer
    
     ── 395. Failure: virtual best returns the vbs (@test.misc.R#6) ────────────────
     ss$algorithm not equal to factor(bests[ss$id], levels = unique(bests)).
     Types not compatible: character is not integer
    
     ── 396. Failure: virtual best works with best list (@test.misc.R#17) ──────────
     ss$algorithm not equal to factor(algs, levels = c("a", "b")).
     Types not compatible: character is not integer
    
     ── 397. Failure: virtual best works with best list (@test.misc.R#17) ──────────
     ss$algorithm not equal to factor(algs, levels = c("a", "b")).
     Types not compatible: character is not integer
    
     ── 398. Failure: virtual best works with best list (@test.misc.R#17) ──────────
     ss$algorithm not equal to factor(algs, levels = c("a", "b")).
     Types not compatible: character is not integer
    
     ── 399. Failure: single best returns the single best (@test.misc.R#52) ────────
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 400. Failure: single best returns the single best (@test.misc.R#52) ────────
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 401. Failure: single best returns the single best (@test.misc.R#52) ────────
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 402. Failure: single best returns the single best (@test.misc.R#52) ────────
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 403. Failure: single best returns the single best (@test.misc.R#52) ────────
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 404. Failure: single best returns the single best (@test.misc.R#52) ────────
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 405. Failure: single best returns the single best (@test.misc.R#52) ────────
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 406. Failure: single best returns the single best (@test.misc.R#52) ────────
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 407. Failure: single best returns the single best (@test.misc.R#52) ────────
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 408. Failure: single best returns the single best (@test.misc.R#52) ────────
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 409. Failure: single best returns the single best (@test.misc.R#57) ────────
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 410. Failure: single best returns the single best (@test.misc.R#57) ────────
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 411. Failure: single best returns the single best (@test.misc.R#57) ────────
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 412. Failure: single best returns the single best (@test.misc.R#57) ────────
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 413. Failure: single best returns the single best (@test.misc.R#57) ────────
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 414. Failure: single best returns the single best (@test.misc.R#57) ────────
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 415. Failure: single best returns the single best (@test.misc.R#57) ────────
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 416. Failure: single best returns the single best (@test.misc.R#57) ────────
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 417. Failure: single best returns the single best (@test.misc.R#57) ────────
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 418. Failure: single best returns the single best (@test.misc.R#57) ────────
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 419. Failure: single best works with best list (@test.misc.R#73) ───────────
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 420. Failure: single best works with best list (@test.misc.R#73) ───────────
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 421. Failure: single best works with best list (@test.misc.R#73) ───────────
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 422. Failure: single best works with best list (@test.misc.R#73) ───────────
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 423. Failure: single best works with best list (@test.misc.R#73) ───────────
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 424. Failure: single best works with best list (@test.misc.R#73) ───────────
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 425. Failure: single best works with best list (@test.misc.R#73) ───────────
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 426. Failure: single best works with best list (@test.misc.R#73) ───────────
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 427. Failure: single best works with best list (@test.misc.R#73) ───────────
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 428. Failure: single best works with best list (@test.misc.R#73) ───────────
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 429. Failure: single best works with best list (@test.misc.R#78) ───────────
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 430. Failure: single best works with best list (@test.misc.R#78) ───────────
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 431. Failure: single best works with best list (@test.misc.R#78) ───────────
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 432. Failure: single best works with best list (@test.misc.R#78) ───────────
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 433. Failure: single best works with best list (@test.misc.R#78) ───────────
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 434. Failure: single best works with best list (@test.misc.R#78) ───────────
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 435. Failure: single best works with best list (@test.misc.R#78) ───────────
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 436. Failure: single best works with best list (@test.misc.R#78) ───────────
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 437. Failure: single best works with best list (@test.misc.R#78) ───────────
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 438. Failure: single best works with best list (@test.misc.R#78) ───────────
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 439. Failure: single best by count returns the single best (@test.misc.R#91)
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 440. Failure: single best by count returns the single best (@test.misc.R#91)
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 441. Failure: single best by count returns the single best (@test.misc.R#91)
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 442. Failure: single best by count works with best list (@test.misc.R#104) ─
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 443. Failure: single best by count works with best list (@test.misc.R#104) ─
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 444. Failure: single best by count works with best list (@test.misc.R#104) ─
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 445. Failure: single best by par returns the single best (@test.misc.R#117)
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 446. Failure: single best by par returns the single best (@test.misc.R#117)
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 447. Failure: single best by par returns the single best (@test.misc.R#117)
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 448. Failure: single best by par returns the single best (@test.misc.R#117)
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 449. Failure: single best by par returns the single best (@test.misc.R#117)
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 450. Failure: single best by par returns the single best (@test.misc.R#117)
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 451. Failure: single best by par returns the single best (@test.misc.R#117)
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 452. Failure: single best by par returns the single best (@test.misc.R#117)
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 453. Failure: single best by par returns the single best (@test.misc.R#117)
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 454. Failure: single best by par returns the single best (@test.misc.R#117)
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 455. Failure: single best by par works with best list (@test.misc.R#131) ───
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 456. Failure: single best by par works with best list (@test.misc.R#131) ───
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 457. Failure: single best by par works with best list (@test.misc.R#131) ───
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 458. Failure: single best by par works with best list (@test.misc.R#131) ───
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 459. Failure: single best by par works with best list (@test.misc.R#131) ───
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 460. Failure: single best by par works with best list (@test.misc.R#131) ───
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 461. Failure: single best by par works with best list (@test.misc.R#131) ───
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 462. Failure: single best by par works with best list (@test.misc.R#131) ───
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 463. Failure: single best by par works with best list (@test.misc.R#131) ───
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 464. Failure: single best by par works with best list (@test.misc.R#131) ───
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 465. Failure: single best by par works with train/test split (@test.misc.R#14
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 466. Failure: single best by par works with train/test split (@test.misc.R#14
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 467. Failure: single best by par works with train/test split (@test.misc.R#14
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 468. Failure: single best by par works with train/test split (@test.misc.R#14
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 469. Failure: single best by par works with train/test split (@test.misc.R#14
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 470. Failure: single best by par works with train/test split (@test.misc.R#14
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 471. Failure: single best by par works with train/test split (@test.misc.R#14
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 472. Failure: single best by par works with train/test split (@test.misc.R#14
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 473. Failure: single best by par works with train/test split (@test.misc.R#14
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 474. Failure: single best by par works with train/test split (@test.misc.R#14
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 475. Failure: single best by successes returns the single best (@test.misc.R#
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 476. Failure: single best by successes returns the single best (@test.misc.R#
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 477. Failure: single best by successes returns the single best (@test.misc.R#
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 478. Failure: single best by successes returns the single best (@test.misc.R#
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 479. Failure: single best by successes returns the single best (@test.misc.R#
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 480. Failure: single best by successes returns the single best (@test.misc.R#
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 481. Failure: single best by successes returns the single best (@test.misc.R#
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 482. Failure: single best by successes returns the single best (@test.misc.R#
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 483. Failure: single best by successes returns the single best (@test.misc.R#
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 484. Failure: single best by successes returns the single best (@test.misc.R#
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 485. Failure: single best by successes works with best list (@test.misc.R#177
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 486. Failure: single best by successes works with best list (@test.misc.R#177
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 487. Failure: single best by successes works with best list (@test.misc.R#177
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 488. Failure: single best by successes works with best list (@test.misc.R#177
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 489. Failure: single best by successes works with best list (@test.misc.R#177
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 490. Failure: single best by successes works with best list (@test.misc.R#177
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 491. Failure: single best by successes works with best list (@test.misc.R#177
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 492. Failure: single best by successes works with best list (@test.misc.R#177
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 493. Failure: single best by successes works with best list (@test.misc.R#177
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 494. Failure: single best by successes works with best list (@test.misc.R#177
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 495. Failure: predTable tabulates (@test.misc.R#211) ───────────────────────
     as.vector(tab1) not equal to c(2, 1).
     Lengths differ: 0 is not 2
    
     ── 496. Failure: predTable tabulates (@test.misc.R#212) ───────────────────────
     names(tab1) not equal to c("a", "b").
     target is NULL, current is character
    
     ── 497. Failure: predTable tabulates (@test.misc.R#220) ───────────────────────
     as.vector(tab3) not equal to c(2, 1).
     Lengths differ: 0 is not 2
    
     ── 498. Failure: predTable tabulates (@test.misc.R#221) ───────────────────────
     names(tab3) not equal to c("a", "b").
     target is NULL, current is character
    
     ── 499. Failure: predTable tabulates (@test.misc.R#225) ───────────────────────
     as.vector(tab4) not equal to 3.
     Lengths differ: 0 is not 1
    
     ── 500. Failure: predTable tabulates (@test.misc.R#226) ───────────────────────
     names(tab4) not equal to "a".
     target is NULL, current is character
    
     ── 501. Failure: predTable tabulates (@test.misc.R#248) ───────────────────────
     as.vector(tab6) not equal to 6.
     Lengths differ: 0 is not 1
    
     ── 502. Failure: predTable tabulates (@test.misc.R#249) ───────────────────────
     names(tab6) not equal to "a".
     target is NULL, current is character
    
     ── 503. Failure: regression predicts (@test.regression.R#4) ───────────────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 504. Failure: regression predicts (@test.regression.R#4) ───────────────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 505. Failure: regression predicts (@test.regression.R#4) ───────────────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 506. Failure: regression predicts (@test.regression.R#4) ───────────────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 507. Failure: regression predicts (@test.regression.R#4) ───────────────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 508. Failure: regression predicts (@test.regression.R#4) ───────────────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 509. Failure: regression predicts (@test.regression.R#4) ───────────────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 510. Failure: regression predicts (@test.regression.R#4) ───────────────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 511. Failure: regression predicts (@test.regression.R#4) ───────────────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 512. Failure: regression predicts (@test.regression.R#4) ───────────────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 513. Failure: regression returns predictor (@test.regression.R#15) ─────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 514. Failure: regression returns predictor (@test.regression.R#15) ─────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 515. Failure: regression returns predictor (@test.regression.R#15) ─────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 516. Failure: regression returns predictor (@test.regression.R#15) ─────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 517. Failure: regression returns predictor (@test.regression.R#15) ─────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 518. Failure: regression returns predictor (@test.regression.R#15) ─────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 519. Failure: regression returns predictor (@test.regression.R#15) ─────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 520. Failure: regression returns predictor (@test.regression.R#15) ─────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 521. Failure: regression returns predictor (@test.regression.R#15) ─────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 522. Failure: regression returns predictor (@test.regression.R#15) ─────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 523. Failure: regression returns predictor that works without IDs (@test.regr
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 524. Failure: regression returns predictor that works without IDs (@test.regr
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 525. Failure: regression returns predictor that works without IDs (@test.regr
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 526. Failure: regression returns predictor that works without IDs (@test.regr
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 527. Failure: regression returns predictor that works without IDs (@test.regr
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 528. Failure: regression returns predictor that works without IDs (@test.regr
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 529. Failure: regression returns predictor that works without IDs (@test.regr
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 530. Failure: regression returns predictor that works without IDs (@test.regr
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 531. Failure: regression returns predictor that works without IDs (@test.regr
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 532. Failure: regression returns predictor that works without IDs (@test.regr
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 533. Failure: regression allows to combine by max (@test.regression.R#56) ──
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 534. Failure: regression allows to combine by max (@test.regression.R#56) ──
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 535. Failure: regression allows to combine by max (@test.regression.R#56) ──
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 536. Failure: regression allows to combine by max (@test.regression.R#56) ──
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 537. Failure: regression allows to combine by max (@test.regression.R#56) ──
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 538. Failure: regression allows to combine by max (@test.regression.R#56) ──
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 539. Failure: regression allows to combine by max (@test.regression.R#56) ──
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 540. Failure: regression allows to combine by max (@test.regression.R#56) ──
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 541. Failure: regression allows to combine by max (@test.regression.R#56) ──
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 542. Failure: regression allows to combine by max (@test.regression.R#56) ──
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 543. Failure: regression allows to combine by max (@test.regression.R#64) ──
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 544. Failure: regression allows to combine by max (@test.regression.R#64) ──
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 545. Failure: regression allows to combine by max (@test.regression.R#64) ──
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 546. Failure: regression allows to combine by max (@test.regression.R#64) ──
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 547. Failure: regression allows to combine by max (@test.regression.R#64) ──
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 548. Failure: regression allows to combine by max (@test.regression.R#64) ──
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 549. Failure: regression allows to combine by max (@test.regression.R#64) ──
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 550. Failure: regression allows to combine by max (@test.regression.R#64) ──
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 551. Failure: regression allows to combine by max (@test.regression.R#64) ──
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 552. Failure: regression allows to combine by max (@test.regression.R#64) ──
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 553. Failure: regression allows stacking (@test.regression.R#73) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 554. Failure: regression allows stacking (@test.regression.R#73) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 555. Failure: regression allows stacking (@test.regression.R#73) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 556. Failure: regression allows stacking (@test.regression.R#73) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 557. Failure: regression allows stacking (@test.regression.R#73) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 558. Failure: regression allows stacking (@test.regression.R#73) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 559. Failure: regression allows stacking (@test.regression.R#73) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 560. Failure: regression allows stacking (@test.regression.R#73) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 561. Failure: regression allows stacking (@test.regression.R#73) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 562. Failure: regression allows stacking (@test.regression.R#73) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 563. Failure: regression allows stacking (@test.regression.R#81) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 564. Failure: regression allows stacking (@test.regression.R#81) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 565. Failure: regression allows stacking (@test.regression.R#81) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 566. Failure: regression allows stacking (@test.regression.R#81) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 567. Failure: regression allows stacking (@test.regression.R#81) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 568. Failure: regression allows stacking (@test.regression.R#81) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 569. Failure: regression allows stacking (@test.regression.R#81) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 570. Failure: regression allows stacking (@test.regression.R#81) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 571. Failure: regression allows stacking (@test.regression.R#81) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 572. Failure: regression allows stacking (@test.regression.R#81) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 573. Failure: regression works with single algorithm (@test.regression.R#122)
     ss$algorithm not equal to factor(c("b")).
     Types not compatible: character is not integer
    
     ── 574. Failure: regression works with single algorithm (@test.regression.R#122)
     ss$algorithm not equal to factor(c("b")).
     Types not compatible: character is not integer
    
     ── 575. Failure: regression works with single algorithm (@test.regression.R#122)
     ss$algorithm not equal to factor(c("b")).
     Types not compatible: character is not integer
    
     ── 576. Failure: regression works with single algorithm (@test.regression.R#122)
     ss$algorithm not equal to factor(c("b")).
     Types not compatible: character is not integer
    
     ── 577. Failure: regression works with single algorithm (@test.regression.R#122)
     ss$algorithm not equal to factor(c("b")).
     Types not compatible: character is not integer
    
     ── 578. Failure: regression works with single algorithm (@test.regression.R#122)
     ss$algorithm not equal to factor(c("b")).
     Types not compatible: character is not integer
    
     ── 579. Failure: regression works with single algorithm (@test.regression.R#122)
     ss$algorithm not equal to factor(c("b")).
     Types not compatible: character is not integer
    
     ── 580. Failure: regression works with single algorithm (@test.regression.R#122)
     ss$algorithm not equal to factor(c("b")).
     Types not compatible: character is not integer
    
     ── 581. Failure: regression works with single algorithm (@test.regression.R#122)
     ss$algorithm not equal to factor(c("b")).
     Types not compatible: character is not integer
    
     ── 582. Failure: regression works with single algorithm (@test.regression.R#122)
     ss$algorithm not equal to factor(c("b")).
     Types not compatible: character is not integer
    
     ── 583. Failure: regressionPairs predicts (@test.regressionPairs.R#4) ─────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 584. Failure: regressionPairs predicts (@test.regressionPairs.R#4) ─────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 585. Failure: regressionPairs predicts (@test.regressionPairs.R#4) ─────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 586. Failure: regressionPairs predicts (@test.regressionPairs.R#4) ─────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 587. Failure: regressionPairs predicts (@test.regressionPairs.R#4) ─────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 588. Failure: regressionPairs predicts (@test.regressionPairs.R#4) ─────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 589. Failure: regressionPairs predicts (@test.regressionPairs.R#4) ─────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 590. Failure: regressionPairs predicts (@test.regressionPairs.R#4) ─────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 591. Failure: regressionPairs predicts (@test.regressionPairs.R#4) ─────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 592. Failure: regressionPairs predicts (@test.regressionPairs.R#4) ─────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 593. Failure: regressionPairs returns predictor (@test.regressionPairs.R#15)
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 594. Failure: regressionPairs returns predictor (@test.regressionPairs.R#15)
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 595. Failure: regressionPairs returns predictor (@test.regressionPairs.R#15)
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 596. Failure: regressionPairs returns predictor (@test.regressionPairs.R#15)
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 597. Failure: regressionPairs returns predictor (@test.regressionPairs.R#15)
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 598. Failure: regressionPairs returns predictor (@test.regressionPairs.R#15)
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 599. Failure: regressionPairs returns predictor (@test.regressionPairs.R#15)
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 600. Failure: regressionPairs returns predictor (@test.regressionPairs.R#15)
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 601. Failure: regressionPairs returns predictor (@test.regressionPairs.R#15)
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 602. Failure: regressionPairs returns predictor (@test.regressionPairs.R#15)
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 603. Failure: regressionPairs returns predictor that works without IDs (@test
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 604. Failure: regressionPairs returns predictor that works without IDs (@test
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 605. Failure: regressionPairs returns predictor that works without IDs (@test
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 606. Failure: regressionPairs returns predictor that works without IDs (@test
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 607. Failure: regressionPairs returns predictor that works without IDs (@test
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 608. Failure: regressionPairs returns predictor that works without IDs (@test
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 609. Failure: regressionPairs returns predictor that works without IDs (@test
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 610. Failure: regressionPairs returns predictor that works without IDs (@test
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 611. Failure: regressionPairs returns predictor that works without IDs (@test
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 612. Failure: regressionPairs returns predictor that works without IDs (@test
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 613. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     ── 614. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     ── 615. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     ── 616. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     ── 617. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     ── 618. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     ── 619. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     ── 620. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     ── 621. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     ── 622. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     ── 623. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     ── 624. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     ── 625. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     ── 626. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     ── 627. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     ── 628. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     ── 629. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     ── 630. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     ── 631. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     ── 632. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     ── 633. Failure: regressionPairs respects minimize (@test.regressionPairs.R#73)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 634. Failure: regressionPairs respects minimize (@test.regressionPairs.R#73)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 635. Failure: regressionPairs respects minimize (@test.regressionPairs.R#73)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 636. Failure: regressionPairs respects minimize (@test.regressionPairs.R#73)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 637. Failure: regressionPairs respects minimize (@test.regressionPairs.R#73)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 638. Failure: regressionPairs respects minimize (@test.regressionPairs.R#73)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 639. Failure: regressionPairs respects minimize (@test.regressionPairs.R#73)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 640. Failure: regressionPairs respects minimize (@test.regressionPairs.R#73)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 641. Failure: regressionPairs respects minimize (@test.regressionPairs.R#73)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 642. Failure: regressionPairs respects minimize (@test.regressionPairs.R#73)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 643. Failure: regressionPairs respects minimize (@test.regressionPairs.R#81)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 644. Failure: regressionPairs respects minimize (@test.regressionPairs.R#81)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 645. Failure: regressionPairs respects minimize (@test.regressionPairs.R#81)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 646. Failure: regressionPairs respects minimize (@test.regressionPairs.R#81)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 647. Failure: regressionPairs respects minimize (@test.regressionPairs.R#81)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 648. Failure: regressionPairs respects minimize (@test.regressionPairs.R#81)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 649. Failure: regressionPairs respects minimize (@test.regressionPairs.R#81)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 650. Failure: regressionPairs respects minimize (@test.regressionPairs.R#81)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 651. Failure: regressionPairs respects minimize (@test.regressionPairs.R#81)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 652. Failure: regressionPairs respects minimize (@test.regressionPairs.R#81)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 653. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 654. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 655. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 656. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 657. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 658. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 659. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 660. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 661. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 662. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 663. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 664. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 665. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 666. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 667. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 668. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 669. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 670. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 671. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 672. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ══ testthat results ═══════════════════════════════════════════════════════════
     [ OK: 1417 | SKIPPED: 10 | WARNINGS: 2 | FAILED: 672 ]
     1. Failure: classify classifies (@test.classify.R#4)
     2. Failure: classify classifies (@test.classify.R#4)
     3. Failure: classify classifies (@test.classify.R#4)
     4. Failure: classify classifies (@test.classify.R#4)
     5. Failure: classify classifies (@test.classify.R#4)
     6. Failure: classify classifies (@test.classify.R#4)
     7. Failure: classify classifies (@test.classify.R#4)
     8. Failure: classify classifies (@test.classify.R#4)
     9. Failure: classify classifies (@test.classify.R#4)
     1. ...
    
     Error: testthat unit tests failed
     Execution halted
Flavor: r-devel-linux-x86_64-debian-gcc

Version: 0.9.2
Check: tests
Result: ERROR
     Running ‘run-all.R’ [21s/24s]
    Running the tests in ‘tests/run-all.R’ failed.
    Complete output:
     > library(testthat)
     > library(ParamHelpers)
     >
     > test_check("llama")
     Loading required package: llama
     Loading required package: mlr
     'mlr' is in maintenance mode since July 2019. Future development
     efforts will go into its successor 'mlr3' (<https://mlr3.mlr-org.com>).
     ── 1. Failure: classify classifies (@test.classify.R#4) ───────────────────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 2. Failure: classify classifies (@test.classify.R#4) ───────────────────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 3. Failure: classify classifies (@test.classify.R#4) ───────────────────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 4. Failure: classify classifies (@test.classify.R#4) ───────────────────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 5. Failure: classify classifies (@test.classify.R#4) ───────────────────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 6. Failure: classify classifies (@test.classify.R#4) ───────────────────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 7. Failure: classify classifies (@test.classify.R#4) ───────────────────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 8. Failure: classify classifies (@test.classify.R#4) ───────────────────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 9. Failure: classify classifies (@test.classify.R#4) ───────────────────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 10. Failure: classify classifies (@test.classify.R#4) ──────────────────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 11. Failure: classify returns predictor (@test.classify.R#15) ──────────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 12. Failure: classify returns predictor (@test.classify.R#15) ──────────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 13. Failure: classify returns predictor (@test.classify.R#15) ──────────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 14. Failure: classify returns predictor (@test.classify.R#15) ──────────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 15. Failure: classify returns predictor (@test.classify.R#15) ──────────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 16. Failure: classify returns predictor (@test.classify.R#15) ──────────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 17. Failure: classify returns predictor (@test.classify.R#15) ──────────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 18. Failure: classify returns predictor (@test.classify.R#15) ──────────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 19. Failure: classify returns predictor (@test.classify.R#15) ──────────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 20. Failure: classify returns predictor (@test.classify.R#15) ──────────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 21. Failure: classify returns predictor that works without IDs (@test.classif
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 22. Failure: classify returns predictor that works without IDs (@test.classif
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 23. Failure: classify returns predictor that works without IDs (@test.classif
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 24. Failure: classify returns predictor that works without IDs (@test.classif
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 25. Failure: classify returns predictor that works without IDs (@test.classif
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 26. Failure: classify returns predictor that works without IDs (@test.classif
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 27. Failure: classify returns predictor that works without IDs (@test.classif
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 28. Failure: classify returns predictor that works without IDs (@test.classif
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 29. Failure: classify returns predictor that works without IDs (@test.classif
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 30. Failure: classify returns predictor that works without IDs (@test.classif
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 31. Failure: classify takes list of classifiers (@test.classify.R#47) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 32. Failure: classify takes list of classifiers (@test.classify.R#47) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 33. Failure: classify takes list of classifiers (@test.classify.R#47) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 34. Failure: classify takes list of classifiers (@test.classify.R#47) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 35. Failure: classify takes list of classifiers (@test.classify.R#47) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 36. Failure: classify takes list of classifiers (@test.classify.R#47) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 37. Failure: classify takes list of classifiers (@test.classify.R#47) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 38. Failure: classify takes list of classifiers (@test.classify.R#47) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 39. Failure: classify takes list of classifiers (@test.classify.R#47) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 40. Failure: classify takes list of classifiers (@test.classify.R#47) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 41. Failure: classify takes list of classifiers (@test.classify.R#55) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 42. Failure: classify takes list of classifiers (@test.classify.R#55) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 43. Failure: classify takes list of classifiers (@test.classify.R#55) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 44. Failure: classify takes list of classifiers (@test.classify.R#55) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 45. Failure: classify takes list of classifiers (@test.classify.R#55) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 46. Failure: classify takes list of classifiers (@test.classify.R#55) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 47. Failure: classify takes list of classifiers (@test.classify.R#55) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 48. Failure: classify takes list of classifiers (@test.classify.R#55) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 49. Failure: classify takes list of classifiers (@test.classify.R#55) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 50. Failure: classify takes list of classifiers (@test.classify.R#55) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 51. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 52. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 53. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 54. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 55. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 56. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 57. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 58. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 59. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 60. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 61. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 62. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 63. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 64. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 65. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 66. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 67. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 68. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 69. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 70. Failure: classify takes list of classifiers and combination function (@te
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 71. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 72. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 73. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 74. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 75. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 76. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 77. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 78. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 79. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 80. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 81. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 82. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 83. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 84. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 85. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 86. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 87. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 88. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 89. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 90. Failure: classify ensemble does majority voting by default (@test.classif
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 91. Failure: classify works with NA predictions (@test.classify.R#98) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 92. Failure: classify works with NA predictions (@test.classify.R#98) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 93. Failure: classify works with NA predictions (@test.classify.R#98) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 94. Failure: classify works with NA predictions (@test.classify.R#98) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 95. Failure: classify works with NA predictions (@test.classify.R#98) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 96. Failure: classify works with NA predictions (@test.classify.R#98) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 97. Failure: classify works with NA predictions (@test.classify.R#98) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 98. Failure: classify works with NA predictions (@test.classify.R#98) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 99. Failure: classify works with NA predictions (@test.classify.R#98) ──────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 100. Failure: classify works with NA predictions (@test.classify.R#98) ─────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 101. Failure: classify works with NA predictions (@test.classify.R#105) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 102. Failure: classify works with NA predictions (@test.classify.R#105) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 103. Failure: classify works with NA predictions (@test.classify.R#105) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 104. Failure: classify works with NA predictions (@test.classify.R#105) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 105. Failure: classify works with NA predictions (@test.classify.R#105) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 106. Failure: classify works with NA predictions (@test.classify.R#105) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 107. Failure: classify works with NA predictions (@test.classify.R#105) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 108. Failure: classify works with NA predictions (@test.classify.R#105) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 109. Failure: classify works with NA predictions (@test.classify.R#105) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 110. Failure: classify works with NA predictions (@test.classify.R#105) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 111. Failure: classify works with NA predictions (@test.classify.R#112) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 112. Failure: classify works with NA predictions (@test.classify.R#112) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 113. Failure: classify works with NA predictions (@test.classify.R#112) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 114. Failure: classify works with NA predictions (@test.classify.R#112) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 115. Failure: classify works with NA predictions (@test.classify.R#112) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 116. Failure: classify works with NA predictions (@test.classify.R#112) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 117. Failure: classify works with NA predictions (@test.classify.R#112) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 118. Failure: classify works with NA predictions (@test.classify.R#112) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 119. Failure: classify works with NA predictions (@test.classify.R#112) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 120. Failure: classify works with NA predictions (@test.classify.R#112) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 121. Failure: classify works with NA predictions (@test.classify.R#119) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 122. Failure: classify works with NA predictions (@test.classify.R#119) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 123. Failure: classify works with NA predictions (@test.classify.R#119) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 124. Failure: classify works with NA predictions (@test.classify.R#119) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 125. Failure: classify works with NA predictions (@test.classify.R#119) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 126. Failure: classify works with NA predictions (@test.classify.R#119) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 127. Failure: classify works with NA predictions (@test.classify.R#119) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 128. Failure: classify works with NA predictions (@test.classify.R#119) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 129. Failure: classify works with NA predictions (@test.classify.R#119) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 130. Failure: classify works with NA predictions (@test.classify.R#119) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 131. Failure: classify works with NA predictions (@test.classify.R#126) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 132. Failure: classify works with NA predictions (@test.classify.R#126) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 133. Failure: classify works with NA predictions (@test.classify.R#126) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 134. Failure: classify works with NA predictions (@test.classify.R#126) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 135. Failure: classify works with NA predictions (@test.classify.R#126) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 136. Failure: classify works with NA predictions (@test.classify.R#126) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 137. Failure: classify works with NA predictions (@test.classify.R#126) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 138. Failure: classify works with NA predictions (@test.classify.R#126) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 139. Failure: classify works with NA predictions (@test.classify.R#126) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 140. Failure: classify works with NA predictions (@test.classify.R#126) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 141. Failure: classify works with NA predictions (@test.classify.R#133) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 142. Failure: classify works with NA predictions (@test.classify.R#133) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 143. Failure: classify works with NA predictions (@test.classify.R#133) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 144. Failure: classify works with NA predictions (@test.classify.R#133) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 145. Failure: classify works with NA predictions (@test.classify.R#133) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 146. Failure: classify works with NA predictions (@test.classify.R#133) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 147. Failure: classify works with NA predictions (@test.classify.R#133) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 148. Failure: classify works with NA predictions (@test.classify.R#133) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 149. Failure: classify works with NA predictions (@test.classify.R#133) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 150. Failure: classify works with NA predictions (@test.classify.R#133) ────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 151. Failure: classify works with probabilities (@test.classify.R#160) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 152. Failure: classify works with probabilities (@test.classify.R#160) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 153. Failure: classify works with probabilities (@test.classify.R#160) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 154. Failure: classify works with probabilities (@test.classify.R#160) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 155. Failure: classify works with probabilities (@test.classify.R#160) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 156. Failure: classify works with probabilities (@test.classify.R#160) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 157. Failure: classify works with probabilities (@test.classify.R#160) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 158. Failure: classify works with probabilities (@test.classify.R#160) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 159. Failure: classify works with probabilities (@test.classify.R#160) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 160. Failure: classify works with probabilities (@test.classify.R#160) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 161. Failure: classify works with probabilities (@test.classify.R#167) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 162. Failure: classify works with probabilities (@test.classify.R#167) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 163. Failure: classify works with probabilities (@test.classify.R#167) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 164. Failure: classify works with probabilities (@test.classify.R#167) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 165. Failure: classify works with probabilities (@test.classify.R#167) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 166. Failure: classify works with probabilities (@test.classify.R#167) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 167. Failure: classify works with probabilities (@test.classify.R#167) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 168. Failure: classify works with probabilities (@test.classify.R#167) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 169. Failure: classify works with probabilities (@test.classify.R#167) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 170. Failure: classify works with probabilities (@test.classify.R#167) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 171. Failure: classify works with probabilities (@test.classify.R#174) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 172. Failure: classify works with probabilities (@test.classify.R#174) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 173. Failure: classify works with probabilities (@test.classify.R#174) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 174. Failure: classify works with probabilities (@test.classify.R#174) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 175. Failure: classify works with probabilities (@test.classify.R#174) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 176. Failure: classify works with probabilities (@test.classify.R#174) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 177. Failure: classify works with probabilities (@test.classify.R#174) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 178. Failure: classify works with probabilities (@test.classify.R#174) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 179. Failure: classify works with probabilities (@test.classify.R#174) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 180. Failure: classify works with probabilities (@test.classify.R#174) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 181. Failure: classify works with probabilities (@test.classify.R#181) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 182. Failure: classify works with probabilities (@test.classify.R#181) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 183. Failure: classify works with probabilities (@test.classify.R#181) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 184. Failure: classify works with probabilities (@test.classify.R#181) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 185. Failure: classify works with probabilities (@test.classify.R#181) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 186. Failure: classify works with probabilities (@test.classify.R#181) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 187. Failure: classify works with probabilities (@test.classify.R#181) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 188. Failure: classify works with probabilities (@test.classify.R#181) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 189. Failure: classify works with probabilities (@test.classify.R#181) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 190. Failure: classify works with probabilities (@test.classify.R#181) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 191. Failure: classify works with probabilities (@test.classify.R#188) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 192. Failure: classify works with probabilities (@test.classify.R#188) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 193. Failure: classify works with probabilities (@test.classify.R#188) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 194. Failure: classify works with probabilities (@test.classify.R#188) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 195. Failure: classify works with probabilities (@test.classify.R#188) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 196. Failure: classify works with probabilities (@test.classify.R#188) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 197. Failure: classify works with probabilities (@test.classify.R#188) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 198. Failure: classify works with probabilities (@test.classify.R#188) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 199. Failure: classify works with probabilities (@test.classify.R#188) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 200. Failure: classify works with probabilities (@test.classify.R#188) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 201. Failure: classify works with probabilities (@test.classify.R#195) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 202. Failure: classify works with probabilities (@test.classify.R#195) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 203. Failure: classify works with probabilities (@test.classify.R#195) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 204. Failure: classify works with probabilities (@test.classify.R#195) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 205. Failure: classify works with probabilities (@test.classify.R#195) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 206. Failure: classify works with probabilities (@test.classify.R#195) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 207. Failure: classify works with probabilities (@test.classify.R#195) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 208. Failure: classify works with probabilities (@test.classify.R#195) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 209. Failure: classify works with probabilities (@test.classify.R#195) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 210. Failure: classify works with probabilities (@test.classify.R#195) ─────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 211. Failure: classifyPairs classifies (@test.classifyPairs.R#4) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 212. Failure: classifyPairs classifies (@test.classifyPairs.R#4) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 213. Failure: classifyPairs classifies (@test.classifyPairs.R#4) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 214. Failure: classifyPairs classifies (@test.classifyPairs.R#4) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 215. Failure: classifyPairs classifies (@test.classifyPairs.R#4) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 216. Failure: classifyPairs classifies (@test.classifyPairs.R#4) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 217. Failure: classifyPairs classifies (@test.classifyPairs.R#4) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 218. Failure: classifyPairs classifies (@test.classifyPairs.R#4) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 219. Failure: classifyPairs classifies (@test.classifyPairs.R#4) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 220. Failure: classifyPairs classifies (@test.classifyPairs.R#4) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 221. Failure: classifyPairs returns predictor (@test.classifyPairs.R#15) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 222. Failure: classifyPairs returns predictor (@test.classifyPairs.R#15) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 223. Failure: classifyPairs returns predictor (@test.classifyPairs.R#15) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 224. Failure: classifyPairs returns predictor (@test.classifyPairs.R#15) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 225. Failure: classifyPairs returns predictor (@test.classifyPairs.R#15) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 226. Failure: classifyPairs returns predictor (@test.classifyPairs.R#15) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 227. Failure: classifyPairs returns predictor (@test.classifyPairs.R#15) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 228. Failure: classifyPairs returns predictor (@test.classifyPairs.R#15) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 229. Failure: classifyPairs returns predictor (@test.classifyPairs.R#15) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 230. Failure: classifyPairs returns predictor (@test.classifyPairs.R#15) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 231. Failure: classifyPairs returns predictor that works without IDs (@test.c
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 232. Failure: classifyPairs returns predictor that works without IDs (@test.c
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 233. Failure: classifyPairs returns predictor that works without IDs (@test.c
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 234. Failure: classifyPairs returns predictor that works without IDs (@test.c
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 235. Failure: classifyPairs returns predictor that works without IDs (@test.c
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 236. Failure: classifyPairs returns predictor that works without IDs (@test.c
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 237. Failure: classifyPairs returns predictor that works without IDs (@test.c
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 238. Failure: classifyPairs returns predictor that works without IDs (@test.c
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 239. Failure: classifyPairs returns predictor that works without IDs (@test.c
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 240. Failure: classifyPairs returns predictor that works without IDs (@test.c
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 241. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     ── 242. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     ── 243. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     ── 244. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     ── 245. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     ── 246. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     ── 247. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     ── 248. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     ── 249. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     ── 250. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     ── 251. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     ── 252. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     ── 253. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     ── 254. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     ── 255. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     ── 256. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     ── 257. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     ── 258. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     ── 259. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     ── 260. Failure: classifyPairs works with three algorithms (@test.classifyPairs.
     ss$algorithm not equal to factor(c("b", "c", "d")).
     Types not compatible: character is not integer
    
     ── 261. Failure: classifyPairs respects minimize (@test.classifyPairs.R#64) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 262. Failure: classifyPairs respects minimize (@test.classifyPairs.R#64) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 263. Failure: classifyPairs respects minimize (@test.classifyPairs.R#64) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 264. Failure: classifyPairs respects minimize (@test.classifyPairs.R#64) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 265. Failure: classifyPairs respects minimize (@test.classifyPairs.R#64) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 266. Failure: classifyPairs respects minimize (@test.classifyPairs.R#64) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 267. Failure: classifyPairs respects minimize (@test.classifyPairs.R#64) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 268. Failure: classifyPairs respects minimize (@test.classifyPairs.R#64) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 269. Failure: classifyPairs respects minimize (@test.classifyPairs.R#64) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 270. Failure: classifyPairs respects minimize (@test.classifyPairs.R#64) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 271. Failure: classifyPairs respects minimize (@test.classifyPairs.R#72) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 272. Failure: classifyPairs respects minimize (@test.classifyPairs.R#72) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 273. Failure: classifyPairs respects minimize (@test.classifyPairs.R#72) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 274. Failure: classifyPairs respects minimize (@test.classifyPairs.R#72) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 275. Failure: classifyPairs respects minimize (@test.classifyPairs.R#72) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 276. Failure: classifyPairs respects minimize (@test.classifyPairs.R#72) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 277. Failure: classifyPairs respects minimize (@test.classifyPairs.R#72) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 278. Failure: classifyPairs respects minimize (@test.classifyPairs.R#72) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 279. Failure: classifyPairs respects minimize (@test.classifyPairs.R#72) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 280. Failure: classifyPairs respects minimize (@test.classifyPairs.R#72) ───
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 281. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 282. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 283. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 284. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 285. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 286. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 287. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 288. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 289. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 290. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 291. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 292. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 293. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 294. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 295. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 296. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 297. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 298. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 299. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 300. Failure: classifyPairs allows combination function (@test.classifyPairs.
     ss$algorithm not equal to factor(c("a", "b")).
     Types not compatible: character is not integer
    
     ── 301. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 302. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 303. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 304. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 305. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 306. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 307. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 308. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 309. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 310. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 311. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 312. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 313. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 314. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 315. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 316. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 317. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 318. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 319. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 320. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 321. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 322. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 323. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 324. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 325. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 326. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 327. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 328. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 329. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 330. Failure: classifyPairs works with NA predictions (@test.classifyPairs.R#
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 331. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 332. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 333. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 334. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 335. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 336. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 337. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 338. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 339. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 340. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 341. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 342. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 343. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 344. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 345. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 346. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 347. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 348. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 349. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 350. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 351. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 352. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 353. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 354. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 355. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 356. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 357. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 358. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 359. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 360. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 361. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 362. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 363. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 364. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 365. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 366. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 367. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 368. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 369. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 370. Failure: classifyPairs works with probabilities (@test.classifyPairs.R#1
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 371. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     ── 372. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     ── 373. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     ── 374. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     ── 375. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     ── 376. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     ── 377. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     ── 378. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     ── 379. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     ── 380. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     ── 381. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     ── 382. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     ── 383. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     ── 384. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     ── 385. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     ── 386. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     ── 387. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     ── 388. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     ── 389. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     ── 390. Failure: cluster takes list of clusterers and combinator (@test.cluster.
     ss$algorithm not equal to factor("c").
     Types not compatible: character is not integer
    
     ── 391. Failure: virtual best returns the vbs (@test.misc.R#6) ────────────────
     ss$algorithm not equal to factor(bests[ss$id], levels = unique(bests)).
     Types not compatible: character is not integer
    
     ── 392. Failure: virtual best returns the vbs (@test.misc.R#6) ────────────────
     ss$algorithm not equal to factor(bests[ss$id], levels = unique(bests)).
     Types not compatible: character is not integer
    
     ── 393. Failure: virtual best returns the vbs (@test.misc.R#6) ────────────────
     ss$algorithm not equal to factor(bests[ss$id], levels = unique(bests)).
     Types not compatible: character is not integer
    
     ── 394. Failure: virtual best returns the vbs (@test.misc.R#6) ────────────────
     ss$algorithm not equal to factor(bests[ss$id], levels = unique(bests)).
     Types not compatible: character is not integer
    
     ── 395. Failure: virtual best returns the vbs (@test.misc.R#6) ────────────────
     ss$algorithm not equal to factor(bests[ss$id], levels = unique(bests)).
     Types not compatible: character is not integer
    
     ── 396. Failure: virtual best works with best list (@test.misc.R#17) ──────────
     ss$algorithm not equal to factor(algs, levels = c("a", "b")).
     Types not compatible: character is not integer
    
     ── 397. Failure: virtual best works with best list (@test.misc.R#17) ──────────
     ss$algorithm not equal to factor(algs, levels = c("a", "b")).
     Types not compatible: character is not integer
    
     ── 398. Failure: virtual best works with best list (@test.misc.R#17) ──────────
     ss$algorithm not equal to factor(algs, levels = c("a", "b")).
     Types not compatible: character is not integer
    
     ── 399. Failure: single best returns the single best (@test.misc.R#52) ────────
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 400. Failure: single best returns the single best (@test.misc.R#52) ────────
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 401. Failure: single best returns the single best (@test.misc.R#52) ────────
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 402. Failure: single best returns the single best (@test.misc.R#52) ────────
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 403. Failure: single best returns the single best (@test.misc.R#52) ────────
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 404. Failure: single best returns the single best (@test.misc.R#52) ────────
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 405. Failure: single best returns the single best (@test.misc.R#52) ────────
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 406. Failure: single best returns the single best (@test.misc.R#52) ────────
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 407. Failure: single best returns the single best (@test.misc.R#52) ────────
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 408. Failure: single best returns the single best (@test.misc.R#52) ────────
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 409. Failure: single best returns the single best (@test.misc.R#57) ────────
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 410. Failure: single best returns the single best (@test.misc.R#57) ────────
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 411. Failure: single best returns the single best (@test.misc.R#57) ────────
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 412. Failure: single best returns the single best (@test.misc.R#57) ────────
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 413. Failure: single best returns the single best (@test.misc.R#57) ────────
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 414. Failure: single best returns the single best (@test.misc.R#57) ────────
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 415. Failure: single best returns the single best (@test.misc.R#57) ────────
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 416. Failure: single best returns the single best (@test.misc.R#57) ────────
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 417. Failure: single best returns the single best (@test.misc.R#57) ────────
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 418. Failure: single best returns the single best (@test.misc.R#57) ────────
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 419. Failure: single best works with best list (@test.misc.R#73) ───────────
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 420. Failure: single best works with best list (@test.misc.R#73) ───────────
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 421. Failure: single best works with best list (@test.misc.R#73) ───────────
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 422. Failure: single best works with best list (@test.misc.R#73) ───────────
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 423. Failure: single best works with best list (@test.misc.R#73) ───────────
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 424. Failure: single best works with best list (@test.misc.R#73) ───────────
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 425. Failure: single best works with best list (@test.misc.R#73) ───────────
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 426. Failure: single best works with best list (@test.misc.R#73) ───────────
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 427. Failure: single best works with best list (@test.misc.R#73) ───────────
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 428. Failure: single best works with best list (@test.misc.R#73) ───────────
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 429. Failure: single best works with best list (@test.misc.R#78) ───────────
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 430. Failure: single best works with best list (@test.misc.R#78) ───────────
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 431. Failure: single best works with best list (@test.misc.R#78) ───────────
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 432. Failure: single best works with best list (@test.misc.R#78) ───────────
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 433. Failure: single best works with best list (@test.misc.R#78) ───────────
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 434. Failure: single best works with best list (@test.misc.R#78) ───────────
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 435. Failure: single best works with best list (@test.misc.R#78) ───────────
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 436. Failure: single best works with best list (@test.misc.R#78) ───────────
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 437. Failure: single best works with best list (@test.misc.R#78) ───────────
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 438. Failure: single best works with best list (@test.misc.R#78) ───────────
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 439. Failure: single best by count returns the single best (@test.misc.R#91)
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 440. Failure: single best by count returns the single best (@test.misc.R#91)
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 441. Failure: single best by count returns the single best (@test.misc.R#91)
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 442. Failure: single best by count works with best list (@test.misc.R#104) ─
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 443. Failure: single best by count works with best list (@test.misc.R#104) ─
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 444. Failure: single best by count works with best list (@test.misc.R#104) ─
     ss$algorithm not equal to factor("a").
     Types not compatible: character is not integer
    
     ── 445. Failure: single best by par returns the single best (@test.misc.R#117)
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 446. Failure: single best by par returns the single best (@test.misc.R#117)
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 447. Failure: single best by par returns the single best (@test.misc.R#117)
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 448. Failure: single best by par returns the single best (@test.misc.R#117)
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 449. Failure: single best by par returns the single best (@test.misc.R#117)
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 450. Failure: single best by par returns the single best (@test.misc.R#117)
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 451. Failure: single best by par returns the single best (@test.misc.R#117)
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 452. Failure: single best by par returns the single best (@test.misc.R#117)
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 453. Failure: single best by par returns the single best (@test.misc.R#117)
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 454. Failure: single best by par returns the single best (@test.misc.R#117)
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 455. Failure: single best by par works with best list (@test.misc.R#131) ───
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 456. Failure: single best by par works with best list (@test.misc.R#131) ───
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 457. Failure: single best by par works with best list (@test.misc.R#131) ───
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 458. Failure: single best by par works with best list (@test.misc.R#131) ───
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 459. Failure: single best by par works with best list (@test.misc.R#131) ───
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 460. Failure: single best by par works with best list (@test.misc.R#131) ───
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 461. Failure: single best by par works with best list (@test.misc.R#131) ───
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 462. Failure: single best by par works with best list (@test.misc.R#131) ───
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 463. Failure: single best by par works with best list (@test.misc.R#131) ───
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 464. Failure: single best by par works with best list (@test.misc.R#131) ───
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 465. Failure: single best by par works with train/test split (@test.misc.R#14
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 466. Failure: single best by par works with train/test split (@test.misc.R#14
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 467. Failure: single best by par works with train/test split (@test.misc.R#14
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 468. Failure: single best by par works with train/test split (@test.misc.R#14
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 469. Failure: single best by par works with train/test split (@test.misc.R#14
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 470. Failure: single best by par works with train/test split (@test.misc.R#14
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 471. Failure: single best by par works with train/test split (@test.misc.R#14
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 472. Failure: single best by par works with train/test split (@test.misc.R#14
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 473. Failure: single best by par works with train/test split (@test.misc.R#14
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 474. Failure: single best by par works with train/test split (@test.misc.R#14
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 475. Failure: single best by successes returns the single best (@test.misc.R#
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 476. Failure: single best by successes returns the single best (@test.misc.R#
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 477. Failure: single best by successes returns the single best (@test.misc.R#
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 478. Failure: single best by successes returns the single best (@test.misc.R#
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 479. Failure: single best by successes returns the single best (@test.misc.R#
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 480. Failure: single best by successes returns the single best (@test.misc.R#
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 481. Failure: single best by successes returns the single best (@test.misc.R#
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 482. Failure: single best by successes returns the single best (@test.misc.R#
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 483. Failure: single best by successes returns the single best (@test.misc.R#
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 484. Failure: single best by successes returns the single best (@test.misc.R#
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 485. Failure: single best by successes works with best list (@test.misc.R#177
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 486. Failure: single best by successes works with best list (@test.misc.R#177
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 487. Failure: single best by successes works with best list (@test.misc.R#177
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 488. Failure: single best by successes works with best list (@test.misc.R#177
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 489. Failure: single best by successes works with best list (@test.misc.R#177
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 490. Failure: single best by successes works with best list (@test.misc.R#177
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 491. Failure: single best by successes works with best list (@test.misc.R#177
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 492. Failure: single best by successes works with best list (@test.misc.R#177
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 493. Failure: single best by successes works with best list (@test.misc.R#177
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 494. Failure: single best by successes works with best list (@test.misc.R#177
     ss$algorithm not equal to factor("b").
     Types not compatible: character is not integer
    
     ── 495. Failure: predTable tabulates (@test.misc.R#211) ───────────────────────
     as.vector(tab1) not equal to c(2, 1).
     Lengths differ: 0 is not 2
    
     ── 496. Failure: predTable tabulates (@test.misc.R#212) ───────────────────────
     names(tab1) not equal to c("a", "b").
     target is NULL, current is character
    
     ── 497. Failure: predTable tabulates (@test.misc.R#220) ───────────────────────
     as.vector(tab3) not equal to c(2, 1).
     Lengths differ: 0 is not 2
    
     ── 498. Failure: predTable tabulates (@test.misc.R#221) ───────────────────────
     names(tab3) not equal to c("a", "b").
     target is NULL, current is character
    
     ── 499. Failure: predTable tabulates (@test.misc.R#225) ───────────────────────
     as.vector(tab4) not equal to 3.
     Lengths differ: 0 is not 1
    
     ── 500. Failure: predTable tabulates (@test.misc.R#226) ───────────────────────
     names(tab4) not equal to "a".
     target is NULL, current is character
    
     ── 501. Failure: predTable tabulates (@test.misc.R#248) ───────────────────────
     as.vector(tab6) not equal to 6.
     Lengths differ: 0 is not 1
    
     ── 502. Failure: predTable tabulates (@test.misc.R#249) ───────────────────────
     names(tab6) not equal to "a".
     target is NULL, current is character
    
     ── 503. Failure: regression predicts (@test.regression.R#4) ───────────────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 504. Failure: regression predicts (@test.regression.R#4) ───────────────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 505. Failure: regression predicts (@test.regression.R#4) ───────────────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 506. Failure: regression predicts (@test.regression.R#4) ───────────────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 507. Failure: regression predicts (@test.regression.R#4) ───────────────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 508. Failure: regression predicts (@test.regression.R#4) ───────────────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 509. Failure: regression predicts (@test.regression.R#4) ───────────────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 510. Failure: regression predicts (@test.regression.R#4) ───────────────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 511. Failure: regression predicts (@test.regression.R#4) ───────────────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 512. Failure: regression predicts (@test.regression.R#4) ───────────────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 513. Failure: regression returns predictor (@test.regression.R#15) ─────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 514. Failure: regression returns predictor (@test.regression.R#15) ─────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 515. Failure: regression returns predictor (@test.regression.R#15) ─────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 516. Failure: regression returns predictor (@test.regression.R#15) ─────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 517. Failure: regression returns predictor (@test.regression.R#15) ─────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 518. Failure: regression returns predictor (@test.regression.R#15) ─────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 519. Failure: regression returns predictor (@test.regression.R#15) ─────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 520. Failure: regression returns predictor (@test.regression.R#15) ─────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 521. Failure: regression returns predictor (@test.regression.R#15) ─────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 522. Failure: regression returns predictor (@test.regression.R#15) ─────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 523. Failure: regression returns predictor that works without IDs (@test.regr
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 524. Failure: regression returns predictor that works without IDs (@test.regr
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 525. Failure: regression returns predictor that works without IDs (@test.regr
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 526. Failure: regression returns predictor that works without IDs (@test.regr
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 527. Failure: regression returns predictor that works without IDs (@test.regr
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 528. Failure: regression returns predictor that works without IDs (@test.regr
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 529. Failure: regression returns predictor that works without IDs (@test.regr
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 530. Failure: regression returns predictor that works without IDs (@test.regr
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 531. Failure: regression returns predictor that works without IDs (@test.regr
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 532. Failure: regression returns predictor that works without IDs (@test.regr
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 533. Failure: regression allows to combine by max (@test.regression.R#56) ──
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 534. Failure: regression allows to combine by max (@test.regression.R#56) ──
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 535. Failure: regression allows to combine by max (@test.regression.R#56) ──
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 536. Failure: regression allows to combine by max (@test.regression.R#56) ──
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 537. Failure: regression allows to combine by max (@test.regression.R#56) ──
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 538. Failure: regression allows to combine by max (@test.regression.R#56) ──
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 539. Failure: regression allows to combine by max (@test.regression.R#56) ──
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 540. Failure: regression allows to combine by max (@test.regression.R#56) ──
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 541. Failure: regression allows to combine by max (@test.regression.R#56) ──
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 542. Failure: regression allows to combine by max (@test.regression.R#56) ──
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 543. Failure: regression allows to combine by max (@test.regression.R#64) ──
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 544. Failure: regression allows to combine by max (@test.regression.R#64) ──
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 545. Failure: regression allows to combine by max (@test.regression.R#64) ──
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 546. Failure: regression allows to combine by max (@test.regression.R#64) ──
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 547. Failure: regression allows to combine by max (@test.regression.R#64) ──
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 548. Failure: regression allows to combine by max (@test.regression.R#64) ──
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 549. Failure: regression allows to combine by max (@test.regression.R#64) ──
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 550. Failure: regression allows to combine by max (@test.regression.R#64) ──
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 551. Failure: regression allows to combine by max (@test.regression.R#64) ──
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 552. Failure: regression allows to combine by max (@test.regression.R#64) ──
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 553. Failure: regression allows stacking (@test.regression.R#73) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 554. Failure: regression allows stacking (@test.regression.R#73) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 555. Failure: regression allows stacking (@test.regression.R#73) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 556. Failure: regression allows stacking (@test.regression.R#73) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 557. Failure: regression allows stacking (@test.regression.R#73) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 558. Failure: regression allows stacking (@test.regression.R#73) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 559. Failure: regression allows stacking (@test.regression.R#73) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 560. Failure: regression allows stacking (@test.regression.R#73) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 561. Failure: regression allows stacking (@test.regression.R#73) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 562. Failure: regression allows stacking (@test.regression.R#73) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 563. Failure: regression allows stacking (@test.regression.R#81) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 564. Failure: regression allows stacking (@test.regression.R#81) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 565. Failure: regression allows stacking (@test.regression.R#81) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 566. Failure: regression allows stacking (@test.regression.R#81) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 567. Failure: regression allows stacking (@test.regression.R#81) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 568. Failure: regression allows stacking (@test.regression.R#81) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 569. Failure: regression allows stacking (@test.regression.R#81) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 570. Failure: regression allows stacking (@test.regression.R#81) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 571. Failure: regression allows stacking (@test.regression.R#81) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 572. Failure: regression allows stacking (@test.regression.R#81) ───────────
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 573. Failure: regression works with single algorithm (@test.regression.R#122)
     ss$algorithm not equal to factor(c("b")).
     Types not compatible: character is not integer
    
     ── 574. Failure: regression works with single algorithm (@test.regression.R#122)
     ss$algorithm not equal to factor(c("b")).
     Types not compatible: character is not integer
    
     ── 575. Failure: regression works with single algorithm (@test.regression.R#122)
     ss$algorithm not equal to factor(c("b")).
     Types not compatible: character is not integer
    
     ── 576. Failure: regression works with single algorithm (@test.regression.R#122)
     ss$algorithm not equal to factor(c("b")).
     Types not compatible: character is not integer
    
     ── 577. Failure: regression works with single algorithm (@test.regression.R#122)
     ss$algorithm not equal to factor(c("b")).
     Types not compatible: character is not integer
    
     ── 578. Failure: regression works with single algorithm (@test.regression.R#122)
     ss$algorithm not equal to factor(c("b")).
     Types not compatible: character is not integer
    
     ── 579. Failure: regression works with single algorithm (@test.regression.R#122)
     ss$algorithm not equal to factor(c("b")).
     Types not compatible: character is not integer
    
     ── 580. Failure: regression works with single algorithm (@test.regression.R#122)
     ss$algorithm not equal to factor(c("b")).
     Types not compatible: character is not integer
    
     ── 581. Failure: regression works with single algorithm (@test.regression.R#122)
     ss$algorithm not equal to factor(c("b")).
     Types not compatible: character is not integer
    
     ── 582. Failure: regression works with single algorithm (@test.regression.R#122)
     ss$algorithm not equal to factor(c("b")).
     Types not compatible: character is not integer
    
     ── 583. Failure: regressionPairs predicts (@test.regressionPairs.R#4) ─────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 584. Failure: regressionPairs predicts (@test.regressionPairs.R#4) ─────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 585. Failure: regressionPairs predicts (@test.regressionPairs.R#4) ─────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 586. Failure: regressionPairs predicts (@test.regressionPairs.R#4) ─────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 587. Failure: regressionPairs predicts (@test.regressionPairs.R#4) ─────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 588. Failure: regressionPairs predicts (@test.regressionPairs.R#4) ─────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 589. Failure: regressionPairs predicts (@test.regressionPairs.R#4) ─────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 590. Failure: regressionPairs predicts (@test.regressionPairs.R#4) ─────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 591. Failure: regressionPairs predicts (@test.regressionPairs.R#4) ─────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 592. Failure: regressionPairs predicts (@test.regressionPairs.R#4) ─────────
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 593. Failure: regressionPairs returns predictor (@test.regressionPairs.R#15)
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 594. Failure: regressionPairs returns predictor (@test.regressionPairs.R#15)
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 595. Failure: regressionPairs returns predictor (@test.regressionPairs.R#15)
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 596. Failure: regressionPairs returns predictor (@test.regressionPairs.R#15)
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 597. Failure: regressionPairs returns predictor (@test.regressionPairs.R#15)
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 598. Failure: regressionPairs returns predictor (@test.regressionPairs.R#15)
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 599. Failure: regressionPairs returns predictor (@test.regressionPairs.R#15)
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 600. Failure: regressionPairs returns predictor (@test.regressionPairs.R#15)
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 601. Failure: regressionPairs returns predictor (@test.regressionPairs.R#15)
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 602. Failure: regressionPairs returns predictor (@test.regressionPairs.R#15)
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 603. Failure: regressionPairs returns predictor that works without IDs (@test
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 604. Failure: regressionPairs returns predictor that works without IDs (@test
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 605. Failure: regressionPairs returns predictor that works without IDs (@test
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 606. Failure: regressionPairs returns predictor that works without IDs (@test
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 607. Failure: regressionPairs returns predictor that works without IDs (@test
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 608. Failure: regressionPairs returns predictor that works without IDs (@test
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 609. Failure: regressionPairs returns predictor that works without IDs (@test
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 610. Failure: regressionPairs returns predictor that works without IDs (@test
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 611. Failure: regressionPairs returns predictor that works without IDs (@test
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 612. Failure: regressionPairs returns predictor that works without IDs (@test
     ss$algorithm not equal to factor(c("c", "b")).
     Types not compatible: character is not integer
    
     ── 613. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     ── 614. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     ── 615. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     ── 616. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     ── 617. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     ── 618. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     ── 619. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     ── 620. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     ── 621. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     ── 622. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     ── 623. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     ── 624. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     ── 625. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     ── 626. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     ── 627. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     ── 628. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     ── 629. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     ── 630. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     ── 631. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     ── 632. Failure: regressionPairs works with three algorithms (@test.regressionPa
     ss$algorithm not equal to factor(c("c", "b", "d")).
     Types not compatible: character is not integer
    
     ── 633. Failure: regressionPairs respects minimize (@test.regressionPairs.R#73)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 634. Failure: regressionPairs respects minimize (@test.regressionPairs.R#73)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 635. Failure: regressionPairs respects minimize (@test.regressionPairs.R#73)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 636. Failure: regressionPairs respects minimize (@test.regressionPairs.R#73)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 637. Failure: regressionPairs respects minimize (@test.regressionPairs.R#73)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 638. Failure: regressionPairs respects minimize (@test.regressionPairs.R#73)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 639. Failure: regressionPairs respects minimize (@test.regressionPairs.R#73)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 640. Failure: regressionPairs respects minimize (@test.regressionPairs.R#73)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 641. Failure: regressionPairs respects minimize (@test.regressionPairs.R#73)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 642. Failure: regressionPairs respects minimize (@test.regressionPairs.R#73)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 643. Failure: regressionPairs respects minimize (@test.regressionPairs.R#81)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 644. Failure: regressionPairs respects minimize (@test.regressionPairs.R#81)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 645. Failure: regressionPairs respects minimize (@test.regressionPairs.R#81)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 646. Failure: regressionPairs respects minimize (@test.regressionPairs.R#81)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 647. Failure: regressionPairs respects minimize (@test.regressionPairs.R#81)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 648. Failure: regressionPairs respects minimize (@test.regressionPairs.R#81)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 649. Failure: regressionPairs respects minimize (@test.regressionPairs.R#81)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 650. Failure: regressionPairs respects minimize (@test.regressionPairs.R#81)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 651. Failure: regressionPairs respects minimize (@test.regressionPairs.R#81)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 652. Failure: regressionPairs respects minimize (@test.regressionPairs.R#81)
     ss$algorithm not equal to factor(c("foo", "bar")).
     Types not compatible: character is not integer
    
     ── 653. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 654. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 655. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 656. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 657. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 658. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 659. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 660. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 661. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 662. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 663. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 664. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 665. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 666. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 667. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 668. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 669. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 670. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 671. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ── 672. Failure: regressionPairs allows combine classifier (@test.regressionPair
     ss$algorithm not equal to factor(c("b", "c")).
     Types not compatible: character is not integer
    
     ══ testthat results ═══════════════════════════════════════════════════════════
     [ OK: 1417 | SKIPPED: 10 | WARNINGS: 2 | FAILED: 672 ]
     1. Failure: classify classifies (@test.classify.R#4)
     2. Failure: classify classifies (@test.classify.R#4)
     3. Failure: classify classifies (@test.classify.R#4)
     4. Failure: classify classifies (@test.classify.R#4)
     5. Failure: classify classifies (@test.classify.R#4)
     6. Failure: classify classifies (@test.classify.R#4)
     7. Failure: classify classifies (@test.classify.R#4)
     8. Failure: classify classifies (@test.classify.R#4)
     9. Failure: classify classifies (@test.classify.R#4)
     1. ...
    
     Error: testthat unit tests failed
     Execution halted
Flavor: r-devel-linux-x86_64-fedora-clang