libcore/luni/src/test/java/org/apache/harmony/security/tests/java/security/DigestInputStream2Test.java

   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
  18 package org.apache.harmony.security.tests.java.security;
  19
  20 import java.io.ByteArrayInputStream;
  21 import java.io.IOException;
  22 import java.security.DigestInputStream;
  23 import java.security.MessageDigest;
  24 import java.security.NoSuchAlgorithmException;
  25 import tests.support.Support_ASimpleInputStream;
  26
  27 public 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 }