tests/testthat/test-SeaSondeRAPM.R

In SeaSondeR: Radial Metrics from SeaSonde HF-Radar Data

#### seasonder_createSeaSondeRAPM ####

#### All Tested Functions Exist ####
test_that("All tested functions exist", {
  funs <- c(
    "seasonder_createSeaSondeRAPM", "seasonder_disableMessages",
    "validate_SeaSondeRAPM_quality_matrix", "validate_SeaSondeRAPM_BEAR",
    "validate_SeaSondeRAPM_SiteOrigin", "validate_SeaSondeRAPM_AmplitudeFactors",
    "validate_SeaSondeRAPM_StationCode", "validate_SeaSondeRAPM_PhaseCorrections",
    "validate_SeaSondeRAPM_Type", "validate_SeaSondeRAPM_Creator",
    "validate_SeaSondeRAPM_SiteName", "validate_SeaSondeRAPM_FileName",
    "validate_SeaSondeRAPM_CreateTimeStamp", "validate_SeaSondeRAPM_ProcessingSteps",
    "validate_SeaSondeRAPM_AntennaBearing", "validate_SeaSondeRAPM_BearingResolution",
    "validate_SeaSondeRAPM_Smoothing", "validate_SeaSondeRAPM_CommentLine",
    "validate_SeaSondeRAPM_FileID",
    "seasonder_validateAttributesSeaSondeRAPM", "seasonder_initializeAttributesSeaSondeRAPM",
    "seasonder_setSeaSondeRAPM_quality_matrix", "seasonder_getSeaSondeRAPM_quality_matrix",
    "seasonder_setSeaSondeRAPM_BEAR", "seasonder_getSeaSondeRAPM_BEAR",
    "seasonder_setSeaSondeRAPM_PhaseCorrections", "seasonder_getSeaSondeRAPM_PhaseCorrections",
    "seasonder_setSeaSondeRAPM_Type", "seasonder_getSeaSondeRAPM_Type",
    "seasonder_setSeaSondeRAPM_Creator", "seasonder_getSeaSondeRAPM_Creator",
    "seasonder_setSeaSondeRAPM_SiteName", "seasonder_getSeaSondeRAPM_SiteName",
    "seasonder_setSeaSondeRAPM_SiteOrigin", "seasonder_getSeaSondeRAPM_SiteOrigin",
    "seasonder_setSeaSondeRAPM_FileName", "seasonder_getSeaSondeRAPM_FileName",
    "seasonder_setSeaSondeRAPM_CreateTimeStamp", "seasonder_getSeaSondeRAPM_CreateTimeStamp",
    "seasonder_setSeaSondeRAPM_ProcessingSteps", "seasonder_getSeaSondeRAPM_ProcessingSteps",
    "seasonder_setSeaSondeRAPM_AmplitudeFactors", "seasonder_getSeaSondeRAPM_AmplitudeFactors",
    "seasonder_setSeaSondeRAPM_AntennaBearing", "seasonder_getSeaSondeRAPM_AntennaBearing",
    "seasonder_setSeaSondeRAPM_StationCode", "seasonder_getSeaSondeRAPM_StationCode",
    "seasonder_setSeaSondeRAPM_BearingResolution", "seasonder_getSeaSondeRAPM_BearingResolution",
    "seasonder_setSeaSondeRAPM_Smoothing", "seasonder_getSeaSondeRAPM_Smoothing",
    "seasonder_setSeaSondeRAPM_CommentLine", "seasonder_getSeaSondeRAPM_CommentLine",
    "seasonder_setSeaSondeRAPM_FileID", "seasonder_getSeaSondeRAPM_FileID",
    "seasonder_smoothAPM", "seasonder_trimAPM", "seasonder_applyAPMAmplitudeAndPhaseCorrections",
    "seasonder_readSeaSondeRAPMFile", "seasonder_readPhaseFile",
    "SeaSondeRAPM_creation_step_text", "SeaSondeRAPM_antenna_bearing_override_step_text",
    "SeaSondeRAPM_smoothing_step_text", "SeaSondeRAPM_trimming_step_text",
    "SeaSondeRAPM_amplitude_and_phase_corrections_step_text", "SeaSondeRAPM_phase_correction_override_step_text",
    "SeaSondeRAPM_amplitude_factors_override_step_text", "SeaSondeRAPM_SiteOrigin_override_step_text",
    "seasonder_plotAPMLoops", "parse_metadata_line","seasonder_extrapolateAPM"
  )
  for (f in funs) {
    expect_true(exists(f, mode = "function"), info = paste("Function", f, "does not exist"))
  }
})



