test_that("average_spectra works - balanced spectra", {
  # Mock data for FTIR spectra
  ftir_data <- data.frame(
    sample_id = c("A", "A", "B", "B", "C", "C"),
    wavenumber = c(1000, 1050, 1000, 1050, 1000, 1050),
    absorbance = c(0.1, 0.2, 0.3, 0.4, 0.5, 0.6)
  )

  # Average spectra A and B
  average <- average_spectra(ftir_data, sample_ids = c("A", "B"), average_id = "average_AB")
  expect_equal(nrow(average), 2) # Expect 2 rows (wavenumbers)
  expect_equal(average$sample_id[1], "average_AB") # Expect new sample ID
  expect_equal(average$absorbance[average$wavenumber == 1000], 0.2) # Expect mean absorbance
  expect_equal(attr(average, "intensity"), "absorbance")

  # Average only sample A
  average <- average_spectra(ftir_data, sample_ids = "A", average_id = "average_A")
  expect_equal(nrow(average), 2) # Expect 2 rows (wavenumbers)
  expect_equal(average$sample_id[1], "average_A") # Expect new sample ID
  expect_equal(average$absorbance, ftir_data[ftir_data$sample_id == "A", ]$absorbance) # Expect original data for A
  expect_equal(attr(average, "intensity"), "absorbance")

  # Average all samples
  average <- average_spectra(ftir_data)
  expect_equal(nrow(average), 2) # Expect 3 rows (unique wavenumbers)
  expect_equal(average$sample_id[1], "averaged_spectra") # Expect default ID
  expect_equal(average$absorbance[average$wavenumber == 1000], 0.3) # Expect mean absorbance
  expect_equal(attr(average, "intensity"), "absorbance")

  # Test Transmittance
  ftir_transmittance <- ftir_data
  colnames(ftir_transmittance)[3] <- "transmittance"
  avg_trans <- average_spectra(ftir_transmittance)

  expect_equal(nrow(avg_trans), 2) # Expect 3 rows (unique wavenumbers)
  expect_equal(avg_trans$sample_id[1], "averaged_spectra") # Expect default ID
  expect_equal(avg_trans$transmittance[avg_trans$wavenumber == 1000], 0.3) # Expect mean absorbance
  expect_equal(average[, c("sample_id", "wavenumber")], avg_trans[, c("sample_id", "wavenumber")])
  expect_equal(average$absorbance, avg_trans$transmittance)
  expect_equal(attr(avg_trans, "intensity"), "transmittance")
  expect_equal(nrow(average), 2) # Expect 3 rows (unique wavenumbers)
  expect_equal(average$sample_id[1], "averaged_spectra") # Expect default ID
  expect_equal(average$absorbance[average$wavenumber == 1000], 0.3) # Expect mean absorbance

  expect_error(average_spectra("not_a_data_frame"))
  expect_error(average_spectra(ftir_data[, c("wavenumber", "absorbance")]), regexp = "is missing a column", fixed = TRUE)
  expect_error(average_spectra(ftir_data[, c("wavenumber", "sample_id")]), regexp = "must have one of", fixed = TRUE)
  expect_error(average_spectra(ftir_data[, c("sample_id", "absorbance")]), regexp = "is missing a column", fixed = TRUE)

  expect_error(average_spectra(ftir_data, sample_ids = "invalid_id"), regexp = "All provided", fixed = TRUE)

  expect_error(average_spectra(ftir_data, average_id = 10))

  ftir_data_mismatch <- ftir_data
  ftir_data_mismatch$wavenumber[ftir_data_mismatch$sample_id == "C"] <- c(1001, 1051)

  expect_warning(average_spectra(ftir_data_mismatch, sample_ids = c("A", "C")), regexp = "There is a mismatch in the wavenumber axis between sample_ids", fixed = TRUE)
})

