tests/pass/pointers.rs

   1 fn one_line_ref() -> i16 {
   2     *&1
   3 }
   4
   5 fn basic_ref() -> i16 {
   6     let x = &1;
   7     *x
   8 }
   9
  10 fn basic_ref_mut() -> i16 {
  11     let x = &mut 1;
  12     *x += 2;
  13     *x
  14 }
  15
  16 fn basic_ref_mut_var() -> i16 {
  17     let mut a = 1;
  18     {
  19         let x = &mut a;
  20         *x += 2;
  21     }
  22     a
  23 }
  24
  25 fn tuple_ref_mut() -> (i8, i8) {
  26     let mut t = (10, 20);
  27     {
  28         let x = &mut t.1;
  29         *x += 2;
  30     }
  31     t
  32 }
  33
  34 fn match_ref_mut() -> i8 {
  35     let mut t = (20, 22);
  36     {
  37         let opt = Some(&mut t);
  38         match opt {
  39             Some(&mut (ref mut x, ref mut y)) => *x += *y,
  40             None => {}
  41         }
  42     }
  43     t.0
  44 }
  45
  46 fn dangling_pointer() -> *const i32 {
  47     let b = Box::new((42, 42)); // make it bigger than the alignment, so that there is some "room" after this pointer
  48     &b.0 as *const i32
  49 }
  50
  51 fn main() {
  52     assert_eq!(one_line_ref(), 1);
  53     assert_eq!(basic_ref(), 1);
  54     assert_eq!(basic_ref_mut(), 3);
  55     assert_eq!(basic_ref_mut_var(), 3);
  56     assert_eq!(tuple_ref_mut(), (10, 22));
  57     assert_eq!(match_ref_mut(), 42);
  58
  59     // Compare even dangling pointers with NULL, and with others in the same allocation, including
  60     // out-of-bounds.
  61     assert!(dangling_pointer() != std::ptr::null());
  62     assert!(match dangling_pointer() as usize {
  63         0 => false,
  64         _ => true,
  65     });
  66     let dangling = dangling_pointer();
  67     assert!(dangling == dangling);
  68     assert!(dangling.wrapping_add(1) != dangling);
  69     assert!(dangling.wrapping_sub(1) != dangling);
  70
  71     // Compare pointer with BIG integers
  72     let dangling = dangling as usize;
  73     assert!(dangling != usize::MAX);
  74     assert!(dangling != usize::MAX - 1);
  75     assert!(dangling != usize::MAX - 2);
  76     assert!(dangling != usize::MAX - 3); // this is even 4-aligned, but it still cannot be equal because of the extra "room" after this pointer
  77     assert_eq!((usize::MAX - 3) % 4, 0); // just to be sure we got this right
  78
  79     // Compare pointer with unaligned integers
  80     assert!(dangling != 1usize);
  81     assert!(dangling != 2usize);
  82     assert!(dangling != 3usize);
  83     // 4 is a possible choice! So we cannot compare with that.
  84     assert!(dangling != 5usize);
  85     assert!(dangling != 6usize);
  86     assert!(dangling != 7usize);
  87
  88     // Using inequality to do the comparison.
  89     assert!(dangling > 0);
  90     assert!(dangling > 1);
  91     assert!(dangling > 2);
  92     assert!(dangling > 3);
  93     assert!(dangling >= 4);
  94 }