describe("seasonder_createSeaSondeRAPM", {

  it("returns an object of class 'SeaSondeRAPM'", {
    seasonder_disableMessages()
    result <- seasonder_createSeaSondeRAPM()
    expect_type(result, "complex")  # Expecting the underlying matrix to be complex
    expect_s3_class(result, "SeaSondeRAPM")
  })

  it("throws an error for non-matrix inputs", {
    seasonder_disableMessages()
    expect_error(
      seasonder_createSeaSondeRAPM("Not a matrix"),
      "seasonder_validateCalibrationMatrixSeaSondeRAPM: Input calibration_matrix must be a matrix."
    )
  })

  it("throws an error for matrices with rows != 3", {
    seasonder_disableMessages()
    expect_error(
      seasonder_createSeaSondeRAPM(matrix(complex(real = NA, imaginary = NA), nrow = 2, ncol = 0)),
      "seasonder_validateCalibrationMatrixSeaSondeRAPM: Calibration matrix must have three rows."
    )
  })

  it("throws an error for non-complex matrices", {
    seasonder_disableMessages()
    expect_error(
      seasonder_createSeaSondeRAPM(matrix(numeric(0), nrow = 3, ncol = 0)),
      "seasonder_validateCalibrationMatrixSeaSondeRAPM: Calibration matrix must contain complex numbers."
    )
  })

  # it("properly initializes attributes", {
  #   Type <- "Some Type"
  #   result <- seasonder_createSeaSondeRAPM(Type = Type)

  #   expect_equal(attributes(result)$Type, Type)
  #   expect_equal(attributes(result)$BEAR, numeric(0))
  #   expect_equal(attributes(result)$Creator, character(0))
  #   expect_equal(attributes(result)$SiteName, character(0))
  #   # Se asigna SiteOrigin con nombres para latitud y longitud:
  #   expect_equal(attributes(result)$SiteOrigin, c(Latitude = 0, Longitude = 0))
  #   expect_equal(attributes(result)$FileName, character(0))
  #   expect_equal(attributes(result)$ProcessingSteps, character(0))
  #   expect_equal(attributes(result)$AmplitudeFactors, numeric(2))
  #   expect_equal(attributes(result)$AntennaBearing, numeric(0))
  #   expect_equal(attributes(result)$StationCode, character(0))
  #   expect_equal(attributes(result)$BearingResolution, numeric(0))
  #   expect_equal(attributes(result)$Smoothing, numeric(0))
  #   expect_equal(attributes(result)$CommentLine, character(0))
  #   expect_equal(attributes(result)$FileID, character(0))
  #   expect_equal(attributes(result)$PhaseCorrections, numeric(2))

  #   # Verificar que 'quality_matrix' es una matriz compleja de 3 filas y 0 columnas
  #   expect_true(is.matrix(attributes(result)$quality_matrix))
  #   expect_true(is.complex(attributes(result)$quality_matrix))
  #   expect_equal(dim(attributes(result)$quality_matrix), c(3, 0))
  # })
})

