src/test/run-pass/discrim-explicit-23030.rs

   1 // Copyright 2015 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 // Issue 23030: Workaround overflowing discriminant
  12 // with explicit assignments.
  13
  14 // See also compile-fail/overflow-discrim.rs, which shows what
  15 // happens if you leave the OhNo explicit cases out here.
  16
  17 use std::{i8,u8,i16,u16,i32,u32,i64,u64,isize,usize};
  18
  19 fn f_i8() {
  20     #[repr(i8)]
  21     enum A {
  22         Ok = i8::MAX - 1,
  23         Ok2,
  24         OhNo = i8::MIN,
  25         NotTheEnd = -1,
  26         Zero,
  27     }
  28
  29     let _x = (A::Ok, A::Ok2, A::OhNo);
  30     let z = (A::NotTheEnd, A::Zero).1 as i8;
  31     assert_eq!(z, 0);
  32 }
  33
  34 fn f_u8() {
  35     #[repr(u8)]
  36     enum A {
  37         Ok = u8::MAX - 1,
  38         Ok2,
  39         OhNo = u8::MIN,
  40     }
  41
  42     let _x = (A::Ok, A::Ok2, A::OhNo);
  43 }
  44
  45 fn f_i16() {
  46     #[repr(i16)]
  47     enum A {
  48         Ok = i16::MAX - 1,
  49         Ok2,
  50         OhNo = i16::MIN,
  51         NotTheEnd = -1,
  52         Zero,
  53     }
  54
  55     let _x = (A::Ok, A::Ok2, A::OhNo);
  56     let z = (A::NotTheEnd, A::Zero).1 as i16;
  57     assert_eq!(z, 0);
  58 }
  59
  60 fn f_u16() {
  61     #[repr(u16)]
  62     enum A {
  63         Ok = u16::MAX - 1,
  64         Ok2,
  65         OhNo = u16::MIN,
  66     }
  67
  68     let _x = (A::Ok, A::Ok2, A::OhNo);
  69 }
  70
  71 fn f_i32() {
  72     #[repr(i32)]
  73     enum A {
  74         Ok = i32::MAX - 1,
  75         Ok2,
  76         OhNo = i32::MIN,
  77         NotTheEnd = -1,
  78         Zero,
  79     }
  80
  81     let _x = (A::Ok, A::Ok2, A::OhNo);
  82     let z = (A::NotTheEnd, A::Zero).1 as i32;
  83     assert_eq!(z, 0);
  84 }
  85
  86 fn f_u32() {
  87     #[repr(u32)]
  88     enum A {
  89         Ok = u32::MAX - 1,
  90         Ok2,
  91         OhNo = u32::MIN,
  92     }
  93
  94     let _x = (A::Ok, A::Ok2, A::OhNo);
  95 }
  96
  97 fn f_i64() {
  98     #[repr(i64)]
  99     enum A {
 100         Ok = i64::MAX - 1,
 101         Ok2,
 102         OhNo = i64::MIN,
 103         NotTheEnd = -1,
 104         Zero,
 105     }
 106
 107     let _x = (A::Ok, A::Ok2, A::OhNo);
 108     let z = (A::NotTheEnd, A::Zero).1 as i64;
 109     assert_eq!(z, 0);
 110 }
 111
 112 fn f_u64() {
 113     #[repr(u64)]
 114     enum A {
 115         Ok = u64::MAX - 1,
 116         Ok2,
 117         OhNo = u64::MIN,
 118     }
 119
 120     let _x = (A::Ok, A::Ok2, A::OhNo);
 121 }
 122
 123 fn f_isize() {
 124     #[repr(isize)]
 125     enum A {
 126         Ok = isize::MAX - 1,
 127         Ok2,
 128         OhNo = isize::MIN,
 129         NotTheEnd = -1,
 130         Zero,
 131     }
 132
 133     let _x = (A::Ok, A::Ok2, A::OhNo);
 134     let z = (A::NotTheEnd, A::Zero).1 as isize;
 135     assert_eq!(z, 0);
 136 }
 137
 138 fn f_usize() {
 139     #[repr(usize)]
 140     enum A {
 141         Ok = usize::MAX - 1,
 142         Ok2,
 143         OhNo = usize::MIN,
 144     }
 145
 146     let _x = (A::Ok, A::Ok2, A::OhNo);
 147 }
 148
 149 fn main() {
 150     f_i8(); f_u8();
 151     f_i16(); f_u16();
 152     f_i32(); f_u32();
 153     f_i64(); f_u64();
 154
 155     f_isize(); f_usize();
 156 }