harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From smish...@apache.org
Subject svn commit: r467267 - in /incubator/harmony/enhanced/classlib/trunk/modules/security/src/test: impl/java/org/apache/harmony/security/tests/provider/crypto/ impl/java/org/apache/harmony/security/tests/provider/crypto/serialization/ resources/serializati...
Date Tue, 24 Oct 2006 08:02:42 GMT
Author: smishura
Date: Tue Oct 24 01:02:41 2006
New Revision: 467267

URL: http://svn.apache.org/viewvc?view=rev&rev=467267
Log:
Apply patch for HARMONY-1924 ([classlib][security] crypto provider: tests against classes developed)

Added:
    incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/impl/java/org/apache/harmony/security/tests/provider/crypto/
    incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/impl/java/org/apache/harmony/security/tests/provider/crypto/CryptoProviderTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/impl/java/org/apache/harmony/security/tests/provider/crypto/SHA1ImplTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/impl/java/org/apache/harmony/security/tests/provider/crypto/SHA1PRNG_SecureRandomTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/impl/java/org/apache/harmony/security/tests/provider/crypto/serialization/
    incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/impl/java/org/apache/harmony/security/tests/provider/crypto/serialization/SHA1PRNG_SecureRandomTest.java   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/resources/serialization/org/apache/harmony/security/tests/provider/
    incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/resources/serialization/org/apache/harmony/security/tests/provider/crypto/
    incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/resources/serialization/org/apache/harmony/security/tests/provider/crypto/serialization/
    incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/resources/serialization/org/apache/harmony/security/tests/provider/crypto/serialization/SHA1PRNG_SecureRandomTest.golden.0.ser   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/resources/serialization/org/apache/harmony/security/tests/provider/crypto/serialization/SHA1PRNG_SecureRandomTest.golden.1.ser   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/resources/serialization/org/apache/harmony/security/tests/provider/crypto/serialization/SHA1PRNG_SecureRandomTest.golden.2.ser   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/resources/serialization/org/apache/harmony/security/tests/provider/crypto/serialization/SHA1PRNG_SecureRandomTest.golden.3.ser   (with props)
    incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/resources/serialization/org/apache/harmony/security/tests/provider/crypto/serialization/SHA1PRNG_SecureRandomTest.golden.4.ser   (with props)

Added: incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/impl/java/org/apache/harmony/security/tests/provider/crypto/CryptoProviderTest.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/impl/java/org/apache/harmony/security/tests/provider/crypto/CryptoProviderTest.java?view=auto&rev=467267
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/impl/java/org/apache/harmony/security/tests/provider/crypto/CryptoProviderTest.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/impl/java/org/apache/harmony/security/tests/provider/crypto/CryptoProviderTest.java Tue Oct 24 01:02:41 2006
@@ -0,0 +1,103 @@
+/*
+ *  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.security.tests.provider.crypto;
+
+
+import org.apache.harmony.security.provider.crypto.CryptoProvider;
+
+import java.security.Security;
+import java.security.SecureRandom;
+import java.security.MessageDigest;
+import java.security.Signature;
+import java.security.KeyFactory;
+import java.security.DigestException;
+import java.security.NoSuchAlgorithmException;
+import java.security.NoSuchProviderException;
+import java.security.Provider;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+
+/**
+ * Tests against CryptoProvider.
+ */
+
+
+public class CryptoProviderTest extends TestCase {
+
+
+    private static final String providerName = "Crypto";     // name of provider
+    private static final String shaprng      = "SHA1PRNG";   // name of algorithm
+    private static final String sha_1        = "SHA-1";      // name of algorithm
+    private static final String sha_1_alias  = "SHA1";       // alias name
+    private static final String sha_1_alias2 = "SHA";        // alias name
+
+    private static final String dsaNames[] = { "SHA1withDSA",
+                                               "SHAwithDSA",
+                                               "DSAwithSHA1",
+                                               "SHA1/DSA",
+                                               "SHA/DSA",
+                                               "SHA-1/DSA",
+                                               "DSA",
+                                               "DSS",
+                                               "OID.1.2.840.10040.4.3",
+                                               "1.2.840.10040.4.3",
+                                               "1.3.14.3.2.13",
+                                               "1.3.14.3.2.27" };
+
+    private static final String keyFactoryNames[] = { "DSA",
+                                                      "1.3.14.3.2.12",
+                                                      "1.2.840.10040.4.1" };
+
+    /**
+     * Test against CryptoProvider() methods.
+     */
+    public void testCrypto() throws NoSuchAlgorithmException, NoSuchProviderException {
+        SecureRandom sr;
+        MessageDigest md;
+        Signature sign;
+        KeyFactory keyFactory;
+
+        sr = SecureRandom.getInstance(shaprng, providerName);
+
+        md = MessageDigest.getInstance(sha_1, providerName);
+        md = MessageDigest.getInstance(sha_1_alias, providerName);
+        md = MessageDigest.getInstance(sha_1_alias2, providerName);
+
+        for ( int i = 0; i < dsaNames.length; i++ ) {
+            sign = Signature.getInstance(dsaNames[i], providerName);
+        }
+
+        for ( int i = 0; i < keyFactoryNames.length; i++ ) {
+            keyFactory = KeyFactory.getInstance(keyFactoryNames[i], providerName);
+        }
+    }
+
+ 
+    public static Test suite() {
+        return new TestSuite(CryptoProviderTest.class);
+    }
+
+    public static void main(String[] args) {
+        junit.textui.TestRunner.run(suite());
+    }
+
+ }