test_that("average_spectra works unbalanced", {
  # Prep a non-balanced data set
  ftir_data <- biodiesel[biodiesel$sample_id %in% unique(biodiesel$sample_id)[1:3], ]

  # sample 2 has different wavenumbers
  ftir_data[ftir_data$sample_id == unique(ftir_data$sample_id)[2], ]$wavenumber <- ftir_data[ftir_data$sample_id == unique(ftir_data$sample_id)[2], ]$wavenumber + 0.05

  # sample 3 has different wavenumber range
  ftir_data <- ftir_data[!(ftir_data$sample_id %in% unique(ftir_data$sample_id)[3] & ftir_data$wavenumber > 3500), ]
  ftir_data <- ftir_data[!(ftir_data$sample_id %in% unique(ftir_data$sample_id)[3] & ftir_data$wavenumber < 1000), ]

  expect_warning(average_spectra(ftir_data), regexp = "There is a mismatch in the wavenumber axis between sample_ids", fixed = TRUE)

  suppressWarnings(avg_123 <- average_spectra(ftir_data))
  suppressWarnings(avg_12 <- average_spectra(ftir_data, sample_ids = unique(ftir_data$sample_id)[1:2]))
  suppressWarnings(avg_13 <- average_spectra(ftir_data, sample_ids = unique(ftir_data$sample_id)[c(1, 3)]))
  suppressWarnings(avg_23 <- average_spectra(ftir_data, sample_ids = unique(ftir_data$sample_id)[2:3]))

  # For now, just trying to test performance is consistent
  expect_equal(avg_123$wavenumber[1], 1000.7902)
  expect_equal(avg_12$wavenumber[1], 700.7895)
  expect_equal(tail(avg_12$wavenumber, 1), 3997.6198)
  expect_equal(tail(avg_123$wavenumber, 1), 3498.1066)

  expect_equal(nrow(avg_123), 1341)
  expect_equal(nrow(avg_12), 1770)
  expect_equal(nrow(avg_23), 1341)
  expect_equal(nrow(avg_13), 1340)

  expect_equal(mean(avg_12$absorbance), 0.04881436, tolerance = 1e-7)
  expect_equal(mean(avg_13$absorbance), 0.05684917, tolerance = 1e-7)
  expect_equal(mean(avg_23$absorbance), 0.05677168, tolerance = 1e-7)
  expect_equal(mean(avg_123$absorbance), 0.05678947, tolerance = 1e-7)

  expect_equal(attr(avg_12, "intensity"), "absorbance")
  expect_equal(attr(avg_13, "intensity"), "absorbance")
  expect_equal(attr(avg_23, "intensity"), "absorbance")
  expect_equal(attr(avg_123, "intensity"), "absorbance")
})

test_that("add_subtract_scalar_value works", {
  # Mock data for FTIR spectra
  ftir_data <- data.frame(
    sample_id = c("A", "A", "B", "B", "C"),
    wavenumber = c(1000, 1050, 1000, 1050, 1100),
    absorbance = c(0.1, 0.2, 0.3, 0.4, 0.5)
  )

  # Add 0.5 to absorbance of all samples
  modified_data <- add_scalar_value(ftir_data, value = 0.5)

  expect_equal(nrow(modified_data), nrow(ftir_data)) # Expect same number of rows
  expect_equal(modified_data$wavenumber, ftir_data$wavenumber) # Expect unchanged wavenumbers
  expect_equal(modified_data$absorbance, c(0.6, 0.7, 0.8, 0.9, 1.0)) # Expect modified absorbance
  expect_equal(attr(modified_data, "intensity"), "absorbance")

  # Add 1.0 to absorbance of samples A and B
  modified_data <- add_scalar_value(ftir_data, value = 1.0, sample_ids = c("A", "B"))

  expect_equal(modified_data$absorbance[modified_data$sample_id == "A"], c(1.1, 1.2)) # Expect modified absorbance for A
  expect_equal(modified_data$absorbance[modified_data$sample_id == "B"], c(1.3, 1.4)) # Expect modified absorbance for B
  expect_equal(modified_data$absorbance[modified_data$sample_id == "C"], 0.5) # Expect unchanged absorbance for C

  expect_error(add_scalar_value(ftir_data, value = "invalid"), regexp = "Provided `value` must be numeric", fixed = TRUE)
  expect_error(subtract_scalar_value(ftir_data, value = "invalid"), regexp = "Provided `value` must be numeric", fixed = TRUE)

  expect_error(add_scalar_value(ftir_data, value = 0.5, sample_ids = "invalid_id"), regexp = "All provided `sample_ids` must be in `ftir` data", fixed = TRUE)

  expect_equal(attr(modified_data, "intensity"), "absorbance")

  # Modify ftir_data to have transmittance instead of absorbance
  ftir_data_transmittance <- ftir_data
  ftir_data_transmittance$absorbance <- NULL
  ftir_data_transmittance$transmittance <- c(90, 80, 70, 60, 50)

  modified_data <- add_scalar_value(ftir_data_transmittance, value = 1)

  expect_equal(modified_data$transmittance, c(91, 81, 71, 61, 51)) # Expect modified transmittance
  expect_equal(attr(modified_data, "intensity"), "transmittance")

  modified_data <- subtract_scalar_value(ftir_data_transmittance, value = 1)
  expect_equal(modified_data$transmittance, c(89, 79, 69, 59, 49))
  expect_equal(attr(modified_data, "intensity"), "transmittance")
})


