Running 'testthat.R' [7s/8s]
Running the tests in 'tests/testthat.R' failed.
Complete output:
  > library(testthat)
  > library(ccdrAlgorithm)
  > 
  > test_check("ccdrAlgorithm")
  == Skipped tests ===============================================================
  * empty test (1)
  
  == Failed tests ================================================================
  -- Error (test-bwlist.R:47:5): Black lists work OK -----------------------------
  Error: Input matrix must be square!
  Backtrace:
       x
    1. \-ccdrAlgorithm::ccdr.run(sbdata, lambdas.length = nlambda, blacklist = blocks) test-bwlist.R:47:4
    2.   \-ccdrAlgorithm:::ccdr_call(...)
    3.     \-sparsebnUtils::as.edgeList(fit[[k]]$edges)
    4.       +-sparsebnUtils::edgeList(x)
    5.       \-ccdrAlgorithm:::edgeList.SparseBlockMatrixR(x)
    6.         +-sparsebnUtils::edgeList(el)
    7.         \-sparsebnUtils:::edgeList.matrix(el)
    8.           \-sparsebnUtils:::matrix_to_edgeList(x)
    9.             +-sparsebnUtils::edgeList(as.sparse(x))
   10.             \-sparsebnUtils::as.sparse(x)
   11.               +-sparsebnUtils::sparse(x, index = "R", ...)
   12.               \-sparsebnUtils:::sparse.matrix(x, index = "R", ...)
   13.                 \-sparsebnUtils:::matrix_to_sparse(x, index = "R", ...)
  -- Failure (test-ccdr_call.R:32:5): ccdr_call runs as expected -----------------
  `ccdr_call(...)` threw an error.
  Message: Input matrix must be square!
  Class:   simpleError/error/condition
  Backtrace:
       x
    1. +-testthat::expect_error(...) test-ccdr_call.R:32:4
    2. | \-testthat:::quasi_capture(...)
    3. |   +-testthat:::.capture(...)
    4. |   | \-base::withCallingHandlers(...)
    5. |   \-rlang::eval_bare(quo_get_expr(.quo), quo_get_env(.quo))
    6. \-ccdrAlgorithm:::ccdr_call(...)
    7.   \-sparsebnUtils::as.edgeList(fit[[k]]$edges)
    8.     +-sparsebnUtils::edgeList(x)
    9.     \-ccdrAlgorithm:::edgeList.SparseBlockMatrixR(x)
   10.       +-sparsebnUtils::edgeList(el)
   11.       \-sparsebnUtils:::edgeList.matrix(el)
   12.         \-sparsebnUtils:::matrix_to_edgeList(x)
   13.           +-sparsebnUtils::edgeList(as.sparse(x))
   14.           \-sparsebnUtils::as.sparse(x)
   15.             +-sparsebnUtils::sparse(x, index = "R", ...)
   16.             \-sparsebnUtils:::sparse.matrix(x, index = "R", ...)
   17.               \-sparsebnUtils:::matrix_to_sparse(x, index = "R", ...)
  -- Failure (test-ccdr_call.R:36:5): ccdr_call runs as expected -----------------
  `ccdr_call(...)` threw an error.
  Message: Input matrix must be square!
  Class:   simpleError/error/condition
  Backtrace:
       x
    1. +-testthat::expect_error(...) test-ccdr_call.R:36:4
    2. | \-testthat:::quasi_capture(...)
    3. |   +-testthat:::.capture(...)
    4. |   | \-base::withCallingHandlers(...)
    5. |   \-rlang::eval_bare(quo_get_expr(.quo), quo_get_env(.quo))
    6. \-ccdrAlgorithm:::ccdr_call(...)
    7.   \-sparsebnUtils::as.edgeList(fit[[k]]$edges)
    8.     +-sparsebnUtils::edgeList(x)
    9.     \-ccdrAlgorithm:::edgeList.SparseBlockMatrixR(x)
   10.       +-sparsebnUtils::edgeList(el)
   11.       \-sparsebnUtils:::edgeList.matrix(el)
   12.         \-sparsebnUtils:::matrix_to_edgeList(x)
   13.           +-sparsebnUtils::edgeList(as.sparse(x))
   14.           \-sparsebnUtils::as.sparse(x)
   15.             +-sparsebnUtils::sparse(x, index = "R", ...)
   16.             \-sparsebnUtils:::sparse.matrix(x, index = "R", ...)
   17.               \-sparsebnUtils:::matrix_to_sparse(x, index = "R", ...)
  -- Failure (test-ccdr_ivn.R:27:5): ccdr.run runs as expected -------------------
  `ccdr.run(data = dat.test, lambdas.length = lambdas.length.test)` threw an error.
  Message: Input matrix must be square!
  Class:   simpleError/error/condition
  Backtrace:
       x
    1. +-testthat::expect_error(...) test-ccdr_ivn.R:27:4
    2. | \-testthat:::quasi_capture(...)
    3. |   +-testthat:::.capture(...)
    4. |   | \-base::withCallingHandlers(...)
    5. |   \-rlang::eval_bare(quo_get_expr(.quo), quo_get_env(.quo))
    6. \-ccdrAlgorithm::ccdr.run(data = dat.test, lambdas.length = lambdas.length.test)
    7.   \-ccdrAlgorithm:::ccdr_call(...)
    8.     \-sparsebnUtils::as.edgeList(fit[[k]]$edges)
    9.       +-sparsebnUtils::edgeList(x)
   10.       \-ccdrAlgorithm:::edgeList.SparseBlockMatrixR(x)
   11.         +-sparsebnUtils::edgeList(el)
   12.         \-sparsebnUtils:::edgeList.matrix(el)
   13.           \-sparsebnUtils:::matrix_to_edgeList(x)
   14.             +-sparsebnUtils::edgeList(as.sparse(x))
   15.             \-sparsebnUtils::as.sparse(x)
   16.               +-sparsebnUtils::sparse(x, index = "R", ...)
   17.               \-sparsebnUtils:::sparse.matrix(x, index = "R", ...)
   18.                 \-sparsebnUtils:::matrix_to_sparse(x, index = "R", ...)
  -- Failure (test-ccdr_ivn.R:33:5): Check special case ivn = list(NULL, NULL, ...) --
  `ccdr.run(data = data.null, lambdas.length = lambdas.length.test)` threw an error.
  Message: Input matrix must be square!
  Class:   simpleError/error/condition
  Backtrace:
       x
    1. +-testthat::expect_error(...) test-ccdr_ivn.R:33:4
    2. | \-testthat:::quasi_capture(...)
    3. |   +-testthat:::.capture(...)
    4. |   | \-base::withCallingHandlers(...)
    5. |   \-rlang::eval_bare(quo_get_expr(.quo), quo_get_env(.quo))
    6. \-ccdrAlgorithm::ccdr.run(data = data.null, lambdas.length = lambdas.length.test)
    7.   \-ccdrAlgorithm:::ccdr_call(...)
    8.     \-sparsebnUtils::as.edgeList(fit[[k]]$edges)
    9.       +-sparsebnUtils::edgeList(x)
   10.       \-ccdrAlgorithm:::edgeList.SparseBlockMatrixR(x)
   11.         +-sparsebnUtils::edgeList(el)
   12.         \-sparsebnUtils:::edgeList.matrix(el)
   13.           \-sparsebnUtils:::matrix_to_edgeList(x)
   14.             +-sparsebnUtils::edgeList(as.sparse(x))
   15.             \-sparsebnUtils::as.sparse(x)
   16.               +-sparsebnUtils::sparse(x, index = "R", ...)
   17.               \-sparsebnUtils:::sparse.matrix(x, index = "R", ...)
   18.                 \-sparsebnUtils:::matrix_to_sparse(x, index = "R", ...)
  -- Failure (test-ccdr_ivn.R:85:5): Check input: lambdas ------------------------
  `ccdr.run(data = dat.test, lambdas = lambdas.test)` threw an error.
  Message: Input matrix must be square!
  Class:   simpleError/error/condition
  Backtrace:
       x
    1. +-testthat::expect_error(...) test-ccdr_ivn.R:85:4
    2. | \-testthat:::quasi_capture(...)
    3. |   +-testthat:::.capture(...)
    4. |   | \-base::withCallingHandlers(...)
    5. |   \-rlang::eval_bare(quo_get_expr(.quo), quo_get_env(.quo))
    6. \-ccdrAlgorithm::ccdr.run(data = dat.test, lambdas = lambdas.test)
    7.   \-ccdrAlgorithm:::ccdr_call(...)
    8.     \-sparsebnUtils::as.edgeList(fit[[k]]$edges)
    9.       +-sparsebnUtils::edgeList(x)
   10.       \-ccdrAlgorithm:::edgeList.SparseBlockMatrixR(x)
   11.         +-sparsebnUtils::edgeList(el)
   12.         \-sparsebnUtils:::edgeList.matrix(el)
   13.           \-sparsebnUtils:::matrix_to_edgeList(x)
   14.             +-sparsebnUtils::edgeList(as.sparse(x))
   15.             \-sparsebnUtils::as.sparse(x)
   16.               +-sparsebnUtils::sparse(x, index = "R", ...)
   17.               \-sparsebnUtils:::sparse.matrix(x, index = "R", ...)
   18.                 \-sparsebnUtils:::matrix_to_sparse(x, index = "R", ...)
  -- Error (test-ccdr_ivn.R:121:5): Check input: error.tol -----------------------
  Error: Input matrix must be square!
  Backtrace:
       x
    1. +-testthat::expect_warning(...) test-ccdr_ivn.R:121:4
    2. | \-testthat:::quasi_capture(enquo(object), label, capture_warnings)
    3. |   +-testthat:::.capture(...)
    4. |   | \-base::withCallingHandlers(...)
    5. |   \-rlang::eval_bare(quo_get_expr(.quo), quo_get_env(.quo))
    6. \-ccdrAlgorithm::ccdr.run(...)
    7.   \-ccdrAlgorithm:::ccdr_call(...)
    8.     \-sparsebnUtils::as.edgeList(fit[[k]]$edges)
    9.       +-sparsebnUtils::edgeList(x)
   10.       \-ccdrAlgorithm:::edgeList.SparseBlockMatrixR(x)
   11.         +-sparsebnUtils::edgeList(el)
   12.         \-sparsebnUtils:::edgeList.matrix(el)
   13.           \-sparsebnUtils:::matrix_to_edgeList(x)
   14.             +-sparsebnUtils::edgeList(as.sparse(x))
   15.             \-sparsebnUtils::as.sparse(x)
   16.               +-sparsebnUtils::sparse(x, index = "R", ...)
   17.               \-sparsebnUtils:::sparse.matrix(x, index = "R", ...)
   18.                 \-sparsebnUtils:::matrix_to_sparse(x, index = "R", ...)
  -- Failure (test-ccdr_ivn.R:126:5): Check input: gamma -------------------------
  `ccdr.run(...)` threw an error.
  Message: Input matrix must be square!
  Class:   simpleError/error/condition
  Backtrace:
       x
    1. +-testthat::expect_error(...) test-ccdr_ivn.R:126:4
    2. | \-testthat:::quasi_capture(...)
    3. |   +-testthat:::.capture(...)
    4. |   | \-base::withCallingHandlers(...)
    5. |   \-rlang::eval_bare(quo_get_expr(.quo), quo_get_env(.quo))
    6. \-ccdrAlgorithm::ccdr.run(...)
    7.   \-ccdrAlgorithm:::ccdr_call(...)
    8.     \-sparsebnUtils::as.edgeList(fit[[k]]$edges)
    9.       +-sparsebnUtils::edgeList(x)
   10.       \-ccdrAlgorithm:::edgeList.SparseBlockMatrixR(x)
   11.         +-sparsebnUtils::edgeList(el)
   12.         \-sparsebnUtils:::edgeList.matrix(el)
   13.           \-sparsebnUtils:::matrix_to_edgeList(x)
   14.             +-sparsebnUtils::edgeList(as.sparse(x))
   15.             \-sparsebnUtils::as.sparse(x)
   16.               +-sparsebnUtils::sparse(x, index = "R", ...)
   17.               \-sparsebnUtils:::sparse.matrix(x, index = "R", ...)
   18.                 \-sparsebnUtils:::matrix_to_sparse(x, index = "R", ...)
  -- Failure (test-ccdr_ivn.R:139:5): Check input: verbose -----------------------
  `ccdr.run(...)` threw an error.
  Message: Input matrix must be square!
  Class:   simpleError/error/condition
  Backtrace:
       x
    1. +-testthat::expect_error(...) test-ccdr_ivn.R:139:4
    2. | \-testthat:::quasi_capture(...)
    3. |   +-testthat:::.capture(...)
    4. |   | \-base::withCallingHandlers(...)
    5. |   \-rlang::eval_bare(quo_get_expr(.quo), quo_get_env(.quo))
    6. \-ccdrAlgorithm::ccdr.run(...)
    7.   \-ccdrAlgorithm:::ccdr_call(...)
    8.     \-sparsebnUtils::as.edgeList(fit[[k]]$edges)
    9.       +-sparsebnUtils::edgeList(x)
   10.       \-ccdrAlgorithm:::edgeList.SparseBlockMatrixR(x)
   11.         +-sparsebnUtils::edgeList(el)
   12.         \-sparsebnUtils:::edgeList.matrix(el)
   13.           \-sparsebnUtils:::matrix_to_edgeList(x)
   14.             +-sparsebnUtils::edgeList(as.sparse(x))
   15.             \-sparsebnUtils::as.sparse(x)
   16.               +-sparsebnUtils::sparse(x, index = "R", ...)
   17.               \-sparsebnUtils:::sparse.matrix(x, index = "R", ...)
   18.                 \-sparsebnUtils:::matrix_to_sparse(x, index = "R", ...)
  -- Failure (test-ccdr_ivn.R:142:5): Check input: verbose -----------------------
  `ccdr.run(...)` threw an error.
  Message: Input matrix must be square!
  Class:   simpleError/error/condition
  Backtrace:
       x
    1. +-testthat::expect_error(...) test-ccdr_ivn.R:142:4
    2. | \-testthat:::quasi_capture(...)
    3. |   +-testthat:::.capture(...)
    4. |   | \-base::withCallingHandlers(...)
    5. |   \-rlang::eval_bare(quo_get_expr(.quo), quo_get_env(.quo))
    6. \-ccdrAlgorithm::ccdr.run(...)
    7.   \-ccdrAlgorithm:::ccdr_call(...)
    8.     \-sparsebnUtils::as.edgeList(fit[[k]]$edges)
    9.       +-sparsebnUtils::edgeList(x)
   10.       \-ccdrAlgorithm:::edgeList.SparseBlockMatrixR(x)
   11.         +-sparsebnUtils::edgeList(el)
   12.         \-sparsebnUtils:::edgeList.matrix(el)
   13.           \-sparsebnUtils:::matrix_to_edgeList(x)
   14.             +-sparsebnUtils::edgeList(as.sparse(x))
   15.             \-sparsebnUtils::as.sparse(x)
   16.               +-sparsebnUtils::sparse(x, index = "R", ...)
   17.               \-sparsebnUtils:::sparse.matrix(x, index = "R", ...)
   18.                 \-sparsebnUtils:::matrix_to_sparse(x, index = "R", ...)
  -- Failure (test-ccdr_run.R:26:5): ccdr.run runs as expected -------------------
  `ccdr.run(data = dat.test, lambdas.length = lambdas.length.test)` threw an error.
  Message: Input matrix must be square!
  Class:   simpleError/error/condition
  Backtrace:
       x
    1. +-testthat::expect_error(...) test-ccdr_run.R:26:4
    2. | \-testthat:::quasi_capture(...)
    3. |   +-testthat:::.capture(...)
    4. |   | \-base::withCallingHandlers(...)
    5. |   \-rlang::eval_bare(quo_get_expr(.quo), quo_get_env(.quo))
    6. \-ccdrAlgorithm::ccdr.run(data = dat.test, lambdas.length = lambdas.length.test)
    7.   \-ccdrAlgorithm:::ccdr_call(...)
    8.     \-sparsebnUtils::as.edgeList(fit[[k]]$edges)
    9.       +-sparsebnUtils::edgeList(x)
   10.       \-ccdrAlgorithm:::edgeList.SparseBlockMatrixR(x)
   11.         +-sparsebnUtils::edgeList(el)
   12.         \-sparsebnUtils:::edgeList.matrix(el)
   13.           \-sparsebnUtils:::matrix_to_edgeList(x)
   14.             +-sparsebnUtils::edgeList(as.sparse(x))
   15.             \-sparsebnUtils::as.sparse(x)
   16.               +-sparsebnUtils::sparse(x, index = "R", ...)
   17.               \-sparsebnUtils:::sparse.matrix(x, index = "R", ...)
   18.                 \-sparsebnUtils:::matrix_to_sparse(x, index = "R", ...)
  -- Failure (test-ccdr_run.R:43:5): Check input: lambdas ------------------------
  `ccdr.run(data = dat.test, lambdas = lambdas.test)` threw an error.
  Message: Input matrix must be square!
  Class:   simpleError/error/condition
  Backtrace:
       x
    1. +-testthat::expect_error(...) test-ccdr_run.R:43:4
    2. | \-testthat:::quasi_capture(...)
    3. |   +-testthat:::.capture(...)
    4. |   | \-base::withCallingHandlers(...)
    5. |   \-rlang::eval_bare(quo_get_expr(.quo), quo_get_env(.quo))
    6. \-ccdrAlgorithm::ccdr.run(data = dat.test, lambdas = lambdas.test)
    7.   \-ccdrAlgorithm:::ccdr_call(...)
    8.     \-sparsebnUtils::as.edgeList(fit[[k]]$edges)
    9.       +-sparsebnUtils::edgeList(x)
   10.       \-ccdrAlgorithm:::edgeList.SparseBlockMatrixR(x)
   11.         +-sparsebnUtils::edgeList(el)
   12.         \-sparsebnUtils:::edgeList.matrix(el)
   13.           \-sparsebnUtils:::matrix_to_edgeList(x)
   14.             +-sparsebnUtils::edgeList(as.sparse(x))
   15.             \-sparsebnUtils::as.sparse(x)
   16.               +-sparsebnUtils::sparse(x, index = "R", ...)
   17.               \-sparsebnUtils:::sparse.matrix(x, index = "R", ...)
   18.                 \-sparsebnUtils:::matrix_to_sparse(x, index = "R", ...)
  -- Error (test-ccdr_run.R:79:5): Check input: error.tol ------------------------
  Error: Input matrix must be square!
  Backtrace:
       x
    1. +-testthat::expect_warning(...) test-ccdr_run.R:79:4
    2. | \-testthat:::quasi_capture(enquo(object), label, capture_warnings)
    3. |   +-testthat:::.capture(...)
    4. |   | \-base::withCallingHandlers(...)
    5. |   \-rlang::eval_bare(quo_get_expr(.quo), quo_get_env(.quo))
    6. \-ccdrAlgorithm::ccdr.run(...)
    7.   \-ccdrAlgorithm:::ccdr_call(...)
    8.     \-sparsebnUtils::as.edgeList(fit[[k]]$edges)
    9.       +-sparsebnUtils::edgeList(x)
   10.       \-ccdrAlgorithm:::edgeList.SparseBlockMatrixR(x)
   11.         +-sparsebnUtils::edgeList(el)
   12.         \-sparsebnUtils:::edgeList.matrix(el)
   13.           \-sparsebnUtils:::matrix_to_edgeList(x)
   14.             +-sparsebnUtils::edgeList(as.sparse(x))
   15.             \-sparsebnUtils::as.sparse(x)
   16.               +-sparsebnUtils::sparse(x, index = "R", ...)
   17.               \-sparsebnUtils:::sparse.matrix(x, index = "R", ...)
   18.                 \-sparsebnUtils:::matrix_to_sparse(x, index = "R", ...)
  -- Failure (test-ccdr_run.R:84:5): Check input: gamma --------------------------
  `ccdr.run(...)` threw an error.
  Message: Input matrix must be square!
  Class:   simpleError/error/condition
  Backtrace:
       x
    1. +-testthat::expect_error(...) test-ccdr_run.R:84:4
    2. | \-testthat:::quasi_capture(...)
    3. |   +-testthat:::.capture(...)
    4. |   | \-base::withCallingHandlers(...)
    5. |   \-rlang::eval_bare(quo_get_expr(.quo), quo_get_env(.quo))
    6. \-ccdrAlgorithm::ccdr.run(...)
    7.   \-ccdrAlgorithm:::ccdr_call(...)
    8.     \-sparsebnUtils::as.edgeList(fit[[k]]$edges)
    9.       +-sparsebnUtils::edgeList(x)
   10.       \-ccdrAlgorithm:::edgeList.SparseBlockMatrixR(x)
   11.         +-sparsebnUtils::edgeList(el)
   12.         \-sparsebnUtils:::edgeList.matrix(el)
   13.           \-sparsebnUtils:::matrix_to_edgeList(x)
   14.             +-sparsebnUtils::edgeList(as.sparse(x))
   15.             \-sparsebnUtils::as.sparse(x)
   16.               +-sparsebnUtils::sparse(x, index = "R", ...)
   17.               \-sparsebnUtils:::sparse.matrix(x, index = "R", ...)
   18.                 \-sparsebnUtils:::matrix_to_sparse(x, index = "R", ...)
  -- Failure (test-ccdr_run.R:97:5): Check input: verbose ------------------------
  `ccdr.run(...)` threw an error.
  Message: Input matrix must be square!
  Class:   simpleError/error/condition
  Backtrace:
       x
    1. +-testthat::expect_error(...) test-ccdr_run.R:97:4
    2. | \-testthat:::quasi_capture(...)
    3. |   +-testthat:::.capture(...)
    4. |   | \-base::withCallingHandlers(...)
    5. |   \-rlang::eval_bare(quo_get_expr(.quo), quo_get_env(.quo))
    6. \-ccdrAlgorithm::ccdr.run(...)
    7.   \-ccdrAlgorithm:::ccdr_call(...)
    8.     \-sparsebnUtils::as.edgeList(fit[[k]]$edges)
    9.       +-sparsebnUtils::edgeList(x)
   10.       \-ccdrAlgorithm:::edgeList.SparseBlockMatrixR(x)
   11.         +-sparsebnUtils::edgeList(el)
   12.         \-sparsebnUtils:::edgeList.matrix(el)
   13.           \-sparsebnUtils:::matrix_to_edgeList(x)
   14.             +-sparsebnUtils::edgeList(as.sparse(x))
   15.             \-sparsebnUtils::as.sparse(x)
   16.               +-sparsebnUtils::sparse(x, index = "R", ...)
   17.               \-sparsebnUtils:::sparse.matrix(x, index = "R", ...)
   18.                 \-sparsebnUtils:::matrix_to_sparse(x, index = "R", ...)
  -- Failure (test-ccdr_run.R:100:5): Check input: verbose -----------------------
  `ccdr.run(...)` threw an error.
  Message: Input matrix must be square!
  Class:   simpleError/error/condition
  Backtrace:
       x
    1. +-testthat::expect_error(...) test-ccdr_run.R:100:4
    2. | \-testthat:::quasi_capture(...)
    3. |   +-testthat:::.capture(...)
    4. |   | \-base::withCallingHandlers(...)
    5. |   \-rlang::eval_bare(quo_get_expr(.quo), quo_get_env(.quo))
    6. \-ccdrAlgorithm::ccdr.run(...)
    7.   \-ccdrAlgorithm:::ccdr_call(...)
    8.     \-sparsebnUtils::as.edgeList(fit[[k]]$edges)
    9.       +-sparsebnUtils::edgeList(x)
   10.       \-ccdrAlgorithm:::edgeList.SparseBlockMatrixR(x)
   11.         +-sparsebnUtils::edgeList(el)
   12.         \-sparsebnUtils:::edgeList.matrix(el)
   13.           \-sparsebnUtils:::matrix_to_edgeList(x)
   14.             +-sparsebnUtils::edgeList(as.sparse(x))
   15.             \-sparsebnUtils::as.sparse(x)
   16.               +-sparsebnUtils::sparse(x, index = "R", ...)
   17.               \-sparsebnUtils:::sparse.matrix(x, index = "R", ...)
   18.                 \-sparsebnUtils:::matrix_to_sparse(x, index = "R", ...)
  -- Error (test-default_run.R:12:5): Testing default behaviour of ccdr.run ------
  Error: Input matrix must be square!
  Backtrace:
       x
    1. \-ccdrAlgorithm::ccdr.run(data = data, lambdas.length = 20) test-default_run.R:12:4
    2.   \-ccdrAlgorithm:::ccdr_call(...)
    3.     \-sparsebnUtils::as.edgeList(fit[[k]]$edges)
    4.       +-sparsebnUtils::edgeList(x)
    5.       \-ccdrAlgorithm:::edgeList.SparseBlockMatrixR(x)
    6.         +-sparsebnUtils::edgeList(el)
    7.         \-sparsebnUtils:::edgeList.matrix(el)
    8.           \-sparsebnUtils:::matrix_to_edgeList(x)
    9.             +-sparsebnUtils::edgeList(as.sparse(x))
   10.             \-sparsebnUtils::as.sparse(x)
   11.               +-sparsebnUtils::sparse(x, index = "R", ...)
   12.               \-sparsebnUtils:::sparse.matrix(x, index = "R", ...)
   13.                 \-sparsebnUtils:::matrix_to_sparse(x, index = "R", ...)
  -- Error (test-default_run.R:33:5): Testing ccdr.run with manual settings ------
  Error: Input matrix must be square!
  Backtrace:
       x
    1. \-ccdrAlgorithm::ccdr.run(...) test-default_run.R:33:4
    2.   \-ccdrAlgorithm:::ccdr_call(...)
    3.     \-sparsebnUtils::as.edgeList(fit[[k]]$edges)
    4.       +-sparsebnUtils::edgeList(x)
    5.       \-ccdrAlgorithm:::edgeList.SparseBlockMatrixR(x)
    6.         +-sparsebnUtils::edgeList(el)
    7.         \-sparsebnUtils:::edgeList.matrix(el)
    8.           \-sparsebnUtils:::matrix_to_edgeList(x)
    9.             +-sparsebnUtils::edgeList(as.sparse(x))
   10.             \-sparsebnUtils::as.sparse(x)
   11.               +-sparsebnUtils::sparse(x, index = "R", ...)
   12.               \-sparsebnUtils:::sparse.matrix(x, index = "R", ...)
   13.                 \-sparsebnUtils:::matrix_to_sparse(x, index = "R", ...)
  -- Error (test-default_run.R:54:5): Bugfix: ccdr.run returns the correct number of solutions --
  Error: Input matrix must be square!
  Backtrace:
       x
    1. \-ccdrAlgorithm::ccdr.run(data = data, lambdas.length = 5) test-default_run.R:54:4
    2.   \-ccdrAlgorithm:::ccdr_call(...)
    3.     \-sparsebnUtils::as.edgeList(fit[[k]]$edges)
    4.       +-sparsebnUtils::edgeList(x)
    5.       \-ccdrAlgorithm:::edgeList.SparseBlockMatrixR(x)
    6.         +-sparsebnUtils::edgeList(el)
    7.         \-sparsebnUtils:::edgeList.matrix(el)
    8.           \-sparsebnUtils:::matrix_to_edgeList(x)
    9.             +-sparsebnUtils::edgeList(as.sparse(x))
   10.             \-sparsebnUtils::as.sparse(x)
   11.               +-sparsebnUtils::sparse(x, index = "R", ...)
   12.               \-sparsebnUtils:::sparse.matrix(x, index = "R", ...)
   13.                 \-sparsebnUtils:::matrix_to_sparse(x, index = "R", ...)
  -- Error (test-default_run.R:67:5): ccdr.run with intervention, case 1: --------
  Error: Input matrix must be square!
  Backtrace:
       x
    1. \-ccdrAlgorithm::ccdr.run(data = data.ivn, lambdas.length = 10) test-default_run.R:67:4
    2.   \-ccdrAlgorithm:::ccdr_call(...)
    3.     \-sparsebnUtils::as.edgeList(fit[[k]]$edges)
    4.       +-sparsebnUtils::edgeList(x)
    5.       \-ccdrAlgorithm:::edgeList.SparseBlockMatrixR(x)
    6.         +-sparsebnUtils::edgeList(el)
    7.         \-sparsebnUtils:::edgeList.matrix(el)
    8.           \-sparsebnUtils:::matrix_to_edgeList(x)
    9.             +-sparsebnUtils::edgeList(as.sparse(x))
   10.             \-sparsebnUtils::as.sparse(x)
   11.               +-sparsebnUtils::sparse(x, index = "R", ...)
   12.               \-sparsebnUtils:::sparse.matrix(x, index = "R", ...)
   13.                 \-sparsebnUtils:::matrix_to_sparse(x, index = "R", ...)
  -- Error (test-default_run.R:87:5): Testing ccdr.run with intervention using manual settings --
  Error: Input matrix must be square!
  Backtrace:
       x
    1. \-ccdrAlgorithm::ccdr.run(...) test-default_run.R:87:4
    2.   \-ccdrAlgorithm:::ccdr_call(...)
    3.     \-sparsebnUtils::as.edgeList(fit[[k]]$edges)
    4.       +-sparsebnUtils::edgeList(x)
    5.       \-ccdrAlgorithm:::edgeList.SparseBlockMatrixR(x)
    6.         +-sparsebnUtils::edgeList(el)
    7.         \-sparsebnUtils:::edgeList.matrix(el)
    8.           \-sparsebnUtils:::matrix_to_edgeList(x)
    9.             +-sparsebnUtils::edgeList(as.sparse(x))
   10.             \-sparsebnUtils::as.sparse(x)
   11.               +-sparsebnUtils::sparse(x, index = "R", ...)
   12.               \-sparsebnUtils:::sparse.matrix(x, index = "R", ...)
   13.                 \-sparsebnUtils:::matrix_to_sparse(x, index = "R", ...)
  -- Error (test-default_run.R:108:5): Bugfix: ccdr.run returns the correct number of solutions --
  Error: Input matrix must be square!
  Backtrace:
       x
    1. \-ccdrAlgorithm::ccdr.run(data = data, lambdas.length = 5) test-default_run.R:108:4
    2.   \-ccdrAlgorithm:::ccdr_call(...)
    3.     \-sparsebnUtils::as.edgeList(fit[[k]]$edges)
    4.       +-sparsebnUtils::edgeList(x)
    5.       \-ccdrAlgorithm:::edgeList.SparseBlockMatrixR(x)
    6.         +-sparsebnUtils::edgeList(el)
    7.         \-sparsebnUtils:::edgeList.matrix(el)
    8.           \-sparsebnUtils:::matrix_to_edgeList(x)
    9.             +-sparsebnUtils::edgeList(as.sparse(x))
   10.             \-sparsebnUtils::as.sparse(x)
   11.               +-sparsebnUtils::sparse(x, index = "R", ...)
   12.               \-sparsebnUtils:::sparse.matrix(x, index = "R", ...)
   13.                 \-sparsebnUtils:::matrix_to_sparse(x, index = "R", ...)
  -- Error (test-get_adjacency_matrix.R:7:5): get.adjacency.matrix works on empty graphs --
  Error: Input matrix must be square!
  Backtrace:
       x
    1. +-testthat::expect_equivalent(...) test-get_adjacency_matrix.R:7:4
    2. | \-testthat::quasi_label(enquo(object), label, arg = "object")
    3. |   \-rlang::eval_bare(expr, quo_get_env(quo))
    4. +-base::as.matrix(get.adjacency.matrix(sbm))
    5. +-sparsebnUtils::get.adjacency.matrix(sbm)
    6. \-ccdrAlgorithm:::get.adjacency.matrix.SparseBlockMatrixR(sbm)
    7.   +-sparsebnUtils::get.adjacency.matrix(sparsebnUtils::as.edgeList(x))
    8.   \-sparsebnUtils::as.edgeList(x)
    9.     +-sparsebnUtils::edgeList(x)
   10.     \-ccdrAlgorithm:::edgeList.SparseBlockMatrixR(x)
   11.       +-sparsebnUtils::edgeList(el)
   12.       \-sparsebnUtils:::edgeList.matrix(el)
   13.         \-sparsebnUtils:::matrix_to_edgeList(x)
   14.           +-sparsebnUtils::edgeList(as.sparse(x))
   15.           \-sparsebnUtils::as.sparse(x)
   16.             +-sparsebnUtils::sparse(x, index = "R", ...)
   17.             \-sparsebnUtils:::sparse.matrix(x, index = "R", ...)
   18.               \-sparsebnUtils:::matrix_to_sparse(x, index = "R", ...)
  -- Error (test-num_edges.R:5:5): num.edges works on SBM ------------------------
  Error: Input matrix must be square!
  Backtrace:
       x
    1. +-testthat::expect_equal(...) test-num_edges.R:5:4
    2. | \-testthat::quasi_label(enquo(object), label, arg = "object")
    3. |   \-rlang::eval_bare(expr, quo_get_env(quo))
    4. +-sparsebnUtils::num.edges(generate_empty_SparseBlockMatrixR())
    5. \-ccdrAlgorithm:::num.edges.SparseBlockMatrixR(generate_empty_SparseBlockMatrixR())
    6.   +-sparsebnUtils::num.edges(sparsebnUtils::as.edgeList(x))
    7.   \-sparsebnUtils::as.edgeList(x)
    8.     +-sparsebnUtils::edgeList(x)
    9.     \-ccdrAlgorithm:::edgeList.SparseBlockMatrixR(x)
   10.       +-sparsebnUtils::edgeList(el)
   11.       \-sparsebnUtils:::edgeList.matrix(el)
   12.         \-sparsebnUtils:::matrix_to_edgeList(x)
   13.           +-sparsebnUtils::edgeList(as.sparse(x))
   14.           \-sparsebnUtils::as.sparse(x)
   15.             +-sparsebnUtils::sparse(x, index = "R", ...)
   16.             \-sparsebnUtils:::sparse.matrix(x, index = "R", ...)
   17.               \-sparsebnUtils:::matrix_to_sparse(x, index = "R", ...)
  -- Error (test-s3_as.R:104:5): as.SparseBlockMatrixR -> as.edgeList -> as.matrix makes no changes --
  Error: Input matrix must be square!
  Backtrace:
       x
    1. +-base::as.matrix(sparsebnUtils::as.edgeList(sbm)) test-s3_as.R:104:4
    2. \-sparsebnUtils::as.edgeList(sbm)
    3.   +-sparsebnUtils::edgeList(x)
    4.   \-ccdrAlgorithm:::edgeList.SparseBlockMatrixR(x)
    5.     +-sparsebnUtils::edgeList(el)
    6.     \-sparsebnUtils:::edgeList.matrix(el)
    7.       \-sparsebnUtils:::matrix_to_edgeList(x)
    8.         +-sparsebnUtils::edgeList(as.sparse(x))
    9.         \-sparsebnUtils::as.sparse(x)
   10.           +-sparsebnUtils::sparse(x, index = "R", ...)
   11.           \-sparsebnUtils:::sparse.matrix(x, index = "R", ...)
   12.             \-sparsebnUtils:::matrix_to_sparse(x, index = "R", ...)
  -- Error (test-sigmas.R:8:5): Output is the same when sigmas is specified manually --
  Error: Input matrix must be square!
  Backtrace:
       x
    1. \-ccdrAlgorithm::ccdr.run(sbdata, lambdas.length = 20) test-sigmas.R:8:4
    2.   \-ccdrAlgorithm:::ccdr_call(...)
    3.     \-sparsebnUtils::as.edgeList(fit[[k]]$edges)
    4.       +-sparsebnUtils::edgeList(x)
    5.       \-ccdrAlgorithm:::edgeList.SparseBlockMatrixR(x)
    6.         +-sparsebnUtils::edgeList(el)
    7.         \-sparsebnUtils:::edgeList.matrix(el)
    8.           \-sparsebnUtils:::matrix_to_edgeList(x)
    9.             +-sparsebnUtils::edgeList(as.sparse(x))
   10.             \-sparsebnUtils::as.sparse(x)
   11.               +-sparsebnUtils::sparse(x, index = "R", ...)
   12.               \-sparsebnUtils:::sparse.matrix(x, index = "R", ...)
   13.                 \-sparsebnUtils:::matrix_to_sparse(x, index = "R", ...)
  -- Failure (test-sigmas.R:19:5): Setting sigmas works without error ------------
  `ccdr.run(sbdata, lambdas.length = 20, sigmas = rep(1, ncol(dat)))` threw an error.
  Message: Input matrix must be square!
  Class:   simpleError/error/condition
  Backtrace:
       x
    1. +-testthat::expect_error(...) test-sigmas.R:19:4
    2. | \-testthat:::quasi_capture(...)
    3. |   +-testthat:::.capture(...)
    4. |   | \-base::withCallingHandlers(...)
    5. |   \-rlang::eval_bare(quo_get_expr(.quo), quo_get_env(.quo))
    6. \-ccdrAlgorithm::ccdr.run(...)
    7.   \-ccdrAlgorithm:::ccdr_call(...)
    8.     \-sparsebnUtils::as.edgeList(fit[[k]]$edges)
    9.       +-sparsebnUtils::edgeList(x)
   10.       \-ccdrAlgorithm:::edgeList.SparseBlockMatrixR(x)
   11.         +-sparsebnUtils::edgeList(el)
   12.         \-sparsebnUtils:::edgeList.matrix(el)
   13.           \-sparsebnUtils:::matrix_to_edgeList(x)
   14.             +-sparsebnUtils::edgeList(as.sparse(x))
   15.             \-sparsebnUtils::as.sparse(x)
   16.               +-sparsebnUtils::sparse(x, index = "R", ...)
   17.               \-sparsebnUtils:::sparse.matrix(x, index = "R", ...)
   18.                 \-sparsebnUtils:::matrix_to_sparse(x, index = "R", ...)
  -- Failure (test-sigmas.R:23:5): Setting sigmas works without error ------------
  `ccdr.run(sbdata, lambdas.length = 20, sigmas = runif(pp))` threw an error.
  Message: Input matrix must be square!
  Class:   simpleError/error/condition
  Backtrace:
       x
    1. +-testthat::expect_error(...) test-sigmas.R:23:4
    2. | \-testthat:::quasi_capture(...)
    3. |   +-testthat:::.capture(...)
    4. |   | \-base::withCallingHandlers(...)
    5. |   \-rlang::eval_bare(quo_get_expr(.quo), quo_get_env(.quo))
    6. \-ccdrAlgorithm::ccdr.run(sbdata, lambdas.length = 20, sigmas = runif(pp))
    7.   \-ccdrAlgorithm:::ccdr_call(...)
    8.     \-sparsebnUtils::as.edgeList(fit[[k]]$edges)
    9.       +-sparsebnUtils::edgeList(x)
   10.       \-ccdrAlgorithm:::edgeList.SparseBlockMatrixR(x)
   11.         +-sparsebnUtils::edgeList(el)
   12.         \-sparsebnUtils:::edgeList.matrix(el)
   13.           \-sparsebnUtils:::matrix_to_edgeList(x)
   14.             +-sparsebnUtils::edgeList(as.sparse(x))
   15.             \-sparsebnUtils::as.sparse(x)
   16.               +-sparsebnUtils::sparse(x, index = "R", ...)
   17.               \-sparsebnUtils:::sparse.matrix(x, index = "R", ...)
   18.                 \-sparsebnUtils:::matrix_to_sparse(x, index = "R", ...)
  -- Error (test-test_cases.R:31:9): If cors = 0 and betas = 0, ouput should be all zeroes (low-dim) --
  Error: Input matrix must be square!
  Backtrace:
       x
    1. +-testthat::expect_true(...) test-test_cases.R:31:8
    2. | \-testthat::quasi_label(enquo(object), label, arg = "object")
    3. |   \-rlang::eval_bare(expr, quo_get_env(quo))
    4. +-sparsebnUtils::get.adjacency.matrix(final[[k]]$sbm)
    5. \-ccdrAlgorithm:::get.adjacency.matrix.SparseBlockMatrixR(final[[k]]$sbm)
    6.   +-sparsebnUtils::get.adjacency.matrix(sparsebnUtils::as.edgeList(x))
    7.   \-sparsebnUtils::as.edgeList(x)
    8.     +-sparsebnUtils::edgeList(x)
    9.     \-ccdrAlgorithm:::edgeList.SparseBlockMatrixR(x)
   10.       +-sparsebnUtils::edgeList(el)
   11.       \-sparsebnUtils:::edgeList.matrix(el)
   12.         \-sparsebnUtils:::matrix_to_edgeList(x)
   13.           +-sparsebnUtils::edgeList(as.sparse(x))
   14.           \-sparsebnUtils::as.sparse(x)
   15.             +-sparsebnUtils::sparse(x, index = "R", ...)
   16.             \-sparsebnUtils:::sparse.matrix(x, index = "R", ...)
   17.               \-sparsebnUtils:::matrix_to_sparse(x, index = "R", ...)
  -- Error (test-test_cases.R:57:9): If cors = 0 and betas = 0, ouput should be all zeroes (high-dim) --
  Error: Input matrix must be square!
  Backtrace:
       x
    1. +-testthat::expect_true(...) test-test_cases.R:57:8
    2. | \-testthat::quasi_label(enquo(object), label, arg = "object")
    3. |   \-rlang::eval_bare(expr, quo_get_env(quo))
    4. +-sparsebnUtils::get.adjacency.matrix(final[[k]]$sbm)
    5. \-ccdrAlgorithm:::get.adjacency.matrix.SparseBlockMatrixR(final[[k]]$sbm)
    6.   +-sparsebnUtils::get.adjacency.matrix(sparsebnUtils::as.edgeList(x))
    7.   \-sparsebnUtils::as.edgeList(x)
    8.     +-sparsebnUtils::edgeList(x)
    9.     \-ccdrAlgorithm:::edgeList.SparseBlockMatrixR(x)
   10.       +-sparsebnUtils::edgeList(el)
   11.       \-sparsebnUtils:::edgeList.matrix(el)
   12.         \-sparsebnUtils:::matrix_to_edgeList(x)
   13.           +-sparsebnUtils::edgeList(as.sparse(x))
   14.           \-sparsebnUtils::as.sparse(x)
   15.             +-sparsebnUtils::sparse(x, index = "R", ...)
   16.             \-sparsebnUtils:::sparse.matrix(x, index = "R", ...)
   17.               \-sparsebnUtils:::matrix_to_sparse(x, index = "R", ...)
  
  [ FAIL 30 | WARN 0 | SKIP 1 | PASS 115 ]
  Error: Test failures
  Execution halted