#### Validation Functions ####
describe("Validation Functions", {

  it("validate_SeaSondeRAPM_quality_matrix works as expected", {
    seasonde_apm_obj <- matrix(0, nrow = 3, ncol = 2)
    # Caso exitoso
    expect_silent(
      validate_SeaSondeRAPM_quality_matrix(
        matrix(complex(real = 1:6, imaginary = 1:6), nrow = 3),
        seasonde_apm_obj
      )
    )
    # Casos de error
    expect_error(
      validate_SeaSondeRAPM_quality_matrix(
        matrix(1:6, nrow = 3),
        seasonde_apm_obj
      )
    )
    expect_error(
      validate_SeaSondeRAPM_quality_matrix(
        matrix(complex(real = 1:2, imaginary = 1:2), nrow = 2),
        seasonde_apm_obj
      )
    )
  })

  it("validate_SeaSondeRAPM_BEAR works as expected", {
    seasonde_apm_obj <- matrix(0, nrow = 3, ncol = 3)
    expect_silent(validate_SeaSondeRAPM_BEAR(c(1, 2, 3), seasonde_apm_obj))
    expect_error(validate_SeaSondeRAPM_BEAR("string", seasonde_apm_obj))
  })

  it("validate_SeaSondeRAPM_SiteOrigin works as expected", {
    expect_silent(validate_SeaSondeRAPM_SiteOrigin(c(1, 2)))
    expect_error(validate_SeaSondeRAPM_SiteOrigin("SiteOrigin"))
  })

  it("validate_SeaSondeRAPM_AmplitudeFactors works as expected", {
    expect_silent(validate_SeaSondeRAPM_AmplitudeFactors(c(1, 2)))
    expect_error(validate_SeaSondeRAPM_AmplitudeFactors("invalid"))
  })

  it("validate_SeaSondeRAPM_StationCode works as expected", {
    expect_silent(validate_SeaSondeRAPM_StationCode("XYZA"))
    expect_error(validate_SeaSondeRAPM_StationCode(123))
  })

  it("validate_SeaSondeRAPM_PhaseCorrections works as expected", {
    expect_silent(validate_SeaSondeRAPM_PhaseCorrections(c(1, 2)))
    expect_error(validate_SeaSondeRAPM_PhaseCorrections("invalid"))
  })

  # it("validate_SeaSondeRAPM_Type works as expected", {
  #   expect_silent(validate_SeaSondeRAPM_Type("Measured Antenna Pattern"))
  #   expect_error(validate_SeaSondeRAPM_Type(123))
  # })

  it("validate_SeaSondeRAPM_Creator works as expected", {
    expect_silent(validate_SeaSondeRAPM_Creator(""))
    expect_silent(validate_SeaSondeRAPM_Creator("John Doe"))
    expect_error(validate_SeaSondeRAPM_Creator(123))
  })

  it("validate_SeaSondeRAPM_SiteName works as expected", {
    expect_silent(validate_SeaSondeRAPM_SiteName("SiteName"))
    expect_error(validate_SeaSondeRAPM_SiteName(123))
  })

  it("validate_SeaSondeRAPM_FileName works as expected", {
    expect_silent(validate_SeaSondeRAPM_FileName(""))
    expect_silent(validate_SeaSondeRAPM_FileName("file.txt"))
    expect_error(validate_SeaSondeRAPM_FileName(123))
  })

  it("validate_SeaSondeRAPM_CreateTimeStamp works as expected", {
    expect_silent(validate_SeaSondeRAPM_CreateTimeStamp(Sys.time()))
    expect_error(validate_SeaSondeRAPM_CreateTimeStamp("invalid_date"))
  })

  it("validate_SeaSondeRAPM_ProcessingSteps works as expected", {
    expect_silent(validate_SeaSondeRAPM_ProcessingSteps(character(0)))
    expect_silent(validate_SeaSondeRAPM_ProcessingSteps(c("step1", "step2")))
    expect_error(validate_SeaSondeRAPM_ProcessingSteps(123))
  })

  it("validate_SeaSondeRAPM_AntennaBearing works as expected", {
    expect_silent(validate_SeaSondeRAPM_AntennaBearing(90))
    expect_error(validate_SeaSondeRAPM_AntennaBearing("90"))
  })

  it("validate_SeaSondeRAPM_BearingResolution works as expected", {
    expect_silent(validate_SeaSondeRAPM_BearingResolution(1.5))
    expect_error(validate_SeaSondeRAPM_BearingResolution("1.5"))
  })

  it("validate_SeaSondeRAPM_Smoothing works as expected", {
    expect_silent(validate_SeaSondeRAPM_Smoothing(1.5))
    expect_error(validate_SeaSondeRAPM_Smoothing("1.5"))
  })

  it("validate_SeaSondeRAPM_CommentLine works as expected", {
    expect_silent(validate_SeaSondeRAPM_CommentLine("This is a comment"))
    expect_error(validate_SeaSondeRAPM_CommentLine(123))
  })

  it("validate_SeaSondeRAPM_FileID works as expected", {
    expect_silent(validate_SeaSondeRAPM_FileID("file_001"))
    expect_error(validate_SeaSondeRAPM_FileID(1))
  })
})

#### seasonder_validateAttributesSeaSondeRAPM ####
describe("seasonder_validateAttributesSeaSondeRAPM", {
  it("calls each individual validation function", {
    # Configurar mocks para cada función de validación
    mock_quality_matrix  <- mockthat::mock("Called validate_quality_matrix")
    mock_BEAR            <- mockthat::mock("Called validate_BEAR")
    mock_Type            <- mockthat::mock("Called validate_Type")
    mock_Creator         <- mockthat::mock("Called validate_Creator")
    mock_SiteName        <- mockthat::mock("Called validate_SiteName")
    mock_SiteOrigin      <- mockthat::mock("Called validate_SiteOrigin")
    mock_FileName        <- mockthat::mock("Called validate_FileName")
    mock_CreateTimeStamp <- mockthat::mock("Called validate_CreateTimeStamp")
    mock_ProcessingSteps <- mockthat::mock("Called validate_ProcessingSteps")
    mock_AmplitudeFactors<- mockthat::mock("Called validate_AmplitudeFactors")
    mock_AntennaBearing  <- mockthat::mock("Called validate_AntennaBearing")
    mock_StationCode     <- mockthat::mock("Called validate_StationCode")
    mock_BearingResolution <- mockthat::mock("Called validate_BearingResolution")
    mock_Smoothing       <- mockthat::mock("Called validate_Smoothing")
    mock_CommentLine     <- mockthat::mock("Called validate_CommentLine")
    mock_FileID          <- mockthat::mock("Called validate_FileID")
    mock_PhaseCorrections<- mockthat::mock("Called validate_PhaseCorrections")

    seasonde_obj <- list()  # objeto de prueba (dummy)

    mockthat::with_mock(
      validate_SeaSondeRAPM_quality_matrix = mock_quality_matrix,
      validate_SeaSondeRAPM_BEAR           = mock_BEAR,
      validate_SeaSondeRAPM_Type           = mock_Type,
      validate_SeaSondeRAPM_Creator        = mock_Creator,
      validate_SeaSondeRAPM_SiteName       = mock_SiteName,
      validate_SeaSondeRAPM_SiteOrigin     = mock_SiteOrigin,
      validate_SeaSondeRAPM_FileName       = mock_FileName,
      validate_SeaSondeRAPM_CreateTimeStamp= mock_CreateTimeStamp,
      validate_SeaSondeRAPM_ProcessingSteps= mock_ProcessingSteps,
      validate_SeaSondeRAPM_AmplitudeFactors= mock_AmplitudeFactors,
      validate_SeaSondeRAPM_AntennaBearing = mock_AntennaBearing,
      validate_SeaSondeRAPM_StationCode    = mock_StationCode,
      validate_SeaSondeRAPM_BearingResolution= mock_BearingResolution,
      validate_SeaSondeRAPM_Smoothing      = mock_Smoothing,
      validate_SeaSondeRAPM_CommentLine    = mock_CommentLine,
      validate_SeaSondeRAPM_FileID         = mock_FileID,
      validate_SeaSondeRAPM_PhaseCorrections = mock_PhaseCorrections, {
        seasonder_validateAttributesSeaSondeRAPM(seasonde_obj)
      }
    )
    expect_equal(mockthat::mock_n_called(mock_quality_matrix), 1)
    expect_equal(mockthat::mock_n_called(mock_BEAR), 1)
    expect_equal(mockthat::mock_n_called(mock_Type), 1)
    expect_equal(mockthat::mock_n_called(mock_Creator), 1)
    expect_equal(mockthat::mock_n_called(mock_SiteName), 1)
    expect_equal(mockthat::mock_n_called(mock_SiteOrigin), 1)
    expect_equal(mockthat::mock_n_called(mock_FileName), 1)
    expect_equal(mockthat::mock_n_called(mock_CreateTimeStamp), 1)
    expect_equal(mockthat::mock_n_called(mock_ProcessingSteps), 1)
    expect_equal(mockthat::mock_n_called(mock_AmplitudeFactors), 1)
    expect_equal(mockthat::mock_n_called(mock_AntennaBearing), 1)
    expect_equal(mockthat::mock_n_called(mock_StationCode), 1)
    expect_equal(mockthat::mock_n_called(mock_BearingResolution), 1)
    expect_equal(mockthat::mock_n_called(mock_Smoothing), 1)
    expect_equal(mockthat::mock_n_called(mock_CommentLine), 1)
    expect_equal(mockthat::mock_n_called(mock_FileID), 1)
    expect_equal(mockthat::mock_n_called(mock_PhaseCorrections), 1)
  })
})