Propchange: incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/impl/java/org/apache/harmony/security/tests/provider/crypto/CryptoProviderTest.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/impl/java/org/apache/harmony/security/tests/provider/crypto/SHA1ImplTest.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/impl/java/org/apache/harmony/security/tests/provider/crypto/SHA1ImplTest.java?view=auto&rev=467267
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/impl/java/org/apache/harmony/security/tests/provider/crypto/SHA1ImplTest.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/impl/java/org/apache/harmony/security/tests/provider/crypto/SHA1ImplTest.java Tue Oct 24 01:02:41 2006
@@ -0,0 +1,253 @@
+/*
+ *  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.security.tests.provider.crypto;
+
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+import org.apache.harmony.security.provider.crypto.SHA1Impl;
+
+import java.security.MessageDigest;
+
+
+/**
+ * Tests against methods in SHA1Impl class.
+ * The input data and results of computing are defined in Secure Hash Standard,
+ * see http://www.itl.nist.gov/fipspubs/fip180-1.htm
+ */
+
+
+public class SHA1ImplTest extends TestCase {
+
+
+    // SHA1Data constant used in below methods
+    private static final int INDEX = SHA1Impl.BYTES_OFFSET;
+
+    private static MessageDigest md;
+
+
+    /*
+     * @see TestCase#setUp()
+     */
+    protected void setUp() throws Exception {
+        super.setUp();
+        md = MessageDigest.getInstance("SHA-1", "Crypto");
+    }
+
+
+    /*
+     * The test checks out that for given three byte input
+     * a value returned by SHA1Impl is equal to both :
+     * - one defined in the Standard and
+     * - one calculated with alternative computation algorithm defined in the Standard.
+     */
+    public final void testOneBlockMessage() {
+
+        int[] words = new int[INDEX +6];	// working array to compute hash
+
+        // values defined in examples in Secure Hash Standard
+        int[] hash1 = {0x67452301, 0xEFCDAB89, 0x98BADCFE, 0x10325476, 0xC3D2E1F0 };
+        int[] hash  = {0xA9993E36, 0x4706816A, 0xBA3E2571, 0x7850C26C, 0x9CD0D89D };
+
+        for (int i = 0; i < words.length; i++ ) {
+            words[i] = 0;
+        }
+        words[0]  = 0x61626380;    // constants from Secure Hash Standard
+        words[15] = 0x00000018;
+
+        alternateHash(words, hash1);
+
+
+        md.update(new byte[]{0x61,0x62,0x63});
+        byte[] dgst = md.digest();
+
+        for ( int k = 0; k < 5; k++ ) {
+            int i = k*4;
+
+            int j = ((dgst[i  ]&0xff)<<24) | ((dgst[i+1]&0xff)<<16) | 
+                    ((dgst[i+2]&0xff)<<8 ) | (dgst[i+3]&0xff)  ;
+
+            assertTrue("false1: k=" + k + " hash1[k]=" + Integer.toHexString(hash1[k]), 
+                       hash[k] == hash1[k] ); 
+
+            assertTrue("false2: k=" + k + " j=" + Integer.toHexString(j), hash[k] == j );
+        }
+    }
+
+
+
+
+    /*
+     * The test checks out that SHA1Impl computes correct value
+     * if data supplied takes exactly fourteen words of sexteen word buffer.
+     */
+    public final void testMultiBlockMessage() {
+
+        // values defined in examples in Secure Hash Standard
+        int[] hash  = {0x84983e44, 0x1c3bd26e, 0xbaae4aa1, 0xf95129e5, 0xe54670f1 };
+
+        // string defined in examples in Secure Hash Standard
+        md.update("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq".getBytes());
+        byte[] dgst = md.digest();
+
+        for ( int k = 0; k < 5; k++ ) {
+            int i = k*4;
+
+                int j = ((dgst[i  ]&0xff)<<24) | ((dgst[i+1]&0xff)<<16) | 
+                        ((dgst[i+2]&0xff)<<8 ) | (dgst[i+3]&0xff)  ;
+
+            assertTrue("false: k=" + k + " j=" + Integer.toHexString(j), hash[k] == j );
+        }
+    }
+
+
+    /*
+     * The test checks out that SHA1Impl returns correct values 
+     * for four different cases of infilling internal buffer and computing intermediate hash.
+     */
+    public final void testLongMessage() {
+
+        // values defined in examples in Secure Hash Standard
+        int[] hash  = {0x34aa973c, 0xd4c4daa4, 0xf61eeb2b, 0xdbad2731, 0x6534016f };
+
+        byte msgs[][] = new byte[][] { {0x61},
+                                       {0x61, 0x61},
+                                       {0x61, 0x61, 0x61},
+                                       {0x61, 0x61, 0x61, 0x61} };
+
+        int lngs[] = new int[]{1000000, 500000, 333333, 250000};
+
+        for ( int n = 0; n < 4; n++ ) {
+
+            for ( int i = 0; i < lngs[n]; i++) {
+                md.update(msgs[n]);
+            }
+            if ( n == 2 ) {
+                md.update(msgs[0]);
+            }
+
+            byte[] dgst = md.digest();
+            for ( int k = 0; k < 5; k++ ) {
+                int i = k*4;
+
+                int j = ((dgst[i  ]&0xff)<<24) | ((dgst[i+1]&0xff)<<16) | 
+                        ((dgst[i+2]&0xff)<<8 ) | (dgst[i+3]&0xff)  ;
+
+                assertTrue("false: n =" + n + "  k=" + k + " j" + Integer.toHexString(j), 
+                            hash[k] == j );
+            }
+        }
+    }
+
+
+    /**
+     * implements alternative algorithm described in the SECURE HASH STANDARD
+     */
+    private void alternateHash(int[] bufW, int[] hash) {
+
+        // constants defned in Secure Hash Standard
+        final int[] K = { 
+
+            0x5A827999, 0x5A827999, 0x5A827999, 0x5A827999,
+            0x5A827999, 0x5A827999, 0x5A827999, 0x5A827999,
+            0x5A827999, 0x5A827999, 0x5A827999, 0x5A827999,
+            0x5A827999, 0x5A827999, 0x5A827999, 0x5A827999,
+            0x5A827999, 0x5A827999, 0x5A827999, 0x5A827999,
+
+            0x6ED9EBA1, 0x6ED9EBA1, 0x6ED9EBA1, 0x6ED9EBA1,
+            0x6ED9EBA1, 0x6ED9EBA1, 0x6ED9EBA1, 0x6ED9EBA1,
+            0x6ED9EBA1, 0x6ED9EBA1, 0x6ED9EBA1, 0x6ED9EBA1,
+            0x6ED9EBA1, 0x6ED9EBA1, 0x6ED9EBA1, 0x6ED9EBA1,
+            0x6ED9EBA1, 0x6ED9EBA1, 0x6ED9EBA1, 0x6ED9EBA1,
+
+            0x8F1BBCDC, 0x8F1BBCDC, 0x8F1BBCDC, 0x8F1BBCDC,
+            0x8F1BBCDC, 0x8F1BBCDC, 0x8F1BBCDC, 0x8F1BBCDC,
+            0x8F1BBCDC, 0x8F1BBCDC, 0x8F1BBCDC, 0x8F1BBCDC,
+            0x8F1BBCDC, 0x8F1BBCDC, 0x8F1BBCDC, 0x8F1BBCDC,
+            0x8F1BBCDC, 0x8F1BBCDC, 0x8F1BBCDC, 0x8F1BBCDC,
+
+            0xCA62C1D6, 0xCA62C1D6, 0xCA62C1D6, 0xCA62C1D6,
+            0xCA62C1D6, 0xCA62C1D6, 0xCA62C1D6, 0xCA62C1D6,
+            0xCA62C1D6, 0xCA62C1D6, 0xCA62C1D6, 0xCA62C1D6,
+            0xCA62C1D6, 0xCA62C1D6, 0xCA62C1D6, 0xCA62C1D6,
+            0xCA62C1D6, 0xCA62C1D6, 0xCA62C1D6, 0xCA62C1D6
+        };
+
+        int  a = hash[0]; //0x67452301 ;
+        int  b = hash[1]; //0xEFCDAB89 ;
+        int  c = hash[2]; //0x98BADCFE ;
+        int  d = hash[3]; //0x10325476 ;
+        int  e = hash[4]; //0xC3D2E1F0 ;
+
+        // implementation constant and variables
+
+        final int MASK = 0x0000000F;
+        int temp;
+        int s;
+        int tmp;
+
+        // computation defined in Secure Hash Standard
+        for ( int t = 0 ; t < 80 ; t++ ) {
+
+            s = t & MASK;
+
+            if ( t >= 16) {
+
+                tmp = bufW[ (s+13)&MASK ] ^ bufW[(s+8)&MASK ] ^ bufW[ (s+2)&MASK ] ^ bufW[s];
+                bufW[s] = ( tmp<<1 ) | ( tmp>>>31 );
+            }
+
+            temp = ( a << 5 ) | ( a >>> 27 );
+
+            if ( t < 20 ) {
+                temp += ( b & c ) | ( (~b) & d ) ;
+            } else if ( t < 40 ) {
+                temp += b ^ c ^ d ;
+            } else if ( t < 60 ) {
+                temp += ( b & c ) | ( b & d ) | ( c & d ) ;
+            } else {
+                temp += b ^ c ^ d ;
+            }
+
+            temp += e + bufW[s] + K[t] ;
+            e = d;
+            d = c;
+            c = ( b<<30 ) | ( b>>>2 ) ;
+            b = a;
+            a = temp;
+        }
+        hash[0] += a;
+        hash[1] += b;
+        hash[2] += c;
+        hash[3] += d;
+        hash[4] += e;
+    }
+
+
+    public static Test suite() {
+        return new TestSuite(SHA1ImplTest.class);
+    }
+
+    public static void main(String[] args) {
+        junit.textui.TestRunner.run(suite());
+    }
+
+ }

