tests/testthat/test-check_character.R

In OlinkAnalyze: Facilitate Analysis of Proteomic Data from Olink

# Test check_is_character ----

test_that(
  "check is character works - TRUE",
  {
    expect_true(
      object = check_is_character(x = "I_Shall_Pass",
                                  error = FALSE)
    )

    expect_true(
      object = check_is_character(x = "I_Shall_Pass",
                                  error = TRUE)
    )

    expect_true(
      object = check_is_character(x = c("I_Shall_Pass"),
                                  error = FALSE)
    )

    expect_true(
      object = check_is_character(x = c("I_Shall_Pass"),
                                  error = TRUE)
    )

    expect_true(
      object = check_is_character(x = c("I_Shall_Pass",
                                        NULL),
                                  error = FALSE)
    )

    expect_true(
      object = check_is_character(x = c("I_Shall_Pass",
                                        NULL),
                                  error = TRUE)
    )

    expect_true(
      object = check_is_character(x = c("I_Shall_Pass",
                                        "I_Shall_Not_Pass"),
                                  error = TRUE)
    )

    expect_true(
      object = check_is_character(x = c("I_Shall_Pass",
                                        "I_Shall_Not_Pass"),
                                  error = FALSE)
    )
  }
)

test_that(
  "check is character works - FALSE",
  {
    expect_false(
      object = check_is_character(x = c("I_Shall_Pass",
                                        NA_character_),
                                  error = FALSE)
    )

    expect_false(
      object = check_is_character(x = NA_character_,
                                  error = FALSE)
    )

    expect_false(
      object = check_is_character(x = NULL,
                                  error = FALSE)
    )

    expect_false(
      object = check_is_character(x = 1,
                                  error = FALSE)
    )

    expect_false(
      object = check_is_character(x = 1L,
                                  error = FALSE)
    )

    expect_false(
      object = check_is_character(x = TRUE,
                                  error = FALSE)
    )
  }
)

test_that(
  "check is character works - ERROR",
  {
    expect_error(
      object = check_is_character(x = c("I_Shall_Pass",
                                        NA_character_),
                                  error = TRUE),
      regexp = gsub(pattern = " ",
                    replacement = "([[:space:]].*|\\n.*)?",
                    x = "must be a character vector!",
                    fixed = TRUE)
    )

    expect_error(
      object = check_is_character(x = NA_character_,
                                  error = TRUE),
      regexp = gsub(pattern = " ",
                    replacement = "([[:space:]].*|\\n.*)?",
                    x = "must be a character vector!",
                    fixed = TRUE)
    )

    expect_error(
      object = check_is_character(x = NULL,
                                  error = TRUE),
      regexp = gsub(pattern = " ",
                    replacement = "([[:space:]].*|\\n.*)?",
                    x = "must be a character vector!",
                    fixed = TRUE)
    )

    expect_error(
      object = check_is_character(x = 1,
                                  error = TRUE),
      regexp = gsub(pattern = " ",
                    replacement = "([[:space:]].*|\\n.*)?",
                    x = "must be a character vector!",
                    fixed = TRUE)
    )

    expect_error(
      object = check_is_character(x = 1L,
                                  error = TRUE),
      regexp = gsub(pattern = " ",
                    replacement = "([[:space:]].*|\\n.*)?",
                    x = "must be a character vector!",
                    fixed = TRUE)
    )

    expect_error(
      object = check_is_character(x = TRUE,
                                  error = TRUE),
      regexp = gsub(pattern = " ",
                    replacement = "([[:space:]].*|\\n.*)?",
                    x = "must be a character vector!",
                    fixed = TRUE)
    )
  }
)

# Test check_is_scalar_character ----

test_that(
  "check is scalar character works - TRUE",
  {
    expect_true(
      object = check_is_scalar_character(x = "I_Shall_Pass",
                                         error = TRUE)
    )

    expect_true(
      object = check_is_scalar_character(x = "I_Shall_Pass",
                                         error = FALSE)
    )

    expect_true(
      object = check_is_scalar_character(x = c("I_Shall_Pass"),
                                         error = TRUE)
    )

    expect_true(
      object = check_is_scalar_character(x = c("I_Shall_Pass"),
                                         error = FALSE)
    )

    expect_true(
      object = check_is_scalar_character(x = c("I_Shall_Pass",
                                               NULL),
                                         error = TRUE)
    )

    expect_true(
      object = check_is_scalar_character(x = c("I_Shall_Pass",
                                               NULL),
                                         error = FALSE)
    )
  }
)

test_that(
  "check is scalar character works - FALSE",
  {
    expect_false(
      object = check_is_scalar_character(x = c("I_Shall_Pass",
                                               "I_Shall_Not_Pass"),
                                         error = FALSE)
    )

    expect_false(
      object = check_is_scalar_character(x = c("I_Shall_Pass",
                                               NA_character_),
                                         error = FALSE)
    )

    expect_false(
      object = check_is_scalar_character(x = NA_character_,
                                         error = FALSE)
    )

    expect_false(
      object = check_is_scalar_character(x = NULL,
                                         error = FALSE)
    )

    expect_false(
      object = check_is_scalar_character(x = 1,
                                         error = FALSE)
    )

    expect_false(
      object = check_is_scalar_character(x = 1L,
                                         error = FALSE)
    )

    expect_false(
      object = check_is_scalar_character(x = TRUE,
                                         error = FALSE)
    )
  }
)

test_that(
  "check is scalar character works - ERROR",
  {
    expect_error(
      object = check_is_scalar_character(x = c("I_Shall_Pass",
                                               "I_Shall_Not_Pass"),
                                         error = TRUE),
      regexp = gsub(pattern = " ",
                    replacement = "([[:space:]].*|\\n.*)?",
                    x = "must be a scalar character!",
                    fixed = TRUE)
    )

    expect_error(
      object = check_is_scalar_character(x = c("I_Shall_Pass",
                                               NA_character_),
                                         error = TRUE),
      regexp = gsub(pattern = " ",
                    replacement = "([[:space:]].*|\\n.*)?",
                    x = "must be a scalar character!",
                    fixed = TRUE)
    )

    expect_error(
      object = check_is_scalar_character(x = NA_character_,
                                         error = TRUE),
      regexp = gsub(pattern = " ",
                    replacement = "([[:space:]].*|\\n.*)?",
                    x = "must be a scalar character!",
                    fixed = TRUE)
    )

    expect_error(
      object = check_is_scalar_character(x = NULL,
                                         error = TRUE),
      regexp = gsub(pattern = " ",
                    replacement = "([[:space:]].*|\\n.*)?",
                    x = "must be a scalar character!",
                    fixed = TRUE)
    )

    expect_error(
      object = check_is_scalar_character(x = 1,
                                         error = TRUE),
      regexp = gsub(pattern = " ",
                    replacement = "([[:space:]].*|\\n.*)?",
                    x = "must be a scalar character!",
                    fixed = TRUE)
    )

    expect_error(
      object = check_is_scalar_character(x = 1L,
                                         error = TRUE),
      regexp = gsub(pattern = " ",
                    replacement = "([[:space:]].*|\\n.*)?",
                    x = "must be a scalar character!",
                    fixed = TRUE)
    )

    expect_error(
      object = check_is_scalar_character(x = TRUE,
                                         error = TRUE),
      regexp = gsub(pattern = " ",
                    replacement = "([[:space:]].*|\\n.*)?",
                    x = "must be a scalar character!",
                    fixed = TRUE)
    )
  }
)