src/libcoretest/ptr.rs

   1 // Copyright 2014 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 use core::ptr::*;
  12 use core::mem;
  13
  14 #[test]
  15 fn test() {
  16     unsafe {
  17         struct Pair {
  18             fst: int,
  19             snd: int
  20         };
  21         let mut p = Pair {fst: 10, snd: 20};
  22         let pptr: *mut Pair = &mut p;
  23         let iptr: *mut int = mem::transmute(pptr);
  24         assert_eq!(*iptr, 10);
  25         *iptr = 30;
  26         assert_eq!(*iptr, 30);
  27         assert_eq!(p.fst, 30);
  28
  29         *pptr = Pair {fst: 50, snd: 60};
  30         assert_eq!(*iptr, 50);
  31         assert_eq!(p.fst, 50);
  32         assert_eq!(p.snd, 60);
  33
  34         let v0 = vec![32000u16, 32001u16, 32002u16];
  35         let mut v1 = vec![0u16, 0u16, 0u16];
  36
  37         copy_memory(v1.as_mut_ptr().offset(1),
  38                     v0.as_ptr().offset(1), 1);
  39         assert!((v1[0] == 0u16 &&
  40                  v1[1] == 32001u16 &&
  41                  v1[2] == 0u16));
  42         copy_memory(v1.as_mut_ptr(),
  43                     v0.as_ptr().offset(2), 1);
  44         assert!((v1[0] == 32002u16 &&
  45                  v1[1] == 32001u16 &&
  46                  v1[2] == 0u16));
  47         copy_memory(v1.as_mut_ptr().offset(2),
  48                     v0.as_ptr(), 1u);
  49         assert!((v1[0] == 32002u16 &&
  50                  v1[1] == 32001u16 &&
  51                  v1[2] == 32000u16));
  52     }
  53 }
  54
  55 #[test]
  56 fn test_is_null() {
  57     let p: *const int = null();
  58     assert!(p.is_null());
  59     assert!(!p.is_not_null());
  60
  61     let q = unsafe { p.offset(1) };
  62     assert!(!q.is_null());
  63     assert!(q.is_not_null());
  64
  65     let mp: *mut int = null_mut();
  66     assert!(mp.is_null());
  67     assert!(!mp.is_not_null());
  68
  69     let mq = unsafe { mp.offset(1) };
  70     assert!(!mq.is_null());
  71     assert!(mq.is_not_null());
  72 }
  73
  74 #[test]
  75 fn test_as_ref() {
  76     unsafe {
  77         let p: *const int = null();
  78         assert_eq!(p.as_ref(), None);
  79
  80         let q: *const int = &2;
  81         assert_eq!(q.as_ref().unwrap(), &2);
  82
  83         let p: *mut int = null_mut();
  84         assert_eq!(p.as_ref(), None);
  85
  86         let q: *mut int = &mut 2;
  87         assert_eq!(q.as_ref().unwrap(), &2);
  88
  89         // Lifetime inference
  90         let u = 2i;
  91         {
  92             let p: *const int = &u as *const _;
  93             assert_eq!(p.as_ref().unwrap(), &2);
  94         }
  95     }
  96 }
  97
  98 #[test]
  99 fn test_as_mut() {
 100     unsafe {
 101         let p: *mut int = null_mut();
 102         assert!(p.as_mut() == None);
 103
 104         let q: *mut int = &mut 2;
 105         assert!(q.as_mut().unwrap() == &mut 2);
 106
 107         // Lifetime inference
 108         let mut u = 2i;
 109         {
 110             let p: *mut int = &mut u as *mut _;
 111             assert!(p.as_mut().unwrap() == &mut 2);
 112         }
 113     }
 114 }
 115
 116 #[test]
 117 fn test_ptr_addition() {
 118     unsafe {
 119         let xs = Vec::from_elem(16, 5i);
 120         let mut ptr = xs.as_ptr();
 121         let end = ptr.offset(16);
 122
 123         while ptr < end {
 124             assert_eq!(*ptr, 5);
 125             ptr = ptr.offset(1);
 126         }
 127
 128         let mut xs_mut = xs;
 129         let mut m_ptr = xs_mut.as_mut_ptr();
 130         let m_end = m_ptr.offset(16);
 131
 132         while m_ptr < m_end {
 133             *m_ptr += 5;
 134             m_ptr = m_ptr.offset(1);
 135         }
 136
 137         assert!(xs_mut == Vec::from_elem(16, 10i));
 138     }
 139 }
 140
 141 #[test]
 142 fn test_ptr_subtraction() {
 143     unsafe {
 144         let xs = vec![0,1,2,3,4,5,6,7,8,9];
 145         let mut idx = 9i8;
 146         let ptr = xs.as_ptr();
 147
 148         while idx >= 0i8 {
 149             assert_eq!(*(ptr.offset(idx as int)), idx as int);
 150             idx = idx - 1i8;
 151         }
 152
 153         let mut xs_mut = xs;
 154         let m_start = xs_mut.as_mut_ptr();
 155         let mut m_ptr = m_start.offset(9);
 156
 157         while m_ptr >= m_start {
 158             *m_ptr += *m_ptr;
 159             m_ptr = m_ptr.offset(-1);
 160         }
 161
 162         assert!(xs_mut == vec![0,2,4,6,8,10,12,14,16,18]);
 163     }
 164 }
 165
 166 #[test]
 167 fn test_set_memory() {
 168     let mut xs = [0u8; 20];
 169     let ptr = xs.as_mut_ptr();
 170     unsafe { set_memory(ptr, 5u8, xs.len()); }
 171     assert!(xs == [5u8; 20]);
 172 }