001: /*
002: * Licensed to the Apache Software Foundation (ASF) under one or more
003: * contributor license agreements. See the NOTICE file distributed with
004: * this work for additional information regarding copyright ownership.
005: * The ASF licenses this file to You under the Apache License, Version 2.0
006: * (the "License"); you may not use this file except in compliance with
007: * the License. You may obtain a copy of the License at
008: *
009: * http://www.apache.org/licenses/LICENSE-2.0
010: *
011: * Unless required by applicable law or agreed to in writing, software
012: * distributed under the License is distributed on an "AS IS" BASIS,
013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014: * See the License for the specific language governing permissions and
015: * limitations under the License.
016: */
017:
018: /**
019: * @author Boris V. Kuznetsov
020: * @version $Revision$
021: */package org.apache.harmony.security.tests.java.security;
022:
023: import java.nio.ByteBuffer;
024: import java.security.DigestException;
025: import java.security.MessageDigestSpi;
026:
027: import junit.framework.TestCase;
028:
029: /**
030: * Tests for <code>MessageDigestSpi</code> constructor and methods
031: */
032: public class MessageDigestSpiTest extends TestCase {
033:
034: /**
035: * java.security.MessageDigestSpi#engineDigest(byte[], int, int)
036: */
037: public void test_engineDigestLB$LILI() throws Exception {
038:
039: final int DIGEST_LENGTH = 2;
040:
041: MyMessageDigest md = new MyMessageDigest() {
042:
043: public int engineGetDigestLength() {
044: return DIGEST_LENGTH;
045: }
046:
047: public byte[] engineDigest() {
048: return new byte[DIGEST_LENGTH]; // return non-null value
049: }
050: };
051:
052: byte[] b = new byte[5];
053: try {
054: // test: null output buffer
055: md.engineDigest(null, 1, DIGEST_LENGTH);
056: fail("No expected NullPointerException");
057: } catch (NullPointerException e) {
058: }
059: try {
060: //test: len param < digest length
061: md.engineDigest(b, 1, DIGEST_LENGTH - 1);
062: fail("No expected DigestException");
063: } catch (DigestException e) {
064: }
065:
066: assertEquals("incorrect result", DIGEST_LENGTH, md
067: .engineDigest(b, 1, 3));
068:
069: // Regression for HARMONY-3045
070: md = new MyMessageDigest();
071: try {
072: md.engineDigest(b, 0, 1);
073: fail("should throw NullPointerException");
074: } catch (NullPointerException e) {
075: // expected
076: }
077: }
078:
079: /**
080: * java.security.MessageDigestSpi#engineGetDigestLength()
081: */
082: public void test_engineGetDigestLength() {
083: MyMessageDigest md = new MyMessageDigest();
084: assertEquals(0, md.engineGetDigestLength());
085: }
086:
087: /**
088: * java.security.MessageDigestSpi#engineUpdate(ByteBuffer)
089: */
090: public void test_engineUpdateLjava_nio_ByteBuffer() {
091: MyMessageDigest md = new MyMessageDigest();
092: byte[] b = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
093:
094: ByteBuffer buf = ByteBuffer.wrap(b, 0, b.length);
095: buf.get(b);
096: int limit = buf.limit();
097: md.engineUpdate(buf);
098: assertEquals(limit, buf.limit());
099: assertEquals(limit, buf.position());
100:
101: buf = ByteBuffer.wrap(b, 0, b.length);
102: buf.get();
103: buf.get();
104: buf.get();
105: md.engineUpdate(buf);
106: assertEquals(limit, buf.limit());
107: assertEquals(limit, buf.position());
108: }
109:
110: /**
111: * @tests java.security.MessageDigestSpi#clone()
112: */
113: public void test_clone() throws CloneNotSupportedException {
114: MyMessageDigest md = new MyMessageDigest();
115: try {
116: md.clone();
117: fail("No expected CloneNotSupportedException");
118: } catch (CloneNotSupportedException e) {
119: }
120:
121: MyMessageDigestCloneable mdc = new MyMessageDigestCloneable();
122: assertNotSame(mdc, mdc.clone());
123: }
124:
125: private class MyMessageDigest extends MessageDigestSpi {
126:
127: @Override
128: public void engineReset() {
129: }
130:
131: @Override
132: public byte[] engineDigest() {
133: return null;
134: }
135:
136: @Override
137: public void engineUpdate(byte arg0) {
138: }
139:
140: @Override
141: public void engineUpdate(byte[] arg0, int arg1, int arg2) {
142: }
143:
144: @Override
145: protected int engineDigest(byte[] buf, int offset, int len)
146: throws DigestException {
147: return super .engineDigest(buf, offset, len);
148: }
149:
150: @Override
151: protected int engineGetDigestLength() {
152: return super .engineGetDigestLength();
153: }
154:
155: @Override
156: protected void engineUpdate(ByteBuffer input) {
157: super .engineUpdate(input);
158: }
159: }
160:
161: private class MyMessageDigestCloneable extends MyMessageDigest
162: implements Cloneable {
163: }
164: }
|