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
18package org.apache.harmony.security.tests.java.security;
19
20import java.nio.ByteBuffer;
21import java.security.DigestException;
22import java.security.MessageDigest;
23
24import junit.framework.TestCase;
25
26import org.apache.harmony.security.tests.support.MyMessageDigest1;
27
28/**
29 * Tests for <code>MessageDigest</code> constructor and methods
30 */
31public class MessageDigest1Test extends TestCase {
32
33    /**
34     * @tests java.security.MessageDigest#reset()
35     */
36    public void test_reset() {
37        MyMessageDigest1 md = new MyMessageDigest1("ABC");
38        md.reset();
39        assertTrue(md.runEngineReset);
40    }
41
42    /**
43     * @tests java.security.MessageDigest#update(byte)
44     */
45    public void test_updateLB() {
46        MyMessageDigest1 md = new MyMessageDigest1("ABC");
47        md.update((byte) 1);
48        assertTrue(md.runEngineUpdate1);
49    }
50
51    /**
52     * @tests java.security.MessageDigest#update(byte[], int, int)
53     */
54    public void test_updateLB$LILI() {
55        MyMessageDigest1 md = new MyMessageDigest1("ABC");
56        final byte[] bytes = { 1, 2, 3, 4, 5 };
57        md.update(bytes, 1, 2);
58        assertTrue(md.runEngineUpdate2);
59
60        // Regression for HARMONY-1120
61        try {
62            // buf == null
63            md.update(null, 0, 1);
64            fail("No expected IllegalArgumentException");
65        } catch (IllegalArgumentException e) {
66        }
67        try {
68            // offset + len > buf.length
69            md.update(bytes, 0, bytes.length + 1);
70            fail("No expected IllegalArgumentException");
71        } catch (IllegalArgumentException e) {
72        }
73        try {
74            // offset + len > Integer.MAX_VALUE
75            md.update(bytes, Integer.MAX_VALUE, 1);
76            fail("No expected IllegalArgumentException");
77        } catch (IllegalArgumentException e) {
78        }
79        // offset<0 and len<0 are passed to provider
80        final int offset = -1;
81        final int len = -1;
82        md = new MyMessageDigest1("ABC") {
83            @Override
84            public void engineUpdate(byte[] arg0, int arg1, int arg2) {
85                assertSame("buf", bytes, arg0);
86                assertEquals("offset", offset, arg1);
87                assertEquals("len", len, arg2);
88                runEngineUpdate2 = true;
89            }
90        };
91        md.update(bytes, offset, len);
92        assertTrue(md.runEngineUpdate2);
93    }
94
95    /**
96     * @tests java.security.MessageDigest#update(byte[])
97     */
98    public void test_updateLB$() {
99        MyMessageDigest1 md = new MyMessageDigest1("ABC");
100        byte[] b = { 1, 2, 3, 4, 5 };
101        md.update(b);
102        assertTrue(md.runEngineUpdate2);
103    }
104
105    /**
106     * @tests java.security.MessageDigest#update(ByteBuffer)
107     */
108    public void test_updateLjava_nio_ByteBuffer() {
109        MyMessageDigest1 md = new MyMessageDigest1("ABC");
110        byte[] b = { 1, 2, 3, 4, 5 };
111        ByteBuffer byteBuffer = ByteBuffer.wrap(b);
112
113        int limit = byteBuffer.limit();
114        md.update(byteBuffer);
115        assertTrue(md.runEngineUpdate2);
116        assertEquals(byteBuffer.limit(), byteBuffer.position());
117        assertEquals(limit, byteBuffer.limit());
118    }
119
120    /**
121     * @tests java.security.MessageDigest#digest()
122     */
123    public void test_digest() {
124        MyMessageDigest1 md = new MyMessageDigest1("ABC");
125        assertEquals("incorrect result", 0, md.digest().length);
126        assertTrue(md.runEngineDigest);
127    }
128
129    /**
130     * @tests java.security.MessageDigest#digest(byte[])
131     */
132    public void test_digestLB$() {
133        MyMessageDigest1 md = new MyMessageDigest1("ABC");
134        byte[] b = { 1, 2, 3, 4, 5 };
135        assertEquals("incorrect result", 0, md.digest(b).length);
136        assertTrue(md.runEngineDigest);
137    }
138
139    /**
140     * @tests java.security.MessageDigest#digest(byte[], int, int)
141     */
142    public void test_digestLB$LILI() throws Exception {
143        MyMessageDigest1 md = new MyMessageDigest1("ABC");
144        byte[] b = { 1, 2, 3, 4, 5 };
145        assertEquals("incorrect result", 0, md.digest(b, 2, 3));
146        assertTrue("digest failed", md.runEngineDigest);
147
148        // Regression for Harmony-1148
149        md = new MyMessageDigest1();
150        final byte[] bytes = new byte[] { 2, 4, 1 };
151        try {
152            // buf == null
153            md.digest(null, 0, 1);
154            fail("No expected IllegalArgumentException");
155        } catch (IllegalArgumentException e) {
156        }
157        try {
158            // offset + len > buf.length
159            md.digest(bytes, 0, bytes.length + 1);
160            fail("No expected IllegalArgumentException");
161        } catch (IllegalArgumentException e) {
162        }
163        try {
164            // offset + len > Integer.MAX_VALUE
165            md.digest(bytes, Integer.MAX_VALUE, 1);
166            fail("No expected IllegalArgumentException");
167        } catch (IllegalArgumentException e) {
168        }
169        // offset<0 and len<0 are passed to provider
170        final int offset = -1;
171        final int len = -1;
172        final int status = 33;
173        md = new MyMessageDigest1("ABC") {
174            @Override
175            public int engineDigest(byte[] arg0, int arg1, int arg2) {
176                assertSame("buf", bytes, arg0);
177                assertEquals("offset", offset, arg1);
178                assertEquals("len", len, arg2);
179                return status;
180            }
181        };
182        assertEquals("returned status", status, md.digest(bytes, offset, len));
183    }
184
185    /**
186     * @tests java.security.MessageDigest#isEqual(byte[],byte[])
187     */
188    public void test_isEqualLB$LB$() {
189        byte[] b1 = { 1, 2, 3, 4 };
190        byte[] b2 = { 1, 2, 3, 4, 5 };
191        byte[] b3 = { 1, 3, 3, 4 };
192        byte[] b4 = { 1, 2, 3, 4 };
193
194        assertTrue(MessageDigest.isEqual(b1, b4));
195        assertFalse(MessageDigest.isEqual(b1, b2));
196        assertFalse(MessageDigest.isEqual(b1, b3));
197    }
198
199    /**
200     * @tests java.security.MessageDigest#getAlgorithm()
201     */
202    public void test_getAlgorithm() {
203        MyMessageDigest1 md = new MyMessageDigest1("ABC");
204        assertEquals("ABC", md.getAlgorithm());
205    }
206
207    /**
208     * @tests java.security.MessageDigest#getProvider()
209     */
210    public void test_getProvider() {
211        MyMessageDigest1 md = new MyMessageDigest1("ABC");
212        assertNull(md.getProvider());
213    }
214
215    /**
216     * @tests java.security.MessageDigest#getDigestLength()
217     */
218    public void test_getDigestLength() {
219        MyMessageDigest1 md = new MyMessageDigest1("ABC");
220        assertEquals(0, md.getDigestLength());
221    }
222
223    /**
224     * Tests SHA MessageDigest provider
225     */
226    public void testSHAProvider() throws Exception {
227        MessageDigest md = MessageDigest.getInstance("SHA");
228        byte[] bytes = new byte[] { 1, 1, 1, 1, 1 };
229
230        // Regression for HARMONY-1120
231        // testing combination with provider
232        try {
233            // offset < 0
234            md.update(bytes, -1, 1);
235            fail("No expected IndexOutOfBoundsException");
236        } catch (IndexOutOfBoundsException e) {
237        }
238        // No exception for len < 0
239        md.update(bytes, 1, -1);
240
241        //Regression for Harmony-1148
242        md = MessageDigest.getInstance("SHA");
243        try {
244            // offset < 0
245            md.digest(bytes, 0, -1);
246            fail("No expected DigestException");
247        } catch (DigestException e) {
248        }
249        try {
250            // len < 0
251            md.digest(bytes, -1, 0);
252            fail("No expected DigestException");
253        } catch (DigestException e) {
254        }
255
256    }
257}
258