Running 'test-all.R' [163s/143s]
Running the tests in 'tests/test-all.R' failed.
Complete output:
  > library(testthat)
  > test_check("rgbif")
  Loading required package: rgbif
  -- 1. Error: keyword query returns the correct (@test-dataset_search.r#18)  ----
  Reader error: control characters are not allowed: #80 at 3376
  1: vcr::use_cassette("dataset_search_keyword", {
         tt <- dataset_search(keyword = "france")
     }) at testthat/test-dataset_search.r:18
  2: insert_cassette(name, record = record, match_requests_on = match_requests_on, update_content_length_header = update_content_length_header, 
         allow_playback_repeats = allow_playback_repeats, serialize_with = serialize_with, 
         persist_with = persist_with, preserve_exact_body_bytes = preserve_exact_body_bytes)
  3: Cassette$new(name = name, record = record, match_requests_on = match_requests_on, 
         re_record_interval = NULL, tag = NULL, tags = NULL, update_content_length_header = update_content_length_header, 
         decode_compressed_response = NULL, allow_playback_repeats = allow_playback_repeats, 
         allow_unused_http_interactions = NULL, exclusive = NULL, serialize_with = serialize_with, 
         persist_with = persist_with, preserve_exact_body_bytes = preserve_exact_body_bytes)
  4: .subset2(public_bind_env, "initialize")(...)
  5: self$http_interactions()
  6: HTTPInteractionList$new(interactions = {
         if (self$should_stub_requests()) {
             self$previously_recorded_interactions()
         }
         else {
             list()
         }
     }, request_matchers = vcr_configuration()$match_requests_on)
  7: .subset2(public_bind_env, "initialize")(...)
  8: self$previously_recorded_interactions()
  9: compact(lapply(self$deserialized_hash()[["http_interactions"]], function(z) {
         response <- VcrResponse$new(z$response$status, z$response$headers, z$response$body$string, 
             self$cassette_opts)
         if (self$update_content_length_header) 
             response$update_content_length_header()
         zz <- HTTPInteraction$new(request = Request$new(z$request$method, z$request$uri, 
             z$request$body$string, z$request$headers), response = response)
         hash <- zz$to_hash()
         if (request_ignorer$should_be_ignored(hash$request)) 
             NULL
         else hash
     }))
  10: Filter(Negate(is.null), x)
  11: unlist(lapply(x, f))
  12: lapply(x, f)
  13: lapply(self$deserialized_hash()[["http_interactions"]], function(z) {
         response <- VcrResponse$new(z$response$status, z$response$headers, z$response$body$string, 
             self$cassette_opts)
         if (self$update_content_length_header) 
             response$update_content_length_header()
         zz <- HTTPInteraction$new(request = Request$new(z$request$method, z$request$uri, 
             z$request$body$string, z$request$headers), response = response)
         hash <- zz$to_hash()
         if (request_ignorer$should_be_ignored(hash$request)) 
             NULL
         else hash
     })
  14: self$deserialized_hash()
  15: self$serializer$deserialize_path()
  16: yaml::yaml.load(str)
  
  -- 2. Error: limited search returns the correct (@test-dataset_search.r#52)  ---
  Reader error: control characters are not allowed: #80 at 1677
  1: vcr::use_cassette("dataset_search_limit", {
         tt <- dataset_search(type = "OCCURRENCE", limit = 2)
     }) at testthat/test-dataset_search.r:52
  2: insert_cassette(name, record = record, match_requests_on = match_requests_on, update_content_length_header = update_content_length_header, 
         allow_playback_repeats = allow_playback_repeats, serialize_with = serialize_with, 
         persist_with = persist_with, preserve_exact_body_bytes = preserve_exact_body_bytes)
  3: Cassette$new(name = name, record = record, match_requests_on = match_requests_on, 
         re_record_interval = NULL, tag = NULL, tags = NULL, update_content_length_header = update_content_length_header, 
         decode_compressed_response = NULL, allow_playback_repeats = allow_playback_repeats, 
         allow_unused_http_interactions = NULL, exclusive = NULL, serialize_with = serialize_with, 
         persist_with = persist_with, preserve_exact_body_bytes = preserve_exact_body_bytes)
  4: .subset2(public_bind_env, "initialize")(...)
  5: self$http_interactions()
  6: HTTPInteractionList$new(interactions = {
         if (self$should_stub_requests()) {
             self$previously_recorded_interactions()
         }
         else {
             list()
         }
     }, request_matchers = vcr_configuration()$match_requests_on)
  7: .subset2(public_bind_env, "initialize")(...)
  8: self$previously_recorded_interactions()
  9: compact(lapply(self$deserialized_hash()[["http_interactions"]], function(z) {
         response <- VcrResponse$new(z$response$status, z$response$headers, z$response$body$string, 
             self$cassette_opts)
         if (self$update_content_length_header) 
             response$update_content_length_header()
         zz <- HTTPInteraction$new(request = Request$new(z$request$method, z$request$uri, 
             z$request$body$string, z$request$headers), response = response)
         hash <- zz$to_hash()
         if (request_ignorer$should_be_ignored(hash$request)) 
             NULL
         else hash
     }))
  10: Filter(Negate(is.null), x)
  11: unlist(lapply(x, f))
  12: lapply(x, f)
  13: lapply(self$deserialized_hash()[["http_interactions"]], function(z) {
         response <- VcrResponse$new(z$response$status, z$response$headers, z$response$body$string, 
             self$cassette_opts)
         if (self$update_content_length_header) 
             response$update_content_length_header()
         zz <- HTTPInteraction$new(request = Request$new(z$request$method, z$request$uri, 
             z$request$body$string, z$request$headers), response = response)
         hash <- zz$to_hash()
         if (request_ignorer$should_be_ignored(hash$request)) 
             NULL
         else hash
     })
  14: self$deserialized_hash()
  15: self$serializer$deserialize_path()
  16: yaml::yaml.load(str)
  
  -- 3. Error: type query returns the correct class (@test-dataset_suggest.r#4)  -
  Reader error: control characters are not allowed: #80 at 3939
  1: vcr::use_cassette("dataset_suggest", {
         tt <- dataset_suggest(query = "Amazon", type = "OCCURRENCE")
     }) at testthat/test-dataset_suggest.r:4
  2: insert_cassette(name, record = record, match_requests_on = match_requests_on, update_content_length_header = update_content_length_header, 
         allow_playback_repeats = allow_playback_repeats, serialize_with = serialize_with, 
         persist_with = persist_with, preserve_exact_body_bytes = preserve_exact_body_bytes)
  3: Cassette$new(name = name, record = record, match_requests_on = match_requests_on, 
         re_record_interval = NULL, tag = NULL, tags = NULL, update_content_length_header = update_content_length_header, 
         decode_compressed_response = NULL, allow_playback_repeats = allow_playback_repeats, 
         allow_unused_http_interactions = NULL, exclusive = NULL, serialize_with = serialize_with, 
         persist_with = persist_with, preserve_exact_body_bytes = preserve_exact_body_bytes)
  4: .subset2(public_bind_env, "initialize")(...)
  5: self$http_interactions()
  6: HTTPInteractionList$new(interactions = {
         if (self$should_stub_requests()) {
             self$previously_recorded_interactions()
         }
         else {
             list()
         }
     }, request_matchers = vcr_configuration()$match_requests_on)
  7: .subset2(public_bind_env, "initialize")(...)
  8: self$previously_recorded_interactions()
  9: compact(lapply(self$deserialized_hash()[["http_interactions"]], function(z) {
         response <- VcrResponse$new(z$response$status, z$response$headers, z$response$body$string, 
             self$cassette_opts)
         if (self$update_content_length_header) 
             response$update_content_length_header()
         zz <- HTTPInteraction$new(request = Request$new(z$request$method, z$request$uri, 
             z$request$body$string, z$request$headers), response = response)
         hash <- zz$to_hash()
         if (request_ignorer$should_be_ignored(hash$request)) 
             NULL
         else hash
     }))
  10: Filter(Negate(is.null), x)
  11: unlist(lapply(x, f))
  12: lapply(x, f)
  13: lapply(self$deserialized_hash()[["http_interactions"]], function(z) {
         response <- VcrResponse$new(z$response$status, z$response$headers, z$response$body$string, 
             self$cassette_opts)
         if (self$update_content_length_header) 
             response$update_content_length_header()
         zz <- HTTPInteraction$new(request = Request$new(z$request$method, z$request$uri, 
             z$request$body$string, z$request$headers), response = response)
         hash <- zz$to_hash()
         if (request_ignorer$should_be_ignored(hash$request)) 
             NULL
         else hash
     })
  14: self$deserialized_hash()
  15: self$serializer$deserialize_path()
  16: yaml::yaml.load(str)
  
  -- 4. Error: limited search returns the correct class (@test-dataset_suggest.r#3
  Reader error: control characters are not allowed: #80 at 1612
  1: vcr::use_cassette("dataset_suggest_limit", {
         tt <- dataset_suggest(type = "OCCURRENCE", limit = 2)
     }) at testthat/test-dataset_suggest.r:30
  2: insert_cassette(name, record = record, match_requests_on = match_requests_on, update_content_length_header = update_content_length_header, 
         allow_playback_repeats = allow_playback_repeats, serialize_with = serialize_with, 
         persist_with = persist_with, preserve_exact_body_bytes = preserve_exact_body_bytes)
  3: Cassette$new(name = name, record = record, match_requests_on = match_requests_on, 
         re_record_interval = NULL, tag = NULL, tags = NULL, update_content_length_header = update_content_length_header, 
         decode_compressed_response = NULL, allow_playback_repeats = allow_playback_repeats, 
         allow_unused_http_interactions = NULL, exclusive = NULL, serialize_with = serialize_with, 
         persist_with = persist_with, preserve_exact_body_bytes = preserve_exact_body_bytes)
  4: .subset2(public_bind_env, "initialize")(...)
  5: self$http_interactions()
  6: HTTPInteractionList$new(interactions = {
         if (self$should_stub_requests()) {
             self$previously_recorded_interactions()
         }
         else {
             list()
         }
     }, request_matchers = vcr_configuration()$match_requests_on)
  7: .subset2(public_bind_env, "initialize")(...)
  8: self$previously_recorded_interactions()
  9: compact(lapply(self$deserialized_hash()[["http_interactions"]], function(z) {
         response <- VcrResponse$new(z$response$status, z$response$headers, z$response$body$string, 
             self$cassette_opts)
         if (self$update_content_length_header) 
             response$update_content_length_header()
         zz <- HTTPInteraction$new(request = Request$new(z$request$method, z$request$uri, 
             z$request$body$string, z$request$headers), response = response)
         hash <- zz$to_hash()
         if (request_ignorer$should_be_ignored(hash$request)) 
             NULL
         else hash
     }))
  10: Filter(Negate(is.null), x)
  11: unlist(lapply(x, f))
  12: lapply(x, f)
  13: lapply(self$deserialized_hash()[["http_interactions"]], function(z) {
         response <- VcrResponse$new(z$response$status, z$response$headers, z$response$body$string, 
             self$cassette_opts)
         if (self$update_content_length_header) 
             response$update_content_length_header()
         zz <- HTTPInteraction$new(request = Request$new(z$request$method, z$request$uri, 
             z$request$body$string, z$request$headers), response = response)
         hash <- zz$to_hash()
         if (request_ignorer$should_be_ignored(hash$request)) 
             NULL
         else hash
     })
  14: self$deserialized_hash()
  15: self$serializer$deserialize_path()
  16: yaml::yaml.load(str)
  
  -- 5. Error: enumeration (@test-enumeration.r#4)  ------------------------------
  Reader error: control characters are not allowed: #94 at 13702
  1: vcr::use_cassette("enumeration", {
         a <- enumeration()
         b <- enumeration("NameType")
         c <- enumeration("MetadataType")
         d <- enumeration("TypeStatus")
         e <- enumeration_country()
     }) at testthat/test-enumeration.r:4
  2: insert_cassette(name, record = record, match_requests_on = match_requests_on, update_content_length_header = update_content_length_header, 
         allow_playback_repeats = allow_playback_repeats, serialize_with = serialize_with, 
         persist_with = persist_with, preserve_exact_body_bytes = preserve_exact_body_bytes)
  3: Cassette$new(name = name, record = record, match_requests_on = match_requests_on, 
         re_record_interval = NULL, tag = NULL, tags = NULL, update_content_length_header = update_content_length_header, 
         decode_compressed_response = NULL, allow_playback_repeats = allow_playback_repeats, 
         allow_unused_http_interactions = NULL, exclusive = NULL, serialize_with = serialize_with, 
         persist_with = persist_with, preserve_exact_body_bytes = preserve_exact_body_bytes)
  4: .subset2(public_bind_env, "initialize")(...)
  5: self$http_interactions()
  6: HTTPInteractionList$new(interactions = {
         if (self$should_stub_requests()) {
             self$previously_recorded_interactions()
         }
         else {
             list()
         }
     }, request_matchers = vcr_configuration()$match_requests_on)
  7: .subset2(public_bind_env, "initialize")(...)
  8: self$previously_recorded_interactions()
  9: compact(lapply(self$deserialized_hash()[["http_interactions"]], function(z) {
         response <- VcrResponse$new(z$response$status, z$response$headers, z$response$body$string, 
             self$cassette_opts)
         if (self$update_content_length_header) 
             response$update_content_length_header()
         zz <- HTTPInteraction$new(request = Request$new(z$request$method, z$request$uri, 
             z$request$body$string, z$request$headers), response = response)
         hash <- zz$to_hash()
         if (request_ignorer$should_be_ignored(hash$request)) 
             NULL
         else hash
     }))
  10: Filter(Negate(is.null), x)
  11: unlist(lapply(x, f))
  12: lapply(x, f)
  13: lapply(self$deserialized_hash()[["http_interactions"]], function(z) {
         response <- VcrResponse$new(z$response$status, z$response$headers, z$response$body$string, 
             self$cassette_opts)
         if (self$update_content_length_header) 
             response$update_content_length_header()
         zz <- HTTPInteraction$new(request = Request$new(z$request$method, z$request$uri, 
             z$request$body$string, z$request$headers), response = response)
         hash <- zz$to_hash()
         if (request_ignorer$should_be_ignored(hash$request)) 
             NULL
         else hash
     })
  14: self$deserialized_hash()
  15: self$serializer$deserialize_path()
  16: yaml::yaml.load(str)
  
  -- 6. Error: returns the correct class (@test-name_lookup.r#4)  ----------------
  Reader error: control characters are not allowed: #84 at 83063
  1: vcr::use_cassette("name_lookup", {
         tt <- name_lookup(query = "mammalia")
         uu <- name_lookup(query = "Cnaemidophorus", rank = "genus", return = "data")
     }) at testthat/test-name_lookup.r:4
  2: insert_cassette(name, record = record, match_requests_on = match_requests_on, update_content_length_header = update_content_length_header, 
         allow_playback_repeats = allow_playback_repeats, serialize_with = serialize_with, 
         persist_with = persist_with, preserve_exact_body_bytes = preserve_exact_body_bytes)
  3: Cassette$new(name = name, record = record, match_requests_on = match_requests_on, 
         re_record_interval = NULL, tag = NULL, tags = NULL, update_content_length_header = update_content_length_header, 
         decode_compressed_response = NULL, allow_playback_repeats = allow_playback_repeats, 
         allow_unused_http_interactions = NULL, exclusive = NULL, serialize_with = serialize_with, 
         persist_with = persist_with, preserve_exact_body_bytes = preserve_exact_body_bytes)
  4: .subset2(public_bind_env, "initialize")(...)
  5: self$http_interactions()
  6: HTTPInteractionList$new(interactions = {
         if (self$should_stub_requests()) {
             self$previously_recorded_interactions()
         }
         else {
             list()
         }
     }, request_matchers = vcr_configuration()$match_requests_on)
  7: .subset2(public_bind_env, "initialize")(...)
  8: self$previously_recorded_interactions()
  9: compact(lapply(self$deserialized_hash()[["http_interactions"]], function(z) {
         response <- VcrResponse$new(z$response$status, z$response$headers, z$response$body$string, 
             self$cassette_opts)
         if (self$update_content_length_header) 
             response$update_content_length_header()
         zz <- HTTPInteraction$new(request = Request$new(z$request$method, z$request$uri, 
             z$request$body$string, z$request$headers), response = response)
         hash <- zz$to_hash()
         if (request_ignorer$should_be_ignored(hash$request)) 
             NULL
         else hash
     }))
  10: Filter(Negate(is.null), x)
  11: unlist(lapply(x, f))
  12: lapply(x, f)
  13: lapply(self$deserialized_hash()[["http_interactions"]], function(z) {
         response <- VcrResponse$new(z$response$status, z$response$headers, z$response$body$string, 
             self$cassette_opts)
         if (self$update_content_length_header) 
             response$update_content_length_header()
         zz <- HTTPInteraction$new(request = Request$new(z$request$method, z$request$uri, 
             z$request$body$string, z$request$headers), response = response)
         hash <- zz$to_hash()
         if (request_ignorer$should_be_ignored(hash$request)) 
             NULL
         else hash
     })
  14: self$deserialized_hash()
  15: self$serializer$deserialize_path()
  16: yaml::yaml.load(str)
  
  -- 7. Error: paging: name_usage returns as many records as asked, limit > 1000 (
  Reader error: control characters are not allowed: #89 at 191741
  1: vcr::use_cassette("name_lookup_paging1", {
         aa <- name_lookup(datasetKey = "a5224e5b-6379-4d33-a29d-14b56015893d", limit = 1001)
     }) at testthat/test-name_lookup.r:79
  2: insert_cassette(name, record = record, match_requests_on = match_requests_on, update_content_length_header = update_content_length_header, 
         allow_playback_repeats = allow_playback_repeats, serialize_with = serialize_with, 
         persist_with = persist_with, preserve_exact_body_bytes = preserve_exact_body_bytes)
  3: Cassette$new(name = name, record = record, match_requests_on = match_requests_on, 
         re_record_interval = NULL, tag = NULL, tags = NULL, update_content_length_header = update_content_length_header, 
         decode_compressed_response = NULL, allow_playback_repeats = allow_playback_repeats, 
         allow_unused_http_interactions = NULL, exclusive = NULL, serialize_with = serialize_with, 
         persist_with = persist_with, preserve_exact_body_bytes = preserve_exact_body_bytes)
  4: .subset2(public_bind_env, "initialize")(...)
  5: self$http_interactions()
  6: HTTPInteractionList$new(interactions = {
         if (self$should_stub_requests()) {
             self$previously_recorded_interactions()
         }
         else {
             list()
         }
     }, request_matchers = vcr_configuration()$match_requests_on)
  7: .subset2(public_bind_env, "initialize")(...)
  8: self$previously_recorded_interactions()
  9: compact(lapply(self$deserialized_hash()[["http_interactions"]], function(z) {
         response <- VcrResponse$new(z$response$status, z$response$headers, z$response$body$string, 
             self$cassette_opts)
         if (self$update_content_length_header) 
             response$update_content_length_header()
         zz <- HTTPInteraction$new(request = Request$new(z$request$method, z$request$uri, 
             z$request$body$string, z$request$headers), response = response)
         hash <- zz$to_hash()
         if (request_ignorer$should_be_ignored(hash$request)) 
             NULL
         else hash
     }))
  10: Filter(Negate(is.null), x)
  11: unlist(lapply(x, f))
  12: lapply(x, f)
  13: lapply(self$deserialized_hash()[["http_interactions"]], function(z) {
         response <- VcrResponse$new(z$response$status, z$response$headers, z$response$body$string, 
             self$cassette_opts)
         if (self$update_content_length_header) 
             response$update_content_length_header()
         zz <- HTTPInteraction$new(request = Request$new(z$request$method, z$request$uri, 
             z$request$body$string, z$request$headers), response = response)
         hash <- zz$to_hash()
         if (request_ignorer$should_be_ignored(hash$request)) 
             NULL
         else hash
     })
  14: self$deserialized_hash()
  15: self$serializer$deserialize_path()
  16: yaml::yaml.load(str)
  
  -- 8. Error: paging: class data and meta not modified by paging (@test-name_look
  Reader error: control characters are not allowed: #89 at 194054
  1: vcr::use_cassette("name_lookup_paging2", {
         bb1 <- name_lookup(datasetKey = "a5224e5b-6379-4d33-a29d-14b56015893d", limit = 1)
         bb2 <- name_lookup(datasetKey = "a5224e5b-6379-4d33-a29d-14b56015893d", limit = 1002)
     }) at testthat/test-name_lookup.r:92
  2: insert_cassette(name, record = record, match_requests_on = match_requests_on, update_content_length_header = update_content_length_header, 
         allow_playback_repeats = allow_playback_repeats, serialize_with = serialize_with, 
         persist_with = persist_with, preserve_exact_body_bytes = preserve_exact_body_bytes)
  3: Cassette$new(name = name, record = record, match_requests_on = match_requests_on, 
         re_record_interval = NULL, tag = NULL, tags = NULL, update_content_length_header = update_content_length_header, 
         decode_compressed_response = NULL, allow_playback_repeats = allow_playback_repeats, 
         allow_unused_http_interactions = NULL, exclusive = NULL, serialize_with = serialize_with, 
         persist_with = persist_with, preserve_exact_body_bytes = preserve_exact_body_bytes)
  4: .subset2(public_bind_env, "initialize")(...)
  5: self$http_interactions()
  6: HTTPInteractionList$new(interactions = {
         if (self$should_stub_requests()) {
             self$previously_recorded_interactions()
         }
         else {
             list()
         }
     }, request_matchers = vcr_configuration()$match_requests_on)
  7: .subset2(public_bind_env, "initialize")(...)
  8: self$previously_recorded_interactions()
  9: compact(lapply(self$deserialized_hash()[["http_interactions"]], function(z) {
         response <- VcrResponse$new(z$response$status, z$response$headers, z$response$body$string, 
             self$cassette_opts)
         if (self$update_content_length_header) 
             response$update_content_length_header()
         zz <- HTTPInteraction$new(request = Request$new(z$request$method, z$request$uri, 
             z$request$body$string, z$request$headers), response = response)
         hash <- zz$to_hash()
         if (request_ignorer$should_be_ignored(hash$request)) 
             NULL
         else hash
     }))
  10: Filter(Negate(is.null), x)
  11: unlist(lapply(x, f))
  12: lapply(x, f)
  13: lapply(self$deserialized_hash()[["http_interactions"]], function(z) {
         response <- VcrResponse$new(z$response$status, z$response$headers, z$response$body$string, 
             self$cassette_opts)
         if (self$update_content_length_header) 
             response$update_content_length_header()
         zz <- HTTPInteraction$new(request = Request$new(z$request$method, z$request$uri, 
             z$request$body$string, z$request$headers), response = response)
         hash <- zz$to_hash()
         if (request_ignorer$should_be_ignored(hash$request)) 
             NULL
         else hash
     })
  14: self$deserialized_hash()
  15: self$serializer$deserialize_path()
  16: yaml::yaml.load(str)
  
  -- 9. Error: name_suggest returns the correct (@test-name_suggest.r#4)  --------
  Reader error: control characters are not allowed: #89 at 30873
  1: vcr::use_cassette("name_suggest", {
         a <- name_suggest(q = "Puma concolor")
         b <- name_suggest(q = "Puma")
         c <- name_suggest(q = "Puma", limit = 2)
         d <- name_suggest(q = "Puma", fields = c("key", "canonicalName"))
     }) at testthat/test-name_suggest.r:4
  2: insert_cassette(name, record = record, match_requests_on = match_requests_on, update_content_length_header = update_content_length_header, 
         allow_playback_repeats = allow_playback_repeats, serialize_with = serialize_with, 
         persist_with = persist_with, preserve_exact_body_bytes = preserve_exact_body_bytes)
  3: Cassette$new(name = name, record = record, match_requests_on = match_requests_on, 
         re_record_interval = NULL, tag = NULL, tags = NULL, update_content_length_header = update_content_length_header, 
         decode_compressed_response = NULL, allow_playback_repeats = allow_playback_repeats, 
         allow_unused_http_interactions = NULL, exclusive = NULL, serialize_with = serialize_with, 
         persist_with = persist_with, preserve_exact_body_bytes = preserve_exact_body_bytes)
  4: .subset2(public_bind_env, "initialize")(...)
  5: self$http_interactions()
  6: HTTPInteractionList$new(interactions = {
         if (self$should_stub_requests()) {
             self$previously_recorded_interactions()
         }
         else {
             list()
         }
     }, request_matchers = vcr_configuration()$match_requests_on)
  7: .subset2(public_bind_env, "initialize")(...)
  8: self$previously_recorded_interactions()
  9: compact(lapply(self$deserialized_hash()[["http_interactions"]], function(z) {
         response <- VcrResponse$new(z$response$status, z$response$headers, z$response$body$string, 
             self$cassette_opts)
         if (self$update_content_length_header) 
             response$update_content_length_header()
         zz <- HTTPInteraction$new(request = Request$new(z$request$method, z$request$uri, 
             z$request$body$string, z$request$headers), response = response)
         hash <- zz$to_hash()
         if (request_ignorer$should_be_ignored(hash$request)) 
             NULL
         else hash
     }))
  10: Filter(Negate(is.null), x)
  11: unlist(lapply(x, f))
  12: lapply(x, f)
  13: lapply(self$deserialized_hash()[["http_interactions"]], function(z) {
         response <- VcrResponse$new(z$response$status, z$response$headers, z$response$body$string, 
             self$cassette_opts)
         if (self$update_content_length_header) 
             response$update_content_length_header()
         zz <- HTTPInteraction$new(request = Request$new(z$request$method, z$request$uri, 
             z$request$body$string, z$request$headers), response = response)
         hash <- zz$to_hash()
         if (request_ignorer$should_be_ignored(hash$request)) 
             NULL
         else hash
     })
  14: self$deserialized_hash()
  15: self$serializer$deserialize_path()
  16: yaml::yaml.load(str)
  
  -- 10. Error: name_usage parents route works (@test-name_usage.r#89)  ----------
  Reader error: control characters are not allowed: #88 at 11226
  1: vcr::use_cassette("name_usage_data_parents", {
         rte2 <- name_usage(key = 5231190, data = "parents")
         rte2a <- name_usage(key = 5135783, data = "parents")
     }) at testthat/test-name_usage.r:89
  2: insert_cassette(name, record = record, match_requests_on = match_requests_on, update_content_length_header = update_content_length_header, 
         allow_playback_repeats = allow_playback_repeats, serialize_with = serialize_with, 
         persist_with = persist_with, preserve_exact_body_bytes = preserve_exact_body_bytes)
  3: Cassette$new(name = name, record = record, match_requests_on = match_requests_on, 
         re_record_interval = NULL, tag = NULL, tags = NULL, update_content_length_header = update_content_length_header, 
         decode_compressed_response = NULL, allow_playback_repeats = allow_playback_repeats, 
         allow_unused_http_interactions = NULL, exclusive = NULL, serialize_with = serialize_with, 
         persist_with = persist_with, preserve_exact_body_bytes = preserve_exact_body_bytes)
  4: .subset2(public_bind_env, "initialize")(...)
  5: self$http_interactions()
  6: HTTPInteractionList$new(interactions = {
         if (self$should_stub_requests()) {
             self$previously_recorded_interactions()
         }
         else {
             list()
         }
     }, request_matchers = vcr_configuration()$match_requests_on)
  7: .subset2(public_bind_env, "initialize")(...)
  8: self$previously_recorded_interactions()
  9: compact(lapply(self$deserialized_hash()[["http_interactions"]], function(z) {
         response <- VcrResponse$new(z$response$status, z$response$headers, z$response$body$string, 
             self$cassette_opts)
         if (self$update_content_length_header) 
             response$update_content_length_header()
         zz <- HTTPInteraction$new(request = Request$new(z$request$method, z$request$uri, 
             z$request$body$string, z$request$headers), response = response)
         hash <- zz$to_hash()
         if (request_ignorer$should_be_ignored(hash$request)) 
             NULL
         else hash
     }))
  10: Filter(Negate(is.null), x)
  11: unlist(lapply(x, f))
  12: lapply(x, f)
  13: lapply(self$deserialized_hash()[["http_interactions"]], function(z) {
         response <- VcrResponse$new(z$response$status, z$response$headers, z$response$body$string, 
             self$cassette_opts)
         if (self$update_content_length_header) 
             response$update_content_length_header()
         zz <- HTTPInteraction$new(request = Request$new(z$request$method, z$request$uri, 
             z$request$body$string, z$request$headers), response = response)
         hash <- zz$to_hash()
         if (request_ignorer$should_be_ignored(hash$request)) 
             NULL
         else hash
     })
  14: self$deserialized_hash()
  15: self$serializer$deserialize_path()
  16: yaml::yaml.load(str)
  
  -- 11. Error: gbif_oai_identify (@test-oai.R#4)  -------------------------------
  Reader error: control characters are not allowed: #80 at 2136
  1: vcr::use_cassette("gbif_oai_identify", {
         tt <- gbif_oai_identify()
     }) at testthat/test-oai.R:4
  2: insert_cassette(name, record = record, match_requests_on = match_requests_on, update_content_length_header = update_content_length_header, 
         allow_playback_repeats = allow_playback_repeats, serialize_with = serialize_with, 
         persist_with = persist_with, preserve_exact_body_bytes = preserve_exact_body_bytes)
  3: Cassette$new(name = name, record = record, match_requests_on = match_requests_on, 
         re_record_interval = NULL, tag = NULL, tags = NULL, update_content_length_header = update_content_length_header, 
         decode_compressed_response = NULL, allow_playback_repeats = allow_playback_repeats, 
         allow_unused_http_interactions = NULL, exclusive = NULL, serialize_with = serialize_with, 
         persist_with = persist_with, preserve_exact_body_bytes = preserve_exact_body_bytes)
  4: .subset2(public_bind_env, "initialize")(...)
  5: self$http_interactions()
  6: HTTPInteractionList$new(interactions = {
         if (self$should_stub_requests()) {
             self$previously_recorded_interactions()
         }
         else {
             list()
         }
     }, request_matchers = vcr_configuration()$match_requests_on)
  7: .subset2(public_bind_env, "initialize")(...)
  8: self$previously_recorded_interactions()
  9: compact(lapply(self$deserialized_hash()[["http_interactions"]], function(z) {
         response <- VcrResponse$new(z$response$status, z$response$headers, z$response$body$string, 
             self$cassette_opts)
         if (self$update_content_length_header) 
             response$update_content_length_header()
         zz <- HTTPInteraction$new(request = Request$new(z$request$method, z$request$uri, 
             z$request$body$string, z$request$headers), response = response)
         hash <- zz$to_hash()
         if (request_ignorer$should_be_ignored(hash$request)) 
             NULL
         else hash
     }))
  10: Filter(Negate(is.null), x)
  11: unlist(lapply(x, f))
  12: lapply(x, f)
  13: lapply(self$deserialized_hash()[["http_interactions"]], function(z) {
         response <- VcrResponse$new(z$response$status, z$response$headers, z$response$body$string, 
             self$cassette_opts)
         if (self$update_content_length_header) 
             response$update_content_length_header()
         zz <- HTTPInteraction$new(request = Request$new(z$request$method, z$request$uri, 
             z$request$body$string, z$request$headers), response = response)
         hash <- zz$to_hash()
         if (request_ignorer$should_be_ignored(hash$request)) 
             NULL
         else hash
     })
  14: self$deserialized_hash()
  15: self$serializer$deserialize_path()
  16: yaml::yaml.load(str)
  
  -- 12. Error: gbif_oai_list_sets (@test-oai.R#24)  -----------------------------
  Reader error: control characters are not allowed: #80 at 11203
  1: vcr::use_cassette("gbif_oai_list_sets", {
         tt <- gbif_oai_list_sets()
     }) at testthat/test-oai.R:24
  2: insert_cassette(name, record = record, match_requests_on = match_requests_on, update_content_length_header = update_content_length_header, 
         allow_playback_repeats = allow_playback_repeats, serialize_with = serialize_with, 
         persist_with = persist_with, preserve_exact_body_bytes = preserve_exact_body_bytes)
  3: Cassette$new(name = name, record = record, match_requests_on = match_requests_on, 
         re_record_interval = NULL, tag = NULL, tags = NULL, update_content_length_header = update_content_length_header, 
         decode_compressed_response = NULL, allow_playback_repeats = allow_playback_repeats, 
         allow_unused_http_interactions = NULL, exclusive = NULL, serialize_with = serialize_with, 
         persist_with = persist_with, preserve_exact_body_bytes = preserve_exact_body_bytes)
  4: .subset2(public_bind_env, "initialize")(...)
  5: self$http_interactions()
  6: HTTPInteractionList$new(interactions = {
         if (self$should_stub_requests()) {
             self$previously_recorded_interactions()
         }
         else {
             list()
         }
     }, request_matchers = vcr_configuration()$match_requests_on)
  7: .subset2(public_bind_env, "initialize")(...)
  8: self$previously_recorded_interactions()
  9: compact(lapply(self$deserialized_hash()[["http_interactions"]], function(z) {
         response <- VcrResponse$new(z$response$status, z$response$headers, z$response$body$string, 
             self$cassette_opts)
         if (self$update_content_length_header) 
             response$update_content_length_header()
         zz <- HTTPInteraction$new(request = Request$new(z$request$method, z$request$uri, 
             z$request$body$string, z$request$headers), response = response)
         hash <- zz$to_hash()
         if (request_ignorer$should_be_ignored(hash$request)) 
             NULL
         else hash
     }))
  10: Filter(Negate(is.null), x)
  11: unlist(lapply(x, f))
  12: lapply(x, f)
  13: lapply(self$deserialized_hash()[["http_interactions"]], function(z) {
         response <- VcrResponse$new(z$response$status, z$response$headers, z$response$body$string, 
             self$cassette_opts)
         if (self$update_content_length_header) 
             response$update_content_length_header()
         zz <- HTTPInteraction$new(request = Request$new(z$request$method, z$request$uri, 
             z$request$body$string, z$request$headers), response = response)
         hash <- zz$to_hash()
         if (request_ignorer$should_be_ignored(hash$request)) 
             NULL
         else hash
     })
  14: self$deserialized_hash()
  15: self$serializer$deserialize_path()
  16: yaml::yaml.load(str)
  
  -- 13. Error: returns the correct class (@test-occ_data.R#7)  ------------------
  Reader error: control characters are not allowed: #80 at 140613
  1: vcr::use_cassette("occ_data", {
         tt <- occ_data(taxonKey = key, limit = 2)
         uu <- occ_data(taxonKey = key, limit = 20)
         vv <- occ_data(taxonKey = key)
     }) at testthat/test-occ_data.R:7
  2: insert_cassette(name, record = record, match_requests_on = match_requests_on, update_content_length_header = update_content_length_header, 
         allow_playback_repeats = allow_playback_repeats, serialize_with = serialize_with, 
         persist_with = persist_with, preserve_exact_body_bytes = preserve_exact_body_bytes)
  3: Cassette$new(name = name, record = record, match_requests_on = match_requests_on, 
         re_record_interval = NULL, tag = NULL, tags = NULL, update_content_length_header = update_content_length_header, 
         decode_compressed_response = NULL, allow_playback_repeats = allow_playback_repeats, 
         allow_unused_http_interactions = NULL, exclusive = NULL, serialize_with = serialize_with, 
         persist_with = persist_with, preserve_exact_body_bytes = preserve_exact_body_bytes)
  4: .subset2(public_bind_env, "initialize")(...)
  5: self$http_interactions()
  6: HTTPInteractionList$new(interactions = {
         if (self$should_stub_requests()) {
             self$previously_recorded_interactions()
         }
         else {
             list()
         }
     }, request_matchers = vcr_configuration()$match_requests_on)
  7: .subset2(public_bind_env, "initialize")(...)
  8: self$previously_recorded_interactions()
  9: compact(lapply(self$deserialized_hash()[["http_interactions"]], function(z) {
         response <- VcrResponse$new(z$response$status, z$response$headers, z$response$body$string, 
             self$cassette_opts)
         if (self$update_content_length_header) 
             response$update_content_length_header()
         zz <- HTTPInteraction$new(request = Request$new(z$request$method, z$request$uri, 
             z$request$body$string, z$request$headers), response = response)
         hash <- zz$to_hash()
         if (request_ignorer$should_be_ignored(hash$request)) 
             NULL
         else hash
     }))
  10: Filter(Negate(is.null), x)
  11: unlist(lapply(x, f))
  12: lapply(x, f)
  13: lapply(self$deserialized_hash()[["http_interactions"]], function(z) {
         response <- VcrResponse$new(z$response$status, z$response$headers, z$response$body$string, 
             self$cassette_opts)
         if (self$update_content_length_header) 
             response$update_content_length_header()
         zz <- HTTPInteraction$new(request = Request$new(z$request$method, z$request$uri, 
             z$request$body$string, z$request$headers), response = response)
         hash <- zz$to_hash()
         if (request_ignorer$should_be_ignored(hash$request)) 
             NULL
         else hash
     })
  14: self$deserialized_hash()
  15: self$serializer$deserialize_path()
  16: yaml::yaml.load(str)
  
  -- 14. Error: returns the correct class (@test-occ_search.r#7)  ----------------
  Reader error: control characters are not allowed: #80 at 140613
  1: vcr::use_cassette("occ_search", {
         tt <- occ_search(taxonKey = key, limit = 2)
         uu <- occ_search(taxonKey = key, limit = 20)
         vv <- occ_search(taxonKey = key, return = "meta")
     }) at testthat/test-occ_search.r:7
  2: insert_cassette(name, record = record, match_requests_on = match_requests_on, update_content_length_header = update_content_length_header, 
         allow_playback_repeats = allow_playback_repeats, serialize_with = serialize_with, 
         persist_with = persist_with, preserve_exact_body_bytes = preserve_exact_body_bytes)
  3: Cassette$new(name = name, record = record, match_requests_on = match_requests_on, 
         re_record_interval = NULL, tag = NULL, tags = NULL, update_content_length_header = update_content_length_header, 
         decode_compressed_response = NULL, allow_playback_repeats = allow_playback_repeats, 
         allow_unused_http_interactions = NULL, exclusive = NULL, serialize_with = serialize_with, 
         persist_with = persist_with, preserve_exact_body_bytes = preserve_exact_body_bytes)
  4: .subset2(public_bind_env, "initialize")(...)
  5: self$http_interactions()
  6: HTTPInteractionList$new(interactions = {
         if (self$should_stub_requests()) {
             self$previously_recorded_interactions()
         }
         else {
             list()
         }
     }, request_matchers = vcr_configuration()$match_requests_on)
  7: .subset2(public_bind_env, "initialize")(...)
  8: self$previously_recorded_interactions()
  9: compact(lapply(self$deserialized_hash()[["http_interactions"]], function(z) {
         response <- VcrResponse$new(z$response$status, z$response$headers, z$response$body$string, 
             self$cassette_opts)
         if (self$update_content_length_header) 
             response$update_content_length_header()
         zz <- HTTPInteraction$new(request = Request$new(z$request$method, z$request$uri, 
             z$request$body$string, z$request$headers), response = response)
         hash <- zz$to_hash()
         if (request_ignorer$should_be_ignored(hash$request)) 
             NULL
         else hash
     }))
  10: Filter(Negate(is.null), x)
  11: unlist(lapply(x, f))
  12: lapply(x, f)
  13: lapply(self$deserialized_hash()[["http_interactions"]], function(z) {
         response <- VcrResponse$new(z$response$status, z$response$headers, z$response$body$string, 
             self$cassette_opts)
         if (self$update_content_length_header) 
             response$update_content_length_header()
         zz <- HTTPInteraction$new(request = Request$new(z$request$method, z$request$uri, 
             z$request$body$string, z$request$headers), response = response)
         hash <- zz$to_hash()
         if (request_ignorer$should_be_ignored(hash$request)) 
             NULL
         else hash
     })
  14: self$deserialized_hash()
  15: self$serializer$deserialize_path()
  16: yaml::yaml.load(str)
  
  -- 15. Error: returns the correct class (@test-occ_search.r#66)  ---------------
  Reader error: control characters are not allowed: #80 at 72614
  1: vcr::use_cassette("occ_search_taxonkey", {
         out <- occ_search(taxonKey = key, return = "data")
     }) at testthat/test-occ_search.r:66
  2: insert_cassette(name, record = record, match_requests_on = match_requests_on, update_content_length_header = update_content_length_header, 
         allow_playback_repeats = allow_playback_repeats, serialize_with = serialize_with, 
         persist_with = persist_with, preserve_exact_body_bytes = preserve_exact_body_bytes)
  3: Cassette$new(name = name, record = record, match_requests_on = match_requests_on, 
         re_record_interval = NULL, tag = NULL, tags = NULL, update_content_length_header = update_content_length_header, 
         decode_compressed_response = NULL, allow_playback_repeats = allow_playback_repeats, 
         allow_unused_http_interactions = NULL, exclusive = NULL, serialize_with = serialize_with, 
         persist_with = persist_with, preserve_exact_body_bytes = preserve_exact_body_bytes)
  4: .subset2(public_bind_env, "initialize")(...)
  5: self$http_interactions()
  6: HTTPInteractionList$new(interactions = {
         if (self$should_stub_requests()) {
             self$previously_recorded_interactions()
         }
         else {
             list()
         }
     }, request_matchers = vcr_configuration()$match_requests_on)
  7: .subset2(public_bind_env, "initialize")(...)
  8: self$previously_recorded_interactions()
  9: compact(lapply(self$deserialized_hash()[["http_interactions"]], function(z) {
         response <- VcrResponse$new(z$response$status, z$response$headers, z$response$body$string, 
             self$cassette_opts)
         if (self$update_content_length_header) 
             response$update_content_length_header()
         zz <- HTTPInteraction$new(request = Request$new(z$request$method, z$request$uri, 
             z$request$body$string, z$request$headers), response = response)
         hash <- zz$to_hash()
         if (request_ignorer$should_be_ignored(hash$request)) 
             NULL
         else hash
     }))
  10: Filter(Negate(is.null), x)
  11: unlist(lapply(x, f))
  12: lapply(x, f)
  13: lapply(self$deserialized_hash()[["http_interactions"]], function(z) {
         response <- VcrResponse$new(z$response$status, z$response$headers, z$response$body$string, 
             self$cassette_opts)
         if (self$update_content_length_header) 
             response$update_content_length_header()
         zz <- HTTPInteraction$new(request = Request$new(z$request$method, z$request$uri, 
             z$request$body$string, z$request$headers), response = response)
         hash <- zz$to_hash()
         if (request_ignorer$should_be_ignored(hash$request)) 
             NULL
         else hash
     })
  14: self$deserialized_hash()
  15: self$serializer$deserialize_path()
  16: yaml::yaml.load(str)
  
  -- 16. Error: returns the correct class (@test-parsenames.r#4)  ----------------
  Reader error: control characters are not allowed: #97 at 1283
  1: vcr::use_cassette("parsenames", {
         tt <- parsenames(scientificname = "x Agropogon littoralis")
         uu <- parsenames(c("Arrhenatherum elatius var. elatius", "Secale cereale subsp. cereale", 
             "Secale cereale ssp. cereale", "Vanessa atalanta (Linnaeus, 1758)"))
     }) at testthat/test-parsenames.r:4
  2: insert_cassette(name, record = record, match_requests_on = match_requests_on, update_content_length_header = update_content_length_header, 
         allow_playback_repeats = allow_playback_repeats, serialize_with = serialize_with, 
         persist_with = persist_with, preserve_exact_body_bytes = preserve_exact_body_bytes)
  3: Cassette$new(name = name, record = record, match_requests_on = match_requests_on, 
         re_record_interval = NULL, tag = NULL, tags = NULL, update_content_length_header = update_content_length_header, 
         decode_compressed_response = NULL, allow_playback_repeats = allow_playback_repeats, 
         allow_unused_http_interactions = NULL, exclusive = NULL, serialize_with = serialize_with, 
         persist_with = persist_with, preserve_exact_body_bytes = preserve_exact_body_bytes)
  4: .subset2(public_bind_env, "initialize")(...)
  5: self$http_interactions()
  6: HTTPInteractionList$new(interactions = {
         if (self$should_stub_requests()) {
             self$previously_recorded_interactions()
         }
         else {
             list()
         }
     }, request_matchers = vcr_configuration()$match_requests_on)
  7: .subset2(public_bind_env, "initialize")(...)
  8: self$previously_recorded_interactions()
  9: compact(lapply(self$deserialized_hash()[["http_interactions"]], function(z) {
         response <- VcrResponse$new(z$response$status, z$response$headers, z$response$body$string, 
             self$cassette_opts)
         if (self$update_content_length_header) 
             response$update_content_length_header()
         zz <- HTTPInteraction$new(request = Request$new(z$request$method, z$request$uri, 
             z$request$body$string, z$request$headers), response = response)
         hash <- zz$to_hash()
         if (request_ignorer$should_be_ignored(hash$request)) 
             NULL
         else hash
     }))
  10: Filter(Negate(is.null), x)
  11: unlist(lapply(x, f))
  12: lapply(x, f)
  13: lapply(self$deserialized_hash()[["http_interactions"]], function(z) {
         response <- VcrResponse$new(z$response$status, z$response$headers, z$response$body$string, 
             self$cassette_opts)
         if (self$update_content_length_header) 
             response$update_content_length_header()
         zz <- HTTPInteraction$new(request = Request$new(z$request$method, z$request$uri, 
             z$request$body$string, z$request$headers), response = response)
         hash <- zz$to_hash()
         if (request_ignorer$should_be_ignored(hash$request)) 
             NULL
         else hash
     })
  14: self$deserialized_hash()
  15: self$serializer$deserialize_path()
  16: yaml::yaml.load(str)
  
  == testthat results  ===========================================================
  OK: 628 SKIPPED: 27 FAILED: 16
  1. Error: keyword query returns the correct (@test-dataset_search.r#18) 
  2. Error: limited search returns the correct (@test-dataset_search.r#52) 
  3. Error: type query returns the correct class (@test-dataset_suggest.r#4) 
  4. Error: limited search returns the correct class (@test-dataset_suggest.r#30) 
  5. Error: enumeration (@test-enumeration.r#4) 
  6. Error: returns the correct class (@test-name_lookup.r#4) 
  7. Error: paging: name_usage returns as many records as asked, limit > 1000 (@test-name_lookup.r#79) 
  8. Error: paging: class data and meta not modified by paging (@test-name_lookup.r#92) 
  9. Error: name_suggest returns the correct (@test-name_suggest.r#4) 
  1. ...
  
  Error: testthat unit tests failed
  Execution halted