Propchange: incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/impl/java/org/apache/harmony/security/tests/provider/crypto/SHA1ImplTest.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/impl/java/org/apache/harmony/security/tests/provider/crypto/SHA1PRNG_SecureRandomTest.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/impl/java/org/apache/harmony/security/tests/provider/crypto/SHA1PRNG_SecureRandomTest.java?view=auto&rev=467267
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/impl/java/org/apache/harmony/security/tests/provider/crypto/SHA1PRNG_SecureRandomTest.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/impl/java/org/apache/harmony/security/tests/provider/crypto/SHA1PRNG_SecureRandomTest.java Tue Oct 24 01:02:41 2006
@@ -0,0 +1,421 @@
+/*
+ *  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.security.tests.provider.crypto;
+
+
+import java.security.InvalidParameterException;
+import java.security.Security;
+import java.security.SecureRandom;
+import java.security.NoSuchAlgorithmException;
+import java.security.NoSuchProviderException;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+
+/**
+ * Tests against methods in SecureRandom class object using SHA1PRNG_SecureRandomImpl.
+ */
+
+
+public class SHA1PRNG_SecureRandomTest extends TestCase {
+
+
+    private static final int LENGTH = 100;               // constant defining loop limit
+    private static final int INCR   = 10;                // constant defining loop increment
+
+    private static final String algorithm = "SHA1PRNG";  // algorithm's name
+    private static final String provider  = "Crypto";   // provider'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, provider);
+        sr2 = SecureRandom.getInstance(algorithm, provider);
+    }
+
+
+    /**
+     * 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 {
+
+        SecureRandom sr1;    // these are needed to test new SecureRandom objects in loop
+        SecureRandom sr2;    //
+
+        byte[] myBytes;
+        byte[] myBytes1;
+        byte[] myBytes2;
+
+        for ( int i = 1; i < LENGTH/2; i+=INCR ) {
+
+            sr1 = SecureRandom.getInstance(algorithm, provider);
+            sr2 = SecureRandom.getInstance(algorithm, provider);
+
+            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];
+            }
+            if ( flag ) {
+                fail("unexpected: myBytes1[] == myBytes2[]  :: 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
+     * invokation 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
+     * invokation 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 {
+
+        SecureRandom sr1;    // these are needed to test new SecureRandom objects in loop
+        SecureRandom sr2;    //
+
+        byte[] myBytes;
+        byte[] myBytes1;
+        byte[] myBytes2;
+
+        // case 1:
+        for ( int i = 1; i < LENGTH/2; i+=INCR ) {
+
+            sr1 = SecureRandom.getInstance(algorithm, provider);
+            sr2 = SecureRandom.getInstance(algorithm, provider);
+
+            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];
+            }
+            if ( flag ) {
+                fail("unexpected: myBytes1[] == myBytes2[]  :: 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, provider);
+            sr2 = SecureRandom.getInstance(algorithm, provider);
+
+            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 sipplied with the same seed is additionally
+     *   sipplied 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);
+        }
+
+    }
+
+
+    public static Test suite() {
+        return new TestSuite(SHA1PRNG_SecureRandomTest.class);
+    }
+
+    public static void main(String[] args) {
+        junit.textui.TestRunner.run(suite());
+    }
+
+}

Propchange: incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/impl/java/org/apache/harmony/security/tests/provider/crypto/SHA1PRNG_SecureRandomTest.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/impl/java/org/apache/harmony/security/tests/provider/crypto/serialization/SHA1PRNG_SecureRandomTest.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/impl/java/org/apache/harmony/security/tests/provider/crypto/serialization/SHA1PRNG_SecureRandomTest.java?view=auto&rev=467267
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/impl/java/org/apache/harmony/security/tests/provider/crypto/serialization/SHA1PRNG_SecureRandomTest.java (added)
+++ incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/impl/java/org/apache/harmony/security/tests/provider/crypto/serialization/SHA1PRNG_SecureRandomTest.java Tue Oct 24 01:02:41 2006
@@ -0,0 +1,415 @@
+/*
+ *  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.security.tests.provider.crypto.serialization;
+
+
+import org.apache.harmony.testframework.serialization.SerializationTest;
+import org.apache.harmony.testframework.serialization.SerializationTest.SerializableAssert;
+
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+
+import java.security.Security;
+import java.security.SecureRandom;
+import java.security.NoSuchAlgorithmException;
+import java.security.NoSuchProviderException;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.FileInputStream;
+import java.io.Serializable;
+
+
+/**
+ * Tests against SecureRandom with SHA1PRNG serialization
+ */
+
+
+public class SHA1PRNG_SecureRandomTest extends TestCase {
+
+
+    private static final int LIMIT1 = 100;   // constant value limiting loop
+    private static final int LIMIT2 = 50;    //
+
+    private static final int CASES = 4;
+ 
+    static String algorithm = "SHA1PRNG";    // name of algorithm
+    static String provider  = "Crypto";     // name of provider
+
+    private int testcase = 0;
+
+    private byte zero[] = new byte[0];
+
+    private int flag;
+    private static final int SELF   = 0;
+    private static final int GOLDEN = 1;
+
+
+    /**
+     * @return array of SecureRandom objects to be deserialized in tests.
+     */
+    protected Object[] getData() {
+
+        SecureRandom sr;
+        Object[] data = new Object[5];
+      
+
+        for ( int i = 0; i < data.length ; i++ ) {
+            try {
+                sr = SecureRandom.getInstance(algorithm, provider);
+
+                switch (i) {
+
+                  case 0 : break;
+
+                  case 1 : sr.setSeed( zero );
+                           break;
+
+                  case 2 : sr.setSeed( new byte[] { (byte)1 } );
+                           break;
+
+                  case 3 : sr.nextBytes( zero );
+                           break;
+
+                  case 4 : sr.nextBytes( new byte[1] );
+                           break;
+                }
+                data[i] = sr;
+ 
+            } catch (NoSuchAlgorithmException e) {
+                throw new RuntimeException("ATTENTION: " + e);
+            } catch (NoSuchProviderException e) {
+                throw new RuntimeException("ATTENTION: " + e);
+            }
+        }
+        return data;
+    };
+
+
+    /**
+     * Compareing sequencies of bytes 
+     * returned by "nextBytes(..)" of referenced and tested objects
+     */
+    private void testingSame(SecureRandom ref, SecureRandom test) {
+
+        byte refBytes[]  = null;
+        byte testBytes[] = null;
+
+        for ( int k = 0; k < LIMIT2; k++ ) {
+
+            for ( int i = 0; i < LIMIT1; i++ ) {
+
+                refBytes  = new byte[i];
+                testBytes = new byte[i];
+
+                ref.nextBytes(refBytes);
+                test.nextBytes(testBytes);
+
+                for (int j = 0; j < refBytes.length; j++ ) {
+                    assertTrue("NOT same:  testcase =" + testcase +
+                               " k=" +k + " i=" +i + " j=" +j +
+                               " refBytes[j]=" + refBytes[j] + " testBytes[j]=" + testBytes[j],
+                                refBytes[j] == testBytes[j] );
+                }
+            }
+            ref.setSeed(refBytes);
+            test.setSeed(testBytes);
+        }
+    }
+
+
+    /**
+     * Compareing sequencies of bytes 
+     * returned by "nextBytes(..)" of referenced and tested objects
+     */
+    private void testingNotSame(SecureRandom ref, SecureRandom test) {
+
+        byte refTotalBytes[]  = new byte[(LIMIT1*LIMIT1)/2];
+        byte testTotalBytes[] = new byte[(LIMIT1*LIMIT1)/2];
+
+        for ( int k = 0; k < LIMIT2; k++ ) {
+
+            byte refBytes[]  = null;
+            byte testBytes[] = null;
+
+            int n = 0;
+
+            for ( int i = 0; i < LIMIT1; i++ ) {
+
+                refBytes  = new byte[i];
+                testBytes = new byte[i];
+
+                ref.nextBytes(refBytes);
+                test.nextBytes(testBytes);
+
+                System.arraycopy(refBytes,  0, refTotalBytes,  n, refBytes.length);
+                System.arraycopy(testBytes, 0, testTotalBytes, n, testBytes.length);
+
+                n += i;
+            }
+
+            boolean b = true;
+            int j = 0;
+            for ( int n1 = 0 ; n1 <= n ; n1++) {
+
+                b &= refTotalBytes[n1] == testTotalBytes[n1];
+
+                if ( j >= 20 || n1 == n ) {
+                    assertFalse("the same sequencies :: testcase=" + testcase + 
+                                " k=" +k + "n1 =" + n1, b);
+                    b = true;
+                    j = 0;
+                }
+                j++;
+            }
+
+            ref.setSeed(refBytes);
+            test.setSeed(testBytes);
+        }
+    }
+
+
+    private SerializableAssert comparator = new SerializableAssert(){
+
+        /**
+         * Tests that data objects can be serialized and deserialized without exceptions 
+         * and the deserialization produces object of the same class.
+         */
+        public void assertDeserialized(Serializable reference, Serializable test) {
+
+            SecureRandom ref = (SecureRandom) reference;
+            SecureRandom tst = (SecureRandom) test;
+
+            boolean b;
+            byte seed[] = new byte[]{ 0 };
+
+            switch ( testcase ) {
+
+              // non-initialized object
+
+              case 0 : // testing setSeed(..)
+                       ref.setSeed(zero);
+                       tst.setSeed(zero);
+                       testingSame(ref, tst);
+                       break;
+
+              case 5 : // testing setSeed(..)
+                       ref.setSeed(seed);
+                       tst.setSeed(seed);
+                       testingSame(ref, tst);
+                       break;
+
+              case 10 : // testing nextBytes(..)
+                        ref.nextBytes(zero);
+                        tst.nextBytes(zero);
+                        testingNotSame(ref, tst);
+                        break;
+
+              case 15 : // testing nextBytes(..)
+                        ref.nextBytes(seed);
+                        tst.nextBytes(seed);
+                        testingNotSame(ref, tst);
+                        break;
+
+              // object initialized with setSeed(zero)
+
+              case 1 : // testing setSeed(..)
+                       ref.setSeed(zero);
+                       tst.setSeed(zero);
+                       testingSame(ref, tst);
+                       break;
+
+              case 6 : // testing setSeed(..)
+                       ref.setSeed(seed);
+                       tst.setSeed(seed);
+                       testingSame(ref, tst);
+                       break;
+
+              case 11 : // testing nextBytes(..)
+                        ref.nextBytes(zero);
+                        tst.nextBytes(zero);
+                        testingSame(ref, tst);
+                        break;
+
+              case 16 : // testing nextBytes(..)
+                        ref.nextBytes(seed);
+                        tst.nextBytes(seed);
+                        testingSame(ref, tst);
+                        break;
+
+              // object initialized with setSeed(seed)
+
+              case 2 : // testing setSeed(..)
+                       ref.setSeed(zero);
+                       tst.setSeed(zero);
+                       testingSame(ref, tst);
+                       break;
+
+              case 7 : // testing setSeed(..)
+                       ref.setSeed(seed);
+                       tst.setSeed(seed);
+                       testingSame(ref, tst);
+                       break;
+
+              case 12 : // testing nextBytes(..)
+                        ref.nextBytes(zero);
+                        tst.nextBytes(zero);
+                        testingSame(ref, tst);
+                        break;
+
+              case 17 : // testing nextBytes(..)
+                        ref.nextBytes(seed);
+                        tst.nextBytes(seed);
+                        testingSame(ref, tst);
+                        break;
+
+              // object initialized with nextBytes(zero)
+
+              case 3 : // testing setSeed(..)
+                       ref.setSeed(zero);
+                       tst.setSeed(zero);
+                       if ( flag == SELF ) {
+                           testingSame(ref, tst);
+                       } else {
+                           testingNotSame(ref, tst);
+                       }
+                       break;
+
+              case 8 : // testing setSeed(..)
+                       ref.setSeed(seed);
+                       tst.setSeed(seed);
+                       if ( flag == SELF ) {
+                           testingSame(ref, tst);
+                       } else {
+                           testingNotSame(ref, tst);
+                       }
+                       break;
+
+              case 13 : // testing nextBytes(..)
+                        ref.nextBytes(zero);
+                        tst.nextBytes(zero);
+                        if ( flag == SELF ) {
+                            testingSame(ref, tst);
+                        } else {
+                            testingNotSame(ref, tst);
+                        }
+                        break;
+
+              case 18 : // testing nextBytes(..)
+                        ref.nextBytes(seed);
+                        tst.nextBytes(seed);
+                        if ( flag == SELF ) {
+                            testingSame(ref, tst);
+                        } else {
+                            testingNotSame(ref, tst);
+                        }
+                        break;
+
+              // object initialized with nextBytes(seed)
+
+              case 4 : // testing setSeed(..)
+                       ref.setSeed(zero);
+                       tst.setSeed(zero);
+                       if ( flag == SELF ) {
+                           testingSame(ref, tst);
+                       } else {
+                           testingNotSame(ref, tst);
+                       }
+                       break;
+
+              case 9 : // testing setSeed(..)
+                       ref.setSeed(seed);
+                       tst.setSeed(seed);
+                       if ( flag == SELF ) {
+                       testingSame(ref, tst);
+                       } else {
+                           testingNotSame(ref, tst);
+                       }
+                       break;
+
+              case 14 : // testing nextBytes(..)
+                        ref.nextBytes(zero);
+                        tst.nextBytes(zero);
+                        if ( flag == SELF ) {
+                            testingSame(ref, tst);
+                        } else {
+                            testingNotSame(ref, tst);
+                        }
+                        break;
+
+               case 19 : // testing nextBytes(..)
+                         ref.nextBytes(seed);
+                         tst.nextBytes(seed);
+                         if ( flag == SELF ) {
+                             testingSame(ref, tst);
+                         } else {
+                             testingNotSame(ref, tst);
+                         }
+                         break;
+
+               default: fail("ATTENTION: default case is not expected to happen");
+            }
+            testcase++;
+        }
+    };
+
+
+    /**
+     * Testing deserialized object.
+     */
+    public void testSerializationSelf() throws Exception {
+
+        Object[] data;
+
+        flag = SELF;
+        for ( int i = 0; i < CASES; i++ ) {
+
+            data = getData();
+            SerializationTest.verifySelf(data, comparator);
+        }
+    }
+
+
+    /**
+     * Testing that SecureRandom with SHA1PRNG objects can be deserialized from golden files.
+     */
+    public void testSerializationCompartibility() throws Exception {
+
+        Object[] data;
+
+        flag = GOLDEN;
+        for ( int i = 0; i < CASES; i++ ) {
+
+            data = getData();
+            SerializationTest.verifyGolden(this, data, comparator);
+        }
+    }
+
+
+    public static Test suite() {
+        return new TestSuite(SHA1PRNG_SecureRandomTest.class);
+    }
+
+    public static void main(String[] args)  {
+        junit.textui.TestRunner.run(suite());
+    }
+
+}

