src/test/run-pass/mir_raw_fat_ptr.rs

   1 // Copyright 2015 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 // check raw fat pointer ops in mir
  12 // FIXME: please improve this when we get monomorphization support
  13
  14 use std::mem;
  15
  16 #[derive(Debug, PartialEq, Eq)]
  17 struct ComparisonResults {
  18     lt: bool,
  19     le: bool,
  20     gt: bool,
  21     ge: bool,
  22     eq: bool,
  23     ne: bool
  24 }
  25
  26 const LT: ComparisonResults = ComparisonResults {
  27     lt: true,
  28     le: true,
  29     gt: false,
  30     ge: false,
  31     eq: false,
  32     ne: true
  33 };
  34
  35 const EQ: ComparisonResults = ComparisonResults {
  36     lt: false,
  37     le: true,
  38     gt: false,
  39     ge: true,
  40     eq: true,
  41     ne: false
  42 };
  43
  44 const GT: ComparisonResults = ComparisonResults {
  45     lt: false,
  46     le: false,
  47     gt: true,
  48     ge: true,
  49     eq: false,
  50     ne: true
  51 };
  52
  53 fn compare_su8(a: *const S<[u8]>, b: *const S<[u8]>) -> ComparisonResults {
  54     ComparisonResults {
  55         lt: a < b,
  56         le: a <= b,
  57         gt: a > b,
  58         ge: a >= b,
  59         eq: a == b,
  60         ne: a != b
  61     }
  62 }
  63
  64 fn compare_au8(a: *const [u8], b: *const [u8]) -> ComparisonResults {
  65     ComparisonResults {
  66         lt: a < b,
  67         le: a <= b,
  68         gt: a > b,
  69         ge: a >= b,
  70         eq: a == b,
  71         ne: a != b
  72     }
  73 }
  74
  75 fn compare_foo<'a>(a: *const (Foo+'a), b: *const (Foo+'a)) -> ComparisonResults {
  76     ComparisonResults {
  77         lt: a < b,
  78         le: a <= b,
  79         gt: a > b,
  80         ge: a >= b,
  81         eq: a == b,
  82         ne: a != b
  83     }
  84 }
  85
  86 fn simple_eq<'a>(a: *const (Foo+'a), b: *const (Foo+'a)) -> bool {
  87     let result = a == b;
  88     result
  89 }
  90
  91 fn assert_inorder<T: Copy>(a: &[T],
  92                            compare: fn(T, T) -> ComparisonResults) {
  93     for i in 0..a.len() {
  94         for j in 0..a.len() {
  95             let cres = compare(a[i], a[j]);
  96             if i < j {
  97                 assert_eq!(cres, LT);
  98             } else if i == j {
  99                 assert_eq!(cres, EQ);
 100             } else {
 101                 assert_eq!(cres, GT);
 102             }
 103         }
 104     }
 105 }
 106
 107 trait Foo { fn foo(&self) -> usize; }
 108 impl<T> Foo for T {
 109     fn foo(&self) -> usize {
 110         mem::size_of::<T>()
 111     }
 112 }
 113
 114 struct S<T:?Sized>(u32, T);
 115
 116 fn main() {
 117     let array = [0,1,2,3,4];
 118     let array2 = [5,6,7,8,9];
 119
 120     // fat ptr comparison: addr then extra
 121
 122     // check ordering for arrays
 123     let mut ptrs: Vec<*const [u8]> = vec![
 124         &array[0..0], &array[0..1], &array, &array[1..]
 125     ];
 126
 127     let array_addr = &array as *const [u8] as *const u8 as usize;
 128     let array2_addr = &array2 as *const [u8] as *const u8 as usize;
 129     if array2_addr < array_addr {
 130         ptrs.insert(0, &array2);
 131     } else {
 132         ptrs.push(&array2);
 133     }
 134     assert_inorder(&ptrs, compare_au8);
 135
 136     let u8_ = (0u8, 1u8);
 137     let u32_ = (4u32, 5u32);
 138
 139     // check ordering for ptrs
 140     let buf: &mut [*const Foo] = &mut [
 141         &u8_, &u8_.0,
 142         &u32_, &u32_.0,
 143     ];
 144     buf.sort_by(|u,v| {
 145         let u : [*const (); 2] = unsafe { mem::transmute(*u) };
 146         let v : [*const (); 2] = unsafe { mem::transmute(*v) };
 147         u.cmp(&v)
 148     });
 149     assert_inorder(buf, compare_foo);
 150
 151     // check ordering for structs containing arrays
 152     let ss: (S<[u8; 2]>,
 153              S<[u8; 3]>,
 154              S<[u8; 2]>) = (
 155         S(7, [8, 9]),
 156         S(10, [11, 12, 13]),
 157         S(4, [5, 6])
 158     );
 159     assert_inorder(&[
 160         &ss.0 as *const S<[u8]>,
 161         &ss.1 as *const S<[u8]>,
 162         &ss.2 as *const S<[u8]>
 163             ], compare_su8);
 164
 165     assert!(simple_eq(&0u8 as *const _, &0u8 as *const _));
 166     assert!(!simple_eq(&0u8 as *const _, &1u8 as *const _));
 167 }