| 1| |// This demonstrated Issue #84561: function-like macros produce unintuitive coverage results. | |
| 2| | | |
| 3| |// expect-exit-status-101 | |
| 4| 21|#[derive(PartialEq, Eq)] | |
| ------------------ | |
| | <issue_84561::Foo as core::cmp::PartialEq>::eq: | |
| | 4| 21|#[derive(PartialEq, Eq)] | |
| ------------------ | |
| | Unexecuted instantiation: <issue_84561::Foo as core::cmp::PartialEq>::ne | |
| ------------------ | |
| 5| |struct Foo(u32); | |
| 6| 1|fn test3() { | |
| 7| 1| let is_true = std::env::args().len() == 1; | |
| 8| 1| let bar = Foo(1); | |
| 9| 1| assert_eq!(bar, Foo(1)); | |
| 10| 1| let baz = Foo(0); | |
| 11| 1| assert_ne!(baz, Foo(1)); | |
| 12| 1| println!("{:?}", Foo(1)); | |
| 13| 1| println!("{:?}", bar); | |
| 14| 1| println!("{:?}", baz); | |
| 15| 1| | |
| 16| 1| assert_eq!(Foo(1), Foo(1)); | |
| 17| 1| assert_ne!(Foo(0), Foo(1)); | |
| 18| 1| assert_eq!(Foo(2), Foo(2)); | |
| 19| 1| let bar = Foo(0); | |
| 20| 1| assert_ne!(bar, Foo(3)); | |
| 21| 1| assert_ne!(Foo(0), Foo(4)); | |
| 22| 1| assert_eq!(Foo(3), Foo(3), "with a message"); | |
| ^0 | |
| 23| 1| println!("{:?}", bar); | |
| 24| 1| println!("{:?}", Foo(1)); | |
| 25| 1| | |
| 26| 1| assert_ne!(Foo(0), Foo(5), "{}", if is_true { "true message" } else { "false message" }); | |
| ^0 ^0 ^0 | |
| 27| 1| assert_ne!( | |
| 28| | Foo(0) | |
| 29| | , | |
| 30| | Foo(5) | |
| 31| | , | |
| 32| 0| "{}" | |
| 33| 0| , | |
| 34| 0| if | |
| 35| 0| is_true | |
| 36| | { | |
| 37| 0| "true message" | |
| 38| | } else { | |
| 39| 0| "false message" | |
| 40| | } | |
| 41| | ); | |
| 42| | | |
| 43| 1| let is_true = std::env::args().len() == 1; | |
| 44| 1| | |
| 45| 1| assert_eq!( | |
| 46| 1| Foo(1), | |
| 47| 1| Foo(1) | |
| 48| 1| ); | |
| 49| 1| assert_ne!( | |
| 50| 1| Foo(0), | |
| 51| 1| Foo(1) | |
| 52| 1| ); | |
| 53| 1| assert_eq!( | |
| 54| 1| Foo(2), | |
| 55| 1| Foo(2) | |
| 56| 1| ); | |
| 57| 1| let bar = Foo(1); | |
| 58| 1| assert_ne!( | |
| 59| 1| bar, | |
| 60| 1| Foo(3) | |
| 61| 1| ); | |
| 62| 1| if is_true { | |
| 63| 1| assert_ne!( | |
| 64| 1| Foo(0), | |
| 65| 1| Foo(4) | |
| 66| 1| ); | |
| 67| | } else { | |
| 68| 0| assert_eq!( | |
| 69| 0| Foo(3), | |
| 70| 0| Foo(3) | |
| 71| 0| ); | |
| 72| | } | |
| 73| 1| if is_true { | |
| 74| 1| assert_ne!( | |
| 75| | Foo(0), | |
| 76| | Foo(4), | |
| 77| 0| "with a message" | |
| 78| | ); | |
| 79| | } else { | |
| 80| 0| assert_eq!( | |
| 81| | Foo(3), | |
| 82| | Foo(3), | |
| 83| 0| "with a message" | |
| 84| | ); | |
| 85| | } | |
| 86| 1| assert_ne!( | |
| 87| 1| if is_true { | |
| 88| 1| Foo(0) | |
| 89| | } else { | |
| 90| 0| Foo(1) | |
| 91| | }, | |
| 92| | Foo(5) | |
| 93| | ); | |
| 94| 1| assert_ne!( | |
| 95| 1| Foo(5), | |
| 96| 1| if is_true { | |
| 97| 1| Foo(0) | |
| 98| | } else { | |
| 99| 0| Foo(1) | |
| 100| | } | |
| 101| | ); | |
| 102| 1| assert_ne!( | |
| 103| 1| if is_true { | |
| 104| 1| assert_eq!( | |
| 105| 1| Foo(3), | |
| 106| 1| Foo(3) | |
| 107| 1| ); | |
| 108| 1| Foo(0) | |
| 109| | } else { | |
| 110| 0| assert_ne!( | |
| 111| 0| if is_true { | |
| 112| 0| Foo(0) | |
| 113| | } else { | |
| 114| 0| Foo(1) | |
| 115| | }, | |
| 116| | Foo(5) | |
| 117| | ); | |
| 118| 0| Foo(1) | |
| 119| | }, | |
| 120| | Foo(5), | |
| 121| 0| "with a message" | |
| 122| | ); | |
| 123| 1| assert_eq!( | |
| 124| | Foo(1), | |
| 125| | Foo(3), | |
| 126| 1| "this assert should fail" | |
| 127| | ); | |
| 128| 0| assert_eq!( | |
| 129| | Foo(3), | |
| 130| | Foo(3), | |
| 131| 0| "this assert should not be reached" | |
| 132| | ); | |
| 133| 0|} | |
| 134| | | |
| 135| |impl std::fmt::Debug for Foo { | |
| 136| | fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result { | |
| 137| 7| write!(f, "try and succeed")?; | |
| ^0 | |
| 138| 7| Ok(()) | |
| 139| 7| } | |
| 140| |} | |
| 141| | | |
| 142| |static mut DEBUG_LEVEL_ENABLED: bool = false; | |
| 143| | | |
| 144| |macro_rules! debug { | |
| 145| | ($($arg:tt)+) => ( | |
| 146| | if unsafe { DEBUG_LEVEL_ENABLED } { | |
| 147| | println!($($arg)+); | |
| 148| | } | |
| 149| | ); | |
| 150| |} | |
| 151| | | |
| 152| 1|fn test1() { | |
| 153| 1| debug!("debug is enabled"); | |
| ^0 | |
| 154| 1| debug!("debug is enabled"); | |
| ^0 | |
| 155| 1| let _ = 0; | |
| 156| 1| debug!("debug is enabled"); | |
| ^0 | |
| 157| 1| unsafe { | |
| 158| 1| DEBUG_LEVEL_ENABLED = true; | |
| 159| 1| } | |
| 160| 1| debug!("debug is enabled"); | |
| 161| 1|} | |
| 162| | | |
| 163| |macro_rules! call_debug { | |
| 164| | ($($arg:tt)+) => ( | |
| 165| 1| fn call_print(s: &str) { | |
| 166| 1| print!("{}", s); | |
| 167| 1| } | |
| 168| | | |
| 169| | call_print("called from call_debug: "); | |
| 170| | debug!($($arg)+); | |
| 171| | ); | |
| 172| |} | |
| 173| | | |
| 174| 1|fn test2() { | |
| 175| 1| call_debug!("debug is enabled"); | |
| 176| 1|} | |
| 177| | | |
| 178| 1|fn main() { | |
| 179| 1| test1(); | |
| 180| 1| test2(); | |
| 181| 1| test3(); | |
| 182| 1|} | |