Propchange: incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/impl/java/org/apache/harmony/security/tests/provider/crypto/serialization/SHA1PRNG_SecureRandomTest.java
------------------------------------------------------------------------------
    svn:eol-style = native

Added: incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/resources/serialization/org/apache/harmony/security/tests/provider/crypto/serialization/SHA1PRNG_SecureRandomTest.golden.0.ser
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/resources/serialization/org/apache/harmony/security/tests/provider/crypto/serialization/SHA1PRNG_SecureRandomTest.golden.0.ser?view=auto&rev=467267
==============================================================================
Binary file - no diff available.

Propchange: incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/resources/serialization/org/apache/harmony/security/tests/provider/crypto/serialization/SHA1PRNG_SecureRandomTest.golden.0.ser
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/resources/serialization/org/apache/harmony/security/tests/provider/crypto/serialization/SHA1PRNG_SecureRandomTest.golden.1.ser
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/resources/serialization/org/apache/harmony/security/tests/provider/crypto/serialization/SHA1PRNG_SecureRandomTest.golden.1.ser?view=auto&rev=467267
==============================================================================
Binary file - no diff available.

Propchange: incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/resources/serialization/org/apache/harmony/security/tests/provider/crypto/serialization/SHA1PRNG_SecureRandomTest.golden.1.ser
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/resources/serialization/org/apache/harmony/security/tests/provider/crypto/serialization/SHA1PRNG_SecureRandomTest.golden.2.ser
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/resources/serialization/org/apache/harmony/security/tests/provider/crypto/serialization/SHA1PRNG_SecureRandomTest.golden.2.ser?view=auto&rev=467267
==============================================================================
Binary file - no diff available.

