android-platform-libcore/luni/src/test/java/org/apache/harmony/security/tests/java/security/DigestOutputStreamTest.java - nest-cam/4320010/android-platform-libcore - 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 Vladimir N. Molotkov
 * @version $Revision$
 */

 package org.apache.harmony.security.tests.java.security;

 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.OutputStream;
 import java.security.DigestOutputStream;
 import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
 import java.util.Arrays;
 import junit.framework.TestCase;
 import org.apache.harmony.security.tests.support.MDGoldenData;
 import org.apache.harmony.security.tests.support.MyMessageDigest1;
 import tests.support.Support_OutputStream;

 /**
  * Tests for fields and methods of class <code>DigestInputStream</code>
  *
  */
 public class DigestOutputStreamTest extends TestCase {

     /**
      * Message digest algorithm name used during testing
      */
     private static final String algorithmName[] = {
             "SHA-1",
             "SHA",
             "SHA1",
             "SHA-256",
             "SHA-384",
             "SHA-512",
             "MD5",
     };
     /**
      * Chunk size for read(byte, off, len) tests
      */
     private static final int CHUNK_SIZE = 32;
     /**
      * Test message for digest computations
      */
     private static final byte[] myMessage = MDGoldenData.getMessage();
     /**
      * The length of test message
      */
     private static final int MY_MESSAGE_LEN = myMessage.length;

     //
     // Tests
     //

     /**
      * java.security.DigestOutputStream#DigestOutputStream(java.io.OutputStream,
      *        java.security.MessageDigest)
      */
     public void test_CtorLjava_io_OutputStreamLjava_security_MessageDigest() {

         // non-null parameters
         MessageDigest md = new MyMessageDigest1();
         MyOutputStream out = new MyOutputStream();

         MyDigestOutputStream dos = new MyDigestOutputStream(out, md);
         assertSame(out, dos.myOutputStream());
         assertSame(md, dos.myMessageDigest());

         // null parameters
         dos = new MyDigestOutputStream(null, null);
         assertNull(dos.myOutputStream());
         assertNull(dos.myMessageDigest());

         dos = new MyDigestOutputStream(null, md);
         assertNull(dos.myOutputStream());
         assertNotNull(dos.myMessageDigest());

         dos = new MyDigestOutputStream(out, null);
         assertNotNull(dos.myOutputStream());
         assertNull(dos.myMessageDigest());
     }

     /**
      * java.security.DigestOutputStream#getMessageDigest()
      */
     public void test_getMessageDigest() {

         MessageDigest digest = new MyMessageDigest1();
         OutputStream out = new MyOutputStream();

         // non-null parameter
         DigestOutputStream dos = new DigestOutputStream(out, digest);
         assertSame(digest, dos.getMessageDigest());

         // null parameter
         dos = new DigestOutputStream(out, null);
         assertNull("getMessageDigest should have returned null", dos.getMessageDigest());
     }

     /**
      * java.security.DigestOutputStream#setMessageDigest(MessageDigest)
      */
     public void test_setMessageDigestLjava_security_MessageDigest() {

         MessageDigest digest = new MyMessageDigest1();
         OutputStream out = new MyOutputStream();

         DigestOutputStream dos = new DigestOutputStream(out, null);

         // non-null parameter
         dos.setMessageDigest(digest);
         assertSame(digest, dos.getMessageDigest());

         // null parameter
         dos.setMessageDigest(null);
         assertNull("getMessageDigest should have returned null", dos.getMessageDigest());
     }


     /**
      * Test #1 for <code>write(int)</code> method<br>
      *
      * Assertion: writes the byte to the output stream<br>
      * Assertion: updates associated digest<br>
      */
     public final void testWriteint01()
         throws IOException {
         for (int k=0; k<algorithmName.length; k++) {
             try {
                 MessageDigest md = MessageDigest.getInstance(algorithmName[k]);
                 ByteArrayOutputStream bos = new ByteArrayOutputStream(MY_MESSAGE_LEN);
                 DigestOutputStream dos = new DigestOutputStream(bos, md);
                 for (int i=0; i<MY_MESSAGE_LEN; i++) {
                     dos.write(myMessage[i]);
                 }
                 // check that bytes have been written correctly
                 assertTrue("write", Arrays.equals(MDGoldenData.getMessage(), bos.toByteArray()));
                 // check that associated digest has been updated properly
                 assertTrue("update", Arrays.equals(dos.getMessageDigest().digest(),
                                                    MDGoldenData.getDigest(algorithmName[k])));
                 return;
             } catch (NoSuchAlgorithmException e) {
                 // allowed failure
             }
         }
         fail(getName() + ": no MessageDigest algorithms available - test not performed");
     }

     /**
      * Test #2 for <code>write(int)</code> method<br>
      * Test #1 for <code>on(boolean)</code> method<br>
      *
      * Assertion: <code>write(int)</code> must not update digest if it is off<br>
      * Assertion: <code>on(boolean)</code> turns digest functionality on
      * if <code>true</code> passed as a parameter or off if <code>false</code>
      * passed
      */
     public final void testWriteint02()
         throws IOException {
         for (int k=0; k<algorithmName.length; k++) {
             try {
                 MessageDigest md = MessageDigest.getInstance(algorithmName[k]);
                 ByteArrayOutputStream bos = new ByteArrayOutputStream(MY_MESSAGE_LEN);
                 DigestOutputStream dos = new DigestOutputStream(bos, md);

                 // turn digest off
                 dos.on(false);

                 for (int i=0; i<MY_MESSAGE_LEN; i++) {
                     dos.write(myMessage[i]);
                 }

                 // check that bytes have been written correctly
                 assertTrue("write", Arrays.equals(MDGoldenData.getMessage(), bos.toByteArray()));
                 // check that digest value has not been updated by write()
                 assertTrue("update", Arrays.equals(dos.getMessageDigest().digest(),
                                                    MDGoldenData.getDigest(algorithmName[k]+"_NU")));
                 return;
             } catch (NoSuchAlgorithmException e) {
                 // allowed failure
             }
         }
         fail(getName() + ": no MessageDigest algorithms available - test not performed");
     }

     /**
      * Test #3 for <code>write(int)</code> method<br>
      *
      * Assertion: broken <code>DigestOutputStream</code>instance:
      * <code>OutputStream</code> not set. <code>write(int)</code> must
      * not work
      */
     public final void testWriteint03() throws IOException {
         for (int k=0; k<algorithmName.length; k++) {
             try {
                 MessageDigest md = MessageDigest.getInstance(algorithmName[k]);
                 DigestOutputStream dos = new DigestOutputStream(null, md);
                 // must result in an exception
                 try {
                     for (int i=0; i<MY_MESSAGE_LEN; i++) {
                         dos.write(myMessage[i]);
                     }
                     fail("OutputStream not set. write(int) must not work");
                 } catch (Exception e) {
                     return;
                 }
             } catch (NoSuchAlgorithmException e) {
                 // allowed failure
             }
         }
         fail(getName() + ": no MessageDigest algorithms available - test not performed");
     }

     /**
      * Test #4 for <code>write(int)</code> method<br>
      *
      * Assertion: broken <code>DigestOutputStream</code>instance:
      * associated <code>MessageDigest</code> not set.
      * <code>write(int)</code> must not work when digest
      * functionality is on
      */
     public final void testWriteint04() throws IOException {
         OutputStream os = new ByteArrayOutputStream(MY_MESSAGE_LEN);
         DigestOutputStream dos = new DigestOutputStream(os, null);

         // must result in an exception
         try {
             for (int i=0; i<MY_MESSAGE_LEN; i++) {
                 dos.write(myMessage[i]);
             }
             fail("OutputStream not set. write(int) must not work");
         } catch (Exception e) {
             return;
         }
     }

     /**
      * Test #5 for <code>write(int)</code> method<br>
      * Test #2 for <code>on(boolean)</code> method<br>
      *
      * Assertion: broken <code>DigestOutputStream</code>instance:
      * associated <code>MessageDigest</code> not set.
      * <code>write(int)</code> must work when digest
      * functionality is off
      */
     public final void testWriteint05() throws IOException {
         ByteArrayOutputStream bos = new ByteArrayOutputStream(MY_MESSAGE_LEN);
         DigestOutputStream dos = new DigestOutputStream(bos, null);
         // set digest functionality to off
         dos.on(false);
         // the following must pass without any exception
         for (int i=0; i<MY_MESSAGE_LEN; i++) {
             dos.write(myMessage[i]);
         }
         // check that bytes have been written correctly
         assertTrue(Arrays.equals(MDGoldenData.getMessage(), bos.toByteArray()));
     }

     /**
      * Test #1 for <code>write(byte[],int,int)</code> method<br>
      *
      * Assertion: put bytes into output stream<br>
      *
      * Assertion: updates associated digest<br>
      */
     public final void test_write$BII_1() throws IOException {
         for (int k=0; k<algorithmName.length; k++) {
             try {
                 ByteArrayOutputStream bos = new ByteArrayOutputStream(MY_MESSAGE_LEN);
                 MessageDigest md = MessageDigest.getInstance(algorithmName[k]);
                 DigestOutputStream dos = new DigestOutputStream(bos, md);

                 // write message at once
                 dos.write(myMessage, 0, MY_MESSAGE_LEN);

                 // check write
                 assertTrue("write", Arrays.equals(myMessage, bos.toByteArray()));
                 // check that associated digest has been updated properly
                 assertTrue("update", Arrays.equals(dos.getMessageDigest().digest(),
                                                    MDGoldenData.getDigest(algorithmName[k])));
                 return;
             } catch (NoSuchAlgorithmException e) {
                 // allowed failure
             }
         }
         fail(getName() + ": no MessageDigest algorithms available - test not performed");
     }

     /**
      * Test #2 for <code>write(byte[],int,int)</code> method<br>
      *
      * Assertion: put bytes into output stream<br>
      *
      * Assertion: updates associated digest<br>
      */
     public final void test_write$BII_2() throws IOException {
         // check precondition
         assertEquals(0, MY_MESSAGE_LEN % CHUNK_SIZE);
         for (int k=0; k<algorithmName.length; k++) {
             try {

                 ByteArrayOutputStream bos = new ByteArrayOutputStream(MY_MESSAGE_LEN);
                 MessageDigest md = MessageDigest.getInstance(algorithmName[k]);
                 DigestOutputStream dos = new DigestOutputStream(bos, md);

                 // write message by chunks
                 for (int i=0; i<MY_MESSAGE_LEN/CHUNK_SIZE; i++) {
                     dos.write(myMessage, i*CHUNK_SIZE, CHUNK_SIZE);
                 }
                 // check write
                 assertTrue("write", Arrays.equals(myMessage, bos.toByteArray()));
                 // check that associated digest has been updated properly
                 assertTrue("update", Arrays.equals(dos.getMessageDigest().digest(),
                         MDGoldenData.getDigest(algorithmName[k])));
                 return;
             } catch (NoSuchAlgorithmException e) {
                 // allowed failure
             }
         }
         fail(getName() + ": no MessageDigest algorithms available - test not performed");
     }


     /**
      * Test #3 for <code>write(byte[],int,int)</code> method<br>
      *
      * Assertion: put bytes into output stream<br>
      *
      * Assertion: updates associated digest<br>
      */
     public final void test_write$BII_3()
         throws NoSuchAlgorithmException,
                IOException {
         // check precondition
         assertTrue(MY_MESSAGE_LEN % (CHUNK_SIZE+1) != 0);

         for (int k=0; k<algorithmName.length; k++) {
             try {
                 ByteArrayOutputStream bos = new ByteArrayOutputStream(MY_MESSAGE_LEN);
                 MessageDigest md = MessageDigest.getInstance(algorithmName[k]);
                 DigestOutputStream dos = new DigestOutputStream(bos, md);

                 // write message by chunks
                 for (int i=0; i<MY_MESSAGE_LEN/(CHUNK_SIZE+1); i++) {
                     dos.write(myMessage, i*(CHUNK_SIZE+1), CHUNK_SIZE+1);
                 }
                 // write remaining bytes
                 dos.write(myMessage,
                         MY_MESSAGE_LEN/(CHUNK_SIZE+1)*(CHUNK_SIZE+1),
                         MY_MESSAGE_LEN % (CHUNK_SIZE+1));
                 // check write
                 assertTrue("write", Arrays.equals(myMessage, bos.toByteArray()));
                 // check that associated digest has been updated properly
                 assertTrue("update", Arrays.equals(dos.getMessageDigest().digest(),
                         MDGoldenData.getDigest(algorithmName[k])));
                 return;
             } catch (NoSuchAlgorithmException e) {
                 // allowed failure
             }
         }
         fail(getName() + ": no MessageDigest algorithms available - test not performed");
     }

     /**
      * Test #4 for <code>write(byte[],int,int)</code> method<br>
      *
      * Assertion: put bytes into output stream<br>
      *
      * Assertion: does not update associated digest if digest
      * functionality is off<br>
      */
     public final void test_write$BII_4()
         throws NoSuchAlgorithmException,
                IOException {
         // check precondition
         assertEquals(0, MY_MESSAGE_LEN % CHUNK_SIZE);

         for (int k=0; k<algorithmName.length; k++) {
             try {
                 ByteArrayOutputStream bos = new ByteArrayOutputStream(MY_MESSAGE_LEN);
                 MessageDigest md = MessageDigest.getInstance(algorithmName[k]);
                 DigestOutputStream dos = new DigestOutputStream(bos, md);

                 // set digest functionality off
                 dos.on(false);

                 // write message by chunks
                 for (int i=0; i<MY_MESSAGE_LEN/CHUNK_SIZE; i++) {
                     dos.write(myMessage, i*CHUNK_SIZE, CHUNK_SIZE);
                 }

                 // check write
                 assertTrue("write", Arrays.equals(myMessage, bos.toByteArray()));
                 // check that associated digest has not been updated
                 assertTrue("update", Arrays.equals(dos.getMessageDigest().digest(),
                         MDGoldenData.getDigest(algorithmName[k]+"_NU")));
                 return;
             } catch (NoSuchAlgorithmException e) {
                 // allowed failure
             }
         }
         fail(getName() + ": no MessageDigest algorithms available - test not performed");
     }

     /**
      * java.security.DigestOutputStream#write(byte[], int, int)
      */
     public void test_write$BII_6() throws Exception {

         // Regression form HARMONY-1091.
         MessageDigest md = new MyMessageDigest1();
         byte[] bytes = new byte[] { 1, 2 };
         DigestOutputStream dig = new DigestOutputStream(
                 new ByteArrayOutputStream(), md);
         // buf == null
         try {
             dig.write(null, -1, 0);
             fail("No expected IllegalArgumentException");
         } catch (IllegalArgumentException e) {
         }
         // offset + len > buf.length
         try {
             dig.write(bytes, 0, bytes.length + 1);
             fail("No expected IllegalArgumentException");
         } catch (IllegalArgumentException e) {
         }
         // offset < 0
         try {
             dig.write(bytes, -1, 1);
             fail("No expected IndexOutOfBoundsException");
         } catch (IndexOutOfBoundsException e) {
         }
         // len < 0
         try {
             dig.write(bytes, 0, -1);
             fail("No expected IndexOutOfBoundsException");
         } catch (IndexOutOfBoundsException e) {
         }
     }

     /**
      * java.io.DigestOutputStream#write(byte[], int, int)
      */
     public void test_write$BII_7()
         throws IOException, NoSuchAlgorithmException {
         Support_OutputStream sos = new Support_OutputStream(MY_MESSAGE_LEN);
         MessageDigest md = MessageDigest.getInstance(algorithmName[0]);
         DigestOutputStream dos = new DigestOutputStream(sos, md);

         dos.write(myMessage, 0, MY_MESSAGE_LEN);

         try {
             // Support_OutputStream throws an IOException if the internal
             // buffer is full, which it should be now.
             dos.write(myMessage, 0, MY_MESSAGE_LEN);
             fail("Test 1: IOException expected.");
         } catch (IOException e) {
             // Expected.
         }
     }

     /**
      * Test for <code>on()</code> method<br>
      * Assertion: turns digest functionality on or off
      */
     public final void testOn() throws IOException {
         for (int k=0; k<algorithmName.length; k++) {
             try {
                 ByteArrayOutputStream bos = new ByteArrayOutputStream(MY_MESSAGE_LEN);
                 MessageDigest md = MessageDigest.getInstance(algorithmName[k]);
                 DigestOutputStream dos = new DigestOutputStream(bos, md);

                 // turn digest off
                 dos.on(false);

                 for (int i=0; i<MY_MESSAGE_LEN-1; i++) {
                     dos.write(myMessage[i]);
                 }

                 // turn digest on
                 dos.on(true);

                 // read remaining byte
                 dos.write(myMessage[MY_MESSAGE_LEN-1]);

                 byte[] digest = dos.getMessageDigest().digest();

                 // check that digest value has been
                 // updated by the last write(int) call
                 assertFalse(Arrays.equals(digest,MDGoldenData.getDigest(algorithmName[k])));
                 assertFalse(Arrays.equals(digest,MDGoldenData.getDigest(algorithmName[k]+"_NU")));
                 return;
             } catch (NoSuchAlgorithmException e) {
                 // allowed failure
             }
         }
         fail(getName() + ": no MessageDigest algorithms available - test not performed");
     }

     /**
      * Test for <code>toString()</code> method<br>
      * Assertion: returns <code>String</code> representation of this object
      */
     public final void testToString() throws NoSuchAlgorithmException {
         for (int k=0; k<algorithmName.length; k++) {
             try {
                 ByteArrayOutputStream bos = new ByteArrayOutputStream(MY_MESSAGE_LEN);
                 MessageDigest md = MessageDigest.getInstance(algorithmName[k]);
                 DigestOutputStream dos = new DigestOutputStream(bos, md);

                 assertNotNull(dos.toString());
                 return;
             } catch (NoSuchAlgorithmException e) {
                 // allowed failure
             }
         }
         fail(getName() + ": no MessageDigest algorithms available - test not performed");
     }

     /**
      * java.security.DigestOutputStream#on(boolean)
      */
     public void test_onZ() throws Exception {
         // Test for method void java.security.DigestOutputStream.on(boolean)
         DigestOutputStream dos = new DigestOutputStream(
                 new ByteArrayOutputStream(), MessageDigest.getInstance("SHA"));
         dos.on(false);
         byte digestArray[] = { 23, 43, 44 };
         dos.write(digestArray, 1, 1);
         byte digestResult[] = dos.getMessageDigest().digest();
         byte expected[] = { -38, 57, -93, -18, 94, 107, 75, 13, 50, 85,
                 -65, -17, -107, 96, 24, -112, -81, -40, 7, 9 };
         assertTrue("Digest did not return expected result.",
                    Arrays.equals(digestResult, expected));
         // now turn on processing and re-run
         dos.on(true);
         dos.write(digestArray, 1, 1);
         digestResult = dos.getMessageDigest().digest();
         byte expected1[] = { -87, 121, -17, 16, -52, 111, 106, 54, -33,
                 107, -118, 50, 51, 7, -18, 59, -78, -30, -37, -100 };

         assertTrue("Digest did not return expected result.",
                    Arrays.equals(digestResult, expected1));
     }

     /**
      * java.security.DigestOutputStream#write(byte[], int, int)
      */
     public void test_write$BII_5() throws Exception {
         // Test for method void java.security.DigestOutputStream.write(byte [],
         // int, int)
             DigestOutputStream dos = new DigestOutputStream(
                 new ByteArrayOutputStream(), MessageDigest.getInstance("SHA"));
             byte digestArray[] = { 23, 43, 44 };
             dos.write(digestArray, 1, 1);
             byte digestResult[] = dos.getMessageDigest().digest();
             byte expected[] = { -87, 121, -17, 16, -52, 111, 106, 54, -33, 107,
                     -118, 50, 51, 7, -18, 59, -78, -30, -37, -100 };

             assertTrue("Digest did not return expected result.",
                        Arrays.equals(digestResult, expected));
     }

     /**
      * java.security.DigestOutputStream#write(int)
      */
     public void test_writeI() throws Exception {
         // Test for method void java.security.DigestOutputStream.write(int)
             DigestOutputStream dos = new DigestOutputStream(
                 new ByteArrayOutputStream(), MessageDigest.getInstance("SHA"));
             dos.write((byte) 43);
             byte digestResult[] = dos.getMessageDigest().digest();
             byte expected[] = { -87, 121, -17, 16, -52, 111, 106, 54, -33, 107,
                     -118, 50, 51, 7, -18, 59, -78, -30, -37, -100 };

             assertTrue("Digest did not return expected result.",
                        Arrays.equals(digestResult, expected));
     }


     private class MyOutputStream extends OutputStream {
         @Override
         public void write(int arg0) throws IOException {
         }
     }

     private class MyDigestOutputStream extends DigestOutputStream {
         public MyDigestOutputStream(OutputStream out, MessageDigest digest) {
             super(out, digest);
         }

         public MessageDigest myMessageDigest() {
             return digest;
         }

         public OutputStream myOutputStream() {
             return out;
         }
     }
 }
	/*
	* 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 Vladimir N. Molotkov
	* @version $Revision$
	*/

	package org.apache.harmony.security.tests.java.security;

	import java.io.ByteArrayOutputStream;
	import java.io.IOException;
	import java.io.OutputStream;
	import java.security.DigestOutputStream;
	import java.security.MessageDigest;
	import java.security.NoSuchAlgorithmException;
	import java.util.Arrays;
	import junit.framework.TestCase;
	import org.apache.harmony.security.tests.support.MDGoldenData;
	import org.apache.harmony.security.tests.support.MyMessageDigest1;
	import tests.support.Support_OutputStream;

	/**
	* Tests for fields and methods of class <code>DigestInputStream</code>
	*
	*/
	public class DigestOutputStreamTest extends TestCase {

	/**
	* Message digest algorithm name used during testing
	*/
	private static final String algorithmName[] = {
	"SHA-1",
	"SHA",
	"SHA1",
	"SHA-256",
	"SHA-384",
	"SHA-512",
	"MD5",
	};
	/**
	* Chunk size for read(byte, off, len) tests
	*/
	private static final int CHUNK_SIZE = 32;
	/**
	* Test message for digest computations
	*/
	private static final byte[] myMessage = MDGoldenData.getMessage();
	/**
	* The length of test message
	*/
	private static final int MY_MESSAGE_LEN = myMessage.length;

	//
	// Tests
	//

	/**
	* java.security.DigestOutputStream#DigestOutputStream(java.io.OutputStream,
	* java.security.MessageDigest)
	*/
	public void test_CtorLjava_io_OutputStreamLjava_security_MessageDigest() {

	// non-null parameters
	MessageDigest md = new MyMessageDigest1();
	MyOutputStream out = new MyOutputStream();

	MyDigestOutputStream dos = new MyDigestOutputStream(out, md);
	assertSame(out, dos.myOutputStream());
	assertSame(md, dos.myMessageDigest());

	// null parameters
	dos = new MyDigestOutputStream(null, null);
	assertNull(dos.myOutputStream());
	assertNull(dos.myMessageDigest());

	dos = new MyDigestOutputStream(null, md);
	assertNull(dos.myOutputStream());
	assertNotNull(dos.myMessageDigest());

	dos = new MyDigestOutputStream(out, null);
	assertNotNull(dos.myOutputStream());
	assertNull(dos.myMessageDigest());
	}

	/**
	* java.security.DigestOutputStream#getMessageDigest()
	*/
	public void test_getMessageDigest() {

	MessageDigest digest = new MyMessageDigest1();
	OutputStream out = new MyOutputStream();

	// non-null parameter
	DigestOutputStream dos = new DigestOutputStream(out, digest);
	assertSame(digest, dos.getMessageDigest());

	// null parameter
	dos = new DigestOutputStream(out, null);
	assertNull("getMessageDigest should have returned null", dos.getMessageDigest());
	}

	/**
	* java.security.DigestOutputStream#setMessageDigest(MessageDigest)
	*/
	public void test_setMessageDigestLjava_security_MessageDigest() {

	MessageDigest digest = new MyMessageDigest1();
	OutputStream out = new MyOutputStream();

	DigestOutputStream dos = new DigestOutputStream(out, null);

	// non-null parameter
	dos.setMessageDigest(digest);
	assertSame(digest, dos.getMessageDigest());

	// null parameter
	dos.setMessageDigest(null);
	assertNull("getMessageDigest should have returned null", dos.getMessageDigest());
	}


	/**
	* Test #1 for <code>write(int)</code> method<br>
	*
	* Assertion: writes the byte to the output stream<br>
	* Assertion: updates associated digest<br>
	*/
	public final void testWriteint01()
	throws IOException {
	for (int k=0; k<algorithmName.length; k++) {
	try {
	MessageDigest md = MessageDigest.getInstance(algorithmName[k]);
	ByteArrayOutputStream bos = new ByteArrayOutputStream(MY_MESSAGE_LEN);
	DigestOutputStream dos = new DigestOutputStream(bos, md);
	for (int i=0; i<MY_MESSAGE_LEN; i++) {
	dos.write(myMessage[i]);
	}
	// check that bytes have been written correctly
	assertTrue("write", Arrays.equals(MDGoldenData.getMessage(), bos.toByteArray()));
	// check that associated digest has been updated properly
	assertTrue("update", Arrays.equals(dos.getMessageDigest().digest(),
	MDGoldenData.getDigest(algorithmName[k])));
	return;
	} catch (NoSuchAlgorithmException e) {
	// allowed failure
	}
	}
	fail(getName() + ": no MessageDigest algorithms available - test not performed");
	}

	/**
	* Test #2 for <code>write(int)</code> method<br>
	* Test #1 for <code>on(boolean)</code> method<br>
	*
	* Assertion: <code>write(int)</code> must not update digest if it is off<br>
	* Assertion: <code>on(boolean)</code> turns digest functionality on
	* if <code>true</code> passed as a parameter or off if <code>false</code>
	* passed
	*/
	public final void testWriteint02()
	throws IOException {
	for (int k=0; k<algorithmName.length; k++) {
	try {
	MessageDigest md = MessageDigest.getInstance(algorithmName[k]);
	ByteArrayOutputStream bos = new ByteArrayOutputStream(MY_MESSAGE_LEN);
	DigestOutputStream dos = new DigestOutputStream(bos, md);

	// turn digest off
	dos.on(false);

	for (int i=0; i<MY_MESSAGE_LEN; i++) {
	dos.write(myMessage[i]);
	}

	// check that bytes have been written correctly
	assertTrue("write", Arrays.equals(MDGoldenData.getMessage(), bos.toByteArray()));
	// check that digest value has not been updated by write()
	assertTrue("update", Arrays.equals(dos.getMessageDigest().digest(),
	MDGoldenData.getDigest(algorithmName[k]+"_NU")));
	return;
	} catch (NoSuchAlgorithmException e) {
	// allowed failure
	}
	}
	fail(getName() + ": no MessageDigest algorithms available - test not performed");
	}

	/**
	* Test #3 for <code>write(int)</code> method<br>
	*
	* Assertion: broken <code>DigestOutputStream</code>instance:
	* <code>OutputStream</code> not set. <code>write(int)</code> must
	* not work
	*/
	public final void testWriteint03() throws IOException {
	for (int k=0; k<algorithmName.length; k++) {
	try {
	MessageDigest md = MessageDigest.getInstance(algorithmName[k]);
	DigestOutputStream dos = new DigestOutputStream(null, md);
	// must result in an exception
	try {
	for (int i=0; i<MY_MESSAGE_LEN; i++) {
	dos.write(myMessage[i]);
	}
	fail("OutputStream not set. write(int) must not work");
	} catch (Exception e) {
	return;
	}
	} catch (NoSuchAlgorithmException e) {
	// allowed failure
	}
	}
	fail(getName() + ": no MessageDigest algorithms available - test not performed");
	}

	/**
	* Test #4 for <code>write(int)</code> method<br>
	*
	* Assertion: broken <code>DigestOutputStream</code>instance:
	* associated <code>MessageDigest</code> not set.
	* <code>write(int)</code> must not work when digest
	* functionality is on
	*/
	public final void testWriteint04() throws IOException {
	OutputStream os = new ByteArrayOutputStream(MY_MESSAGE_LEN);
	DigestOutputStream dos = new DigestOutputStream(os, null);

	// must result in an exception
	try {
	for (int i=0; i<MY_MESSAGE_LEN; i++) {
	dos.write(myMessage[i]);
	}
	fail("OutputStream not set. write(int) must not work");
	} catch (Exception e) {
	return;
	}
	}

	/**
	* Test #5 for <code>write(int)</code> method<br>
	* Test #2 for <code>on(boolean)</code> method<br>
	*
	* Assertion: broken <code>DigestOutputStream</code>instance:
	* associated <code>MessageDigest</code> not set.
	* <code>write(int)</code> must work when digest
	* functionality is off
	*/
	public final void testWriteint05() throws IOException {
	ByteArrayOutputStream bos = new ByteArrayOutputStream(MY_MESSAGE_LEN);
	DigestOutputStream dos = new DigestOutputStream(bos, null);
	// set digest functionality to off
	dos.on(false);
	// the following must pass without any exception
	for (int i=0; i<MY_MESSAGE_LEN; i++) {
	dos.write(myMessage[i]);
	}
	// check that bytes have been written correctly
	assertTrue(Arrays.equals(MDGoldenData.getMessage(), bos.toByteArray()));
	}

	/**
	* Test #1 for <code>write(byte[],int,int)</code> method<br>
	*
	* Assertion: put bytes into output stream<br>
	*
	* Assertion: updates associated digest<br>
	*/
	public final void test_write$BII_1() throws IOException {
	for (int k=0; k<algorithmName.length; k++) {
	try {
	ByteArrayOutputStream bos = new ByteArrayOutputStream(MY_MESSAGE_LEN);
	MessageDigest md = MessageDigest.getInstance(algorithmName[k]);
	DigestOutputStream dos = new DigestOutputStream(bos, md);

	// write message at once
	dos.write(myMessage, 0, MY_MESSAGE_LEN);

	// check write
	assertTrue("write", Arrays.equals(myMessage, bos.toByteArray()));
	// check that associated digest has been updated properly
	assertTrue("update", Arrays.equals(dos.getMessageDigest().digest(),
	MDGoldenData.getDigest(algorithmName[k])));
	return;
	} catch (NoSuchAlgorithmException e) {
	// allowed failure
	}
	}
	fail(getName() + ": no MessageDigest algorithms available - test not performed");
	}

	/**
	* Test #2 for <code>write(byte[],int,int)</code> method<br>
	*
	* Assertion: put bytes into output stream<br>
	*
	* Assertion: updates associated digest<br>
	*/
	public final void test_write$BII_2() throws IOException {
	// check precondition
	assertEquals(0, MY_MESSAGE_LEN % CHUNK_SIZE);
	for (int k=0; k<algorithmName.length; k++) {
	try {

	ByteArrayOutputStream bos = new ByteArrayOutputStream(MY_MESSAGE_LEN);
	MessageDigest md = MessageDigest.getInstance(algorithmName[k]);
	DigestOutputStream dos = new DigestOutputStream(bos, md);

	// write message by chunks
	for (int i=0; i<MY_MESSAGE_LEN/CHUNK_SIZE; i++) {
	dos.write(myMessage, i*CHUNK_SIZE, CHUNK_SIZE);
	}
	// check write
	assertTrue("write", Arrays.equals(myMessage, bos.toByteArray()));
	// check that associated digest has been updated properly
	assertTrue("update", Arrays.equals(dos.getMessageDigest().digest(),
	MDGoldenData.getDigest(algorithmName[k])));
	return;
	} catch (NoSuchAlgorithmException e) {
	// allowed failure
	}
	}
	fail(getName() + ": no MessageDigest algorithms available - test not performed");
	}


	/**
	* Test #3 for <code>write(byte[],int,int)</code> method<br>
	*
	* Assertion: put bytes into output stream<br>
	*
	* Assertion: updates associated digest<br>
	*/
	public final void test_write$BII_3()
	throws NoSuchAlgorithmException,
	IOException {
	// check precondition
	assertTrue(MY_MESSAGE_LEN % (CHUNK_SIZE+1) != 0);

	for (int k=0; k<algorithmName.length; k++) {
	try {
	ByteArrayOutputStream bos = new ByteArrayOutputStream(MY_MESSAGE_LEN);
	MessageDigest md = MessageDigest.getInstance(algorithmName[k]);
	DigestOutputStream dos = new DigestOutputStream(bos, md);

	// write message by chunks
	for (int i=0; i<MY_MESSAGE_LEN/(CHUNK_SIZE+1); i++) {
	dos.write(myMessage, i*(CHUNK_SIZE+1), CHUNK_SIZE+1);
	}
	// write remaining bytes
	dos.write(myMessage,
	MY_MESSAGE_LEN/(CHUNK_SIZE+1)*(CHUNK_SIZE+1),
	MY_MESSAGE_LEN % (CHUNK_SIZE+1));
	// check write
	assertTrue("write", Arrays.equals(myMessage, bos.toByteArray()));
	// check that associated digest has been updated properly
	assertTrue("update", Arrays.equals(dos.getMessageDigest().digest(),
	MDGoldenData.getDigest(algorithmName[k])));
	return;
	} catch (NoSuchAlgorithmException e) {
	// allowed failure
	}
	}
	fail(getName() + ": no MessageDigest algorithms available - test not performed");
	}

	/**
	* Test #4 for <code>write(byte[],int,int)</code> method<br>
	*
	* Assertion: put bytes into output stream<br>
	*
	* Assertion: does not update associated digest if digest
	* functionality is off<br>
	*/
	public final void test_write$BII_4()
	throws NoSuchAlgorithmException,
	IOException {
	// check precondition
	assertEquals(0, MY_MESSAGE_LEN % CHUNK_SIZE);

	for (int k=0; k<algorithmName.length; k++) {
	try {
	ByteArrayOutputStream bos = new ByteArrayOutputStream(MY_MESSAGE_LEN);
	MessageDigest md = MessageDigest.getInstance(algorithmName[k]);
	DigestOutputStream dos = new DigestOutputStream(bos, md);

	// set digest functionality off
	dos.on(false);

	// write message by chunks
	for (int i=0; i<MY_MESSAGE_LEN/CHUNK_SIZE; i++) {
	dos.write(myMessage, i*CHUNK_SIZE, CHUNK_SIZE);
	}

	// check write
	assertTrue("write", Arrays.equals(myMessage, bos.toByteArray()));
	// check that associated digest has not been updated
	assertTrue("update", Arrays.equals(dos.getMessageDigest().digest(),
	MDGoldenData.getDigest(algorithmName[k]+"_NU")));
	return;
	} catch (NoSuchAlgorithmException e) {
	// allowed failure
	}
	}
	fail(getName() + ": no MessageDigest algorithms available - test not performed");
	}

	/**
	* java.security.DigestOutputStream#write(byte[], int, int)
	*/
	public void test_write$BII_6() throws Exception {

	// Regression form HARMONY-1091.
	MessageDigest md = new MyMessageDigest1();
	byte[] bytes = new byte[] { 1, 2 };
	DigestOutputStream dig = new DigestOutputStream(
	new ByteArrayOutputStream(), md);
	// buf == null
	try {
	dig.write(null, -1, 0);
	fail("No expected IllegalArgumentException");
	} catch (IllegalArgumentException e) {
	}
	// offset + len > buf.length
	try {
	dig.write(bytes, 0, bytes.length + 1);
	fail("No expected IllegalArgumentException");
	} catch (IllegalArgumentException e) {
	}
	// offset < 0
	try {
	dig.write(bytes, -1, 1);
	fail("No expected IndexOutOfBoundsException");
	} catch (IndexOutOfBoundsException e) {
	}
	// len < 0
	try {
	dig.write(bytes, 0, -1);
	fail("No expected IndexOutOfBoundsException");
	} catch (IndexOutOfBoundsException e) {
	}
	}

	/**
	* java.io.DigestOutputStream#write(byte[], int, int)
	*/
	public void test_write$BII_7()
	throws IOException, NoSuchAlgorithmException {
	Support_OutputStream sos = new Support_OutputStream(MY_MESSAGE_LEN);
	MessageDigest md = MessageDigest.getInstance(algorithmName[0]);
	DigestOutputStream dos = new DigestOutputStream(sos, md);

	dos.write(myMessage, 0, MY_MESSAGE_LEN);

	try {
	// Support_OutputStream throws an IOException if the internal
	// buffer is full, which it should be now.
	dos.write(myMessage, 0, MY_MESSAGE_LEN);
	fail("Test 1: IOException expected.");
	} catch (IOException e) {
	// Expected.
	}
	}

	/**
	* Test for <code>on()</code> method<br>
	* Assertion: turns digest functionality on or off
	*/
	public final void testOn() throws IOException {
	for (int k=0; k<algorithmName.length; k++) {
	try {
	ByteArrayOutputStream bos = new ByteArrayOutputStream(MY_MESSAGE_LEN);
	MessageDigest md = MessageDigest.getInstance(algorithmName[k]);
	DigestOutputStream dos = new DigestOutputStream(bos, md);

	// turn digest off
	dos.on(false);

	for (int i=0; i<MY_MESSAGE_LEN-1; i++) {
	dos.write(myMessage[i]);
	}

	// turn digest on
	dos.on(true);

	// read remaining byte
	dos.write(myMessage[MY_MESSAGE_LEN-1]);

	byte[] digest = dos.getMessageDigest().digest();

	// check that digest value has been
	// updated by the last write(int) call
	assertFalse(Arrays.equals(digest,MDGoldenData.getDigest(algorithmName[k])));
	assertFalse(Arrays.equals(digest,MDGoldenData.getDigest(algorithmName[k]+"_NU")));
	return;
	} catch (NoSuchAlgorithmException e) {
	// allowed failure
	}
	}
	fail(getName() + ": no MessageDigest algorithms available - test not performed");
	}

	/**
	* Test for <code>toString()</code> method<br>
	* Assertion: returns <code>String</code> representation of this object
	*/
	public final void testToString() throws NoSuchAlgorithmException {
	for (int k=0; k<algorithmName.length; k++) {
	try {
	ByteArrayOutputStream bos = new ByteArrayOutputStream(MY_MESSAGE_LEN);
	MessageDigest md = MessageDigest.getInstance(algorithmName[k]);
	DigestOutputStream dos = new DigestOutputStream(bos, md);

	assertNotNull(dos.toString());
	return;
	} catch (NoSuchAlgorithmException e) {
	// allowed failure
	}
	}
	fail(getName() + ": no MessageDigest algorithms available - test not performed");
	}

	/**
	* java.security.DigestOutputStream#on(boolean)
	*/
	public void test_onZ() throws Exception {
	// Test for method void java.security.DigestOutputStream.on(boolean)
	DigestOutputStream dos = new DigestOutputStream(
	new ByteArrayOutputStream(), MessageDigest.getInstance("SHA"));
	dos.on(false);
	byte digestArray[] = { 23, 43, 44 };
	dos.write(digestArray, 1, 1);
	byte digestResult[] = dos.getMessageDigest().digest();
	byte expected[] = { -38, 57, -93, -18, 94, 107, 75, 13, 50, 85,
	-65, -17, -107, 96, 24, -112, -81, -40, 7, 9 };
	assertTrue("Digest did not return expected result.",
	Arrays.equals(digestResult, expected));
	// now turn on processing and re-run
	dos.on(true);
	dos.write(digestArray, 1, 1);
	digestResult = dos.getMessageDigest().digest();
	byte expected1[] = { -87, 121, -17, 16, -52, 111, 106, 54, -33,
	107, -118, 50, 51, 7, -18, 59, -78, -30, -37, -100 };

	assertTrue("Digest did not return expected result.",
	Arrays.equals(digestResult, expected1));
	}

	/**
	* java.security.DigestOutputStream#write(byte[], int, int)
	*/
	public void test_write$BII_5() throws Exception {
	// Test for method void java.security.DigestOutputStream.write(byte [],
	// int, int)
	DigestOutputStream dos = new DigestOutputStream(
	new ByteArrayOutputStream(), MessageDigest.getInstance("SHA"));
	byte digestArray[] = { 23, 43, 44 };
	dos.write(digestArray, 1, 1);
	byte digestResult[] = dos.getMessageDigest().digest();
	byte expected[] = { -87, 121, -17, 16, -52, 111, 106, 54, -33, 107,
	-118, 50, 51, 7, -18, 59, -78, -30, -37, -100 };

	assertTrue("Digest did not return expected result.",
	Arrays.equals(digestResult, expected));
	}

	/**
	* java.security.DigestOutputStream#write(int)
	*/
	public void test_writeI() throws Exception {
	// Test for method void java.security.DigestOutputStream.write(int)
	DigestOutputStream dos = new DigestOutputStream(
	new ByteArrayOutputStream(), MessageDigest.getInstance("SHA"));
	dos.write((byte) 43);
	byte digestResult[] = dos.getMessageDigest().digest();
	byte expected[] = { -87, 121, -17, 16, -52, 111, 106, 54, -33, 107,
	-118, 50, 51, 7, -18, 59, -78, -30, -37, -100 };

	assertTrue("Digest did not return expected result.",
	Arrays.equals(digestResult, expected));
	}


	private class MyOutputStream extends OutputStream {
	@Override
	public void write(int arg0) throws IOException {
	}
	}

	private class MyDigestOutputStream extends DigestOutputStream {
	public MyDigestOutputStream(OutputStream out, MessageDigest digest) {
	super(out, digest);
	}

	public MessageDigest myMessageDigest() {
	return digest;
	}

	public OutputStream myOutputStream() {
	return out;
	}
	}
	}