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.codec.stateful.examples;
18  
19  import java.nio.ByteBuffer;
20  import java.util.Random;
21  
22  import junit.framework.TestCase;
23  
24  import org.apache.asn1.codec.EncoderException;
25  import org.apache.asn1.codec.binary.Hex;
26  import org.apache.asn1.codec.stateful.EncoderCallback;
27  import org.apache.asn1.codec.stateful.StatefulEncoder;
28  
29  /***
30   * Document me.
31   * 
32   * @author <a href="mailto:dev@directory.apache.org"> Apache Directory
33   *         Project</a> $Rev: 161723 $
34   */
35  public class HexEncoderTest extends TestCase implements EncoderCallback
36  {
37      HexEncoder encoder = null;
38      byte[] encoded = null;
39      byte[] data = null;
40  
41  
42      protected void setUp() throws Exception
43      {
44          super.setUp();
45          encoder = new HexEncoder();
46          encoder.setCallback( this );
47      }
48  
49  
50      protected void tearDown() throws Exception
51      {
52          super.tearDown();
53          data = null;
54          encoder = null;
55          encoded = null;
56      }
57  
58  
59      private void generateData( int amount )
60      {
61          Random rand = new Random(System.currentTimeMillis()) ;
62          data = new byte[amount];
63          rand.nextBytes( data );
64      }
65  
66  
67      public void encodeOccurred( StatefulEncoder encoder, Object encodedObj )
68      {
69          ByteBuffer encodedBuf = ( ByteBuffer ) encodedObj ;
70  
71          if ( encoded == null )
72          {
73              encoded = new byte[encodedBuf.remaining()];
74              encodedBuf.get( encoded ) ;
75          }
76          else
77          {
78              byte[] temp = encoded ;
79              encoded = new byte[encodedBuf.remaining() + temp.length];
80              System.arraycopy( temp, 0, encoded, 0, temp.length );
81              encodedBuf.get( encoded, temp.length, encodedBuf.remaining() );
82          }
83      }
84  
85  
86      public void testEncode0() throws EncoderException
87      {
88          generateData( 0 );
89          encoder.encode( ByteBuffer.wrap( data ) );
90          if ( encoded == null )
91          {
92              encoded = new byte[0];
93          }
94          assertEncoded( encoded, Hex.encodeHex( data ) );
95      }
96  
97  
98      public void testEncode1() throws EncoderException
99      {
100         generateData( 1 );
101         encoder.encode( ByteBuffer.wrap( data ) );
102         assertEncoded( encoded, Hex.encodeHex( data ) );
103     }
104 
105 
106     public void testEncode25() throws EncoderException
107     {
108         generateData( 25 );
109         encoder.encode( ByteBuffer.wrap( data ) );
110         assertEncoded( encoded, Hex.encodeHex( data ) );
111     }
112 
113 
114     public void testEncode63() throws EncoderException
115     {
116         generateData( 63 );
117         encoder.encode( ByteBuffer.wrap( data ) );
118         assertEncoded( encoded, Hex.encodeHex( data ) );
119     }
120 
121 
122     public void testEncode64() throws EncoderException
123     {
124         generateData( 64 );
125         encoder.encode( ByteBuffer.wrap( data ) );
126         assertEncoded( encoded, Hex.encodeHex( data ) );
127     }
128 
129 
130     public void testEncode65() throws EncoderException
131     {
132         generateData( 65 );
133         encoder.encode( ByteBuffer.wrap( data ) );
134         assertEncoded( encoded, Hex.encodeHex( data ) );
135     }
136 
137 
138     public void testEncode66() throws EncoderException
139     {
140         generateData( 66 );
141         encoder.encode( ByteBuffer.wrap( data ) );
142         assertEncoded( encoded, Hex.encodeHex( data ) );
143     }
144 
145 
146     public void testEncode512() throws EncoderException
147     {
148         generateData( 512 );
149         encoder.encode( ByteBuffer.wrap( data ) );
150         assertEncoded( encoded, Hex.encodeHex( data ) );
151     }
152 
153 
154     private void assertEncoded( byte[] encoded, char[] hex )
155     {
156         if ( encoded.length != hex.length )
157         {
158             fail( "encoded length of " + encoded.length
159                     + " did not match expected hex char length of "
160                     + hex.length ) ;
161         }
162 
163         for ( int ii = 0; ii < encoded.length; ii++ )
164         {
165             if ( encoded[ii] != hex[ii] )
166             {
167                 fail( "encoding failed - encoded array does not match" ) ;
168             }
169         }
170     }
171 }