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