Running 'run-all.R' [20s/23s]
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