src/test/ui/stdlib-unit-tests/raw-fat-ptr.rs

   1 // run-pass
   2 // check raw fat pointer ops
   3
   4 use std::mem;
   5
   6 fn assert_inorder<T: PartialEq + PartialOrd>(a: &[T]) {
   7     for i in 0..a.len() {
   8         for j in 0..a.len() {
   9             if i < j {
  10                 assert!(a[i] < a[j]);
  11                 assert!(a[i] <= a[j]);
  12                 assert!(!(a[i] == a[j]));
  13                 assert!(a[i] != a[j]);
  14                 assert!(!(a[i] >= a[j]));
  15                 assert!(!(a[i] > a[j]));
  16             } else if i == j {
  17                 assert!(!(a[i] < a[j]));
  18                 assert!(a[i] <= a[j]);
  19                 assert!(a[i] == a[j]);
  20                 assert!(!(a[i] != a[j]));
  21                 assert!(a[i] >= a[j]);
  22                 assert!(!(a[i] > a[j]));
  23             } else {
  24                 assert!(!(a[i] < a[j]));
  25                 assert!(!(a[i] <= a[j]));
  26                 assert!(!(a[i] == a[j]));
  27                 assert!(a[i] != a[j]);
  28                 assert!(a[i] >= a[j]);
  29                 assert!(a[i] > a[j]);
  30             }
  31         }
  32     }
  33 }
  34
  35 trait Foo { fn foo(&self) -> usize; }
  36 impl<T> Foo for T {
  37     fn foo(&self) -> usize {
  38         mem::size_of::<T>()
  39     }
  40 }
  41
  42 struct S<T:?Sized>(u32, T);
  43
  44 fn main() {
  45     let mut array = [0,1,2,3,4];
  46     let mut array2 = [5,6,7,8,9];
  47
  48     // fat ptr comparison: addr then extra
  49
  50     // check ordering for arrays
  51     let mut ptrs: Vec<*const [u8]> = vec![
  52         &array[0..0], &array[0..1], &array, &array[1..]
  53     ];
  54
  55     let array_addr = &array as *const [u8] as *const u8 as usize;
  56     let array2_addr = &array2 as *const [u8] as *const u8 as usize;
  57     if array2_addr < array_addr {
  58         ptrs.insert(0, &array2);
  59     } else {
  60         ptrs.push(&array2);
  61     }
  62     assert_inorder(&ptrs);
  63
  64     // check ordering for mut arrays
  65     let mut ptrs: Vec<*mut [u8]> = vec![
  66         &mut array[0..0], &mut array[0..1], &mut array, &mut array[1..]
  67     ];
  68
  69     let array_addr = &mut array as *mut [u8] as *mut u8 as usize;
  70     let array2_addr = &mut array2 as *mut [u8] as *mut u8 as usize;
  71     if array2_addr < array_addr {
  72         ptrs.insert(0, &mut array2);
  73     } else {
  74         ptrs.push(&mut array2);
  75     }
  76     assert_inorder(&ptrs);
  77
  78     let mut u8_ = (0u8, 1u8);
  79     let mut u32_ = (4u32, 5u32);
  80
  81     // check ordering for ptrs
  82     let buf: &mut [*const dyn Foo] = &mut [
  83         &u8_, &u8_.0,
  84         &u32_, &u32_.0,
  85     ];
  86     buf.sort_by(|u,v| {
  87         let u : [*const (); 2] = unsafe { mem::transmute(*u) };
  88         let v : [*const (); 2] = unsafe { mem::transmute(*v) };
  89         u.cmp(&v)
  90     });
  91     assert_inorder(buf);
  92
  93     // check ordering for mut ptrs
  94     let buf: &mut [*mut dyn Foo] = &mut [
  95         &mut u8_, &mut u8_.0,
  96         &mut u32_, &mut u32_.0,
  97     ];
  98     buf.sort_by(|u,v| {
  99         let u : [*const (); 2] = unsafe { mem::transmute(*u) };
 100         let v : [*const (); 2] = unsafe { mem::transmute(*v) };
 101         u.cmp(&v)
 102     });
 103     assert_inorder(buf);
 104
 105     // check ordering for structs containing arrays
 106     let ss: (S<[u8; 2]>,
 107              S<[u8; 3]>,
 108              S<[u8; 2]>) = (
 109         S(7, [8, 9]),
 110         S(10, [11, 12, 13]),
 111         S(4, [5, 6])
 112     );
 113     assert_inorder(&[
 114         &ss.0 as *const S<[u8]>,
 115         &ss.1 as *const S<[u8]>,
 116         &ss.2 as *const S<[u8]>
 117     ]);
 118 }