wavetools 0.1.2

Command-line tools for digital simulation waveform analysis -- read, filter, and diff FST and VCD files
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

//------------------------------------------------------------------------------
// cat_tests.rs
// Data-driven tests comparing wavecat output against expected golden files
//
// SPDX-FileCopyrightText: Hudson River Trading
// SPDX-License-Identifier: MIT
//------------------------------------------------------------------------------

use std::path::Path;

use wavetools::{names_only, open_wave_file, write_attrs, write_names, write_signals_wave, NameOptions, SignalOutputOptions};

/// Strip the .fst or .vcd extension to get the base name used for expected files.
fn base_name(path: &Path) -> String {
    let file_name = path.file_name().unwrap().to_str().unwrap();
    file_name
        .strip_suffix(".fst")
        .or_else(|| file_name.strip_suffix(".vcd"))
        .expect("test file must have .fst or .vcd extension")
        .to_string()
}

/// For each .fst/.vcd file, compare `write_names --sort` output against
/// `tests/data/expected/{base}.names`.
fn test_names(path: &Path) -> datatest_stable::Result<()> {
    let base = base_name(path);
    let expected_path = path
        .parent()
        .unwrap()
        .join(format!("expected/{}.names", base));
    let expected = std::fs::read_to_string(&expected_path).map_err(|e| {
        format!(
            "Missing expected file {}: {} -- generate it with: wavecat --names --sort {}",
            expected_path.display(),
            e,
            path.display(),
        )
    })?;

    let name_options = NameOptions::default();
    let (_, hier) = open_wave_file(path, &name_options)?;
    let handle_to_names = names_only(&hier.signal_map, &hier.names);

    let mut output = Vec::new();
    write_names(&mut output, &handle_to_names, true)?;
    let actual = String::from_utf8(output)?;

    assert_eq!(actual, expected, "names mismatch for {}", path.display());
    Ok(())
}

/// For each .fst/.vcd file, compare sorted signal dump against
/// `tests/data/expected/{base}.cat`.
fn test_cat(path: &Path) -> datatest_stable::Result<()> {
    let base = base_name(path);
    let expected_path = path
        .parent()
        .unwrap()
        .join(format!("expected/{}.cat", base));
    let expected = std::fs::read_to_string(&expected_path).map_err(|e| {
        format!(
            "Missing expected file {}: {} -- generate it with: wavecat --sort {}",
            expected_path.display(),
            e,
            path.display(),
        )
    })?;

    let name_options = NameOptions::default();
    let (mut reader, hier) = open_wave_file(path, &name_options)?;
    let handle_to_names = names_only(&hier.signal_map, &hier.names);

    let options = SignalOutputOptions {
        sort: true,
        time_pound: false,
    };
    let mut output = Vec::new();
    write_signals_wave(&mut output, &mut reader, &handle_to_names, 0, None, &options)?;
    let actual = String::from_utf8(output)?;

    assert_eq!(actual, expected, "cat mismatch for {}", path.display());
    Ok(())
}

/// For each .fst/.vcd file, compare sorted `write_attrs` output against
/// `tests/data/expected/{filename}.attrs`.  Unlike names/cat tests, attrs
/// include the format extension because type metadata differs across formats
/// (e.g. FST preserves "reg"/"integer" while VCD uses "wire").
fn test_attrs(path: &Path) -> datatest_stable::Result<()> {
    let file_name = path.file_name().unwrap().to_str().unwrap();
    let expected_path = path
        .parent()
        .unwrap()
        .join(format!("expected/{}.attrs", file_name));
    let expected = std::fs::read_to_string(&expected_path).map_err(|e| {
        format!(
            "Missing expected file {}: {} -- generate it with: wavecat --attrs --sort {}",
            expected_path.display(),
            e,
            path.display(),
        )
    })?;

    let name_options = NameOptions::default();
    let (_, hier) = open_wave_file(path, &name_options)?;

    let mut output = Vec::new();
    write_attrs(&mut output, &hier.signal_map, &hier.names, true)?;
    let actual = String::from_utf8(output)?;

    assert_eq!(actual, expected, "attrs mismatch for {}", path.display());
    Ok(())
}

datatest_stable::harness! {
    { test = test_names, root = "tests/data", pattern = r"^[^/]+\.(fst|vcd)$" },
    { test = test_cat,   root = "tests/data", pattern = r"^[^/]+\.(fst|vcd)$" },
    { test = test_attrs, root = "tests/data", pattern = r"^[^/]+\.(fst|vcd)$" },
}