test_tools 0.19.1

Tools for writing and running tests.
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210

// Re-export pretty_assertions if available
#[cfg(feature = "diagnostics_runtime_assertions")]
#[allow(unused_imports)]
pub use pretty_assertions::*;

// Placeholder macros for diagnostics tools compatibility
// NOTE: Real implementations in `diagnostics_tools` use `pretty_assertions` for better diff output
// Standalone versions use standard Rust assertions without fancy formatting

/// Placeholder macro for `a_true` - asserts boolean expression is true at runtime
/// NOTE: Real implementation in `diagnostics_tools` wraps `assert`!() with same semantics
#[macro_export]
macro_rules! a_true {
  () => {};
  ( $($Rest:tt)* ) => {
    assert!( $($Rest)* );
  };
}

/// Placeholder macro for `a_false` - asserts boolean expression is false at runtime
/// NOTE: Real implementation in `diagnostics_tools` wraps `assert`!(!...) with same semantics
#[macro_export]
macro_rules! a_false {
  () => {};
  ( $($Rest:tt)* ) => {
    assert!( ! $($Rest)* );
  };
}

/// Placeholder macro for `a_id` - asserts two expressions are identical (equal)
/// NOTE: Real implementation in `diagnostics_tools` uses `pretty_assertions::assert_eq`!() for better diff
/// Standalone version uses `pretty_assertions` when available, standard `assert_eq` otherwise
#[macro_export]
macro_rules! a_id {
  ( $left:expr , $right:expr $(,)? ) => {
    #[ cfg( feature = "diagnostics_runtime_assertions" ) ]
    {
      $crate::diagnostics_tools::assert_eq!( $left, $right );
    }
    #[ cfg( not( feature = "diagnostics_runtime_assertions" ) ) ]
    {
      assert_eq!( $left, $right );
    }
  };
  ( $left:expr, $right:expr, $($arg:tt)* ) => {
    #[ cfg( feature = "diagnostics_runtime_assertions" ) ]
    {
      $crate::diagnostics_tools::assert_eq!( $left, $right, $($arg)* );
    }
    #[ cfg( not( feature = "diagnostics_runtime_assertions" ) ) ]
    {
      assert_eq!( $left, $right, $($arg)* );
    }
  };
}

/// Placeholder macro for `a_not_id` - asserts two expressions are not identical (not equal)
/// NOTE: Real implementation in `diagnostics_tools` uses `pretty_assertions::assert_ne`!() for better diff
/// Standalone version uses `pretty_assertions` when available, standard `assert_ne` otherwise
#[macro_export]
macro_rules! a_not_id {
  ( $left:expr , $right:expr $(,)? ) => {
    #[ cfg( feature = "diagnostics_runtime_assertions" ) ]
    {
      $crate::diagnostics_tools::assert_ne!( $left, $right );
    }
    #[ cfg( not( feature = "diagnostics_runtime_assertions" ) ) ]
    {
      assert_ne!( $left, $right );
    }
  };
  ( $left:expr, $right:expr, $($arg:tt)* ) => {
    #[ cfg( feature = "diagnostics_runtime_assertions" ) ]
    {
      $crate::diagnostics_tools::assert_ne!( $left, $right, $($arg)* );
    }
    #[ cfg( not( feature = "diagnostics_runtime_assertions" ) ) ]
    {
      assert_ne!( $left, $right, $($arg)* );
    }
  };
}

/// Placeholder macro for `a_dbg_true` - asserts boolean expression is true in debug builds
/// NOTE: Real implementation in `diagnostics_tools` wraps `debug_assert`!() with same semantics
#[macro_export]
macro_rules! a_dbg_true {
  () => {};
  ( $($Rest:tt)* ) => {
    debug_assert!( $($Rest)* );
  };
}

/// Placeholder macro for `a_dbg_false` - asserts boolean expression is false in debug builds
/// NOTE: Real implementation in `diagnostics_tools` wraps `debug_assert`!(!...) with same semantics
#[macro_export]
macro_rules! a_dbg_false {
  () => {};
  ( $($Rest:tt)* ) => {
    debug_assert!( ! $($Rest)* );
  };
}

