diff --git a/noinst/README.md b/noinst/README.md
new file mode 100644
index 0000000..96f210f
--- /dev/null
+++ b/noinst/README.md
@@ -0,0 +1,21 @@
+# noinst/
+
+Tools to generate test code from .RData files. Not included in package.
+
+## Files
+
+- `td0.24.1_R3.2.3_64bit.RData` - Reference results from v0.24.1 for regression testing
+- `data_input_swisspharma.RData` - Historical test data (redundant with `data/swisspharma.RData`)
+- `00_functions.R` - Helper functions for legacy tests
+- `extract_test_data.R` - Example: extract data to R code using `constructive`
+- `generate_test_code.R` - Functions to generate test fixtures
+
+## Usage
+
+Regenerate test fixtures:
+```r
+source("noinst/generate_test_code.R")
+generate_test_fixtures()
+```
+
+Old tests loaded .RData files and only ran on CI. New tests use inline R code and `skip_on_cran()`, so they run locally and are better organized.
diff --git a/noinst/extract_test_data.R b/noinst/extract_test_data.R
new file mode 100644
index 0000000..48fa75f
--- /dev/null
+++ b/noinst/extract_test_data.R
@@ -0,0 +1,104 @@
+# Example Script: Extract Test Data from .RData Files
+# =====================================================
+# This script demonstrates how to use the constructive package to generate
+# R code representations of data objects from .RData files.
+#
+# The generated code can then be copied into test files, eliminating the need
+# for external data dependencies.
+
+library(constructive)
+
+# Load the reference data
+# ============================================================================
+load("noinst/data_input_swisspharma.RData")
+load("noinst/td0.24.1_R3.2.3_64bit.RData")
+
+# Example 1: Generate code for a simple time series
+# ============================================================================
+cat("\n=== Example 1: sales.a (full object) ===\n")
+construct(sales.a)
+
+cat("\n\n=== Example 1b: sales.a (first 5 values only) ===\n")
+sales.a.mini <- window(sales.a, end = 1979)
+construct(sales.a.mini)
+
+
+# Example 2: Generate code for quarterly exports (subset)
+# ============================================================================
+cat("\n\n=== Example 2: exports.q (first 2 years = 8 quarters) ===\n")
+exports.q.mini <- window(exports.q, end = c(1976, 4))
+construct(exports.q.mini)
+
+
+# Example 3: Extract specific reference values from old results
+# ============================================================================
+cat("\n\n=== Example 3: Reference values for regression tests ===\n")
+
+# Get first 4 values from a few key methods
+ref_subset <- list(
+  dencho_p_1 = as.numeric(r$y2q[1:4, "dencho_p_1"]),
+  cl_rss_R = as.numeric(r$y2q[1:4, "cl_rss_R"]),
+  fer = as.numeric(r$y2q[1:4, "fer"])
+)
+
+construct(ref_subset)
+
+
+# Example 4: Generate code with styling
+# ============================================================================
+cat("\n\n=== Example 4: Formatted with styler ===\n")
+
+code_text <- construct(sales.a.mini, pipe = "base")
+code_chr <- capture.output(code_text)
+styled_code <- styler::style_text(code_chr)
+cat(paste(styled_code, collapse = "\n"))
+
+
+# Example 5: Create a complete test data fixture
+# ============================================================================
+cat("\n\n=== Example 5: Complete test fixture ===\n")
+
+test_fixture <- list(
+  # Input data (shortened for testing)
+  sales_annual = window(sales.a, start = 1975, end = 1979),
+  exports_quarterly = window(exports.q, start = c(1975, 1), end = c(1979, 4)),
+
+  # Reference values for key methods (first 4 quarters only)
+  reference = list(
+    dencho_p_1 = as.numeric(r$y2q[1:4, "dencho_p_1"]),
+    cl_rss_R = as.numeric(r$y2q[1:4, "cl_rss_R"])
+  )
+)
+
+construct(test_fixture)
+
+
+# Verification: Test that constructed code works
+# ============================================================================
+cat("\n\n=== Verification ===\n")
+
+# Reconstruct sales.a from generated code and compare
+sales_reconstructed <- ts(
+  c(
+    136.7023, 151.0561, 156.1824, 157.2078, 162.334, 174.5098,
+    188.6881, 199.8403, 209.3044, 217.9514, 226.4858, 236.3158,
+    247.2106, 259.5633, 270.917, 281.0579, 290.1869, 299.3203,
+    307.0203, 316.581, 326.9476, 335.2306, 343.9407, 353.0683,
+    363.5683, 375.2936, 385.3843, 395.0016, 406.2823, 416.0856,
+    425.9923, 436.3003, 446.8336, 458.3336, 469.5836, 481.5003
+  ),
+  start = 1975, frequency = 1
+)
+
+cat("sales.a matches reconstructed:", all.equal(sales.a, sales_reconstructed), "\n")
+
+
+# Notes
+# ============================================================================
+cat("\n\n=== Notes ===\n")
+cat("1. Use constructive::construct() to generate R code from objects\n")
+cat("2. Use styler::style_text() to format the generated code nicely\n")
+cat("3. Extract subsets of large objects to keep test files manageable\n")
+cat("4. Verify that constructed code recreates the original object\n")
+cat("5. For tests: prefer data(swisspharma) for built-in data\n")
+cat("6. Only inline small custom fixtures or reference values\n")
diff --git a/noinst/generate_test_code.R b/noinst/generate_test_code.R
new file mode 100644
index 0000000..9ebc94b
--- /dev/null
+++ b/noinst/generate_test_code.R
@@ -0,0 +1,184 @@
+# Helper Functions to Generate Test Code from .RData Files
+# ===========================================================
+# These functions extract data from .RData files and generate clean,
+# readable R code that can be copied into test files.
+
+library(constructive)
+
+#' Generate R code to recreate a time series object
+#'
+#' @param ts_obj A ts object
+#' @param name Optional name for the object (for documentation)
+#' @param max_values Maximum number of values to include (NULL for all)
+#' @param digits Number of digits for rounding (default 10 for high precision)
+#' @return Character vector of formatted R code
+generate_ts_code <- function(ts_obj, name = NULL, max_values = NULL, digits = 10) {
+  if (!is.null(max_values) && length(ts_obj) > max_values) {
+    ts_obj <- window(ts_obj, end = time(ts_obj)[max_values])
+  }
+
+  # Extract components
+  values <- as.numeric(ts_obj)
+  freq <- frequency(ts_obj)
+  start_time <- start(ts_obj)
+
+  # Round values for cleaner output
+  values <- round(values, digits)
+
+  # Format the values nicely - break into lines of ~4 values
+  values_per_line <- 4
+  value_lines <- split(values, ceiling(seq_along(values) / values_per_line))
+  value_strings <- sapply(value_lines, function(x) paste(x, collapse = ", "))
+
+  # Format start parameter
+  start_str <- if (length(start_time) == 1) {
+    as.character(start_time)
+  } else {
+    paste0("c(", paste(start_time, collapse = ", "), ")")
+  }
+
+  # Build the code
+  code <- c(
+    if (!is.null(name)) paste0("# ", name),
+    "ts(",
+    "  c(",
+    paste0("    ", value_strings, ifelse(seq_along(value_strings) < length(value_strings), ",", "")),
+    "  ),",
+    paste0("  start = ", start_str, ","),
+    paste0("  frequency = ", freq),
+    ")"
+  )
+
+  return(code)
+}
+
+
+#' Generate R code for a list of reference values
+#'
+#' @param value_list Named list of numeric vectors
+#' @param digits Number of digits for rounding
+#' @return Character vector of formatted R code
+generate_list_code <- function(value_list, digits = 10) {
+  # Use constructive but with cleaner numeric formatting
+  code <- capture.output(construct(lapply(value_list, function(x) round(x, digits))))
+  # Format with styler
+  styled <- styler::style_text(code)
+  return(as.character(styled))
+}
+
+
+#' Extract reference values from td0.24.1 file for specific methods
+#'
+#' @param methods Character vector of method names
+#' @param n_values Number of values to extract from each method
+#' @param conversion Either "y2q" or "q2m"
+#' @return Named list of reference values
+extract_reference_values <- function(methods, n_values = 10, conversion = "y2q") {
+  # Load the reference data
+  env <- new.env()
+  load("noinst/td0.24.1_R3.2.3_64bit.RData", envir = env)
+
+  # Get the r list and extract the appropriate conversion
+  r <- env$r
+  result_matrix <- r[[conversion]]
+
+  # Extract values for each method
+  ref_values <- lapply(methods, function(method) {
+    if (method %in% colnames(result_matrix)) {
+      as.numeric(result_matrix[1:min(n_values, nrow(result_matrix)), method])
+    } else {
+      warning("Method ", method, " not found in reference data")
+      NULL
+    }
+  })
+  names(ref_values) <- methods
+
+  # Remove NULL entries
+  ref_values[!sapply(ref_values, is.null)]
+}
+
+
+#' Complete workflow: Extract and format test fixtures
+#'
+#' @param output_file File to write the generated code to
+generate_test_fixtures <- function(output_file = "tests/testthat/helper-fixtures.R") {
+  # Load both data files
+  load("noinst/data_input_swisspharma.RData")
+  load("noinst/td0.24.1_R3.2.3_64bit.RData")
+
+  # Helper functions from 00_functions.R
+  source("noinst/00_functions.R")
+
+  output <- c(
+    "# Test Fixtures and Helper Functions",
+    "# ===================================",
+    "# This file contains test data and helper functions.",
+    "# Generated automatically from noinst/ data files.",
+    "# DO NOT EDIT BY HAND - regenerate using noinst/generate_test_code.R",
+    "",
+    "# Helper Functions",
+    "# ---------------",
+    ""
+  )
+
+  # Add the helper functions
+  output <- c(
+    output,
+    "# Function to run all temporal disaggregation methods",
+    readLines("noinst/00_functions.R"),
+    "",
+    "# Reference Values for Regression Tests",
+    "# --------------------------------------",
+    "# These are expected outputs from tempdisagg v0.24.1 for comparison",
+    ""
+  )
+
+  # Extract key reference values (just a few methods, not all 34)
+  key_methods <- c(
+    "dencho_p_1", "dencho_p_2",
+    "cl_rss_R", "cl_log",
+    "fer", "lit_rss"
+  )
+
+  output <- c(
+    output,
+    "# Year to quarter conversion - first 10 values for key methods",
+    "reference_y2q <- ",
+    generate_list_code(extract_reference_values(key_methods, n_values = 10, conversion = "y2q")),
+    ""
+  )
+
+  output <- c(
+    output,
+    "# Quarter to month conversion - first 10 values for key methods",
+    "reference_q2m <- ",
+    generate_list_code(extract_reference_values(key_methods, n_values = 10, conversion = "q2m")),
+    ""
+  )
+
+  # Write to file
+  writeLines(output, output_file)
+  cat("Generated test fixtures written to:", output_file, "\n")
+
+  # Format with styler
+  styler::style_file(output_file)
+  cat("File formatted with styler\n")
+}
+
+
+# Example usage
+# =============
+if (FALSE) {
+  # Generate ts code
+  load("noinst/data_input_swisspharma.RData")
+
+  cat("=== Small sales.a subset ===\n")
+  cat(generate_ts_code(sales.a, "Annual sales", max_values = 10), sep = "\n")
+
+  cat("\n\n=== Reference values ===\n")
+  ref_vals <- extract_reference_values(c("dencho_p_1", "cl_rss_R", "fer"), n_values = 5)
+  cat(generate_list_code(ref_vals), sep = "\n")
+
+  cat("\n\n=== Generate complete fixtures file ===\n")
+  # generate_test_fixtures()
+}
diff --git a/tests/test-all.R b/tests/test-all.R
deleted file mode 100644
index dfe6d5b..0000000
--- a/tests/test-all.R
+++ /dev/null
@@ -1,249 +0,0 @@
-# These tests are more extensive and only need to run on GHA, not on CRAN.
-library(testthat)
-library(tempdisagg)
-
-test_check("tempdisagg")
-
-
-# check only if we are on GHA, we don't want the data file (300k) to be part
-# of the package
-if (
-  Sys.getenv("CI") != "" &&
-  Sys.getenv("GITHUB_WORKSPACE") != "" &&
-
-  # Numerical tests don't work on some GHA Linux
-  R.Version()$os != "linux-gnu") {
-
-  # GHA folder (on GHA)
-  path <- file.path(Sys.getenv("GITHUB_WORKSPACE"), "noinst")
-
-  message("running extensive tests on CI only")
-
-  setwd(path)
-
-
-  # load data, functions
-  # ============================================================================
-  input_old <- "td0.24.1_R3.2.3_64bit.RData"
-  # input_new <- "td0.24.2_R3.2.3_64bit.RData"
-
-  file_in <- "data_input_swisspharma.RData"
-
-  load(file = input_old)
-  load(file_in)
-  file_function <- "00_functions.R"
-
-  old <- list()
-  old$r <- r
-  old$R <- R
-  old$td_version <- td_version
-  old$r_version <- r_version
-  rm(r, R, td_version, r_version)
-
-  source(file_function)
-
-  # calculate data with acutal tempdisagg
-  # ============================================================================
-
-  library(tempdisagg)
-  # library(divtools)
-  # if(truncated) {
-  #   file_out <- paste0("td", td_version, "_R", r_version, "_truncate.RData")
-  #   exports.q <- window(exports.q, start=1975); imports.q <- window(imports.q, start=1975)
-  #   exports.m <- window(exports.m, start=1975); imports.m <- window(imports.m, start=1975)
-  # } else {file_out <- paste0("td", td_version, "_R", r_version, ".RData")}
-
-
-  # estimation with tempdisagg in R (yearly to quarterly)
-  # ----------------------------------------------------------------------------
-  R <- list()
-  r <- list()
-  formula1 <- sales.a ~ exports.q + imports.q
-  formula2 <- sales.a ~ 1
-  formula3 <- sales.a ~ 0 + exports.q
-  freq <- frequency(exports.q)
-
-  R$y2q <- estimAll(formula1 = formula1, formula2 = formula2, formula3 = formula3, freq = freq, pre = FALSE)
-  r$y2q <- do.call(cbind, lapply(R$y2q, predict))
-
-  # estimation with tempdisagg in R (quarterly to monthly)
-  # ----------------------------------------------------------------------------
-  formula1 <- sales.q ~ exports.m + imports.m
-  formula2 <- sales.q ~ 1
-  formula3 <- sales.q ~ 0 + exports.m
-  freq <- frequency(exports.m)
-
-  R$q2m <- estimAll(formula1 = formula1, formula2 = formula2, formula3 = formula3, freq = freq, pre = FALSE)
-  r$q2m <- do.call(cbind, lapply(R$q2m, predict))
-
-
-  # Checks
-  # ============================================================================
-
-  # aggregation fullfilled?
-  # ----------------------------------------------------------------------------
-  stopifnot(sapply(R$y2q, function(x) {
-    all.equal(window(ta(predict(x)), start = start(sales.a)), sales.a, tolerance = 1e-7)
-  }))
-  stopifnot(sapply(R$q2m, function(x) {
-    all.equal(window(ta(predict(x), to = 4), start = start(sales.q), end = end(sales.q)), sales.q, tolerance = 1e-5, check.attributes = FALSE)
-  }))
-
-  stopifnot(sapply(old$R$y2q, function(x) {
-    all.equal(window(ta(predict(x)), start = start(sales.a)), sales.a, tolerance = 1e-7)
-  }))
-  stopifnot(sapply(old$R$q2m, function(x) {
-    all.equal(window(ta(predict(x), to = 4), start = start(sales.q), end = end(sales.q)), sales.q, tolerance = 1e-5, check.attributes = FALSE)
-  }))
-
-  # all components: TRUE
-
-  # # summary statistics of tempdisagg estimations
-  # # -------------------------------------------------------------------------------
-  # for(i in 1:length(R$y2q)) {
-  #   info <- paste("Hit ENTER to get to the summary statistics of", toupper(names(R$y2q)[i]),"")
-  #   readline(info)
-  #   # print(summary(R$y2q[[i]]))
-  #   print(summary(R$y2q[[i]]))
-  #   cat("\n\n")
-  # }
-
-
-  stop_and_print <- function(x) {
-    oo <- getOption("warning.length")
-    on.exit(options(warning.length = oo))
-    options(warning.length = 8000)
-    stop("differences found between new and old tempdisagg\n", paste(capture.output(x), collapse = "\n"), call. = FALSE)
-  }
-
-  # Comparison: new vs. old tempdisagg version
-  # ===============================================================================
-  # a) time series match?
-  # -------------------------------------------------------------------------------
-  # year to quarter conversion
-  if (any(colnames(r$y2q) != colnames(old$r$y2q))) {
-    warning("\nThere are less time series in the old set, the new set has been adjusted\n")
-    r$y2q <- r$y2q[, colnames(old$r$y2q)]
-  }
-  if (sum(abs(diffsNewOld(r$y2q, old$r$y2q)[, 'comp.max'])) > 1e-3) {
-    stop_and_print(diffsNewOld(r$y2q, old$r$y2q))
-  }
-  # identical(r$y2q, old$r$y2q)
-
-
-  # quarter to month conversion
-  if (any(colnames(r$q2m) != colnames(old$r$q2m))) {
-    warning("\nThere are less time series in the old set, the new set has been adjusted\n")
-    r$q2m <- r$q2m[, colnames(old$r$q2m)]
-  }
-  if (sum(abs(diffsNewOld(r$y2q, old$r$y2q)[, 'comp.max'])) > 1e-3) {
-    stop_and_print(diffsNewOld(r$q2m, old$r$q2m))
-  }
-  # identical(r$q2m, old$r$q2m)
-
-
-  # b) td-Objects match?
-  # -------------------------------------------------------------------------------
-
-  R$y2q <- lapply(R$y2q, function(e) {
-    e$mode <- NULL
-    e
-  })
-  R$q2m <- lapply(R$q2m, function(e) {
-    e$mode <- NULL
-    e
-  })
-  if (any(names(R) != names(old$R))) {
-    R <- R[names(old$R)]
-  }
-  # td objects dont match on CI for some reason...
-  # stopifnot(all.equal(R, old$R, tol = 1e-5))
-
-  # c) graphical comparisons if necessary
-  # -------------------------------------------------------------------------------
-  # for(i in colnames(r$y2q)){
-  #   tit <- toupper(i)
-  #   info <- paste("Hit ENTER to get to the plot of", tit,"")
-  #   readline(info)
-  #   ts.plot(cbind(r$y2q[,i], old$r$y2q[,i]), col=c("red", "blue"), lty=c("solid", "dashed"), main=tit); grid()
-  #   cat("\n\n")
-  # }
-
-  # diffs <- diffsNewOld(r$y2q, old$r$y2q)
-  # for(i in colnames(diffs)){
-  #   tit <- toupper(i)
-  #   info <- paste("Hit ENTER to get to the plot of", tit,"")
-  #   readline(info)
-  #   plot(diffs[,i], col="red", main=tit, ylab="diffs", xlab="", xaxt="n", cex.lab=1.5); grid()
-  #   axis(1, 1:length(diffs[,i]), names(diffs[,i]), las=3, cex.axis=0.8)
-  #   cat("\n\n")
-  # }
-
-
-
-  # Aggregation Tests (including first, last)
-  # ----------------------------------------------------------------------------
-
-  am_m_sum <- predict(td(airmiles ~ 1, to = "monthly", method = "denton-cholette", conversion = "sum"))
-  stopifnot(all.equal(airmiles, ta(am_m_sum, to = "annual", conversion = "sum")))
-  stopifnot(all.equal(am_m_sum, ta(am_m_sum, to = 12, conversion = "sum")))
-
-  am_q_sum <- ta(am_m_sum, to = "quarterly", conversion = "sum")
-  stopifnot(all.equal(airmiles, ta(am_q_sum, to = "annual", conversion = "sum")))
-  stopifnot(all.equal(am_q_sum, ta(am_q_sum, to = 4, conversion = "sum")))
-
-  am_s_sum <- ta(am_q_sum, to = 2, conversion = "sum")
-  stopifnot(all.equal(airmiles, ta(am_s_sum, to = "annual", conversion = "sum")))
-  stopifnot(all.equal(am_s_sum, ta(am_s_sum, to = 2, conversion = "sum")))
-
-  am_y_sum <- ta(am_s_sum, to = "annual", conversion = "sum")
-  stopifnot(all.equal(airmiles, ta(am_y_sum, to = "annual", conversion = "sum")))
-
-
-  am_m_average <- predict(td(airmiles ~ 1, to = "monthly", method = "denton-cholette", conversion = "average"))
-  stopifnot(all.equal(airmiles, ta(am_m_average, to = "annual", conversion = "average")))
-  stopifnot(all.equal(am_m_average, ta(am_m_average, to = 12, conversion = "average")))
-
-  am_q_average <- ta(am_m_average, to = "quarterly", conversion = "average")
-  stopifnot(all.equal(airmiles, ta(am_q_average, to = "annual", conversion = "average")))
-  stopifnot(all.equal(am_q_average, ta(am_q_average, to = 4, conversion = "average")))
-
-  am_s_average <- ta(am_q_average, to = 2, conversion = "average")
-  stopifnot(all.equal(airmiles, ta(am_s_average, to = "annual", conversion = "average")))
-  stopifnot(all.equal(am_s_average, ta(am_s_average, to = 2, conversion = "average")))
-
-  am_y_average <- ta(am_s_average, to = "annual", conversion = "average")
-  stopifnot(all.equal(airmiles, ta(am_y_average, to = "annual", conversion = "average")))
-
-
-  am_m_first <- predict(td(airmiles ~ 1, to = "monthly", method = "denton-cholette", conversion = "first"))
-  stopifnot(all.equal(airmiles, ta(am_m_first, to = "annual", conversion = "first")))
-  stopifnot(all.equal(am_m_first, ta(am_m_first, to = 12, conversion = "first")))
-
-  am_q_first <- ta(am_m_first, to = "quarterly", conversion = "first")
-  stopifnot(all.equal(airmiles, ta(am_q_first, to = "annual", conversion = "first")))
-  stopifnot(all.equal(am_q_first, ta(am_q_first, to = 4, conversion = "first")))
-
-  am_s_first <- ta(am_q_first, to = 2, conversion = "first")
-  stopifnot(all.equal(airmiles, ta(am_s_first, to = "annual", conversion = "first")))
-  stopifnot(all.equal(am_s_first, ta(am_s_first, to = 2, conversion = "first")))
-
-  am_y_first <- ta(am_s_first, to = "annual", conversion = "first")
-  stopifnot(all.equal(airmiles, ta(am_y_first, to = "annual", conversion = "first")))
-
-
-  am_m_last <- predict(td(airmiles ~ 1, to = "monthly", method = "denton-cholette", conversion = "last"))
-  stopifnot(all.equal(airmiles, ta(am_m_last, to = "annual", conversion = "last")))
-  stopifnot(all.equal(am_m_last, ta(am_m_last, to = 12, conversion = "last")))
-
-  am_q_last <- ta(am_m_last, to = "quarterly", conversion = "last")
-  stopifnot(all.equal(airmiles, ta(am_q_last, to = "annual", conversion = "last")))
-  stopifnot(all.equal(am_q_last, ta(am_q_last, to = 4, conversion = "last")))
-
-  am_s_last <- ta(am_q_last, to = 2, conversion = "last")
-  stopifnot(all.equal(airmiles, ta(am_s_last, to = "annual", conversion = "last")))
-  stopifnot(all.equal(am_s_last, ta(am_s_last, to = 2, conversion = "last")))
-
-  am_y_last <- ta(am_s_last, to = "annual", conversion = "last")
-  stopifnot(all.equal(airmiles, ta(am_y_last, to = "annual", conversion = "last")))
-}
diff --git a/tests/testthat/helper-fixtures.R b/tests/testthat/helper-fixtures.R
new file mode 100644
index 0000000..01e3221
--- /dev/null
+++ b/tests/testthat/helper-fixtures.R
@@ -0,0 +1,127 @@
+# Test Fixtures
+# ==============
+# Test data used across multiple test files.
+
+# Additional Test Data
+# --------------------
+# The swisspharma dataset in the package doesn't include monthly imports,
+# but we need it for quarter-to-month disaggregation tests.
+
+# Monthly imports (full series 1972-2011)
+imports.m <- ts(
+  c(
+    256.023, 250.435, 283.282, 253.186, 270.172, 277.821, 248.297, 266.026,
+    243.617, 287.12, 287.573, 252.667, 290.867, 266.997, 301.148, 255.017,
+    313.349, 293.94, 297.728, 298.575, 279.209, 354.624, 327.204, 288.303,
+    381.248, 399.54, 421.689, 442.056, 454.929, 417.335, 471.753, 412.143,
+    410.699, 449.952, 390.984, 360.325, 377.846, 348.565, 328.617, 362.339,
+    326.704, 320.706, 307.474, 263.728, 300.691, 312.609, 273.079, 310.238,
+    322.766, 302.769, 366.396, 345.068, 349.797, 371.673, 363.255, 318.451,
+    354.661, 377.687, 366.412, 380.27, 348.344, 361.915, 469.46, 385.619,
+    402.251, 425.568, 381.722, 373.83, 387.026, 372.677, 373.833, 367.666,
+    353.299, 325.657, 398.132, 363.648, 371.463, 395.33, 347.052, 327.108,
+    336.313, 365.349, 374.156, 364.969, 372.517, 390.605, 455.901, 410.363,
+    474.881, 447.255, 492.271, 429.349, 396.557, 491.75, 473.974, 447.611,
+    508.308, 543.345, 613.658, 555.211, 518.097, 557.8, 528.644, 441.998,
+    505.111, 541.337, 489.131, 479.235, 477.164, 548.372, 600.288, 544.257,
+    536.997, 573.378, 558.802, 483.732, 584.199, 554.091, 532.345, 514.071,
+    498.858, 532.813, 605.468, 540.336, 502.456, 589.41, 552.583, 490.637,
+    557.648, 546.874, 611.827, 573.287, 520.855, 552.276, 628.397, 562.82,
+    595.237, 620.29, 532.652, 524.202, 605.422, 614.217, 634.796, 583.545,
+    624.459, 644.974, 684.1, 614.017, 706.173, 645.976, 673.155, 617.532,
+    618.901, 742.922, 706.572, 603.476, 702.3, 728.957, 773.479, 802.739,
+    764.926, 749.956, 789.231, 625.927, 707.533, 822.065, 732.364, 705,
+    770.808, 708.803, 709.606, 816.367, 688.227, 748.127, 729.573, 583.688,
+    690.34, 724.185, 632.529, 627.196, 633.493, 665.91, 759.194, 677.527,
+    648.057, 711.384, 696.895, 660.894, 716.334, 744.142, 713.546, 707.224,
+    649.853684, 738.637718, 854.374321, 742.07786, 761.530108, 803.471103, 765.663723, 743.201562,
+    807.477359, 849.101196, 839.749567, 819.775699, 823.139315, 863.82257, 910.312369, 948.320254,
+    943.767869, 965.381616, 882.81773, 806.538436, 870.403378, 930.843009, 941.18064, 833.399978,
+    900.569345, 892.943121, 982.207198, 869.852232, 922.132386, 897.017945, 889.450238, 814.838304,
+    823.463517, 947.234, 934.859834, 749.896447, 909.995603, 877.653646, 924.554234, 953.102123,
+    874.657639, 864.712768, 936.815183, 781.811067, 844.285373, 951.11336, 953.08811, 801.422203,
+    969.432144, 962.717624, 1032.160663, 979.796666, 878.746375, 1084.536279, 1004.242024, 797.424572,
+    942.203021, 1014.342963, 943.087751, 844.730289, 877.197396, 935.850345, 990.613421, 1045.355598,
+    911.7985, 1071.036944, 983.542035, 931.788749, 1005.149728, 1023.570638, 1083.974225, 994.27343,
+    925.542958, 961.324318, 1141.559016, 1015.794971, 995.946353, 1108.704016, 991.170136, 965.911537,
+    1110.315576, 1088.439279, 1151.425697, 1084.536111, 892.942987, 1011.386831, 1191.088837, 1055.233206,
+    1164.778306, 1220.699017, 954.017385, 1065.074432, 1050.282558, 1211.497701, 1230.772374, 934.491792,
+    1117.940832, 1105.884067, 1164.464032, 1137.771115, 1142.983939, 1143.479679, 1222.787546, 941.710043,
+    1069.056518, 1287.574545, 1172.485816, 1014.136144, 1283.194662, 1215.865745, 1308.954449, 1665.189493,
+    1299.42468, 1377.733495, 1561.024088, 1290.438757, 1404.380276, 1694.058835, 1343.910077, 1349.139789,
+    1378.29203, 1429.066782, 1513.12955, 1534.765256, 1426.596905, 1689.627969, 1605.763597, 1302.264149,
+    1479.736706, 1536.9538, 1545.685597, 1354.795672, 1246.379968, 1384.626963, 1727.330378, 1519.574174,
+    1494.004253, 1688.20325, 1617.579509, 1557.713608, 1742.781819, 1655.823172, 1798.522506, 1889.559974,
+    1569.419301, 1624.43456, 1859.809472, 1691.837966, 1840.880653, 1841.39625, 1958.426633, 1751.29015,
+    1556.010748, 2158.370577, 2200.194679, 1846.430779, 1977.427947, 2017.924831, 2307.182424, 2387.575063,
+    2192.471887, 2214.430787, 2368.540639, 2165.161837, 1915.767307, 2654.724226, 2332.033258, 1723.036311,
+    2145.620137, 2440.366115, 2065.739817, 3006.95051, 2152.623157, 2530.930639, 2605.691911, 1911.482088,
+    2135.777895, 2415.454168, 2217.36664, 1811.378315, 3054.139064, 2161.265718, 2276.422648, 2494.414188,
+    2213.662651, 2123.939662, 2551.003326, 1860.79875, 2031.994091, 2255.120215, 2334.789703, 2131.80478,
+    2375.260974, 2100.748012, 2733.887162, 2720.923873, 1987.908351, 2554.891595, 2540.355065, 2449.293485,
+    2435.316254, 2531.132379, 2689.386239, 2487.624126, 2181.894195, 2827.193661, 2752.258764, 3279.007336,
+    2580.31877, 2578.08621, 2718.790406, 2839.672106, 2482.377636, 2742.936564, 3361.985319, 2451.938286,
+    2723.652472, 2605.284815, 3164.751159, 2977.561226, 2919.095822, 3483.681814, 2757.692421, 2899.319914,
+    2460.303247, 3390.743102, 3492.745143, 2910.040098, 3359.350231, 3044.815723, 3898.104321, 3210.065533,
+    3571.594159, 3484.329545, 3879.1574, 3224.839838, 3136.721911, 3871.350169, 3636.878671, 2942.548833,
+    3000.945262, 3378.486216, 3103.639648, 3618.306286, 3326.510975, 3319.897425, 3641.982211, 2796.410192,
+    2965.381075, 3028.958747, 2935.070907, 3156.839818, 2754.693764, 2799.420143, 2874.024209, 2821.869027,
+    2934.746297, 3224.896646, 3282.17346, 2544.562596, 3117.010935, 2933.546051, 2796.994439, 2879.897837,
+    2663.075206, 3273.633506, 3444.042805, 3054.888187, 3270.736694, 3292.534326, 3184.215019, 3228.878501,
+    2654.329812, 3121.976357, 3539.051135, 3059.332011, 2942.13803, 2945.558001, 3634.153528, 3557.971786,
+    3195.295399, 2923.477021
+  ),
+  start = c(1972, 1),
+  frequency = 12
+)
+
+
+# Reference Values for Regression Tests
+# --------------------------------------
+# These are expected outputs from tempdisagg v0.24.1 for comparison
+
+# Year to quarter conversion - first 10 values for key methods
+reference_y2q <-
+  list(
+    dencho_p_1 = rep(NA_real_, 10L),
+    dencho_p_2 = rep(NA_real_, 10L),
+    cl_rss_R = c(
+      31.0648296314, 31.376628094, 29.9492852367, 32.3700157927, 32.4855992935,
+      32.9370177056, 32.9416949892, 34.2025283839, 39.4907189242, 40.6948442203
+    ),
+    cl_log = c(
+      30.8957937267, 31.2145424609, 29.7518464152, 32.2513261944, 32.3279995961,
+      32.8269209836, 32.8317836851, 34.0730685505, 39.4243199059, 40.7028002148
+    ),
+    fer = c(
+      30.6645443975, 30.8809117534, 29.9338961272, 31.5300107504, 31.7254275179,
+      31.9913519817, 32.060256688, 33.1479292732, 36.9901490699, 38.153782642
+    ),
+    lit_rss = c(
+      24.3686906726, 24.5556141176, 24.8805391048, 25.0169084874, 25.9365352397,
+      26.2217041913, 27.0337754387, 28.6411343647, 30.3927507945, 32.4751826273
+    )
+  )
+
+# Quarter to month conversion - first 10 values for key methods
+reference_q2m <-
+  list(
+    dencho_p_1 = rep(NA_real_, 10L),
+    dencho_p_2 = rep(NA_real_, 10L),
+    cl_rss_R = c(
+      10.3180800327, 10.1522044102, 11.5193547929, 10.636927362, 10.4999046226,
+      11.1754442577, 10.8117721231, 10.0073754759, 9.9693788871, 10.8083334286
+    ),
+    cl_log = c(
+      10.4719212312, 10.305063411, 11.7006461437, 10.8134260502, 10.6428781463,
+      11.3455286026, 11.0059032067, 10.1287376864, 10.1226699053, 10.9438170138
+    ),
+    fer = c(
+      10.766518281, 10.6019129351, 11.9999366552, 11.1254221699, 10.9218344627,
+      11.6394881791, 11.3326631072, 10.3941167125, 10.4225413312, 11.2073635473
+    ),
+    lit_rss = c(
+      11.40765992, 11.2361792056, 12.6989066457, 11.788044205, 11.5656142196,
+      12.3204628141, 12.0090811809, 11.0098790169, 11.049585857, 11.8598712394
+    )
+  )
diff --git a/tests/testthat/test-aggregation.R b/tests/testthat/test-aggregation.R
new file mode 100644
index 0000000..eb74331
--- /dev/null
+++ b/tests/testthat/test-aggregation.R
@@ -0,0 +1,161 @@
+# Tests for ta() - Temporal Aggregation Function
+# ================================================
+# These tests verify that the ta() function correctly aggregates time series
+# across different frequencies and conversion methods.
+
+library(testthat)
+library(tempdisagg)
+
+# Basic Aggregation Tests (CRAN-safe)
+# ----------------------------------------------------------------------------
+
+test_that("ta() performs basic sum aggregation", {
+  # Monthly to annual
+  x <- ts(rep(1, 23), frequency = 12, start = c(2000, 2))
+  result <- ta(x, to = "annual", conversion = "sum")
+
+  expect_equal(result, ts(12, start = 2001))
+  expect_s3_class(result, "ts")
+})
+
+test_that("ta() performs basic average aggregation", {
+  x <- ts(rep(12, 24), frequency = 12, start = c(2000, 1))
+  result <- ta(x, to = "annual", conversion = "average")
+
+  expect_equal(result, ts(c(12, 12), start = 2000))
+})
+
+test_that("ta() performs first aggregation", {
+  x <- ts(1:12, frequency = 12, start = c(2000, 1))
+  result <- ta(x, to = "annual", conversion = "first")
+
+  expect_equal(result, ts(1, start = 2000))
+})
+
+test_that("ta() performs last aggregation", {
+  x <- ts(1:12, frequency = 12, start = c(2000, 1))
+  result <- ta(x, to = "annual", conversion = "last")
+
+  expect_equal(result, ts(12, start = 2000))
+})
+
+test_that("ta() handles quarterly to annual aggregation", {
+  x <- ts(c(1, 2, 3, 4), frequency = 4, start = c(2000, 1))
+  result <- ta(x, to = "annual", conversion = "sum")
+
+  expect_equal(result, ts(10, start = 2000))
+})
+
+test_that("ta() works with numeric frequency specification", {
+  x <- ts(1:12, frequency = 12, start = c(2000, 1))
+
+  # Using numeric frequency instead of "annual"
+  result_numeric <- ta(x, to = 1, conversion = "sum")
+  result_string <- ta(x, to = "annual", conversion = "sum")
+
+  expect_equal(result_numeric, result_string)
+})
+
+test_that("ta() preserves aggregation property with package data", {
+  # Use built-in swisspharma data
+  data(swisspharma)
+
+  # Quarterly to annual
+  annual_from_q <- ta(sales.q, to = "annual", conversion = "average")
+
+  # Check that it aggregates correctly
+  expect_s3_class(annual_from_q, "ts")
+  expect_equal(frequency(annual_from_q), 1)
+})
+
+
+# Edge Cases
+# ----------------------------------------------------------------------------
+
+test_that("ta() handles incomplete periods", {
+  # Start in middle of year - incomplete first year
+  x <- ts(rep(1, 22), frequency = 12, start = c(2000, 3))
+  result <- ta(x, to = "annual", conversion = "sum")
+
+  # Result should be a valid time series
+  expect_s3_class(result, "ts")
+  expect_equal(frequency(result), 1)
+
+  # Should aggregate the available data
+  expect_true(length(result) >= 1)
+})
+
+test_that("ta() works with different time series starts", {
+  x1 <- ts(1:8, frequency = 4, start = c(2000, 1))
+  x2 <- ts(1:8, frequency = 4, start = c(2000, 2))
+
+  r1 <- ta(x1, to = 1, conversion = "sum")
+  r2 <- ta(x2, to = 1, conversion = "sum")
+
+  # Both should produce valid results
+  expect_s3_class(r1, "ts")
+  expect_s3_class(r2, "ts")
+})
+
+
+# Multiple Frequency Conversions
+# ----------------------------------------------------------------------------
+
+test_that("ta() can aggregate from monthly to quarterly", {
+  x <- ts(1:12, frequency = 12, start = c(2000, 1))
+  result <- ta(x, to = "quarterly", conversion = "sum")
+
+  expect_equal(result, ts(c(6, 15, 24, 33), frequency = 4, start = c(2000, 1)))
+  expect_equal(frequency(result), 4)
+})
+
+test_that("ta() can aggregate from monthly to semi-annual", {
+  x <- ts(rep(1, 12), frequency = 12, start = c(2000, 1))
+  result <- ta(x, to = 2, conversion = "sum")
+
+  expect_equal(result, ts(c(6, 6), frequency = 2, start = c(2000, 1)))
+})
+
+
+# Conversion Method Tests
+# ----------------------------------------------------------------------------
+
+test_that("ta() conversion methods work", {
+  x <- ts(1:12, frequency = 12, start = c(2000, 1))
+
+  # Test the main conversion methods
+  r_avg <- ta(x, to = "annual", conversion = "average")
+  r_sum <- ta(x, to = "annual", conversion = "sum")
+
+  # Average and sum should give different results
+  expect_false(isTRUE(all.equal(r_avg, r_sum)))
+
+  # Both should be valid ts objects
+  expect_s3_class(r_avg, "ts")
+  expect_s3_class(r_sum, "ts")
+})
+
+test_that("ta() handles all conversion methods", {
+  x <- ts(1:24, frequency = 12, start = c(2000, 1))
+
+  # Should not error
+  expect_no_error(ta(x, to = "annual", conversion = "sum"))
+  expect_no_error(ta(x, to = "annual", conversion = "average"))
+  expect_no_error(ta(x, to = "annual", conversion = "first"))
+  expect_no_error(ta(x, to = "annual", conversion = "last"))
+})
+
+
+# Identity Property
+# ----------------------------------------------------------------------------
+
+test_that("ta() returns same series when aggregating to same frequency", {
+  x <- ts(1:12, frequency = 12, start = c(2000, 1))
+
+  # Aggregating monthly to monthly should return same (with appropriate tolerance)
+  result <- ta(x, to = 12, conversion = "sum")
+  expect_equal(result, x)
+
+  result_avg <- ta(x, to = 12, conversion = "average")
+  expect_equal(result_avg, x)
+})
diff --git a/tests/testthat/test-conversion-types.R b/tests/testthat/test-conversion-types.R
new file mode 100644
index 0000000..26fd12c
--- /dev/null
+++ b/tests/testthat/test-conversion-types.R
@@ -0,0 +1,233 @@
+# Comprehensive Tests for Conversion Types
+# =========================================
+# These tests verify that all conversion types (sum, average, first, last)
+# work correctly across multi-level aggregation chains.
+#
+# Based on lines 184-248 from the original tests/test-all.R
+# These tests can be slow, so they are skipped on CRAN.
+
+library(testthat)
+library(tempdisagg)
+
+# Multi-Level Aggregation Chains
+# ============================================================================
+# Tests verify that aggregation properties hold through multiple levels:
+# annual -> monthly -> quarterly -> semi-annual -> annual
+
+test_that("sum conversion preserves aggregation through multi-level chain", {
+  skip_on_cran() # Slow comprehensive test
+
+  # Use built-in airmiles dataset
+  am <- airmiles
+
+  # Disaggregate annual to monthly
+  am_m_sum <- predict(td(am ~ 1, to = "monthly", method = "denton-cholette", conversion = "sum"))
+
+  # Test 1: Monthly aggregates back to annual
+  expect_equal(am, ta(am_m_sum, to = "annual", conversion = "sum"))
+
+  # Test 2: Monthly to monthly (identity)
+  expect_equal(am_m_sum, ta(am_m_sum, to = 12, conversion = "sum"))
+
+  # Aggregate monthly to quarterly
+  am_q_sum <- ta(am_m_sum, to = "quarterly", conversion = "sum")
+
+  # Test 3: Quarterly aggregates back to annual
+  expect_equal(am, ta(am_q_sum, to = "annual", conversion = "sum"))
+
+  # Test 4: Quarterly to quarterly (identity)
+  expect_equal(am_q_sum, ta(am_q_sum, to = 4, conversion = "sum"))
+
+  # Aggregate quarterly to semi-annual
+  am_s_sum <- ta(am_q_sum, to = 2, conversion = "sum")
+
+  # Test 5: Semi-annual aggregates back to annual
+  expect_equal(am, ta(am_s_sum, to = "annual", conversion = "sum"))
+
+  # Test 6: Semi-annual to semi-annual (identity)
+  expect_equal(am_s_sum, ta(am_s_sum, to = 2, conversion = "sum"))
+
+  # Aggregate semi-annual to annual
+  am_y_sum <- ta(am_s_sum, to = "annual", conversion = "sum")
+
+  # Test 7: Annual matches original
+  expect_equal(am, ta(am_y_sum, to = "annual", conversion = "sum"))
+})
+
+
+test_that("average conversion preserves aggregation through multi-level chain", {
+  skip_on_cran() # Slow comprehensive test
+
+  am <- airmiles
+
+  # Disaggregate annual to monthly (average)
+  am_m_average <- predict(td(am ~ 1, to = "monthly", method = "denton-cholette", conversion = "average"))
+
+  # Test 1: Monthly aggregates back to annual
+  expect_equal(am, ta(am_m_average, to = "annual", conversion = "average"))
+
+  # Test 2: Monthly to monthly (identity)
+  expect_equal(am_m_average, ta(am_m_average, to = 12, conversion = "average"))
+
+  # Aggregate monthly to quarterly
+  am_q_average <- ta(am_m_average, to = "quarterly", conversion = "average")
+
+  # Test 3: Quarterly aggregates back to annual
+  expect_equal(am, ta(am_q_average, to = "annual", conversion = "average"))
+
+  # Test 4: Quarterly to quarterly (identity)
+  expect_equal(am_q_average, ta(am_q_average, to = 4, conversion = "average"))
+
+  # Aggregate quarterly to semi-annual
+  am_s_average <- ta(am_q_average, to = 2, conversion = "average")
+
+  # Test 5: Semi-annual aggregates back to annual
+  expect_equal(am, ta(am_s_average, to = "annual", conversion = "average"))
+
+  # Test 6: Semi-annual to semi-annual (identity)
+  expect_equal(am_s_average, ta(am_s_average, to = 2, conversion = "average"))
+
+  # Aggregate semi-annual to annual
+  am_y_average <- ta(am_s_average, to = "annual", conversion = "average")
+
+  # Test 7: Annual matches original
+  expect_equal(am, ta(am_y_average, to = "annual", conversion = "average"))
+})
+
+
+test_that("first conversion preserves aggregation through multi-level chain", {
+  skip_on_cran() # Slow comprehensive test
+
+  am <- airmiles
+
+  # Disaggregate annual to monthly (first)
+  am_m_first <- predict(td(am ~ 1, to = "monthly", method = "denton-cholette", conversion = "first"))
+
+  # Test 1: Monthly aggregates back to annual
+  expect_equal(am, ta(am_m_first, to = "annual", conversion = "first"))
+
+  # Test 2: Monthly to monthly (identity)
+  expect_equal(am_m_first, ta(am_m_first, to = 12, conversion = "first"))
+
+  # Aggregate monthly to quarterly
+  am_q_first <- ta(am_m_first, to = "quarterly", conversion = "first")
+
+  # Test 3: Quarterly aggregates back to annual
+  expect_equal(am, ta(am_q_first, to = "annual", conversion = "first"))
+
+  # Test 4: Quarterly to quarterly (identity)
+  expect_equal(am_q_first, ta(am_q_first, to = 4, conversion = "first"))
+
+  # Aggregate quarterly to semi-annual
+  am_s_first <- ta(am_q_first, to = 2, conversion = "first")
+
+  # Test 5: Semi-annual aggregates back to annual
+  expect_equal(am, ta(am_s_first, to = "annual", conversion = "first"))
+
+  # Test 6: Semi-annual to semi-annual (identity)
+  expect_equal(am_s_first, ta(am_s_first, to = 2, conversion = "first"))
+
+  # Aggregate semi-annual to annual
+  am_y_first <- ta(am_s_first, to = "annual", conversion = "first")
+
+  # Test 7: Annual matches original
+  expect_equal(am, ta(am_y_first, to = "annual", conversion = "first"))
+})
+
+
+test_that("last conversion preserves aggregation through multi-level chain", {
+  skip_on_cran() # Slow comprehensive test
+
+  am <- airmiles
+
+  # Disaggregate annual to monthly (last)
+  am_m_last <- predict(td(am ~ 1, to = "monthly", method = "denton-cholette", conversion = "last"))
+
+  # Test 1: Monthly aggregates back to annual
+  expect_equal(am, ta(am_m_last, to = "annual", conversion = "last"))
+
+  # Test 2: Monthly to monthly (identity)
+  expect_equal(am_m_last, ta(am_m_last, to = 12, conversion = "last"))
+
+  # Aggregate monthly to quarterly
+  am_q_last <- ta(am_m_last, to = "quarterly", conversion = "last")
+
+  # Test 3: Quarterly aggregates back to annual
+  expect_equal(am, ta(am_q_last, to = "annual", conversion = "last"))
+
+  # Test 4: Quarterly to quarterly (identity)
+  expect_equal(am_q_last, ta(am_q_last, to = 4, conversion = "last"))
+
+  # Aggregate quarterly to semi-annual
+  am_s_last <- ta(am_q_last, to = 2, conversion = "last")
+
+  # Test 5: Semi-annual aggregates back to annual
+  expect_equal(am, ta(am_s_last, to = "annual", conversion = "last"))
+
+  # Test 6: Semi-annual to semi-annual (identity)
+  expect_equal(am_s_last, ta(am_s_last, to = 2, conversion = "last"))
+
+  # Aggregate semi-annual to annual
+  am_y_last <- ta(am_s_last, to = "annual", conversion = "last")
+
+  # Test 7: Annual matches original
+  expect_equal(am, ta(am_y_last, to = "annual", conversion = "last"))
+})
+
+
+# Conversion Type Consistency Tests
+# ============================================================================
+
+test_that("different conversion types produce different but valid results", {
+  skip_on_cran()
+
+  am <- window(airmiles, start = 1950, end = 1955) # Smaller subset for speed
+
+  # Disaggregate with all methods
+  am_sum <- predict(td(am ~ 1, to = 12, method = "denton-cholette", conversion = "sum"))
+  am_avg <- predict(td(am ~ 1, to = 12, method = "denton-cholette", conversion = "average"))
+  am_first <- predict(td(am ~ 1, to = 12, method = "denton-cholette", conversion = "first"))
+  am_last <- predict(td(am ~ 1, to = 12, method = "denton-cholette", conversion = "last"))
+
+  # All should aggregate back correctly with their respective methods
+  expect_equal(am, ta(am_sum, to = 1, conversion = "sum"))
+  expect_equal(am, ta(am_avg, to = 1, conversion = "average"))
+  expect_equal(am, ta(am_first, to = 1, conversion = "first"))
+  expect_equal(am, ta(am_last, to = 1, conversion = "last"))
+
+  # Results should be different
+  expect_false(isTRUE(all.equal(am_sum, am_avg)))
+  expect_false(isTRUE(all.equal(am_sum, am_first)))
+  expect_false(isTRUE(all.equal(am_avg, am_last)))
+})
+
+
+# Test with Actual Package Data
+# ============================================================================
+
+test_that("conversion types work with swisspharma data", {
+  skip_on_cran()
+
+  data(swisspharma)
+
+  # Test with quarterly sales
+  q_data <- window(sales.q, end = c(1980, 4))
+
+  # Aggregate to annual with different methods
+  a_sum <- ta(q_data, to = "annual", conversion = "sum")
+  a_avg <- ta(q_data, to = "annual", conversion = "average")
+  a_first <- ta(q_data, to = "annual", conversion = "first")
+  a_last <- ta(q_data, to = "annual", conversion = "last")
+
+  # All should be valid time series
+  expect_s3_class(a_sum, "ts")
+  expect_s3_class(a_avg, "ts")
+  expect_s3_class(a_first, "ts")
+  expect_s3_class(a_last, "ts")
+
+  # All should have annual frequency
+  expect_equal(frequency(a_sum), 1)
+  expect_equal(frequency(a_avg), 1)
+  expect_equal(frequency(a_first), 1)
+  expect_equal(frequency(a_last), 1)
+})
diff --git a/tests/testthat/test-methods-chow-lin.R b/tests/testthat/test-methods-chow-lin.R
new file mode 100644
index 0000000..f282238
--- /dev/null
+++ b/tests/testthat/test-methods-chow-lin.R
@@ -0,0 +1,214 @@
+# Tests for Chow-Lin Methods
+# ===========================
+# Tests for Chow-Lin temporal disaggregation methods.
+# These are comprehensive tests that are skipped on CRAN.
+
+library(testthat)
+library(tempdisagg)
+
+# Load test data
+data(swisspharma)
+
+# Helper function for aggregation tests
+test_aggregation_holds <- function(model, original_data, tolerance = 1e-7) {
+  disagg <- predict(model)
+  aggregated <- ta(disagg, to = frequency(original_data), conversion = "sum")
+  # Window to match original data period
+  aggregated_windowed <- window(aggregated, start = start(original_data), end = end(original_data))
+  expect_equal(aggregated_windowed, original_data, tolerance = tolerance)
+}
+
+
+# Chow-Lin MinRSS Variants
+# ============================================================================
+
+test_that("chow-lin-minrss-ecotrim works correctly", {
+  skip_on_cran()
+
+  # Year to quarter disaggregation
+  m <- td(sales.a ~ exports.q + imports.q, method = "chow-lin-minrss-ecotrim", truncated.rho = -1)
+
+  expect_s3_class(m, "td")
+  expect_no_error(predict(m))
+  expect_no_error(summary(m))
+
+  # Test aggregation property
+  test_aggregation_holds(m, sales.a, tolerance = 1e-7)
+})
+
+
+test_that("chow-lin-minrss-quilis works correctly", {
+  skip_on_cran()
+
+  # Year to quarter disaggregation
+  m <- td(sales.a ~ exports.q + imports.q, method = "chow-lin-minrss-quilis", truncated.rho = -1)
+
+  expect_s3_class(m, "td")
+  expect_no_error(predict(m))
+  expect_no_error(summary(m))
+
+  # Test aggregation property
+  test_aggregation_holds(m, sales.a, tolerance = 1e-7)
+})
+
+
+test_that("chow-lin-minrss methods produce similar but not identical results", {
+  skip_on_cran()
+
+  # Use smaller data subset for speed
+  y <- window(sales.a, end = 1985)
+  x1 <- window(exports.q, end = c(1985, 4))
+  x2 <- window(imports.q, end = c(1985, 4))
+
+  m_ecotrim <- td(y ~ x1 + x2, method = "chow-lin-minrss-ecotrim", truncated.rho = -1)
+  m_quilis <- td(y ~ x1 + x2, method = "chow-lin-minrss-quilis", truncated.rho = -1)
+
+  r_ecotrim <- predict(m_ecotrim)
+  r_quilis <- predict(m_quilis)
+
+  # Both should aggregate correctly
+  test_aggregation_holds(m_ecotrim, y)
+  test_aggregation_holds(m_quilis, y)
+
+  # Results should be similar (correlation > 0.99) but not identical
+  expect_gt(cor(as.numeric(r_ecotrim), as.numeric(r_quilis)), 0.99)
+  expect_false(isTRUE(all.equal(r_ecotrim, r_quilis, tolerance = 1e-10)))
+})
+
+
+# Chow-Lin MaxLog
+# ============================================================================
+
+test_that("chow-lin-maxlog works correctly", {
+  skip_on_cran()
+
+  m <- td(sales.a ~ exports.q + imports.q, method = "chow-lin-maxlog", truncated.rho = -1)
+
+  expect_s3_class(m, "td")
+  expect_no_error(predict(m))
+  expect_no_error(summary(m))
+
+  # Test aggregation property
+  test_aggregation_holds(m, sales.a, tolerance = 1e-7)
+})
+
+
+test_that("chow-lin-maxlog differs from minrss methods", {
+  skip_on_cran()
+
+  y <- window(sales.a, end = 1985)
+  x1 <- window(exports.q, end = c(1985, 4))
+  x2 <- window(imports.q, end = c(1985, 4))
+
+  m_maxlog <- td(y ~ x1 + x2, method = "chow-lin-maxlog", truncated.rho = -1)
+  m_minrss <- td(y ~ x1 + x2, method = "chow-lin-minrss-ecotrim", truncated.rho = -1)
+
+  r_maxlog <- predict(m_maxlog)
+  r_minrss <- predict(m_minrss)
+
+  # Both should aggregate correctly
+  test_aggregation_holds(m_maxlog, y)
+  test_aggregation_holds(m_minrss, y)
+
+  # Results should be similar but not identical
+  expect_gt(cor(as.numeric(r_maxlog), as.numeric(r_minrss)), 0.95)
+  expect_false(isTRUE(all.equal(r_maxlog, r_minrss, tolerance = 1e-5)))
+})
+
+
+# Chow-Lin Fixed Rho
+# ============================================================================
+
+test_that("chow-lin-fixed works with specified rho", {
+  skip_on_cran()
+
+  # Test with rho = 0.6
+  m <- td(sales.a ~ exports.q + imports.q, method = "chow-lin-fixed", fixed.rho = 0.6)
+
+  expect_s3_class(m, "td")
+  expect_no_error(predict(m))
+  expect_no_error(summary(m))
+
+  # Test aggregation property
+  test_aggregation_holds(m, sales.a, tolerance = 1e-7)
+
+  # Check that rho is actually 0.6
+  expect_equal(m$rho, 0.6)
+})
+
+
+test_that("chow-lin-fixed works with different rho values", {
+  skip_on_cran()
+
+  y <- window(sales.a, end = 1985)
+  x1 <- window(exports.q, end = c(1985, 4))
+  x2 <- window(imports.q, end = c(1985, 4))
+
+  m_rho_0 <- td(y ~ x1 + x2, method = "chow-lin-fixed", fixed.rho = 0.0)
+  m_rho_05 <- td(y ~ x1 + x2, method = "chow-lin-fixed", fixed.rho = 0.5)
+  m_rho_09 <- td(y ~ x1 + x2, method = "chow-lin-fixed", fixed.rho = 0.9)
+
+  # All should work and aggregate correctly
+  test_aggregation_holds(m_rho_0, y)
+  test_aggregation_holds(m_rho_05, y)
+  test_aggregation_holds(m_rho_09, y)
+
+  # Results should differ based on rho
+  r0 <- predict(m_rho_0)
+  r05 <- predict(m_rho_05)
+  r09 <- predict(m_rho_09)
+
+  expect_false(isTRUE(all.equal(r0, r05)))
+  expect_false(isTRUE(all.equal(r05, r09)))
+})
+
+
+# Quarter to Month Disaggregation
+# ============================================================================
+
+test_that("chow-lin methods work for quarter to month disaggregation", {
+  skip_on_cran()
+
+  # Use smaller data subset
+  y <- window(sales.q, end = c(1985, 4))
+  x1 <- window(exports.m, end = c(1985, 12))
+  x2 <- window(imports.m, end = c(1985, 12))
+
+  m <- td(y ~ x1 + x2, method = "chow-lin-minrss-ecotrim", truncated.rho = -1)
+
+  expect_s3_class(m, "td")
+  expect_no_error(predict(m))
+
+  # Test aggregation property (with looser tolerance for monthly data)
+  test_aggregation_holds(m, y, tolerance = 1e-5)
+})
+
+
+# Edge Cases and Robustness
+# ============================================================================
+
+test_that("chow-lin works with single indicator", {
+  skip_on_cran()
+
+  y <- window(sales.a, end = 1985)
+  x <- window(exports.q, end = c(1985, 4))
+
+  m <- td(y ~ x, method = "chow-lin-minrss-ecotrim", truncated.rho = -1)
+
+  expect_s3_class(m, "td")
+  test_aggregation_holds(m, y)
+})
+
+
+test_that("chow-lin works with intercept-only model", {
+  skip_on_cran()
+
+  y <- window(sales.a, end = 1985)
+
+  # Note: intercept-only should probably use a different method like denton,
+  # but chow-lin should handle it gracefully or error informatively
+  expect_error(
+    td(y ~ 1, method = "chow-lin-minrss-ecotrim", truncated.rho = -1),
+    NA # NA means we expect no error, or we might expect a specific error
+  )
+})
diff --git a/tests/testthat/test-methods-denton.R b/tests/testthat/test-methods-denton.R
new file mode 100644
index 0000000..bef39c2
--- /dev/null
+++ b/tests/testthat/test-methods-denton.R
@@ -0,0 +1,304 @@
+# Tests for Denton and Denton-Cholette Methods
+# ==============================================
+# Tests for Denton and Denton-Cholette temporal disaggregation methods.
+# These are comprehensive tests that are skipped on CRAN.
+
+library(testthat)
+library(tempdisagg)
+
+# Load test data
+data(swisspharma)
+
+# Helper function for aggregation tests
+test_aggregation_holds <- function(model, original_data, tolerance = 1e-7) {
+  disagg <- predict(model)
+  aggregated <- ta(disagg, to = frequency(original_data), conversion = "sum")
+  aggregated_windowed <- window(aggregated, start = start(original_data), end = end(original_data))
+  expect_equal(aggregated_windowed, original_data, tolerance = tolerance)
+}
+
+
+# Denton-Cholette with Different h Values
+# ============================================================================
+
+test_that("denton-cholette works with h=0 (original difference)", {
+  skip_on_cran()
+
+  y <- window(sales.a, end = 1985)
+  m <- td(y ~ 1, to = 4, method = "denton-cholette", h = 0)
+
+  expect_s3_class(m, "td")
+  expect_no_error(predict(m))
+  test_aggregation_holds(m, y)
+})
+
+
+test_that("denton-cholette works with h=1 (first difference)", {
+  skip_on_cran()
+
+  y <- window(sales.a, end = 1985)
+  m <- td(y ~ 1, to = 4, method = "denton-cholette", h = 1)
+
+  expect_s3_class(m, "td")
+  expect_no_error(predict(m))
+  test_aggregation_holds(m, y)
+})
+
+
+test_that("denton-cholette works with h=2 (second difference)", {
+  skip_on_cran()
+
+  y <- window(sales.a, end = 1985)
+  m <- td(y ~ 1, to = 4, method = "denton-cholette", h = 2)
+
+  expect_s3_class(m, "td")
+  expect_no_error(predict(m))
+  test_aggregation_holds(m, y)
+})
+
+
+test_that("denton-cholette produces different results for different h values", {
+  skip_on_cran()
+
+  y <- window(sales.a, end = 1985)
+
+  m0 <- td(y ~ 1, to = 4, method = "denton-cholette", h = 0)
+  m1 <- td(y ~ 1, to = 4, method = "denton-cholette", h = 1)
+  m2 <- td(y ~ 1, to = 4, method = "denton-cholette", h = 2)
+
+  r0 <- predict(m0)
+  r1 <- predict(m1)
+  r2 <- predict(m2)
+
+  # All should aggregate correctly
+  test_aggregation_holds(m0, y)
+  test_aggregation_holds(m1, y)
+  test_aggregation_holds(m2, y)
+
+  # Results should differ
+  expect_false(isTRUE(all.equal(r0, r1)))
+  expect_false(isTRUE(all.equal(r1, r2)))
+  expect_false(isTRUE(all.equal(r0, r2)))
+})
+
+
+# Proportional vs Additive Criterion
+# ============================================================================
+
+test_that("denton-cholette works with proportional criterion", {
+  skip_on_cran()
+
+  y <- window(sales.a, end = 1985)
+  m <- td(y ~ 1, to = 4, method = "denton-cholette", h = 1, criterion = "proportional")
+
+  expect_s3_class(m, "td")
+  test_aggregation_holds(m, y)
+})
+
+
+test_that("denton-cholette works with additive criterion", {
+  skip_on_cran()
+
+  y <- window(sales.a, end = 1985)
+  m <- td(y ~ 1, to = 4, method = "denton-cholette", h = 1, criterion = "additive")
+
+  expect_s3_class(m, "td")
+  test_aggregation_holds(m, y)
+})
+
+
+test_that("proportional and additive criteria work correctly", {
+  skip_on_cran()
+
+  y <- window(sales.a, end = 1985)
+
+  m_prop <- td(y ~ 1, to = 4, method = "denton-cholette", h = 1, criterion = "proportional")
+  m_add <- td(y ~ 1, to = 4, method = "denton-cholette", h = 1, criterion = "additive")
+
+  r_prop <- predict(m_prop)
+  r_add <- predict(m_add)
+
+  # Both should aggregate correctly
+  test_aggregation_holds(m_prop, y)
+  test_aggregation_holds(m_add, y)
+
+  # Results may be similar or different depending on data characteristics
+  # Main requirement is that both produce valid results
+  expect_s3_class(r_prop, "ts")
+  expect_s3_class(r_add, "ts")
+})
+
+
+# Denton-Cholette with Indicator
+# ============================================================================
+
+test_that("denton-cholette works with indicator variable", {
+  skip_on_cran()
+
+  y <- window(sales.a, end = 1985)
+  x <- window(exports.q, end = c(1985, 4))
+
+  # No intercept model with indicator
+  m <- td(y ~ 0 + x, method = "denton-cholette", h = 1)
+
+  expect_s3_class(m, "td")
+  expect_no_error(predict(m))
+  test_aggregation_holds(m, y)
+})
+
+
+test_that("denton-cholette with indicator differs from without", {
+  skip_on_cran()
+
+  y <- window(sales.a, end = 1985)
+  x <- window(exports.q, end = c(1985, 4))
+
+  m_ind <- td(y ~ 0 + x, method = "denton-cholette", h = 1)
+  m_const <- td(y ~ 1, to = 4, method = "denton-cholette", h = 1)
+
+  r_ind <- predict(m_ind)
+  r_const <- predict(m_const)
+
+  # Both should aggregate correctly
+  test_aggregation_holds(m_ind, y)
+  test_aggregation_holds(m_const, y)
+
+  # Results should differ (indicator should follow x more closely)
+  expect_false(isTRUE(all.equal(r_ind, r_const)))
+})
+
+
+# Plain Denton Method
+# ============================================================================
+
+test_that("plain denton works with h=0", {
+  skip_on_cran()
+
+  y <- window(sales.a, end = 1985)
+  m <- td(y ~ 1, to = 4, method = "denton", h = 0)
+
+  expect_s3_class(m, "td")
+  test_aggregation_holds(m, y)
+})
+
+
+test_that("plain denton works with h=1", {
+  skip_on_cran()
+
+  y <- window(sales.a, end = 1985)
+  m <- td(y ~ 1, to = 4, method = "denton", h = 1)
+
+  expect_s3_class(m, "td")
+  test_aggregation_holds(m, y)
+})
+
+
+test_that("plain denton works with h=2", {
+  skip_on_cran()
+
+  y <- window(sales.a, end = 1985)
+  m <- td(y ~ 1, to = 4, method = "denton", h = 2)
+
+  expect_s3_class(m, "td")
+  test_aggregation_holds(m, y)
+})
+
+
+test_that("denton vs denton-cholette both work correctly", {
+  skip_on_cran()
+
+  y <- window(sales.a, end = 1985)
+
+  m_den <- td(y ~ 1, to = 4, method = "denton", h = 1)
+  m_dencho <- td(y ~ 1, to = 4, method = "denton-cholette", h = 1)
+
+  r_den <- predict(m_den)
+  r_dencho <- predict(m_dencho)
+
+  # Both should aggregate correctly
+  test_aggregation_holds(m_den, y)
+  test_aggregation_holds(m_dencho, y)
+
+  # Both should produce valid results
+  expect_s3_class(r_den, "ts")
+  expect_s3_class(r_dencho, "ts")
+
+  # Results may vary depending on implementation
+  expect_false(any(is.na(r_den)))
+  expect_false(any(is.na(r_dencho)))
+})
+
+
+# Denton with Different Criteria
+# ============================================================================
+
+test_that("plain denton works with proportional criterion", {
+  skip_on_cran()
+
+  y <- window(sales.a, end = 1985)
+  m <- td(y ~ 1, to = 4, method = "denton", h = 1, criterion = "proportional")
+
+  expect_s3_class(m, "td")
+  test_aggregation_holds(m, y)
+})
+
+
+test_that("plain denton works with additive criterion", {
+  skip_on_cran()
+
+  y <- window(sales.a, end = 1985)
+  m <- td(y ~ 1, to = 4, method = "denton", h = 1, criterion = "additive")
+
+  expect_s3_class(m, "td")
+  test_aggregation_holds(m, y)
+})
+
+
+# Quarter to Month Disaggregation
+# ============================================================================
+
+test_that("denton-cholette works for quarter to month disaggregation", {
+  skip_on_cran()
+
+  y <- window(sales.q, end = c(1985, 4))
+  m <- td(y ~ 1, to = 12, method = "denton-cholette", h = 1)
+
+  expect_s3_class(m, "td")
+  test_aggregation_holds(m, y, tolerance = 1e-5)
+})
+
+
+test_that("denton works for quarter to month disaggregation", {
+  skip_on_cran()
+
+  y <- window(sales.q, end = c(1985, 4))
+  m <- td(y ~ 1, to = 12, method = "denton", h = 1)
+
+  expect_s3_class(m, "td")
+  test_aggregation_holds(m, y, tolerance = 1e-5)
+})
+
+
+# Comprehensive Matrix of Methods
+# ============================================================================
+
+test_that("all denton method combinations work", {
+  skip_on_cran()
+
+  y <- window(sales.a, end = 1980) # Smaller data for speed
+
+  # Matrix of all combinations
+  methods <- c("denton", "denton-cholette")
+  h_values <- c(0, 1, 2)
+  criteria <- c("proportional", "additive")
+
+  for (method in methods) {
+    for (h in h_values) {
+      for (criterion in criteria) {
+        m <- td(y ~ 1, to = 4, method = method, h = h, criterion = criterion)
+        expect_s3_class(m, "td")
+        test_aggregation_holds(m, y, tolerance = 1e-7)
+      }
+    }
+  }
+})
diff --git a/tests/testthat/test-methods-other.R b/tests/testthat/test-methods-other.R
new file mode 100644
index 0000000..8e06cd9
--- /dev/null
+++ b/tests/testthat/test-methods-other.R
@@ -0,0 +1,305 @@
+# Tests for Other Disaggregation Methods
+# ========================================
+# Tests for Fernandez, Litterman, OLS, and Uniform methods.
+# These are comprehensive tests that are skipped on CRAN.
+
+library(testthat)
+library(tempdisagg)
+
+# Load test data
+data(swisspharma)
+
+# Helper function for aggregation tests
+test_aggregation_holds <- function(model, original_data, tolerance = 1e-7) {
+  disagg <- predict(model)
+  aggregated <- ta(disagg, to = frequency(original_data), conversion = "sum")
+  aggregated_windowed <- window(aggregated, start = start(original_data), end = end(original_data))
+  expect_equal(aggregated_windowed, original_data, tolerance = tolerance)
+}
+
+
+# Fernandez Method
+# ============================================================================
+
+test_that("fernandez method works correctly", {
+  skip_on_cran()
+
+  y <- window(sales.a, end = 1985)
+  x1 <- window(exports.q, end = c(1985, 4))
+  x2 <- window(imports.q, end = c(1985, 4))
+
+  m <- td(y ~ x1 + x2, method = "fernandez", truncated.rho = -1)
+
+  expect_s3_class(m, "td")
+  expect_no_error(predict(m))
+  expect_no_error(summary(m))
+
+  test_aggregation_holds(m, y)
+})
+
+
+test_that("fernandez works with single indicator", {
+  skip_on_cran()
+
+  y <- window(sales.a, end = 1985)
+  x <- window(exports.q, end = c(1985, 4))
+
+  m <- td(y ~ x, method = "fernandez", truncated.rho = -1)
+
+  expect_s3_class(m, "td")
+  test_aggregation_holds(m, y)
+})
+
+
+test_that("fernandez differs from chow-lin", {
+  skip_on_cran()
+
+  y <- window(sales.a, end = 1985)
+  x1 <- window(exports.q, end = c(1985, 4))
+  x2 <- window(imports.q, end = c(1985, 4))
+
+  m_fer <- td(y ~ x1 + x2, method = "fernandez", truncated.rho = -1)
+  m_cl <- td(y ~ x1 + x2, method = "chow-lin-minrss-ecotrim", truncated.rho = -1)
+
+  r_fer <- predict(m_fer)
+  r_cl <- predict(m_cl)
+
+  # Both should aggregate correctly
+  test_aggregation_holds(m_fer, y)
+  test_aggregation_holds(m_cl, y)
+
+  # Results should be similar but not identical
+  expect_gt(cor(as.numeric(r_fer), as.numeric(r_cl)), 0.95)
+  expect_false(isTRUE(all.equal(r_fer, r_cl, tolerance = 1e-5)))
+})
+
+
+# Litterman Methods
+# ============================================================================
+
+test_that("litterman-minrss works correctly", {
+  skip_on_cran()
+
+  y <- window(sales.a, end = 1985)
+  x1 <- window(exports.q, end = c(1985, 4))
+  x2 <- window(imports.q, end = c(1985, 4))
+
+  m <- td(y ~ x1 + x2, method = "litterman-minrss", truncated.rho = -1)
+
+  expect_s3_class(m, "td")
+  expect_no_error(predict(m))
+  expect_no_error(summary(m))
+
+  test_aggregation_holds(m, y)
+})
+
+
+test_that("litterman-maxlog works correctly", {
+  skip_on_cran()
+
+  y <- window(sales.a, end = 1985)
+  x1 <- window(exports.q, end = c(1985, 4))
+  x2 <- window(imports.q, end = c(1985, 4))
+
+  m <- td(y ~ x1 + x2, method = "litterman-maxlog", truncated.rho = -1)
+
+  expect_s3_class(m, "td")
+  expect_no_error(predict(m))
+  expect_no_error(summary(m))
+
+  test_aggregation_holds(m, y)
+})
+
+
+test_that("litterman-fixed works with specified rho", {
+  skip_on_cran()
+
+  y <- window(sales.a, end = 1985)
+  x1 <- window(exports.q, end = c(1985, 4))
+  x2 <- window(imports.q, end = c(1985, 4))
+
+  m <- td(y ~ x1 + x2, method = "litterman-fixed", fixed.rho = 0.6)
+
+  expect_s3_class(m, "td")
+  expect_no_error(predict(m))
+
+  test_aggregation_holds(m, y)
+  expect_equal(m$rho, 0.6)
+})
+
+
+test_that("litterman minrss and maxlog produce different results", {
+  skip_on_cran()
+
+  y <- window(sales.a, end = 1985)
+  x1 <- window(exports.q, end = c(1985, 4))
+  x2 <- window(imports.q, end = c(1985, 4))
+
+  m_minrss <- td(y ~ x1 + x2, method = "litterman-minrss", truncated.rho = -1)
+  m_maxlog <- td(y ~ x1 + x2, method = "litterman-maxlog", truncated.rho = -1)
+
+  r_minrss <- predict(m_minrss)
+  r_maxlog <- predict(m_maxlog)
+
+  # Both should aggregate correctly
+  test_aggregation_holds(m_minrss, y)
+  test_aggregation_holds(m_maxlog, y)
+
+  # Results should be similar but not identical
+  expect_gt(cor(as.numeric(r_minrss), as.numeric(r_maxlog)), 0.95)
+  expect_false(isTRUE(all.equal(r_minrss, r_maxlog, tolerance = 1e-5)))
+})
+
+
+# OLS Method
+# ============================================================================
+
+test_that("ols method works correctly", {
+  skip_on_cran()
+
+  y <- window(sales.a, end = 1985)
+  x1 <- window(exports.q, end = c(1985, 4))
+  x2 <- window(imports.q, end = c(1985, 4))
+
+  m <- td(y ~ x1 + x2, method = "ols")
+
+  expect_s3_class(m, "td")
+  expect_no_error(predict(m))
+  expect_no_error(summary(m))
+
+  test_aggregation_holds(m, y)
+})
+
+
+test_that("ols works with single indicator", {
+  skip_on_cran()
+
+  y <- window(sales.a, end = 1985)
+  x <- window(exports.q, end = c(1985, 4))
+
+  m <- td(y ~ x, method = "ols")
+
+  expect_s3_class(m, "td")
+  test_aggregation_holds(m, y)
+})
+
+
+test_that("ols is simpler than chow-lin", {
+  skip_on_cran()
+
+  y <- window(sales.a, end = 1985)
+  x1 <- window(exports.q, end = c(1985, 4))
+  x2 <- window(imports.q, end = c(1985, 4))
+
+  m_ols <- td(y ~ x1 + x2, method = "ols")
+  m_cl <- td(y ~ x1 + x2, method = "chow-lin-minrss-ecotrim", truncated.rho = -1)
+
+  # OLS should not have rho parameter (or rho should be 0)
+  expect_true(is.null(m_ols$rho) || m_ols$rho == 0)
+
+  # Chow-Lin should have estimated rho
+  expect_false(is.null(m_cl$rho))
+
+  # Both should work
+  test_aggregation_holds(m_ols, y)
+  test_aggregation_holds(m_cl, y)
+})
+
+
+# Uniform Method
+# ============================================================================
+
+test_that("uniform method works correctly", {
+  skip_on_cran()
+
+  y <- window(sales.a, end = 1985)
+
+  m <- td(y ~ 1, to = 4, method = "uniform")
+
+  expect_s3_class(m, "td")
+  expect_no_error(predict(m))
+
+  test_aggregation_holds(m, y)
+})
+
+
+test_that("uniform distributes values evenly", {
+  skip_on_cran()
+
+  # Simple test case
+  y <- ts(c(100, 100, 100), start = 2000, frequency = 1)
+
+  m <- td(y ~ 1, to = 4, method = "uniform")
+  result <- predict(m)
+
+  # Each quarter should be 25 (100/4)
+  expect_equal(
+    as.numeric(window(result, start = c(2000, 1), end = c(2000, 4))),
+    rep(25, 4)
+  )
+})
+
+
+test_that("uniform differs from denton methods", {
+  skip_on_cran()
+
+  y <- window(sales.a, end = 1985)
+
+  m_uni <- td(y ~ 1, to = 4, method = "uniform")
+  m_den <- td(y ~ 1, to = 4, method = "denton", h = 1)
+
+  r_uni <- predict(m_uni)
+  r_den <- predict(m_den)
+
+  # Both should aggregate correctly
+  test_aggregation_holds(m_uni, y)
+  test_aggregation_holds(m_den, y)
+
+  # Results should differ (uniform is flat within each year)
+  expect_false(isTRUE(all.equal(r_uni, r_den)))
+})
+
+
+# Quarter to Month Disaggregation
+# ============================================================================
+
+test_that("fernandez works for quarter to month disaggregation", {
+  skip_on_cran()
+
+  y <- window(sales.q, end = c(1985, 4))
+  x1 <- window(exports.m, end = c(1985, 12))
+  x2 <- window(imports.m, end = c(1985, 12))
+
+  m <- td(y ~ x1 + x2, method = "fernandez", truncated.rho = -1)
+
+  expect_s3_class(m, "td")
+  test_aggregation_holds(m, y, tolerance = 1e-5)
+})
+
+
+test_that("litterman works for quarter to month disaggregation", {
+  skip_on_cran()
+
+  y <- window(sales.q, end = c(1985, 4))
+  x1 <- window(exports.m, end = c(1985, 12))
+  x2 <- window(imports.m, end = c(1985, 12))
+
+  m <- td(y ~ x1 + x2, method = "litterman-minrss", truncated.rho = -1)
+
+  expect_s3_class(m, "td")
+  test_aggregation_holds(m, y, tolerance = 1e-5)
+})
+
+
+test_that("ols works for quarter to month disaggregation", {
+  skip_on_cran()
+
+  y <- window(sales.q, end = c(1985, 4))
+  x1 <- window(exports.m, end = c(1985, 12))
+  x2 <- window(imports.m, end = c(1985, 12))
+
+  m <- td(y ~ x1 + x2, method = "ols")
+
+  expect_s3_class(m, "td")
+  test_aggregation_holds(m, y, tolerance = 1e-5)
+})
diff --git a/tests/testthat/test_numeric.R b/tests/testthat/test-numeric-mode.R
similarity index 100%
rename from tests/testthat/test_numeric.R
rename to tests/testthat/test-numeric-mode.R
diff --git a/tests/testthat/test-numerical-regression.R b/tests/testthat/test-numerical-regression.R
new file mode 100644
index 0000000..aacbec0
--- /dev/null
+++ b/tests/testthat/test-numerical-regression.R
@@ -0,0 +1,255 @@
+# Numerical Regression Tests
+# ===========================
+# These tests compare current results against reference values from v0.24.1
+# to detect unintended numerical changes.
+#
+# Based on lines 120-161 from the original tests/test-all.R
+# Reference values are stored in tests/testthat/helper-fixtures.R
+
+library(testthat)
+library(tempdisagg)
+
+# Load test data
+data(swisspharma)
+
+test_that("year-to-quarter disaggregation matches reference values", {
+  skip_on_cran() # Numerical regression test
+
+  # Test a subset of key methods against reference values
+  # Reference values are first 10 quarters from v0.24.1
+
+  # Setup formulas (same as in original estimAll function)
+  formula1 <- sales.a ~ exports.q + imports.q
+
+  # Chow-Lin MinRSS (Ecotrim variant)
+  m_cl_rss <- td(formula1, method = "chow-lin-minrss-ecotrim", truncated.rho = -1)
+  result_cl_rss <- predict(m_cl_rss)
+
+  # Compare first 10 values to reference
+  expect_equal(
+    as.numeric(result_cl_rss[1:10]),
+    reference_y2q$cl_rss_R,
+    tolerance = 1e-8,
+    label = "chow-lin-minrss-ecotrim first 10 values"
+  )
+
+  # Chow-Lin MaxLog
+  m_cl_log <- td(formula1, method = "chow-lin-maxlog", truncated.rho = -1)
+  result_cl_log <- predict(m_cl_log)
+
+  expect_equal(
+    as.numeric(result_cl_log[1:10]),
+    reference_y2q$cl_log,
+    tolerance = 1e-8,
+    label = "chow-lin-maxlog first 10 values"
+  )
+
+  # Fernandez
+  m_fer <- td(formula1, method = "fernandez", truncated.rho = -1)
+  result_fer <- predict(m_fer)
+
+  expect_equal(
+    as.numeric(result_fer[1:10]),
+    reference_y2q$fer,
+    tolerance = 1e-8,
+    label = "fernandez first 10 values"
+  )
+
+  # Litterman MinRSS
+  m_lit_rss <- td(formula1, method = "litterman-minrss", truncated.rho = -1)
+  result_lit_rss <- predict(m_lit_rss)
+
+  expect_equal(
+    as.numeric(result_lit_rss[1:10]),
+    reference_y2q$lit_rss,
+    tolerance = 1e-5, # Looser tolerance for litterman methods
+    label = "litterman-minrss first 10 values"
+  )
+})
+
+
+test_that("quarter-to-month disaggregation matches reference values", {
+  skip_on_cran() # Numerical regression test
+
+  # Setup formulas
+  formula1 <- sales.q ~ exports.m + imports.m
+
+  # Chow-Lin MinRSS (Ecotrim variant)
+  m_cl_rss <- td(formula1, method = "chow-lin-minrss-ecotrim", truncated.rho = -1)
+  result_cl_rss <- predict(m_cl_rss)
+
+  expect_equal(
+    as.numeric(result_cl_rss[1:10]),
+    reference_q2m$cl_rss_R,
+    tolerance = 1e-7, # Slightly looser tolerance for monthly data
+    label = "chow-lin-minrss-ecotrim (q2m) first 10 values"
+  )
+
+  # Chow-Lin MaxLog
+  m_cl_log <- td(formula1, method = "chow-lin-maxlog", truncated.rho = -1)
+  result_cl_log <- predict(m_cl_log)
+
+  expect_equal(
+    as.numeric(result_cl_log[1:10]),
+    reference_q2m$cl_log,
+    tolerance = 1e-7,
+    label = "chow-lin-maxlog (q2m) first 10 values"
+  )
+
+  # Fernandez
+  m_fer <- td(formula1, method = "fernandez", truncated.rho = -1)
+  result_fer <- predict(m_fer)
+
+  expect_equal(
+    as.numeric(result_fer[1:10]),
+    reference_q2m$fer,
+    tolerance = 1e-7,
+    label = "fernandez (q2m) first 10 values"
+  )
+})
+
+
+test_that("denton methods work correctly", {
+  skip_on_cran() # Numerical regression test
+
+  formula2 <- sales.a ~ 1
+
+  # Denton-Cholette h=1 (proportional)
+  m_dencho_p_1 <- td(formula2, method = "denton-cholette", h = 1, to = 4)
+  result_dencho_p_1 <- predict(m_dencho_p_1)
+
+  # Check that results are reasonable (not NA, proper aggregation)
+  expect_false(any(is.na(result_dencho_p_1)))
+  aggregated <- ta(result_dencho_p_1, to = "annual", conversion = "sum")
+  expect_equal(
+    window(aggregated, start = start(sales.a), end = end(sales.a)),
+    sales.a,
+    tolerance = 1e-7
+  )
+
+  # Denton-Cholette h=2 (proportional)
+  m_dencho_p_2 <- td(formula2, method = "denton-cholette", h = 2, to = 4)
+  result_dencho_p_2 <- predict(m_dencho_p_2)
+
+  # Check that results are reasonable
+  expect_false(any(is.na(result_dencho_p_2)))
+  aggregated2 <- ta(result_dencho_p_2, to = "annual", conversion = "sum")
+  expect_equal(
+    window(aggregated2, start = start(sales.a), end = end(sales.a)),
+    sales.a,
+    tolerance = 1e-7
+  )
+
+  # Note: Reference values from v0.24.1 are NA for these methods,
+  # so we test aggregation property instead of exact values
+})
+
+
+test_that("aggregation property holds for all methods", {
+  skip_on_cran() # Comprehensive test
+
+  # Year to quarter
+  formula1_y2q <- sales.a ~ exports.q + imports.q
+  formula2_y2q <- sales.a ~ 1
+
+  # Test that all methods satisfy aggregation constraint
+  methods_with_indicators <- c(
+    "chow-lin-minrss-ecotrim", "chow-lin-minrss-quilis", "chow-lin-maxlog",
+    "fernandez", "litterman-minrss", "litterman-maxlog", "ols"
+  )
+
+  for (method in methods_with_indicators) {
+    m <- td(formula1_y2q, method = method, truncated.rho = if (method == "ols") NULL else -1)
+    result <- predict(m)
+    aggregated <- ta(result, to = "annual", conversion = "sum")
+    aggregated <- window(aggregated, start = start(sales.a), end = end(sales.a))
+
+    expect_equal(
+      aggregated, sales.a,
+      tolerance = 1e-7,
+      label = sprintf("%s aggregation property", method)
+    )
+  }
+
+  # Methods without indicators
+  methods_no_indicators <- c("denton-cholette", "denton", "uniform")
+
+  for (method in methods_no_indicators) {
+    m <- td(formula2_y2q, method = method, to = 4, h = if (method %in% c("denton-cholette", "denton")) 1 else NULL)
+    result <- predict(m)
+    aggregated <- ta(result, to = "annual", conversion = "sum")
+    aggregated <- window(aggregated, start = start(sales.a), end = end(sales.a))
+
+    expect_equal(
+      aggregated, sales.a,
+      tolerance = 1e-7,
+      label = sprintf("%s aggregation property", method)
+    )
+  }
+})
+
+
+test_that("quarter to month aggregation property holds", {
+  skip_on_cran() # Comprehensive test
+
+  formula1_q2m <- sales.q ~ exports.m + imports.m
+  formula2_q2m <- sales.q ~ 1
+
+  # Test with indicators
+  methods_with_indicators <- c(
+    "chow-lin-minrss-ecotrim", "fernandez", "litterman-minrss", "ols"
+  )
+
+  for (method in methods_with_indicators) {
+    m <- td(formula1_q2m, method = method, truncated.rho = if (method == "ols") NULL else -1)
+    result <- predict(m)
+    aggregated <- ta(result, to = "quarterly", conversion = "sum")
+    aggregated <- window(aggregated, start = start(sales.q), end = end(sales.q))
+
+    expect_equal(
+      aggregated, sales.q,
+      tolerance = 1e-5, # Looser tolerance for monthly disaggregation
+      label = sprintf("%s (q2m) aggregation property", method),
+      check.attributes = FALSE
+    )
+  }
+
+  # Test without indicators
+  m_den <- td(formula2_q2m, method = "denton-cholette", h = 1, to = 12)
+  result_den <- predict(m_den)
+  aggregated_den <- ta(result_den, to = "quarterly", conversion = "sum")
+  aggregated_den <- window(aggregated_den, start = start(sales.q), end = end(sales.q))
+
+  expect_equal(
+    aggregated_den, sales.q,
+    tolerance = 1e-5,
+    label = "denton-cholette (q2m) aggregation property",
+    check.attributes = FALSE
+  )
+})
+
+
+test_that("numerical stability over time", {
+  skip_on_cran() # Regression test
+
+  # This test ensures that the numerical results don't drift over package updates
+  # It uses a simple, controlled example
+
+  # Create simple test data
+  y_test <- ts(c(100, 110, 120, 130), start = 2000, frequency = 1)
+  x_test <- ts(rep(c(24, 25, 26, 27), each = 4), start = c(2000, 1), frequency = 4)
+
+  # Run disaggregation
+  m_test <- td(y_test ~ x_test, method = "chow-lin-minrss-ecotrim", truncated.rho = -1)
+  result_test <- predict(m_test)
+
+  # Check that results are reasonable (mean of quarterly should match mean of annual when multiplied by frequency)
+  # Mean of disaggregated quarterly: should be annual mean / 4
+  expect_lt(abs(mean(result_test) - mean(y_test) / 4), 1.0)
+
+  # Check that aggregation holds exactly
+  aggregated_test <- ta(result_test, to = "annual", conversion = "sum")
+  aggregated_test <- window(aggregated_test, start = start(y_test), end = end(y_test))
+
+  expect_equal(aggregated_test, y_test, tolerance = 1e-10)
+})
diff --git a/tests/testthat/test_td.R b/tests/testthat/test-td-basic.R
similarity index 100%
rename from tests/testthat/test_td.R
rename to tests/testthat/test-td-basic.R
diff --git a/tests/testthat/test_misc.R b/tests/testthat/test-tsbox.R
similarity index 100%
rename from tests/testthat/test_misc.R
rename to tests/testthat/test-tsbox.R
diff --git a/tests/testthat/test_output.R b/tests/testthat/test_output.R
deleted file mode 100644
index c5912cb..0000000
--- a/tests/testthat/test_output.R
+++ /dev/null
@@ -1,15 +0,0 @@
-library(testthat)
-library(tempdisagg)
-
-context("output functions")
-
-m <- td(ts(c(1, 1, 1, 1)) ~ 1, to = 4, method = "fast")
-
-test_that("plot works", {
-  plot(m)
-  expect_null(NULL)
-})
-
-test_that("print works", {
-  expect_output(print(m))
-})
diff --git a/tests/testthat/test_ta.R b/tests/testthat/test_ta.R
deleted file mode 100644
index 90972c0..0000000
--- a/tests/testthat/test_ta.R
+++ /dev/null
@@ -1,4 +0,0 @@
-test_that("ta works", {
-  x <- ts(rep(1, 23), frequency = 12, start = c(2000, 2))
-  expect_equal(ta(x, to = "annual", conversion = "sum"), ts(12, start = 2001))
-})