1 #![no_std]
2 #![deny(unsafe_code)]
3
4 #[macro_use]
5 extern crate static_assertions;
6
7 assert_size_eq!(u8, u8, (u8,), [u8; 1]);
8
9 mod assoc_type {
10 trait Trait {
11 type AssocItem: ?Sized;
12 }
13
14 impl<T: ?Sized> Trait for T {
15 type AssocItem = Self;
16 }
17
18 #[allow(dead_code)]
19 struct Value;
20
21 assert_size_eq!(<Value as Trait>::AssocItem, Value);
22
23 // TODO: Is this possible?
24 // pub fn test<T: Trait>() {
25 // assert_size_eq!(<T as Trait>::AssocItem, T);
26 // }
27 }
28
29 // Placed in separate module so that DropCounter's fields are private
30 mod dc {
31 /// A type that acts like somewhat of a reference counter.
32 pub struct DropCounter<'a> {
33 count: &'a mut i32,
34 }
35
36 impl<'a> DropCounter<'a> {
new(count: &'a mut i32) -> DropCounter<'a>37 pub fn new(count: &'a mut i32) -> DropCounter<'a> {
38 *count += 1;
39 DropCounter { count }
40 }
41
count(&self) -> i3242 pub fn count(&self) -> i32 {
43 *self.count
44 }
45 }
46
47 impl<'a> Drop for DropCounter<'a> {
drop(&mut self)48 fn drop(&mut self) {
49 *self.count -= 1
50 }
51 }
52 }
53 use dc::*;
54
55 /// A type that panics on drop.
56 #[allow(dead_code)]
57 struct PanicDrop<T>(T);
58
59 impl<T> Drop for PanicDrop<T> {
drop(&mut self)60 fn drop(&mut self) {
61 panic!("Dropped!");
62 }
63 }
64
65 #[test]
test_eq_size()66 fn test_eq_size() {
67 assert_size_eq!([u8; 2], u16);
68 assert_size_eq!([u8; 2], u16, (u8, u8));
69 assert_size_eq!([u8; 4], u32, (u16, u8, u8), (u16, u16));
70
71 assert_size_eq_val!([0u8; 2], 0u16);
72 assert_size_eq_val!([0u8; 2], 0u16, (0u8, 0u8));
73 assert_size_eq_val!([0u8; 4], 0u32, (0u16, 0u8, 0u8), (0u16, 0u16));
74
75 #[deny(unused_unsafe)]
76 {
77 assert_size_eq!(u8, u8);
78 assert_size_eq_val!(0u8, 0u8);
79 }
80
81 let x = &mut 0;
82 assert_size_eq_ptr!(x, &0);
83 *x = 20;
84 assert_size_eq_ptr!(x, &0);
85
86 // Should fail to compile (un-comment to test manually):
87 // assert_size_eq!(u8, u16);
88 // assert_size_eq_val!(0u8, 0u16);
89 }
90
91 #[test]
test_eq_size_no_drop()92 fn test_eq_size_no_drop() {
93 assert_size_eq!(u32, PanicDrop<u32>);
94 assert_size_eq!(PanicDrop<u32>, u32);
95 assert_size_eq!(PanicDrop<u32>, PanicDrop<u32>);
96 }
97
98 #[test]
test_eq_size_drop_count()99 fn test_eq_size_drop_count() {
100 let mut count = 0;
101 {
102 let dc = DropCounter::new(&mut count);
103 assert_eq!(dc.count(), 1);
104 assert_size_eq_val!(dc, 0usize);
105 assert_eq!(dc.count(), 1);
106 assert_size_eq_val!(dc, 0usize, dc);
107 assert_eq!(dc.count(), 1);
108 }
109 assert_eq!(count, 0);
110
111 assert_size_eq_val!(DropCounter::new(&mut count), 0usize);
112 assert_eq!(count, 0);
113 }
114