/// Placeholder macro for `a_dbg_id` - asserts two expressions are identical in debug builds
/// NOTE: Real implementation in `diagnostics_tools` calls `a_id`!() only if `debug_assertions` enabled
#[macro_export]
macro_rules! a_dbg_id {
  ( $($arg:tt)* ) => {
    if cfg!( debug_assertions ) {
      $crate::a_id!( $($arg)* );
    }
  };
}

/// Placeholder macro for `a_dbg_not_id` - asserts two expressions are not identical in debug builds
/// NOTE: Real implementation in `diagnostics_tools` calls `a_not_id`!() only if `debug_assertions` enabled
#[macro_export]
macro_rules! a_dbg_not_id {
  ( $($arg:tt)* ) => {
    if cfg!( debug_assertions ) {
      $crate::a_not_id!( $($arg)* );
    }
  };
}

/// Placeholder macro for `cta_true` (compile-time assertion compatibility)
/// NOTE: Real implementation in `diagnostics_tools` does compile-time boolean checking
/// Standalone version returns true without compile-time validation
#[macro_export]
macro_rules! cta_true {
  ( $($tokens:tt)* ) => { true };
}

/// Placeholder macro for `cta_type_same_size` (compile-time assertion compatibility)
/// NOTE: Real implementation in `diagnostics_tools` does compile-time size checking
/// Standalone version returns true without compile-time validation
#[macro_export]
macro_rules! cta_type_same_size {
  ( $($tokens:tt)* ) => { true };
}

/// Placeholder macro for `cta_type_same_align` (compile-time assertion compatibility)
/// NOTE: Real implementation in `diagnostics_tools` does compile-time alignment checking
/// Standalone version returns true without compile-time validation
#[macro_export]
macro_rules! cta_type_same_align {
  ( $($tokens:tt)* ) => { true };
}

/// Placeholder macro for `cta_ptr_same_size` (compile-time assertion compatibility)
/// NOTE: Real implementation in `diagnostics_tools` does compile-time pointer size checking
/// Standalone version returns true without compile-time validation
#[macro_export]
macro_rules! cta_ptr_same_size {
  ( $($tokens:tt)* ) => { true };
}

/// Placeholder macro for `cta_mem_same_size` (compile-time assertion compatibility)
/// NOTE: Real implementation in `diagnostics_tools` does compile-time memory size checking
/// Standalone version returns true without compile-time validation
#[macro_export]
macro_rules! cta_mem_same_size {
  ( $($tokens:tt)* ) => { true };
}

pub use a_true;
pub use a_id;
pub use a_false;
pub use cta_true;
pub use a_not_id;
pub use a_dbg_true;
pub use a_dbg_id;
pub use a_dbg_not_id;
pub use cta_type_same_size;
pub use cta_type_same_align;
pub use cta_ptr_same_size;
pub use cta_mem_same_size;

/// Orphan module for compatibility
#[allow(unused_imports)]
pub mod orphan {
  #[cfg(feature = "diagnostics_runtime_assertions")]
  pub use pretty_assertions::*;

  #[cfg(feature = "standalone_diagnostics_tools")]
  pub use super::{a_true, a_id, a_false, cta_true, a_not_id, a_dbg_true, a_dbg_id, a_dbg_not_id,
                  cta_type_same_size, cta_type_same_align, cta_ptr_same_size, cta_mem_same_size};
}

/// Exposed module for compatibility
#[allow(unused_imports)]
pub mod exposed {
  #[cfg(feature = "diagnostics_runtime_assertions")]
  pub use pretty_assertions::*;

  #[cfg(feature = "standalone_diagnostics_tools")]
  pub use super::{a_true, a_id, a_false, cta_true, a_not_id, a_dbg_true, a_dbg_id, a_dbg_not_id,
                  cta_type_same_size, cta_type_same_align, cta_ptr_same_size, cta_mem_same_size};
}

/// Prelude module for compatibility
#[allow(unused_imports)]
pub mod prelude {
  #[cfg(feature = "diagnostics_runtime_assertions")]
  pub use pretty_assertions::*;

  #[cfg(feature = "standalone_diagnostics_tools")]
  pub use super::{a_true, a_id, a_false, cta_true, a_not_id, a_dbg_true, a_dbg_id, a_dbg_not_id,
                  cta_type_same_size, cta_type_same_align, cta_ptr_same_size, cta_mem_same_size};
}