tests/ui/consts/const-binops.rs

   1 // run-pass
   2
   3 macro_rules! assert_approx_eq {
   4     ($a:expr, $b:expr) => ({
   5         let (a, b) = (&$a, &$b);
   6         assert!((*a - *b).abs() < 1.0e-6,
   7                 "{} is not approximately equal to {}", *a, *b);
   8     })
   9 }
  10
  11 static A: isize = -4 + 3;
  12 static A2: usize = 3 + 3;
  13 static B: f64 = 3.0 + 2.7;
  14
  15 static C: isize = 3 - 4;
  16 static D: usize = 3 - 3;
  17 static E: f64 = 3.0 - 2.7;
  18
  19 static E2: isize = -3 * 3;
  20 static F: usize = 3 * 3;
  21 static G: f64 = 3.3 * 3.3;
  22
  23 static H: isize = 3 / -1;
  24 static I: usize = 3 / 3;
  25 static J: f64 = 3.3 / 3.3;
  26
  27 static N: bool = true && false;
  28
  29 static O: bool = true || false;
  30
  31 static P: isize = 3 & 1;
  32 static Q: usize = 1 & 3;
  33
  34 static R: isize = 3 | 1;
  35 static S: usize = 1 | 3;
  36
  37 static T: isize = 3 ^ 1;
  38 static U: usize = 1 ^ 3;
  39
  40 static V: isize = 1 << 3;
  41
  42 // NOTE: better shr coverage
  43 static W: isize = 1024 >> 4;
  44 static X: usize = 1024 >> 4;
  45
  46 static Y: bool = 1 == 1;
  47 static Z: bool = 1.0f64 == 1.0;
  48
  49 static AA: bool = 1 <= 2;
  50 static AB: bool = -1 <= 2;
  51 static AC: bool = 1.0f64 <= 2.0;
  52
  53 static AD: bool = 1 < 2;
  54 static AE: bool = -1 < 2;
  55 static AF: bool = 1.0f64 < 2.0;
  56
  57 static AG: bool = 1 != 2;
  58 static AH: bool = -1 != 2;
  59 static AI: bool = 1.0f64 != 2.0;
  60
  61 static AJ: bool = 2 >= 1;
  62 static AK: bool = 2 >= -2;
  63 static AL: bool = 1.0f64 >= -2.0;
  64
  65 static AM: bool = 2 > 1;
  66 static AN: bool = 2 > -2;
  67 static AO: bool = 1.0f64 > -2.0;
  68
  69 pub fn main() {
  70     assert_eq!(A, -1);
  71     assert_eq!(A2, 6);
  72     assert_approx_eq!(B, 5.7);
  73
  74     assert_eq!(C, -1);
  75     assert_eq!(D, 0);
  76     assert_approx_eq!(E, 0.3);
  77
  78     assert_eq!(E2, -9);
  79     assert_eq!(F, 9);
  80     assert_approx_eq!(G, 10.89);
  81
  82     assert_eq!(H, -3);
  83     assert_eq!(I, 1);
  84     assert_approx_eq!(J, 1.0);
  85
  86     assert_eq!(N, false);
  87
  88     assert_eq!(O, true);
  89
  90     assert_eq!(P, 1);
  91     assert_eq!(Q, 1);
  92
  93     assert_eq!(R, 3);
  94     assert_eq!(S, 3);
  95
  96     assert_eq!(T, 2);
  97     assert_eq!(U, 2);
  98
  99     assert_eq!(V, 8);
 100
 101     assert_eq!(W, 64);
 102     assert_eq!(X, 64);
 103
 104     assert_eq!(Y, true);
 105     assert_eq!(Z, true);
 106
 107     assert_eq!(AA, true);
 108     assert_eq!(AB, true);
 109     assert_eq!(AC, true);
 110
 111     assert_eq!(AD, true);
 112     assert_eq!(AE, true);
 113     assert_eq!(AF, true);
 114
 115     assert_eq!(AG, true);
 116     assert_eq!(AH, true);
 117     assert_eq!(AI, true);
 118
 119     assert_eq!(AJ, true);
 120     assert_eq!(AK, true);
 121     assert_eq!(AL, true);
 122
 123     assert_eq!(AM, true);
 124     assert_eq!(AN, true);
 125     assert_eq!(AO, true);
 126 }