test_that("Baseline error checking works", {
  expect_error(recalculate_baseline("not_a_dataframe"), regexp = "must be a data frame. You provided a string", fixed = TRUE)

  expect_error(recalculate_baseline(biodiesel, method = "failure"), regexp = "must be a string", fixed = TRUE)

  expect_error(recalculate_baseline(biodiesel, individually = "failure"), regexp = "must be a boolean value", fixed = TRUE)

  expect_error(recalculate_baseline(biodiesel, sample_ids = "A"), regexp = "All provided `sample_ids` must be in `ftir` data.", fixed = TRUE)

  expect_error(recalculate_baseline(biodiesel, wavenumber_range = c(1, 2, 3)), regexp = "must be of length 1 or 2", fixed = TRUE)

  expect_error(recalculate_baseline(biodiesel, wavenumber_range = c("one", "two")), regexp = "`wavenumber_range` must be `numeric` or `NA`.", fixed = TRUE)

  expect_error(recalculate_baseline(biodiesel, method = "point", wavenumber_range = c(1, 2)), regexp = "must be one numeric value", fixed = TRUE)
  expect_error(recalculate_baseline(biodiesel, method = "point", wavenumber_range = NA), regexp = "must be a single numeric value", fixed = TRUE)

  expect_error(recalculate_baseline(biodiesel, method = "minimum", wavenumber_range = 1), regexp = "or two numeric values if `method = 'minimum'`", fixed = TRUE)
  expect_error(recalculate_baseline(biodiesel, method = "maximum", wavenumber_range = 1), regexp = "or two numeric values if `method = 'maximum'`", fixed = TRUE)

  expect_error(recalculate_baseline(biodiesel, method = "average", wavenumber_range = 1500), regexp = "must be two numeric values", fixed = TRUE)
})

