Nothing
# Regression tests for the 2026-09-24 package re-evaluation, Section A
# (statistical silent-wrong defects A1-A12). Every test_that() description
# is prefixed with its item id. Each test FAILS on HEAD 92a1882 (pre-fix)
# for the reason described in its comment, and passes after the fix.
# --- Shared fixture helper -------------------------------------------------
# Builds a multi-event data_tbl + list-mock model_tbl pair, directly usable
# with `SomeTest$new()$compute(data_tbl, model_tbl)` (the pattern used by the
# 2026-09-24 audit repro scripts). `model` list elements are plain lists
# (list(statistics = list(...))), NOT ModelBase R6 instances -- matching the
# audit's a_funcs.R fixture pattern.
.me_fixture <- function(event_ids, firm_symbols = NULL, n_est = 30,
event_window = -5:5, seed = 1001,
sigma_by_event = NULL, n_params_by_event = NULL,
all_na_event_ids = integer(0), ar_gen = NULL) {
set.seed(seed)
if (is.null(firm_symbols)) firm_symbols <- paste0("F", event_ids)
n_ew <- length(event_window)
data_tbl <- purrr::map2_dfr(event_ids, firm_symbols, function(eid, fs) {
est_idx <- seq(-(n_est + 5), -6)
if (!is.null(ar_gen)) {
vals <- ar_gen(eid)
ar_est <- vals$est
ar_evt <- vals$evt
} else {
ar_est <- rnorm(n_est, sd = 0.01)
ar_evt <- rnorm(n_ew, sd = 0.01)
}
if (eid %in% all_na_event_ids) ar_evt <- rep(NA_real_, n_ew)
tibble::tibble(
event_id = eid, firm_symbol = fs, group = "g",
relative_index = c(est_idx, event_window),
estimation_window = c(rep(1L, n_est), rep(0L, n_ew)),
event_window = c(rep(0L, n_est), rep(1L, n_ew)),
abnormal_returns = c(ar_est, ar_evt)
)
})
model_tbl <- tibble::tibble(
event_id = event_ids,
model = purrr::map(event_ids, function(eid) {
sg <- if (!is.null(sigma_by_event)) sigma_by_event[[as.character(eid)]] else 0.01
kp <- if (!is.null(n_params_by_event)) n_params_by_event[[as.character(eid)]] else 2
list(statistics = list(
sigma = sg,
degree_of_freedom = n_est - 2,
residuals = rnorm(n_est, sd = sg),
n_params = kp,
forecast_error_corrected_sigma = rep(sg, n_ew)
))
})
)
list(data = data_tbl, model = model_tbl)
}
.count_warnings <- function(expr) {
n <- 0L
result <- withCallingHandlers(
expr,
warning = function(w) { n <<- n + 1L; invokeRestart("muffleWarning") }
)
list(result = result, n = n)
}
# --- A1 ----------------------------------------------------------------
test_that("A1: RollingWindowModel beta/alpha/sigma match lm() on complete pairs", {
set.seed(101)
n_est <- 150
index_returns <- rnorm(n_est, sd = 0.01)
firm_returns <- 0.001 + 1.2 * index_returns + rnorm(n_est, sd = 0.005)
na_days <- seq(3, n_est, by = 3)
firm_returns[na_days] <- NA_real_
# Index outliers ONLY on the NA-firm days -- if fit() computed x_bar/ss_xx
# from ALL index values (including these outlier days), beta would be
# biased away from what lm() on the complete-pair subset produces.
index_returns[na_days] <- index_returns[na_days] + 0.2
d <- tibble::tibble(
firm_returns = firm_returns,
index_returns = index_returns,
estimation_window = 1L,
event_window = 0L,
relative_index = seq(-n_est, -1)
)
d <- dplyr::bind_rows(d, tibble::tibble(
firm_returns = NA_real_, index_returns = 0.001,
estimation_window = 0L, event_window = 1L, relative_index = 0L
))
model <- RollingWindowModel$new(window_size = 150, min_obs = 30)
expect_no_warning(model$fit(d))
expect_true(model$is_fitted)
complete <- is.finite(firm_returns) & is.finite(index_returns)
fit_lm <- lm(firm_returns[complete] ~ index_returns[complete])
expect_equal(unname(model$statistics$alpha), unname(coef(fit_lm)[1]), tolerance = 1e-10)
expect_equal(unname(model$statistics$beta), unname(coef(fit_lm)[2]), tolerance = 1e-10)
expect_equal(model$statistics$sigma, summary(fit_lm)$sigma, tolerance = 1e-10)
expect_equal(model$statistics$degree_of_freedom, sum(complete) - 2)
expect_equal(model$statistics$n_params, 2)
})
# --- A2 ----------------------------------------------------------------
test_that("A2: all-NA event excluded identically across CSectT/Patell/BMP/Sign/GSign/KP", {
fx6 <- .me_fixture(event_ids = 1:6, all_na_event_ids = 6, seed = 2001)
fx5 <- list(
data = dplyr::filter(fx6$data, event_id != 6),
model = dplyr::filter(fx6$model, event_id != 6)
)
checks <- list(
list(cls = CSectTTest, col = "caar_t"),
list(cls = PatellZTest, col = "caar_z"),
list(cls = BMPTest, col = "cbmp_t"),
list(cls = SignTest, col = "csign_z"),
list(cls = GeneralizedSignTest, col = "cgsign_z"),
list(cls = KolariPynnonenTest, col = "ckp_t")
)
for (chk in checks) {
out <- .count_warnings(chk$cls$new()$compute(fx6$data, fx6$model))
expect_equal(out$n, 1, info = chk$col)
r5 <- chk$cls$new()$compute(fx5$data, fx5$model)
expect_equal(out$result[[chk$col]], r5[[chk$col]], info = chk$col)
}
})
test_that("A2: strict mode errors naming the excluded event_id", {
fx6 <- .me_fixture(event_ids = 1:6, all_na_event_ids = 6, seed = 2002)
withr::local_options(EventStudy.degenerate_handling = "strict")
expect_error(CSectTTest$new()$compute(fx6$data, fx6$model), "6")
})
test_that("A2: pipeline excludes an unfitted model's event without a second warning", {
symbols <- paste0("FIRM_", LETTERS[1:4])
firm_data <- create_mock_firm_data(symbols = symbols)
index_data <- create_mock_index_data()
request <- create_mock_request(firm_symbols = symbols)
firm_data$adjusted[firm_data$symbol == "FIRM_D"] <- NA_real_
task <- EventStudyTask$new(firm_data, index_data, request)
ps <- ParameterSet$new(
multi_event_statistics = MultiEventStatisticsSet$new(list(
CSectTTest$new(), KolariPynnonenTest$new(), PatellZTest$new()
))
)
out <- .count_warnings(run_event_study(task, ps))
expect_equal(out$n, 1)
task_full <- out$result
symbols3 <- symbols[1:3]
firm_data3 <- create_mock_firm_data(symbols = symbols3)
request3 <- create_mock_request(firm_symbols = symbols3)
task3 <- EventStudyTask$new(firm_data3, index_data, request3)
task3 <- suppressWarnings(run_event_study(task3, ps))
cs_full <- task_full$aar_caar_tbl$CSectT[[1]]
cs_3 <- task3$aar_caar_tbl$CSectT[[1]]
last_full <- nrow(cs_full)
last_3 <- nrow(cs_3)
expect_equal(cs_full$caar_t[last_full], cs_3$caar_t[last_3])
kp_full <- task_full$aar_caar_tbl$KP[[1]]
kp_3 <- task3$aar_caar_tbl$KP[[1]]
expect_equal(kp_full$ckp_t[nrow(kp_full)], kp_3$ckp_t[nrow(kp_3)])
pz_full <- task_full$aar_caar_tbl$PatellZ[[1]]
pz_3 <- task3$aar_caar_tbl$PatellZ[[1]]
expect_equal(pz_full$caar_z[nrow(pz_full)], pz_3$caar_z[nrow(pz_3)])
})
test_that("A2: STATS-03 partial gap still contributes 0 to that event's CAR (unchanged)", {
fx <- .me_fixture(event_ids = 1:3, seed = 2003, n_est = 15, event_window = -2:2)
fx$data$abnormal_returns[fx$data$event_id == 1 & fx$data$relative_index == 0] <- NA_real_
result <- CSectTTest$new()$compute(fx$data, fx$model)
# STATS-03: the missing AR contributes 0 to THAT EVENT's own CAR (used for
# the caar_t denominator, sd_caar) -- the aar/caar POINT ESTIMATE itself
# uses na.rm=TRUE across events (unaffected by this convention). Hand-
# replicate sd_caar's per-event coalesced-to-0 cumsum and confirm caar_t
# (not caar) matches -- i.e. the convention is unchanged by the A2 fix.
ew <- fx$data %>% dplyr::filter(event_window == 1)
aar_hand <- ew %>%
dplyr::group_by(relative_index) %>%
dplyr::summarise(aar = mean(abnormal_returns, na.rm = TRUE),
n_valid_events = sum(!is.na(abnormal_returns)), .groups = "drop") %>%
dplyr::mutate(caar = cumsum(dplyr::coalesce(aar, 0)))
sd_caar_hand <- ew %>%
dplyr::group_by(event_id) %>%
dplyr::mutate(car = cumsum(dplyr::coalesce(abnormal_returns, 0))) %>%
dplyr::group_by(relative_index) %>%
dplyr::summarise(sd_caar = sd(car, na.rm = TRUE), .groups = "drop")
hand <- aar_hand %>%
dplyr::left_join(sd_caar_hand, by = "relative_index") %>%
dplyr::mutate(caar_t_hand = sqrt(n_valid_events) * caar / sd_caar) %>%
dplyr::arrange(relative_index)
result <- dplyr::arrange(result, relative_index)
expect_equal(result$caar_t, hand$caar_t_hand, tolerance = 1e-12)
})
# --- A3 ----------------------------------------------------------------
test_that("A3: KP excludes a constant-SAR event from r_bar and uses per-day n_valid_events", {
n_est <- 30
event_window <- -5:5
n_ew <- length(event_window)
set.seed(3001)
base <- rnorm(n_est, sd = 0.01)
ar_gen <- function(eid) {
if (eid <= 5) {
est <- base + rnorm(n_est, sd = 0.002)
} else {
est <- rep(0.005, n_est) # constant SAR -> sd == 0, excluded from r_bar
}
list(est = est, evt = rnorm(n_ew, sd = 0.01))
}
sigma_by_event <- as.list(setNames(c(rep(0.01, 5), 0.02), as.character(1:6)))
fx <- .me_fixture(event_ids = 1:6, n_est = n_est, event_window = event_window,
seed = 3002, ar_gen = ar_gen, sigma_by_event = sigma_by_event)
out <- .count_warnings(KolariPynnonenTest$new()$compute(fx$data, fx$model))
expect_equal(out$n, 1)
result <- out$result
bmp_result <- BMPTest$new()$compute(fx$data, fx$model)
expect_false(isTRUE(all.equal(result$kp_t, bmp_result$bmp_t)))
est_sar <- fx$data %>%
dplyr::filter(estimation_window == 1, event_id <= 5) %>%
dplyr::left_join(tibble::tibble(event_id = 1:5, sigma = 0.01), by = "event_id") %>%
dplyr::mutate(sar = abnormal_returns / sigma) %>%
dplyr::select(relative_index, event_id, sar) %>%
tidyr::pivot_wider(names_from = event_id, values_from = sar)
cor_mat <- stats::cor(as.matrix(est_sar[, -1]))
r5 <- (sum(cor_mat) - 5) / (5 * 4)
n_t <- result$n_valid_events
expect_true(all(n_t == 6))
expected_kp_t <- bmp_result$bmp_t * sqrt((1 - r5) / (1 + (n_t - 1) * r5))
expect_equal(result$kp_t, expected_kp_t, tolerance = 1e-8)
})
test_that("A3: KP sets kp_t/ckp_t to NA with a single usable event (never falls back to 1)", {
n_est <- 30
event_window <- -2:2
ar_gen <- function(eid) {
est <- if (eid == 1) rnorm(n_est, sd = 0.01) else rep(0.003, n_est)
list(est = est, evt = rnorm(length(event_window), sd = 0.01))
}
sigma_by_event <- as.list(setNames(c(0.01, 0.02), c("1", "2")))
fx <- .me_fixture(event_ids = 1:2, n_est = n_est, event_window = event_window,
seed = 3011, ar_gen = ar_gen, sigma_by_event = sigma_by_event)
out <- .count_warnings(KolariPynnonenTest$new()$compute(fx$data, fx$model))
expect_equal(out$n, 1)
expect_true(all(is.na(out$result$kp_t)))
expect_true(all(is.na(out$result$ckp_t)))
})
test_that("A3: KP per-day adjustment uses that day's n_valid_events", {
n_est <- 30
event_window <- -3:3
n_ew <- length(event_window)
set.seed(3020)
base <- rnorm(n_est, sd = 0.01)
ar_gen <- function(eid) list(est = base + rnorm(n_est, sd = 0.002),
evt = rnorm(n_ew, sd = 0.01))
fx <- .me_fixture(event_ids = 1:5, n_est = n_est, event_window = event_window,
seed = 3021, ar_gen = ar_gen)
fx$data$abnormal_returns[fx$data$event_id == 1 & fx$data$relative_index == 0] <- NA_real_
result <- suppressWarnings(KolariPynnonenTest$new()$compute(fx$data, fx$model))
day0 <- result[result$relative_index == 0, ]
expect_equal(day0$n_valid_events, 4)
bmp_result <- suppressWarnings(BMPTest$new()$compute(fx$data, fx$model))
est_sar <- fx$data %>%
dplyr::filter(estimation_window == 1) %>%
dplyr::left_join(tibble::tibble(event_id = 1:5, sigma = 0.01), by = "event_id") %>%
dplyr::mutate(sar = abnormal_returns / sigma) %>%
dplyr::select(relative_index, event_id, sar) %>%
tidyr::pivot_wider(names_from = event_id, values_from = sar)
cor_mat <- stats::cor(as.matrix(est_sar[, -1]))
r_bar <- (sum(cor_mat) - 5) / (5 * 4)
expected <- bmp_result$bmp_t[bmp_result$relative_index == 0] *
sqrt((1 - r_bar) / (1 + (4 - 1) * r_bar))
expect_equal(day0$kp_t, expected, tolerance = 1e-8)
})
# --- A4 ----------------------------------------------------------------
test_that("A4: RankTest and GeneralizedSignTest group by event_id, not firm_symbol", {
fx_distinct <- .me_fixture(event_ids = 1:4, firm_symbols = paste0("F", 1:4),
seed = 4001, n_est = 20, event_window = -3:3)
fx_recur <- fx_distinct
fx_recur$data <- fx_recur$data %>%
dplyr::mutate(firm_symbol = c("F1", "F1", "F2", "F2")[match(event_id, 1:4)])
r_rank_distinct <- RankTest$new()$compute(fx_distinct$data, fx_distinct$model)
r_rank_recur <- RankTest$new()$compute(fx_recur$data, fx_recur$model)
expect_equal(r_rank_distinct$rank_z, r_rank_recur$rank_z)
r_gsign_distinct <- GeneralizedSignTest$new()$compute(fx_distinct$data, fx_distinct$model)
r_gsign_recur <- GeneralizedSignTest$new()$compute(fx_recur$data, fx_recur$model)
expect_equal(r_gsign_distinct$gsign_z, r_gsign_recur$gsign_z)
expect_equal(r_gsign_distinct$cgsign_z, r_gsign_recur$cgsign_z)
})
# --- A5 ----------------------------------------------------------------
test_that("A5: cross_sectional_regression errors on duplicate event_id in data", {
task <- create_fitted_mock_task(n_firms = 4)
data <- tibble::tibble(event_id = c(1, 1, 2, 3), x = rnorm(4))
err <- tryCatch(cross_sectional_regression(task, ~x, data), error = function(e) e)
expect_true(inherits(err, "eventstudy_error_bad_argument"))
expect_match(conditionMessage(err), "1")
})
test_that("A5: cross_sectional_regression warns once on unmatched task events", {
task <- create_fitted_mock_task(n_firms = 4)
data <- tibble::tibble(event_id = 1:2, x = rnorm(2))
# robust = FALSE: with n_obs == n_params (2 events, intercept + x), HC1
# is singular and sandwich emits its own (unrelated) warning -- robust
# SEs are irrelevant to what this test checks (the unmatched-event warning).
expect_warning(result <- cross_sectional_regression(task, ~x, data, robust = FALSE),
"task event")
expect_equal(result$n_obs, 2)
})
test_that("A5: cross_sectional_regression errors when car_window exceeds the event window", {
task <- create_fitted_mock_task(n_firms = 4)
data <- tibble::tibble(event_id = 1:4, x = rnorm(4))
err <- tryCatch(
cross_sectional_regression(task, ~x, data, car_window = c(-20, 2)),
error = function(e) e
)
expect_true(inherits(err, "eventstudy_error_bad_argument"))
})
test_that("A5: cross_sectional_regression excludes an event with a missing AR inside car_window", {
task <- create_fitted_mock_task(n_firms = 4)
ew_rows <- which(task$data_tbl$data[[1]]$event_window == 1)
task$data_tbl$data[[1]]$abnormal_returns[ew_rows[1]] <- NA_real_
data <- tibble::tibble(event_id = 1:4, x = rnorm(4))
expect_warning(result <- cross_sectional_regression(task, ~x, data), "missing")
expect_equal(result$n_obs, 3)
expect_false(1 %in% result$car_data$event_id)
})
# --- A6 / A8 -------------------------------------------------------------
test_that("A6: MarketModel routes insufficient obs (n_valid < n_params + 1) through the contract", {
d2 <- create_mock_model_data(n_estimation = 2)
m <- MarketModel$new()
expect_warning(m$fit(d2), "insufficient estimation observations")
expect_false(m$is_fitted)
m_strict <- MarketModel$new()
m_strict$degenerate_mode <- "strict"
expect_error(m_strict$fit(d2))
})
test_that("A6: MarketModel with 20 valid obs fits and warns about the short window", {
d20 <- create_mock_model_data(n_estimation = 20)
m <- MarketModel$new()
expect_warning(m$fit(d20), "estimation window has only 20 valid observations")
expect_true(m$is_fitted)
})
test_that("A6: MarketModel with 120 obs fits without warning", {
d120 <- create_mock_model_data(n_estimation = 120)
m <- MarketModel$new()
expect_no_warning(m$fit(d120))
expect_true(m$is_fitted)
})
test_that("A6: FamaFrench3FactorModel routes insufficient obs through the contract", {
d4 <- create_mock_factor_model_data(n_estimation = 4)
m <- FamaFrench3FactorModel$new()
expect_warning(m$fit(d4), "insufficient estimation observations")
expect_false(m$is_fitted)
})
test_that("A6: MarketModel FEC uses complete pairs only", {
set.seed(6001)
n_est <- 100
index_returns <- rnorm(n_est, sd = 0.01)
firm_returns <- 0.001 + 1.1 * index_returns + rnorm(n_est, sd = 0.005)
extreme <- order(abs(index_returns), decreasing = TRUE)[1:10]
firm_returns[extreme] <- NA_real_
n_event <- 5
event_index <- rnorm(n_event, sd = 0.01)
d <- tibble::tibble(
firm_returns = c(firm_returns, rep(NA_real_, n_event)),
index_returns = c(index_returns, event_index),
estimation_window = c(rep(1L, n_est), rep(0L, n_event)),
event_window = c(rep(0L, n_est), rep(1L, n_event)),
relative_index = c(seq(-n_est, -1), seq(0, n_event - 1))
)
m <- MarketModel$new()
expect_no_warning(m$fit(d))
complete <- !is.na(firm_returns) & !is.na(index_returns)
meanRm <- mean(index_returns[complete])
ssRm <- sum((index_returns[complete] - meanRm)^2)
expected_fec <- m$statistics$sigma *
sqrt(1 + 1 / sum(complete) + (event_index - meanRm)^2 / ssRm)
expect_equal(m$statistics$forecast_error_corrected_sigma, expected_fec, tolerance = 1e-12)
})
test_that("A6/A8: statistics$n_params matches the documented value per model class", {
d <- create_mock_model_data(n_estimation = 120)
fd <- create_mock_factor_model_data(n_estimation = 120)
mm <- MarketModel$new(); mm$fit(d)
expect_equal(mm$statistics$n_params, 2)
ff3 <- FamaFrench3FactorModel$new(); ff3$fit(fd)
expect_equal(ff3$statistics$n_params, 4)
carhart <- Carhart4FactorModel$new(); carhart$fit(fd)
expect_equal(carhart$statistics$n_params, 5)
ff5 <- FamaFrench5FactorModel$new(); ff5$fit(fd)
expect_equal(ff5$statistics$n_params, 6)
cpma <- ComparisonPeriodMeanAdjustedModel$new(); cpma$fit(d)
expect_equal(cpma$statistics$n_params, 1)
ma <- MarketAdjustedModel$new(); ma$fit(d)
expect_equal(ma$statistics$n_params, 0)
})
test_that("A6: PatellZTest aar_z uses m = valid estimation obs and k = model n_params", {
fx <- .me_fixture(event_ids = 1:3, n_est = 30, event_window = -3:3, seed = 6010,
n_params_by_event = as.list(setNames(rep(4, 3), as.character(1:3))))
na_rows <- which(fx$data$event_id == 1 & fx$data$estimation_window == 1)[1:10]
fx$data$abnormal_returns[na_rows] <- NA_real_
result <- PatellZTest$new()$compute(fx$data, fx$model)
sd_asar <- fx$data %>%
dplyr::filter(estimation_window == 1) %>%
dplyr::group_by(event_id) %>%
dplyr::summarise(m = sum(is.finite(abnormal_returns)), .groups = "drop") %>%
dplyr::mutate(k = 4, Q_i = ifelse(m > k + 2, (m - k) / (m - k - 2), 1))
Q_total <- sqrt(sum(sd_asar$Q_i))
sigma_by_event <- purrr::map_dbl(fx$model$model, ~.x$statistics$sigma)
evt <- fx$data %>%
dplyr::filter(event_window == 1) %>%
dplyr::left_join(tibble::tibble(event_id = fx$model$event_id, sigma = sigma_by_event),
by = "event_id") %>%
dplyr::mutate(sar = abnormal_returns / sigma)
hand <- evt %>%
dplyr::group_by(relative_index) %>%
dplyr::summarise(sum_sar = sum(sar, na.rm = TRUE), .groups = "drop") %>%
dplyr::mutate(aar_z = sum_sar / Q_total) %>%
dplyr::arrange(relative_index)
result <- dplyr::arrange(result, relative_index)
expect_equal(result$aar_z, hand$aar_z, tolerance = 1e-10)
})
# --- A7 ----------------------------------------------------------------
test_that("A7: caltime_t doubles when the event-day shock doubles; df is estimation-window based", {
n_events <- 20
n_est <- 40
event_window <- -2:2
shock <- 0.01
build_fixture <- function(shock_val) {
purrr::map_dfr(seq_len(n_events), function(i) {
ar_est <- rnorm(n_est, sd = 0.01)
ar_evt <- rnorm(length(event_window), sd = 0.01)
ar_evt[event_window == 0] <- shock_val
tibble::tibble(
event_id = i, firm_symbol = paste0("F", i), group = "g",
relative_index = c(seq(-(n_est + 5), -6), event_window),
estimation_window = c(rep(1L, n_est), rep(0L, length(event_window))),
event_window = c(rep(0L, n_est), rep(1L, length(event_window))),
abnormal_returns = c(ar_est, ar_evt)
)
})
}
set.seed(7002); d1 <- build_fixture(shock)
set.seed(7002); d2 <- build_fixture(2 * shock)
model_tbl <- tibble::tibble(event_id = 1:n_events, model = vector("list", n_events))
r1 <- CalendarTimePortfolioTest$new()$compute(d1, model_tbl)
r2 <- CalendarTimePortfolioTest$new()$compute(d2, model_tbl)
day0_1 <- r1$caltime_t[r1$relative_index == 0]
day0_2 <- r2$caltime_t[r2$relative_index == 0]
expect_equal(day0_2, 2 * day0_1, tolerance = 1e-10)
est_aar <- d1 %>%
dplyr::filter(estimation_window == 1) %>%
dplyr::group_by(relative_index) %>%
dplyr::summarise(aar = mean(abnormal_returns), .groups = "drop")
ts_sd <- sd(est_aar$aar)
n_estimation_days <- nrow(est_aar)
expect_equal(attr(r1, "caltime_df"), n_estimation_days - 1)
evt_aar <- d1 %>%
dplyr::filter(event_window == 1, relative_index == 0) %>%
dplyr::summarise(aar = mean(abnormal_returns)) %>%
dplyr::pull(aar)
expect_equal(day0_1, evt_aar / ts_sd, tolerance = 1e-10)
task_stub <- structure(
list(aar_caar_tbl = tibble::tibble(group = "g", CalTimeT = list(r1))),
class = "EventStudyTask"
)
p <- adjust_p_values(task_stub, stat_name = "CalTimeT", method = "none")
expected_p <- 2 * stats::pt(-abs(r1$caltime_t), df = n_estimation_days - 1)
expect_equal(p$p_raw_aar, expected_p, tolerance = 1e-10)
})
# --- A8 (also covered by the A6/A8 n_params test above) -----------------
test_that("A8: MarketAdjustedModel FEC sigma equals sigma exactly (correction factor 1)", {
d <- create_mock_model_data(n_estimation = 120)
m <- MarketAdjustedModel$new()
m$fit(d)
n_event <- sum(d$event_window == 1)
expect_equal(m$statistics$forecast_error_corrected_sigma, rep(m$statistics$sigma, n_event))
cpma <- ComparisonPeriodMeanAdjustedModel$new()
cpma$fit(d)
n_valid_fec <- sum(!is.na(d$firm_returns[d$estimation_window == 1]))
expect_equal(
cpma$statistics$forecast_error_corrected_sigma,
rep(cpma$statistics$sigma * sqrt(1 + 1 / n_valid_fec), n_event),
tolerance = 1e-12
)
})
# --- A9 ----------------------------------------------------------------
test_that("A9: n_pos counts strictly positive ARs; a zero AR is counted in n_neg", {
fx <- .me_fixture(event_ids = 1:4, n_est = 20, event_window = -1:1, seed = 9001)
fx$data$abnormal_returns[fx$data$event_id == 1 & fx$data$relative_index == 0] <- 0
r_cs <- CSectTTest$new()$compute(fx$data, fx$model)
r_patell <- PatellZTest$new()$compute(fx$data, fx$model)
model_tbl2 <- tibble::tibble(event_id = 1:4, model = vector("list", 4))
r_cal <- CalendarTimePortfolioTest$new()$compute(fx$data, model_tbl2)
ars_day0 <- fx$data$abnormal_returns[fx$data$event_window == 1 & fx$data$relative_index == 0]
expect_equal(r_cs$n_pos[r_cs$relative_index == 0], sum(ars_day0 > 0))
expect_equal(r_cs$n_neg[r_cs$relative_index == 0], sum(ars_day0 <= 0))
expect_equal(r_patell$n_pos[r_patell$relative_index == 0], sum(ars_day0 > 0))
expect_equal(r_patell$n_neg[r_patell$relative_index == 0], sum(ars_day0 <= 0))
expect_equal(r_cal$n_pos[r_cal$relative_index == 0], sum(ars_day0 > 0))
expect_equal(r_cal$n_neg[r_cal$relative_index == 0], sum(ars_day0 <= 0))
})
# --- A10 -----------------------------------------------------------------
test_that("A10: TestStatisticBase validates confidence_type and warns exactly once when non-default", {
expect_error(CSectTTest$new(confidence_type = "bogus"))
expect_warning(t1 <- CSectTTest$new(confidence_type = "less"), "currently ignored")
expect_equal(t1$confidence_type, "less")
expect_warning(t2 <- CSectTTest$new(confidence_type = "greater"), "currently ignored")
expect_equal(t2$confidence_type, "greater")
expect_no_warning(CSectTTest$new())
expect_no_warning(CSectTTest$new(confidence_type = "two-sided"))
})
# --- A12 -----------------------------------------------------------------
test_that("A12: (a) bootstrap observed_caar matches the mean of per-event CAR; equals cumsum(aar) when NA-free", {
task <- create_fitted_mock_task(n_firms = 4)
ew_rows <- which(task$data_tbl$data[[1]]$event_window == 1)
task$data_tbl$data[[1]]$abnormal_returns[ew_rows[1]] <- NA_real_
result <- bootstrap_test(task, n_boot = 5, seed = 42)
ar_data <- task$data_tbl %>%
dplyr::select(event_id, firm_symbol, data) %>%
tidyr::unnest(data) %>%
dplyr::filter(event_window == 1) %>%
dplyr::select(event_id, relative_index, abnormal_returns)
hand <- ar_data %>%
dplyr::group_by(event_id) %>%
dplyr::mutate(car = cumsum(dplyr::coalesce(abnormal_returns, 0))) %>%
dplyr::group_by(relative_index) %>%
dplyr::summarise(observed_caar = mean(car), .groups = "drop") %>%
dplyr::arrange(relative_index)
result <- dplyr::arrange(result, relative_index)
expect_equal(result$observed_caar, hand$observed_caar, tolerance = 1e-12)
task2 <- create_fitted_mock_task(n_firms = 4)
result2 <- bootstrap_test(task2, n_boot = 5, seed = 42)
result2 <- dplyr::arrange(result2, relative_index)
expect_equal(result2$observed_caar, cumsum(result2$observed_aar), tolerance = 1e-12)
})
test_that("A12: (b) NA bootstrap draws are excluded from the p-value denominator", {
set.seed(1234)
n_est <- 30
event_window <- 0
build_event <- function(eid, ar_k) {
tibble::tibble(
event_id = eid, firm_symbol = paste0("F", eid), group = "g",
relative_index = c(seq(-(n_est + 5), -6), event_window),
estimation_window = c(rep(1L, n_est), 0L),
event_window = c(rep(0L, n_est), 1L),
abnormal_returns = c(rnorm(n_est, sd = 0.01), ar_k)
)
}
d <- dplyr::bind_rows(build_event(1, 0.01), build_event(2, -0.01))
nested <- d %>%
dplyr::group_by(event_id, firm_symbol, group) %>%
tidyr::nest() %>%
dplyr::ungroup()
task <- structure(list(data_tbl = nested), class = "EventStudyTask")
result <- bootstrap_test(task, n_boot = 200, weight_type = "rademacher", seed = 55)
expect_equal(result$boot_p_aar[result$relative_index == 0], 1)
})
Any scripts or data that you put into this service are public.
Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.