| /* |
| * 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. |
| */ |
| |
| /** |
| * @author Alexander Y. Kleymenov |
| * @version $Revision$ |
| */ |
| |
| package org.apache.harmony.crypto.tests.javax.crypto; |
| |
| import dalvik.annotation.TestTargetClass; |
| import dalvik.annotation.TestTargets; |
| import dalvik.annotation.TestLevel; |
| import dalvik.annotation.TestTargetNew; |
| |
| import java.io.ByteArrayInputStream; |
| import java.security.InvalidKeyException; |
| import java.security.Key; |
| import java.security.NoSuchAlgorithmException; |
| import java.security.SecureRandom; |
| |
| import javax.crypto.Cipher; |
| import javax.crypto.KeyGenerator; |
| import javax.crypto.NoSuchPaddingException; |
| import javax.crypto.NullCipher; |
| import javax.crypto.CipherInputStream; |
| |
| import junit.framework.TestCase; |
| |
| @TestTargetClass(CipherInputStream.class) |
| /** |
| */ |
| |
| public class CipherInputStream1Test extends TestCase { |
| |
| private static class TestInputStream extends ByteArrayInputStream { |
| private boolean closed = false; |
| |
| public TestInputStream(byte[] data) { |
| super(data); |
| } |
| |
| public void close() { |
| closed = true; |
| } |
| |
| public boolean wasClosed() { |
| return closed; |
| } |
| } |
| |
| /** |
| * CipherInputStream(InputStream is) method testing. Tests that |
| * CipherInputStream uses NullCipher if Cipher is not specified |
| * in the constructor. |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "CipherInputStream", |
| args = {java.io.InputStream.class} |
| ) |
| public void testCipherInputStream() throws Exception { |
| byte[] data = new byte[] { -127, -100, -50, -10, -1, 0, 1, 10, 50, 127 }; |
| TestInputStream tis = new TestInputStream(data); |
| CipherInputStream cis = new CipherInputStream(tis){}; |
| |
| for (int i = 0; i < data.length; i++) { |
| if ((byte) cis.read() != data[i]) { |
| fail("NullCipher should be used " |
| + "if Cipher is not specified."); |
| } |
| } |
| if (cis.read() != -1) { |
| fail("NullCipher should be used if Cipher is not specified."); |
| } |
| } |
| |
| /** |
| * read() method testing. Tests that method returns the correct value |
| * (related to the InputStream) and that it returns -1 at the end of stream. |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Can not check IOException.", |
| method = "read", |
| args = {} |
| ) |
| public void testRead1() throws Exception { |
| byte[] data = new byte[] { -127, -100, -50, -10, -1, 0, 1, 10, 50, 127 }; |
| TestInputStream tis = new TestInputStream(data); |
| CipherInputStream cis = new CipherInputStream(tis, new NullCipher()); |
| byte res; |
| for (int i = 0; i < data.length; i++) { |
| if ((res = (byte) cis.read()) != data[i]) { |
| fail("read() returned the incorrect value. " + "Expected: " |
| + data[i] + ", Got: " + res + "."); |
| } |
| } |
| if (cis.read() != -1) { |
| fail("read() should return -1 at the end of the stream."); |
| } |
| } |
| |
| /** |
| * read(byte[] b) method testing. Tests that method returns the correct |
| * value (related to the InputStream) and that it returns -1 at the end of |
| * stream. |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Can not check IOException.", |
| method = "read", |
| args = {byte[].class} |
| ) |
| public void testRead2() throws Exception { |
| byte[] data = new byte[] { -127, -100, -50, -10, -1, 0, 1, 10, 50, 127 }; |
| TestInputStream tis = new TestInputStream(data); |
| CipherInputStream cis = new CipherInputStream(tis, new NullCipher()); |
| |
| int expected = data.length; |
| byte[] result = new byte[expected]; |
| |
| int ind = 0; // index into the data array (to check the got data) |
| int got = cis.read(result); // the number of got bytes |
| while (true) { |
| for (int j = 0; j < got - ind; j++) { |
| if (result[j] != data[ind + j]) { |
| fail("read(byte[] b) returned incorrect data."); |
| } |
| } |
| if (got == expected) { |
| break; |
| } else if (got > expected) { |
| fail("The data returned by read(byte[] b) " |
| + "is larger than expected."); |
| } else { |
| ind = got; |
| got += cis.read(result); |
| } |
| } |
| if (cis.read(result) != -1) { |
| fail("read(byte[] b) should return -1 " |
| + "at the end of the stream."); |
| } |
| } |
| |
| /** |
| * read(byte[] b, int off, int len) method testing. Tests that method |
| * returns the correct value (related to the InputStream), that it discards |
| * bytes in the case of null buffer, and that it returns -1 at the end of |
| * stream. |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Can not check IOException.", |
| method = "read", |
| args = {byte[].class, int.class, int.class} |
| ) |
| public void testRead3() throws Exception { |
| byte[] data = new byte[] { -127, -100, -50, -10, -1, 0, 1, 10, 50, 127 }; |
| TestInputStream tis = new TestInputStream(data); |
| CipherInputStream cis = new CipherInputStream(tis, new NullCipher()); |
| |
| int expected = data.length; |
| byte[] result = new byte[expected]; |
| |
| int skip = 2; |
| int ind = skip; // index into the data array (to check the got data) |
| // should read and discard bytes; |
| cis.read(null, 0, skip); |
| int got = skip + cis.read(result, 0, 1); // the number of got bytes |
| while (true) { |
| for (int j = 0; j < got - ind; j++) { |
| assertEquals("read(byte[] b, int off, int len) " |
| + "returned incorrect data.", result[j], data[ind + j]); |
| } |
| if (got == expected) { |
| break; |
| } else if (got > expected) { |
| fail("The data returned by " |
| + "read(byte[] b, int off, int len) " |
| + "is larger than expected."); |
| } else { |
| ind = got; |
| got += cis.read(result, 0, 3); |
| } |
| } |
| if (cis.read(result, 0, 1) != -1) { |
| fail("read() should return -1 at the end of the stream."); |
| } |
| } |
| |
| /** |
| * skip(long n) method testing. Tests that the method correctly skips the |
| * bytes. |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Can not check IOException.", |
| method = "skip", |
| args = {long.class} |
| ) |
| public void testSkip() throws Exception { |
| byte[] data = new byte[] { -127, -100, -50, -10, -1, 0, 1, 10, 50, 127 }; |
| TestInputStream tis = new TestInputStream(data); |
| CipherInputStream cis = new CipherInputStream(tis, new NullCipher()); |
| int expected = data.length; |
| byte[] result = new byte[expected]; |
| |
| int skipped = (int) cis.skip(2); |
| int ind = skipped; |
| int got = skipped + cis.read(result, 0, 1); // the number of got bytes |
| while (true) { |
| for (int j = 0; j < got - ind; j++) { |
| if (result[j] != data[ind + j]) { |
| fail("read(byte[] b, int off, int len) " |
| + "returned incorrect data: Expected " |
| + data[ind + j] + ", got: " + result[j]); |
| } |
| } |
| if (got == expected) { |
| break; |
| } else if (got > expected) { |
| fail("The data returned by " |
| + "read(byte[] b, int off, int len) " |
| + "is larger than expected."); |
| } else { |
| ind = got; |
| got += cis.read(result, 0, 1); |
| } |
| } |
| if ((got = cis.read(result, 0, 1)) != -1) { |
| fail("read() should return -1 at the end of the stream. " |
| + "Output is: " + got + "."); |
| } |
| } |
| |
| /** |
| * available() method testing. Tests that the method always return 0. |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Can not check IOException.", |
| method = "available", |
| args = {} |
| ) |
| public void testAvailable() throws Exception { |
| byte[] data = new byte[] { -127, -100, -50, -10, -1, 0, 1, 10, 50, 127 }; |
| TestInputStream tis = new TestInputStream(data); |
| CipherInputStream cis = new CipherInputStream(tis, new NullCipher()); |
| assertEquals("The returned by available() method value " |
| + "should be 0.", cis.available(), 0); |
| } |
| |
| /** |
| * close() method testing. Tests that the method calls the close() |
| * method of the underlying input stream. |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Can not check IOException.", |
| method = "close", |
| args = {} |
| ) |
| public void testClose() throws Exception { |
| byte[] data = new byte[] { -127, -100, -50, -10, -1, 0, 1, 10, 50, 127 }; |
| TestInputStream tis = new TestInputStream(data); |
| CipherInputStream cis = new CipherInputStream(tis, new NullCipher()); |
| cis.close(); |
| assertTrue("The close() method should call the close() method " |
| + "of its underlying input stream.", tis.wasClosed()); |
| } |
| |
| /** |
| * markSupported() method testing. Tests that mark is not supported. |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "markSupported", |
| args = {} |
| ) |
| public void testMarkSupported() { |
| byte[] data = new byte[] {-127, -100, -50, -10, -1, 0, 1, 10, 50, 127}; |
| TestInputStream tis = new TestInputStream(data); |
| CipherInputStream cis = new CipherInputStream(tis, new NullCipher()); |
| assertFalse("The returned by markSupported() method value " |
| + "should be false.", cis.markSupported()); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "CipherInputStream", |
| args = {java.io.InputStream.class, javax.crypto.Cipher.class} |
| ) |
| public void test_ConstructorLjava_io_InputStreamLjavax_crypto_Cipher () throws |
| NoSuchAlgorithmException, NoSuchPaddingException, InvalidKeyException { |
| ByteArrayInputStream bais = new ByteArrayInputStream(new byte[100]); |
| |
| KeyGenerator kg = KeyGenerator.getInstance("DES"); |
| kg.init(56, new SecureRandom()); |
| Key key = kg.generateKey(); |
| |
| Cipher c = Cipher.getInstance("DES/CBC/NoPadding"); |
| c.init(Cipher.ENCRYPT_MODE, key); |
| |
| CipherInputStream cis = new CipherInputStream(bais, c); |
| |
| assertNotNull(cis); |
| } |
| |
| } |
| |