test_that("Baseline - average works", {
  ftir_data <- data.frame(
    sample_id = c("A", "A", "A", "B", "B", "B", "C", "C", "C"),
    wavenumber = c(1000, 1025, 1050, 1000, 1025, 1050, 1000, 1025, 1050),
    absorbance = c(0.1, 0.2, 0.3, 0.2, 0.3, 0.4, 0.3, 0.4, 0.5)
  )

  expect_warning(recalculate_baseline(ftir_data, method = "average", individually = TRUE),
    regexp = "Adjusting spectra baseline by the average of all values is not analytically useful", fixed = TRUE
  )
  suppressWarnings(recalculated_ftir <- recalculate_baseline(ftir_data, method = "average", individually = TRUE))
  expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$absorbance, c(-0.1, 0, 0.1))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$absorbance, c(-0.1, 0, 0.1))
  expect_equal(attr(recalculated_ftir, "intensity"), "absorbance")

  suppressWarnings(recalculated_ftir <- recalculate_baseline(ftir_data, method = "average", individually = FALSE))
  expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$absorbance, c(-0.1, 0, 0.1))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$absorbance, c(0, 0.1, 0.2))
  expect_equal(attr(recalculated_ftir, "intensity"), "absorbance")

  recalculated_ftir <- recalculate_baseline(ftir_data, method = "average", wavenumber_range = c(1000, 1025), individually = TRUE)
  expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$absorbance, c(-0.05, 0.05, 0.15))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$absorbance, c(-0.05, 0.05, 0.15))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "C", ]$absorbance, c(-0.05, 0.05, 0.15))
  expect_equal(attr(recalculated_ftir, "intensity"), "absorbance")

  recalculated_ftir <- recalculate_baseline(ftir_data, method = "average", wavenumber_range = c(1000, 1025), individually = FALSE)
  expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$absorbance, c(-0.05, 0.05, 0.15))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$absorbance, c(0.05, 0.15, 0.25))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "C", ]$absorbance, c(0.15, 0.25, 0.35))
  expect_equal(attr(recalculated_ftir, "intensity"), "absorbance")

  suppressWarnings(recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = "A", method = "average", individually = TRUE))
  expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$absorbance, c(-0.1, 0.00, 0.1))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$absorbance, c(0.2, 0.3, 0.4))
  expect_equal(attr(recalculated_ftir, "intensity"), "absorbance")

  suppressWarnings(recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = "A", method = "average", individually = FALSE))
  expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$absorbance, c(-0.1, 0.0, 0.1))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$absorbance, c(0.2, 0.3, 0.4))
  expect_equal(attr(recalculated_ftir, "intensity"), "absorbance")

  suppressWarnings(recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "average", individually = TRUE))
  expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$absorbance, c(-0.1, 0.0, 0.1))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$absorbance, c(-0.1, 0.0, 0.1))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "C", ]$absorbance, c(0.3, 0.4, 0.5))
  expect_equal(attr(recalculated_ftir, "intensity"), "absorbance")

  suppressWarnings(recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "average", individually = FALSE))
  expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$absorbance, c(-0.1, 0.0, 0.1))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$absorbance, c(0, 0.1, 0.2))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "C", ]$absorbance, c(0.3, 0.4, 0.5))
  expect_equal(attr(recalculated_ftir, "intensity"), "absorbance")

  ftir_data$transmittance <- c(100, 90, 80, 90, 80, 70, 80, 70, 60)
  ftir_data$absorbance <- NULL

  expect_warning(recalculate_baseline(ftir_data, method = "average", individually = TRUE),
    regexp = "Adjusting spectra baseline by the average of all values is not analytically useful", fixed = TRUE
  )
  suppressWarnings(recalculated_ftir <- recalculate_baseline(ftir_data, method = "average", individually = TRUE))
  expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$transmittance, c(110, 100, 90))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$transmittance, c(110, 100, 90))
  expect_equal(attr(recalculated_ftir, "intensity"), "transmittance")

  suppressWarnings(recalculated_ftir <- recalculate_baseline(ftir_data, method = "average", individually = FALSE))
  expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$transmittance, c(110, 100, 90))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$transmittance, c(100, 90, 80))
  expect_equal(attr(recalculated_ftir, "intensity"), "transmittance")

  recalculated_ftir <- recalculate_baseline(ftir_data, method = "average", wavenumber_range = c(1000, 1025), individually = TRUE)
  expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$transmittance, c(105, 95, 85))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$transmittance, c(105, 95, 85))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "C", ]$transmittance, c(105, 95, 85))
  expect_equal(attr(recalculated_ftir, "intensity"), "transmittance")

  recalculated_ftir <- recalculate_baseline(ftir_data, method = "average", wavenumber_range = c(1000, 1025), individually = FALSE)
  expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$transmittance, c(105, 95, 85))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$transmittance, c(95, 85, 75))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "C", ]$transmittance, c(85, 75, 65))
  expect_equal(attr(recalculated_ftir, "intensity"), "transmittance")

  suppressWarnings(recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = "A", method = "average", individually = TRUE))
  expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$transmittance, c(110, 100, 90))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$transmittance, c(90, 80, 70))
  expect_equal(attr(recalculated_ftir, "intensity"), "transmittance")

  suppressWarnings(recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = "A", method = "average", individually = FALSE))
  expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$transmittance, c(110, 100, 90))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$transmittance, c(90, 80, 70))
  expect_equal(attr(recalculated_ftir, "intensity"), "transmittance")

  suppressWarnings(recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "average", individually = TRUE))
  expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$transmittance, c(110, 100, 90))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$transmittance, c(110, 100, 90))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "C", ]$transmittance, c(80, 70, 60))
  expect_equal(attr(recalculated_ftir, "intensity"), "transmittance")

  suppressWarnings(recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "average", individually = FALSE))
  expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$transmittance, c(110, 100, 90))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$transmittance, c(100, 90, 80))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "C", ]$transmittance, c(80, 70, 60))
  expect_equal(attr(recalculated_ftir, "intensity"), "transmittance")
})

