NeuralAmpModeler-rs 3.0.0

An opinionated, high-performance Neural Amp Modeler (NAM) client and core implementation in Rust for Linux/PipeWire and CLAP plugins.
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
120

// SPDX-License-Identifier: Apache-2.0
// Copyright (c) 2026 Fábio Henrique de Lima Silva (fhl.bsb@gmail.com) All rights reserved.

use super::AlignedVec;
use crate::common::diagnostics::NamErrorCode;

#[test]
fn aligned_from_vec_empty_is_safe() {
    let v: Vec<f32> = Vec::new();
    let aligned = AlignedVec::from_vec(v).unwrap();
    assert!(aligned.is_empty());
    assert_eq!(aligned.len(), 0);
    assert_eq!(aligned.cap(), 0);
}

#[test]
fn aligned_from_vec_preserves_data() {
    let v = vec![1.0f32, 2.0, 3.0];
    let aligned = AlignedVec::from_vec(v).unwrap();
    assert_eq!(aligned.len(), 3);
    assert_eq!(aligned.cap(), 3);
    assert_eq!(aligned[0], 1.0);
    assert_eq!(aligned[1], 2.0);
    assert_eq!(aligned[2], 3.0);
}

#[test]
fn aligned_from_vec_empty_capacity_zero() {
    let v: Vec<f64> = Vec::new();
    let aligned = AlignedVec::from_vec(v).unwrap();
    assert!(aligned.is_empty());
    assert_eq!(aligned.len(), 0);
    assert_eq!(aligned.cap(), 0);
}

#[test]
fn with_capacity_sets_cap() {
    let v = AlignedVec::<f32>::with_capacity(100).unwrap();
    assert_eq!(v.len(), 0);
    assert_eq!(v.cap(), 100);
    assert!(v.is_empty());
}

#[test]
fn with_capacity_zero() {
    let v = AlignedVec::<f32>::with_capacity(0).unwrap();
    assert_eq!(v.len(), 0);
    assert_eq!(v.cap(), 0);
    assert!(v.is_empty());
}

#[test]
fn drop_excess_capacity_leak_free() {
    {
        let _v = AlignedVec::<f32>::with_capacity(1024).unwrap();
    }
}

#[test]
fn new_sets_len_eq_cap() {
    let v = AlignedVec::new(64, 0.0f32).unwrap();
    assert_eq!(v.len(), 64);
    assert_eq!(v.cap(), 64);
    assert_eq!(v[0], 0.0);
    assert_eq!(v[63], 0.0);
}

#[test]
fn clone_preserves_len_cap() {
    let original = AlignedVec::new(42, 1.0f64).unwrap();
    let cloned = original.clone();
    assert_eq!(cloned.len(), 42);
    assert_eq!(cloned.cap(), 42);
    assert_eq!(cloned[0], 1.0);
    assert_eq!(cloned[41], 1.0);
}

#[test]
fn resize_grows_cap_and_len() {
    let mut v = AlignedVec::new(2, 0.0f32).unwrap();
    assert_eq!(v.len(), 2);
    assert_eq!(v.cap(), 2);
    v.resize(8, 1.0f32).unwrap();
    assert_eq!(v.len(), 8);
    assert_eq!(v.cap(), 8);
    assert_eq!(v[0], 0.0);
    assert_eq!(v[7], 1.0);
}

#[test]
fn resize_noop_preserves_dimensions() {
    let mut v = AlignedVec::new(8, 0.0f32).unwrap();
    v.resize(4, 1.0f32).unwrap();
    assert_eq!(v.len(), 8);
    assert_eq!(v.cap(), 8);
}

#[test]
fn alignment_is_64_bytes() {
    let v = AlignedVec::<f32>::new(1, 0.0f32).unwrap();
    assert_eq!(
        v.as_ptr() as usize % AlignedVec::<f32>::ALIGN,
        0,
        "pointer must be 64-byte aligned"
    );
}

#[test]
fn new_alloc_oom_on_layout_overflow() {
    let result = AlignedVec::<f32>::new(isize::MAX as usize, 0.0f32);
    assert!(result.is_err());
    assert_eq!(result.unwrap_err(), NamErrorCode::OutOfMemory);
}

#[test]
fn with_capacity_oom_on_layout_overflow() {
    let result = AlignedVec::<f32>::with_capacity(isize::MAX as usize);
    assert!(result.is_err());
    assert_eq!(result.unwrap_err(), NamErrorCode::OutOfMemory);
}