**Logical indexing** allows you to filter rows of a data frame based on **conditions**. Instead of remembering row numbers, you specify logical expressions, and only rows where the condition is `TRUE` are returned.

name <- c("Alex", "Julia", "Finn")
age <- c(24, 43, 32)
gender <- c("M", "F", "M")
test <- data.frame(name, age, gender)

# People older than 30
test[test$age > 30, ]
# Males only
test[test$gender == 'M', ]

The condition should be placed in the row index position inside square brackets (`[condition, ]`).

# =====================================================================
# СКРЫТЫЕ ТЕСТЫ ДЛЯ user_code.R
#
# КАК МЫ РАБОТАЕМ:
#  1) Виконуємо user_code.R, отримуємо res$logs
#  2) Кожний CASE — окремий dynamic_test(...)
# =====================================================================

library(testthat)
source(testthat::test_path("helper-run_user_code.R"), local = TRUE)

# Ідентифікація файлу користувача
candidates <- c(
  testthat::test_path("..", "..", "user_code.R"),
  testthat::test_path("user_code.R")
)
user_file <- candidates[file.exists(candidates)][1]
if (is.na(user_file)) stop("user_code.R not found")

# Виконання коду з обмеженням обсягу виводу
logs_full <- utils::capture.output(source(user_file, echo = FALSE, print.eval = TRUE))
out <- trimws(substr(paste(logs_full, collapse = " "), 1, 1000))  # максимум 1000 символів

# ---------- CASE 1 ----------
{
  fastest <- mtcars[mtcars$qsec < 16, ]
  ok <- all(rownames(fastest) %in% c("Duster 360", "Camaro Z28", "Ford Pantera L", "Ferrari Dino", "Maserati Bora"))

  dynamic_test(
    ok,
    "Filtering mtcars[qsec < 16] returns correct rows (fastest cars)",
    sprintf("Expected rows: Duster 360, Camaro Z28, Ford Pantera L, Ferrari Dino, Maserati Bora. Got: %s",
            paste(rownames(fastest), collapse = ", "))
  )
}

# ---------- CASE 2 ----------
{
  six_cyl <- mtcars[mtcars$cyl == 6, ]
  ok <- all(rownames(six_cyl) %in% c("Mazda RX4", "Mazda RX4 Wag", "Hornet 4 Drive",
                                     "Valiant", "Merc 280", "Merc 280C", "Ferrari Dino"))

  dynamic_test(
    ok,
    "Filtering mtcars[cyl == 6] returns correct rows (6-cylinder cars)",
    sprintf("Expected 7 rows: Mazda RX4, Mazda RX4 Wag, Hornet 4 Drive, Valiant, Merc 280, Merc 280C, Ferrari Dino. Got: %s",
            paste(rownames(six_cyl), collapse = ", "))
  )
}

# ---------- CASE 3 ----------
{
  ok <- grepl("Duster 360", out) &&
        grepl("Camaro Z28", out) &&
        grepl("Ferrari Dino", out) &&
        grepl("Mazda RX4", out) &&
        grepl("Hornet 4 Drive", out) &&
        grepl("Valiant", out)

  dynamic_test(
    ok,
    "Console output contains names of fastest and 6-cylinder cars",
    sprintf("Expected output to include Duster 360, Camaro Z28, Ferrari Dino, Mazda RX4, Hornet 4 Drive, Valiant. Actual (first 300 chars): %s",
            substr(out, 1, 300))
  )
}

# ---------- CASE 4 ----------
{
  # розділяємо аутпут на два датафрейми по повторному заголовку
  parts <- strsplit(out, "mpg cyl disp hp drat wt qsec vs am gear carb")[[1]]
  part1 <- if (length(parts) >= 2) parts[2] else out
  part2 <- if (length(parts) >= 3) parts[3] else out

  # перевіряємо, що у першій частині (fastest cars) є типові моделі
  fast_ok <- grepl("Duster 360", part1) &&
             grepl("Camaro Z28", part1) &&
             grepl("Ford Pantera L", part1) &&
             grepl("Ferrari Dino", part1) &&
             grepl("Maserati Bora", part1)

  # перевіряємо, що у другій частині (6 cylinders) є типові моделі
  cyl6_ok <- grepl("Mazda RX4", part2) &&
             grepl("Mazda RX4 Wag", part2) &&
             grepl("Hornet 4 Drive", part2) &&
             grepl("Valiant", part2) &&
             grepl("Merc 280", part2) &&
             grepl("Merc 280C", part2) &&
             grepl("Ferrari Dino", part2)

  ok <- fast_ok && cyl6_ok

  dynamic_test(
    ok,
    "Console output contains both filtered data frames with correct car names",
    sprintf("Expected first output to include Duster 360... and second to include Mazda RX4... Actual (first 400 chars): %s",
            substr(out, 1, 400))
  )
}