test_that("Baseline - point works", {
  ftir_data <- data.frame(
    sample_id = c("A", "A", "A", "B", "B", "B", "C", "C", "C"),
    wavenumber = c(1000, 1025, 1050, 1000, 1025, 1050, 1000, 1025, 1050),
    absorbance = c(0.1, 0.2, 0.3, 0.2, 0.3, 0.4, 0.3, 0.4, 0.5)
  )

  recalculated_ftir <- recalculate_baseline(ftir_data, method = "point", wavenumber_range = 1000, individually = TRUE)
  expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$absorbance, c(0, 0.1, 0.2))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$absorbance, c(0, 0.1, 0.2))
  expect_equal(attr(recalculated_ftir, "intensity"), "absorbance")

  suppressWarnings(expect_warning(recalculate_baseline(ftir_data, method = "point", wavenumber_range = 500, individually = TRUE),
    regexp = "Provided wavenumber is not within spectral range", fixed = TRUE
  ))

  suppressWarnings(expect_warning(recalculate_baseline(ftir_data, method = "point", wavenumber_range = 1012.5, individually = TRUE),
    regexp = "No wavenumber values in spectra within 10 cm-1 of supplied point", fixed = TRUE
  ))

  recalculated_ftir <- recalculate_baseline(ftir_data, method = "point", wavenumber_range = 1000, individually = FALSE)
  expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$absorbance, c(0, 0.1, 0.2))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$absorbance, c(0.1, 0.2, 0.3))
  expect_equal(attr(recalculated_ftir, "intensity"), "absorbance")

  recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = "A", method = "point", wavenumber_range = 1000, individually = TRUE)
  expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$absorbance, c(0, 0.1, 0.2))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$absorbance, c(0.2, 0.3, 0.4))
  expect_equal(attr(recalculated_ftir, "intensity"), "absorbance")

  recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = "A", method = "point", wavenumber_range = 1000, individually = FALSE)
  expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$absorbance, c(0, 0.1, 0.2))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$absorbance, c(0.2, 0.3, 0.4))
  expect_equal(attr(recalculated_ftir, "intensity"), "absorbance")

  recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "point", wavenumber_range = 1000, individually = TRUE)
  expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$absorbance, c(0, 0.1, 0.2))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$absorbance, c(0, 0.1, 0.2))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "C", ]$absorbance, c(0.3, 0.4, 0.5))
  expect_equal(attr(recalculated_ftir, "intensity"), "absorbance")

  recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "point", wavenumber_range = 1000, individually = FALSE)
  expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$absorbance, c(0, 0.1, 0.2))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$absorbance, c(0.1, 0.2, 0.3))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "C", ]$absorbance, c(0.3, 0.4, 0.5))
  expect_equal(attr(recalculated_ftir, "intensity"), "absorbance")

  ftir_data$transmittance <- c(90, 80, 70, 80, 70, 60, 70, 60, 50)
  ftir_data$absorbance <- NULL

  recalculated_ftir <- recalculate_baseline(ftir_data, method = "point", wavenumber_range = 1000, individually = TRUE)
  expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$transmittance, c(100, 90, 80))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$transmittance, c(100, 90, 80))
  expect_equal(attr(recalculated_ftir, "intensity"), "transmittance")

  recalculated_ftir <- recalculate_baseline(ftir_data, method = "point", wavenumber_range = 1000, individually = FALSE)
  expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$transmittance, c(100, 90, 80))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$transmittance, c(90, 80, 70))
  expect_equal(attr(recalculated_ftir, "intensity"), "transmittance")

  recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = "A", method = "point", wavenumber_range = 1000, individually = TRUE)
  expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$transmittance, c(100, 90, 80))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$transmittance, c(80, 70, 60))
  expect_equal(attr(recalculated_ftir, "intensity"), "transmittance")

  recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = "A", method = "point", wavenumber_range = 1000, individually = FALSE)
  expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$transmittance, c(100, 90, 80))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$transmittance, c(80, 70, 60))
  expect_equal(attr(recalculated_ftir, "intensity"), "transmittance")

  recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "point", wavenumber_range = 1000, individually = TRUE)
  expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$transmittance, c(100, 90, 80))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$transmittance, c(100, 90, 80))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "C", ]$transmittance, c(70, 60, 50))
  expect_equal(attr(recalculated_ftir, "intensity"), "transmittance")

  recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "point", wavenumber_range = 1000, individually = FALSE)
  expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$transmittance, c(100, 90, 80))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$transmittance, c(90, 80, 70))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "C", ]$transmittance, c(70, 60, 50))
  expect_equal(attr(recalculated_ftir, "intensity"), "transmittance")
})

