Running ‘testthat.R’ [2s/6s]
Running the tests in ‘tests/testthat.R’ failed.
Complete output:
  > library(testthat)
  > library(wdman)
  > 
  > test_check("wdman")
  ── 1. Error: canCallChrome (@test-chrome.R#3)  ─────────────────────────────────
  Can't mock functions in base packages (base)
  1: with_mock(`binman::process_yaml` = binman_process_yaml, `binman::list_versions` = mock_binman_list_versions_chrome, 
         `binman::app_dir` = mock_binman_app_dir, `base::normalizePath` = mock_base_normalizePath, 
         `base::list.files` = mock_base_list.files, `subprocess::spawn_process` = mock_subprocess_spawn_process, 
         `subprocess::process_return_code` = mock_subprocess_process_return_code, `subprocess::process_kill` = mock_subprocess_process_kill, 
         `wdman:::generic_start_log` = mock_generic_start_log, `wdman:::infun_read` = function(...) {
             "infun"
         }, {
             cDrv <- chrome()
             retCommand <- chrome(retcommand = TRUE)
             expect_identical(cDrv$output(), "infun")
             expect_identical(cDrv$error(), "infun")
             logOut <- cDrv$log()[["stdout"]]
             logErr <- cDrv$log()[["stderr"]]
             expect_identical(logOut, "super duper")
             expect_identical(logErr, "no error here")
             expect_identical(cDrv$stop(), "stopped")
         }) at testthat/test-chrome.R:3
  2: extract_mocks(new_values = new_values[!code_pos], .env = .env, eval_env = parent.frame())
  3: lapply(stats::setNames(nm = mock_qual_names), function(qual_name) {
         pkg_name <- gsub(pkg_and_name_rx, "\\1", qual_name)
         if (is_base_pkg(pkg_name)) {
             stop("Can't mock functions in base packages (", pkg_name, ")", call. = FALSE)
         }
         name <- gsub(pkg_and_name_rx, "\\2", qual_name)
         if (pkg_name == "") 
             pkg_name <- .env
         env <- asNamespace(pkg_name)
         if (!exists(name, envir = env, mode = "function")) 
             stop("Function ", name, " not found in environment ", environmentName(env), 
                 ".", call. = FALSE)
         mock(name = name, env = env, new = eval(new_values[[qual_name]], eval_env, eval_env))
     })
  4: FUN(X[[i]], ...)
  5: stop("Can't mock functions in base packages (", pkg_name, ")", call. = FALSE)
  
  ── 2. Error: pickUpErrorFromReturnCode (@test-chrome.R#43)  ────────────────────
  Can't mock functions in base packages (base)
  1: with_mock(`binman::process_yaml` = function(...) {
     }, `binman::list_versions` = mock_binman_list_versions_chrome, `binman::app_dir` = mock_binman_app_dir, 
         `base::normalizePath` = mock_base_normalizePath, `base::list.files` = mock_base_list.files, 
         `subprocess::spawn_process` = mock_subprocess_spawn_process, `subprocess::process_return_code` = function(...) {
             "some error"
         }, `subprocess::process_read` = mock_subprocess_process_read_selenium, `wdman:::generic_start_log` = mock_generic_start_log, 
         {
             expect_error(chrome(version = "2.24"), "Chromedriver couldn't be started")
         }) at testthat/test-chrome.R:43
  2: extract_mocks(new_values = new_values[!code_pos], .env = .env, eval_env = parent.frame())
  3: lapply(stats::setNames(nm = mock_qual_names), function(qual_name) {
         pkg_name <- gsub(pkg_and_name_rx, "\\1", qual_name)
         if (is_base_pkg(pkg_name)) {
             stop("Can't mock functions in base packages (", pkg_name, ")", call. = FALSE)
         }
         name <- gsub(pkg_and_name_rx, "\\2", qual_name)
         if (pkg_name == "") 
             pkg_name <- .env
         env <- asNamespace(pkg_name)
         if (!exists(name, envir = env, mode = "function")) 
             stop("Function ", name, " not found in environment ", environmentName(env), 
                 ".", call. = FALSE)
         mock(name = name, env = env, new = eval(new_values[[qual_name]], eval_env, eval_env))
     })
  4: FUN(X[[i]], ...)
  5: stop("Can't mock functions in base packages (", pkg_name, ")", call. = FALSE)
  
  ── 3. Error: pickUpErrorFromPortInUse (@test-chrome.R#62)  ─────────────────────
  Can't mock functions in base packages (base)
  1: with_mock(`binman::process_yaml` = function(...) {
     }, `binman::list_versions` = mock_binman_list_versions_chrome, `binman::app_dir` = mock_binman_app_dir, 
         `base::normalizePath` = mock_base_normalizePath, `base::list.files` = mock_base_list.files, 
         `subprocess::spawn_process` = mock_subprocess_spawn_process, `subprocess::process_return_code` = mock_subprocess_process_return_code, 
         `subprocess::process_read` = mock_subprocess_process_read_selenium, `subprocess::process_kill` = mock_subprocess_process_kill, 
         `wdman:::generic_start_log` = function(...) {
             list(stderr = "Address already in use")
         }, {
             expect_error(chrome(version = "2.24"), "Chrome Driver signals port")
         }) at testthat/test-chrome.R:62
  2: extract_mocks(new_values = new_values[!code_pos], .env = .env, eval_env = parent.frame())
  3: lapply(stats::setNames(nm = mock_qual_names), function(qual_name) {
         pkg_name <- gsub(pkg_and_name_rx, "\\1", qual_name)
         if (is_base_pkg(pkg_name)) {
             stop("Can't mock functions in base packages (", pkg_name, ")", call. = FALSE)
         }
         name <- gsub(pkg_and_name_rx, "\\2", qual_name)
         if (pkg_name == "") 
             pkg_name <- .env
         env <- asNamespace(pkg_name)
         if (!exists(name, envir = env, mode = "function")) 
             stop("Function ", name, " not found in environment ", environmentName(env), 
                 ".", call. = FALSE)
         mock(name = name, env = env, new = eval(new_values[[qual_name]], eval_env, eval_env))
     })
  4: FUN(X[[i]], ...)
  5: stop("Can't mock functions in base packages (", pkg_name, ")", call. = FALSE)
  
  ── 4. Error: canCallGecko (@test-gecko.R#4)  ───────────────────────────────────
  Can't mock functions in base packages (base)
  1: with_mock(`binman::process_yaml` = function(...) {
     }, `binman::list_versions` = mock_binman_list_versions_gecko, `binman::app_dir` = mock_binman_app_dir, 
         `base::normalizePath` = mock_base_normalizePath, `base::list.files` = mock_base_list.files, 
         `subprocess::spawn_process` = mock_subprocess_spawn_process, `subprocess::process_return_code` = mock_subprocess_process_return_code, 
         `subprocess::process_kill` = mock_subprocess_process_kill, `wdman:::generic_start_log` = mock_generic_start_log, 
         `wdman:::infun_read` = function(...) {
             "infun"
         }, {
             gDrv <- gecko()
             retCommand <- gecko(retcommand = TRUE)
             expect_identical(gDrv$output(), "infun")
             expect_identical(gDrv$error(), "infun")
             logOut <- gDrv$log()[["stdout"]]
             logErr <- gDrv$log()[["stderr"]]
             expect_identical(logOut, "super duper")
             expect_identical(logErr, "no error here")
             expect_identical(gDrv$stop(), "stopped")
         }) at testthat/test-gecko.R:4
  2: extract_mocks(new_values = new_values[!code_pos], .env = .env, eval_env = parent.frame())
  3: lapply(stats::setNames(nm = mock_qual_names), function(qual_name) {
         pkg_name <- gsub(pkg_and_name_rx, "\\1", qual_name)
         if (is_base_pkg(pkg_name)) {
             stop("Can't mock functions in base packages (", pkg_name, ")", call. = FALSE)
         }
         name <- gsub(pkg_and_name_rx, "\\2", qual_name)
         if (pkg_name == "") 
             pkg_name <- .env
         env <- asNamespace(pkg_name)
         if (!exists(name, envir = env, mode = "function")) 
             stop("Function ", name, " not found in environment ", environmentName(env), 
                 ".", call. = FALSE)
         mock(name = name, env = env, new = eval(new_values[[qual_name]], eval_env, eval_env))
     })
  4: FUN(X[[i]], ...)
  5: stop("Can't mock functions in base packages (", pkg_name, ")", call. = FALSE)
  
  ── 5. Error: pickUpErrorFromReturnCode (@test-gecko.R#44)  ─────────────────────
  Can't mock functions in base packages (base)
  1: with_mock(`binman::process_yaml` = function(...) {
     }, `binman::list_versions` = mock_binman_list_versions_gecko, `binman::app_dir` = mock_binman_app_dir, 
         `base::normalizePath` = mock_base_normalizePath, `base::list.files` = mock_base_list.files, 
         `subprocess::spawn_process` = mock_subprocess_spawn_process, `subprocess::process_return_code` = function(...) {
             "some error"
         }, `subprocess::process_read` = mock_subprocess_process_read_selenium, `wdman:::generic_start_log` = mock_generic_start_log, 
         {
             expect_error(gecko(version = "0.11.0"), "Geckodriver couldn't be started")
         }) at testthat/test-gecko.R:44
  2: extract_mocks(new_values = new_values[!code_pos], .env = .env, eval_env = parent.frame())
  3: lapply(stats::setNames(nm = mock_qual_names), function(qual_name) {
         pkg_name <- gsub(pkg_and_name_rx, "\\1", qual_name)
         if (is_base_pkg(pkg_name)) {
             stop("Can't mock functions in base packages (", pkg_name, ")", call. = FALSE)
         }
         name <- gsub(pkg_and_name_rx, "\\2", qual_name)
         if (pkg_name == "") 
             pkg_name <- .env
         env <- asNamespace(pkg_name)
         if (!exists(name, envir = env, mode = "function")) 
             stop("Function ", name, " not found in environment ", environmentName(env), 
                 ".", call. = FALSE)
         mock(name = name, env = env, new = eval(new_values[[qual_name]], eval_env, eval_env))
     })
  4: FUN(X[[i]], ...)
  5: stop("Can't mock functions in base packages (", pkg_name, ")", call. = FALSE)
  
  ── 6. Error: pickUpErrorFromPortInUse (@test-gecko.R#63)  ──────────────────────
  Can't mock functions in base packages (base)
  1: with_mock(`binman::process_yaml` = function(...) {
     }, `binman::list_versions` = mock_binman_list_versions_gecko, `binman::app_dir` = mock_binman_app_dir, 
         `base::normalizePath` = mock_base_normalizePath, `base::list.files` = mock_base_list.files, 
         `subprocess::spawn_process` = mock_subprocess_spawn_process, `subprocess::process_return_code` = mock_subprocess_process_return_code, 
         `subprocess::process_read` = mock_subprocess_process_read_selenium, `subprocess::process_kill` = mock_subprocess_process_kill, 
         `wdman:::generic_start_log` = function(...) {
             list(stderr = "Address in use")
         }, {
             expect_error(gecko(version = "0.11.0"), "Gecko Driver signals port")
         }) at testthat/test-gecko.R:63
  2: extract_mocks(new_values = new_values[!code_pos], .env = .env, eval_env = parent.frame())
  3: lapply(stats::setNames(nm = mock_qual_names), function(qual_name) {
         pkg_name <- gsub(pkg_and_name_rx, "\\1", qual_name)
         if (is_base_pkg(pkg_name)) {
             stop("Can't mock functions in base packages (", pkg_name, ")", call. = FALSE)
         }
         name <- gsub(pkg_and_name_rx, "\\2", qual_name)
         if (pkg_name == "") 
             pkg_name <- .env
         env <- asNamespace(pkg_name)
         if (!exists(name, envir = env, mode = "function")) 
             stop("Function ", name, " not found in environment ", environmentName(env), 
                 ".", call. = FALSE)
         mock(name = name, env = env, new = eval(new_values[[qual_name]], eval_env, eval_env))
     })
  4: FUN(X[[i]], ...)
  5: stop("Can't mock functions in base packages (", pkg_name, ")", call. = FALSE)
  
  ── 7. Error: canCallIEDriver (@test-iedriver.R#4)  ─────────────────────────────
  Can't mock functions in base packages (base)
  1: with_mock(`binman::process_yaml` = function(...) {
     }, `binman::list_versions` = mock_binman_list_versions_iedriver, `binman::app_dir` = mock_binman_app_dir, 
         `base::normalizePath` = mock_base_normalizePath, `base::list.files` = mock_base_list.files, 
         `subprocess::spawn_process` = mock_subprocess_spawn_process, `subprocess::process_return_code` = mock_subprocess_process_return_code, 
         `subprocess::process_kill` = mock_subprocess_process_kill, `base::Sys.info` = function(...) {
             structure("Windows", .Names = "sysname")
         }, `wdman:::generic_start_log` = mock_generic_start_log, `wdman:::infun_read` = function(...) {
             "infun"
         }, {
             ieDrv <- iedriver()
             retCommand <- iedriver(retcommand = TRUE)
             expect_identical(ieDrv$output(), "infun")
             expect_identical(ieDrv$error(), "infun")
             logOut <- ieDrv$log()[["stdout"]]
             logErr <- ieDrv$log()[["stderr"]]
             expect_identical(logOut, "super duper")
             expect_identical(logErr, "no error here")
             expect_identical(ieDrv$stop(), "stopped")
         }) at testthat/test-iedriver.R:4
  2: extract_mocks(new_values = new_values[!code_pos], .env = .env, eval_env = parent.frame())
  3: lapply(stats::setNames(nm = mock_qual_names), function(qual_name) {
         pkg_name <- gsub(pkg_and_name_rx, "\\1", qual_name)
         if (is_base_pkg(pkg_name)) {
             stop("Can't mock functions in base packages (", pkg_name, ")", call. = FALSE)
         }
         name <- gsub(pkg_and_name_rx, "\\2", qual_name)
         if (pkg_name == "") 
             pkg_name <- .env
         env <- asNamespace(pkg_name)
         if (!exists(name, envir = env, mode = "function")) 
             stop("Function ", name, " not found in environment ", environmentName(env), 
                 ".", call. = FALSE)
         mock(name = name, env = env, new = eval(new_values[[qual_name]], eval_env, eval_env))
     })
  4: FUN(X[[i]], ...)
  5: stop("Can't mock functions in base packages (", pkg_name, ")", call. = FALSE)
  
  ── 8. Error: pickUpErrorFromReturnCode (@test-iedriver.R#46)  ──────────────────
  Can't mock functions in base packages (base)
  1: with_mock(`binman::process_yaml` = function(...) {
     }, `binman::list_versions` = mock_binman_list_versions_iedriver, `binman::app_dir` = mock_binman_app_dir, 
         `base::normalizePath` = mock_base_normalizePath, `base::list.files` = mock_base_list.files, 
         `subprocess::spawn_process` = mock_subprocess_spawn_process, `subprocess::process_return_code` = function(...) {
             "some error"
         }, `subprocess::process_read` = mock_subprocess_process_read_selenium, `wdman:::generic_start_log` = mock_generic_start_log, 
         `base::Sys.info` = function(...) {
             structure("Windows", .Names = "sysname")
         }, {
             expect_error(iedriver(version = "3.0.0"), "iedriver couldn't be started")
         }) at testthat/test-iedriver.R:46
  2: extract_mocks(new_values = new_values[!code_pos], .env = .env, eval_env = parent.frame())
  3: lapply(stats::setNames(nm = mock_qual_names), function(qual_name) {
         pkg_name <- gsub(pkg_and_name_rx, "\\1", qual_name)
         if (is_base_pkg(pkg_name)) {
             stop("Can't mock functions in base packages (", pkg_name, ")", call. = FALSE)
         }
         name <- gsub(pkg_and_name_rx, "\\2", qual_name)
         if (pkg_name == "") 
             pkg_name <- .env
         env <- asNamespace(pkg_name)
         if (!exists(name, envir = env, mode = "function")) 
             stop("Function ", name, " not found in environment ", environmentName(env), 
                 ".", call. = FALSE)
         mock(name = name, env = env, new = eval(new_values[[qual_name]], eval_env, eval_env))
     })
  4: FUN(X[[i]], ...)
  5: stop("Can't mock functions in base packages (", pkg_name, ")", call. = FALSE)
  
  ── 9. Error: pickUpErrorFromPortInUse (@test-iedriver.R#68)  ───────────────────
  Can't mock functions in base packages (base)
  1: with_mock(`binman::process_yaml` = function(...) {
     }, `binman::list_versions` = mock_binman_list_versions_iedriver, `binman::app_dir` = mock_binman_app_dir, 
         `base::normalizePath` = mock_base_normalizePath, `base::list.files` = mock_base_list.files, 
         `subprocess::spawn_process` = mock_subprocess_spawn_process, `subprocess::process_return_code` = mock_subprocess_process_return_code, 
         `subprocess::process_read` = mock_subprocess_process_read_selenium, `subprocess::process_kill` = mock_subprocess_process_kill, 
         `wdman:::generic_start_log` = function(...) {
             list(stderr = "Address in use")
         }, `base::Sys.info` = function(...) {
             structure("Windows", .Names = "sysname")
         }, {
             expect_error(iedriver(version = "3.0.0"), "IE Driver signals port")
         }) at testthat/test-iedriver.R:68
  2: extract_mocks(new_values = new_values[!code_pos], .env = .env, eval_env = parent.frame())
  3: lapply(stats::setNames(nm = mock_qual_names), function(qual_name) {
         pkg_name <- gsub(pkg_and_name_rx, "\\1", qual_name)
         if (is_base_pkg(pkg_name)) {
             stop("Can't mock functions in base packages (", pkg_name, ")", call. = FALSE)
         }
         name <- gsub(pkg_and_name_rx, "\\2", qual_name)
         if (pkg_name == "") 
             pkg_name <- .env
         env <- asNamespace(pkg_name)
         if (!exists(name, envir = env, mode = "function")) 
             stop("Function ", name, " not found in environment ", environmentName(env), 
                 ".", call. = FALSE)
         mock(name = name, env = env, new = eval(new_values[[qual_name]], eval_env, eval_env))
     })
  4: FUN(X[[i]], ...)
  5: stop("Can't mock functions in base packages (", pkg_name, ")", call. = FALSE)
  
  ── 10. Error: canCallPhantomJS (@test-phantom.R#4)  ────────────────────────────
  Can't mock functions in base packages (base)
  1: with_mock(`binman::process_yaml` = function(...) {
     }, `binman::list_versions` = mock_binman_list_versions_phantomjs, `binman::app_dir` = mock_binman_app_dir, 
         `base::normalizePath` = mock_base_normalizePath, `base::list.files` = mock_base_list.files, 
         `subprocess::spawn_process` = mock_subprocess_spawn_process, `subprocess::process_return_code` = mock_subprocess_process_return_code, 
         `subprocess::process_kill` = mock_subprocess_process_kill, `wdman:::generic_start_log` = mock_generic_start_log, 
         `wdman:::infun_read` = function(...) {
             "infun"
         }, {
             pDrv <- phantomjs(version = "latest")
             retCommand <- phantomjs(version = "latest", retcommand = TRUE)
             expect_identical(pDrv$output(), "infun")
             expect_identical(pDrv$error(), "infun")
             logOut <- pDrv$log()[["stdout"]]
             logErr <- pDrv$log()[["stderr"]]
             expect_identical(logOut, "super duper")
             expect_identical(logErr, "no error here")
             expect_identical(pDrv$stop(), "stopped")
         }) at testthat/test-phantom.R:4
  2: extract_mocks(new_values = new_values[!code_pos], .env = .env, eval_env = parent.frame())
  3: lapply(stats::setNames(nm = mock_qual_names), function(qual_name) {
         pkg_name <- gsub(pkg_and_name_rx, "\\1", qual_name)
         if (is_base_pkg(pkg_name)) {
             stop("Can't mock functions in base packages (", pkg_name, ")", call. = FALSE)
         }
         name <- gsub(pkg_and_name_rx, "\\2", qual_name)
         if (pkg_name == "") 
             pkg_name <- .env
         env <- asNamespace(pkg_name)
         if (!exists(name, envir = env, mode = "function")) 
             stop("Function ", name, " not found in environment ", environmentName(env), 
                 ".", call. = FALSE)
         mock(name = name, env = env, new = eval(new_values[[qual_name]], eval_env, eval_env))
     })
  4: FUN(X[[i]], ...)
  5: stop("Can't mock functions in base packages (", pkg_name, ")", call. = FALSE)
  
  ── 11. Error: pickUpErrorFromReturnCode (@test-phantom.R#44)  ──────────────────
  Can't mock functions in base packages (base)
  1: with_mock(`binman::process_yaml` = function(...) {
     }, `binman::list_versions` = mock_binman_list_versions_phantomjs, `binman::app_dir` = mock_binman_app_dir, 
         `base::normalizePath` = mock_base_normalizePath, `base::list.files` = mock_base_list.files, 
         `subprocess::spawn_process` = mock_subprocess_spawn_process, `subprocess::process_return_code` = function(...) {
             "some error"
         }, `subprocess::process_read` = mock_subprocess_process_read_selenium, `wdman:::generic_start_log` = mock_generic_start_log, 
         {
             expect_error(phantomjs(version = "2.1.1"), "PhantomJS couldn't be started")
         }) at testthat/test-phantom.R:44
  2: extract_mocks(new_values = new_values[!code_pos], .env = .env, eval_env = parent.frame())
  3: lapply(stats::setNames(nm = mock_qual_names), function(qual_name) {
         pkg_name <- gsub(pkg_and_name_rx, "\\1", qual_name)
         if (is_base_pkg(pkg_name)) {
             stop("Can't mock functions in base packages (", pkg_name, ")", call. = FALSE)
         }
         name <- gsub(pkg_and_name_rx, "\\2", qual_name)
         if (pkg_name == "") 
             pkg_name <- .env
         env <- asNamespace(pkg_name)
         if (!exists(name, envir = env, mode = "function")) 
             stop("Function ", name, " not found in environment ", environmentName(env), 
                 ".", call. = FALSE)
         mock(name = name, env = env, new = eval(new_values[[qual_name]], eval_env, eval_env))
     })
  4: FUN(X[[i]], ...)
  5: stop("Can't mock functions in base packages (", pkg_name, ")", call. = FALSE)
  
  ── 12. Error: pickUpErrorFromPortInUse (@test-phantom.R#63)  ───────────────────
  Can't mock functions in base packages (base)
  1: with_mock(`binman::process_yaml` = function(...) {
     }, `binman::list_versions` = mock_binman_list_versions_phantomjs, `binman::app_dir` = mock_binman_app_dir, 
         `base::normalizePath` = mock_base_normalizePath, `base::list.files` = mock_base_list.files, 
         `subprocess::spawn_process` = mock_subprocess_spawn_process, `subprocess::process_return_code` = mock_subprocess_process_return_code, 
         `subprocess::process_read` = mock_subprocess_process_read_selenium, `subprocess::process_kill` = mock_subprocess_process_kill, 
         `wdman:::generic_start_log` = function(...) {
             list(stdout = "GhostDriver - main.fail.*sourceURL")
         }, {
             expect_error(phantomjs(version = "2.1.1"), "PhantomJS signals port")
         }) at testthat/test-phantom.R:63
  2: extract_mocks(new_values = new_values[!code_pos], .env = .env, eval_env = parent.frame())
  3: lapply(stats::setNames(nm = mock_qual_names), function(qual_name) {
         pkg_name <- gsub(pkg_and_name_rx, "\\1", qual_name)
         if (is_base_pkg(pkg_name)) {
             stop("Can't mock functions in base packages (", pkg_name, ")", call. = FALSE)
         }
         name <- gsub(pkg_and_name_rx, "\\2", qual_name)
         if (pkg_name == "") 
             pkg_name <- .env
         env <- asNamespace(pkg_name)
         if (!exists(name, envir = env, mode = "function")) 
             stop("Function ", name, " not found in environment ", environmentName(env), 
                 ".", call. = FALSE)
         mock(name = name, env = env, new = eval(new_values[[qual_name]], eval_env, eval_env))
     })
  4: FUN(X[[i]], ...)
  5: stop("Can't mock functions in base packages (", pkg_name, ")", call. = FALSE)
  
  ── 13. Error: canCallSelenium (@test-selenium.R#4)  ────────────────────────────
  Can't mock functions in base packages (base)
  1: with_mock(`binman::process_yaml` = function(...) {
     }, `binman::list_versions` = mock_binman_list_versions_selenium, `binman::app_dir` = mock_binman_app_dir, 
         `base::normalizePath` = mock_base_normalizePath, `base::list.files` = mock_base_list.files, 
         `subprocess::spawn_process` = mock_subprocess_spawn_process, `subprocess::process_return_code` = mock_subprocess_process_return_code, 
         `subprocess::process_read` = mock_subprocess_process_read_selenium, `subprocess::process_kill` = mock_subprocess_process_kill, 
         `wdman:::generic_start_log` = mock_generic_start_log, `wdman:::infun_read` = function(...) {
             "infun"
         }, `base::Sys.info` = function(...) {
             structure("Windows", .Names = "sysname")
         }, `wdman:::chrome_check` = function(...) {
             list(platform = "some.plat")
         }, `wdman:::chrome_ver` = function(...) {
             list(path = "some.path")
         }, `wdman:::gecko_check` = function(...) {
             list(platform = "some.plat")
         }, `wdman:::gecko_ver` = function(...) {
             list(path = "some.path")
         }, `wdman:::phantom_check` = function(...) {
             list(platform = "some.plat")
         }, `wdman:::phantom_ver` = function(...) {
             list(path = "some.path")
         }, `wdman:::ie_check` = function(...) {
             list(platform = "some.plat")
         }, `wdman:::ie_ver` = function(...) {
             list(path = "some.path")
         }, {
             selServ <- selenium(iedrver = "latest")
             retCommand <- selenium(iedrver = "latest", retcommand = TRUE)
             expect_identical(selServ$output(), "infun")
             expect_identical(selServ$error(), "infun")
             logOut <- selServ$log()[["stdout"]]
             logErr <- selServ$log()[["stderr"]]
             expect_identical(logOut, "super duper")
             expect_identical(logErr, "no error here")
             expect_identical(selServ$stop(), "stopped")
         }) at testthat/test-selenium.R:4
  2: extract_mocks(new_values = new_values[!code_pos], .env = .env, eval_env = parent.frame())
  3: lapply(stats::setNames(nm = mock_qual_names), function(qual_name) {
         pkg_name <- gsub(pkg_and_name_rx, "\\1", qual_name)
         if (is_base_pkg(pkg_name)) {
             stop("Can't mock functions in base packages (", pkg_name, ")", call. = FALSE)
         }
         name <- gsub(pkg_and_name_rx, "\\2", qual_name)
         if (pkg_name == "") 
             pkg_name <- .env
         env <- asNamespace(pkg_name)
         if (!exists(name, envir = env, mode = "function")) 
             stop("Function ", name, " not found in environment ", environmentName(env), 
                 ".", call. = FALSE)
         mock(name = name, env = env, new = eval(new_values[[qual_name]], eval_env, eval_env))
     })
  4: FUN(X[[i]], ...)
  5: stop("Can't mock functions in base packages (", pkg_name, ")", call. = FALSE)
  
  ── 14. Error: errorIfJavaNotFound (@test-selenium.R#75)  ───────────────────────
  Can't mock functions in base packages (base)
  1: with_mock(`base::Sys.which` = function(...) {
         ""
     }, expect_error(selenium(), "PATH to JAVA not found")) at testthat/test-selenium.R:75
  2: extract_mocks(new_values = new_values[!code_pos], .env = .env, eval_env = parent.frame())
  3: lapply(stats::setNames(nm = mock_qual_names), function(qual_name) {
         pkg_name <- gsub(pkg_and_name_rx, "\\1", qual_name)
         if (is_base_pkg(pkg_name)) {
             stop("Can't mock functions in base packages (", pkg_name, ")", call. = FALSE)
         }
         name <- gsub(pkg_and_name_rx, "\\2", qual_name)
         if (pkg_name == "") 
             pkg_name <- .env
         env <- asNamespace(pkg_name)
         if (!exists(name, envir = env, mode = "function")) 
             stop("Function ", name, " not found in environment ", environmentName(env), 
                 ".", call. = FALSE)
         mock(name = name, env = env, new = eval(new_values[[qual_name]], eval_env, eval_env))
     })
  4: FUN(X[[i]], ...)
  5: stop("Can't mock functions in base packages (", pkg_name, ")", call. = FALSE)
  
  ── 15. Error: errorIfVersionNotFound (@test-selenium.R#82)  ────────────────────
  Can't mock functions in base packages (base)
  1: with_mock(`base::Sys.which` = function(...) {
         "im here"
     }, `binman::process_yaml` = function(...) {
     }, `binman::list_versions` = mock_binman_list_versions_selenium, expect_error(selenium(version = "nothere"), 
         "version requested doesnt match versions available")) at testthat/test-selenium.R:82
  2: extract_mocks(new_values = new_values[!code_pos], .env = .env, eval_env = parent.frame())
  3: lapply(stats::setNames(nm = mock_qual_names), function(qual_name) {
         pkg_name <- gsub(pkg_and_name_rx, "\\1", qual_name)
         if (is_base_pkg(pkg_name)) {
             stop("Can't mock functions in base packages (", pkg_name, ")", call. = FALSE)
         }
         name <- gsub(pkg_and_name_rx, "\\2", qual_name)
         if (pkg_name == "") 
             pkg_name <- .env
         env <- asNamespace(pkg_name)
         if (!exists(name, envir = env, mode = "function")) 
             stop("Function ", name, " not found in environment ", environmentName(env), 
                 ".", call. = FALSE)
         mock(name = name, env = env, new = eval(new_values[[qual_name]], eval_env, eval_env))
     })
  4: FUN(X[[i]], ...)
  5: stop("Can't mock functions in base packages (", pkg_name, ")", call. = FALSE)
  
  ── 16. Error: pickUpErrorFromReturnCode (@test-selenium.R#92)  ─────────────────
  Can't mock functions in base packages (base)
  1: with_mock(`binman::process_yaml` = function(...) {
     }, `binman::list_versions` = mock_binman_list_versions_selenium, `binman::app_dir` = mock_binman_app_dir, 
         `base::normalizePath` = mock_base_normalizePath, `base::list.files` = mock_base_list.files, 
         `subprocess::spawn_process` = mock_subprocess_spawn_process, `subprocess::process_return_code` = function(...) {
             "some error"
         }, `subprocess::process_read` = mock_subprocess_process_read_selenium, `wdman:::generic_start_log` = mock_generic_start_log, 
         `base::Sys.info` = function(...) {
             structure("Windows", .Names = "sysname")
         }, `wdman:::chrome_check` = function(...) {
             list(platform = "some.plat")
         }, `wdman:::chrome_ver` = function(...) {
             list(path = "some.path")
         }, `wdman:::gecko_check` = function(...) {
             list(platform = "some.plat")
         }, `wdman:::gecko_ver` = function(...) {
             list(path = "some.path")
         }, `wdman:::phantom_check` = function(...) {
             list(platform = "some.plat")
         }, `wdman:::phantom_ver` = function(...) {
             list(path = "some.path")
         }, `wdman:::ie_check` = function(...) {
             list(platform = "some.plat")
         }, `wdman:::ie_ver` = function(...) {
             list(path = "some.path")
         }, expect_error(selenium(version = "3.0.1", iedrver = "latest"), "Selenium server couldn't be started")) at testthat/test-selenium.R:92
  2: extract_mocks(new_values = new_values[!code_pos], .env = .env, eval_env = parent.frame())
  3: lapply(stats::setNames(nm = mock_qual_names), function(qual_name) {
         pkg_name <- gsub(pkg_and_name_rx, "\\1", qual_name)
         if (is_base_pkg(pkg_name)) {
             stop("Can't mock functions in base packages (", pkg_name, ")", call. = FALSE)
         }
         name <- gsub(pkg_and_name_rx, "\\2", qual_name)
         if (pkg_name == "") 
             pkg_name <- .env
         env <- asNamespace(pkg_name)
         if (!exists(name, envir = env, mode = "function")) 
             stop("Function ", name, " not found in environment ", environmentName(env), 
                 ".", call. = FALSE)
         mock(name = name, env = env, new = eval(new_values[[qual_name]], eval_env, eval_env))
     })
  4: FUN(X[[i]], ...)
  5: stop("Can't mock functions in base packages (", pkg_name, ")", call. = FALSE)
  
  ── 17. Error: pickUpErrorFromPortInUse (@test-selenium.R#140)  ─────────────────
  Can't mock functions in base packages (base)
  1: with_mock(`binman::process_yaml` = function(...) {
     }, `binman::list_versions` = mock_binman_list_versions_selenium, `binman::app_dir` = mock_binman_app_dir, 
         `base::normalizePath` = mock_base_normalizePath, `base::list.files` = mock_base_list.files, 
         `subprocess::spawn_process` = mock_subprocess_spawn_process, `subprocess::process_return_code` = mock_subprocess_process_return_code, 
         `subprocess::process_read` = mock_subprocess_process_read_selenium, `subprocess::process_kill` = mock_subprocess_process_kill, 
         `wdman:::generic_start_log` = function(...) {
             list(stderr = "Address already in use")
         }, `base::Sys.info` = function(...) {
             structure("Windows", .Names = "sysname")
         }, `wdman:::chrome_check` = function(...) {
             list(platform = "some.plat")
         }, `wdman:::chrome_ver` = function(...) {
             list(path = "some.path")
         }, `wdman:::gecko_check` = function(...) {
             list(platform = "some.plat")
         }, `wdman:::gecko_ver` = function(...) {
             list(path = "some.path")
         }, `wdman:::phantom_check` = function(...) {
             list(platform = "some.plat")
         }, `wdman:::phantom_ver` = function(...) {
             list(path = "some.path")
         }, `wdman:::ie_check` = function(...) {
             list(platform = "some.plat")
         }, `wdman:::ie_ver` = function(...) {
             list(path = "some.path")
         }, expect_error(selenium(), "Selenium server signals port")) at testthat/test-selenium.R:140
  2: extract_mocks(new_values = new_values[!code_pos], .env = .env, eval_env = parent.frame())
  3: lapply(stats::setNames(nm = mock_qual_names), function(qual_name) {
         pkg_name <- gsub(pkg_and_name_rx, "\\1", qual_name)
         if (is_base_pkg(pkg_name)) {
             stop("Can't mock functions in base packages (", pkg_name, ")", call. = FALSE)
         }
         name <- gsub(pkg_and_name_rx, "\\2", qual_name)
         if (pkg_name == "") 
             pkg_name <- .env
         env <- asNamespace(pkg_name)
         if (!exists(name, envir = env, mode = "function")) 
             stop("Function ", name, " not found in environment ", environmentName(env), 
                 ".", call. = FALSE)
         mock(name = name, env = env, new = eval(new_values[[qual_name]], eval_env, eval_env))
     })
  4: FUN(X[[i]], ...)
  5: stop("Can't mock functions in base packages (", pkg_name, ")", call. = FALSE)
  
  ── 18. Error: pickUpWarningOnNoStderr (@test-selenium.R#191)  ──────────────────
  Can't mock functions in base packages (base)
  1: with_mock(`binman::process_yaml` = function(...) {
     }, `binman::list_versions` = mock_binman_list_versions_selenium, `binman::app_dir` = mock_binman_app_dir, 
         `base::normalizePath` = mock_base_normalizePath, `base::list.files` = mock_base_list.files, 
         `subprocess::spawn_process` = mock_subprocess_spawn_process, `subprocess::process_return_code` = mock_subprocess_process_return_code, 
         `subprocess::process_read` = mock_subprocess_process_read_selenium, `wdman:::generic_start_log` = function(...) {
             list(stdout = character(), stderr = character())
         }, `base::Sys.info` = function(...) {
             structure("Windows", .Names = "sysname")
         }, `wdman:::chrome_check` = function(...) {
             list(platform = "some.plat")
         }, `wdman:::chrome_ver` = function(...) {
             list(path = "some.path")
         }, `wdman:::gecko_check` = function(...) {
             list(platform = "some.plat")
         }, `wdman:::gecko_ver` = function(...) {
             list(path = "some.path")
         }, `wdman:::phantom_check` = function(...) {
             list(platform = "some.plat")
         }, `wdman:::phantom_ver` = function(...) {
             list(path = "some.path")
         }, `wdman:::ie_check` = function(...) {
             list(platform = "some.plat")
         }, `wdman:::ie_ver` = function(...) {
             list(path = "some.path")
         }, expect_warning(selenium(), "No output to stderr yet detected")) at testthat/test-selenium.R:191
  2: extract_mocks(new_values = new_values[!code_pos], .env = .env, eval_env = parent.frame())
  3: lapply(stats::setNames(nm = mock_qual_names), function(qual_name) {
         pkg_name <- gsub(pkg_and_name_rx, "\\1", qual_name)
         if (is_base_pkg(pkg_name)) {
             stop("Can't mock functions in base packages (", pkg_name, ")", call. = FALSE)
         }
         name <- gsub(pkg_and_name_rx, "\\2", qual_name)
         if (pkg_name == "") 
             pkg_name <- .env
         env <- asNamespace(pkg_name)
         if (!exists(name, envir = env, mode = "function")) 
             stop("Function ", name, " not found in environment ", environmentName(env), 
                 ".", call. = FALSE)
         mock(name = name, env = env, new = eval(new_values[[qual_name]], eval_env, eval_env))
     })
  4: FUN(X[[i]], ...)
  5: stop("Can't mock functions in base packages (", pkg_name, ")", call. = FALSE)
  
  ══ testthat results  ═══════════════════════════════════════════════════════════
  OK: 26 SKIPPED: 0 FAILED: 18
  1. Error: canCallChrome (@test-chrome.R#3) 
  2. Error: pickUpErrorFromReturnCode (@test-chrome.R#43) 
  3. Error: pickUpErrorFromPortInUse (@test-chrome.R#62) 
  4. Error: canCallGecko (@test-gecko.R#4) 
  5. Error: pickUpErrorFromReturnCode (@test-gecko.R#44) 
  6. Error: pickUpErrorFromPortInUse (@test-gecko.R#63) 
  7. Error: canCallIEDriver (@test-iedriver.R#4) 
  8. Error: pickUpErrorFromReturnCode (@test-iedriver.R#46) 
  9. Error: pickUpErrorFromPortInUse (@test-iedriver.R#68) 
  1. ...
  
  Error: testthat unit tests failed
  Execution halted