use std::io::{BufRead, BufReader};
use std::path::Path;
use approx::assert_relative_eq;
use flate2::read::GzDecoder;
use wfdisc::{DataType, Schema, Wfdisc, WfdiscReader, jdate_from_epoch};
const NSAMP_PER_TRACE: usize = 4800;
const TRACES_PER_FILE: usize = 3;
fn data_dir() -> &'static Path {
Path::new("tests/data")
}
fn read_ascii_reference() -> Vec<i32> {
let path = data_dir().join("201101311155.10.ascii.gz");
let f = std::fs::File::open(&path).expect("open ascii.gz");
let r = BufReader::new(GzDecoder::new(f));
let mut out = Vec::with_capacity(NSAMP_PER_TRACE * TRACES_PER_FILE);
for line in r.lines() {
let line = line.expect("ascii read");
let trimmed = line.trim();
if trimmed.is_empty() {
continue;
}
out.push(trimmed.parse::<i32>().expect("ascii int"));
}
out
}
#[test]
fn css_wfdisc_yields_six_rows() {
let r = WfdiscReader::open(data_dir().join("test_css.wfdisc")).unwrap();
let rows: Vec<Wfdisc> = r.collect::<Result<_, _>>().unwrap();
assert_eq!(rows.len(), 6);
for r in &rows {
assert_eq!(r.schema, Schema::Css30);
assert_eq!(r.nsamp, 4800);
assert_relative_eq!(r.samprate, 80.0);
assert!(matches!(r.datatype, DataType::S4 | DataType::I4));
}
}
#[test]
fn nnsa_wfdisc_yields_six_rows() {
let r = WfdiscReader::open(data_dir().join("test_nnsa.wfdisc")).unwrap();
let rows: Vec<Wfdisc> = r.collect::<Result<_, _>>().unwrap();
assert_eq!(rows.len(), 6);
for r in &rows {
assert_eq!(r.schema, Schema::NnsaKbCore);
assert_eq!(r.nsamp, 4800);
}
}
#[test]
fn jdate_matches_epoch_for_every_row() {
let rows: Vec<_> = WfdiscReader::open(data_dir().join("test_css.wfdisc"))
.unwrap()
.collect::<Result<_, _>>()
.unwrap();
for r in &rows {
assert_eq!(jdate_from_epoch(r.time), r.jdate);
}
}
#[test]
fn be_and_le_traces_decode_to_identical_samples() {
let rows: Vec<_> = WfdiscReader::open(data_dir().join("test_css.wfdisc"))
.unwrap()
.collect::<Result<_, _>>()
.unwrap();
let base = data_dir();
for i in 0..3 {
let be = rows[i].read_samples(base).unwrap();
let le = rows[i + 3].read_samples(base).unwrap();
let be_v = be.as_i32().expect("s4 decodes to i32").to_vec();
let le_v = le.as_i32().expect("i4 decodes to i32").to_vec();
assert_eq!(be_v.len(), NSAMP_PER_TRACE);
assert_eq!(be_v, le_v, "BE and LE traces #{i} disagreed");
}
}
#[test]
fn samples_match_ascii_reference() {
let rows: Vec<_> = WfdiscReader::open(data_dir().join("test_css.wfdisc"))
.unwrap()
.collect::<Result<_, _>>()
.unwrap();
let base = data_dir();
let reference = read_ascii_reference();
assert_eq!(reference.len(), NSAMP_PER_TRACE * TRACES_PER_FILE);
for i in 0..TRACES_PER_FILE {
let trace = rows[i].read_samples(base).unwrap();
let got = trace.as_i32().expect("s4 → i32").to_vec();
let expected = reference[i * NSAMP_PER_TRACE..(i + 1) * NSAMP_PER_TRACE].to_vec();
assert_eq!(got, expected, "trace #{i} ({}) disagreed with ASCII reference", rows[i].chan);
}
}
#[test]
fn read_trace_relative_to_returns_descriptor_and_samples() {
let r = WfdiscReader::open(data_dir().join("test_css.wfdisc")).unwrap();
let first = r.into_iter().next().unwrap().unwrap();
let trace = first.read_trace_relative_to(data_dir()).unwrap();
assert_eq!(trace.descriptor.sta, "TESTbe");
assert_eq!(trace.samples.len(), NSAMP_PER_TRACE);
assert_eq!(trace.descriptor.datatype, DataType::S4);
}
#[test]
#[cfg(feature = "gzip")]
fn falls_back_to_dot_gz_companion_file() {
let rows: Vec<_> = WfdiscReader::open(data_dir().join("test_css_2.wfdisc"))
.unwrap()
.collect::<Result<_, _>>()
.unwrap();
assert_eq!(rows.len(), 6);
let mut traces = 0;
for r in &rows {
let samples = r.read_samples(data_dir()).expect("gzip fallback");
assert_eq!(samples.len(), NSAMP_PER_TRACE);
traces += 1;
}
assert_eq!(traces, 6);
}
#[test]
fn missing_file_surfaces_waveform_not_found() {
let rows: Vec<_> = WfdiscReader::open(data_dir().join("test_css_3.wfdisc"))
.unwrap()
.collect::<Result<_, _>>()
.unwrap();
let row_with_missing = rows
.iter()
.find(|r| r.dfile.contains("missing"))
.expect("a row should point at a missing file");
let err = row_with_missing
.read_samples(data_dir())
.expect_err("expected WaveformNotFound");
assert!(matches!(err, wfdisc::Error::WaveformNotFound { .. }));
}
#[test]
fn unsupported_datatype_reading_yields_error() {
let rows: Vec<_> = WfdiscReader::open(data_dir().join("test_css_3.wfdisc"))
.unwrap()
.collect::<Result<_, _>>()
.unwrap();
let row = rows
.iter()
.find(|r| matches!(r.datatype, DataType::C0))
.expect("row with c0 datatype");
assert_eq!(row.datatype, DataType::C0);
}
#[test]
fn samples_to_f64_preserves_values_for_i32() {
let r = WfdiscReader::open(data_dir().join("test_css.wfdisc")).unwrap();
let first = r.into_iter().next().unwrap().unwrap();
let samples = first.read_samples(data_dir()).unwrap();
let v = samples.to_f64();
assert_eq!(v.len(), NSAMP_PER_TRACE);
let raw: &[i32] = samples.as_i32().unwrap();
for (i, (&a, &b)) in raw.iter().zip(v.iter()).enumerate() {
assert_eq!(a as f64, b, "mismatch at {i}");
}
}
#[test]
fn iterating_after_eof_returns_none() {
let mut r = WfdiscReader::open(data_dir().join("test_css.wfdisc")).unwrap();
let mut count = 0;
while r.next().is_some() {
count += 1;
}
assert_eq!(count, 6);
assert!(r.next().is_none());
assert!(r.next().is_none());
}