#### seasonder_readSeaSondeRAPMFile ####
describe("File Reading", {

  # it("File reading works", {
  #   file_path <- here::here("tests/testthat/data/MeasPattern.txt")
  #   msg <- glue::glue("2022-01-02 03:45:03: Created from {file_path}.")
  #   mk <- mockthat::mock(msg)
  #   mockthat::with_mock(SeaSondeRAPM_creation_step_text = mk, {
  #     test_obj <- seasonder_readSeaSondeRAPMFile(
  #       file_path,
  #       SiteName = "Estación Cies",
  #       Type = "Measured Pattern",
  #       Creator = "Me"
  #     )
  #   })
  #   expect_snapshot_value(test_obj, style = "serialize")
  # })

  it("longitude and latitude override works", {
    file_path <- system.file("css_data/MeasPattern.txt", package = "SeaSondeR")
    target <- c(Latitude = 42, Longitude = -8)
    test_obj <- seasonder_readSeaSondeRAPMFile(
      file_path,
      override_SiteOrigin = target
    ) %>% seasonder_getSeaSondeRAPM_SiteOrigin()
    expect_equal(test_obj, target)
  })
})

#### Plots ####
describe("Plots", {

  it("Loops plot works", {
    file_path <- system.file("css_data/MeasPattern.txt", package = "SeaSondeR")
    seasonder_apm_object <- seasonder_readSeaSondeRAPMFile(file_path)
    p <- seasonder_plotAPMLoops(seasonder_apm_object)
    expect_s3_class(p, "ggplot")
  })

  it("Ambiguity plot works", {
    file_path <- system.file("css_data/MeasPattern.txt", package = "SeaSondeR")
    seasonder_apm_object <- seasonder_readSeaSondeRAPMFile(file_path)
    seasonder_apm_object %<>% seasonder_smoothAPM(10)

    distances <- 1:ncol(seasonder_apm_object) %>% purrr::map(\(i) {
      x <- matrix(
        rep(seasonder_apm_object[, i, drop = FALSE],
            ncol(seasonder_apm_object)),
        nrow = 3, byrow = FALSE
      ) - as.matrix(seasonder_apm_object)
      y <- pracma::Real(sqrt(diag(Conj(t(x)) %*% (x)))) %>% matrix(nrow = 1)
      as.data.frame(y)
    }) %>% purrr::list_rbind() %>% as.matrix()

    inverse_distance <- 10 * log10(1 / distances)
    inverse_distance[is.infinite(inverse_distance)] <- 25

    p <- as.data.frame(as.table(inverse_distance)) %>%
      ggplot2::ggplot(ggplot2::aes(Var2, Var1, fill = Freq)) +
      ggplot2::geom_tile() +
      ggplot2::scale_fill_gradientn(colours = rainbow(256)) +
      ggplot2::theme_minimal()

    expect_s3_class(p, "ggplot")
  })
})

