Running ‘testthat.R’ [9s/11s]
Running the tests in ‘tests/testthat.R’ failed.
Complete output:
  > library(testthat)
  > library(comorbidity)
  > 
  > test_check("comorbidity")
  ── 1. Error: Charlson, ami, I21 (@test-charlson-icd10.R#4)  ────────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "I21"), id = "id", code = "code", score = "charlson") at testthat/test-charlson-icd10.R:4
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 2. Error: Charlson, ami, I22 (@test-charlson-icd10.R#10)  ───────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "I22"), id = "id", code = "code", score = "charlson") at testthat/test-charlson-icd10.R:10
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 3. Error: Charlson, ami, I252 (@test-charlson-icd10.R#16)  ──────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "I252"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:16
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 4. Error: Charlson, chf, I099 (@test-charlson-icd10.R#22)  ──────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "I099"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:22
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 5. Error: Charlson, chf, I110 (@test-charlson-icd10.R#28)  ──────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "I110"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:28
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 6. Error: Charlson, chf, I130 (@test-charlson-icd10.R#34)  ──────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "I130"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:34
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 7. Error: Charlson, chf, I132 (@test-charlson-icd10.R#40)  ──────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "I132"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:40
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 8. Error: Charlson, chf, I255 (@test-charlson-icd10.R#46)  ──────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "I255"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:46
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 9. Error: Charlson, chf, I420 (@test-charlson-icd10.R#52)  ──────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "I420"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:52
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 10. Error: Charlson, chf, I425-429 (@test-charlson-icd10.R#58)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "I425"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:58
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 11. Error: Charlson, chf, I43 (@test-charlson-icd10.R#76)  ──────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "I43"), id = "id", code = "code", score = "charlson") at testthat/test-charlson-icd10.R:76
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 12. Error: Charlson, chf, I50 (@test-charlson-icd10.R#82)  ──────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "I50"), id = "id", code = "code", score = "charlson") at testthat/test-charlson-icd10.R:82
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 13. Error: Charlson, chf, P290 (@test-charlson-icd10.R#88)  ─────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "P290"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:88
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 14. Error: Charlson, pvd, I70 (@test-charlson-icd10.R#94)  ──────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "I70"), id = "id", code = "code", score = "charlson") at testthat/test-charlson-icd10.R:94
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 15. Error: Charlson, pvd, I71 (@test-charlson-icd10.R#100)  ─────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "I71"), id = "id", code = "code", score = "charlson") at testthat/test-charlson-icd10.R:100
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 16. Error: Charlson, pvd, I731 (@test-charlson-icd10.R#106)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "I731"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:106
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 17. Error: Charlson, pvd, I738 (@test-charlson-icd10.R#112)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "I738"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:112
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 18. Error: Charlson, pvd, I739 (@test-charlson-icd10.R#118)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "I739"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:118
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 19. Error: Charlson, pvd, I771 (@test-charlson-icd10.R#124)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "I771"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:124
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 20. Error: Charlson, pvd, I790 (@test-charlson-icd10.R#130)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "I790"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:130
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 21. Error: Charlson, pvd, I792 (@test-charlson-icd10.R#136)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "I792"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:136
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 22. Error: Charlson, pvd, K551 (@test-charlson-icd10.R#142)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "K551"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:142
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 23. Error: Charlson, pvd, K558 (@test-charlson-icd10.R#148)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "K558"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:148
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 24. Error: Charlson, pvd, K559 (@test-charlson-icd10.R#154)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "K559"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:154
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 25. Error: Charlson, pvd, Z958 (@test-charlson-icd10.R#160)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "Z958"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:160
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 26. Error: Charlson, pvd, Z959 (@test-charlson-icd10.R#166)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "Z959"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:166
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 27. Error: Charlson, cevd, G45 (@test-charlson-icd10.R#172)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "G45"), id = "id", code = "code", score = "charlson") at testthat/test-charlson-icd10.R:172
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 28. Error: Charlson, cevd, G46 (@test-charlson-icd10.R#178)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "G46"), id = "id", code = "code", score = "charlson") at testthat/test-charlson-icd10.R:178
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 29. Error: Charlson, cevd, H340 (@test-charlson-icd10.R#184)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "H340"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:184
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 30. Error: Charlson, cevd, I60-69 (@test-charlson-icd10.R#190)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "I60"), id = "id", code = "code", score = "charlson") at testthat/test-charlson-icd10.R:190
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 31. Error: Charlson, dementia, F00-03 (@test-charlson-icd10.R#223)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "F00"), id = "id", code = "code", score = "charlson") at testthat/test-charlson-icd10.R:223
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 32. Error: Charlson, dementia, F051 (@test-charlson-icd10.R#238)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "F051"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:238
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 33. Error: Charlson, dementia, G30 (@test-charlson-icd10.R#244)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "G30"), id = "id", code = "code", score = "charlson") at testthat/test-charlson-icd10.R:244
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 34. Error: Charlson, dementia, G311 (@test-charlson-icd10.R#250)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "G311"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:250
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 35. Error: Charlson, copd, I278 (@test-charlson-icd10.R#256)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "I278"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:256
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 36. Error: Charlson, copd, I279 (@test-charlson-icd10.R#262)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "I279"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:262
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 37. Error: Charlson, copd, J40-47 (@test-charlson-icd10.R#268)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "J40"), id = "id", code = "code", score = "charlson") at testthat/test-charlson-icd10.R:268
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 38. Error: Charlson, copd, J60-67 (@test-charlson-icd10.R#295)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "J60"), id = "id", code = "code", score = "charlson") at testthat/test-charlson-icd10.R:295
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 39. Error: Charlson, copd, J684 (@test-charlson-icd10.R#322)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "J684"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:322
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 40. Error: Charlson, copd, J701 (@test-charlson-icd10.R#328)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "J701"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:328
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 41. Error: Charlson, copd, J703 (@test-charlson-icd10.R#334)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "J703"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:334
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 42. Error: Charlson, rheumd, M05 (@test-charlson-icd10.R#340)  ──────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "M05"), id = "id", code = "code", score = "charlson") at testthat/test-charlson-icd10.R:340
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 43. Error: Charlson, rheumd, M06 (@test-charlson-icd10.R#346)  ──────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "M06"), id = "id", code = "code", score = "charlson") at testthat/test-charlson-icd10.R:346
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 44. Error: Charlson, rheumd, M315 (@test-charlson-icd10.R#352)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "M315"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:352
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 45. Error: Charlson, rheumd, M32-34 (@test-charlson-icd10.R#358)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "M32"), id = "id", code = "code", score = "charlson") at testthat/test-charlson-icd10.R:358
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 46. Error: Charlson, rheumd, M351 (@test-charlson-icd10.R#370)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "M351"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:370
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 47. Error: Charlson, rheumd, M353 (@test-charlson-icd10.R#376)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "M353"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:376
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 48. Error: Charlson, rheumd, M360 (@test-charlson-icd10.R#382)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "M360"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:382
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 49. Error: Charlson, pud, K25-28 (@test-charlson-icd10.R#388)  ──────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "K25"), id = "id", code = "code", score = "charlson") at testthat/test-charlson-icd10.R:388
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 50. Error: Charlson, mld, B18 (@test-charlson-icd10.R#403)  ─────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "B18"), id = "id", code = "code", score = "charlson") at testthat/test-charlson-icd10.R:403
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 51. Error: Charlson, mld, K700-703 (@test-charlson-icd10.R#409)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "K700"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:409
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 52. Error: Charlson, mld, K709 (@test-charlson-icd10.R#424)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "K709"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:424
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 53. Error: Charlson, mld, K713-715 (@test-charlson-icd10.R#430)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "K713"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:430
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 54. Error: Charlson, mld, K717 (@test-charlson-icd10.R#442)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "K717"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:442
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 55. Error: Charlson, mld, K73 (@test-charlson-icd10.R#448)  ─────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "K73"), id = "id", code = "code", score = "charlson") at testthat/test-charlson-icd10.R:448
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 56. Error: Charlson, mld, K74 (@test-charlson-icd10.R#454)  ─────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "K74"), id = "id", code = "code", score = "charlson") at testthat/test-charlson-icd10.R:454
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 57. Error: Charlson, mld, K760 (@test-charlson-icd10.R#460)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "K760"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:460
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 58. Error: Charlson, mld, K762-764 (@test-charlson-icd10.R#466)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "K762"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:466
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 59. Error: Charlson, mld, K768 (@test-charlson-icd10.R#478)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "K768"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:478
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 60. Error: Charlson, mld, K769 (@test-charlson-icd10.R#484)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "K769"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:484
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 61. Error: Charlson, mld, Z944 (@test-charlson-icd10.R#490)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "Z944"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:490
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 62. Error: Charlson, diab, E100 (@test-charlson-icd10.R#496)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "E100"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:496
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 63. Error: Charlson, diab, E101 (@test-charlson-icd10.R#502)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "E101"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:502
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 64. Error: Charlson, diab, E106 (@test-charlson-icd10.R#508)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "E106"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:508
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 65. Error: Charlson, diab, E108 (@test-charlson-icd10.R#514)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "E108"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:514
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 66. Error: Charlson, diab, E109 (@test-charlson-icd10.R#520)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "E109"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:520
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 67. Error: Charlson, diab, E110 (@test-charlson-icd10.R#526)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "E110"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:526
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 68. Error: Charlson, diab, E111 (@test-charlson-icd10.R#532)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "E111"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:532
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 69. Error: Charlson, diab, E116 (@test-charlson-icd10.R#538)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "E116"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:538
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 70. Error: Charlson, diab, E118 (@test-charlson-icd10.R#544)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "E118"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:544
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 71. Error: Charlson, diab, E119 (@test-charlson-icd10.R#550)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "E119"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:550
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 72. Error: Charlson, diab, E120 (@test-charlson-icd10.R#556)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "E120"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:556
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 73. Error: Charlson, diab, E121 (@test-charlson-icd10.R#562)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "E121"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:562
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 74. Error: Charlson, diab, E126 (@test-charlson-icd10.R#568)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "E126"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:568
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 75. Error: Charlson, diab, E128 (@test-charlson-icd10.R#574)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "E128"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:574
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 76. Error: Charlson, diab, E129 (@test-charlson-icd10.R#580)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "E129"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:580
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 77. Error: Charlson, diab, E130 (@test-charlson-icd10.R#586)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "E130"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:586
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 78. Error: Charlson, diab, E131 (@test-charlson-icd10.R#592)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "E131"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:592
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 79. Error: Charlson, diab, E136 (@test-charlson-icd10.R#598)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "E136"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:598
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 80. Error: Charlson, diab, E138 (@test-charlson-icd10.R#604)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "E138"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:604
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 81. Error: Charlson, diab, E139 (@test-charlson-icd10.R#610)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "E139"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:610
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 82. Error: Charlson, diab, E140 (@test-charlson-icd10.R#616)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "E140"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:616
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 83. Error: Charlson, diab, E141 (@test-charlson-icd10.R#622)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "E141"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:622
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 84. Error: Charlson, diab, E146 (@test-charlson-icd10.R#628)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "E146"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:628
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 85. Error: Charlson, diab, E148 (@test-charlson-icd10.R#634)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "E148"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:634
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 86. Error: Charlson, diab, E149 (@test-charlson-icd10.R#640)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "E149"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:640
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 87. Error: Charlson, diabwc, E102-105 (@test-charlson-icd10.R#646)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "E102"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:646
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 88. Error: Charlson, diabwc, E107 (@test-charlson-icd10.R#661)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "E107"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:661
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 89. Error: Charlson, diabwc, E112-115 (@test-charlson-icd10.R#667)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "E112"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:667
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 90. Error: Charlson, diabwc, E117 (@test-charlson-icd10.R#682)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "E117"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:682
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 91. Error: Charlson, diabwc, E122-125 (@test-charlson-icd10.R#688)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "E122"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:688
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 92. Error: Charlson, diabwc, E127 (@test-charlson-icd10.R#703)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "E127"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:703
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 93. Error: Charlson, diabwc, E132-135 (@test-charlson-icd10.R#709)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "E132"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:709
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 94. Error: Charlson, diabwc, E137 (@test-charlson-icd10.R#724)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "E137"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:724
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 95. Error: Charlson, diabwc, E142-145 (@test-charlson-icd10.R#730)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "E142"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:730
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 96. Error: Charlson, diabwc, E147 (@test-charlson-icd10.R#745)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "E147"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:745
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 97. Error: Charlson, hp, G041 (@test-charlson-icd10.R#751)  ─────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "G041"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:751
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 98. Error: Charlson, hp, G114 (@test-charlson-icd10.R#757)  ─────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "G114"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:757
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 99. Error: Charlson, hp, G801 (@test-charlson-icd10.R#763)  ─────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "G801"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:763
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 100. Error: Charlson, hp, G802 (@test-charlson-icd10.R#769)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "G802"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:769
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 101. Error: Charlson, hp, G81 (@test-charlson-icd10.R#775)  ─────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "G81"), id = "id", code = "code", score = "charlson") at testthat/test-charlson-icd10.R:775
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 102. Error: Charlson, hp, G82 (@test-charlson-icd10.R#781)  ─────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "G82"), id = "id", code = "code", score = "charlson") at testthat/test-charlson-icd10.R:781
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 103. Error: Charlson, hp, G830-834 (@test-charlson-icd10.R#787)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "G830"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:787
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 104. Error: Charlson, hp, G839 (@test-charlson-icd10.R#805)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "G839"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:805
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 105. Error: Charlson, rend, I120 (@test-charlson-icd10.R#811)  ──────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "I120"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:811
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 106. Error: Charlson, rend, I120 (@test-charlson-icd10.R#817)  ──────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "I120"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:817
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 107. Error: Charlson, rend, I131 (@test-charlson-icd10.R#823)  ──────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "I131"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:823
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 108. Error: Charlson, rend, N032-073 (@test-charlson-icd10.R#829)  ──────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "N032"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:829
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 109. Error: Charlson, rend, N052-057 (@test-charlson-icd10.R#850)  ──────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "N052"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:850
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 110. Error: Charlson, rend, N18 (@test-charlson-icd10.R#871)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "N18"), id = "id", code = "code", score = "charlson") at testthat/test-charlson-icd10.R:871
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 111. Error: Charlson, rend, N19 (@test-charlson-icd10.R#877)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "N19"), id = "id", code = "code", score = "charlson") at testthat/test-charlson-icd10.R:877
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 112. Error: Charlson, rend, N250 (@test-charlson-icd10.R#883)  ──────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "N250"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:883
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 113. Error: Charlson, rend, Z490-492 (@test-charlson-icd10.R#889)  ──────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "Z490"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:889
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 114. Error: Charlson, rend, Z940 (@test-charlson-icd10.R#901)  ──────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "Z940"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:901
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 115. Error: Charlson, rend, Z992 (@test-charlson-icd10.R#907)  ──────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "Z992"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:907
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 116. Error: Charlson, canc, C00-26 (@test-charlson-icd10.R#913)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "C00"), id = "id", code = "code", score = "charlson") at testthat/test-charlson-icd10.R:913
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 117. Error: Charlson, canc, C30-34 (@test-charlson-icd10.R#997)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "C30"), id = "id", code = "code", score = "charlson") at testthat/test-charlson-icd10.R:997
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 118. Error: Charlson, canc, C41 (@test-charlson-icd10.R#1015)  ──────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "C41"), id = "id", code = "code", score = "charlson") at testthat/test-charlson-icd10.R:1015
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 119. Error: Charlson, canc, C43 (@test-charlson-icd10.R#1021)  ──────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "C43"), id = "id", code = "code", score = "charlson") at testthat/test-charlson-icd10.R:1021
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 120. Error: Charlson, canc, C45-58 (@test-charlson-icd10.R#1027)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "C45"), id = "id", code = "code", score = "charlson") at testthat/test-charlson-icd10.R:1027
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 121. Error: Charlson, canc, C60-76 (@test-charlson-icd10.R#1072)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "C60"), id = "id", code = "code", score = "charlson") at testthat/test-charlson-icd10.R:1072
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 122. Error: Charlson, canc, C81-85 (@test-charlson-icd10.R#1125)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "C81"), id = "id", code = "code", score = "charlson") at testthat/test-charlson-icd10.R:1125
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 123. Error: Charlson, canc, C88 (@test-charlson-icd10.R#1143)  ──────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "C88"), id = "id", code = "code", score = "charlson") at testthat/test-charlson-icd10.R:1143
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 124. Error: Charlson, canc, C90-97 (@test-charlson-icd10.R#1149)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "C90"), id = "id", code = "code", score = "charlson") at testthat/test-charlson-icd10.R:1149
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 125. Error: Charlson, msld, I850 (@test-charlson-icd10.R#1176)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "I850"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:1176
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 126. Error: Charlson, msld, I859 (@test-charlson-icd10.R#1182)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "I859"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:1182
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 127. Error: Charlson, msld, I864 (@test-charlson-icd10.R#1188)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "I864"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:1188
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 128. Error: Charlson, msld, I982 (@test-charlson-icd10.R#1194)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "I982"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:1194
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 129. Error: Charlson, msld, K704 (@test-charlson-icd10.R#1200)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "K704"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:1200
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 130. Error: Charlson, msld, K711 (@test-charlson-icd10.R#1206)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "K711"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:1206
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 131. Error: Charlson, msld, K721 (@test-charlson-icd10.R#1212)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "K721"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:1212
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 132. Error: Charlson, msld, K729 (@test-charlson-icd10.R#1218)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "K729"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:1218
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 133. Error: Charlson, msld, K765 (@test-charlson-icd10.R#1224)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "K765"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:1224
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 134. Error: Charlson, msld, K766 (@test-charlson-icd10.R#1230)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "K766"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:1230
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 135. Error: Charlson, msld, K767 (@test-charlson-icd10.R#1236)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "K767"), id = "id", code = "code", 
         score = "charlson") at testthat/test-charlson-icd10.R:1236
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 136. Error: Charlson, metacanc, C77-80 (@test-charlson-icd10.R#1242)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "C77"), id = "id", code = "code", score = "charlson") at testthat/test-charlson-icd10.R:1242
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 137. Error: Charlson, aids, B20-22 (@test-charlson-icd10.R#1257)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "B20"), id = "id", code = "code", score = "charlson") at testthat/test-charlson-icd10.R:1257
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 138. Error: Charlson, aids, B24 (@test-charlson-icd10.R#1269)  ──────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "B24"), id = "id", code = "code", score = "charlson") at testthat/test-charlson-icd10.R:1269
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 139. Error: Charlson, ami, 410 (@test-charlson-icd9.R#4)  ───────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "410"), id = "id", code = "code", score = "charlson", 
         icd = "icd9") at testthat/test-charlson-icd9.R:4
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 140. Error: Charlson, ami, 412 (@test-charlson-icd9.R#9)  ───────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "412"), id = "id", code = "code", score = "charlson", 
         icd = "icd9") at testthat/test-charlson-icd9.R:9
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 141. Error: Charlson, chf, 39891 (@test-charlson-icd9.R#15)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "39891"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:15
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 142. Error: Charlson, chf, 39891 (@test-charlson-icd9.R#20)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "39891"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:20
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 143. Error: Charlson, chf, 39891 (@test-charlson-icd9.R#25)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "39891"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:25
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 144. Error: Charlson, chf, 40201 (@test-charlson-icd9.R#30)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "40201"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:30
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 145. Error: Charlson, chf, 40211 (@test-charlson-icd9.R#35)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "40211"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:35
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 146. Error: Charlson, chf, 40291 (@test-charlson-icd9.R#40)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "40291"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:40
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 147. Error: Charlson, chf, 40401 (@test-charlson-icd9.R#45)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "40401"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:45
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 148. Error: Charlson, chf, 40403 (@test-charlson-icd9.R#50)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "40403"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:50
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 149. Error: Charlson, chf, 40411 (@test-charlson-icd9.R#55)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "40411"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:55
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 150. Error: Charlson, chf, 40413 (@test-charlson-icd9.R#60)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "40413"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:60
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 151. Error: Charlson, chf, 40491 (@test-charlson-icd9.R#65)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "40491"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:65
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 152. Error: Charlson, chf, 40493 (@test-charlson-icd9.R#70)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "40493"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:70
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 153. Error: Charlson, chf, 4254-4259 (@test-charlson-icd9.R#75)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "4254"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:75
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 154. Error: Charlson, pvd, 0930 (@test-charlson-icd9.R#96)  ─────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "0930"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:96
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 155. Error: Charlson, pvd, 0930 (@test-charlson-icd9.R#101)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "0930"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:101
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 156. Error: Charlson, pvd, 4373 (@test-charlson-icd9.R#106)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "4373"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:106
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 157. Error: Charlson, pvd, 440 (@test-charlson-icd9.R#111)  ─────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "440"), id = "id", code = "code", score = "charlson", 
         icd = "icd9") at testthat/test-charlson-icd9.R:111
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 158. Error: Charlson, pvd, 441 (@test-charlson-icd9.R#116)  ─────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "441"), id = "id", code = "code", score = "charlson", 
         icd = "icd9") at testthat/test-charlson-icd9.R:116
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 159. Error: Charlson, pvd, 4431-4439 (@test-charlson-icd9.R#121)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "4431"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:121
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 160. Error: Charlson, pvd, 471 (@test-charlson-icd9.R#150)  ─────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "471"), id = "id", code = "code", score = "charlson", 
         icd = "icd9") at testthat/test-charlson-icd9.R:150
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 161. Error: Charlson, pvd, 5571 (@test-charlson-icd9.R#155)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "5571"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:155
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 162. Error: Charlson, pvd, 5579 (@test-charlson-icd9.R#160)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "5579"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:160
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 163. Error: Charlson, pvd, V434 (@test-charlson-icd9.R#165)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "V434"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:165
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 164. Error: Charlson, cevd, 36234 (@test-charlson-icd9.R#171)  ──────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "36234"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:171
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 165. Error: Charlson, cevd, 430-438 (@test-charlson-icd9.R#176)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "430"), id = "id", code = "code", score = "charlson", 
         icd = "icd9") at testthat/test-charlson-icd9.R:176
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 166. Error: Charlson, dementia, 290 (@test-charlson-icd9.R#206)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "290"), id = "id", code = "code", score = "charlson", 
         icd = "icd9") at testthat/test-charlson-icd9.R:206
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 167. Error: Charlson, dementia, 2941 (@test-charlson-icd9.R#211)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "2941"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:211
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 168. Error: Charlson, dementia, 3312 (@test-charlson-icd9.R#216)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "3312"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:216
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 169. Error: Charlson, copd, 4168 (@test-charlson-icd9.R#222)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "4168"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:222
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 170. Error: Charlson, copd, 4169 (@test-charlson-icd9.R#227)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "4169"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:227
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 171. Error: Charlson, copd, 490-505 (@test-charlson-icd9.R#232)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "490"), id = "id", code = "code", score = "charlson", 
         icd = "icd9") at testthat/test-charlson-icd9.R:232
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 172. Error: Charlson, copd, 5064 (@test-charlson-icd9.R#282)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "5064"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:282
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 173. Error: Charlson, copd, 5081 (@test-charlson-icd9.R#287)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "5081"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:287
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 174. Error: Charlson, copd, 5088 (@test-charlson-icd9.R#292)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "5088"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:292
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 175. Error: Charlson, rheumd, 4465 (@test-charlson-icd9.R#298)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "4465"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:298
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 176. Error: Charlson, rheumd, 7100-7104 (@test-charlson-icd9.R#303)  ────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "7100"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:303
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 177. Error: Charlson, rheumd, 7140-7142 (@test-charlson-icd9.R#320)  ────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "7140"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:320
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 178. Error: Charlson, rheumd, 7148 (@test-charlson-icd9.R#331)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "7148"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:331
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 179. Error: Charlson, rheumd, 725 (@test-charlson-icd9.R#336)  ──────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "725"), id = "id", code = "code", score = "charlson", 
         icd = "icd9") at testthat/test-charlson-icd9.R:336
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 180. Error: Charlson, pud, 531-534 (@test-charlson-icd9.R#342)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "531"), id = "id", code = "code", score = "charlson", 
         icd = "icd9") at testthat/test-charlson-icd9.R:342
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 181. Error: Charlson, mld, 07022 (@test-charlson-icd9.R#357)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "07022"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:357
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 182. Error: Charlson, mld, 07023 (@test-charlson-icd9.R#362)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "07023"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:362
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 183. Error: Charlson, mld, 07032 (@test-charlson-icd9.R#367)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "07032"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:367
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 184. Error: Charlson, mld, 07033 (@test-charlson-icd9.R#372)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "07033"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:372
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 185. Error: Charlson, mld, 07044 (@test-charlson-icd9.R#377)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "07044"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:377
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 186. Error: Charlson, mld, 07054 (@test-charlson-icd9.R#382)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "07054"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:382
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 187. Error: Charlson, mld, 0706 (@test-charlson-icd9.R#387)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "0706"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:387
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 188. Error: Charlson, mld, 0709 (@test-charlson-icd9.R#392)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "0709"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:392
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 189. Error: Charlson, mld, 570 (@test-charlson-icd9.R#397)  ─────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "570"), id = "id", code = "code", score = "charlson", 
         icd = "icd9") at testthat/test-charlson-icd9.R:397
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 190. Error: Charlson, mld, 571 (@test-charlson-icd9.R#402)  ─────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "571"), id = "id", code = "code", score = "charlson", 
         icd = "icd9") at testthat/test-charlson-icd9.R:402
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 191. Error: Charlson, mld, 5733 (@test-charlson-icd9.R#407)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "5733"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:407
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 192. Error: Charlson, mld, 5734 (@test-charlson-icd9.R#412)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "5734"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:412
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 193. Error: Charlson, mld, 5738 (@test-charlson-icd9.R#417)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "5738"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:417
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 194. Error: Charlson, mld, 5739 (@test-charlson-icd9.R#422)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "5739"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:422
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 195. Error: Charlson, mld, V427 (@test-charlson-icd9.R#427)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "V427"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:427
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 196. Error: Charlson, diab, 2500-2503 (@test-charlson-icd9.R#433)  ──────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "2500"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:433
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 197. Error: Charlson, diab, 2508 (@test-charlson-icd9.R#447)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "2508"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:447
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 198. Error: Charlson, diab, 2509 (@test-charlson-icd9.R#452)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "2509"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:452
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 199. Error: Charlson, diabwc, 2504-2507 (@test-charlson-icd9.R#458)  ────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "2504"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:458
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 200. Error: Charlson, hp, 3341 (@test-charlson-icd9.R#473)  ─────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "3341"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:473
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 201. Error: Charlson, hp, 342 (@test-charlson-icd9.R#478)  ──────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "342"), id = "id", code = "code", score = "charlson", 
         icd = "icd9") at testthat/test-charlson-icd9.R:478
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 202. Error: Charlson, hp, 343 (@test-charlson-icd9.R#483)  ──────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "343"), id = "id", code = "code", score = "charlson", 
         icd = "icd9") at testthat/test-charlson-icd9.R:483
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 203. Error: Charlson, hp, 3440-3446 (@test-charlson-icd9.R#488)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "3440"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:488
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 204. Error: Charlson, hp, 3449 (@test-charlson-icd9.R#511)  ─────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "3449"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:511
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 205. Error: Charlson, rend, 40301 (@test-charlson-icd9.R#517)  ──────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "40301"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:517
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 206. Error: Charlson, rend, 40311 (@test-charlson-icd9.R#522)  ──────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "40311"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:522
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 207. Error: Charlson, rend, 40391 (@test-charlson-icd9.R#527)  ──────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "40391"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:527
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 208. Error: Charlson, rend, 40402 (@test-charlson-icd9.R#532)  ──────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "40402"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:532
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 209. Error: Charlson, rend, 40403 (@test-charlson-icd9.R#537)  ──────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "40403"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:537
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 210. Error: Charlson, rend, 40412 (@test-charlson-icd9.R#542)  ──────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "40412"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:542
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 211. Error: Charlson, rend, 40413 (@test-charlson-icd9.R#547)  ──────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "40413"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:547
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 212. Error: Charlson, rend, 40492 (@test-charlson-icd9.R#552)  ──────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "40492"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:552
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 213. Error: Charlson, rend, 40493 (@test-charlson-icd9.R#557)  ──────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "40493"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:557
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 214. Error: Charlson, rend, 582 (@test-charlson-icd9.R#562)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "582"), id = "id", code = "code", score = "charlson", 
         icd = "icd9") at testthat/test-charlson-icd9.R:562
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 215. Error: Charlson, rend, 5830-5837 (@test-charlson-icd9.R#567)  ──────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "5830"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:567
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 216. Error: Charlson, rend, 585 (@test-charlson-icd9.R#593)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "585"), id = "id", code = "code", score = "charlson", 
         icd = "icd9") at testthat/test-charlson-icd9.R:593
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 217. Error: Charlson, rend, 586 (@test-charlson-icd9.R#598)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "586"), id = "id", code = "code", score = "charlson", 
         icd = "icd9") at testthat/test-charlson-icd9.R:598
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 218. Error: Charlson, rend, 5880 (@test-charlson-icd9.R#603)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "5880"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:603
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 219. Error: Charlson, rend, V420 (@test-charlson-icd9.R#608)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "V420"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:608
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 220. Error: Charlson, rend, V451 (@test-charlson-icd9.R#613)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "V451"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:613
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 221. Error: Charlson, rend, V56 (@test-charlson-icd9.R#618)  ────────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "V56"), id = "id", code = "code", score = "charlson", 
         icd = "icd9") at testthat/test-charlson-icd9.R:618
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 222. Error: Charlson, rend, 40301 (@test-charlson-icd9.R#623)  ──────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "40301"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:623
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 223. Error: Charlson, canc, 140-172 (@test-charlson-icd9.R#629)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "140"), id = "id", code = "code", score = "charlson", 
         icd = "icd9") at testthat/test-charlson-icd9.R:629
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 224. Error: Charlson, canc, 174-195 (@test-charlson-icd9.R#730)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "174"), id = "id", code = "code", score = "charlson", 
         icd = "icd9") at testthat/test-charlson-icd9.R:730
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 225. Error: Charlson, canc, 200-208 (@test-charlson-icd9.R#798)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "200"), id = "id", code = "code", score = "charlson", 
         icd = "icd9") at testthat/test-charlson-icd9.R:798
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 226. Error: Charlson, canc, 2386 (@test-charlson-icd9.R#827)  ───────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "2386"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:827
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 227. Error: Charlson, msld, 4560-4562 (@test-charlson-icd9.R#833)  ──────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "4560"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:833
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 228. Error: Charlson, msld, 5722-5728 (@test-charlson-icd9.R#844)  ──────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "5722"), id = "id", code = "code", 
         score = "charlson", icd = "icd9") at testthat/test-charlson-icd9.R:844
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 229. Error: Charlson, metacanc, 196-199 (@test-charlson-icd9.R#868)  ────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "196"), id = "id", code = "code", score = "charlson", 
         icd = "icd9") at testthat/test-charlson-icd9.R:868
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 230. Error: Charlson, aids, 042-044 (@test-charlson-icd9.R#883)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "042"), id = "id", code = "code", score = "charlson", 
         icd = "icd9") at testthat/test-charlson-icd9.R:883
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 231. Error: comorbidity returns an error if x is a vector (@test-comorbidity.
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: sample_diag(50) at testthat/test-comorbidity.R:4
  2: checkmate::assert_choice(version, choices = c("ICD10_2009", "ICD10_2011", "ICD9_2015"), 
         add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 232. Error: comorbidity returns an error if x, id, code, score are not provid
  LOGICAL() can only be applied to a 'logical', not a 'raw'
  1: data.frame(id = sample(1:5, size = 50, replace = TRUE), code = sample_diag(50), stringsAsFactors = FALSE) at testthat/test-comorbidity.R:11
  2: sample_diag(50)
  3: checkmate::assert_choice(version, choices = c("ICD10_2009", "ICD10_2011", "ICD9_2015"), 
         add = arg_checks)
  4: checkChoice(x, choices, null.ok, fmatch)
  5: qassert(null.ok, "B1")
  
  ── 233. Error: comorbidity returns an error if id, code not in x (@test-comorbid
  LOGICAL() can only be applied to a 'logical', not a 'raw'
  1: data.frame(id = sample(1:5, size = 50, replace = TRUE), code = sample_diag(50), stringsAsFactors = FALSE) at testthat/test-comorbidity.R:61
  2: sample_diag(50)
  3: checkmate::assert_choice(version, choices = c("ICD10_2009", "ICD10_2011", "ICD9_2015"), 
         add = arg_checks)
  4: checkChoice(x, choices, null.ok, fmatch)
  5: qassert(null.ok, "B1")
  
  ── 234. Error: charlson checks for its arguments properly (@test-comorbidity.R#7
  LOGICAL() can only be applied to a 'logical', not a 'raw'
  1: data.frame(id = sample(1:5, size = 50, replace = TRUE), code = sample_diag(50), stringsAsFactors = FALSE) at testthat/test-comorbidity.R:78
  2: sample_diag(50)
  3: checkmate::assert_choice(version, choices = c("ICD10_2009", "ICD10_2011", "ICD9_2015"), 
         add = arg_checks)
  4: checkChoice(x, choices, null.ok, fmatch)
  5: qassert(null.ok, "B1")
  
  ── 235. Error: comorbidity returns a data.frame (@test-comorbidity.R#131)  ─────
  LOGICAL() can only be applied to a 'logical', not a 'raw'
  1: data.frame(id = sample(1:5, size = 50, replace = TRUE), code = sample_diag(50), stringsAsFactors = FALSE) at testthat/test-comorbidity.R:131
  2: sample_diag(50)
  3: checkmate::assert_choice(version, choices = c("ICD10_2009", "ICD10_2011", "ICD9_2015"), 
         add = arg_checks)
  4: checkChoice(x, choices, null.ok, fmatch)
  5: qassert(null.ok, "B1")
  
  ── 236. Error: comorbidity returns a data.frame with the correct number of rows 
  LOGICAL() can only be applied to a 'logical', not a 'raw'
  1: data.frame(id = sample(1:5, size = 10 * 5, replace = TRUE), code = sample_diag(10 * 
         5), stringsAsFactors = FALSE) at testthat/test-comorbidity.R:152
  2: sample_diag(10 * 5)
  3: checkmate::assert_choice(version, choices = c("ICD10_2009", "ICD10_2011", "ICD9_2015"), 
         add = arg_checks)
  4: checkChoice(x, choices, null.ok, fmatch)
  5: qassert(null.ok, "B1")
  
  ── 237. Error: if labelled = TRUE, comorbidity returns variable labels (@test-co
  LOGICAL() can only be applied to a 'logical', not a 'raw'
  1: data.frame(id = sample(1:5, size = 10 * 5, replace = TRUE), code = sample_diag(10 * 
         5), stringsAsFactors = FALSE) at testthat/test-comorbidity.R:169
  2: sample_diag(10 * 5)
  3: checkmate::assert_choice(version, choices = c("ICD10_2009", "ICD10_2011", "ICD9_2015"), 
         add = arg_checks)
  4: checkChoice(x, choices, null.ok, fmatch)
  5: qassert(null.ok, "B1")
  
  ── 238. Error: if labelled = FALSE, comorbidity does not return variable labels 
  LOGICAL() can only be applied to a 'logical', not a 'raw'
  1: data.frame(id = sample(1:5, size = 10 * 5, replace = TRUE), code = sample_diag(10 * 
         5), stringsAsFactors = FALSE) at testthat/test-comorbidity.R:181
  2: sample_diag(10 * 5)
  3: checkmate::assert_choice(version, choices = c("ICD10_2009", "ICD10_2011", "ICD9_2015"), 
         add = arg_checks)
  4: checkChoice(x, choices, null.ok, fmatch)
  5: qassert(null.ok, "B1")
  
  ── 239. Error: if factorise = TRUE comorbidity returns factors (@test-comorbidit
  LOGICAL() can only be applied to a 'logical', not a 'raw'
  1: data.frame(id = sample(1:5, size = 10 * 5, replace = TRUE), code = sample_diag(10 * 
         5), stringsAsFactors = FALSE) at testthat/test-comorbidity.R:206
  2: sample_diag(10 * 5)
  3: checkmate::assert_choice(version, choices = c("ICD10_2009", "ICD10_2011", "ICD9_2015"), 
         add = arg_checks)
  4: checkChoice(x, choices, null.ok, fmatch)
  5: qassert(null.ok, "B1")
  
  ── 240. Error: if factorise = FALSE comorbidity does not return factors (@test-c
  LOGICAL() can only be applied to a 'logical', not a 'raw'
  1: data.frame(id = sample(1:5, size = 10 * 5, replace = TRUE), code = sample_diag(10 * 
         5), stringsAsFactors = FALSE) at testthat/test-comorbidity.R:327
  2: sample_diag(10 * 5)
  3: checkmate::assert_choice(version, choices = c("ICD10_2009", "ICD10_2011", "ICD9_2015"), 
         add = arg_checks)
  4: checkChoice(x, choices, null.ok, fmatch)
  5: qassert(null.ok, "B1")
  
  ── 241. Error: parallel computing works (specifying the number of clusters) (@te
  LOGICAL() can only be applied to a 'logical', not a 'raw'
  1: data.frame(id = sample(1:50, size = 10 * 50, replace = TRUE), code = sample_diag(10 * 
         50), stringsAsFactors = FALSE) at testthat/test-comorbidity.R:448
  2: sample_diag(10 * 50)
  3: checkmate::assert_choice(version, choices = c("ICD10_2009", "ICD10_2011", "ICD9_2015"), 
         add = arg_checks)
  4: checkChoice(x, choices, null.ok, fmatch)
  5: qassert(null.ok, "B1")
  
  ── 242. Error: running computations in parallel vs serial returns the same resul
  LOGICAL() can only be applied to a 'logical', not a 'raw'
  1: data.frame(id = sample(1:50, size = 10 * 50, replace = TRUE), code = sample_diag(10 * 
         50), stringsAsFactors = FALSE) at testthat/test-comorbidity.R:477
  2: sample_diag(10 * 50)
  3: checkmate::assert_choice(version, choices = c("ICD10_2009", "ICD10_2011", "ICD9_2015"), 
         add = arg_checks)
  4: checkChoice(x, choices, null.ok, fmatch)
  5: qassert(null.ok, "B1")
  
  ── 243. Error: Elixhauser, chf, I099 (@test-elixhauser-icd10.R#4)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "I099"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:4
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 244. Error: Elixhauser, chf, I110 (@test-elixhauser-icd10.R#10)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'NULL'
  1: comorbidity(x = data.frame(id = "ID1", code = "I110"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:10
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 245. Error: Elixhauser, chf, I130 (@test-elixhauser-icd10.R#17)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "I130"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:17
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 246. Error: Elixhauser, chf, I132 (@test-elixhauser-icd10.R#24)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "I132"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:24
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 247. Error: Elixhauser, chf, I255 (@test-elixhauser-icd10.R#31)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "I255"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:31
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 248. Error: Elixhauser, chf, I420 (@test-elixhauser-icd10.R#37)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "I420"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:37
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 249. Error: Elixhauser, chf, I425-429 (@test-elixhauser-icd10.R#43)  ────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "I425"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:43
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 250. Error: Elixhauser, chf, I43 (@test-elixhauser-icd10.R#62)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "I43"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:62
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 251. Error: Elixhauser, chf, I50 (@test-elixhauser-icd10.R#68)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "I50"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:68
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 252. Error: Elixhauser, chf, P290 (@test-elixhauser-icd10.R#74)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "P290"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:74
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 253. Error: Elixhauser, carit, I441-443 (@test-elixhauser-icd10.R#80)  ──────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "I441"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:80
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 254. Error: Elixhauser, carit, I456 (@test-elixhauser-icd10.R#92)  ──────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "I456"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:92
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 255. Error: Elixhauser, carit, I459 (@test-elixhauser-icd10.R#98)  ──────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "I459"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:98
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 256. Error: Elixhauser, carit, I47-49 (@test-elixhauser-icd10.R#104)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "I47"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:104
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 257. Error: Elixhauser, carit, R000 (@test-elixhauser-icd10.R#116)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "R000"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:116
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 258. Error: Elixhauser, carit, R001 (@test-elixhauser-icd10.R#122)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "R001"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:122
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 259. Error: Elixhauser, carit, R008 (@test-elixhauser-icd10.R#128)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "R008"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:128
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 260. Error: Elixhauser, carit, T821 (@test-elixhauser-icd10.R#134)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "T821"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:134
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 261. Error: Elixhauser, carit, Z450 (@test-elixhauser-icd10.R#140)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "Z450"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:140
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 262. Error: Elixhauser, carit, Z950 (@test-elixhauser-icd10.R#146)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "Z950"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:146
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 263. Error: Elixhauser, valv, A520 (@test-elixhauser-icd10.R#152)  ──────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "A520"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:152
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 264. Error: Elixhauser, valv, I05-08 (@test-elixhauser-icd10.R#158)  ────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "I05"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:158
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 265. Error: Elixhauser, valv, I091 (@test-elixhauser-icd10.R#173)  ──────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "I091"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:173
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 266. Error: Elixhauser, valv, I098 (@test-elixhauser-icd10.R#179)  ──────────
  LOGICAL() can only be applied to a 'logical', not a 'character'
  1: comorbidity(x = data.frame(id = "ID1", code = "I098"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:179
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 267. Error: Elixhauser, valv, I34-39 (@test-elixhauser-icd10.R#185)  ────────
  LOGICAL() can only be applied to a 'logical', not a 'character'
  1: comorbidity(x = data.frame(id = "ID1", code = "I34"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:185
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 268. Error: Elixhauser, valv, Q230-233 (@test-elixhauser-icd10.R#206)  ──────
  LOGICAL() can only be applied to a 'logical', not a 'character'
  1: comorbidity(x = data.frame(id = "ID1", code = "Q230"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:206
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 269. Error: Elixhauser, valv, Z952-954 (@test-elixhauser-icd10.R#221)  ──────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "Z952"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:221
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 270. Error: Elixhauser, pcd, I26 (@test-elixhauser-icd10.R#233)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'character'
  1: comorbidity(x = data.frame(id = "ID1", code = "I26"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:233
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 271. Error: Elixhauser, pcd, I27 (@test-elixhauser-icd10.R#239)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'character'
  1: comorbidity(x = data.frame(id = "ID1", code = "I27"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:239
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 272. Error: Elixhauser, pcd, I280 (@test-elixhauser-icd10.R#245)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'character'
  1: comorbidity(x = data.frame(id = "ID1", code = "I280"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:245
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 273. Error: Elixhauser, pcd, I288 (@test-elixhauser-icd10.R#251)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'character'
  1: comorbidity(x = data.frame(id = "ID1", code = "I288"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:251
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 274. Error: Elixhauser, pcd, I289 (@test-elixhauser-icd10.R#257)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'character'
  1: comorbidity(x = data.frame(id = "ID1", code = "I289"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:257
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 275. Error: Elixhauser, pvd, I70 (@test-elixhauser-icd10.R#263)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'character'
  1: comorbidity(x = data.frame(id = "ID1", code = "I70"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:263
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 276. Error: Elixhauser, pvd, I71 (@test-elixhauser-icd10.R#269)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'character'
  1: comorbidity(x = data.frame(id = "ID1", code = "I71"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:269
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 277. Error: Elixhauser, pvd, I731 (@test-elixhauser-icd10.R#275)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'character'
  1: comorbidity(x = data.frame(id = "ID1", code = "I731"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:275
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 278. Error: Elixhauser, pvd, I738 (@test-elixhauser-icd10.R#281)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'character'
  1: comorbidity(x = data.frame(id = "ID1", code = "I738"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:281
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 279. Error: Elixhauser, pvd, I739 (@test-elixhauser-icd10.R#287)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "I739"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:287
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 280. Error: Elixhauser, pvd, I771 (@test-elixhauser-icd10.R#293)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "I771"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:293
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 281. Error: Elixhauser, pvd, I790 (@test-elixhauser-icd10.R#299)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "I790"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:299
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 282. Error: Elixhauser, pvd, I792 (@test-elixhauser-icd10.R#305)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "I792"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:305
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 283. Error: Elixhauser, pvd, K551 (@test-elixhauser-icd10.R#311)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "K551"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:311
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 284. Error: Elixhauser, pvd, K558 (@test-elixhauser-icd10.R#317)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "K558"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:317
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 285. Error: Elixhauser, pvd, K559 (@test-elixhauser-icd10.R#323)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "K559"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:323
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 286. Error: Elixhauser, pvd, Z958 (@test-elixhauser-icd10.R#329)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "Z958"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:329
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 287. Error: Elixhauser, pvd, Z959 (@test-elixhauser-icd10.R#335)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "Z959"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:335
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 288. Error: Elixhauser, hypunc, I10 (@test-elixhauser-icd10.R#341)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "I10"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:341
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 289. Error: Elixhauser, hypc, I11-13 (@test-elixhauser-icd10.R#347)  ────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "I11"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:347
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 290. Error: Elixhauser, hypc, I15 (@test-elixhauser-icd10.R#359)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "I15"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:359
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 291. Error: Elixhauser, para, G041 (@test-elixhauser-icd10.R#365)  ──────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "G041"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:365
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 292. Error: Elixhauser, para, G114 (@test-elixhauser-icd10.R#371)  ──────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "G114"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:371
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 293. Error: Elixhauser, para, G801 (@test-elixhauser-icd10.R#378)  ──────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "G801"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:378
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 294. Error: Elixhauser, para, G802 (@test-elixhauser-icd10.R#384)  ──────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "G802"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:384
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 295. Error: Elixhauser, para, G81 (@test-elixhauser-icd10.R#390)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "G81"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:390
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 296. Error: Elixhauser, para, G82 (@test-elixhauser-icd10.R#396)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "G82"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:396
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 297. Error: Elixhauser, para, G830-834 (@test-elixhauser-icd10.R#402)  ──────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "G830"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:402
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 298. Error: Elixhauser, para, G839 (@test-elixhauser-icd10.R#420)  ──────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "G839"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:420
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 299. Error: Elixhauser, ond, G10-13 (@test-elixhauser-icd10.R#426)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "G10"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:426
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 300. Error: Elixhauser, ond, G20-22 (@test-elixhauser-icd10.R#441)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "G20"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:441
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 301. Error: Elixhauser, ond, G254 (@test-elixhauser-icd10.R#453)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "G254"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:453
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 302. Error: Elixhauser, ond, G255 (@test-elixhauser-icd10.R#459)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "G255"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:459
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 303. Error: Elixhauser, ond, G312 (@test-elixhauser-icd10.R#465)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "G312"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:465
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 304. Error: Elixhauser, ond, G318 (@test-elixhauser-icd10.R#471)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "G318"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:471
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 305. Error: Elixhauser, ond, G319 (@test-elixhauser-icd10.R#477)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "G319"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:477
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 306. Error: Elixhauser, ond, G32 (@test-elixhauser-icd10.R#483)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "G32"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:483
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 307. Error: Elixhauser, ond, G35-37 (@test-elixhauser-icd10.R#489)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "G35"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:489
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 308. Error: Elixhauser, ond, G40 (@test-elixhauser-icd10.R#501)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "G40"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:501
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 309. Error: Elixhauser, ond, G41 (@test-elixhauser-icd10.R#507)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "G41"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:507
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 310. Error: Elixhauser, ond, G931 (@test-elixhauser-icd10.R#513)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "G931"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:513
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 311. Error: Elixhauser, ond, G934 (@test-elixhauser-icd10.R#519)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "G934"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:519
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 312. Error: Elixhauser, ond, R470 (@test-elixhauser-icd10.R#525)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "R470"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:525
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 313. Error: Elixhauser, ond, R56 (@test-elixhauser-icd10.R#531)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "R56"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:531
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 314. Error: Elixhauser, cpd, I278 (@test-elixhauser-icd10.R#537)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "I278"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:537
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 315. Error: Elixhauser, cpd, I279 (@test-elixhauser-icd10.R#544)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "I279"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:544
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 316. Error: Elixhauser, cpd, J40-47 (@test-elixhauser-icd10.R#551)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "I278"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:551
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 317. Error: Elixhauser, cpd, J60-67 (@test-elixhauser-icd10.R#558)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "J60"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:558
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 318. Error: Elixhauser, cpd, J684 (@test-elixhauser-icd10.R#585)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "J684"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:585
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 319. Error: Elixhauser, cpd, J701 (@test-elixhauser-icd10.R#591)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "J701"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:591
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 320. Error: Elixhauser, cpd, J703 (@test-elixhauser-icd10.R#597)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "J703"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:597
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 321. Error: Elixhauser, diabunc, E100 (@test-elixhauser-icd10.R#603)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "E100"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:603
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 322. Error: Elixhauser, diabunc, E101 (@test-elixhauser-icd10.R#609)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "E101"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:609
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 323. Error: Elixhauser, diabunc, E109 (@test-elixhauser-icd10.R#615)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "E109"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:615
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 324. Error: Elixhauser, diabunc, E110 (@test-elixhauser-icd10.R#621)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "E110"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:621
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 325. Error: Elixhauser, diabunc, E111 (@test-elixhauser-icd10.R#627)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "E111"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:627
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 326. Error: Elixhauser, diabunc, E119 (@test-elixhauser-icd10.R#633)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "E119"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:633
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 327. Error: Elixhauser, diabunc, E120 (@test-elixhauser-icd10.R#639)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "E120"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:639
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 328. Error: Elixhauser, diabunc, E121 (@test-elixhauser-icd10.R#645)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "E121"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:645
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 329. Error: Elixhauser, diabunc, E129 (@test-elixhauser-icd10.R#651)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "E129"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:651
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 330. Error: Elixhauser, diabunc, E130 (@test-elixhauser-icd10.R#657)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "E130"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:657
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 331. Error: Elixhauser, diabunc, E131 (@test-elixhauser-icd10.R#663)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "E131"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:663
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 332. Error: Elixhauser, diabunc, E139 (@test-elixhauser-icd10.R#669)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "E139"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:669
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 333. Error: Elixhauser, diabunc, E140 (@test-elixhauser-icd10.R#675)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "E140"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:675
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 334. Error: Elixhauser, diabunc, E141 (@test-elixhauser-icd10.R#681)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "E141"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:681
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 335. Error: Elixhauser, diabunc, E149 (@test-elixhauser-icd10.R#687)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "E149"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:687
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 336. Error: Elixhauser, diabc, E102-108 (@test-elixhauser-icd10.R#693)  ─────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "E102"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:693
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 337. Error: Elixhauser, diabc, E112-118 (@test-elixhauser-icd10.R#717)  ─────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "E112"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:717
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 338. Error: Elixhauser, diabc, E122-128 (@test-elixhauser-icd10.R#741)  ─────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "E122"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:741
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 339. Error: Elixhauser, diabc, E132-138 (@test-elixhauser-icd10.R#765)  ─────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "E132"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:765
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 340. Error: Elixhauser, diabc, E142-148 (@test-elixhauser-icd10.R#789)  ─────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "E142"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:789
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 341. Error: Elixhauser, hypothy, E00-03 (@test-elixhauser-icd10.R#813)  ─────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "E00"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:813
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 342. Error: Elixhauser, hypothy, E890 (@test-elixhauser-icd10.R#828)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "E890"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:828
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 343. Error: Elixhauser, rf, I120 (@test-elixhauser-icd10.R#834)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "I120"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:834
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 344. Error: Elixhauser, rf, I131 (@test-elixhauser-icd10.R#841)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "I131"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:841
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 345. Error: Elixhauser, rf, N18 (@test-elixhauser-icd10.R#848)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "N18"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:848
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 346. Error: Elixhauser, rf, N19 (@test-elixhauser-icd10.R#854)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "N19"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:854
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 347. Error: Elixhauser, rf, N250 (@test-elixhauser-icd10.R#860)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "N250"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:860
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 348. Error: Elixhauser, rf, Z490-492 (@test-elixhauser-icd10.R#866)  ────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "Z490"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:866
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 349. Error: Elixhauser, rf, Z940 (@test-elixhauser-icd10.R#878)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "Z940"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:878
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 350. Error: Elixhauser, rf, Z992 (@test-elixhauser-icd10.R#884)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "Z992"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:884
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 351. Error: Elixhauser, ld, B18 (@test-elixhauser-icd10.R#890)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "B18"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:890
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 352. Error: Elixhauser, ld, I85 (@test-elixhauser-icd10.R#896)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "I85"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:896
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 353. Error: Elixhauser, ld, I864 (@test-elixhauser-icd10.R#902)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "I864"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:902
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 354. Error: Elixhauser, ld, I982 (@test-elixhauser-icd10.R#908)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "I982"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:908
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 355. Error: Elixhauser, ld, K70 (@test-elixhauser-icd10.R#914)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "K70"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:914
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 356. Error: Elixhauser, ld, K711 (@test-elixhauser-icd10.R#920)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "K711"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:920
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 357. Error: Elixhauser, ld, K713-715 (@test-elixhauser-icd10.R#926)  ────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "K713"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:926
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 358. Error: Elixhauser, ld, K717 (@test-elixhauser-icd10.R#938)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "K717"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:938
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 359. Error: Elixhauser, ld, K72-74 (@test-elixhauser-icd10.R#944)  ──────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "K72"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:944
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 360. Error: Elixhauser, ld, K760 (@test-elixhauser-icd10.R#956)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "K760"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:956
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 361. Error: Elixhauser, ld, K762-769 (@test-elixhauser-icd10.R#962)  ────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "K762"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:962
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 362. Error: Elixhauser, ld, Z944 (@test-elixhauser-icd10.R#989)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "Z944"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:989
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 363. Error: Elixhauser, pud, K257 (@test-elixhauser-icd10.R#995)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "K257"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:995
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 364. Error: Elixhauser, pud, K259 (@test-elixhauser-icd10.R#1001)  ──────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "K259"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:1001
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 365. Error: Elixhauser, pud, K267 (@test-elixhauser-icd10.R#1007)  ──────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "K267"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:1007
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 366. Error: Elixhauser, pud, K269 (@test-elixhauser-icd10.R#1013)  ──────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "K269"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:1013
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 367. Error: Elixhauser, pud, K277 (@test-elixhauser-icd10.R#1019)  ──────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "K277"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:1019
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 368. Error: Elixhauser, pud, K279 (@test-elixhauser-icd10.R#1025)  ──────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "K279"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:1025
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 369. Error: Elixhauser, pud, K287 (@test-elixhauser-icd10.R#1031)  ──────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "K287"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:1031
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 370. Error: Elixhauser, pud, K289 (@test-elixhauser-icd10.R#1037)  ──────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "K289"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:1037
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 371. Error: Elixhauser, aids, B20-22 (@test-elixhauser-icd10.R#1043)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "B20"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:1043
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 372. Error: Elixhauser, aids, B24 (@test-elixhauser-icd10.R#1055)  ──────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "B24"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:1055
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 373. Error: Elixhauser, lymph, C81-85 (@test-elixhauser-icd10.R#1061)  ──────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "C81"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:1061
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 374. Error: Elixhauser, lymph, C88 (@test-elixhauser-icd10.R#1079)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "C88"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:1079
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 375. Error: Elixhauser, lymph, C96 (@test-elixhauser-icd10.R#1085)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "C96"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:1085
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 376. Error: Elixhauser, lymph, C900 (@test-elixhauser-icd10.R#1091)  ────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "C900"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:1091
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 377. Error: Elixhauser, lymph, C902 (@test-elixhauser-icd10.R#1097)  ────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "C902"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:1097
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 378. Error: Elixhauser, metacanc, C77-80 (@test-elixhauser-icd10.R#1103)  ───
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "C77"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:1103
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 379. Error: Elixhauser, solidtum, C00-26 (@test-elixhauser-icd10.R#1118)  ───
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "C00"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:1118
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 380. Error: Elixhauser, solidtum, C30-34 (@test-elixhauser-icd10.R#1202)  ───
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "C30"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:1202
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 381. Error: Elixhauser, solidtum, C37-41 (@test-elixhauser-icd10.R#1220)  ───
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "C37"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:1220
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 382. Error: Elixhauser, solidtum, C43 (@test-elixhauser-icd10.R#1238)  ──────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "C43"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:1238
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 383. Error: Elixhauser, solidtum, C45-58 (@test-elixhauser-icd10.R#1244)  ───
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "C45"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:1244
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 384. Error: Elixhauser, solidtum, C60-76 (@test-elixhauser-icd10.R#1289)  ───
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "C60"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:1289
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 385. Error: Elixhauser, solidtum, C97 (@test-elixhauser-icd10.R#1343)  ──────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "C97"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:1343
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 386. Error: Elixhauser, rheumd, L940 (@test-elixhauser-icd10.R#1349)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "L940"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:1349
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 387. Error: Elixhauser, rheumd, L941 (@test-elixhauser-icd10.R#1355)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "L941"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:1355
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 388. Error: Elixhauser, rheumd, L943 (@test-elixhauser-icd10.R#1361)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "L943"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:1361
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 389. Error: Elixhauser, rheumd, M05 (@test-elixhauser-icd10.R#1367)  ────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "M05"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:1367
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 390. Error: Elixhauser, rheumd, M06 (@test-elixhauser-icd10.R#1373)  ────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "M06"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:1373
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 391. Error: Elixhauser, rheumd, M08 (@test-elixhauser-icd10.R#1379)  ────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "M08"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:1379
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 392. Error: Elixhauser, rheumd, M120 (@test-elixhauser-icd10.R#1385)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "M120"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:1385
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 393. Error: Elixhauser, rheumd, M123 (@test-elixhauser-icd10.R#1391)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "M123"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:1391
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 394. Error: Elixhauser, rheumd, M30 (@test-elixhauser-icd10.R#1397)  ────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "M30"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:1397
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 395. Error: Elixhauser, rheumd, M310-313 (@test-elixhauser-icd10.R#1403)  ───
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "M310"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:1403
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 396. Error: Elixhauser, rheumd, M32-35 (@test-elixhauser-icd10.R#1418)  ─────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "M32"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:1418
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 397. Error: Elixhauser, rheumd, M45 (@test-elixhauser-icd10.R#1433)  ────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "M45"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:1433
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 398. Error: Elixhauser, rheumd, M461 (@test-elixhauser-icd10.R#1439)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "M461"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:1439
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 399. Error: Elixhauser, rheumd, M468 (@test-elixhauser-icd10.R#1445)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "M468"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:1445
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 400. Error: Elixhauser, rheumd, M469 (@test-elixhauser-icd10.R#1451)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "M469"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:1451
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 401. Error: Elixhauser, coag, D65-68 (@test-elixhauser-icd10.R#1457)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "D65"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:1457
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 402. Error: Elixhauser, coag, D691 (@test-elixhauser-icd10.R#1472)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "D691"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:1472
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 403. Error: Elixhauser, coag, D693-696 (@test-elixhauser-icd10.R#1478)  ─────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "D693"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:1478
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 404. Error: Elixhauser, obes, E66 (@test-elixhauser-icd10.R#1493)  ──────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "E66"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:1493
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 405. Error: Elixhauser, wloss, E40-46 (@test-elixhauser-icd10.R#1499)  ──────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "E40"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:1499
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 406. Error: Elixhauser, wloss, R634 (@test-elixhauser-icd10.R#1523)  ────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "R634"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:1523
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 407. Error: Elixhauser, fed, E222 (@test-elixhauser-icd10.R#1529)  ──────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "E222"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:1529
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 408. Error: Elixhauser, fed, E86 (@test-elixhauser-icd10.R#1535)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "E86"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:1535
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 409. Error: Elixhauser, fed, E87 (@test-elixhauser-icd10.R#1541)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "E87"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:1541
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 410. Error: Elixhauser, blane, D500 (@test-elixhauser-icd10.R#1547)  ────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "D500"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:1547
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 411. Error: Elixhauser, dane, D508 (@test-elixhauser-icd10.R#1553)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "D508"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:1553
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 412. Error: Elixhauser, dane, D509 (@test-elixhauser-icd10.R#1559)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "D509"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:1559
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 413. Error: Elixhauser, dane, D51-53 (@test-elixhauser-icd10.R#1565)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "D51"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:1565
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 414. Error: Elixhauser, alcohol, F10 (@test-elixhauser-icd10.R#1577)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "F10"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:1577
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 415. Error: Elixhauser, alcohol, E52 (@test-elixhauser-icd10.R#1583)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "E52"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:1583
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 416. Error: Elixhauser, alcohol, G621 (@test-elixhauser-icd10.R#1589)  ──────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "G621"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:1589
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 417. Error: Elixhauser, alcohol, I426 (@test-elixhauser-icd10.R#1595)  ──────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "I426"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:1595
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 418. Error: Elixhauser, alcohol, K292 (@test-elixhauser-icd10.R#1602)  ──────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "K292"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:1602
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 419. Error: Elixhauser, alcohol, K700 (@test-elixhauser-icd10.R#1608)  ──────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "K700"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:1608
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 420. Error: Elixhauser, alcohol, K703 (@test-elixhauser-icd10.R#1615)  ──────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "K703"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:1615
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 421. Error: Elixhauser, alcohol, K709 (@test-elixhauser-icd10.R#1622)  ──────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "K709"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:1622
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 422. Error: Elixhauser, alcohol, T51 (@test-elixhauser-icd10.R#1629)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "T51"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:1629
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 423. Error: Elixhauser, alcohol, Z502 (@test-elixhauser-icd10.R#1635)  ──────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "Z502"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:1635
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 424. Error: Elixhauser, alcohol, Z714 (@test-elixhauser-icd10.R#1641)  ──────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "Z714"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:1641
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 425. Error: Elixhauser, alcohol, Z721 (@test-elixhauser-icd10.R#1647)  ──────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "Z721"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:1647
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 426. Error: Elixhauser, drug, F11-16 (@test-elixhauser-icd10.R#1653)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "F11"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:1653
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 427. Error: Elixhauser, drug, F18 (@test-elixhauser-icd10.R#1674)  ──────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "F18"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:1674
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 428. Error: Elixhauser, drug, F19 (@test-elixhauser-icd10.R#1680)  ──────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "F19"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:1680
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 429. Error: Elixhauser, drug, Z715 (@test-elixhauser-icd10.R#1686)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "Z715"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:1686
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 430. Error: Elixhauser, drug, Z722 (@test-elixhauser-icd10.R#1692)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "Z722"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:1692
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 431. Error: Elixhauser, psycho, F20 (@test-elixhauser-icd10.R#1698)  ────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "F20"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:1698
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 432. Error: Elixhauser, psycho, F22-25 (@test-elixhauser-icd10.R#1704)  ─────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "F22"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:1704
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 433. Error: Elixhauser, psycho, F28 (@test-elixhauser-icd10.R#1719)  ────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "F28"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:1719
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 434. Error: Elixhauser, psycho, F29 (@test-elixhauser-icd10.R#1725)  ────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "F29"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:1725
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 435. Error: Elixhauser, psycho, F302 (@test-elixhauser-icd10.R#1731)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "F302"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:1731
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 436. Error: Elixhauser, psycho, F312 (@test-elixhauser-icd10.R#1737)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "F312"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:1737
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 437. Error: Elixhauser, psycho, F315 (@test-elixhauser-icd10.R#1743)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "F315"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:1743
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 438. Error: Elixhauser, depre, F204 (@test-elixhauser-icd10.R#1750)  ────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "F204"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:1750
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 439. Error: Elixhauser, depre, F313-315 (@test-elixhauser-icd10.R#1757)  ────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "F313"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:1757
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 440. Error: Elixhauser, depre, F32 (@test-elixhauser-icd10.R#1770)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "F32"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:1770
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 441. Error: Elixhauser, depre, F33 (@test-elixhauser-icd10.R#1776)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "F33"), id = "id", code = "code", score = "elixhauser") at testthat/test-elixhauser-icd10.R:1776
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 442. Error: Elixhauser, depre, F341 (@test-elixhauser-icd10.R#1782)  ────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "F341"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:1782
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 443. Error: Elixhauser, depre, F412 (@test-elixhauser-icd10.R#1788)  ────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "F412"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:1788
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 444. Error: Elixhauser, depre, F432 (@test-elixhauser-icd10.R#1794)  ────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "F432"), id = "id", code = "code", 
         score = "elixhauser") at testthat/test-elixhauser-icd10.R:1794
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 445. Error: Elixhauser, chf, 39891 (@test-elixhauser-icd9.R#4)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "39891"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:4
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 446. Error: Elixhauser, chf, 40201 (@test-elixhauser-icd9.R#9)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "40201"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:9
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 447. Error: Elixhauser, chf, 40211 (@test-elixhauser-icd9.R#14)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "40211"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:14
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 448. Error: Elixhauser, chf, 40291 (@test-elixhauser-icd9.R#19)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "40291"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:19
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 449. Error: Elixhauser, chf, 40401 (@test-elixhauser-icd9.R#24)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "40401"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:24
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 450. Error: Elixhauser, chf, 40403 (@test-elixhauser-icd9.R#29)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "40403"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:29
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 451. Error: Elixhauser, chf, 40411 (@test-elixhauser-icd9.R#34)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "40411"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:34
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 452. Error: Elixhauser, chf, 40413 (@test-elixhauser-icd9.R#39)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "40413"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:39
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 453. Error: Elixhauser, chf, 40491 (@test-elixhauser-icd9.R#44)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "40491"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:44
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 454. Error: Elixhauser, chf, 40493 (@test-elixhauser-icd9.R#49)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "40493"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:49
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 455. Error: Elixhauser, chf, 4254-4259 (@test-elixhauser-icd9.R#54)  ────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "4254"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:54
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 456. Error: Elixhauser, chf, 428 (@test-elixhauser-icd9.R#75)  ──────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "428"), id = "id", code = "code", score = "elixhauser", 
         icd = "icd9") at testthat/test-elixhauser-icd9.R:75
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 457. Error: Elixhauser, carit, 4260 (@test-elixhauser-icd9.R#81)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "4260"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:81
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 458. Error: Elixhauser, carit, 42613 (@test-elixhauser-icd9.R#86)  ──────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "42613"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:86
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 459. Error: Elixhauser, carit, 4267 (@test-elixhauser-icd9.R#91)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "4267"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:91
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 460. Error: Elixhauser, carit, 4269 (@test-elixhauser-icd9.R#96)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "4269"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:96
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 461. Error: Elixhauser, carit, 42610 (@test-elixhauser-icd9.R#101)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "42610"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:101
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 462. Error: Elixhauser, carit, 42612 (@test-elixhauser-icd9.R#106)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "42612"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:106
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 463. Error: Elixhauser, carit, 4270-4274 (@test-elixhauser-icd9.R#111)  ─────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "4270"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:111
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 464. Error: Elixhauser, carit, 4276-4279 (@test-elixhauser-icd9.R#128)  ─────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "4276"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:128
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 465. Error: Elixhauser, carit, 7850 (@test-elixhauser-icd9.R#142)  ──────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "7850"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:142
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 466. Error: Elixhauser, carit, 99601 (@test-elixhauser-icd9.R#147)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "99601"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:147
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 467. Error: Elixhauser, carit, 99604 (@test-elixhauser-icd9.R#152)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "99604"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:152
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 468. Error: Elixhauser, carit, V450 (@test-elixhauser-icd9.R#157)  ──────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "V450"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:157
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 469. Error: Elixhauser, carit, V533 (@test-elixhauser-icd9.R#162)  ──────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "V533"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:162
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 470. Error: Elixhauser, valv, 0932 (@test-elixhauser-icd9.R#168)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "0932"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:168
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 471. Error: Elixhauser, valv, 394-397 (@test-elixhauser-icd9.R#173)  ────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "394"), id = "id", code = "code", score = "elixhauser", 
         icd = "icd9") at testthat/test-elixhauser-icd9.R:173
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 472. Error: Elixhauser, valv, 424 (@test-elixhauser-icd9.R#187)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "424"), id = "id", code = "code", score = "elixhauser", 
         icd = "icd9") at testthat/test-elixhauser-icd9.R:187
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 473. Error: Elixhauser, valv, 7463-7466 (@test-elixhauser-icd9.R#192)  ──────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "7463"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:192
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 474. Error: Elixhauser, valv, V422 (@test-elixhauser-icd9.R#206)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "V422"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:206
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 475. Error: Elixhauser, valv, V433 (@test-elixhauser-icd9.R#211)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "V433"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:211
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 476. Error: Elixhauser, pcd, 4150 (@test-elixhauser-icd9.R#217)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "4150"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:217
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 477. Error: Elixhauser, pcd, 4151 (@test-elixhauser-icd9.R#222)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "4151"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:222
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 478. Error: Elixhauser, pcd, 416 (@test-elixhauser-icd9.R#227)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "416"), id = "id", code = "code", score = "elixhauser", 
         icd = "icd9") at testthat/test-elixhauser-icd9.R:227
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 479. Error: Elixhauser, pcd, 4170 (@test-elixhauser-icd9.R#232)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "4170"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:232
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 480. Error: Elixhauser, pcd, 4178 (@test-elixhauser-icd9.R#237)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "4178"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:237
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 481. Error: Elixhauser, pcd, 4179 (@test-elixhauser-icd9.R#242)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "4179"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:242
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 482. Error: Elixhauser, pvd, 0930 (@test-elixhauser-icd9.R#248)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "0930"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:248
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 483. Error: Elixhauser, pvd, 4373 (@test-elixhauser-icd9.R#253)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "4373"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:253
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 484. Error: Elixhauser, pvd, 440 (@test-elixhauser-icd9.R#258)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "440"), id = "id", code = "code", score = "elixhauser", 
         icd = "icd9") at testthat/test-elixhauser-icd9.R:258
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 485. Error: Elixhauser, pvd, 441 (@test-elixhauser-icd9.R#263)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "441"), id = "id", code = "code", score = "elixhauser", 
         icd = "icd9") at testthat/test-elixhauser-icd9.R:263
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 486. Error: Elixhauser, pvd, 4431-4439 (@test-elixhauser-icd9.R#268)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "4431"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:268
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 487. Error: Elixhauser, pvd, 4471 (@test-elixhauser-icd9.R#297)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "4471"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:297
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 488. Error: Elixhauser, pvd, 5571 (@test-elixhauser-icd9.R#302)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "5571"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:302
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 489. Error: Elixhauser, pvd, 5579 (@test-elixhauser-icd9.R#307)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "5579"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:307
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 490. Error: Elixhauser, pvd, V434 (@test-elixhauser-icd9.R#312)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "V434"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:312
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 491. Error: Elixhauser, hypunc, 401 (@test-elixhauser-icd9.R#318)  ──────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "401"), id = "id", code = "code", score = "elixhauser", 
         icd = "icd9") at testthat/test-elixhauser-icd9.R:318
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 492. Error: Elixhauser, hypc, 402-405 (@test-elixhauser-icd9.R#324)  ────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "402"), id = "id", code = "code", score = "elixhauser", 
         icd = "icd9") at testthat/test-elixhauser-icd9.R:324
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 493. Error: Elixhauser, para, 3341 (@test-elixhauser-icd9.R#339)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "3341"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:339
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 494. Error: Elixhauser, para, 342 (@test-elixhauser-icd9.R#344)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "342"), id = "id", code = "code", score = "elixhauser", 
         icd = "icd9") at testthat/test-elixhauser-icd9.R:344
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 495. Error: Elixhauser, para, 343 (@test-elixhauser-icd9.R#349)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "343"), id = "id", code = "code", score = "elixhauser", 
         icd = "icd9") at testthat/test-elixhauser-icd9.R:349
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 496. Error: Elixhauser, para, 3440-3446 (@test-elixhauser-icd9.R#355)  ──────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "3440"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:355
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 497. Error: Elixhauser, para, 3449 (@test-elixhauser-icd9.R#378)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "3449"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:378
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 498. Error: Elixhauser, ond, 3319 (@test-elixhauser-icd9.R#385)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "3319"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:385
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 499. Error: Elixhauser, ond, 3320 (@test-elixhauser-icd9.R#390)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "3320"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:390
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 500. Error: Elixhauser, ond, 3321 (@test-elixhauser-icd9.R#395)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "3321"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:395
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 501. Error: Elixhauser, ond, 3334 (@test-elixhauser-icd9.R#400)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "3334"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:400
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 502. Error: Elixhauser, ond, 3335 (@test-elixhauser-icd9.R#405)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "3335"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:405
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 503. Error: Elixhauser, ond, 33392 (@test-elixhauser-icd9.R#410)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "33392"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:410
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 504. Error: Elixhauser, ond, 334-335 (@test-elixhauser-icd9.R#415)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "334"), id = "id", code = "code", score = "elixhauser", 
         icd = "icd9") at testthat/test-elixhauser-icd9.R:415
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 505. Error: Elixhauser, ond, 3362 (@test-elixhauser-icd9.R#423)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "3362"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:423
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 506. Error: Elixhauser, ond, 340 (@test-elixhauser-icd9.R#428)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "340"), id = "id", code = "code", score = "elixhauser", 
         icd = "icd9") at testthat/test-elixhauser-icd9.R:428
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 507. Error: Elixhauser, ond, 341 (@test-elixhauser-icd9.R#433)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "341"), id = "id", code = "code", score = "elixhauser", 
         icd = "icd9") at testthat/test-elixhauser-icd9.R:433
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 508. Error: Elixhauser, ond, 345 (@test-elixhauser-icd9.R#438)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "345"), id = "id", code = "code", score = "elixhauser", 
         icd = "icd9") at testthat/test-elixhauser-icd9.R:438
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 509. Error: Elixhauser, ond, 3481 (@test-elixhauser-icd9.R#443)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "3481"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:443
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 510. Error: Elixhauser, ond, 3483 (@test-elixhauser-icd9.R#448)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "3483"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:448
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 511. Error: Elixhauser, ond, 7803 (@test-elixhauser-icd9.R#453)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "7803"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:453
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 512. Error: Elixhauser, ond, 7843 (@test-elixhauser-icd9.R#458)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "7843"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:458
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 513. Error: Elixhauser, cpd, 4168 (@test-elixhauser-icd9.R#464)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "4168"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:464
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 514. Error: Elixhauser, cpd, 4169 (@test-elixhauser-icd9.R#469)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "4169"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:469
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 515. Error: Elixhauser, cpd, 490-505 (@test-elixhauser-icd9.R#474)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "490"), id = "id", code = "code", score = "elixhauser", 
         icd = "icd9") at testthat/test-elixhauser-icd9.R:474
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 516. Error: Elixhauser, cpd, 5064 (@test-elixhauser-icd9.R#524)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "5064"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:524
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 517. Error: Elixhauser, cpd, 5081 (@test-elixhauser-icd9.R#529)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "5081"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:529
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 518. Error: Elixhauser, cpd, 5088 (@test-elixhauser-icd9.R#534)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "5088"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:534
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 519. Error: Elixhauser, diabunc, 2500-2503 (@test-elixhauser-icd9.R#541)  ───
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "2500"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:541
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 520. Error: Elixhauser, diabc, 2504-2509 (@test-elixhauser-icd9.R#556)  ─────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "2504"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:556
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 521. Error: Elixhauser, hypothy, 2409 (@test-elixhauser-icd9.R#577)  ────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "2409"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:577
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 522. Error: Elixhauser, hypothy, 243 (@test-elixhauser-icd9.R#582)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "243"), id = "id", code = "code", score = "elixhauser", 
         icd = "icd9") at testthat/test-elixhauser-icd9.R:582
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 523. Error: Elixhauser, hypothy, 244 (@test-elixhauser-icd9.R#587)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "244"), id = "id", code = "code", score = "elixhauser", 
         icd = "icd9") at testthat/test-elixhauser-icd9.R:587
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 524. Error: Elixhauser, hypothy, 2461 (@test-elixhauser-icd9.R#592)  ────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "2461"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:592
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 525. Error: Elixhauser, hypothy, 2468 (@test-elixhauser-icd9.R#597)  ────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "2468"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:597
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 526. Error: Elixhauser, rf, 40301 (@test-elixhauser-icd9.R#603)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "40301"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:603
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 527. Error: Elixhauser, rf, 40311 (@test-elixhauser-icd9.R#608)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "40311"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:608
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 528. Error: Elixhauser, rf, 40391 (@test-elixhauser-icd9.R#613)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "40391"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:613
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 529. Error: Elixhauser, rf, 40402 (@test-elixhauser-icd9.R#618)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "40402"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:618
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 530. Error: Elixhauser, rf, 40402 (@test-elixhauser-icd9.R#623)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "40402"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:623
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 531. Error: Elixhauser, rf, 40403 (@test-elixhauser-icd9.R#628)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "40403"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:628
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 532. Error: Elixhauser, rf, 40412 (@test-elixhauser-icd9.R#633)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "40412"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:633
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 533. Error: Elixhauser, rf, 40413 (@test-elixhauser-icd9.R#638)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "40413"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:638
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 534. Error: Elixhauser, rf, 40492 (@test-elixhauser-icd9.R#643)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "40492"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:643
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 535. Error: Elixhauser, rf, 40493 (@test-elixhauser-icd9.R#648)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "40493"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:648
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 536. Error: Elixhauser, rf, 585 (@test-elixhauser-icd9.R#653)  ──────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "585"), id = "id", code = "code", score = "elixhauser", 
         icd = "icd9") at testthat/test-elixhauser-icd9.R:653
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 537. Error: Elixhauser, rf, 586 (@test-elixhauser-icd9.R#658)  ──────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "586"), id = "id", code = "code", score = "elixhauser", 
         icd = "icd9") at testthat/test-elixhauser-icd9.R:658
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 538. Error: Elixhauser, rf, 5880 (@test-elixhauser-icd9.R#663)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "5880"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:663
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 539. Error: Elixhauser, rf, V420 (@test-elixhauser-icd9.R#668)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "V420"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:668
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 540. Error: Elixhauser, rf, V451 (@test-elixhauser-icd9.R#673)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "V451"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:673
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 541. Error: Elixhauser, rf, V56 (@test-elixhauser-icd9.R#678)  ──────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "V56"), id = "id", code = "code", score = "elixhauser", 
         icd = "icd9") at testthat/test-elixhauser-icd9.R:678
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 542. Error: Elixhauser, ld, 07022 (@test-elixhauser-icd9.R#684)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "07022"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:684
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 543. Error: Elixhauser, ld, 07023 (@test-elixhauser-icd9.R#689)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "07023"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:689
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 544. Error: Elixhauser, ld, 07032 (@test-elixhauser-icd9.R#694)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "07032"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:694
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 545. Error: Elixhauser, ld, 07033 (@test-elixhauser-icd9.R#699)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "07033"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:699
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 546. Error: Elixhauser, ld, 07044 (@test-elixhauser-icd9.R#704)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "07044"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:704
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 547. Error: Elixhauser, ld, 07054 (@test-elixhauser-icd9.R#709)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "07054"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:709
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 548. Error: Elixhauser, ld, 0706 (@test-elixhauser-icd9.R#714)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "0706"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:714
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 549. Error: Elixhauser, ld, 0709 (@test-elixhauser-icd9.R#719)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "0709"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:719
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 550. Error: Elixhauser, ld, 4560-4562 (@test-elixhauser-icd9.R#724)  ────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "4560"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:724
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 551. Error: Elixhauser, ld, 570 (@test-elixhauser-icd9.R#735)  ──────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "570"), id = "id", code = "code", score = "elixhauser", 
         icd = "icd9") at testthat/test-elixhauser-icd9.R:735
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 552. Error: Elixhauser, ld, 571 (@test-elixhauser-icd9.R#740)  ──────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "571"), id = "id", code = "code", score = "elixhauser", 
         icd = "icd9") at testthat/test-elixhauser-icd9.R:740
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 553. Error: Elixhauser, ld, 5722-5728 (@test-elixhauser-icd9.R#745)  ────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "5722"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:745
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 554. Error: Elixhauser, ld, 5733 (@test-elixhauser-icd9.R#768)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "5733"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:768
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 555. Error: Elixhauser, ld, 5734 (@test-elixhauser-icd9.R#773)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "5734"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:773
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 556. Error: Elixhauser, ld, 5738 (@test-elixhauser-icd9.R#778)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "5738"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:778
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 557. Error: Elixhauser, ld, 5739 (@test-elixhauser-icd9.R#783)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "5739"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:783
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 558. Error: Elixhauser, ld, V427 (@test-elixhauser-icd9.R#788)  ─────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "V427"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:788
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 559. Error: Elixhauser, pud, 5317 (@test-elixhauser-icd9.R#794)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "5317"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:794
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 560. Error: Elixhauser, pud, 5319 (@test-elixhauser-icd9.R#799)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "5319"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:799
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 561. Error: Elixhauser, pud, 5327 (@test-elixhauser-icd9.R#804)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "5327"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:804
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 562. Error: Elixhauser, pud, 5329 (@test-elixhauser-icd9.R#809)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "5329"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:809
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 563. Error: Elixhauser, pud, 5337 (@test-elixhauser-icd9.R#814)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "5337"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:814
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 564. Error: Elixhauser, pud, 5339 (@test-elixhauser-icd9.R#819)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "5339"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:819
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 565. Error: Elixhauser, pud, 5347 (@test-elixhauser-icd9.R#824)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "5347"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:824
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 566. Error: Elixhauser, pud, 5349 (@test-elixhauser-icd9.R#829)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "5349"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:829
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 567. Error: Elixhauser, aids, 042-044 (@test-elixhauser-icd9.R#835)  ────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "042"), id = "id", code = "code", score = "elixhauser", 
         icd = "icd9") at testthat/test-elixhauser-icd9.R:835
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 568. Error: Elixhauser, lymph, 200-202 (@test-elixhauser-icd9.R#847)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "200"), id = "id", code = "code", score = "elixhauser", 
         icd = "icd9") at testthat/test-elixhauser-icd9.R:847
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 569. Error: Elixhauser, lymph, 2030 (@test-elixhauser-icd9.R#858)  ──────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "2030"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:858
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 570. Error: Elixhauser, lymph, 2386 (@test-elixhauser-icd9.R#863)  ──────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "2386"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:863
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 571. Error: Elixhauser, metacanc, 196-199 (@test-elixhauser-icd9.R#869)  ────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "196"), id = "id", code = "code", score = "elixhauser", 
         icd = "icd9") at testthat/test-elixhauser-icd9.R:869
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 572. Error: Elixhauser, solidtum, 140-172 (@test-elixhauser-icd9.R#884)  ────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "140"), id = "id", code = "code", score = "elixhauser", 
         icd = "icd9") at testthat/test-elixhauser-icd9.R:884
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 573. Error: Elixhauser, solidtum, 174 (@test-elixhauser-icd9.R#985)  ────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "174"), id = "id", code = "code", score = "elixhauser", 
         icd = "icd9") at testthat/test-elixhauser-icd9.R:985
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 574. Error: Elixhauser, solidtum, 195 (@test-elixhauser-icd9.R#990)  ────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "195"), id = "id", code = "code", score = "elixhauser", 
         icd = "icd9") at testthat/test-elixhauser-icd9.R:990
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 575. Error: Elixhauser, rheumd, 446 (@test-elixhauser-icd9.R#996)  ──────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "446"), id = "id", code = "code", score = "elixhauser", 
         icd = "icd9") at testthat/test-elixhauser-icd9.R:996
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 576. Error: Elixhauser, rheumd, 7010 (@test-elixhauser-icd9.R#1001)  ────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "7010"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:1001
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 577. Error: Elixhauser, rheumd, 7100-7104 (@test-elixhauser-icd9.R#1006)  ───
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "7100"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:1006
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 578. Error: Elixhauser, rheumd, 7108 (@test-elixhauser-icd9.R#1023)  ────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "7108"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:1023
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 579. Error: Elixhauser, rheumd, 7109 (@test-elixhauser-icd9.R#1028)  ────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "7109"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:1028
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 580. Error: Elixhauser, rheumd, 7112 (@test-elixhauser-icd9.R#1033)  ────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "7112"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:1033
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 581. Error: Elixhauser, rheumd, 714 (@test-elixhauser-icd9.R#1038)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "714"), id = "id", code = "code", score = "elixhauser", 
         icd = "icd9") at testthat/test-elixhauser-icd9.R:1038
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 582. Error: Elixhauser, rheumd, 7193 (@test-elixhauser-icd9.R#1043)  ────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "7193"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:1043
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 583. Error: Elixhauser, rheumd, 720 (@test-elixhauser-icd9.R#1048)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "720"), id = "id", code = "code", score = "elixhauser", 
         icd = "icd9") at testthat/test-elixhauser-icd9.R:1048
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 584. Error: Elixhauser, rheumd, 725 (@test-elixhauser-icd9.R#1053)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "725"), id = "id", code = "code", score = "elixhauser", 
         icd = "icd9") at testthat/test-elixhauser-icd9.R:1053
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 585. Error: Elixhauser, rheumd, 7285 (@test-elixhauser-icd9.R#1058)  ────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "7285"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:1058
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 586. Error: Elixhauser, rheumd, 72889 (@test-elixhauser-icd9.R#1063)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "72889"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:1063
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 587. Error: Elixhauser, rheumd, 72930 (@test-elixhauser-icd9.R#1068)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "72930"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:1068
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 588. Error: Elixhauser, coag, 286 (@test-elixhauser-icd9.R#1074)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "286"), id = "id", code = "code", score = "elixhauser", 
         icd = "icd9") at testthat/test-elixhauser-icd9.R:1074
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 589. Error: Elixhauser, coag, 2871 (@test-elixhauser-icd9.R#1079)  ──────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "2871"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:1079
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 590. Error: Elixhauser, coag, 2873-2875 (@test-elixhauser-icd9.R#1084)  ─────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "2873"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:1084
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 591. Error: Elixhauser, obes, 2780 (@test-elixhauser-icd9.R#1096)  ──────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "2780"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:1096
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 592. Error: Elixhauser, wloss, 260-263 (@test-elixhauser-icd9.R#1102)  ──────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "260"), id = "id", code = "code", score = "elixhauser", 
         icd = "icd9") at testthat/test-elixhauser-icd9.R:1102
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 593. Error: Elixhauser, wloss, 7832 (@test-elixhauser-icd9.R#1116)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "7832"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:1116
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 594. Error: Elixhauser, wloss, 7994 (@test-elixhauser-icd9.R#1121)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "7994"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:1121
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 595. Error: Elixhauser, fed, 2536 (@test-elixhauser-icd9.R#1127)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "2536"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:1127
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 596. Error: Elixhauser, fed, 276 (@test-elixhauser-icd9.R#1132)  ────────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "276"), id = "id", code = "code", score = "elixhauser", 
         icd = "icd9") at testthat/test-elixhauser-icd9.R:1132
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 597. Error: Elixhauser, blane, 2800 (@test-elixhauser-icd9.R#1138)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "2800"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:1138
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 598. Error: Elixhauser, dane, 2801-2809 (@test-elixhauser-icd9.R#1144)  ─────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "2801"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:1144
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 599. Error: Elixhauser, dane, 281 (@test-elixhauser-icd9.R#1173)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "281"), id = "id", code = "code", score = "elixhauser", 
         icd = "icd9") at testthat/test-elixhauser-icd9.R:1173
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 600. Error: Elixhauser, alcohol, 2652 (@test-elixhauser-icd9.R#1179)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "2652"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:1179
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 601. Error: Elixhauser, alcohol, 2911-2913 (@test-elixhauser-icd9.R#1184)  ──
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "2911"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:1184
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 602. Error: Elixhauser, alcohol, 2915-2919 (@test-elixhauser-icd9.R#1195)  ──
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "2915"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:1195
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 603. Error: Elixhauser, alcohol, 3030 (@test-elixhauser-icd9.R#1212)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "3030"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:1212
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 604. Error: Elixhauser, alcohol, 3039 (@test-elixhauser-icd9.R#1217)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "3039"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:1217
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 605. Error: Elixhauser, alcohol, 3050 (@test-elixhauser-icd9.R#1222)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "3050"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:1222
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 606. Error: Elixhauser, alcohol, 3575 (@test-elixhauser-icd9.R#1227)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "3575"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:1227
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 607. Error: Elixhauser, alcohol, 4255 (@test-elixhauser-icd9.R#1232)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "4255"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:1232
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 608. Error: Elixhauser, alcohol, 5353 (@test-elixhauser-icd9.R#1237)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "5353"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:1237
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 609. Error: Elixhauser, alcohol, 5710-5713 (@test-elixhauser-icd9.R#1242)  ──
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "5710"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:1242
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 610. Error: Elixhauser, alcohol, 980 (@test-elixhauser-icd9.R#1256)  ────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "980"), id = "id", code = "code", score = "elixhauser", 
         icd = "icd9") at testthat/test-elixhauser-icd9.R:1256
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 611. Error: Elixhauser, alcohol, V113 (@test-elixhauser-icd9.R#1261)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "V113"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:1261
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 612. Error: Elixhauser, drug, 292 (@test-elixhauser-icd9.R#1267)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "292"), id = "id", code = "code", score = "elixhauser", 
         icd = "icd9") at testthat/test-elixhauser-icd9.R:1267
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 613. Error: Elixhauser, drug, 304 (@test-elixhauser-icd9.R#1272)  ───────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "304"), id = "id", code = "code", score = "elixhauser", 
         icd = "icd9") at testthat/test-elixhauser-icd9.R:1272
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 614. Error: Elixhauser, drug, 3052-3059 (@test-elixhauser-icd9.R#1277)  ─────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "3052"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:1277
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 615. Error: Elixhauser, drug, V6542 (@test-elixhauser-icd9.R#1303)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "V6542"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:1303
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 616. Error: Elixhauser, psycho, 2938 (@test-elixhauser-icd9.R#1309)  ────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "2938"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:1309
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 617. Error: Elixhauser, psycho, 295 (@test-elixhauser-icd9.R#1314)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "295"), id = "id", code = "code", score = "elixhauser", 
         icd = "icd9") at testthat/test-elixhauser-icd9.R:1314
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 618. Error: Elixhauser, psycho, 29604 (@test-elixhauser-icd9.R#1319)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "29604"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:1319
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 619. Error: Elixhauser, psycho, 29614 (@test-elixhauser-icd9.R#1324)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "29614"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:1324
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 620. Error: Elixhauser, psycho, 29644 (@test-elixhauser-icd9.R#1329)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "29644"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:1329
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 621. Error: Elixhauser, psycho, 29654 (@test-elixhauser-icd9.R#1334)  ───────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "29654"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:1334
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 622. Error: Elixhauser, psycho, 297 (@test-elixhauser-icd9.R#1339)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "297"), id = "id", code = "code", score = "elixhauser", 
         icd = "icd9") at testthat/test-elixhauser-icd9.R:1339
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 623. Error: Elixhauser, psycho, 298 (@test-elixhauser-icd9.R#1344)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "298"), id = "id", code = "code", score = "elixhauser", 
         icd = "icd9") at testthat/test-elixhauser-icd9.R:1344
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 624. Error: Elixhauser, depre, 2962 (@test-elixhauser-icd9.R#1350)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "2962"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:1350
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 625. Error: Elixhauser, depre, 2963 (@test-elixhauser-icd9.R#1355)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "2963"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:1355
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 626. Error: Elixhauser, depre, 2965 (@test-elixhauser-icd9.R#1360)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "2965"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:1360
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 627. Error: Elixhauser, depre, 3004 (@test-elixhauser-icd9.R#1365)  ─────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "3004"), id = "id", code = "code", 
         score = "elixhauser", icd = "icd9") at testthat/test-elixhauser-icd9.R:1365
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 628. Error: Elixhauser, depre, 309 (@test-elixhauser-icd9.R#1370)  ──────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "309"), id = "id", code = "code", score = "elixhauser", 
         icd = "icd9") at testthat/test-elixhauser-icd9.R:1370
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 629. Error: Elixhauser, depre, 311 (@test-elixhauser-icd9.R#1375)  ──────────
  LOGICAL() can only be applied to a 'logical', not a 'builtin'
  1: comorbidity(x = data.frame(id = "ID1", code = "311"), id = "id", code = "code", score = "elixhauser", 
         icd = "icd9") at testthat/test-elixhauser-icd9.R:1375
  2: checkmate::assert_choice(score, choices = c("charlson", "elixhauser"), add = arg_checks)
  3: checkChoice(x, choices, null.ok, fmatch)
  4: qassert(null.ok, "B1")
  
  ── 630. Error: sample_diag returns a string vector (@test-sample_diag.R#40)  ───
  LOGICAL() can only be applied to a 'logical', not a 'raw'
  1: expect_type(sample_diag(), type = "character") at testthat/test-sample_diag.R:40
  2: quasi_label(enquo(object))
  3: eval_bare(get_expr(quo), get_env(quo))
  4: sample_diag()
  5: checkmate::assert_choice(version, choices = c("ICD10_2009", "ICD10_2011", "ICD9_2015"), 
         add = arg_checks)
  6: checkChoice(x, choices, null.ok, fmatch)
  7: qassert(null.ok, "B1")
  
  ── 631. Error: sample_diag returns a vector of appropriate length (@test-sample_
  LOGICAL() can only be applied to a 'logical', not a 'raw'
  1: expect_length(sample_diag(n = 1), n = 1) at testthat/test-sample_diag.R:47
  2: quasi_label(enquo(object))
  3: eval_bare(get_expr(quo), get_env(quo))
  4: sample_diag(n = 1)
  5: checkmate::assert_choice(version, choices = c("ICD10_2009", "ICD10_2011", "ICD9_2015"), 
         add = arg_checks)
  6: checkChoice(x, choices, null.ok, fmatch)
  7: qassert(null.ok, "B1")
  
  ── 632. Error: sample_diag works fine with either versions (@test-sample_diag.R#
  LOGICAL() can only be applied to a 'logical', not a 'raw'
  1: expect_type(sample_diag(version = "ICD10_2009"), type = "character") at testthat/test-sample_diag.R:70
  2: quasi_label(enquo(object))
  3: eval_bare(get_expr(quo), get_env(quo))
  4: sample_diag(version = "ICD10_2009")
  5: checkmate::assert_choice(version, choices = c("ICD10_2009", "ICD10_2011", "ICD9_2015"), 
         add = arg_checks)
  6: checkChoice(x, choices, null.ok, fmatch)
  7: qassert(null.ok, "B1")
  
  ══ testthat results  ═══════════════════════════════════════════════════════════
  OK: 17 SKIPPED: 0 FAILED: 632
  1. Error: Charlson, ami, I21 (@test-charlson-icd10.R#4) 
  2. Error: Charlson, ami, I22 (@test-charlson-icd10.R#10) 
  3. Error: Charlson, ami, I252 (@test-charlson-icd10.R#16) 
  4. Error: Charlson, chf, I099 (@test-charlson-icd10.R#22) 
  5. Error: Charlson, chf, I110 (@test-charlson-icd10.R#28) 
  6. Error: Charlson, chf, I130 (@test-charlson-icd10.R#34) 
  7. Error: Charlson, chf, I132 (@test-charlson-icd10.R#40) 
  8. Error: Charlson, chf, I255 (@test-charlson-icd10.R#46) 
  9. Error: Charlson, chf, I420 (@test-charlson-icd10.R#52) 
  1. ...
  
  Error: testthat unit tests failed
  Execution halted