test_that("Baseline - minimum/maximum works", {
  ftir_data <- data.frame(
    sample_id = c("A", "A", "A", "B", "B", "B", "C", "C", "C"),
    wavenumber = c(1000, 1025, 1050, 1000, 1025, 1050, 1000, 1025, 1050),
    absorbance = c(0.1, 0.2, 0.3, 0.2, 0.3, 0.4, 0.3, 0.4, 0.5)
  )

  recalculated_ftir <- recalculate_baseline(ftir_data, method = "minimum", individually = TRUE)
  expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$absorbance, c(0, 0.1, 0.2))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$absorbance, c(0, 0.1, 0.2))
  expect_equal(
    recalculate_baseline(ftir_data, method = "minimum", individually = TRUE),
    recalculate_baseline(ftir_data, method = "maximum", individually = TRUE)
  )
  expect_equal(attr(recalculated_ftir, "intensity"), "absorbance")

  recalculated_ftir <- recalculate_baseline(ftir_data, method = "minimum", individually = FALSE)
  expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$absorbance, c(0, 0.1, 0.2))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$absorbance, c(0.1, 0.2, 0.3))
  expect_equal(
    recalculate_baseline(ftir_data, method = "minimum", individually = FALSE),
    recalculate_baseline(ftir_data, method = "maximum", individually = FALSE)
  )
  expect_equal(attr(recalculated_ftir, "intensity"), "absorbance")

  recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = "A", method = "minimum", individually = TRUE)
  expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$absorbance, c(0, 0.1, 0.2))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$absorbance, c(0.2, 0.3, 0.4))
  expect_equal(
    recalculate_baseline(ftir_data, sample_ids = "A", method = "minimum", individually = TRUE),
    recalculate_baseline(ftir_data, sample_ids = "A", method = "maximum", individually = TRUE)
  )
  expect_equal(attr(recalculated_ftir, "intensity"), "absorbance")

  recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = "A", method = "minimum", individually = FALSE)
  expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$absorbance, c(0, 0.1, 0.2))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$absorbance, c(0.2, 0.3, 0.4))
  expect_equal(
    recalculate_baseline(ftir_data, sample_ids = "A", method = "minimum", individually = FALSE),
    recalculate_baseline(ftir_data, sample_ids = "A", method = "maximum", individually = FALSE)
  )
  expect_equal(attr(recalculated_ftir, "intensity"), "absorbance")

  recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "minimum", individually = TRUE)
  expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$absorbance, c(0, 0.1, 0.2))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$absorbance, c(0, 0.1, 0.2))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "C", ]$absorbance, c(0.3, 0.4, 0.5))
  expect_equal(
    recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "minimum", individually = TRUE),
    recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "maximum", individually = TRUE)
  )
  expect_equal(attr(recalculated_ftir, "intensity"), "absorbance")

  recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "minimum", individually = FALSE)
  expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$absorbance, c(0, 0.1, 0.2))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$absorbance, c(0.1, 0.2, 0.3))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "C", ]$absorbance, c(0.3, 0.4, 0.5))
  expect_equal(
    recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "minimum", individually = FALSE),
    recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "maximum", individually = FALSE)
  )
  expect_equal(attr(recalculated_ftir, "intensity"), "absorbance")

  recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = c("A", "B"), wavenumber_range = c(1030, 1050), method = "minimum", individually = TRUE)
  expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$absorbance, c(-0.2, -0.1, 0.0))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$absorbance, c(-0.2, -0.1, 0.0))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "C", ]$absorbance, c(0.3, 0.4, 0.5))
  expect_equal(
    recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "minimum", wavenumber_range = c(1030, 1050), individually = TRUE),
    recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "maximum", wavenumber_range = c(1030, 1050), individually = TRUE)
  )
  expect_equal(attr(recalculated_ftir, "intensity"), "absorbance")

  recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = c("A", "B"), wavenumber_range = c(1030, 1050), method = "minimum", individually = FALSE)
  expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$absorbance, c(-0.2, -0.1, 0.0))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$absorbance, c(-0.1, 0.0, 0.1))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "C", ]$absorbance, c(0.3, 0.4, 0.5))
  expect_equal(
    recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "minimum", wavenumber_range = c(1030, 1050), individually = FALSE),
    recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "maximum", wavenumber_range = c(1030, 1050), individually = FALSE)
  )
  expect_equal(attr(recalculated_ftir, "intensity"), "absorbance")

  ftir_data$transmittance <- c(90, 80, 70, 80, 70, 60, 70, 60, 50)
  ftir_data$absorbance <- NULL

  recalculated_ftir <- recalculate_baseline(ftir_data, method = "minimum", individually = TRUE)
  expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$transmittance, c(100, 90, 80))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$transmittance, c(100, 90, 80))
  expect_equal(
    recalculate_baseline(ftir_data, method = "minimum", individually = TRUE),
    recalculate_baseline(ftir_data, method = "maximum", individually = TRUE)
  )
  expect_equal(attr(recalculated_ftir, "intensity"), "transmittance")

  recalculated_ftir <- recalculate_baseline(ftir_data, method = "minimum", individually = FALSE)
  expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$transmittance, c(100, 90, 80))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$transmittance, c(90, 80, 70))
  expect_equal(
    recalculate_baseline(ftir_data, method = "minimum", individually = FALSE),
    recalculate_baseline(ftir_data, method = "maximum", individually = FALSE)
  )
  expect_equal(attr(recalculated_ftir, "intensity"), "transmittance")

  recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = "A", method = "minimum", individually = TRUE)
  expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$transmittance, c(100, 90, 80))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$transmittance, c(80, 70, 60))
  expect_equal(
    recalculate_baseline(ftir_data, sample_ids = "A", method = "minimum", individually = TRUE),
    recalculate_baseline(ftir_data, sample_ids = "A", method = "maximum", individually = TRUE)
  )
  expect_equal(attr(recalculated_ftir, "intensity"), "transmittance")

  recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = "A", method = "minimum", individually = FALSE)
  expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$transmittance, c(100, 90, 80))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$transmittance, c(80, 70, 60))
  expect_equal(
    recalculate_baseline(ftir_data, sample_ids = "A", method = "minimum", individually = FALSE),
    recalculate_baseline(ftir_data, sample_ids = "A", method = "maximum", individually = FALSE)
  )
  expect_equal(attr(recalculated_ftir, "intensity"), "transmittance")

  recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "minimum", individually = TRUE)
  expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$transmittance, c(100, 90, 80))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$transmittance, c(100, 90, 80))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "C", ]$transmittance, c(70, 60, 50))
  expect_equal(
    recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "minimum", individually = TRUE),
    recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "maximum", individually = TRUE)
  )
  expect_equal(attr(recalculated_ftir, "intensity"), "transmittance")

  recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "minimum", individually = FALSE)
  expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$transmittance, c(100, 90, 80))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$transmittance, c(90, 80, 70))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "C", ]$transmittance, c(70, 60, 50))
  expect_equal(
    recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "minimum", individually = FALSE),
    recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "maximum", individually = FALSE)
  )
  expect_equal(attr(recalculated_ftir, "intensity"), "transmittance")

  recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = c("A", "B"), wavenumber_range = c(1030, 1050), method = "minimum", individually = TRUE)
  expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$transmittance, c(120, 110, 100))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$transmittance, c(120, 110, 100))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "C", ]$transmittance, c(70, 60, 50))
  expect_equal(
    recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "minimum", wavenumber_range = c(1030, 1050), individually = TRUE),
    recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "maximum", wavenumber_range = c(1030, 1050), individually = TRUE)
  )
  expect_equal(attr(recalculated_ftir, "intensity"), "transmittance")

  recalculated_ftir <- recalculate_baseline(ftir_data, sample_ids = c("A", "B"), wavenumber_range = c(1030, 1050), method = "minimum", individually = FALSE)
  expect_equal(nrow(recalculated_ftir), nrow(ftir_data))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "A", ]$transmittance, c(120, 110, 100))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "B", ]$transmittance, c(110, 100, 90))
  expect_equal(recalculated_ftir[recalculated_ftir$sample_id == "C", ]$transmittance, c(70, 60, 50))
  expect_equal(
    recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "minimum", wavenumber_range = c(1030, 1050), individually = FALSE),
    recalculate_baseline(ftir_data, sample_ids = c("A", "B"), method = "maximum", wavenumber_range = c(1030, 1050), individually = FALSE)
  )
  expect_equal(attr(recalculated_ftir, "intensity"), "transmittance")
})


