1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17 package org.apache.asn1.ber.digester.rules ;
18
19
20 import junit.framework.TestCase ;
21
22 import org.apache.asn1.ber.TypeClass ;
23 import org.apache.asn1.ber.digester.BERDigester ;
24 import org.apache.asn1.ber.primitives.UniversalTag ;
25 import org.apache.asn1.ber.primitives.UniversalTag;
26 import org.apache.asn1.ber.digester.rules.PrimitiveIntDecodeRule;
27 import org.apache.asn1.ber.digester.BERDigester;
28 import org.apache.asn1.ber.TypeClass;
29
30 import java.nio.ByteBuffer;
31 import java.math.BigInteger;
32
33
34 /***
35 * Tests the PrimitiveIntDecodeRule.
36 *
37 * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a>
38 * @version $Rev: 157644 $
39 */
40 public class PrimitiveIntDecodeRuleTest extends TestCase
41 {
42 PrimitiveIntDecodeRule rule ;
43 BERDigester digester ;
44
45
46 protected void setUp() throws Exception
47 {
48 super.setUp() ;
49 rule = new PrimitiveIntDecodeRule() ;
50 digester = new BERDigester() ;
51 rule.setDigester( digester ) ;
52 int[] pattern = { 0x10000000, 0x02000000 } ;
53 digester.addRule( pattern, rule ) ;
54 }
55
56
57 protected void tearDown() throws Exception
58 {
59 super.tearDown() ;
60 rule.setDigester( null ) ;
61 rule = null ;
62 digester = null ;
63 }
64
65
66 public void testTag()
67 {
68 rule.tag( UniversalTag.INTEGER.getTagId(), true,
69 TypeClass.UNIVERSAL ) ;
70
71 try
72 {
73 rule.tag( 0, false, null ) ;
74 fail( "should never get here" ) ;
75 }
76 catch ( IllegalArgumentException e )
77 {
78 }
79 }
80
81
82 public void testLength()
83 {
84 rule.tag( UniversalTag.INTEGER.getTagId(), true,
85 TypeClass.UNIVERSAL ) ;
86
87 rule.length( 0 ) ;
88 rule.length( 1 ) ;
89 rule.length( 2 ) ;
90 rule.length( 3 ) ;
91 rule.length( 4 ) ;
92
93 try
94 {
95 rule.length( -1 ) ;
96 fail( "should never get here due to exception" ) ;
97 }
98 catch ( IllegalArgumentException e )
99 {
100 }
101
102 try
103 {
104 rule.length( 5 ) ;
105 fail( "should never get here due to exception" ) ;
106 }
107 catch ( IllegalArgumentException e )
108 {
109 }
110 }
111
112
113 public void testValue0()
114 {
115 rule.tag( UniversalTag.INTEGER.getTagId(), true,
116 TypeClass.UNIVERSAL ) ;
117 rule.length( 0 ) ;
118 rule.value( null ) ;
119 }
120
121
122 public void testValue1()
123 {
124 rule.tag( UniversalTag.INTEGER.getTagId(), true,
125 TypeClass.UNIVERSAL ) ;
126 rule.length( 1 ) ;
127 byte[] bites = { 0x45 } ;
128 ByteBuffer buf = ByteBuffer.wrap( bites ) ;
129 rule.value( buf ) ;
130 assertTrue( rule.equals( (byte) 0x45, 0 ) ) ;
131 assertTrue( rule.equals( (byte) 0x00, 1 ) ) ;
132 assertTrue( rule.equals( (byte) 0x00, 2 ) ) ;
133 assertTrue( rule.equals( (byte) 0x00, 3 ) ) ;
134 buf.clear() ;
135 rule.value( buf ) ;
136 assertTrue( rule.equals( (byte) 0x45, 0 ) ) ;
137 assertTrue( rule.equals( (byte) 0x00, 1 ) ) ;
138 assertTrue( rule.equals( (byte) 0x00, 2 ) ) ;
139 assertTrue( rule.equals( (byte) 0x00, 3 ) ) ;
140 }
141
142
143 public void testValue2()
144 {
145 rule.tag( UniversalTag.INTEGER.getTagId(), true,
146 TypeClass.UNIVERSAL ) ;
147 rule.length( 2 ) ;
148 byte[] bites = { 0x45, 0x23 } ;
149 ByteBuffer buf = ByteBuffer.wrap( bites ) ;
150 rule.value( buf ) ;
151 assertTrue( rule.equals( (byte) 0x45, 0 ) ) ;
152 assertTrue( rule.equals( (byte) 0x23, 1 ) ) ;
153 assertTrue( rule.equals( (byte) 0x00, 2 ) ) ;
154 assertTrue( rule.equals( (byte) 0x00, 3 ) ) ;
155 buf.clear() ;
156 rule.value( buf ) ;
157 assertTrue( rule.equals( (byte) 0x45, 0 ) ) ;
158 assertTrue( rule.equals( (byte) 0x23, 1 ) ) ;
159 assertTrue( rule.equals( (byte) 0x00, 2 ) ) ;
160 assertTrue( rule.equals( (byte) 0x00, 3 ) ) ;
161 }
162
163
164 public void testValue2Fragmented()
165 {
166 rule.tag( UniversalTag.INTEGER.getTagId(), true,
167 TypeClass.UNIVERSAL ) ;
168 rule.length( 2 ) ;
169 byte[] bites0 = { 0x45 } ;
170 byte[] bites1 = { 0x23 } ;
171 ByteBuffer buf = ByteBuffer.wrap( bites0 ) ;
172 rule.value( buf ) ;
173 assertTrue( rule.equals( (byte) 0x45, 0 ) ) ;
174 assertTrue( rule.equals( (byte) 0x00, 1 ) ) ;
175 assertTrue( rule.equals( (byte) 0x00, 2 ) ) ;
176 assertTrue( rule.equals( (byte) 0x00, 3 ) ) ;
177 buf = ByteBuffer.wrap( bites1 ) ;
178 rule.value( buf ) ;
179 assertTrue( rule.equals( (byte) 0x45, 0 ) ) ;
180 assertTrue( rule.equals( (byte) 0x23, 1 ) ) ;
181 assertTrue( rule.equals( (byte) 0x00, 2 ) ) ;
182 assertTrue( rule.equals( (byte) 0x00, 3 ) ) ;
183 buf.clear() ;
184 rule.value( buf ) ;
185 assertTrue( rule.equals( (byte) 0x45, 0 ) ) ;
186 assertTrue( rule.equals( (byte) 0x23, 1 ) ) ;
187 assertTrue( rule.equals( (byte) 0x00, 2 ) ) ;
188 assertTrue( rule.equals( (byte) 0x00, 3 ) ) ;
189 }
190
191
192 public void testValue3()
193 {
194 rule.tag( UniversalTag.INTEGER.getTagId(), true,
195 TypeClass.UNIVERSAL ) ;
196 rule.length( 3 ) ;
197 byte[] bites = { 0x45, 0x23, 0x12 } ;
198 ByteBuffer buf = ByteBuffer.wrap( bites ) ;
199 rule.value( buf ) ;
200 assertTrue( rule.equals( (byte) 0x45, 0 ) ) ;
201 assertTrue( rule.equals( (byte) 0x23, 1 ) ) ;
202 assertTrue( rule.equals( (byte) 0x12, 2 ) ) ;
203 assertTrue( rule.equals( (byte) 0x00, 3 ) ) ;
204 buf.clear() ;
205 rule.value( buf ) ;
206 assertTrue( rule.equals( (byte) 0x45, 0 ) ) ;
207 assertTrue( rule.equals( (byte) 0x23, 1 ) ) ;
208 assertTrue( rule.equals( (byte) 0x12, 2 ) ) ;
209 assertTrue( rule.equals( (byte) 0x00, 3 ) ) ;
210 }
211
212
213 public void testValue4()
214 {
215 rule.tag( UniversalTag.INTEGER.getTagId(), true,
216 TypeClass.UNIVERSAL ) ;
217 rule.length( 4 ) ;
218 byte[] bites = { 0x45, 0x23, 0x12, 0x01 } ;
219 ByteBuffer buf = ByteBuffer.wrap( bites ) ;
220 rule.value( buf ) ;
221 assertTrue( rule.equals( (byte) 0x45, 0 ) ) ;
222 assertTrue( rule.equals( (byte) 0x23, 1 ) ) ;
223 assertTrue( rule.equals( (byte) 0x12, 2 ) ) ;
224 assertTrue( rule.equals( (byte) 0x01, 3 ) ) ;
225 buf.clear() ;
226 rule.value( buf ) ;
227 assertTrue( rule.equals( (byte) 0x45, 0 ) ) ;
228 assertTrue( rule.equals( (byte) 0x23, 1 ) ) ;
229 assertTrue( rule.equals( (byte) 0x12, 2 ) ) ;
230 assertTrue( rule.equals( (byte) 0x01, 3 ) ) ;
231 }
232
233
234 public void testValue5()
235 {
236 rule.tag( UniversalTag.INTEGER.getTagId(), true,
237 TypeClass.UNIVERSAL ) ;
238 rule.length( 4 ) ;
239 byte[] bites = { 0x45, 0x23, 0x12, 0x01, 0x07 } ;
240 ByteBuffer buf = ByteBuffer.wrap( bites ) ;
241 rule.value( buf ) ;
242 assertTrue( rule.equals( (byte) 0x45, 0 ) ) ;
243 assertTrue( rule.equals( (byte) 0x23, 1 ) ) ;
244 assertTrue( rule.equals( (byte) 0x12, 2 ) ) ;
245 assertTrue( rule.equals( (byte) 0x01, 3 ) ) ;
246 buf.clear() ;
247 rule.value( buf ) ;
248 assertTrue( rule.equals( (byte) 0x45, 0 ) ) ;
249 assertTrue( rule.equals( (byte) 0x23, 1 ) ) ;
250 assertTrue( rule.equals( (byte) 0x12, 2 ) ) ;
251 assertTrue( rule.equals( (byte) 0x01, 3 ) ) ;
252 }
253
254
255 public void testFinishNullDigester()
256 {
257 rule.setDigester( null ) ;
258 rule.tag( UniversalTag.INTEGER.getTagId(), true,
259 TypeClass.UNIVERSAL ) ;
260 rule.length( 0 ) ;
261 rule.value( null ) ;
262 rule.finish() ;
263
264 assertEquals( 0, digester.getIntCount() ) ;
265 }
266
267
268 public void testFinish0()
269 {
270 rule.tag( UniversalTag.INTEGER.getTagId(), true,
271 TypeClass.UNIVERSAL ) ;
272 rule.length( 0 ) ;
273 rule.value( null ) ;
274 rule.finish() ;
275
276 assertEquals( 1, digester.getIntCount() ) ;
277 assertEquals( 0, digester.popInt() ) ;
278 assertEquals( 0, digester.getIntCount() ) ;
279 }
280
281
282 public void testFinish1()
283 {
284 rule.tag( UniversalTag.INTEGER.getTagId(), true,
285 TypeClass.UNIVERSAL ) ;
286 rule.length( 1 ) ;
287 byte[] bites = { 0x45 } ;
288 ByteBuffer buf = ByteBuffer.wrap( bites ) ;
289 rule.value( buf ) ;
290 assertTrue( rule.equals( (byte) 0x45, 0 ) ) ;
291 assertTrue( rule.equals( (byte) 0x00, 1 ) ) ;
292 assertTrue( rule.equals( (byte) 0x00, 2 ) ) ;
293 assertTrue( rule.equals( (byte) 0x00, 3 ) ) ;
294 buf.clear() ;
295 rule.value( buf ) ;
296 assertTrue( rule.equals( (byte) 0x45, 0 ) ) ;
297 assertTrue( rule.equals( (byte) 0x00, 1 ) ) ;
298 assertTrue( rule.equals( (byte) 0x00, 2 ) ) ;
299 assertTrue( rule.equals( (byte) 0x00, 3 ) ) ;
300
301 rule.finish() ;
302 assertEquals( 1, digester.getIntCount() ) ;
303 assertEquals( 0x45, digester.popInt() ) ;
304 assertEquals( 0, digester.getIntCount() ) ;
305 }
306
307
308 public void testFinish2()
309 {
310 rule.tag( UniversalTag.INTEGER.getTagId(), true,
311 TypeClass.UNIVERSAL ) ;
312 rule.length( 2 ) ;
313 byte[] bites = { 0x45, 0x23 } ;
314 ByteBuffer buf = ByteBuffer.wrap( bites ) ;
315 rule.value( buf ) ;
316 assertTrue( rule.equals( (byte) 0x45, 0 ) ) ;
317 assertTrue( rule.equals( (byte) 0x23, 1 ) ) ;
318 assertTrue( rule.equals( (byte) 0x00, 2 ) ) ;
319 assertTrue( rule.equals( (byte) 0x00, 3 ) ) ;
320 buf.clear() ;
321 rule.value( buf ) ;
322 assertTrue( rule.equals( (byte) 0x45, 0 ) ) ;
323 assertTrue( rule.equals( (byte) 0x23, 1 ) ) ;
324 assertTrue( rule.equals( (byte) 0x00, 2 ) ) ;
325 assertTrue( rule.equals( (byte) 0x00, 3 ) ) ;
326
327 rule.finish() ;
328 BigInteger big = new BigInteger( bites ) ;
329 assertEquals( 1, digester.getIntCount() ) ;
330 assertEquals( big.intValue(), digester.popInt() ) ;
331 assertEquals( 0, digester.getIntCount() ) ;
332 }
333
334
335 public void testFinish2Fragmented()
336 {
337 rule.tag( UniversalTag.INTEGER.getTagId(), true,
338 TypeClass.UNIVERSAL ) ;
339 rule.length( 2 ) ;
340 byte[] bites0 = { 0x45 } ;
341 byte[] bites1 = { 0x23 } ;
342 ByteBuffer buf = ByteBuffer.wrap( bites0 ) ;
343 rule.value( buf ) ;
344 assertTrue( rule.equals( (byte) 0x45, 0 ) ) ;
345 assertTrue( rule.equals( (byte) 0x00, 1 ) ) ;
346 assertTrue( rule.equals( (byte) 0x00, 2 ) ) ;
347 assertTrue( rule.equals( (byte) 0x00, 3 ) ) ;
348 buf = ByteBuffer.wrap( bites1 ) ;
349 rule.value( buf ) ;
350 assertTrue( rule.equals( (byte) 0x45, 0 ) ) ;
351 assertTrue( rule.equals( (byte) 0x23, 1 ) ) ;
352 assertTrue( rule.equals( (byte) 0x00, 2 ) ) ;
353 assertTrue( rule.equals( (byte) 0x00, 3 ) ) ;
354 buf.clear() ;
355 rule.value( buf ) ;
356 assertTrue( rule.equals( (byte) 0x45, 0 ) ) ;
357 assertTrue( rule.equals( (byte) 0x23, 1 ) ) ;
358 assertTrue( rule.equals( (byte) 0x00, 2 ) ) ;
359 assertTrue( rule.equals( (byte) 0x00, 3 ) ) ;
360 rule.finish() ;
361
362 assertEquals( 1, digester.getIntCount() ) ;
363 byte[] bitesUsed = { 0x45, 0x23 } ;
364 BigInteger big = new BigInteger( bitesUsed ) ;
365 assertEquals( big.intValue(), digester.popInt() ) ;
366 assertEquals( 0, digester.getIntCount() ) ;
367 }
368
369
370 public void testFinish3()
371 {
372 rule.tag( UniversalTag.INTEGER.getTagId(), true,
373 TypeClass.UNIVERSAL ) ;
374 rule.length( 3 ) ;
375 byte[] bites = { 0x45, 0x23, 0x12 } ;
376 ByteBuffer buf = ByteBuffer.wrap( bites ) ;
377 rule.value( buf ) ;
378 assertTrue( rule.equals( (byte) 0x45, 0 ) ) ;
379 assertTrue( rule.equals( (byte) 0x23, 1 ) ) ;
380 assertTrue( rule.equals( (byte) 0x12, 2 ) ) ;
381 assertTrue( rule.equals( (byte) 0x00, 3 ) ) ;
382 buf.clear() ;
383 rule.value( buf ) ;
384 assertTrue( rule.equals( (byte) 0x45, 0 ) ) ;
385 assertTrue( rule.equals( (byte) 0x23, 1 ) ) ;
386 assertTrue( rule.equals( (byte) 0x12, 2 ) ) ;
387 assertTrue( rule.equals( (byte) 0x00, 3 ) ) ;
388 rule.finish() ;
389
390 assertEquals( 1, digester.getIntCount() ) ;
391 BigInteger big = new BigInteger( bites ) ;
392 assertEquals( big.intValue(), digester.popInt() ) ;
393 assertEquals( 0, digester.getIntCount() ) ;
394 }
395
396
397 public void testFinish4()
398 {
399 rule.tag( UniversalTag.INTEGER.getTagId(), true,
400 TypeClass.UNIVERSAL ) ;
401 rule.length( 4 ) ;
402 byte[] bites = { 0x45, 0x23, 0x12, 0x01 } ;
403 ByteBuffer buf = ByteBuffer.wrap( bites ) ;
404 rule.value( buf ) ;
405 assertTrue( rule.equals( (byte) 0x45, 0 ) ) ;
406 assertTrue( rule.equals( (byte) 0x23, 1 ) ) ;
407 assertTrue( rule.equals( (byte) 0x12, 2 ) ) ;
408 assertTrue( rule.equals( (byte) 0x01, 3 ) ) ;
409 buf.clear() ;
410 rule.value( buf ) ;
411 assertTrue( rule.equals( (byte) 0x45, 0 ) ) ;
412 assertTrue( rule.equals( (byte) 0x23, 1 ) ) ;
413 assertTrue( rule.equals( (byte) 0x12, 2 ) ) ;
414 assertTrue( rule.equals( (byte) 0x01, 3 ) ) ;
415 rule.finish() ;
416
417 assertEquals( 1, digester.getIntCount() ) ;
418 BigInteger big = new BigInteger( bites ) ;
419 assertEquals( big.intValue(), digester.popInt() ) ;
420 assertEquals( 0, digester.getIntCount() ) ;
421 }
422
423
424 public void testFinish5()
425 {
426 rule.tag( UniversalTag.INTEGER.getTagId(), true,
427 TypeClass.UNIVERSAL ) ;
428 rule.length( 4 ) ;
429 byte[] bites = { 0x45, 0x23, 0x12, 0x01, 0x07 } ;
430 ByteBuffer buf = ByteBuffer.wrap( bites ) ;
431 rule.value( buf ) ;
432 assertTrue( rule.equals( (byte) 0x45, 0 ) ) ;
433 assertTrue( rule.equals( (byte) 0x23, 1 ) ) ;
434 assertTrue( rule.equals( (byte) 0x12, 2 ) ) ;
435 assertTrue( rule.equals( (byte) 0x01, 3 ) ) ;
436 buf.clear() ;
437 rule.value( buf ) ;
438 assertTrue( rule.equals( (byte) 0x45, 0 ) ) ;
439 assertTrue( rule.equals( (byte) 0x23, 1 ) ) ;
440 assertTrue( rule.equals( (byte) 0x12, 2 ) ) ;
441 assertTrue( rule.equals( (byte) 0x01, 3 ) ) ;
442 rule.finish() ;
443
444 assertEquals( 1, digester.getIntCount() ) ;
445 byte[] bitesUsed = { 0x45, 0x23, 0x12, 0x01 } ;
446 BigInteger big = new BigInteger( bitesUsed ) ;
447 assertEquals( big.intValue(), digester.popInt() ) ;
448 assertEquals( 0, digester.getIntCount() ) ;
449 }
450
451
452 public void testByDecoding() throws Exception
453 {
454 byte[] data = { 0x30, 0x03, 0x02, 0x01, 0x0f } ;
455 ByteBuffer buf = ByteBuffer.wrap( data ) ;
456 digester.decode( buf ) ;
457 assertEquals( 0x0f, digester.peekInt() ) ;
458 }
459 }