encoding_index_tests/
index_tests.rs

Help
1// This is a part of rust-encoding.
2// Copyright (c) 2013-2015, Kang Seonghoon.
3// See README.md and LICENSE.txt for details.
4
5//! Macros and utilities for testing indices.
6
7/// Makes a common test suite for single-byte indices.
8#[macro_export]
9macro_rules! single_byte_tests {
10    (
11        mod = $parentmod:ident // XXX Rust issue #20701 prevents the use of `super`
12    ) => (
13        mod tests {
14            extern crate test;
15            use $parentmod::{forward, backward};
16
17            #[test]
18            fn test_correct_table() {
19                for i in 0x80..0x100 {
20                    let i = i as u8;
21                    let j = forward(i);
22                    if j != 0xffff { assert_eq!(backward(j as u32), i); }
23                }
24            }
25
26            #[bench]
27            fn bench_forward_sequential_128(bencher: &mut test::Bencher) {
28                bencher.iter(|| {
29                    for i in 0x80..0x100 {
30                        test::black_box(forward(i as u8));
31                    }
32                })
33            }
34
35            #[bench]
36            fn bench_backward_sequential_128(bencher: &mut test::Bencher) {
37                let mut start: u32 = 0;
38                bencher.iter(|| {
39                    for i in start..(start + 0x80) {
40                        test::black_box(backward(i));
41                    }
42                    start += 0x80;
43                })
44            }
45        }
46    );
47}
48
49/// Makes a common test suite for multi-byte indices.
50#[macro_export]
51macro_rules! multi_byte_tests {
52    (make shared tests and benches with dups = $dups:expr) => ( // internal macro
53        #[test]
54        fn test_correct_table() {
55            static DUPS: &'static [u16] = &$dups;
56            for i in 0..0x10000 {
57                let i = i as u16;
58                if DUPS.contains(&i) { continue; }
59                let j = forward(i);
60                if j != 0xffff { assert_eq!(backward(j), i); }
61            }
62        }
63
64        #[bench]
65        fn bench_forward_sequential_128(bencher: &mut test::Bencher) {
66            let mut start: u32 = 0;
67            bencher.iter(|| {
68                for i in start..(start + 0x80) {
69                    test::black_box(forward(i as u16));
70                }
71                start += 0x80;
72            })
73        }
74
75        #[bench]
76        fn bench_backward_sequential_128(bencher: &mut test::Bencher) {
77            let mut start: u32 = 0;
78            bencher.iter(|| {
79                for i in start..(start + 0x80) {
80                    test::black_box(backward(i));
81                }
82                start += 0x80;
83                if start >= 0x110000 { start = 0; }
84            })
85        }
86    );
87
88    (
89        mod = $parentmod:ident, // XXX Rust issue #20701
90        dups = $dups:expr
91    ) => (
92        mod tests {
93            extern crate test;
94            use $parentmod::{forward, backward};
95
96            multi_byte_tests!(make shared tests and benches with dups = $dups);
97        }
98    );
99
100    (
101        mod = $parentmod:ident, // XXX Rust issue #20701
102        remap = [$remap_min:expr, $remap_max:expr],
103        dups = $dups:expr
104    ) => (
105        mod tests {
106            extern crate test;
107            use $parentmod::{forward, backward, backward_remapped};
108
109            multi_byte_tests!(make shared tests and benches with dups = $dups);
110
111            static REMAP_MIN: u16 = $remap_min;
112            static REMAP_MAX: u16 = $remap_max;
113
114            #[test]
115            fn test_correct_remapping() {
116                for i in REMAP_MIN..(REMAP_MAX+1) {
117                    let j = forward(i);
118                    if j != 0xffff {
119                        let ii = backward_remapped(j);
120                        assert!(ii != i && ii != 0xffff);
121                        let jj = forward(ii);
122                        assert_eq!(j, jj);
123                    }
124                }
125            }
126
127            #[bench]
128            fn bench_backward_remapped_sequential_128(bencher: &mut test::Bencher) {
129                let mut start: u32 = 0;
130                bencher.iter(|| {
131                    for i in start..(start + 0x80) {
132                        test::black_box(backward_remapped(i));
133                    }
134                    start += 0x80;
135                    if start >= 0x110000 { start = 0; }
136                })
137            }
138        }
139    );
140}
141
142/// Makes a common test suite for multi-byte range indices.
143#[macro_export]
144macro_rules! multi_byte_range_tests {
145    (
146        mod = $parentmod:ident,
147        key = [$minkey:expr, $maxkey:expr], key < $keyubound:expr,
148        value = [$minvalue:expr, $maxvalue:expr], value < $valueubound:expr
149    ) => (
150        mod tests {
151            extern crate test;
152            use $parentmod::{forward, backward};
153
154            static MIN_KEY: u32 = $minkey;
155            static MAX_KEY: u32 = $maxkey;
156            static KEY_UBOUND: u32 = $keyubound;
157            static MIN_VALUE: u32 = $minvalue;
158            static MAX_VALUE: u32 = $maxvalue;
159            static VALUE_UBOUND: u32 = $valueubound;
160
161            #[test]
162            #[allow(unused_comparisons)]
163            fn test_no_failure() {
164                for i in (if MIN_KEY>0 {MIN_KEY-1} else {0})..(MAX_KEY+2) {
165                    forward(i);
166                }
167                for j in (if MIN_VALUE>0 {MIN_VALUE-1} else {0})..(MAX_VALUE+2) {
168                    backward(j);
169                }
170            }
171
172            #[test]
173            fn test_correct_table() {
174                for i in MIN_KEY..(MAX_KEY+2) {
175                    let j = forward(i);
176                    if j == 0xffffffff { continue; }
177                    let i_ = backward(j);
178                    if i_ == 0xffffffff { continue; }
179                    assert!(i_ == i,
180                            "backward(forward({})) = backward({}) = {} != {}", i, j, i_, i);
181                }
182            }
183
184            #[bench]
185            fn bench_forward_sequential_128(bencher: &mut test::Bencher) {
186                let mut start: u32 = 0;
187                bencher.iter(|| {
188                    for i in start..(start + 0x80) {
189                        test::black_box(forward(i));
190                    }
191                    start += 0x80;
192                    if start >= KEY_UBOUND { start = 0; }
193                })
194            }
195
196            #[bench]
197            fn bench_backward_sequential_128(bencher: &mut test::Bencher) {
198                let mut start: u32 = 0;
199                bencher.iter(|| {
200                    for i in start..(start + 0x80) {
201                        test::black_box(backward(i));
202                    }
203                    start += 0x80;
204                    if start >= VALUE_UBOUND { start = 0; }
205                })
206            }
207        }
208    );
209}
210
encoding_index_tests/index_tests.rs

encoding_index_tests/
index_tests.rs
