1   /*
2    *   Copyright 2004 The Apache Software Foundation
3    *
4    *   Licensed under the Apache License, Version 2.0 (the "License");
5    *   you may not use this file except in compliance with the License.
6    *   You may obtain a copy of the License at
7    *
8    *       http://www.apache.org/licenses/LICENSE-2.0
9    *
10   *   Unless required by applicable law or agreed to in writing, software
11   *   distributed under the License is distributed on an "AS IS" BASIS,
12   *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13   *   See the License for the specific language governing permissions and
14   *   limitations under the License.
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 }