blob: cbeda35d3b8cfe8a5b226f769282d568f9689012 (
plain)
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
|
#![allow(unused_assignments)]
// expect-exit-status-1
struct Firework<T> where T: Copy + std::fmt::Display {
strength: T,
}
impl<T> Firework<T> where T: Copy + std::fmt::Display {
#[inline(always)]
fn set_strength(&mut self, new_strength: T) {
self.strength = new_strength;
}
}
impl<T> Drop for Firework<T> where T: Copy + std::fmt::Display {
#[inline(always)]
fn drop(&mut self) {
println!("BOOM times {}!!!", self.strength);
}
}
fn main() -> Result<(),u8> {
let mut firecracker = Firework { strength: 1 };
firecracker.set_strength(2);
let mut tnt = Firework { strength: 100.1 };
tnt.set_strength(200.1);
tnt.set_strength(300.3);
if true {
println!("Exiting with error...");
return Err(1);
} // The remaining lines below have no coverage because `if true` (with the constant literal
// `true`) is guaranteed to execute the `then` block, which is also guaranteed to `return`.
// Thankfully, in the normal case, conditions are not guaranteed ahead of time, and as shown
// in other tests, the lines below would have coverage (which would show they had `0`
// executions, assuming the condition still evaluated to `true`).
let _ = Firework { strength: 1000 };
Ok(())
}
// Expected program output:
// Exiting with error...
// BOOM times 100!!!
// BOOM times 1!!!
// Error: 1
|
