endian_trait 0.4.0

A trait for Endianness conversions that can be implemented on most types
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

/*! Test deriving Endian on an enum

This won't compile, because Endian on an enum doesn't make any sense. Cast it to
an integer repr outside the Endian operations.

If this code is uncommented, it should emit an error message about enums not
being supported. Proc-macro panics are compile-time, not runtime, so this test
cannot be run directly.
!*/

#[macro_use]
extern crate endian_trait;

use endian_trait::Endian;
use std::mem::{
	size_of,
	transmute,
};

#[test]
fn derive_8() {
	type Raw = [u8; 1];
	#[repr(u8)]
	#[derive(Endian)]
	enum Foo {
		A = 16,
	}
	assert_eq!(size_of::<Foo>(), 1);

	let bytes_be: Raw = [16];
	let bytes_le: Raw = [16];

	let foo_be: Raw = unsafe { transmute(Foo::A.to_be()) };
	let foo_le: Raw = unsafe { transmute(Foo::A.to_le()) };

	assert_eq!(&bytes_be[..], &foo_be[..]);
	assert_eq!(&bytes_le[..], &foo_le[..]);
}

#[test]
fn derive_16() {
	type Raw = [u8; 2];
	#[repr(i16)]
	#[derive(Endian)]
	enum Foo {
		A = 16,
	}
	assert_eq!(size_of::<Foo>(), 2);

	let bytes_be: Raw = [0, 16];
	let bytes_le: Raw = [16, 0];

	let foo_be: Raw = unsafe { transmute(Foo::A.to_be()) };
	let foo_le: Raw = unsafe { transmute(Foo::A.to_le()) };

	assert_eq!(&bytes_be[..], &foo_be[..]);
	assert_eq!(&bytes_le[..], &foo_le[..]);
}

#[test]
fn derive_32() {
	type Raw = [u8; 4];
	#[repr(u32)]
	#[derive(Endian)]
	enum Foo {
		A = 16,
	}
	assert_eq!(size_of::<Foo>(), 4);

	let bytes_be: Raw = [0, 0, 0, 16];
	let bytes_le: Raw = [16, 0, 0, 0];

	let foo_be: Raw = unsafe { transmute(Foo::A.to_be()) };
	let foo_le: Raw = unsafe { transmute(Foo::A.to_le()) };

	assert_eq!(&bytes_be[..], &foo_be[..]);
	assert_eq!(&bytes_le[..], &foo_le[..]);
}

#[test]
fn derive_64() {
	type Raw = [u8; 8];
	#[repr(i64)]
	#[derive(Endian)]
	enum Foo {
		A = 16,
	}
	assert_eq!(size_of::<Foo>(), 8);

	let bytes_be: Raw = [0, 0, 0, 0, 0, 0, 0, 16];
	let bytes_le: Raw = [16, 0, 0, 0, 0, 0, 0, 0];

	let foo_be: Raw = unsafe { transmute(Foo::A.to_be()) };
	let foo_le: Raw = unsafe { transmute(Foo::A.to_le()) };

	assert_eq!(&bytes_be[..], &foo_be[..]);
	assert_eq!(&bytes_le[..], &foo_le[..]);
}

//  Uncomment these to fail the build.
//  If either of these compiles, it is a bug.
/*
#[test]
#[compile_fail]
#[should_panic]
fn derive_c() {
	#[repr(C)]
	#[derive(Endian)]
	enum Foo {
		A, B, C,
	}
}

//  This fails because the body adds size to the discriminant, and the transmute
//  call powering the Endian transform will not succeed.
#[test]
// #[compile_fail]
#[should_panic]
fn derive_bodied() {
	#[repr(i16)]
	#[derive(Endian)]
	enum Foo {
		A(i8),
	}
}
*/