#### seasonder_smoothAPM ####
describe("Smoothing APM", {
  it("applies smoothing and updates processing steps", {
    # Crear una matriz dummy con 3 filas y 10 columnas
    calib <- matrix(complex(real = 1:30, imaginary = 31:60), nrow = 3)
    apm <- seasonder_createSeaSondeRAPM(calibration_matrix = calib, BEAR = 1:10)

    orig_channel1 <- apm[1, ]
    smoothing_value <- 2
    apm_smoothed <- seasonder_smoothAPM(apm, smoothing = smoothing_value)

    # Verificar que se añade un mensaje de smoothing en ProcessingSteps
    expect_true(any(grepl("APM smoothed with smoothing", seasonder_getSeaSondeRAPM_ProcessingSteps(apm_smoothed))))
    # Verificar que los valores de la primera fila han sido modificados
    expect_false(all(apm_smoothed[1, ] == orig_channel1))
  })
})

#### seasonder_trimAPM ####
describe("Trimming APM", {
  it("trims the data correctly and updates BEAR and processing steps", {
    calib <- matrix(complex(real = 1:30, imaginary = 31:60), nrow = 3)
    apm <- seasonder_createSeaSondeRAPM(calibration_matrix = calib, BEAR = 1:10)
    orig_dim <- dim(apm)
    orig_bear <- seasonder_getSeaSondeRAPM_BEAR(apm)

    trimming_value <- 2
    apm_trimmed <- seasonder_trimAPM(apm, trimming = trimming_value)

    # El número de columnas debe reducirse en 2 * trimming_value
    expect_equal(ncol(apm_trimmed), orig_dim[2] - 2 * trimming_value)
    # La longitud de BEAR se debe ajustar
    expect_equal(length(seasonder_getSeaSondeRAPM_BEAR(apm_trimmed)), length(orig_bear) - 2 * trimming_value)
    expect_true(any(grepl("trimmed", seasonder_getSeaSondeRAPM_ProcessingSteps(apm_trimmed))))
  })
})

#### seasonder_applyAPMAmplitudeAndPhaseCorrections ####
describe("Amplitude and Phase Corrections", {
  it("applies corrections correctly", {
    calib <- matrix(complex(real = rep(1, 15), imaginary = rep(0, 15)), nrow = 3)
    apm <- seasonder_createSeaSondeRAPM(calibration_matrix = calib, BEAR = 1:5)

    # Configurar los factores de amplitud y correcciones de fase
    apm <- seasonder_setSeaSondeRAPM_AmplitudeFactors(apm, c(2, 3))
    apm <- seasonder_setSeaSondeRAPM_PhaseCorrections(apm, c(0, 90))

    orig_ch1 <- apm[1, ]
    orig_ch2 <- apm[2, ]

    apm_corrected <- seasonder_applyAPMAmplitudeAndPhaseCorrections(apm)

    expected_ch1 <- orig_ch1 * 2 * exp(1i * 0 * pi / 180)
    expected_ch2 <- orig_ch2 * 3 * exp(1i * 90 * pi / 180)

    expect_equal(apm_corrected[1, ], expected_ch1)
    expect_equal(apm_corrected[2, ], expected_ch2)
    expect_true(any(grepl("Phase corrections", seasonder_getSeaSondeRAPM_ProcessingSteps(apm_corrected))))
  })
})

#### parse_metadata_line ####
# describe("Metadata Parsing", {
#   it("parses a valid metadata line correctly", {
#     line <- "1.0 2.0 ! Amplitude Factors"
#     parsed <- parse_metadata_line(line)
#     expect_equal(parsed$attribute_name, "AmplitudeFactors")
#     expect_equal(parsed$value, c(1.0, 2.0))
#   })

#   it("returns 'Unknown' for metadata lines with missing delimiter", {
#     line <- "This is a comment without delimiter"
#     parsed <- parse_metadata_line(line)
#     expect_equal(parsed$attribute_name, "Unknown")
#     expect_equal(parsed$value, "This is a comment without delimiter")
#   })
# })

#### Step Text Functions ####
# describe("Step Text Functions", {
#   it("creation step text includes the file path", {
#     file_path <- "dummy_file.txt"
#     text <- SeaSondeRAPM_creation_step_text(file_path)
#     expect_true(grepl(file_path, text))
#   })

#   it("antenna bearing override text includes the new value", {
#     new_bearing <- 45
#     text <- SeaSondeRAPM_antenna_bearing_override_step_text(new_bearing)
#     expect_true(grepl(as.character(new_bearing), text))
#   })

#   it("smoothing step text includes the smoothing parameter", {
#     smoothing <- 5
#     text <- SeaSondeRAPM_smoothing_step_text(smoothing)
#     expect_true(grepl(as.character(smoothing), text))
#   })

#   it("trimming step text includes the trimming value", {
#     trimming <- 3
#     text <- SeaSondeRAPM_trimming_step_text(trimming)
#     expect_true(grepl(as.character(trimming), text))
#   })

