Nothing
# Helper to create mock intraday data
create_mock_intraday_data <- function(symbol = "FIRM_A",
n_bars = 500,
start_time = as.POSIXct("2020-06-15 09:30:00",
tz = "UTC")) {
set.seed(42)
timestamps <- seq(start_time, by = "1 min", length.out = n_bars)
returns <- rnorm(n_bars, mean = 0, sd = 0.001)
prices <- 100 * cumprod(1 + returns)
tibble::tibble(
symbol = symbol,
timestamp = timestamps,
price = prices
)
}
create_mock_intraday_index <- function(index_symbol = "INDEX_1",
n_bars = 500,
start_time = as.POSIXct("2020-06-15 09:30:00",
tz = "UTC")) {
set.seed(123)
timestamps <- seq(start_time, by = "1 min", length.out = n_bars)
returns <- rnorm(n_bars, mean = 0, sd = 0.0008)
prices <- 1000 * cumprod(1 + returns)
tibble::tibble(
symbol = index_symbol,
timestamp = timestamps,
price = prices
)
}
create_mock_intraday_request <- function(firm_symbol = "FIRM_A",
index_symbol = "INDEX_1",
start_time = as.POSIXct("2020-06-15 09:30:00",
tz = "UTC")) {
event_time <- start_time + 300 * 60 # 300 bars in
tibble::tibble(
event_id = 1L,
firm_symbol = firm_symbol,
index_symbol = index_symbol,
event_timestamp = event_time,
group = "TestGroup",
event_window_start = -30L,
event_window_end = 30L,
shift_estimation_window = -31L,
estimation_window_length = 120L
)
}
test_that("IntradayEventStudyTask creates correctly", {
firm <- create_mock_intraday_data()
index <- create_mock_intraday_index()
request <- create_mock_intraday_request()
task <- IntradayEventStudyTask$new(firm, index, request)
expect_s3_class(task, "IntradayEventStudyTask")
expect_s3_class(task, "EventStudyTask")
expect_equal(nrow(task$data_tbl), 1)
})
test_that("IntradayEventStudyTask errors on missing timestamp", {
set.seed(260993) # C7 (2026-09-24): deterministic seed
# C7 (2026-09-24): fixed POSIXct fixture (UTC) instead of Sys.time(), so
# this test is deterministic regardless of when/where it runs.
fixed_time <- as.POSIXct("2024-01-15 09:30:00", tz = "UTC")
firm <- tibble::tibble(
symbol = "FIRM_A",
date = fixed_time + 1:10,
price = 100 + rnorm(10)
)
index <- create_mock_intraday_index()
request <- create_mock_intraday_request()
expect_error(
IntradayEventStudyTask$new(firm, index, request),
"timestamp"
)
})
test_that("IntradayEventStudyTask errors on non-POSIXct timestamp", {
set.seed(261008) # C7 (2026-09-24): deterministic seed
# C7 (2026-09-24): fixed POSIXct fixture (UTC) instead of Sys.time().
fixed_time <- as.POSIXct("2024-01-15 09:30:00", tz = "UTC")
firm <- tibble::tibble(
symbol = "FIRM_A",
timestamp = as.character(fixed_time + 1:10),
price = 100 + rnorm(10)
)
index <- create_mock_intraday_index()
request <- create_mock_intraday_request()
expect_error(
IntradayEventStudyTask$new(firm, index, request),
"POSIXct"
)
})
test_that("prepare_intraday_event_study computes returns and windows", {
firm <- create_mock_intraday_data()
index <- create_mock_intraday_index()
request <- create_mock_intraday_request()
task <- IntradayEventStudyTask$new(firm, index, request)
ps <- ParameterSet$new()
task <- prepare_intraday_event_study(task, ps)
d <- task$data_tbl$data[[1]]
expect_true("firm_returns" %in% names(d))
expect_true("index_returns" %in% names(d))
expect_true("event_window" %in% names(d))
expect_true("estimation_window" %in% names(d))
expect_true("relative_index" %in% names(d))
# Check windows are assigned
expect_gt(sum(d$event_window == 1, na.rm = TRUE), 0)
expect_gt(sum(d$estimation_window == 1, na.rm = TRUE), 0)
})
test_that("IntradayEventStudyTask print works", {
firm <- create_mock_intraday_data()
index <- create_mock_intraday_index()
request <- create_mock_intraday_request()
task <- IntradayEventStudyTask$new(firm, index, request)
expect_output(print(task), "IntradayEventStudyTask")
})
# ---------------------------------------------------------------------------
# Helpers for nonparametric_intraday_test
# ---------------------------------------------------------------------------
#' Create a mock estimation window spanning multiple days with identical
#' intraday time grids.
create_mock_np_estimation_window <- function(n_days = 20, n_bars_per_day = 50,
seed = 42) {
set.seed(seed)
times <- sprintf("%02d:%02d", 10L + seq_len(n_bars_per_day) %/% 60L,
seq_len(n_bars_per_day) %% 60L)
days <- seq_len(n_days)
tibble::tibble(
day = rep(days, each = n_bars_per_day),
time = rep(times, n_days),
abnormalReturn = rnorm(n_days * n_bars_per_day, 0, 0.001)
)
}
#' Create a single event-day window with the same time grid.
create_mock_np_event_window <- function(n_bars = 50, seed = 123,
inject_signal = FALSE) {
set.seed(seed)
times <- sprintf("%02d:%02d", 10L + seq_len(n_bars) %/% 60L,
seq_len(n_bars) %% 60L)
ar <- rnorm(n_bars, 0, 0.001)
if (inject_signal) {
# Inject a large negative signal starting at bar 10 to ensure significance
ar[10:25] <- ar[10:25] - 0.02
}
tibble::tibble(
time = times,
abnormalReturn = ar
)
}
# ---------------------------------------------------------------------------
# Tests for nonparametric_intraday_test
# ---------------------------------------------------------------------------
test_that("nonparametric_intraday_test returns list of tibbles with expected columns", {
est <- create_mock_np_estimation_window()
ew <- create_mock_np_event_window()
event_times <- ew$time[c(1, 20)]
res <- nonparametric_intraday_test(est, ew, event_times)
expect_type(res, "list")
expect_equal(length(res), 2)
expect_equal(names(res), event_times)
for (r in res) {
expect_s3_class(r, "tbl_df")
expect_true(all(c("id", "CAR", "CI", "fitCI") %in% names(r)))
}
})
test_that("nonparametric_intraday_test validates p in (0,1)", {
est <- create_mock_np_estimation_window()
ew <- create_mock_np_event_window()
et <- ew$time[1]
expect_error(nonparametric_intraday_test(est, ew, et, p = 0),
"`p` must be")
expect_error(nonparametric_intraday_test(est, ew, et, p = 1),
"`p` must be")
expect_error(nonparametric_intraday_test(est, ew, et, p = -0.1),
"`p` must be")
})
test_that("nonparametric_intraday_test validates input data frames", {
est <- create_mock_np_estimation_window()
ew <- create_mock_np_event_window()
et <- ew$time[1]
# estimation_window missing column
bad_est <- est[, c("day", "time")]
expect_error(nonparametric_intraday_test(bad_est, ew, et),
"abnormalReturn")
# event_window missing column
bad_ew <- ew[, "time", drop = FALSE]
expect_error(nonparametric_intraday_test(est, bad_ew, et),
"abnormalReturn")
# event_times not character
expect_error(nonparametric_intraday_test(est, ew, 123),
"`event_times`")
})
test_that("nonparametric_intraday_test returns CAR=0/CI=0 for non-significant events", {
est <- create_mock_np_estimation_window(n_days = 20, seed = 42)
ew <- create_mock_np_event_window(seed = 42, inject_signal = FALSE)
et <- ew$time[1]
res <- nonparametric_intraday_test(est, ew, et, p = 0.05, init_window = 5L)
r <- res[[1]]
# Non-significant: single row with zeros
expect_equal(nrow(r), 1)
expect_equal(r$CAR[1], 0)
expect_equal(r$CI[1], 0)
expect_equal(r$fitCI[1], 0)
})
test_that("nonparametric_intraday_test detects significant event with injected signal", {
est <- create_mock_np_estimation_window(n_days = 20, seed = 42)
ew <- create_mock_np_event_window(seed = 42, inject_signal = TRUE)
# Event time at bar 10 where the signal starts
et <- ew$time[10]
res <- nonparametric_intraday_test(est, ew, et, p = 0.05, init_window = 5L)
r <- res[[1]]
# Should detect significance: more than 1 row
expect_gt(nrow(r), 1)
# CAR should be negative (injected negative signal)
expect_true(all(r$CAR < 0))
# fitCI should have same length as CAR
expect_equal(length(r$fitCI), length(r$CAR))
})
test_that("nonparametric_intraday_test upper tail works", {
est <- create_mock_np_estimation_window(n_days = 20, seed = 42)
ew <- create_mock_np_event_window(seed = 42, inject_signal = FALSE)
et <- ew$time[1]
# Upper tail on random data: should also be non-significant
res <- nonparametric_intraday_test(est, ew, et, p = 0.05,
init_window = 5L, upper = TRUE)
r <- res[[1]]
expect_equal(nrow(r), 1)
expect_equal(r$CAR[1], 0)
})
test_that("nonparametric_intraday_test fitCI is polynomial-smoothed", {
est <- create_mock_np_estimation_window(n_days = 20, seed = 42)
ew <- create_mock_np_event_window(seed = 42, inject_signal = TRUE)
et <- ew$time[10]
res <- nonparametric_intraday_test(est, ew, et, p = 0.05, init_window = 5L)
r <- res[[1]]
if (nrow(r) > 1) {
# fitCI should differ from raw CI (smoothed)
# They may be close but not identical for >4 points
if (nrow(r) > 5) {
expect_false(all(r$fitCI == r$CI))
}
# fitCI should be numeric with no NAs
expect_true(is.numeric(r$fitCI))
expect_false(any(is.na(r$fitCI)))
}
})
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.