test_that("Normalization works", {
  expect_error(normalize_spectra("not_a_dataframe"), regexp = "must be a data frame. You provided a string", fixed = TRUE)
  expect_error(normalize_spectra(biodiesel, sample_ids = "A"), regexp = "All provided `sample_ids` must be in `ftir` data.", fixed = TRUE)
  expect_error(normalize_spectra(biodiesel, wavenumber_range = c(1, 2, 3)), regexp = "must be of length 2", fixed = TRUE)
  expect_error(normalize_spectra(biodiesel, wavenumber_range = c("one", "two")), regexp = "`wavenumber_range` must be `numeric` or `NA`.", fixed = TRUE)
  expect_error(normalize_spectra(biodiesel, wavenumber_range = c(1, NA)), regexp = "`wavenumber_range` must be `numeric` or `NA`", fixed = TRUE)
  expect_error(normalize_spectra(biodiesel, wavenumber_range = 1500), regexp = "must be of length 2", fixed = TRUE)
  expect_error(normalize_spectra(absorbance_to_transmittance(biodiesel)), regexp = "Normalization of transmittance spectra not supported", fixed = TRUE)

  spectra <- data.frame(
    wavenumber = c(1, 2, 3, 4, 5, 6, 7, 8, 9, 10),
    absorbance = c(0.1, 0.3, 0.5, 0.7, 0.9, 1.1, 1.3, 1.5, 1.7, 1.9),
    sample_id = "test"
  )
  expect_equal(range(spectra$absorbance), c(0.1, 1.9))
  expect_equal(range(normalize_spectra(spectra)$absorbance), c(0.0, 1.0))
  expect_equal(range(normalize_spectra(spectra, wavenumber_range = c(1, 5))$absorbance), c(0.0, 2.25))
  expect_equal(range(normalize_spectra(spectra, wavenumber_range = c(6, 10))$absorbance), c(-1.25, 1))

  biodiesel_normal <- normalize_spectra(biodiesel, sample_ids = c("diesel_unknown"))

  expect_equal(
    range(biodiesel[biodiesel$sample_id == "biodiesel_0", "absorbance"]),
    range(biodiesel_normal[biodiesel_normal$sample_id == "biodiesel_0", "absorbance"])
  )
  expect_equal(range(biodiesel_normal[biodiesel_normal$sample_id == "diesel_unknown", "absorbance"]), c(0, 1))
  expect_equal(attr(biodiesel_normal, "intensity"), "normalized absorbance")
})


