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
// =============================================================================
// Copyright (c) 2025 - 2026 Haixing Hu.
//
// SPDX-License-Identifier: Apache-2.0
//
// Licensed under the Apache License, Version 2.0.
// =============================================================================
//! Unit tests for StatefulMutatingFunction types (stateful FnMut(&mut T) ->
//! R)
use qubit_function::{
ArcStatefulMutatingFunction,
BoxStatefulMutatingFunction,
MutatingFunctionOnce,
RcStatefulMutatingFunction,
StatefulMutatingFunction,
};
use std::cell::RefCell;
use std::rc::Rc;
// ============================================================================
// StatefulMutatingFunction Default Implementation Tests
// ============================================================================
/// Test struct that implements StatefulMutatingFunction to test default methods
struct TestStatefulMutatingFunction {
multiplier: i32,
}
impl TestStatefulMutatingFunction {
fn new(multiplier: i32) -> Self {
TestStatefulMutatingFunction { multiplier }
}
}
impl StatefulMutatingFunction<i32, i32> for TestStatefulMutatingFunction {
fn apply(&mut self, input: &mut i32) -> i32 {
let old_value = *input;
*input *= self.multiplier;
old_value
}
}
impl Clone for TestStatefulMutatingFunction {
fn clone(&self) -> Self {
TestStatefulMutatingFunction {
multiplier: self.multiplier,
}
}
}
// ============================================================================
// BoxStatefulMutatingFunction Tests
// ============================================================================
#[cfg(test)]
mod test_closure {
use super::{
MutatingFunctionOnce,
Rc,
RefCell,
StatefulMutatingFunction,
};
#[test]
fn test_closure_implements_trait() {
// Use Rc<RefCell<>> to properly test stateful behavior
let count = Rc::new(RefCell::new(0));
let count_clone = Rc::clone(&count);
let closure = move |x: &mut i32| {
let mut current = count_clone.borrow_mut();
*current += 1;
*x *= 2;
*current
};
// Test direct closure calls
let mut value = 5;
let direct_result1 = closure(&mut value);
assert_eq!(direct_result1, 1);
assert_eq!(value, 10);
let direct_result2 = closure(&mut value);
assert_eq!(direct_result2, 2);
assert_eq!(value, 20);
// Test with trait
let count2 = Rc::new(RefCell::new(0));
let count2_clone = Rc::clone(&count2);
let mut closure2 = move |x: &mut i32| {
let mut current = count2_clone.borrow_mut();
*current += 1;
*x *= 2;
*current
};
// Test that closure implements StatefulMutatingFunction trait
let _trait_check: &mut dyn StatefulMutatingFunction<i32, i32> =
&mut closure2;
let mut value2 = 5;
let result1 =
StatefulMutatingFunction::apply(&mut closure2, &mut value2);
assert_eq!(result1, 1);
assert_eq!(value2, 10);
let result2 =
StatefulMutatingFunction::apply(&mut closure2, &mut value2);
assert_eq!(result2, 2);
assert_eq!(value2, 20);
}
}
// ============================================================================
// StatefulMutatingFunction Debug and Display Tests
// ============================================================================