2
2
3
3
extern crate test;
4
4
5
- #[ cfg( feature = "v3-preview" ) ]
6
- use std:: convert:: TryFrom as _;
7
-
8
- #[ cfg( not( feature = "v3-preview" ) ) ]
9
- use data_encoding as constants;
10
- #[ cfg( feature = "v3-preview" ) ]
11
- use data_encoding:: v3_preview as constants;
12
- #[ cfg( feature = "v3-preview" ) ]
13
- use data_encoding:: v3_preview:: { Bit1 , Bit2 , Bit3 , Bit6 , Encoding , False , True } ;
14
5
use data_encoding:: Specification ;
15
6
use test:: Bencher ;
16
7
@@ -21,8 +12,6 @@ fn base02_encode_base(b: &mut Bencher) {
21
12
let mut spec = Specification :: new ( ) ;
22
13
spec. symbols . push_str ( "01" ) ;
23
14
let base = spec. encoding ( ) . unwrap ( ) ;
24
- #[ cfg( feature = "v3-preview" ) ]
25
- let base = Encoding :: < Bit1 , True , False , False , False > :: try_from ( base) . unwrap ( ) ;
26
15
b. iter ( || base. encode_mut ( input, output) ) ;
27
16
}
28
17
@@ -33,8 +22,6 @@ fn base02_decode_base(b: &mut Bencher) {
33
22
let mut spec = Specification :: new ( ) ;
34
23
spec. symbols . push_str ( "01" ) ;
35
24
let base = spec. encoding ( ) . unwrap ( ) ;
36
- #[ cfg( feature = "v3-preview" ) ]
37
- let base = Encoding :: < Bit1 , True , False , False , False > :: try_from ( base) . unwrap ( ) ;
38
25
b. iter ( || base. decode_mut ( input, output) ) ;
39
26
}
40
27
@@ -45,8 +32,6 @@ fn base04_encode_base(b: &mut Bencher) {
45
32
let mut spec = Specification :: new ( ) ;
46
33
spec. symbols . push_str ( "0123" ) ;
47
34
let base = spec. encoding ( ) . unwrap ( ) ;
48
- #[ cfg( feature = "v3-preview" ) ]
49
- let base = Encoding :: < Bit2 , True , False , False , False > :: try_from ( base) . unwrap ( ) ;
50
35
b. iter ( || base. encode_mut ( input, output) ) ;
51
36
}
52
37
@@ -57,8 +42,6 @@ fn base04_decode_base(b: &mut Bencher) {
57
42
let mut spec = Specification :: new ( ) ;
58
43
spec. symbols . push_str ( "0123" ) ;
59
44
let base = spec. encoding ( ) . unwrap ( ) ;
60
- #[ cfg( feature = "v3-preview" ) ]
61
- let base = Encoding :: < Bit2 , True , False , False , False > :: try_from ( base) . unwrap ( ) ;
62
45
b. iter ( || base. decode_mut ( input, output) ) ;
63
46
}
64
47
@@ -69,8 +52,6 @@ fn base08_encode_base(b: &mut Bencher) {
69
52
let mut spec = Specification :: new ( ) ;
70
53
spec. symbols . push_str ( "01234567" ) ;
71
54
let base = spec. encoding ( ) . unwrap ( ) ;
72
- #[ cfg( feature = "v3-preview" ) ]
73
- let base = Encoding :: < Bit3 , True , False , False , False > :: try_from ( base) . unwrap ( ) ;
74
55
b. iter ( || base. encode_mut ( input, output) ) ;
75
56
}
76
57
@@ -81,58 +62,56 @@ fn base08_decode_base(b: &mut Bencher) {
81
62
let mut spec = Specification :: new ( ) ;
82
63
spec. symbols . push_str ( "01234567" ) ;
83
64
let base = spec. encoding ( ) . unwrap ( ) ;
84
- #[ cfg( feature = "v3-preview" ) ]
85
- let base = Encoding :: < Bit3 , True , False , False , False > :: try_from ( base) . unwrap ( ) ;
86
65
b. iter ( || base. decode_mut ( input, output) ) ;
87
66
}
88
67
89
68
#[ bench]
90
69
fn base16_encode_base ( b : & mut Bencher ) {
91
70
let input = & [ 0u8 ; 4096 ] ;
92
71
let output = & mut [ 0u8 ; 8192 ] ;
93
- b. iter ( || constants :: HEXLOWER . encode_mut ( input, output) ) ;
72
+ b. iter ( || data_encoding :: HEXLOWER . encode_mut ( input, output) ) ;
94
73
}
95
74
96
75
#[ bench]
97
76
fn base16_decode_base ( b : & mut Bencher ) {
98
77
let input = & [ b'0' ; 4096 ] ;
99
78
let output = & mut [ 0u8 ; 2048 ] ;
100
- b. iter ( || constants :: HEXLOWER . decode_mut ( input, output) ) ;
79
+ b. iter ( || data_encoding :: HEXLOWER . decode_mut ( input, output) ) ;
101
80
}
102
81
103
82
#[ bench]
104
83
fn base32_encode_base ( b : & mut Bencher ) {
105
84
let input = & [ 0u8 ; 4096 ] ;
106
85
let output = & mut [ 0u8 ; 6560 ] ;
107
- b. iter ( || constants :: BASE32 . encode_mut ( input, output) ) ;
86
+ b. iter ( || data_encoding :: BASE32 . encode_mut ( input, output) ) ;
108
87
}
109
88
110
89
#[ bench]
111
90
fn base32_decode_base ( b : & mut Bencher ) {
112
91
let input = & [ b'A' ; 4096 ] ;
113
92
let output = & mut [ 0u8 ; 2560 ] ;
114
- b. iter ( || constants :: BASE32 . decode_mut ( input, output) ) ;
93
+ b. iter ( || data_encoding :: BASE32 . decode_mut ( input, output) ) ;
115
94
}
116
95
117
96
#[ bench]
118
97
fn base64_encode_base ( b : & mut Bencher ) {
119
98
let input = & [ 0u8 ; 4096 ] ;
120
99
let output = & mut [ 0u8 ; 5462 ] ;
121
- b. iter ( || constants :: BASE64_NOPAD . encode_mut ( input, output) ) ;
100
+ b. iter ( || data_encoding :: BASE64_NOPAD . encode_mut ( input, output) ) ;
122
101
}
123
102
124
103
#[ bench]
125
104
fn base64_decode_base ( b : & mut Bencher ) {
126
105
let input = & [ b'A' ; 4096 ] ;
127
106
let output = & mut [ 0u8 ; 3072 ] ;
128
- b. iter ( || constants :: BASE64_NOPAD . decode_mut ( input, output) ) ;
107
+ b. iter ( || data_encoding :: BASE64_NOPAD . decode_mut ( input, output) ) ;
129
108
}
130
109
131
110
#[ bench]
132
111
fn base64_encode_pad ( b : & mut Bencher ) {
133
112
let input = & mut [ b'A' ; 4096 ] ;
134
113
let output = & mut [ 0u8 ; 5464 ] ;
135
- b. iter ( || constants :: BASE64 . encode_mut ( input, output) ) ;
114
+ b. iter ( || data_encoding :: BASE64 . encode_mut ( input, output) ) ;
136
115
}
137
116
138
117
#[ bench]
@@ -146,7 +125,7 @@ fn base64_decode_pad(b: &mut Bencher) {
146
125
}
147
126
}
148
127
let output = & mut [ 0u8 ; 3072 ] ;
149
- b. iter ( || constants :: BASE64 . decode_mut ( input, output) . unwrap ( ) ) ;
128
+ b. iter ( || data_encoding :: BASE64 . decode_mut ( input, output) . unwrap ( ) ) ;
150
129
}
151
130
152
131
#[ bench]
@@ -157,8 +136,6 @@ fn base64_encode_wrap(b: &mut Bencher) {
157
136
spec. wrap . width = 76 ;
158
137
spec. wrap . separator . push_str ( "\r \n " ) ;
159
138
let base64 = spec. encoding ( ) . unwrap ( ) ;
160
- #[ cfg( feature = "v3-preview" ) ]
161
- let base64 = Encoding :: < Bit6 , True , True , True , True > :: try_from ( base64) . unwrap ( ) ;
162
139
b. iter ( || base64. encode_mut ( input, output) ) ;
163
140
}
164
141
@@ -174,21 +151,19 @@ fn base64_decode_wrap(b: &mut Bencher) {
174
151
spec. wrap . width = 76 ;
175
152
spec. wrap . separator . push_str ( "\r \n " ) ;
176
153
let base64 = spec. encoding ( ) . unwrap ( ) ;
177
- #[ cfg( feature = "v3-preview" ) ]
178
- let base64 = Encoding :: < Bit6 , True , True , True , True > :: try_from ( base64) . unwrap ( ) ;
179
154
b. iter ( || base64. decode_mut ( input, output) . unwrap ( ) ) ;
180
155
}
181
156
182
157
#[ bench]
183
158
fn dnscurve_decode_base ( b : & mut Bencher ) {
184
159
let input = & [ b'0' ; 4096 ] ;
185
160
let output = & mut [ 0u8 ; 2560 ] ;
186
- b. iter ( || constants :: BASE32_DNSCURVE . decode_mut ( input, output) ) ;
161
+ b. iter ( || data_encoding :: BASE32_DNSCURVE . decode_mut ( input, output) ) ;
187
162
}
188
163
189
164
#[ bench]
190
165
fn dnscurve_encode_base ( b : & mut Bencher ) {
191
166
let input = & [ 0u8 ; 4096 ] ;
192
167
let output = & mut [ 0u8 ; 6554 ] ;
193
- b. iter ( || constants :: BASE32_DNSCURVE . encode_mut ( input, output) ) ;
168
+ b. iter ( || data_encoding :: BASE32_DNSCURVE . encode_mut ( input, output) ) ;
194
169
}
0 commit comments