test_hidden.R

# =====================================================================
# ВСПОМОГАТЕЛЬНЫЕ ХЕЛПЕРЫ ДЛЯ ТЕСТОВ
#
# Файл называется helper-*.R: testthat автоматически подхватывает такие
# файлы перед выполнением любых тестов в каталоге tests/testthat.
# =====================================================================

# -----------------------------------------------------------------------------
# run_user_code(...)
#  - безопасно запускает user_code.R в отдельном окружении (env)
#  - перехватывает ВЕСЬ вывод (stdout): как результаты выражений, так и print()/cat()
#  - возвращает:
#       values  — список запрошенных переменных (по именам из аргумента capture)
#       logs    — вектор строк перехваченного вывода
#       env     — окружение, где выполнялся user_code (можно исследовать при необходимости)
#
# ПАРАМЕТРЫ:
#   file        — путь к user_code.R
#   capture     — character-вектор имён переменных, которые нужно извлечь после выполнения
#   inject      — список объектов/функций, которые нужно «подложить» в среду исполнения
#                 (можно использовать для моков/маскировки опасных функций: system, file.remove и т.д.)
#   echo        — печатать код при исполнении (обычно FALSE)
#   print.eval  — ПЕЧАТАТЬ РЕЗУЛЬТАТЫ ВЫРАЖЕНИЙ. Ключевая опция, чтобы строки вида
#                 `prices['Armchair']` попадали в stdout без явного print().
#
# БЕЗОПАСНОСТЬ:
#   - В базовом R нет полноценной «песочницы». Мы изолируем код в новом env,
#     но ОС-доступ не блокируется магически.
#   - Для задач онлайн-платформы можно частично «глушить» опасные вызовы через inject,
#     например:
#       inject = list(
#         system      = function(...) stop("system disabled"),
#         file.remove = function(...) stop("file.remove disabled")
#       )
# -----------------------------------------------------------------------------
run_user_code <- function(
  file = "user_code.R",
  capture = character(0),
  inject = list(),
  echo = FALSE,
  print.eval = TRUE
) {
  # Бросаем явную ошибку, если файла нет (проще диагностировать)
  stopifnot(file.exists(file))

  # Изолированное окружение: parent=baseenv() (без лишних пользовательских объектов сверху)
  env <- new.env(parent = baseenv())

  # Подмешиваем моки/данные в окружение (при необходимости)
  if (length(inject)) list2env(inject, envir = env)

  # ВАЖНО: перехватываем весь вывод выполнения файла.
  # source(..., local=env, echo, print.eval) исполняет код ВНУТРИ env.
  # print.eval=TRUE заставляет R печатать результаты выражений (как в консоли),
  # что позволяет проверять «голые» выражения без print().
  logs <- utils::capture.output(
    base::source(file, local = env, echo = echo, print.eval = print.eval)
  )

  # Собираем запрошенные значения переменных
  values <- setNames(vector("list", length(capture)), capture)
  for (nm in capture) {
    if (exists(nm, envir = env, inherits = FALSE)) {
      values[[nm]] <- get(nm, envir = env, inherits = FALSE)
    } else {
      values[[nm]] <- NULL
    }
  }

  list(values = values, logs = logs, env = env)
}

# -----------------------------------------------------------------------------
# dynamic_test(condition, success, failure)
#  - Создаёт ОДИН тест с «динамическим» названием.
#  - Если condition=TRUE → тест называется success.
#  - Если condition=FALSE → тест называется failure, и тест проваливается.
#  - Используем настоящую expectation (expect_true(TRUE)), чтобы репортёры всегда
#    печатали имя успеха (TAP, progress и т.д.).
# -----------------------------------------------------------------------------
dynamic_test <- function(condition, success, failure) {
  if (isTRUE(condition)) {
    testthat::test_that(success, {
      testthat::expect_true(TRUE)
    })
  } else {
    testthat::test_that(failure, {
      testthat::fail(failure)
    })
  }
}
# =====================================================================

helper-run_user_code.R

Structure multidimensional information by constructing mathematical matrices, organizing tabular dataframes, building hierarchical lists, ultimately extracting specific elements utilizing precise indexing.

Logical Indexing

Example

Lösung