test_that("conversion between units works", {
  biodiesel_transmittance <- absorbance_to_transmittance(biodiesel)
  biodiesel_absorbance <- transmittance_to_absorbance(biodiesel_transmittance)
  expect_named(
    biodiesel_transmittance,
    c("wavenumber", "transmittance", "sample_id")
  )
  expect_named(
    transmittance_to_absorbance(biodiesel_transmittance),
    c("wavenumber", "absorbance", "sample_id")
  )

  expect_equal(attr(biodiesel_transmittance, "intensity"), "transmittance")
  expect_equal(attr(biodiesel_absorbance, "intensity"), "absorbance")

  biodiesel_normal <- normalize_spectra(biodiesel)
  biodiesel_normal_trans <- absorbance_to_transmittance(biodiesel_normal)
  expect_equal(attr(biodiesel_normal_trans, "intensity"), "normalized transmittance")
  expect_equal(attr(transmittance_to_absorbance(biodiesel_normal_trans), "intensity"), "normalized absorbance")

  expect_error(transmittance_to_absorbance(biodiesel),
    "`ftir` must be transmittance data or contain a `transmittance` column.",
    fixed = TRUE
  )
  expect_error(absorbance_to_transmittance(absorbance_to_transmittance(biodiesel)),
    "`ftir` must be absorbance data or contain a `absorbance` column.",
    fixed = TRUE
  )

  example_data <- data.frame(
    "wavenumber" = 1L,
    "absorbance" = c(0, .5, 1, 1.5, 2),
    "sample_id" = "test"
  )
  expect_equal(absorbance_to_transmittance(example_data)$transmittance,
    c(100, 31.62278, 10, 3.162278, 1),
    tolerance = 1e-4
  )

  example_data2 <- data.frame(
    "wavenumber" = 1L,
    "transmittance" = c(100, 50, 10, 5, 1),
    "sample_id" = "test"
  )
  expect_equal(transmittance_to_absorbance(example_data2)$absorbance,
    c(0, 0.30103, 1, 1.30103, 2),
    tolerance = 1e-4
  )

  example_data3 <- data.frame(
    "wavenumber" = 1L,
    "absorbance" = c(0, 0.5, 1, 1.5, 2),
    "sample_id" = "test",
    "transmittance" = c(100, 50, 10, 5, 1)
  )
  expect_error(absorbance_to_transmittance(example_data3),
    "`ftir` cannot contain both `absorbance` and `transmittance` columns.",
    fixed = TRUE
  )
  expect_error(transmittance_to_absorbance(example_data3),
    "`ftir` cannot contain both `absorbance` and `transmittance` columns.",
    fixed = TRUE
  )
})

test_that("Normalization carries thorugh other functions", {
  biodiesel_normal <- normalize_spectra(biodiesel, sample_ids = c("diesel_unknown"))

  expect_equal(
    range(biodiesel[biodiesel$sample_id == "biodiesel_0", "absorbance"]),
    range(biodiesel_normal[biodiesel_normal$sample_id == "biodiesel_0", "absorbance"])
  )
  expect_equal(range(biodiesel_normal[biodiesel_normal$sample_id == "diesel_unknown", "absorbance"]), c(0, 1))
  expect_equal(attr(biodiesel_normal, "intensity"), "normalized absorbance")

  expect_equal(attr(add_scalar_value(biodiesel_normal, 1), "intensity"), "normalized absorbance")
  expect_equal(attr(recalculate_baseline(biodiesel_normal, method = "point", wavenumber_range = 3900), "intensity"), "normalized absorbance")

  expect_equal(attr(absorbance_to_transmittance(biodiesel_normal), "intensity"), "normalized transmittance")
})