luni/src/test/java/org/apache/harmony/crypto/tests/javax/crypto/CipherSpiTest.java - platform/libcore-snapshot - Git at Google

 /*
  *  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 Vera Y. Petrashkova
 * @version $Revision$
 */

 package org.apache.harmony.crypto.tests.javax.crypto;

 import java.security.spec.AlgorithmParameterSpec;
 import java.security.InvalidAlgorithmParameterException;
 import java.security.InvalidKeyException;
 import java.security.Key;
 import java.security.NoSuchAlgorithmException;
 import java.security.SecureRandom;
 import java.security.AlgorithmParameters;
 import javax.crypto.BadPaddingException;
 import javax.crypto.IllegalBlockSizeException;
 import javax.crypto.NoSuchPaddingException;
 import javax.crypto.ShortBufferException;
 import javax.crypto.CipherSpi;
 import java.nio.ByteBuffer;

 import junit.framework.TestCase;


 /**
  * Tests for <code>CipherSpi</code> class constructors and methods.
  *
  */
 public class CipherSpiTest extends TestCase {
     class Mock_CipherSpi extends myCipherSpi {

         @Override
         protected byte[] engineDoFinal(byte[] input, int inputOffset, int inputLen)
                 throws IllegalBlockSizeException, BadPaddingException {
             return super.engineDoFinal(input, inputOffset, inputLen);
         }

         @Override
         protected int engineDoFinal(byte[] input, int inputOffset, int inputLen, byte[] output,
                 int outputOffset) throws ShortBufferException, IllegalBlockSizeException,
                 BadPaddingException {
             return super.engineDoFinal(input, inputOffset, inputLen, output, outputOffset);
         }

         @Override
         protected int engineGetBlockSize() {
             return super.engineGetBlockSize();
         }

         @Override
         protected byte[] engineGetIV() {
             return super.engineGetIV();
         }

         @Override
         protected int engineGetOutputSize(int inputLen) {
             return super.engineGetOutputSize(inputLen);
         }

         @Override
         protected AlgorithmParameters engineGetParameters() {
             return super.engineGetParameters();
         }

         @Override
         protected void engineInit(int opmode, Key key, SecureRandom random)
                 throws InvalidKeyException {
             super.engineInit(opmode, key, random);
         }

         @Override
         protected void engineInit(int opmode, Key key, AlgorithmParameterSpec params,
                 SecureRandom random) throws InvalidKeyException, InvalidAlgorithmParameterException {
             super.engineInit(opmode, key, params, random);
         }

         @Override
         protected void engineInit(int opmode, Key key, AlgorithmParameters params,
                 SecureRandom random) throws InvalidKeyException, InvalidAlgorithmParameterException {
             super.engineInit(opmode, key, params, random);
         }

         @Override
         protected void engineSetMode(String mode) throws NoSuchAlgorithmException {
             super.engineSetMode(mode);
         }

         @Override
         protected void engineSetPadding(String padding) throws NoSuchPaddingException {
             super.engineSetPadding(padding);
         }

         @Override
         protected byte[] engineUpdate(byte[] input, int inputOffset, int inputLen) {
             return super.engineUpdate(input, inputOffset, inputLen);
         }

         @Override
         protected int engineUpdate(byte[] input, int inputOffset, int inputLen, byte[] output,
                 int outputOffset) throws ShortBufferException {
             return super.engineUpdate(input, inputOffset, inputLen, output, outputOffset);
         }

         @Override
         protected int engineGetKeySize(Key key) throws InvalidKeyException {
             return super.engineGetKeySize(key);
         }

         @Override
         protected byte[] engineWrap(Key key) throws InvalidKeyException, IllegalBlockSizeException {
             return super.engineWrap(key);
         }

         @Override
         protected Key engineUnwrap(byte[] wrappedKey, String wrappedKeyAlgorithm, int wrappedKeyType)
                 throws InvalidKeyException, NoSuchAlgorithmException {
             return super.engineUnwrap(wrappedKey, wrappedKeyAlgorithm, wrappedKeyType);
         }
     }

     /**
      * Test for <code>CipherSpi</code> constructor
      * Assertion: constructs CipherSpi
      */
     public void testCipherSpiTests01() throws IllegalBlockSizeException,
             BadPaddingException, ShortBufferException {

         Mock_CipherSpi cSpi = new Mock_CipherSpi();
         assertEquals("BlockSize is not 0", cSpi.engineGetBlockSize(), 0);
         assertEquals("OutputSize is not 0", cSpi.engineGetOutputSize(1), 0);
         byte[] bb = cSpi.engineGetIV();
         assertEquals("Length of result byte array is not 0", bb.length, 0);
         assertNull("Not null result", cSpi.engineGetParameters());
         byte[] bb1 = new byte[10];
         byte[] bb2 = new byte[10];
         bb = cSpi.engineUpdate(bb1, 1, 2);
         assertEquals("Incorrect result of engineUpdate(byte, int, int)",
                 bb.length, 2);
         bb = cSpi.engineDoFinal(bb1, 1, 2);
         assertEquals("Incorrect result of engineDoFinal(byte, int, int)", 2,
                 bb.length);
         assertEquals(
                 "Incorrect result of engineUpdate(byte, int, int, byte, int)",
                 cSpi.engineUpdate(bb1, 1, 2, bb2, 7), 2);
         assertEquals(
                 "Incorrect result of engineDoFinal(byte, int, int, byte, int)",
                 2, cSpi.engineDoFinal(bb1, 1, 2, bb2, 0));
     }

     /**
      * Test for <code>engineGetKeySize(Key)</code> method
      * Assertion: It throws UnsupportedOperationException if it is not overridden
      */
     public void testCipherSpi02() throws Exception {
         Mock_CipherSpi cSpi = new Mock_CipherSpi();
         try {
             cSpi.engineGetKeySize(null);
             fail("UnsupportedOperationException must be thrown");
         } catch (UnsupportedOperationException e) {
         }
     }

     /**
      * Test for <code>engineWrap(Key)</code> method
      * Assertion: It throws UnsupportedOperationException if it is not overridden
      */
     public void testCipherSpi03() throws Exception {
         Mock_CipherSpi cSpi = new Mock_CipherSpi();
         try {
             cSpi.engineWrap(null);
             fail("UnsupportedOperationException must be thrown");
         } catch (UnsupportedOperationException e) {
         }
     }

     /**
      * Test for <code>engineUnwrap(byte[], String, int)</code> method
      * Assertion: It throws UnsupportedOperationException if it is not overridden
      */
     public void testCipherSpi04() throws Exception {
         Mock_CipherSpi cSpi = new Mock_CipherSpi();
         try {
             cSpi.engineUnwrap(new byte[0], "", 0);
             fail("UnsupportedOperationException must be thrown");
         } catch (UnsupportedOperationException e) {
         }
     }

     /**
      * Test for <code>engineUpdate(ByteBuffer, ByteBuffer)</code> method
      * Assertions:
      * throws NullPointerException if one of these buffers is null;
      * throws ShortBufferException is there is no space in output to hold result
      */
     public void testCipherSpi05() throws ShortBufferException {
         Mock_CipherSpi cSpi = new Mock_CipherSpi();
         byte[] bb = { (byte) 0, (byte) 1, (byte) 2, (byte) 3, (byte) 4,
                 (byte) 5, (byte) 6, (byte) 7, (byte) 8, (byte) 9, (byte) 10 };
         int pos = 5;
         int len = bb.length;
         ByteBuffer bbNull = null;
         ByteBuffer bb1 = ByteBuffer.allocate(len);
         bb1.put(bb);
         bb1.position(0);
         try {
             cSpi.engineUpdate(bbNull, bb1);
             fail("NullPointerException must be thrown");
         } catch (NullPointerException e) {
         }
         try {
             cSpi.engineUpdate(bb1, bbNull);
             fail("NullPointerException must be thrown");
         } catch (NullPointerException e) {
         }
         ByteBuffer bb2 = ByteBuffer.allocate(bb.length);
         bb1.position(len);
         assertEquals("Incorrect number of stored bytes", 0, cSpi.engineUpdate(
                 bb1, bb2));

         bb1.position(0);
         bb2.position(len - 2);
         try {
             cSpi.engineUpdate(bb1, bb2);
             fail("ShortBufferException bust be thrown. Output buffer remaining: "
                     .concat(Integer.toString(bb2.remaining())));
         } catch (ShortBufferException e) {
         }
         bb1.position(10);
         bb2.position(0);
         assertTrue("Incorrect number of stored bytes", cSpi.engineUpdate(bb1,
                 bb2) > 0);
         bb1.position(bb.length);
         cSpi.engineUpdate(bb1, bb2);

         bb1.position(pos);
         bb2.position(0);
         int res = cSpi.engineUpdate(bb1, bb2);
         assertTrue("Incorrect result", res > 0);
     }

     /**
      * Test for <code>engineDoFinal(ByteBuffer, ByteBuffer)</code> method
      * Assertions:
      * throws NullPointerException if one of these buffers is null;
      * throws ShortBufferException is there is no space in output to hold result
      */
     public void testCipherSpi06() throws BadPaddingException,
             ShortBufferException, IllegalBlockSizeException {
         Mock_CipherSpi cSpi = new Mock_CipherSpi();
         int len = 10;
         byte[] bbuf = new byte[len];
         for (int i = 0; i < bbuf.length; i++) {
             bbuf[i] = (byte) i;
         }
         ByteBuffer bb1 = ByteBuffer.wrap(bbuf);
         ByteBuffer bbNull = null;
         try {
             cSpi.engineDoFinal(bbNull, bb1);
             fail("NullPointerException must be thrown");
         } catch (NullPointerException e) {
         }
         try {
             cSpi.engineDoFinal(bb1, bbNull);
             fail("NullPointerException must be thrown");
         } catch (NullPointerException e) {
         }
         ByteBuffer bb2 = ByteBuffer.allocate(len);
         bb1.position(bb1.limit());
         assertEquals("Incorrect result", 0, cSpi.engineDoFinal(bb1, bb2));

         bb1.position(0);
         bb2.position(len - 2);
         try {
             cSpi.engineDoFinal(bb1, bb2);
             fail("ShortBufferException must be thrown. Output buffer remaining: "
                     .concat(Integer.toString(bb2.remaining())));
         } catch (ShortBufferException e) {
         }
         int pos = 5;
         bb1.position(pos);
         bb2.position(0);
         assertTrue("Incorrect result", cSpi.engineDoFinal(bb1, bb2) > 0);
     }
 }
 /**
  *
  * Additional class for CipherGeneratorSpi constructor verification
  */

 class myCipherSpi extends CipherSpi {
     private byte[] initV;

     private static byte[] resV = { (byte) 7, (byte) 6, (byte) 5, (byte) 4,
             (byte) 3, (byte) 2, (byte) 1, (byte) 0 };

     public myCipherSpi() {
         this.initV = new byte[0];
     }

     protected void engineSetMode(String mode) throws NoSuchAlgorithmException {
     }

     protected void engineSetPadding(String padding)
             throws NoSuchPaddingException {
     }

     protected int engineGetBlockSize() {
         return 0;
     }

     protected int engineGetOutputSize(int inputLen) {
         return 0;
     }

     protected byte[] engineGetIV() {
         return new byte[0];
     }

     protected AlgorithmParameters engineGetParameters() {
         return null;
     }

     protected void engineInit(int opmode, Key key, SecureRandom random)
             throws InvalidKeyException {
     }

     protected void engineInit(int opmode, Key key,
             AlgorithmParameterSpec params, SecureRandom random)
             throws InvalidKeyException, InvalidAlgorithmParameterException {
     }

     protected void engineInit(int opmode, Key key, AlgorithmParameters params,
             SecureRandom random) throws InvalidKeyException,
             InvalidAlgorithmParameterException {
     }

     protected byte[] engineUpdate(byte[] input, int inputOffset, int inputLen) {
         if (initV.length < inputLen) {
             initV = new byte[inputLen];
         }
         for (int i = 0; i < inputLen; i++) {
             initV[i] = input[inputOffset + i];
         }
         return initV;
     }

     protected int engineUpdate(byte[] input, int inputOffset, int inputLen,
             byte[] output, int outputOffset) throws ShortBufferException {
         byte []res = engineUpdate(input, inputOffset, inputLen);
         int t = res.length;
         if ((output.length - outputOffset) < t) {
             throw new ShortBufferException("Update");
         }
         for (int i = 0; i < t; i++) {
             output[i + outputOffset] = initV[i];
         }
         return t;
     }

     protected byte[] engineDoFinal(byte[] input, int inputOffset, int inputLen)
             throws IllegalBlockSizeException, BadPaddingException {
         if (resV.length > inputLen) {
             byte[] bb = new byte[inputLen];
             for (int i = 0; i < inputLen; i++) {
                 bb[i] = resV[i];
             }
             return bb;
         }
         return resV;
     }

     protected int engineDoFinal(byte[] input, int inputOffset, int inputLen,
             byte[] output, int outputOffset) throws ShortBufferException,
             IllegalBlockSizeException, BadPaddingException {
         byte[] res = engineDoFinal(input, inputOffset, inputLen);

         int t = res.length;
         if ((output.length - outputOffset) < t) {
             throw new ShortBufferException("DoFinal");
         }
         for (int i = 0; i < t; i++) {
             output[i + outputOffset] = res[i];
         }
         return t;
     }


     protected int engineUpdate(ByteBuffer input, ByteBuffer output)
     throws ShortBufferException {
         return super.engineUpdate(input, output);
     }
     protected int engineDoFinal(ByteBuffer input, ByteBuffer output)
     throws ShortBufferException, IllegalBlockSizeException,
     BadPaddingException {
         return super.engineDoFinal(input, output);
     }
 }
	/*
	* 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 Vera Y. Petrashkova
	* @version $Revision$
	*/

	package org.apache.harmony.crypto.tests.javax.crypto;

	import java.security.spec.AlgorithmParameterSpec;
	import java.security.InvalidAlgorithmParameterException;
	import java.security.InvalidKeyException;
	import java.security.Key;
	import java.security.NoSuchAlgorithmException;
	import java.security.SecureRandom;
	import java.security.AlgorithmParameters;
	import javax.crypto.BadPaddingException;
	import javax.crypto.IllegalBlockSizeException;
	import javax.crypto.NoSuchPaddingException;
	import javax.crypto.ShortBufferException;
	import javax.crypto.CipherSpi;
	import java.nio.ByteBuffer;

	import junit.framework.TestCase;


	/**
	* Tests for <code>CipherSpi</code> class constructors and methods.
	*
	*/
	public class CipherSpiTest extends TestCase {
	class Mock_CipherSpi extends myCipherSpi {

	@Override
	protected byte[] engineDoFinal(byte[] input, int inputOffset, int inputLen)
	throws IllegalBlockSizeException, BadPaddingException {
	return super.engineDoFinal(input, inputOffset, inputLen);
	}

	@Override
	protected int engineDoFinal(byte[] input, int inputOffset, int inputLen, byte[] output,
	int outputOffset) throws ShortBufferException, IllegalBlockSizeException,
	BadPaddingException {
	return super.engineDoFinal(input, inputOffset, inputLen, output, outputOffset);
	}

	@Override
	protected int engineGetBlockSize() {
	return super.engineGetBlockSize();
	}

	@Override
	protected byte[] engineGetIV() {
	return super.engineGetIV();
	}

	@Override
	protected int engineGetOutputSize(int inputLen) {
	return super.engineGetOutputSize(inputLen);
	}

	@Override
	protected AlgorithmParameters engineGetParameters() {
	return super.engineGetParameters();
	}

	@Override
	protected void engineInit(int opmode, Key key, SecureRandom random)
	throws InvalidKeyException {
	super.engineInit(opmode, key, random);
	}

	@Override
	protected void engineInit(int opmode, Key key, AlgorithmParameterSpec params,
	SecureRandom random) throws InvalidKeyException, InvalidAlgorithmParameterException {
	super.engineInit(opmode, key, params, random);
	}

	@Override
	protected void engineInit(int opmode, Key key, AlgorithmParameters params,
	SecureRandom random) throws InvalidKeyException, InvalidAlgorithmParameterException {
	super.engineInit(opmode, key, params, random);
	}

	@Override
	protected void engineSetMode(String mode) throws NoSuchAlgorithmException {
	super.engineSetMode(mode);
	}

	@Override
	protected void engineSetPadding(String padding) throws NoSuchPaddingException {
	super.engineSetPadding(padding);
	}

	@Override
	protected byte[] engineUpdate(byte[] input, int inputOffset, int inputLen) {
	return super.engineUpdate(input, inputOffset, inputLen);
	}

	@Override
	protected int engineUpdate(byte[] input, int inputOffset, int inputLen, byte[] output,
	int outputOffset) throws ShortBufferException {
	return super.engineUpdate(input, inputOffset, inputLen, output, outputOffset);
	}

	@Override
	protected int engineGetKeySize(Key key) throws InvalidKeyException {
	return super.engineGetKeySize(key);
	}

	@Override
	protected byte[] engineWrap(Key key) throws InvalidKeyException, IllegalBlockSizeException {
	return super.engineWrap(key);
	}

	@Override
	protected Key engineUnwrap(byte[] wrappedKey, String wrappedKeyAlgorithm, int wrappedKeyType)
	throws InvalidKeyException, NoSuchAlgorithmException {
	return super.engineUnwrap(wrappedKey, wrappedKeyAlgorithm, wrappedKeyType);
	}
	}

	/**
	* Test for <code>CipherSpi</code> constructor
	* Assertion: constructs CipherSpi
	*/
	public void testCipherSpiTests01() throws IllegalBlockSizeException,
	BadPaddingException, ShortBufferException {

	Mock_CipherSpi cSpi = new Mock_CipherSpi();
	assertEquals("BlockSize is not 0", cSpi.engineGetBlockSize(), 0);
	assertEquals("OutputSize is not 0", cSpi.engineGetOutputSize(1), 0);
	byte[] bb = cSpi.engineGetIV();
	assertEquals("Length of result byte array is not 0", bb.length, 0);
	assertNull("Not null result", cSpi.engineGetParameters());
	byte[] bb1 = new byte[10];
	byte[] bb2 = new byte[10];
	bb = cSpi.engineUpdate(bb1, 1, 2);
	assertEquals("Incorrect result of engineUpdate(byte, int, int)",
	bb.length, 2);
	bb = cSpi.engineDoFinal(bb1, 1, 2);
	assertEquals("Incorrect result of engineDoFinal(byte, int, int)", 2,
	bb.length);
	assertEquals(
	"Incorrect result of engineUpdate(byte, int, int, byte, int)",
	cSpi.engineUpdate(bb1, 1, 2, bb2, 7), 2);
	assertEquals(
	"Incorrect result of engineDoFinal(byte, int, int, byte, int)",
	2, cSpi.engineDoFinal(bb1, 1, 2, bb2, 0));
	}

	/**
	* Test for <code>engineGetKeySize(Key)</code> method
	* Assertion: It throws UnsupportedOperationException if it is not overridden
	*/
	public void testCipherSpi02() throws Exception {
	Mock_CipherSpi cSpi = new Mock_CipherSpi();
	try {
	cSpi.engineGetKeySize(null);
	fail("UnsupportedOperationException must be thrown");
	} catch (UnsupportedOperationException e) {
	}
	}

	/**
	* Test for <code>engineWrap(Key)</code> method
	* Assertion: It throws UnsupportedOperationException if it is not overridden
	*/
	public void testCipherSpi03() throws Exception {
	Mock_CipherSpi cSpi = new Mock_CipherSpi();
	try {
	cSpi.engineWrap(null);
	fail("UnsupportedOperationException must be thrown");
	} catch (UnsupportedOperationException e) {
	}
	}

	/**
	* Test for <code>engineUnwrap(byte[], String, int)</code> method
	* Assertion: It throws UnsupportedOperationException if it is not overridden
	*/
	public void testCipherSpi04() throws Exception {
	Mock_CipherSpi cSpi = new Mock_CipherSpi();
	try {
	cSpi.engineUnwrap(new byte[0], "", 0);
	fail("UnsupportedOperationException must be thrown");
	} catch (UnsupportedOperationException e) {
	}
	}

	/**
	* Test for <code>engineUpdate(ByteBuffer, ByteBuffer)</code> method
	* Assertions:
	* throws NullPointerException if one of these buffers is null;
	* throws ShortBufferException is there is no space in output to hold result
	*/
	public void testCipherSpi05() throws ShortBufferException {
	Mock_CipherSpi cSpi = new Mock_CipherSpi();
	byte[] bb = { (byte) 0, (byte) 1, (byte) 2, (byte) 3, (byte) 4,
	(byte) 5, (byte) 6, (byte) 7, (byte) 8, (byte) 9, (byte) 10 };
	int pos = 5;
	int len = bb.length;
	ByteBuffer bbNull = null;
	ByteBuffer bb1 = ByteBuffer.allocate(len);
	bb1.put(bb);
	bb1.position(0);
	try {
	cSpi.engineUpdate(bbNull, bb1);
	fail("NullPointerException must be thrown");
	} catch (NullPointerException e) {
	}
	try {
	cSpi.engineUpdate(bb1, bbNull);
	fail("NullPointerException must be thrown");
	} catch (NullPointerException e) {
	}
	ByteBuffer bb2 = ByteBuffer.allocate(bb.length);
	bb1.position(len);
	assertEquals("Incorrect number of stored bytes", 0, cSpi.engineUpdate(
	bb1, bb2));

	bb1.position(0);
	bb2.position(len - 2);
	try {
	cSpi.engineUpdate(bb1, bb2);
	fail("ShortBufferException bust be thrown. Output buffer remaining: "
	.concat(Integer.toString(bb2.remaining())));
	} catch (ShortBufferException e) {
	}
	bb1.position(10);
	bb2.position(0);
	assertTrue("Incorrect number of stored bytes", cSpi.engineUpdate(bb1,
	bb2) > 0);
	bb1.position(bb.length);
	cSpi.engineUpdate(bb1, bb2);

	bb1.position(pos);
	bb2.position(0);
	int res = cSpi.engineUpdate(bb1, bb2);
	assertTrue("Incorrect result", res > 0);
	}

	/**
	* Test for <code>engineDoFinal(ByteBuffer, ByteBuffer)</code> method
	* Assertions:
	* throws NullPointerException if one of these buffers is null;
	* throws ShortBufferException is there is no space in output to hold result
	*/
	public void testCipherSpi06() throws BadPaddingException,
	ShortBufferException, IllegalBlockSizeException {
	Mock_CipherSpi cSpi = new Mock_CipherSpi();
	int len = 10;
	byte[] bbuf = new byte[len];
	for (int i = 0; i < bbuf.length; i++) {
	bbuf[i] = (byte) i;
	}
	ByteBuffer bb1 = ByteBuffer.wrap(bbuf);
	ByteBuffer bbNull = null;
	try {
	cSpi.engineDoFinal(bbNull, bb1);
	fail("NullPointerException must be thrown");
	} catch (NullPointerException e) {
	}
	try {
	cSpi.engineDoFinal(bb1, bbNull);
	fail("NullPointerException must be thrown");
	} catch (NullPointerException e) {
	}
	ByteBuffer bb2 = ByteBuffer.allocate(len);
	bb1.position(bb1.limit());
	assertEquals("Incorrect result", 0, cSpi.engineDoFinal(bb1, bb2));

	bb1.position(0);
	bb2.position(len - 2);
	try {
	cSpi.engineDoFinal(bb1, bb2);
	fail("ShortBufferException must be thrown. Output buffer remaining: "
	.concat(Integer.toString(bb2.remaining())));
	} catch (ShortBufferException e) {
	}
	int pos = 5;
	bb1.position(pos);
	bb2.position(0);
	assertTrue("Incorrect result", cSpi.engineDoFinal(bb1, bb2) > 0);
	}
	}
	/**
	*
	* Additional class for CipherGeneratorSpi constructor verification
	*/

	class myCipherSpi extends CipherSpi {
	private byte[] initV;

	private static byte[] resV = { (byte) 7, (byte) 6, (byte) 5, (byte) 4,
	(byte) 3, (byte) 2, (byte) 1, (byte) 0 };

	public myCipherSpi() {
	this.initV = new byte[0];
	}

	protected void engineSetMode(String mode) throws NoSuchAlgorithmException {
	}

	protected void engineSetPadding(String padding)
	throws NoSuchPaddingException {
	}

	protected int engineGetBlockSize() {
	return 0;
	}

	protected int engineGetOutputSize(int inputLen) {
	return 0;
	}

	protected byte[] engineGetIV() {
	return new byte[0];
	}

	protected AlgorithmParameters engineGetParameters() {
	return null;
	}

	protected void engineInit(int opmode, Key key, SecureRandom random)
	throws InvalidKeyException {
	}

	protected void engineInit(int opmode, Key key,
	AlgorithmParameterSpec params, SecureRandom random)
	throws InvalidKeyException, InvalidAlgorithmParameterException {
	}

	protected void engineInit(int opmode, Key key, AlgorithmParameters params,
	SecureRandom random) throws InvalidKeyException,
	InvalidAlgorithmParameterException {
	}

	protected byte[] engineUpdate(byte[] input, int inputOffset, int inputLen) {
	if (initV.length < inputLen) {
	initV = new byte[inputLen];
	}
	for (int i = 0; i < inputLen; i++) {
	initV[i] = input[inputOffset + i];
	}
	return initV;
	}

	protected int engineUpdate(byte[] input, int inputOffset, int inputLen,
	byte[] output, int outputOffset) throws ShortBufferException {
	byte []res = engineUpdate(input, inputOffset, inputLen);
	int t = res.length;
	if ((output.length - outputOffset) < t) {
	throw new ShortBufferException("Update");
	}
	for (int i = 0; i < t; i++) {
	output[i + outputOffset] = initV[i];
	}
	return t;
	}

	protected byte[] engineDoFinal(byte[] input, int inputOffset, int inputLen)
	throws IllegalBlockSizeException, BadPaddingException {
	if (resV.length > inputLen) {
	byte[] bb = new byte[inputLen];
	for (int i = 0; i < inputLen; i++) {
	bb[i] = resV[i];
	}
	return bb;
	}
	return resV;
	}

	protected int engineDoFinal(byte[] input, int inputOffset, int inputLen,
	byte[] output, int outputOffset) throws ShortBufferException,
	IllegalBlockSizeException, BadPaddingException {
	byte[] res = engineDoFinal(input, inputOffset, inputLen);

	int t = res.length;
	if ((output.length - outputOffset) < t) {
	throw new ShortBufferException("DoFinal");
	}
	for (int i = 0; i < t; i++) {
	output[i + outputOffset] = res[i];
	}
	return t;
	}


	protected int engineUpdate(ByteBuffer input, ByteBuffer output)
	throws ShortBufferException {
	return super.engineUpdate(input, output);
	}
	protected int engineDoFinal(ByteBuffer input, ByteBuffer output)
	throws ShortBufferException, IllegalBlockSizeException,
	BadPaddingException {
	return super.engineDoFinal(input, output);
	}
	}