#   it("amplitude and phase corrections text includes correction values", {
#     amp1 <- 2; amp2 <- 3; phase1 <- 10; phase2 <- 20
#     text <- SeaSondeRAPM_amplitude_and_phase_corrections_step_text(amp1, amp2, phase1, phase2)
#     expect_true(grepl(as.character(phase1), text))
#     expect_true(grepl(as.character(amp1), text))
#   })

#   it("phase correction override text includes the new phase values", {
#     phases <- c(15, 30)
#     text <- SeaSondeRAPM_phase_correction_override_step_text(phases)
#     expect_true(grepl(as.character(phases[1]), text))
#     expect_true(grepl(as.character(phases[2]), text))
#   })

#   it("amplitude factors override text includes the new factors", {
#     amps <- c(0.5, 0.75)
#     text <- SeaSondeRAPM_amplitude_factors_override_step_text(amps)
#     expect_true(grepl(as.character(amps[1]), text))
#     expect_true(grepl(as.character(amps[2]), text))
#   })

#   it("SiteOrigin override text includes the new latitude and longitude", {
#     site_origin <- c(10, 20)
#     text <- SeaSondeRAPM_SiteOrigin_override_step_text(site_origin)
#     expect_true(grepl(as.character(site_origin[1]), text))
#     expect_true(grepl(as.character(site_origin[2]), text))
#   })
# })

#### seasonder_readPhaseFile ####
describe("Phase File Reading", {
  it("reads a phase file and returns correct phase values", {
    tf <- tempfile()
    writeLines("45.0 90.0", tf)
    phases <- seasonder_readPhaseFile(tf)
    expect_equal(phases, c(phase1 = 45.0, phase2 = 90.0))
    unlink(tf)
  })
})

#### Setter and Getter Functions ####
# describe("Setter and Getter Functions", {
#   it("sets and retrieves the Type attribute correctly", {
#     calib <- matrix(complex(real = 1:30, imaginary = 31:60), nrow = 3)
#     apm <- seasonder_createSeaSondeRAPM(calibration_matrix = calib, BEAR = 1:10)
#     apm <- seasonder_setSeaSondeRAPM_Type(apm, "Test Type")
#     expect_equal(seasonder_getSeaSondeRAPM_Type(apm), "Test Type")
#   })

#   it("sets and retrieves the Creator attribute correctly", {
#     calib <- matrix(complex(real = 1:30, imaginary = 31:60), nrow = 3)
#     apm <- seasonder_createSeaSondeRAPM(calibration_matrix = calib, BEAR = 1:10)
#     apm <- seasonder_setSeaSondeRAPM_Creator(apm, "John Doe")
#     expect_equal(seasonder_getSeaSondeRAPM_Creator(apm), "John Doe")
#   })

#   it("sets multiple attributes and passes overall validation", {
#     calib <- matrix(complex(real = 1:30, imaginary = 31:60), nrow = 3)
#     apm <- seasonder_createSeaSondeRAPM(calibration_matrix = calib, BEAR = 1:10)
#     apm <- seasonder_setSeaSondeRAPM_SiteName(apm, "Test Site")
#     apm <- seasonder_setSeaSondeRAPM_SiteOrigin(apm, c(10, 20))
#     apm <- seasonder_setSeaSondeRAPM_FileName(apm, "file.txt")
#     expect_silent(seasonder_validateAttributesSeaSondeRAPM(apm))
#   })
# })


#### seasonder_readSeaSondeRAPMFile Overrides ####
# describe("seasonder_readSeaSondeRAPMFile Overrides", {

#   it("overrides antenna_bearing correctly when provided", {
#     file_path <- here::here("tests/testthat/data/MeasPattern.txt")
#     override_val <- 90
#     obj <- seasonder_readSeaSondeRAPMFile(file_path, override_antenna_bearing = override_val)
#     expect_equal(seasonder_getSeaSondeRAPM_AntennaBearing(obj), override_val)
#     expect_true(any(grepl("AntennaBearing overriden", seasonder_getSeaSondeRAPM_ProcessingSteps(obj))))
#   })

#   it("overrides phase_corrections when provided as a valid numeric vector", {
#     file_path <- here::here("tests/testthat/data/MeasPattern.txt")
#     override_phase <- c(15, -15)
#     obj <- seasonder_readSeaSondeRAPMFile(file_path, override_phase_corrections = override_phase)
#     expect_equal(seasonder_getSeaSondeRAPM_PhaseCorrections(obj), override_phase)
#     expect_true(any(grepl("PhaseCorrection overriden", seasonder_getSeaSondeRAPM_ProcessingSteps(obj))))
#   })

