Macro test_toolbox::actual

macro_rules! actual {
    (@ dbg $var : ident : $typ : ty) => { ... };
    (@ rls $var : ident : $typ : ty) => { ... };
    (@ dbg $var : ident : $typ : ty ; $val : expr) => { ... };
    (@ rls $var : ident : $typ : ty ; $val : expr) => { ... };
    (@ dbg mut $var : ident : $typ : ty ; $exp : expr) => { ... };
    (@ rls mut $var : ident : $typ : ty ; $exp : expr) => { ... };
}

Macro to define different actual variables for debug and release

This is useful when testing logic with differing actual variable definitions based on build.

Basically erogonomifies the following …

cfg_if! {
   if #[cfg(not(debug_assertions))] {
       let expected = Default::default();
   } else {
       let expected = 42;
   }
}
cfg_if! {
   if #[cfg(not(debug_assertions))] {
       let actual: usize = Default::default();
   } else {
       let actual: usize;
   }
}

#[cfg(debug_assertions)]
{ actual = sut(); }

assert_eq!(expected, actual);

with ..

expect! { expected = Default::default(), 42 }
actual! { @dbg actual: usize }

#[cfg(debug_assertions)]
{ actual = sut(); }

assert_eq!(expected, actual);

Features

Examples

• debug; uninitialized actual variable release; actual variable initialized to default

expect! { expected: usize = Default::default(), 42 }
actual! { @dbg actual: usize }

#[cfg(debug_assertions)]
{ actual = sut(); }

assert_eq!(expected, actual);

• release; uninitialized actual variable debug; actual variable initialized to default

expect! { expected: usize = 42, Default::default() }
actual! { @rls actual: usize }

#[cfg(not(debug_assertions))]
{ actual = sut(); }

assert_eq!(expected, actual);

• debug; uninitialized actual variable release; actual variable initialized to a value

expect! { expected: usize = 2, 42 }
actual! { @dbg actual: usize; 2 }

#[cfg(debug_assertions)]
{ actual = sut(); }

assert_eq!(expected, actual);

• release; uninitialized actual variable debug; actual variable initialized to a value

expect! { expected: usize = 42, 2 }
actual! { @rls actual: usize; 2 }

#[cfg(not(debug_assertions))]
{ actual = sut(); }

assert_eq!(expected, actual);

• debug; mutable actual variable initialized to a value release; immutable actual variable initialized to a value

expect! { expected = "", "Forty Two" }
actual! { @dbg mut actual: String; String::new() }

#[cfg(debug_assertions)]
{ actual.push_str(&sut()); }

assert_eq!(expected, &actual);

• release; mutable actual variable initialized to a value debug; immutable actual variable initialized to a value

expect! { expected = "Forty Two", "" }
actual! { @rls mut actual: String; String::new() }

#[cfg(not(debug_assertions))]
{ actual.push_str(&sut()); }

assert_eq!(expected, &actual);