wfdisc 0.1.1

Reader for CSS 3.0 / NNSA KB Core wfdisc seismological waveform descriptor files. Cross-validated against ObsPy.
Documentation
//! End-to-end integration tests against the bundled ObsPy test data.
//!
//! Test data files (under `tests/data/`) are vendored unchanged from the
//! ObsPy project — see `tests/data/README.obspy.txt`. Each `.w` file
//! contains three concatenated 4800-sample, 80 Hz traces (Z, E, N — the
//! foff order recorded in the wfdisc rows). The matching `.ascii.gz`
//! file is the canonical reference produced by `css2ascii.c`.

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();

    // The 6 rows are: TESTbe HHZ, HHE, HHN, then TESTle HHZ, HHE, HHN.
    // Each pair (i, i+3) reads the same logical trace from BE vs LE
    // copies of the data; samples must match exactly.
    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);

    // BE rows are 0..3, ordered by foff (0, 19200, 38400). The ASCII
    // file is the entire 57600-byte binary file dumped as %d per line in
    // the same byte order, so row i's samples must equal
    // reference[i*4800 .. (i+1)*4800].
    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() {
    // test_css_2.wfdisc references 201101311155_2.{be,le}.w which only
    // exist as gzipped companions in tests/data — exercises the gzip
    // fallback path.
    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() {
    // test_css_3.wfdisc contains a row pointing at a non-existent file.
    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() {
    // test_css_3.wfdisc has one row with datatype "c0" (ASCII int —
    // recognised but unsupported for sample decoding).
    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");
    // Even when the dfile is missing, parser-level dtype recognition is fine.
    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);
    // Subsequent calls keep returning None.
    assert!(r.next().is_none());
    assert!(r.next().is_none());
}