#   it("overrides phase_corrections when provided as a valid file path", {
#     tf <- tempfile()
#     writeLines("30.0 60.0", tf)
#     file_path <- here::here("tests/testthat/data/MeasPattern.txt")
#     obj <- seasonder_readSeaSondeRAPMFile(file_path, override_phase_corrections = tf)
#     expect_equal(seasonder_getSeaSondeRAPM_PhaseCorrections(obj), c(phase1 = 30.0, phase2 = 60.0))
#     expect_true(any(grepl("PhaseCorrection overriden", seasonder_getSeaSondeRAPM_ProcessingSteps(obj))))
#     unlink(tf)
#   })

#   it("does not override phase_corrections when provided an invalid numeric vector", {
#     file_path <- here::here("tests/testthat/data/MeasPattern.txt")
#     default_phase <- c(0, 0)  # Valor por defecto definido en seasonder_initializeAttributesSeaSondeRAPM
#     obj <- seasonder_readSeaSondeRAPMFile(file_path, override_phase_corrections = c(10))
#     expect_equal(seasonder_getSeaSondeRAPM_PhaseCorrections(obj), default_phase)
#   })

#   it("overrides amplitude_factors when provided a valid numeric vector", {
#     file_path <- here::here("tests/testthat/data/MeasPattern.txt")
#     override_amp <- c(1.5, 2.5)
#     obj <- seasonder_readSeaSondeRAPMFile(file_path, override_amplitude_factors = override_amp)
#     expect_equal(seasonder_getSeaSondeRAPM_AmplitudeFactors(obj), override_amp)
#     expect_true(any(grepl("AmplitudeFactors overriden", seasonder_getSeaSondeRAPM_ProcessingSteps(obj))))
#   })

#   it("does not override amplitude_factors when provided an invalid numeric vector", {
#     file_path <- here::here("tests/testthat/data/MeasPattern.txt")
#     default_amp <- c(0, 0)  # Valor por defecto
#     obj <- seasonder_readSeaSondeRAPMFile(file_path, override_amplitude_factors = c(1))
#     expect_equal(seasonder_getSeaSondeRAPM_AmplitudeFactors(obj), default_amp)
#   })
# })

#### validate_SeaSondeRAPM_StationCode Coverage ####
describe("validate_SeaSondeRAPM_StationCode", {

  it("accepts an empty character vector", {
    expect_silent(validate_SeaSondeRAPM_StationCode(character(0)))
  })

  it("accepts a valid 4-character station code", {
    expect_silent(validate_SeaSondeRAPM_StationCode("ABCD"))
  })

  it("rejects a station code with less than 4 characters", {
    expect_error(validate_SeaSondeRAPM_StationCode("ABC"),
                 "StationCode must have 4 characters")
  })

  it("rejects a station code with more than 4 characters", {
    expect_error(validate_SeaSondeRAPM_StationCode("ABCDE"),
                 "StationCode must have 4 characters")
  })

  it("rejects a station code vector with length > 1", {
    expect_error(validate_SeaSondeRAPM_StationCode(c("ABCD", "EFGH")),
                 "StationCode must have length 0 or 1")
  })

  it("rejects non-character input", {
    expect_error(validate_SeaSondeRAPM_StationCode(123),
                 "StationCode must be a character string")
  })
})

#### validate_SeaSondeRAPM_BEAR Coverage ####
describe("validate_SeaSondeRAPM_BEAR", {

  it("accepts a valid numeric vector within -180 to 180 and matching calibration matrix columns", {
    dummy_obj <- matrix(0, nrow = 3, ncol = 4)
    valid_bear <- c(-90, 0, 90, 180)
    expect_silent(validate_SeaSondeRAPM_BEAR(valid_bear, dummy_obj))
  })

  it("rejects non-numeric BEAR input", {
    dummy_obj <- matrix(0, nrow = 3, ncol = 4)
    expect_error(validate_SeaSondeRAPM_BEAR("not numeric", dummy_obj),
                 "BEAR must be a numeric vector")
  })

  it("rejects a numeric vector with incorrect length", {
    dummy_obj <- matrix(0, nrow = 3, ncol = 4)
    invalid_bear <- c(-90, 0, 90)  # Longitud 3 en lugar de 4
    expect_error(validate_SeaSondeRAPM_BEAR(invalid_bear, dummy_obj),
                 "BEAR must be a numeric vector of length 4")
  })

  it("rejects a numeric vector with values out of the -180 to 180 range", {
    dummy_obj <- matrix(0, nrow = 3, ncol = 2)
    invalid_bear <- c(-200, 50)  # -200 está fuera de rango
    expect_error(validate_SeaSondeRAPM_BEAR(invalid_bear, dummy_obj),
                 "BEAR must be a numeric vector of values between -180 and 180")
  })
})


#### seasonder_extrapolateAPM ####

# describe("seasonder_extrapolateAPM", {
#   # Create a dummy SeaSondeRAPM object with the provided structure
#   dummy_mat <- matrix(c(
#     10, 20, 30, 40, 50,   # row 1
#     15, 25, 35, 45, 55,     # row 2
#     100,200,300,400,500     # row 3
#   ), nrow = 3, ncol = 5, byrow = TRUE)
#   rownames(dummy_mat) <- c("A1", "A2", "A3")
#   colnames(dummy_mat) <- as.character(c(10, 20, 30, 40, 50))
#   dummy_obj <- dummy_mat
#   attr(dummy_obj, "BEAR") <- c(10, 20, 30, 40, 50)
#   attr(dummy_obj, "BearingResolution") <- 10

