Add enum_underlying_type test

Author: lucic71

tests/unit/enum_int_interop.cpp

@@ -50,8 +50,6 @@ int classify_option(int option) {
 
 Color make_color(int n) { return (Color)n; }
 
-enum Flag : bool { FLAG_OFF = false, FLAG_ON = true };
-
 int main() {
   Color c = RED;
 
@@ -142,10 +140,5 @@ int main() {
   assert(entries[2].color == BLUE);
   assert(entries[2].opt == OPT_C);
 
-  Flag flag = FLAG_ON;
-  assert(flag);
-  assert(!FLAG_OFF);
-  flag = FLAG_OFF;
-  assert(flag == FLAG_OFF);
   return 0;
 }

tests/unit/enum_underlying_type.cpp

@@ -0,0 +1,49 @@
+#include <cassert>
+#include <cstdint>
+
+enum Flag : bool { FLAG_OFF = false, FLAG_ON = true };
+
+enum Small : unsigned char { SMALL_ZERO = 0, SMALL_MAX = 255 };
+
+enum Signed : signed char { SIGNED_MIN = -128, SIGNED_ONE = 1 };
+
+enum Wide : long long { WIDE_NEG = -1, WIDE_BIG = 1LL << 40 };
+
+enum Sized : uint16_t { SIZED_A = 1, SIZED_B = 0xFFFF };
+
+enum class Scoped : int8_t { NEG = -2, POS = 2 };
+
+int main() {
+  Flag flag = FLAG_ON;
+  assert(flag);
+  assert(!FLAG_OFF);
+  flag = FLAG_OFF;
+  assert(flag == FLAG_OFF);
+  bool b = flag;
+  assert(b == false);
+
+  Small s = SMALL_MAX;
+  assert(s == 255);
+  assert(sizeof(s) == 1);
+  s = SMALL_ZERO;
+  assert(s + 1 == 1);
+
+  Signed sg = SIGNED_MIN;
+  assert(sg == -128);
+  assert(sg < SIGNED_ONE);
+
+  Wide w = WIDE_BIG;
+  assert(w == (1LL << 40));
+  assert(sizeof(w) == 8);
+  assert(WIDE_NEG < 0);
+
+  Sized z = SIZED_B;
+  assert(z == 0xFFFF);
+  assert(sizeof(z) == 2);
+  assert(SIZED_A + 1 == 2);
+
+  Scoped sc = Scoped::NEG;
+  assert(static_cast<int>(sc) == -2);
+  assert(static_cast<int8_t>(Scoped::POS) == 2);
+  return 0;
+}

tests/unit/out/refcount/enum_int_interop.rs

@@ -86,9 +86,6 @@ pub fn classify_option_5(mut option: i32) -> i32 {
 pub fn make_color_6(mut n: i32) -> Color {
     return ((n) as Color);
 }
-pub type Flag = bool;
-pub const Flag_FLAG_OFF: Flag = false;
-pub const Flag_FLAG_ON: Flag = true;
 pub fn main() {
     __cpp2rust_init_globals();
     std::process::exit(main_0());
@@ -191,11 +188,6 @@ fn main_0() -> i32 {
         (({ (*entries_3.with(Value::clone).borrow())[(2) as usize].opt } as i32)
             == (Option_OPT_C as i32))
     );
-    let mut flag: Flag = Flag_FLAG_ON;
-    assert!(flag);
-    assert!(!(Flag_FLAG_OFF));
-    flag = Flag_FLAG_OFF;
-    assert!(((flag as i32) == (Flag_FLAG_OFF as i32)));
     return 0;
 }
 pub fn __cpp2rust_init_globals() {

tests/unit/out/refcount/enum_underlying_type.rs

@@ -0,0 +1,60 @@
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::io::prelude::*;
+use std::io::{Read, Seek, Write};
+use std::os::fd::AsFd;
+use std::rc::{Rc, Weak};
+pub type Flag = bool;
+pub const Flag_FLAG_OFF: Flag = false;
+pub const Flag_FLAG_ON: Flag = true;
+pub type Small = u8;
+pub const Small_SMALL_ZERO: Small = 0;
+pub const Small_SMALL_MAX: Small = 255;
+pub type Signed = i8;
+pub const Signed_SIGNED_MIN: Signed = -128;
+pub const Signed_SIGNED_ONE: Signed = 1;
+pub type Wide = i64;
+pub const Wide_WIDE_NEG: Wide = -1;
+pub const Wide_WIDE_BIG: Wide = 1099511627776;
+pub type Sized = u16;
+pub const Sized_SIZED_A: Sized = 1;
+pub const Sized_SIZED_B: Sized = 65535;
+pub type Scoped = i8;
+pub const Scoped_NEG: Scoped = -2;
+pub const Scoped_POS: Scoped = 2;
+pub fn main() {
+    __cpp2rust_init_globals();
+    std::process::exit(main_0());
+}
+fn main_0() -> i32 {
+    let mut flag: Flag = Flag_FLAG_ON;
+    assert!(flag);
+    assert!(!(Flag_FLAG_OFF));
+    flag = Flag_FLAG_OFF;
+    assert!(((flag as i32) == (Flag_FLAG_OFF as i32)));
+    let mut b: bool = flag;
+    assert!(((b as i32) == (false as i32)));
+    let mut s: Small = Small_SMALL_MAX;
+    assert!(((s as i32) == 255));
+    assert!((::std::mem::size_of::<Small>() == 1_usize));
+    s = Small_SMALL_ZERO;
+    assert!((((s as i32) + 1) == 1));
+    let mut sg: Signed = Signed_SIGNED_MIN;
+    assert!(((sg as i32) == -128_i32));
+    assert!(((sg as i32) < (Signed_SIGNED_ONE as i32)));
+    let mut w: Wide = Wide_WIDE_BIG;
+    assert!(((w as i64) == (1_i64 << 40)));
+    assert!((::std::mem::size_of::<Wide>() == 8_usize));
+    assert!(((Wide_WIDE_NEG as i64) < 0_i64));
+    let mut z: Sized = Sized_SIZED_B;
+    assert!(((z as i32) == 65535));
+    assert!((::std::mem::size_of::<Sized>() == 2_usize));
+    assert!((((Sized_SIZED_A as i32) + 1) == 2));
+    let mut sc: Scoped = Scoped_NEG;
+    assert!(((sc as i32) == -2_i32));
+    assert!((((Scoped_POS as i8) as i32) == 2));
+    return 0;
+}
+pub fn __cpp2rust_init_globals() {}

tests/unit/out/unsafe/enum_int_interop.rs

@@ -79,9 +79,6 @@ pub unsafe fn classify_option_5(mut option: i32) -> i32 {
 pub unsafe fn make_color_6(mut n: i32) -> Color {
     return ((n) as Color);
 }
-pub type Flag = bool;
-pub const Flag_FLAG_OFF: Flag = false;
-pub const Flag_FLAG_ON: Flag = true;
 pub fn main() {
     unsafe {
         __cpp2rust_init_globals();
@@ -195,11 +192,6 @@ unsafe fn main_0() -> i32 {
         (((*std::cell::LazyCell::force_mut(&mut *&raw mut entries_3))[(2) as usize].opt as i32)
             == (Option_OPT_C as i32))
     );
-    let mut flag: Flag = Flag_FLAG_ON;
-    assert!(flag);
-    assert!(!(Flag_FLAG_OFF));
-    flag = Flag_FLAG_OFF;
-    assert!(((flag as i32) == (Flag_FLAG_OFF as i32)));
     return 0;
 }
 pub unsafe fn __cpp2rust_init_globals() {

tests/unit/out/unsafe/enum_underlying_type.rs

@@ -0,0 +1,62 @@
+extern crate libc;
+use libc::*;
+extern crate libcc2rs;
+use libcc2rs::*;
+use std::collections::BTreeMap;
+use std::io::{Read, Seek, Write};
+use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
+use std::rc::Rc;
+pub type Flag = bool;
+pub const Flag_FLAG_OFF: Flag = false;
+pub const Flag_FLAG_ON: Flag = true;
+pub type Small = u8;
+pub const Small_SMALL_ZERO: Small = 0;
+pub const Small_SMALL_MAX: Small = 255;
+pub type Signed = i8;
+pub const Signed_SIGNED_MIN: Signed = -128;
+pub const Signed_SIGNED_ONE: Signed = 1;
+pub type Wide = i64;
+pub const Wide_WIDE_NEG: Wide = -1;
+pub const Wide_WIDE_BIG: Wide = 1099511627776;
+pub type Sized = u16;
+pub const Sized_SIZED_A: Sized = 1;
+pub const Sized_SIZED_B: Sized = 65535;
+pub type Scoped = i8;
+pub const Scoped_NEG: Scoped = -2;
+pub const Scoped_POS: Scoped = 2;
+pub fn main() {
+    unsafe {
+        __cpp2rust_init_globals();
+        std::process::exit(main_0() as i32);
+    }
+}
+unsafe fn main_0() -> i32 {
+    let mut flag: Flag = Flag_FLAG_ON;
+    assert!(flag);
+    assert!(!(Flag_FLAG_OFF));
+    flag = Flag_FLAG_OFF;
+    assert!(((flag as i32) == (Flag_FLAG_OFF as i32)));
+    let mut b: bool = flag;
+    assert!(((b as i32) == (false as i32)));
+    let mut s: Small = Small_SMALL_MAX;
+    assert!(((s as i32) == (255)));
+    assert!(((::std::mem::size_of::<Small>()) == (1_usize)));
+    s = Small_SMALL_ZERO;
+    assert!((((s as i32) + (1)) == (1)));
+    let mut sg: Signed = Signed_SIGNED_MIN;
+    assert!(((sg as i32) == (-128_i32)));
+    assert!(((sg as i32) < (Signed_SIGNED_ONE as i32)));
+    let mut w: Wide = Wide_WIDE_BIG;
+    assert!(((w as i64) == ((1_i64) << (40))));
+    assert!(((::std::mem::size_of::<Wide>()) == (8_usize)));
+    assert!(((Wide_WIDE_NEG as i64) < (0_i64)));
+    let mut z: Sized = Sized_SIZED_B;
+    assert!(((z as i32) == (65535)));
+    assert!(((::std::mem::size_of::<Sized>()) == (2_usize)));
+    assert!((((Sized_SIZED_A as i32) + (1)) == (2)));
+    let mut sc: Scoped = Scoped_NEG;
+    assert!(((sc as i32) == (-2_i32)));
+    assert!((((Scoped_POS as i8) as i32) == (2)));
+    return 0;
+}
+pub unsafe fn __cpp2rust_init_globals() {}