/*
* 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");
}
}
}