1/*
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements.  See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License.  You may obtain a copy of the License at
8 *
9 *     http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18package org.apache.harmony.security.tests.java.security;
19
20import java.io.ByteArrayInputStream;
21import java.io.IOException;
22import java.security.DigestInputStream;
23import java.security.MessageDigest;
24import java.security.NoSuchAlgorithmException;
25import tests.support.Support_ASimpleInputStream;
26
27public class DigestInputStream2Test extends junit.framework.TestCase {
28
29    ByteArrayInputStream inStream;
30
31    ByteArrayInputStream inStream1;
32
33    MessageDigest digest;
34
35    /**
36     * java.security.DigestInputStream#DigestInputStream(java.io.InputStream,
37     *        java.security.MessageDigest)
38     */
39    public void test_ConstructorLjava_io_InputStreamLjava_security_MessageDigest() {
40        // Test for method java.security.DigestInputStream(java.io.InputStream,
41        // java.security.MessageDigest)
42        DigestInputStream dis = new DigestInputStream(inStream, digest);
43        assertNotNull("Constructor returned null instance", dis);
44    }
45
46    /**
47     * java.security.DigestInputStream#getMessageDigest()
48     */
49    public void test_getMessageDigest() {
50        // Test for method java.security.MessageDigest
51        // java.security.DigestInputStream.getMessageDigest()
52        DigestInputStream dis = new DigestInputStream(inStream, digest);
53        assertEquals("getMessageDigest returned a bogus result", digest, dis
54                .getMessageDigest());
55    }
56
57    /**
58     * java.security.DigestInputStream#on(boolean)
59     */
60    public void test_onZ() throws Exception {
61        // Test for method void java.security.DigestInputStream.on(boolean)
62        MessageDigest originalDigest = (MessageDigest) (digest.clone());
63        MessageDigest noChangeDigest = (MessageDigest) (digest.clone());
64        DigestInputStream dis = new DigestInputStream(inStream, noChangeDigest);
65        // turn off processing
66        dis.on(false);
67        // read some data
68        int c = dis.read();
69        assertEquals('T', c);
70
71        // make sure the digest for the part where it was off has not
72        // changed
73        assertTrue("MessageDigest changed even though processing was off",
74                MessageDigest.isEqual(noChangeDigest.digest(), originalDigest
75                        .digest()));
76        MessageDigest changeDigest = (MessageDigest) (digest.clone());
77        dis = new DigestInputStream(inStream, digest);
78
79        // turn on processing
80        dis.on(true);
81        c = dis.read();
82        assertEquals('h', c);
83
84        // make sure the digest has changed
85        assertTrue("MessageDigest did not change with processing on",
86                !MessageDigest.isEqual(digest.digest(), changeDigest.digest()));
87    }
88
89    /**
90     * java.security.DigestInputStream#read()
91     */
92    public void test_read() throws IOException {
93        // Test for method int java.security.DigestInputStream.read()
94        DigestInputStream dis = new DigestInputStream(inStream, digest);
95
96        // read and compare the data that the inStream has
97        int c;
98        while ((c = dis.read()) > -1) {
99            int d = inStream1.read();
100            assertEquals(d, c);
101        }// end while
102    }
103
104    /**
105     * java.security.DigestInputStream#read(byte[], int, int)
106     */
107    public void test_read$BII() throws IOException {
108        // Test for method int java.security.DigestInputStream.read(byte [],
109        // int, int)
110        DigestInputStream dis = new DigestInputStream(inStream, digest);
111        int bytesToRead = inStream.available();
112        byte buf1[] = new byte[bytesToRead + 5];
113        byte buf2[] = new byte[bytesToRead + 5];
114        // make sure we're actually reading some data
115        assertTrue("No data to read for this test", bytesToRead>0);
116
117        // read and compare the data that the inStream has
118        int bytesRead1 = dis.read(buf1, 5, bytesToRead);
119        int bytesRead2 = inStream1.read(buf2, 5, bytesToRead);
120        assertEquals("Didn't read the same from each stream", bytesRead1,
121                bytesRead2);
122        assertEquals("Didn't read the entire", bytesRead1, bytesToRead);
123        // compare the arrays
124        boolean same = true;
125        for (int i = 0; i < bytesToRead + 5; i++) {
126            if (buf1[i] != buf2[i]) {
127                same = false;
128            }
129        }// end for
130        assertTrue("Didn't get the same data", same);
131    }
132
133    /**
134     * java.security.DigestInputStream#read(byte[], int, int)
135     */
136    public void test_read$BII_Exception() throws IOException {
137        DigestInputStream is = new DigestInputStream(inStream, digest);
138        byte[] buf = null;
139        try {
140            is.read(buf, -1, 0);
141            fail("Test 1: NullPointerException expected.");
142        } catch (NullPointerException e) {
143            // Expected.
144        }
145
146        buf = new byte[1000];
147        try {
148            is.read(buf, -1, 0);
149            fail("Test 2: IndexOutOfBoundsException expected.");
150        } catch (IndexOutOfBoundsException e) {
151            // Expected.
152        }
153
154        try {
155            is.read(buf, 0, -1);
156            fail("Test 3: IndexOutOfBoundsException expected.");
157        } catch (IndexOutOfBoundsException e) {
158            // Expected.
159        }
160
161        try {
162            is.read(buf, -1, -1);
163            fail("Test 4: IndexOutOfBoundsException expected.");
164        } catch (IndexOutOfBoundsException e) {
165            // Expected.
166        }
167
168        try {
169            is.read(buf, 0, 1001);
170            fail("Test 5: IndexOutOfBoundsException expected.");
171        } catch (IndexOutOfBoundsException e) {
172            // Expected.
173        }
174
175        try {
176            is.read(buf, 1001, 0);
177            fail("Test 6: IndexOutOfBoundsException expected.");
178        } catch (IndexOutOfBoundsException e) {
179            // Expected.
180        }
181
182        try {
183            is.read(buf, 500, 501);
184            fail("Test 7: IndexOutOfBoundsException expected.");
185        } catch (IndexOutOfBoundsException e) {
186            // Expected.
187        }
188
189        is.close();
190
191        Support_ASimpleInputStream sis = new Support_ASimpleInputStream(true);
192        is = new DigestInputStream(sis, digest);
193        try {
194            is.read(buf, 0, 100);
195            fail("Test 9: IOException expected.");
196        } catch (IOException e) {
197            // Expected.
198        }
199        sis.throwExceptionOnNextUse = false;
200        is.close();
201    }
202
203    /**
204     * java.security.DigestInputStream#setMessageDigest(java.security.MessageDigest)
205     */
206    public void test_setMessageDigestLjava_security_MessageDigest() {
207        // Test for method void
208        // java.security.DigestInputStream.setMessageDigest(java.security.MessageDigest)
209        DigestInputStream dis = new DigestInputStream(inStream, null);
210
211        // make sure the digest is null when it's not been set
212        assertNull(
213                "Uninitialised MessageDigest should have been returned as null",
214                dis.getMessageDigest());
215        dis.setMessageDigest(digest);
216        assertEquals("Wrong MessageDigest was returned.", digest, dis
217                .getMessageDigest());
218    }
219
220    /**
221     * Sets up the fixture, for example, open a network connection. This method
222     * is called before a test is executed.
223     */
224    protected void setUp() {
225        // create a ByteArrayInputStream to perform digesting on
226        inStream = new ByteArrayInputStream(
227                "This is a test string for digesting".getBytes());
228        inStream1 = new ByteArrayInputStream(
229                "This is a test string for digesting".getBytes());
230        try {
231            digest = MessageDigest.getInstance("SHA-1");
232        } catch (NoSuchAlgorithmException e) {
233            fail("Unable to find SHA-1 algorithm");
234        }
235    }
236}
237