harmony-tests/src/test/java/org/apache/harmony/tests/javax/security/OldSHA1PRNGSecureRandomTest.java - 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.
  */

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

 import java.security.NoSuchAlgorithmException;
 import java.security.NoSuchProviderException;
 import java.security.SecureRandom;

 import junit.framework.TestCase;

 /**
  * Tests against methods in SecureRandom class object using
  * SHA1PRNG_SecureRandomImpl.
  */
 public class OldSHA1PRNGSecureRandomTest extends TestCase {

     private static final int LENGTH = 20; // constant defining loop limit

     private static final int INCR = 2; // constant defining loop increment

     private static final String algorithm = "SHA1PRNG"; // algorithm's name

     private static SecureRandom sr; // fields used by tests

     private static SecureRandom sr2; //

     /*
      * @see TestCase#setUp()
      */
     protected void setUp() throws Exception {
         super.setUp();
         sr = SecureRandom.getInstance(algorithm);
         sr2 = SecureRandom.getInstance(algorithm);
     }

     /**
      * test against the "void generateSeed(int)" method; it checks out that the
      * method throws NegativeArraySizeException if argument <0
      */
     public final void testGenerateSeedint01() {
         try {
             sr.generateSeed(-1);
             fail("generateSeed(-1) :: No NegativeArraySizeException");
         } catch (NegativeArraySizeException e) {
         }
     }

     /**
      * test against the "void generateSeed(int)" method; it checks out that
      * number of bits returned is equal to one requested; the check includes
      * case for argument's value == 0;
      */
     public final void testGenerateSeedint02() {
         for (int i = 0; i < LENGTH; i++) {
             byte[] myBytes = sr.generateSeed(i);
             assertFalse("unexpected: myBytes.length != i  :: i==" + i + " myBytes.length="
                     + myBytes.length, myBytes.length != i);
         }
     }

     /**
      * test against the "void generateSeed(int)" method; it checks out the
      * quality of entropy (# of different bytes in sequential calls is more or
      * equal to 50%)
      */
     public final void testGenerateSeedint03() {
         byte[] myBytes1;
         byte[] myBytes2;

         for (int i = 0; i < LENGTH; i += INCR) {
             int n = 0;
             myBytes1 = sr.generateSeed(i);
             myBytes2 = sr.generateSeed(i);

             for (int j = 0; j < i; j++) {
                 if (myBytes1[j] == myBytes2[j]) {
                     n++;
                 }
             }
             assertFalse("unexpected: n*2 > i  :: i=" + i + " n=" + n, n * 2 > i);
         }
     }

     /**
      * test against the "void nextBytes(byte[])" method; it checks out that the
      * method throws NPE if argument supplied is null
      */
     public final void testNextBytesbyteArray01() {
         try {
             sr.nextBytes(null);
             fail("unexpected: nextBytes(null) :: No NullPointerException");
         } catch (NullPointerException e) {
         }
     }

     /**
      * test against the "void nextBytes(byte[])" method; it checks out that
      * different SecureRandom objects being supplied with the same seed return
      * the same sequencies of bytes as results of their "nextBytes(byte[])"
      * methods
      */
     public final void testNextBytesbyteArray02() {
         byte[] myBytes;
         byte[] myBytes1;
         byte[] myBytes2;

         // case1: sequencies are of the same length
         for (int i = 1; i < LENGTH; i += INCR) {
             myBytes = new byte[i];

             for (int j = 1; j < i; j++) {
                 myBytes[j] = (byte) (j & 0xFF);
             }
             sr.setSeed(myBytes);
             sr2.setSeed(myBytes);

             for (int k = 1; k < LENGTH; k += INCR) {
                 myBytes1 = new byte[k];
                 myBytes2 = new byte[k];
                 sr.nextBytes(myBytes1);
                 sr2.nextBytes(myBytes2);

                 for (int l = 0; l < k; l++) {
                     assertFalse("unexpected: myBytes1[l] != myBytes2[l]  :: l==" + l + " k=" + k
                             + " i=" + i + " myBytes1[l]=" + myBytes1[l] + " myBytes2[l]="
                             + myBytes2[l], myBytes1[l] != myBytes2[l]);
                 }
             }
         }

         // case2: sequencies are of different lengths
         for (int n = 1; n < LENGTH; n += INCR) {
             int n1 = 10;
             int n2 = 20;
             int n3 = 100;
             byte[][] bytes1 = new byte[10][n1];
             byte[][] bytes2 = new byte[5][n2];

             for (int k = 0; k < bytes1.length; k++) {
                 sr.nextBytes(bytes1[k]);
             }
             for (int k = 0; k < bytes2.length; k++) {
                 sr2.nextBytes(bytes2[k]);
             }

             for (int k = 0; k < n3; k++) {
                 int i1 = k / n1;
                 int i2 = k % n1;
                 int i3 = k / n2;
                 int i4 = k % n2;
                 assertTrue("non-equality: i1=" + i1 + " i2=" + i2 + " i3=" + i3 + " i4=" + i4,
                         bytes1[i1][i2] == bytes2[i3][i4]);
             }
         }
     }

     /**
      * test against the "void nextBytes(byte[])" method; it checks out that
      * different SecureRandom objects being supplied with seed by themselves
      * return different sequencies of bytes as results of their
      * "nextBytes(byte[])" methods
      */
     public final void testNextBytesbyteArray03() throws NoSuchAlgorithmException,
             NoSuchProviderException {
         /* these are needed to test new SecureRandom objects in loop */
         SecureRandom sr1;
         SecureRandom sr2;

         byte[] myBytes1;
         byte[] myBytes2;

         for (int i = 1; i < LENGTH / 2; i += INCR) {
             sr1 = SecureRandom.getInstance(algorithm);
             sr2 = SecureRandom.getInstance(algorithm);

             boolean flag = true;

             myBytes1 = new byte[i];
             myBytes2 = new byte[i];

             sr1.nextBytes(myBytes1);
             sr2.nextBytes(myBytes2);
             for (int j = 0; j < i; j++) {
                 flag &= myBytes1[j] == myBytes2[j];
             }

             // check again to avoid intermittent failures
             sr1.nextBytes(myBytes1);
             sr2.nextBytes(myBytes2);
             for (int j = 0; j < i; j++) {
                 flag &= myBytes1[j] == myBytes2[j];
             }

             if (flag) {
                 // probability of false failure is 1.5*10^-5 per run for i=1 or
                 // less for i > 1
                 fail("TESTING RANDOM NUMBER GENERATOR QUALITY: IGNORE THIS FAILURE IF INTERMITTENT :: i="
                         + i);
             }
         }
     }

     /**
      * test against the "void nextBytes(byte[])" method; it checks out behavior
      * of SecureRandom object in cases of passing byte array of zero length to
      * "nextBytes(byte[])" method. The test contains two testcases: - first
      * testcase checks out that if for two newly created SecureRandom objects
      * invocation of "nextBytes(new byte[0])" method are first ones then further
      * calls to nextBytes(..) methods return different byte arrays, that is,
      * first "nextBytes(new byte[0])" aslo randomizes internal state; - second
      * testcase checks out that if for two newly created SecureRandom objects
      * invocation of "setSeed(..)" methods are first ones then further calls to
      * "nextBytes(new byte[0])" methods has no effect
      */
     public final void testNextBytesbyteArray04() throws NoSuchAlgorithmException,
             NoSuchProviderException {
         /*
          * these are needed to test new SecureRandom objects in loop
          */
         SecureRandom sr1;
         SecureRandom sr2;

         byte[] myBytes;
         byte[] myBytes1;
         byte[] myBytes2;

         // case 1:
         for (int i = 1; i < LENGTH / 2; i += INCR) {
             sr1 = SecureRandom.getInstance(algorithm);
             sr2 = SecureRandom.getInstance(algorithm);

             sr1.nextBytes(new byte[0]);
             sr2.nextBytes(new byte[0]);

             boolean flag = true;

             myBytes1 = new byte[i];
             myBytes2 = new byte[i];

             sr1.nextBytes(myBytes1);
             sr2.nextBytes(myBytes2);
             for (int j = 0; j < i; j++) {
                 flag &= myBytes1[j] == myBytes2[j];
             }

             // check again to avoid intermittent failures
             sr1.nextBytes(myBytes1);
             sr2.nextBytes(myBytes2);
             for (int j = 0; j < i; j++) {
                 flag &= myBytes1[j] == myBytes2[j];
             }

             if (flag) {
                 // probability of false failure is 1.5*10^-5 per run for i=1 or
                 // less for i > 1
                 fail("TESTING RANDOM NUMBER GENERATOR QUALITY: IGNORE THIS FAILURE IF INTERMITTENT :: i="
                         + i);
             }
         }

         myBytes = new byte[] {
             (byte) 0
         };

         // case2:
         for (int n = 1; n < LENGTH; n += INCR) {
             byte[][] bytes1 = new byte[2][n];
             byte[][] bytes2 = new byte[2][n];

             sr1 = SecureRandom.getInstance(algorithm);
             sr2 = SecureRandom.getInstance(algorithm);

             sr1.setSeed(myBytes);
             sr2.setSeed(myBytes);

             sr1.nextBytes(bytes1[0]);
             sr1.nextBytes(bytes1[1]);

             sr2.nextBytes(bytes2[0]);
             sr2.nextBytes(new byte[0]);
             sr2.nextBytes(bytes2[1]);

             for (int k = 0; k < 2; k++) {
                 for (int j = 0; j < n; j++) {
                     assertTrue("non-equality: k=" + k + " j=" + j + " bytes1[k][j]=" + bytes1[k][j]
                             + " bytes2[k][j]=" + bytes2[k][j], bytes1[k][j] == bytes2[k][j]);
                 }
             }
         }
     }

     /**
      * test against the "void setSeed(byte[])" method; it checks out that the
      * method throws NPE if argument supplied is null
      */
     public final void testSetSeedbyteArray01() {
         try {
             sr.setSeed(null);
             fail("setSeed(null) :: No NullPointerException");
         } catch (NullPointerException e) {
         }
     }

     /**
      * test against the "void setSeed(byte[])" method; it checks out that
      * "setSeed(byte[])" method supplements its argument to current seed rather
      * than replaces current seed
      */
     public final void testSetSeedbyteArray02() throws NoSuchFieldException, SecurityException,
             IllegalAccessException {
         byte[] seed = new byte[LENGTH];
         byte[] bytes1 = new byte[LENGTH];
         byte[] bytes2 = new byte[LENGTH];
         boolean b;

         for (int i = 0; i < seed.length; i++) {
             seed[i] = (byte) i;
         }

         sr.setSeed(seed);
         sr.setSeed(seed);
         sr2.setSeed(seed);

         sr.nextBytes(bytes1);
         sr2.nextBytes(bytes2);

         b = true;
         for (int j = 0; j < bytes1.length; j++) {
             b &= bytes1[j] == bytes2[j];
         }
         assertFalse("unexpected: sequences are equal", b);
     }

     /**
      * test against the "void setSeed(byte[])" method; it checks out that the
      * "byte[0]" argument has no effect; there are two testcases: - if one of
      * two SecureRandom objects supplied with the same seed is additionally
      * supplied with such array, "nextBytes(..)" of both objects return the same
      * bytes; - two byte arrays returned by "nextBytes(..)" in following
      * sequence nextBytes(..); setSeed(new byte[0]); nextBytes(..); don't
      * contain the same byte sequencies.
      */
     public final void testSetSeedbyteArray03() throws NoSuchFieldException, SecurityException,
             IllegalAccessException {
         byte[] seed = new byte[LENGTH];
         byte[] bytes1;
         byte[] bytes2;

         for (int i = 0; i < seed.length; i++) {
             seed[i] = (byte) i;
         }

         // testcase begins with "bytes1" and "bytes2" of zero length
         for (int i = 0; i < LENGTH; i++) {
             bytes1 = new byte[i];
             bytes2 = new byte[i];

             sr.setSeed(seed);
             sr.setSeed(new byte[0]);
             sr.nextBytes(bytes1);

             sr2.setSeed(seed);
             sr2.nextBytes(bytes2);

             for (int j = 0; j < bytes1.length; j++) {
                 assertEquals("bytes1[j] != bytes2[j] :: j=" + j, bytes1[j], bytes2[j]);
             }
         }

         for (int i = 1; i < LENGTH; i++) {
             bytes1 = new byte[i];
             bytes2 = new byte[i];

             sr.setSeed(seed);
             sr.nextBytes(bytes1);
             sr.setSeed(new byte[0]);
             sr.nextBytes(bytes2);

             boolean b = true;
             for (int j = 0; j < bytes1.length; j++) {
                 b &= bytes1[j] == bytes2[j];
             }
             assertFalse("sequences are equal i=" + i, b);
         }
     }
 }
	/*
	* 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.
	*/

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

	import java.security.NoSuchAlgorithmException;
	import java.security.NoSuchProviderException;
	import java.security.SecureRandom;

	import junit.framework.TestCase;

	/**
	* Tests against methods in SecureRandom class object using
	* SHA1PRNG_SecureRandomImpl.
	*/
	public class OldSHA1PRNGSecureRandomTest extends TestCase {

	private static final int LENGTH = 20; // constant defining loop limit

	private static final int INCR = 2; // constant defining loop increment

	private static final String algorithm = "SHA1PRNG"; // algorithm's name

	private static SecureRandom sr; // fields used by tests

	private static SecureRandom sr2; //

	/*
	* @see TestCase#setUp()
	*/
	protected void setUp() throws Exception {
	super.setUp();
	sr = SecureRandom.getInstance(algorithm);
	sr2 = SecureRandom.getInstance(algorithm);
	}

	/**
	* test against the "void generateSeed(int)" method; it checks out that the
	* method throws NegativeArraySizeException if argument <0
	*/
	public final void testGenerateSeedint01() {
	try {
	sr.generateSeed(-1);
	fail("generateSeed(-1) :: No NegativeArraySizeException");
	} catch (NegativeArraySizeException e) {
	}
	}

	/**
	* test against the "void generateSeed(int)" method; it checks out that
	* number of bits returned is equal to one requested; the check includes
	* case for argument's value == 0;
	*/
	public final void testGenerateSeedint02() {
	for (int i = 0; i < LENGTH; i++) {
	byte[] myBytes = sr.generateSeed(i);
	assertFalse("unexpected: myBytes.length != i :: i==" + i + " myBytes.length="
	+ myBytes.length, myBytes.length != i);
	}
	}

	/**
	* test against the "void generateSeed(int)" method; it checks out the
	* quality of entropy (# of different bytes in sequential calls is more or
	* equal to 50%)
	*/
	public final void testGenerateSeedint03() {
	byte[] myBytes1;
	byte[] myBytes2;

	for (int i = 0; i < LENGTH; i += INCR) {
	int n = 0;
	myBytes1 = sr.generateSeed(i);
	myBytes2 = sr.generateSeed(i);

	for (int j = 0; j < i; j++) {
	if (myBytes1[j] == myBytes2[j]) {
	n++;
	}
	}
	assertFalse("unexpected: n2 > i :: i=" + i + " n=" + n, n 2 > i);
	}
	}

	/**
	* test against the "void nextBytes(byte[])" method; it checks out that the
	* method throws NPE if argument supplied is null
	*/
	public final void testNextBytesbyteArray01() {
	try {
	sr.nextBytes(null);
	fail("unexpected: nextBytes(null) :: No NullPointerException");
	} catch (NullPointerException e) {
	}
	}

	/**
	* test against the "void nextBytes(byte[])" method; it checks out that
	* different SecureRandom objects being supplied with the same seed return
	* the same sequencies of bytes as results of their "nextBytes(byte[])"
	* methods
	*/
	public final void testNextBytesbyteArray02() {
	byte[] myBytes;
	byte[] myBytes1;
	byte[] myBytes2;

	// case1: sequencies are of the same length
	for (int i = 1; i < LENGTH; i += INCR) {
	myBytes = new byte[i];

	for (int j = 1; j < i; j++) {
	myBytes[j] = (byte) (j & 0xFF);
	}
	sr.setSeed(myBytes);
	sr2.setSeed(myBytes);

	for (int k = 1; k < LENGTH; k += INCR) {
	myBytes1 = new byte[k];
	myBytes2 = new byte[k];
	sr.nextBytes(myBytes1);
	sr2.nextBytes(myBytes2);

	for (int l = 0; l < k; l++) {
	assertFalse("unexpected: myBytes1[l] != myBytes2[l] :: l==" + l + " k=" + k
	+ " i=" + i + " myBytes1[l]=" + myBytes1[l] + " myBytes2[l]="
	+ myBytes2[l], myBytes1[l] != myBytes2[l]);
	}
	}
	}

	// case2: sequencies are of different lengths
	for (int n = 1; n < LENGTH; n += INCR) {
	int n1 = 10;
	int n2 = 20;
	int n3 = 100;
	byte[][] bytes1 = new byte[10][n1];
	byte[][] bytes2 = new byte[5][n2];

	for (int k = 0; k < bytes1.length; k++) {
	sr.nextBytes(bytes1[k]);
	}
	for (int k = 0; k < bytes2.length; k++) {
	sr2.nextBytes(bytes2[k]);
	}

	for (int k = 0; k < n3; k++) {
	int i1 = k / n1;
	int i2 = k % n1;
	int i3 = k / n2;
	int i4 = k % n2;
	assertTrue("non-equality: i1=" + i1 + " i2=" + i2 + " i3=" + i3 + " i4=" + i4,
	bytes1[i1][i2] == bytes2[i3][i4]);
	}
	}
	}

	/**
	* test against the "void nextBytes(byte[])" method; it checks out that
	* different SecureRandom objects being supplied with seed by themselves
	* return different sequencies of bytes as results of their
	* "nextBytes(byte[])" methods
	*/
	public final void testNextBytesbyteArray03() throws NoSuchAlgorithmException,
	NoSuchProviderException {
	/* these are needed to test new SecureRandom objects in loop */
	SecureRandom sr1;
	SecureRandom sr2;

	byte[] myBytes1;
	byte[] myBytes2;

	for (int i = 1; i < LENGTH / 2; i += INCR) {
	sr1 = SecureRandom.getInstance(algorithm);
	sr2 = SecureRandom.getInstance(algorithm);

	boolean flag = true;

	myBytes1 = new byte[i];
	myBytes2 = new byte[i];

	sr1.nextBytes(myBytes1);
	sr2.nextBytes(myBytes2);
	for (int j = 0; j < i; j++) {
	flag &= myBytes1[j] == myBytes2[j];
	}

	// check again to avoid intermittent failures
	sr1.nextBytes(myBytes1);
	sr2.nextBytes(myBytes2);
	for (int j = 0; j < i; j++) {
	flag &= myBytes1[j] == myBytes2[j];
	}

	if (flag) {
	// probability of false failure is 1.5*10^-5 per run for i=1 or
	// less for i > 1
	fail("TESTING RANDOM NUMBER GENERATOR QUALITY: IGNORE THIS FAILURE IF INTERMITTENT :: i="
	+ i);
	}
	}
	}

	/**
	* test against the "void nextBytes(byte[])" method; it checks out behavior
	* of SecureRandom object in cases of passing byte array of zero length to
	* "nextBytes(byte[])" method. The test contains two testcases: - first
	* testcase checks out that if for two newly created SecureRandom objects
	* invocation of "nextBytes(new byte[0])" method are first ones then further
	* calls to nextBytes(..) methods return different byte arrays, that is,
	* first "nextBytes(new byte[0])" aslo randomizes internal state; - second
	* testcase checks out that if for two newly created SecureRandom objects
	* invocation of "setSeed(..)" methods are first ones then further calls to
	* "nextBytes(new byte[0])" methods has no effect
	*/
	public final void testNextBytesbyteArray04() throws NoSuchAlgorithmException,
	NoSuchProviderException {
	/*
	* these are needed to test new SecureRandom objects in loop
	*/
	SecureRandom sr1;
	SecureRandom sr2;

	byte[] myBytes;
	byte[] myBytes1;
	byte[] myBytes2;

	// case 1:
	for (int i = 1; i < LENGTH / 2; i += INCR) {
	sr1 = SecureRandom.getInstance(algorithm);
	sr2 = SecureRandom.getInstance(algorithm);

	sr1.nextBytes(new byte[0]);
	sr2.nextBytes(new byte[0]);

	boolean flag = true;

	myBytes1 = new byte[i];
	myBytes2 = new byte[i];

	sr1.nextBytes(myBytes1);
	sr2.nextBytes(myBytes2);
	for (int j = 0; j < i; j++) {
	flag &= myBytes1[j] == myBytes2[j];
	}

	// check again to avoid intermittent failures
	sr1.nextBytes(myBytes1);
	sr2.nextBytes(myBytes2);
	for (int j = 0; j < i; j++) {
	flag &= myBytes1[j] == myBytes2[j];
	}

	if (flag) {
	// probability of false failure is 1.5*10^-5 per run for i=1 or
	// less for i > 1
	fail("TESTING RANDOM NUMBER GENERATOR QUALITY: IGNORE THIS FAILURE IF INTERMITTENT :: i="
	+ i);
	}
	}

	myBytes = new byte[] {
	(byte) 0
	};

	// case2:
	for (int n = 1; n < LENGTH; n += INCR) {
	byte[][] bytes1 = new byte[2][n];
	byte[][] bytes2 = new byte[2][n];

	sr1 = SecureRandom.getInstance(algorithm);
	sr2 = SecureRandom.getInstance(algorithm);

	sr1.setSeed(myBytes);
	sr2.setSeed(myBytes);

	sr1.nextBytes(bytes1[0]);
	sr1.nextBytes(bytes1[1]);

	sr2.nextBytes(bytes2[0]);
	sr2.nextBytes(new byte[0]);
	sr2.nextBytes(bytes2[1]);

	for (int k = 0; k < 2; k++) {
	for (int j = 0; j < n; j++) {
	assertTrue("non-equality: k=" + k + " j=" + j + " bytes1[k][j]=" + bytes1[k][j]
	+ " bytes2[k][j]=" + bytes2[k][j], bytes1[k][j] == bytes2[k][j]);
	}
	}
	}
	}

	/**
	* test against the "void setSeed(byte[])" method; it checks out that the
	* method throws NPE if argument supplied is null
	*/
	public final void testSetSeedbyteArray01() {
	try {
	sr.setSeed(null);
	fail("setSeed(null) :: No NullPointerException");
	} catch (NullPointerException e) {
	}
	}

	/**
	* test against the "void setSeed(byte[])" method; it checks out that
	* "setSeed(byte[])" method supplements its argument to current seed rather
	* than replaces current seed
	*/
	public final void testSetSeedbyteArray02() throws NoSuchFieldException, SecurityException,
	IllegalAccessException {
	byte[] seed = new byte[LENGTH];
	byte[] bytes1 = new byte[LENGTH];
	byte[] bytes2 = new byte[LENGTH];
	boolean b;

	for (int i = 0; i < seed.length; i++) {
	seed[i] = (byte) i;
	}

	sr.setSeed(seed);
	sr.setSeed(seed);
	sr2.setSeed(seed);

	sr.nextBytes(bytes1);
	sr2.nextBytes(bytes2);

	b = true;
	for (int j = 0; j < bytes1.length; j++) {
	b &= bytes1[j] == bytes2[j];
	}
	assertFalse("unexpected: sequences are equal", b);
	}

	/**
	* test against the "void setSeed(byte[])" method; it checks out that the
	* "byte[0]" argument has no effect; there are two testcases: - if one of
	* two SecureRandom objects supplied with the same seed is additionally
	* supplied with such array, "nextBytes(..)" of both objects return the same
	* bytes; - two byte arrays returned by "nextBytes(..)" in following
	* sequence nextBytes(..); setSeed(new byte[0]); nextBytes(..); don't
	* contain the same byte sequencies.
	*/
	public final void testSetSeedbyteArray03() throws NoSuchFieldException, SecurityException,
	IllegalAccessException {
	byte[] seed = new byte[LENGTH];
	byte[] bytes1;
	byte[] bytes2;

	for (int i = 0; i < seed.length; i++) {
	seed[i] = (byte) i;
	}

	// testcase begins with "bytes1" and "bytes2" of zero length
	for (int i = 0; i < LENGTH; i++) {
	bytes1 = new byte[i];
	bytes2 = new byte[i];

	sr.setSeed(seed);
	sr.setSeed(new byte[0]);
	sr.nextBytes(bytes1);

	sr2.setSeed(seed);
	sr2.nextBytes(bytes2);

	for (int j = 0; j < bytes1.length; j++) {
	assertEquals("bytes1[j] != bytes2[j] :: j=" + j, bytes1[j], bytes2[j]);
	}
	}

	for (int i = 1; i < LENGTH; i++) {
	bytes1 = new byte[i];
	bytes2 = new byte[i];

	sr.setSeed(seed);
	sr.nextBytes(bytes1);
	sr.setSeed(new byte[0]);
	sr.nextBytes(bytes2);

	boolean b = true;
	for (int j = 0; j < bytes1.length; j++) {
	b &= bytes1[j] == bytes2[j];
	}
	assertFalse("sequences are equal i=" + i, b);
	}
	}
	}