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

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.apache.harmony.security.tests.java.security;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.security.DigestInputStream;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import tests.support.Support_ASimpleInputStream;

public class DigestInputStream2Test extends junit.framework.TestCase {

    ByteArrayInputStream inStream;

    ByteArrayInputStream inStream1;

    MessageDigest digest;

    /**
     * java.security.DigestInputStream#DigestInputStream(java.io.InputStream,
     *        java.security.MessageDigest)
     */
    public void test_ConstructorLjava_io_InputStreamLjava_security_MessageDigest() {
        // Test for method java.security.DigestInputStream(java.io.InputStream,
        // java.security.MessageDigest)
        DigestInputStream dis = new DigestInputStream(inStream, digest);
        assertNotNull("Constructor returned null instance", dis);
    }

    /**
     * java.security.DigestInputStream#getMessageDigest()
     */
    public void test_getMessageDigest() {
        // Test for method java.security.MessageDigest
        // java.security.DigestInputStream.getMessageDigest()
        DigestInputStream dis = new DigestInputStream(inStream, digest);
        assertEquals("getMessageDigest returned a bogus result", digest, dis
                .getMessageDigest());
    }

    /**
     * java.security.DigestInputStream#on(boolean)
     */
    public void test_onZ() throws Exception {
        // Test for method void java.security.DigestInputStream.on(boolean)
        MessageDigest originalDigest = (MessageDigest) (digest.clone());
        MessageDigest noChangeDigest = (MessageDigest) (digest.clone());
        DigestInputStream dis = new DigestInputStream(inStream, noChangeDigest);
        // turn off processing
        dis.on(false);
        // read some data
        int c = dis.read();
        assertEquals('T', c);

        // make sure the digest for the part where it was off has not
        // changed
        assertTrue("MessageDigest changed even though processing was off",
                MessageDigest.isEqual(noChangeDigest.digest(), originalDigest
                        .digest()));
        MessageDigest changeDigest = (MessageDigest) (digest.clone());
        dis = new DigestInputStream(inStream, digest);

        // turn on processing
        dis.on(true);
        c = dis.read();
        assertEquals('h', c);

        // make sure the digest has changed
        assertTrue("MessageDigest did not change with processing on",
                !MessageDigest.isEqual(digest.digest(), changeDigest.digest()));
    }

    /**
     * java.security.DigestInputStream#read()
     */
    public void test_read() throws IOException {
        // Test for method int java.security.DigestInputStream.read()
        DigestInputStream dis = new DigestInputStream(inStream, digest);

        // read and compare the data that the inStream has
        int c;
        while ((c = dis.read()) > -1) {
            int d = inStream1.read();
            assertEquals(d, c);
        }// end while
    }

    /**
     * java.security.DigestInputStream#read(byte[], int, int)
     */
    public void test_read$BII() throws IOException {
        // Test for method int java.security.DigestInputStream.read(byte [],
        // int, int)
        DigestInputStream dis = new DigestInputStream(inStream, digest);
        int bytesToRead = inStream.available();
        byte buf1[] = new byte[bytesToRead + 5];
        byte buf2[] = new byte[bytesToRead + 5];
        // make sure we're actually reading some data
        assertTrue("No data to read for this test", bytesToRead>0);

        // read and compare the data that the inStream has
        int bytesRead1 = dis.read(buf1, 5, bytesToRead);
        int bytesRead2 = inStream1.read(buf2, 5, bytesToRead);
        assertEquals("Didn't read the same from each stream", bytesRead1,
                bytesRead2);
        assertEquals("Didn't read the entire", bytesRead1, bytesToRead);
        // compare the arrays
        boolean same = true;
        for (int i = 0; i < bytesToRead + 5; i++) {
            if (buf1[i] != buf2[i]) {
                same = false;
            }
        }// end for
        assertTrue("Didn't get the same data", same);
    }

    /**
     * java.security.DigestInputStream#read(byte[], int, int)
     */
    public void test_read$BII_Exception() throws IOException {
        DigestInputStream is = new DigestInputStream(inStream, digest);
        byte[] buf = null;
        try {
            is.read(buf, -1, 0);
            fail("Test 1: NullPointerException expected.");
        } catch (NullPointerException e) {
            // Expected.
        }

        buf = new byte[1000];
        try {
            is.read(buf, -1, 0);
            fail("Test 2: IndexOutOfBoundsException expected.");
        } catch (IndexOutOfBoundsException e) {
            // Expected.
        }

        try {
            is.read(buf, 0, -1);
            fail("Test 3: IndexOutOfBoundsException expected.");
        } catch (IndexOutOfBoundsException e) {
            // Expected.
        }

        try {
            is.read(buf, -1, -1);
            fail("Test 4: IndexOutOfBoundsException expected.");
        } catch (IndexOutOfBoundsException e) {
            // Expected.
        }

        try {
            is.read(buf, 0, 1001);
            fail("Test 5: IndexOutOfBoundsException expected.");
        } catch (IndexOutOfBoundsException e) {
            // Expected.
        }

        try {
            is.read(buf, 1001, 0);
            fail("Test 6: IndexOutOfBoundsException expected.");
        } catch (IndexOutOfBoundsException e) {
            // Expected.
        }

        try {
            is.read(buf, 500, 501);
            fail("Test 7: IndexOutOfBoundsException expected.");
        } catch (IndexOutOfBoundsException e) {
            // Expected.
        }

        is.close();

        Support_ASimpleInputStream sis = new Support_ASimpleInputStream(true);
        is = new DigestInputStream(sis, digest);
        try {
            is.read(buf, 0, 100);
            fail("Test 9: IOException expected.");
        } catch (IOException e) {
            // Expected.
        }
        sis.throwExceptionOnNextUse = false;
        is.close();
    }

    /**
     * java.security.DigestInputStream#setMessageDigest(java.security.MessageDigest)
     */
    public void test_setMessageDigestLjava_security_MessageDigest() {
        // Test for method void
        // java.security.DigestInputStream.setMessageDigest(java.security.MessageDigest)
        DigestInputStream dis = new DigestInputStream(inStream, null);

        // make sure the digest is null when it's not been set
        assertNull(
                "Uninitialised MessageDigest should have been returned as null",
                dis.getMessageDigest());
        dis.setMessageDigest(digest);
        assertEquals("Wrong MessageDigest was returned.", digest, dis
                .getMessageDigest());
    }

    /**
     * Sets up the fixture, for example, open a network connection. This method
     * is called before a test is executed.
     */
    protected void setUp() {
        // create a ByteArrayInputStream to perform digesting on
        inStream = new ByteArrayInputStream(
                "This is a test string for digesting".getBytes());
        inStream1 = new ByteArrayInputStream(
                "This is a test string for digesting".getBytes());
        try {
            digest = MessageDigest.getInstance("SHA-1");
        } catch (NoSuchAlgorithmException e) {
            fail("Unable to find SHA-1 algorithm");
        }
    }
}