Propchange: incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/resources/serialization/org/apache/harmony/security/tests/provider/crypto/serialization/SHA1PRNG_SecureRandomTest.golden.2.ser
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/resources/serialization/org/apache/harmony/security/tests/provider/crypto/serialization/SHA1PRNG_SecureRandomTest.golden.3.ser
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/resources/serialization/org/apache/harmony/security/tests/provider/crypto/serialization/SHA1PRNG_SecureRandomTest.golden.3.ser?view=auto&rev=467267
==============================================================================
Binary file - no diff available.

Propchange: incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/resources/serialization/org/apache/harmony/security/tests/provider/crypto/serialization/SHA1PRNG_SecureRandomTest.golden.3.ser
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream

Added: incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/resources/serialization/org/apache/harmony/security/tests/provider/crypto/serialization/SHA1PRNG_SecureRandomTest.golden.4.ser
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/resources/serialization/org/apache/harmony/security/tests/provider/crypto/serialization/SHA1PRNG_SecureRandomTest.golden.4.ser?view=auto&rev=467267
==============================================================================
Binary file - no diff available.

Propchange: incubator/harmony/enhanced/classlib/trunk/modules/security/src/test/resources/serialization/org/apache/harmony/security/tests/provider/crypto/serialization/SHA1PRNG_SecureRandomTest.golden.4.ser
------------------------------------------------------------------------------
    svn:mime-type = application/octet-stream



Mime
View raw message