Macro 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);