1 // run-pass
2 // check raw fat pointer ops
3 
4 use std::mem;
5 
assert_inorder<T: PartialEq + PartialOrd>(a: &[T])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 
foo(&self) -> usize35 trait Foo { fn foo(&self) -> usize; }
36 impl<T> Foo for T {
foo(&self) -> usize37     fn foo(&self) -> usize {
38         mem::size_of::<T>()
39     }
40 }
41 
42 struct S<T:?Sized>(u32, T);
43 
main()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 }
119