KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > columba > ristretto > coder > Base64DecoderInputStreamTest


1 /* ***** BEGIN LICENSE BLOCK *****
2  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
3  *
4  * The contents of this file are subject to the Mozilla Public License Version
5  * 1.1 (the "License"); you may not use this file except in compliance with
6  * the License. You may obtain a copy of the License at
7  * http://www.mozilla.org/MPL/
8  *
9  * Software distributed under the License is distributed on an "AS IS" basis,
10  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
11  * for the specific language governing rights and limitations under the
12  * License.
13  *
14  * The Original Code is Ristretto Mail API.
15  *
16  * The Initial Developers of the Original Code are
17  * Timo Stich and Frederik Dietz.
18  * Portions created by the Initial Developers are Copyright (C) 2004
19  * All Rights Reserved.
20  *
21  * Contributor(s):
22  *
23  * Alternatively, the contents of this file may be used under the terms of
24  * either the GNU General Public License Version 2 or later (the "GPL"), or
25  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
26  * in which case the provisions of the GPL or the LGPL are applicable instead
27  * of those above. If you wish to allow use of your version of this file only
28  * under the terms of either the GPL or the LGPL, and not to allow others to
29  * use your version of this file under the terms of the MPL, indicate your
30  * decision by deleting the provisions above and replace them with the notice
31  * and other provisions required by the GPL or the LGPL. If you do not delete
32  * the provisions above, a recipient may use your version of this file under
33  * the terms of any one of the MPL, the GPL or the LGPL.
34  *
35  * ***** END LICENSE BLOCK ***** */

36 package org.columba.ristretto.coder;
37
38 import java.io.ByteArrayInputStream JavaDoc;
39 import java.io.IOException JavaDoc;
40 import java.io.InputStream JavaDoc;
41 import java.util.Random JavaDoc;
42
43 import junit.framework.TestCase;
44
45 import org.columba.ristretto.io.CharSequenceSource;
46 import org.columba.ristretto.io.SourceInputStream;
47
48 public class Base64DecoderInputStreamTest extends TestCase {
49
50     /**
51      * Constructor for Base64DecoderInputStreamTest.
52      * @param arg0
53      */

54     public Base64DecoderInputStreamTest(String JavaDoc arg0) {
55         super(arg0);
56     }
57     
58     public void test0Pads() {
59         String JavaDoc input = "/4BA/4BA";
60         CharSequenceSource source = new CharSequenceSource( input );
61         Base64DecoderInputStream base64in= new Base64DecoderInputStream( new SourceInputStream(source));
62         int[] result = { 0x0ff, 0x080, 0x040, 0x0ff, 0x080, 0x040 };
63         int pos = 0;
64         
65         try {
66             int nextIn = base64in.read();
67             while( nextIn != -1 ) {
68                 assertTrue( nextIn == result[pos++]);
69                 nextIn = base64in.read();
70             }
71         } catch (IOException JavaDoc e) {
72             e.printStackTrace();
73         }
74         
75         assertTrue( pos == 6 );
76     }
77
78     public void test1Pads() {
79         String JavaDoc input = "/4BA/4A=";
80         CharSequenceSource source = new CharSequenceSource( input );
81         Base64DecoderInputStream base64in= new Base64DecoderInputStream( new SourceInputStream(source));
82         int[] result = { 0x0ff, 0x080, 0x040, 0x0ff, 0x080, 0x040 };
83         int pos = 0;
84         
85         try {
86             int nextIn = base64in.read();
87             while( nextIn != -1 ) {
88                 assertTrue( nextIn == result[pos++]);
89                 nextIn = base64in.read();
90             }
91         } catch (IOException JavaDoc e) {
92             e.printStackTrace();
93         }
94         
95         assertTrue( pos == 5 );
96     }
97
98
99     public void test2Pads() {
100         String JavaDoc input = "/4BA/w==";
101         CharSequenceSource source = new CharSequenceSource( input );
102         Base64DecoderInputStream base64in= new Base64DecoderInputStream( new SourceInputStream(source));
103         int[] result = { 0x0ff, 0x080, 0x040, 0x0ff, 0x080, 0x040 };
104         int pos = 0;
105         
106         try {
107             int nextIn = base64in.read();
108             while( nextIn != -1 ) {
109                 assertTrue( nextIn == result[pos++]);
110                 nextIn = base64in.read();
111             }
112         } catch (IOException JavaDoc e) {
113             e.printStackTrace();
114         }
115         
116         assertTrue( pos == 4 );
117     }
118
119
120     public void testBreak() {
121         String JavaDoc input = "/4B\nA/4\r\nBA";
122         CharSequenceSource source = new CharSequenceSource( input );
123         Base64DecoderInputStream base64in= new Base64DecoderInputStream( new SourceInputStream(source));
124         int[] result = { 0x0ff, 0x080, 0x040, 0x0ff, 0x080, 0x040 };
125         int pos = 0;
126         
127         try {
128             int nextIn = base64in.read();
129             while( nextIn != -1 ) {
130                 assertTrue( nextIn == result[pos++]);
131                 nextIn = base64in.read();
132             }
133         } catch (IOException JavaDoc e) {
134             e.printStackTrace();
135         }
136         
137         assertTrue( pos == 6 );
138     }
139     
140     public void testencodedecode() {
141         Random JavaDoc random = new Random JavaDoc();
142         byte[] testInput = new byte[(int) (random.nextFloat() * 1024)];
143         random.nextBytes(testInput);
144         InputStream JavaDoc in = new Base64DecoderInputStream( new Base64EncoderInputStream( new ByteArrayInputStream JavaDoc(testInput)));
145         try {
146             for( int i=0; i<testInput.length; i++) {
147                 byte next = (byte) in.read();
148                 if(testInput[i] != next ) {
149                     System.out.println( i + " " + testInput[i] + " != "+ next);
150                 }
151                 assertTrue(testInput[i] == next);
152             }
153         } catch (IOException JavaDoc e) {
154             e.printStackTrace();
155         }
156     }
157 }
158
Popular Tags