/*
* 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.nio.ByteBuffer;
import java.security.DigestException;
import java.security.MessageDigest;
import java.security.MessageDigestSpi;
import java.security.NoSuchAlgorithmException;
import java.security.Provider;
import junit.framework.TestCase;
import org.apache.harmony.security.tests.support.MyMessageDigest1;
/**
* Tests for <code>MessageDigest</code> constructor and methods
*/
public class MessageDigest1Test extends TestCase {
/**
* java.security.MessageDigest#reset()
*/
public void test_reset() {
MyMessageDigest1 md = new MyMessageDigest1("ABC");
md.reset();
assertTrue(md.runEngineReset);
}
/**
* java.security.MessageDigest#update(byte)
*/
public void test_updateLB() {
MyMessageDigest1 md = new MyMessageDigest1("ABC");
md.update((byte) 1);
assertTrue(md.runEngineUpdate1);
}
/**
* java.security.MessageDigest#update(byte[], int, int)
*/
public void test_updateLB$LILI() {
MyMessageDigest1 md = new MyMessageDigest1("ABC");
final byte[] bytes = { 1, 2, 3, 4, 5 };
md.update(bytes, 1, 2);
assertTrue(md.runEngineUpdate2);
// Regression for HARMONY-1120
try {
// buf == null
md.update(null, 0, 1);
fail("No expected IllegalArgumentException");
} catch (IllegalArgumentException e) {
}
try {
// offset + len > buf.length
md.update(bytes, 0, bytes.length + 1);
fail("No expected IllegalArgumentException");
} catch (IllegalArgumentException e) {
}
try {
// offset + len > Integer.MAX_VALUE
md.update(bytes, Integer.MAX_VALUE, 1);
fail("No expected IllegalArgumentException");
} catch (IllegalArgumentException e) {
}
// offset<0 and len<0 are passed to provider
final int offset = -1;
final int len = -1;
md = new MyMessageDigest1("ABC") {
@Override
public void engineUpdate(byte[] arg0, int arg1, int arg2) {
assertSame("buf", bytes, arg0);
assertEquals("offset", offset, arg1);
assertEquals("len", len, arg2);
runEngineUpdate2 = true;
}
};
md.update(bytes, offset, len);
assertTrue(md.runEngineUpdate2);
}
/**
* java.security.MessageDigest#update(byte[])
*/
public void test_updateLB$() {
MyMessageDigest1 md = new MyMessageDigest1("ABC");
byte[] b = { 1, 2, 3, 4, 5 };
md.update(b);
assertTrue(md.runEngineUpdate2);
}
/**
* java.security.MessageDigest#update(ByteBuffer)
*/
public void test_updateLjava_nio_ByteBuffer() {
MyMessageDigest1 md = new MyMessageDigest1("ABC");
byte[] b = { 1, 2, 3, 4, 5 };
ByteBuffer byteBuffer = ByteBuffer.wrap(b);
int limit = byteBuffer.limit();
md.update(byteBuffer);
assertTrue(md.runEngineUpdate2);
assertEquals(byteBuffer.limit(), byteBuffer.position());
assertEquals(limit, byteBuffer.limit());
}
/**
* java.security.MessageDigest#digest()
*/
public void test_digest() {
MyMessageDigest1 md = new MyMessageDigest1("ABC");
assertEquals("incorrect result", 0, md.digest().length);
assertTrue(md.runEngineDigest);
}
/**
* java.security.MessageDigest#digest(byte[])
*/
public void test_digestLB$() {
MyMessageDigest1 md = new MyMessageDigest1("ABC");
byte[] b = { 1, 2, 3, 4, 5 };
assertEquals("incorrect result", 0, md.digest(b).length);
assertTrue(md.runEngineDigest);
}
/**
* java.security.MessageDigest#digest(byte[], int, int)
*/
public void test_digestLB$LILI() throws Exception {
MyMessageDigest1 md = new MyMessageDigest1("ABC");
byte[] b = { 1, 2, 3, 4, 5 };
assertEquals("incorrect result", 0, md.digest(b, 2, 3));
assertTrue("digest failed", md.runEngineDigest);
// Regression for Harmony-1148
md = new MyMessageDigest1();
final byte[] bytes = new byte[] { 2, 4, 1 };
try {
// buf == null
md.digest(null, 0, 1);
fail("No expected IllegalArgumentException");
} catch (IllegalArgumentException e) {
}
try {
// offset + len > buf.length
md.digest(bytes, 0, bytes.length + 1);
fail("No expected IllegalArgumentException");
} catch (IllegalArgumentException e) {
}
try {
// offset + len > Integer.MAX_VALUE
md.digest(bytes, Integer.MAX_VALUE, 1);
fail("No expected IllegalArgumentException");
} catch (IllegalArgumentException e) {
}
// offset<0 and len<0 are passed to provider
final int offset = -1;
final int len = -1;
final int status = 33;
md = new MyMessageDigest1("ABC") {
@Override
public int engineDigest(byte[] arg0, int arg1, int arg2) {
assertSame("buf", bytes, arg0);
assertEquals("offset", offset, arg1);
assertEquals("len", len, arg2);
return status;
}
};
assertEquals("returned status", status, md.digest(bytes, offset, len));
try {
MessageDigest digest = MessageDigest.getInstance("TestDigest", new TestProvider());
digest.digest(new byte[5], 0, 5);
fail("expected DigestException");
} catch (DigestException e) {
// ok
}
}
/**
* java.security.MessageDigest#isEqual(byte[],byte[])
*/
public void test_isEqualLB$LB$() {
byte[] b1 = { 1, 2, 3, 4 };
byte[] b2 = { 1, 2, 3, 4, 5 };
byte[] b3 = { 1, 3, 3, 4 };
byte[] b4 = { 1, 2, 3, 4 };
assertTrue(MessageDigest.isEqual(b1, b4));
assertFalse(MessageDigest.isEqual(b1, b2));
assertFalse(MessageDigest.isEqual(b1, b3));
}
/**
* java.security.MessageDigest#getAlgorithm()
*/
public void test_getAlgorithm() {
MyMessageDigest1 md = new MyMessageDigest1("ABC");
assertEquals("ABC", md.getAlgorithm());
}
/**
* java.security.MessageDigest#getProvider()
*/
public void test_getProvider() {
MyMessageDigest1 md = new MyMessageDigest1("ABC");
assertNull(md.getProvider());
}
/**
* java.security.MessageDigest#getDigestLength()
*/
public void test_getDigestLength() {
MyMessageDigest1 md = new MyMessageDigest1("ABC");
assertEquals(0, md.getDigestLength());
}
/**
* Tests SHA MessageDigest provider
*/
public void testSHAProvider() {
MessageDigest md = null;
try {
md = MessageDigest.getInstance("SHA");
} catch (NoSuchAlgorithmException e) {
fail("unexpected exception: " + e);
}
byte[] bytes = new byte[] { 1, 1, 1, 1, 1 };
// Regression for HARMONY-1120
// testing combination with provider
try {
// offset < 0
md.update(bytes, -1, 1);
fail("No expected IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException e) {
}
try {
md.update(bytes, 1, -1);
fail("No expected IndexOutOfBoundsException");
} catch (IndexOutOfBoundsException e) {
}
//Regression for Harmony-1148
try {
md = MessageDigest.getInstance("SHA");
} catch (NoSuchAlgorithmException e) {
fail("unexpected exception: " + e);
}
try {
// offset < 0
md.digest(bytes, 0, -1);
fail("No expected DigestException");
} catch (DigestException e) {
}
try {
// len < 0
md.digest(bytes, -1, 0);
fail("No expected DigestException");
} catch (DigestException e) {
}
try {
md = MessageDigest.getInstance("UnknownDigest");
fail("expected NoSuchAlgorithmException");
} catch (NoSuchAlgorithmException e) {
// ok
}
}
class TestProvider extends Provider {
public TestProvider() {
super("TestProvider", 1.0, "info");
put("MessageDigest.TestDigest", TestMessageDigestSpi.class.getName());
}
}
public static class TestMessageDigestSpi extends MessageDigestSpi {
public TestMessageDigestSpi() {
}
@Override
protected byte[] engineDigest() {
return new byte[]{3,4,5,6,7,8,9,3,45,6,7,};
}
@Override
protected void engineReset() {
}
@Override
protected void engineUpdate(byte input) {
}
@Override
protected void engineUpdate(byte[] input, int offset, int len) {
}
@Override
protected int engineGetDigestLength() {
return 42;
}
}
}