#   # Test case: n = 0, no extrapolation
#   test_that("should not change the object when n = 0", {
#     new_obj <- seasonder_extrapolateAPM(dummy_obj, n = 0)
#     expect_equal(ncol(new_obj), ncol(dummy_obj), info = "Matrix columns should remain unchanged for n = 0")
#     expect_equal(attr(new_obj, "BEAR"), attr(dummy_obj, "BEAR"), info = "BEAR attribute should remain unchanged for n = 0")
#     expect_equal(colnames(new_obj), colnames(dummy_obj), info = "Column names should remain the same for n = 0")
#     expect_equal(new_obj, dummy_obj, info = "Matrix values should remain unchanged for n = 0")
#   })

#   # Test case: n = 1, one column extrapolated on each side
#   test_that("should extrapolate one column on each side when n = 1", {
#     new_obj <- seasonder_extrapolateAPM(dummy_obj, n = 1)
#     original_BEAR <- attr(dummy_obj, "BEAR")
#     res <- attr(dummy_obj, "BearingResolution")
#     expected_BEAR <- c(original_BEAR[1] - res, original_BEAR, tail(original_BEAR, 1) + res)
#     expect_equal(attr(new_obj, "BEAR"), expected_BEAR,
#                  info = "BEAR attribute should include extrapolated bearings for n = 1")
#     expect_equal(ncol(new_obj), length(expected_BEAR),
#                  info = "Matrix should have correct number of columns for n = 1")
#     expect_equal(colnames(new_obj), as.character(expected_BEAR),
#                  info = "Column names should match extrapolated BEAR values for n = 1")

#     # Calculate expected values via linear extrapolation
#     left_extrap <- dummy_obj[, 1] - (dummy_obj[, 2] - dummy_obj[, 1])
#     right_extrap <- dummy_obj[, ncol(dummy_obj)] + (dummy_obj[, ncol(dummy_obj)] - dummy_obj[, ncol(dummy_obj) - 1])
#     expected_matrix <- cbind(left_extrap, dummy_obj, right_extrap)
#     expect_equal(as.numeric(new_obj), as.numeric(expected_matrix),
#                  info = "Matrix values should be correctly extrapolated for n = 1")
#   })

#   # Test case: n = 2, two columns extrapolated on each side
#   test_that("should extrapolate two columns on each side when n = 2", {
#     new_obj <- seasonder_extrapolateAPM(dummy_obj, n = 2)
#     original_BEAR <- attr(dummy_obj, "BEAR")
#     res <- attr(dummy_obj, "BearingResolution")
#     expected_BEAR <- c(original_BEAR[1] - 2 * res, original_BEAR[1] - res, original_BEAR,
#                        tail(original_BEAR, 1) + res, tail(original_BEAR, 1) + 2 * res)
#     expect_equal(attr(new_obj, "BEAR"), expected_BEAR,
#                  info = "BEAR attribute should include extrapolated bearings for n = 2")
#     expect_equal(ncol(new_obj), length(expected_BEAR),
#                  info = "Matrix should have correct number of columns for n = 2")
#     expect_equal(colnames(new_obj), as.character(expected_BEAR),
#                  info = "Column names should match extrapolated BEAR values for n = 2")

#     # Compute expected matrix values using linear extrapolation
#     slope_left <- (dummy_obj[, 2] - dummy_obj[, 1]) / (original_BEAR[2] - original_BEAR[1])
#     left_extrap1 <- dummy_obj[, 1] + slope_left * ((original_BEAR[1] - 2 * res) - original_BEAR[1])
#     left_extrap2 <- dummy_obj[, 1] + slope_left * ((original_BEAR[1] - res) - original_BEAR[1])

#     n_orig <- ncol(dummy_obj)
#     slope_right <- (dummy_obj[, n_orig] - dummy_obj[, n_orig - 1]) / (original_BEAR[n_orig] - original_BEAR[n_orig - 1])
#     right_extrap1 <- dummy_obj[, n_orig] + slope_right * ((tail(original_BEAR, 1) + res) - tail(original_BEAR, 1))
#     right_extrap2 <- dummy_obj[, n_orig] + slope_right * ((tail(original_BEAR, 1) + 2 * res) - tail(original_BEAR, 1))

#     expected_matrix <- cbind(left_extrap1, left_extrap2, dummy_obj, right_extrap1, right_extrap2)
#     expect_equal(as.numeric(new_obj), as.numeric(expected_matrix),
#                  info = "Matrix values should be correctly extrapolated for n = 2")
#   })
#   it("works on a real file",{

#     file_path <- here::here("tests/testthat/data/MeasPattern.txt")
#     seasonder_apm_object <- seasonder_readSeaSondeRAPMFile(file_path)

#     test <- seasonder_extrapolateAPM(seasonder_apm_object)

#   })

# })