From f0429097a74dc0341bb7e6e4825152fc36b657f0 Mon Sep 17 00:00:00 2001
From: Stephen Smalley <sds@tycho.nsa.gov>
Date: Fri, 13 Jan 2012 08:43:27 -0500
Subject: Extend forkAndSpecialize to take further input arguments.

Extend forkAndSpecialize to take two further input arguments,
a seInfo string and the niceName for the process.  These can be used
as further selectors in determining the SELinux security context for
the process.

Change-Id: If3a654070025e699b2266425f6eb8ab7e6b8c562
---
 dalvik/src/main/java/dalvik/system/Zygote.java | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/dalvik/src/main/java/dalvik/system/Zygote.java b/dalvik/src/main/java/dalvik/system/Zygote.java
index 28c9912..ec114ed 100644
--- a/dalvik/src/main/java/dalvik/system/Zygote.java
+++ b/dalvik/src/main/java/dalvik/system/Zygote.java
@@ -107,20 +107,23 @@ public class Zygote {
      * dimension having a length of 3 and representing
      * (resource, rlim_cur, rlim_max). These are set via the posix
      * setrlimit(2) call.
+     * @param seInfo null-ok a string specifying SEAndroid information for
+     * the new process.
+     * @param niceName null-ok a string specifying the process name.
      *
      * @return 0 if this is the child, pid of the child
      * if this is the parent, or -1 on error.
      */
     public static int forkAndSpecialize(int uid, int gid, int[] gids,
-            int debugFlags, int[][] rlimits) {
+            int debugFlags, int[][] rlimits, String seInfo, String niceName) {
         preFork();
-        int pid = nativeForkAndSpecialize(uid, gid, gids, debugFlags, rlimits);
+        int pid = nativeForkAndSpecialize(uid, gid, gids, debugFlags, rlimits, seInfo, niceName);
         postFork();
         return pid;
     }
 
     native public static int nativeForkAndSpecialize(int uid, int gid,
-            int[] gids, int debugFlags, int[][] rlimits);
+            int[] gids, int debugFlags, int[][] rlimits, String seInfo, String niceName);
 
     /**
      * Forks a new VM instance.
@@ -130,7 +133,7 @@ public class Zygote {
     public static int forkAndSpecialize(int uid, int gid, int[] gids,
             boolean enableDebugger, int[][] rlimits) {
         int debugFlags = enableDebugger ? DEBUG_ENABLE_DEBUGGER : 0;
-        return forkAndSpecialize(uid, gid, gids, debugFlags, rlimits);
+        return forkAndSpecialize(uid, gid, gids, debugFlags, rlimits, null, null);
     }
 
     /**
@@ -175,7 +178,7 @@ public class Zygote {
     public static int forkSystemServer(int uid, int gid, int[] gids,
             boolean enableDebugger, int[][] rlimits) {
         int debugFlags = enableDebugger ? DEBUG_ENABLE_DEBUGGER : 0;
-        return forkAndSpecialize(uid, gid, gids, debugFlags, rlimits);
+        return forkAndSpecialize(uid, gid, gids, debugFlags, rlimits, null, null);
     }
 
     native public static int nativeForkSystemServer(int uid, int gid,
-- 
cgit v1.1


From c6d24c6b88ce50c1fa2b9e89253d5839eff1618a Mon Sep 17 00:00:00 2001
From: Lukasz Rymanowski <lukasz.rymanowski@tieto.com>
Date: Wed, 7 Dec 2011 12:59:32 +0100
Subject: BT: Adding support for wrf files to BT OPP

This patch adds support for wrf files to BT OPP.
Proper mime type /application/octet-stream with extension
wrf was added to webkit framework.

Change-Id: I2cdd961a78281129b96fba51d5df37c534c5c893
Signed-off-by: Christian Bejram <christian.bejram@stericsson.com>
---
 luni/src/main/java/libcore/net/MimeUtils.java | 1 +
 1 file changed, 1 insertion(+)

diff --git a/luni/src/main/java/libcore/net/MimeUtils.java b/luni/src/main/java/libcore/net/MimeUtils.java
index 8371c68..4681bbc 100644
--- a/luni/src/main/java/libcore/net/MimeUtils.java
+++ b/luni/src/main/java/libcore/net/MimeUtils.java
@@ -349,6 +349,7 @@ public final class MimeUtils {
         add("video/x-ms-wvx", "wvx");
         add("video/x-msvideo", "avi");
         add("video/x-sgi-movie", "movie");
+        add("video/x-webex", "wrf");
         add("x-conference/x-cooltalk", "ice");
         add("x-epoc/x-sisx-app", "sisx");
         applyOverrides();
-- 
cgit v1.1


From 3ec5e434af58fedddcb34e08dbd021bfb78bc69c Mon Sep 17 00:00:00 2001
From: Masanori Ogino <ogino.masanori@sharp.co.jp>
Date: Tue, 17 Apr 2012 17:20:55 +0900
Subject: Avoid a wavy result for InterruptReadable/WritableChannel test

Currently Thread#interrupt() API cannot interrupt (just close fd)
even if a thread is blocking in I/O operation for an InterruptibleChannel.
In other words, if a thread is blocked by read()/write() operation,
then the Thread#interrupt() from another thread will close fd,
but it cannot interrupt the blocking operation of Channel.
In this test case, if the calling sequence is interrupt() -->read()/
write() (actually it occurs on many dual core ICS devices),
then the test passes. Because the fd has already been closed.
However, if the order of the calling sequence would change to
read()/write() --> interrupt(), the test fails (i.e, I/O operation
will not return). It occurs on a device which has a  single core
processor. Indeed, if I change the test case by adding sleep()
before interrupt() then it fails on Galaxy Nexus.

The blocking call stack is below;
at libcore.io.Posix.readBytes(Native Method) <-- BLOCKED!
at libcore.io.Posix.read(Posix.java:113)
at libcore.io.BlockGuardOs.read(BlockGuardOs.java:144)
at java.nio.FileChannelImpl.readImpl(FileChannelImpl.java:294)
at java.nio.FileChannelImpl.read(FileChannelImpl.java:278)
at java.nio.PipeImpl$PipeSourceChannel.read(PipeImpl.java:89)
at libcore.java.io.InterruptedStreamTest.
        testInterruptReadableChannel(InterruptedStreamTest.java:133)
...

So the test should be wait before interrupting the current thread
in order to avoid a wavy result for these test cases.
They will pass after the interruption of blocked operation
in Channel is implemented correctly.

And also I correct a wrong method call from
testInterruptWritableSocketChannel().

Change-Id: Iaae3128d264070e818dc82d831ea8048bb43ad4a
---
 luni/src/test/java/libcore/java/io/InterruptedStreamTest.java | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)
 mode change 100644 => 100755 luni/src/test/java/libcore/java/io/InterruptedStreamTest.java

diff --git a/luni/src/test/java/libcore/java/io/InterruptedStreamTest.java b/luni/src/test/java/libcore/java/io/InterruptedStreamTest.java
old mode 100644
new mode 100755
index e973b8f..e1f51bd
--- a/luni/src/test/java/libcore/java/io/InterruptedStreamTest.java
+++ b/luni/src/test/java/libcore/java/io/InterruptedStreamTest.java
@@ -28,6 +28,7 @@ import java.net.InetSocketAddress;
 import java.net.Socket;
 import java.nio.ByteBuffer;
 import java.nio.channels.ClosedByInterruptException;
+import java.nio.channels.ClosedChannelException;
 import java.nio.channels.Pipe;
 import java.nio.channels.ReadableByteChannel;
 import java.nio.channels.ServerSocketChannel;
@@ -93,7 +94,7 @@ public final class InterruptedStreamTest extends TestCase {
 
     public void testInterruptWritableSocketChannel() throws Exception {
         sockets = newSocketChannelPair();
-        testInterruptReadableChannel(sockets[0].getChannel());
+        testInterruptWritableChannel(sockets[0].getChannel());
     }
 
     /**
@@ -166,6 +167,7 @@ public final class InterruptedStreamTest extends TestCase {
                 channel.write(ByteBuffer.allocate(BUFFER_SIZE));
             }
         } catch (ClosedByInterruptException expected) {
+        } catch (ClosedChannelException expected) {
         }
     }
 
@@ -173,6 +175,10 @@ public final class InterruptedStreamTest extends TestCase {
         final Thread toInterrupt = Thread.currentThread();
         new Thread(new Runnable () {
             @Override public void run() {
+                try {
+                    Thread.sleep(1000);
+                } catch (InterruptedException ex) {
+                }
                 toInterrupt.interrupt();
             }
         }).start();
-- 
cgit v1.1


From b7e0772d25499ddf5435e53a90cf1a6d753786d7 Mon Sep 17 00:00:00 2001
From: Chris Dearman <chris@mips.com>
Date: Tue, 1 May 2012 16:11:58 -0700
Subject: [MIPS] Add MIPS Architecture support

Change-Id: Idce58bad54a3f25dbe984c580cb6a48cc906ba76
Signed-off-by: Chris Dearman <chris@mips.com>
---
 luni/src/main/native/libcore_io_Memory.cpp      | 131 ++++++++++++++++--------
 luni/src/main/native/libcore_io_OsConstants.cpp |   2 +
 luni/src/test/java/libcore/io/MemoryTest.java   | 120 ++++++++++++++++------
 3 files changed, 177 insertions(+), 76 deletions(-)

diff --git a/luni/src/main/native/libcore_io_Memory.cpp b/luni/src/main/native/libcore_io_Memory.cpp
index 2200453..a511978 100644
--- a/luni/src/main/native/libcore_io_Memory.cpp
+++ b/luni/src/main/native/libcore_io_Memory.cpp
@@ -31,49 +31,114 @@
 #if defined(__arm__)
 // 32-bit ARM has load/store alignment restrictions for longs.
 #define LONG_ALIGNMENT_MASK 0x3
+#define INT_ALIGNMENT_MASK 0x0
+#define SHORT_ALIGNMENT_MASK 0x0
+#elif defined(__mips__)
+// MIPS has load/store alignment restrictions for longs, ints and shorts.
+#define LONG_ALIGNMENT_MASK 0x7
+#define INT_ALIGNMENT_MASK 0x3
+#define SHORT_ALIGNMENT_MASK 0x1
 #elif defined(__i386__)
 // x86 can load anything at any alignment.
 #define LONG_ALIGNMENT_MASK 0x0
+#define INT_ALIGNMENT_MASK 0x0
+#define SHORT_ALIGNMENT_MASK 0x0
 #else
 #error unknown load/store alignment restrictions for this architecture
 #endif
 
+// Use packed structures for access to unaligned data on targets with alignment restrictions.
+// The compiler will generate appropriate code to access these structures without
+// generating alignment exceptions.
+template <typename T> static inline T get_unaligned(const T* address) {
+    struct unaligned { T v; } __attribute__ ((packed));
+    const unaligned* p = reinterpret_cast<const unaligned*>(address);
+    return p->v;
+}
+
+template <typename T> static inline void put_unaligned(T* address, T v) {
+    struct unaligned { T v; } __attribute__ ((packed));
+    unaligned* p = reinterpret_cast<unaligned*>(address);
+    p->v = v;
+}
+
 template <typename T> static T cast(jint address) {
     return reinterpret_cast<T>(static_cast<uintptr_t>(address));
 }
 
+// Byte-swap 2 jshort values packed in a jint.
+static inline jint bswap_2x16(jint v) {
+    // v is initially ABCD
+    v = bswap_32(v);                              // v=DCBA
+#if defined(__mips__) && defined(__mips_isa_rev) && (__mips_isa_rev >= 2)
+    __asm__ volatile ("wsbh %0, %0" : "+r" (v));  // v=BADC
+#else
+    v = (v << 16) | ((v >> 16) & 0xffff);         // v=BADC
+#endif
+    return v;
+}
+
 static inline void swapShorts(jshort* dstShorts, const jshort* srcShorts, size_t count) {
     // Do 32-bit swaps as long as possible...
     jint* dst = reinterpret_cast<jint*>(dstShorts);
     const jint* src = reinterpret_cast<const jint*>(srcShorts);
-    for (size_t i = 0; i < count / 2; ++i) {
-        jint v = *src++;                            // v=ABCD
-        v = bswap_32(v);                            // v=DCBA
-        jint v2 = (v << 16) | ((v >> 16) & 0xffff); // v=BADC
-        *dst++ = v2;
-    }
-    // ...with one last 16-bit swap if necessary.
-    if ((count % 2) != 0) {
-        jshort v = *reinterpret_cast<const jshort*>(src);
-        *reinterpret_cast<jshort*>(dst) = bswap_16(v);
+
+    if ((reinterpret_cast<uintptr_t>(dst) & INT_ALIGNMENT_MASK) == 0 &&
+        (reinterpret_cast<uintptr_t>(src) & INT_ALIGNMENT_MASK) == 0) {
+        for (size_t i = 0; i < count / 2; ++i) {
+            jint v = *src++;
+            *dst++ = bswap_2x16(v);
+        }
+        // ...with one last 16-bit swap if necessary.
+        if ((count % 2) != 0) {
+            jshort v = *reinterpret_cast<const jshort*>(src);
+            *reinterpret_cast<jshort*>(dst) = bswap_16(v);
+        }
+    } else {
+        for (size_t i = 0; i < count / 2; ++i) {
+            jint v = get_unaligned<jint>(src++);
+            put_unaligned<jint>(dst++, bswap_2x16(v));
+        }
+        if ((count % 2) != 0) {
+          jshort v = get_unaligned<jshort>(reinterpret_cast<const jshort*>(src));
+          put_unaligned<jshort>(reinterpret_cast<jshort*>(dst), bswap_16(v));
+        }
     }
 }
 
 static inline void swapInts(jint* dstInts, const jint* srcInts, size_t count) {
-    for (size_t i = 0; i < count; ++i) {
-        jint v = *srcInts++;
-        *dstInts++ = bswap_32(v);
+    if ((reinterpret_cast<uintptr_t>(dstInts) & INT_ALIGNMENT_MASK) == 0 &&
+        (reinterpret_cast<uintptr_t>(srcInts) & INT_ALIGNMENT_MASK) == 0) {
+        for (size_t i = 0; i < count; ++i) {
+            jint v = *srcInts++;
+            *dstInts++ = bswap_32(v);
+        }
+    } else {
+        for (size_t i = 0; i < count; ++i) {
+            jint v = get_unaligned<int>(srcInts++);
+            put_unaligned<jint>(dstInts++, bswap_32(v));
+        }
     }
 }
 
 static inline void swapLongs(jlong* dstLongs, const jlong* srcLongs, size_t count) {
     jint* dst = reinterpret_cast<jint*>(dstLongs);
     const jint* src = reinterpret_cast<const jint*>(srcLongs);
-    for (size_t i = 0; i < count; ++i) {
-        jint v1 = *src++;
-        jint v2 = *src++;
-        *dst++ = bswap_32(v2);
-        *dst++ = bswap_32(v1);
+    if ((reinterpret_cast<uintptr_t>(dstLongs) & INT_ALIGNMENT_MASK) == 0 &&
+        (reinterpret_cast<uintptr_t>(srcLongs) & INT_ALIGNMENT_MASK) == 0) {
+        for (size_t i = 0; i < count; ++i) {
+          jint v1 = *src++;
+          jint v2 = *src++;
+          *dst++ = bswap_32(v2);
+          *dst++ = bswap_32(v1);
+        }
+    } else {
+        for (size_t i = 0; i < count; ++i) {
+            jint v1 = get_unaligned<jint>(src++);
+            jint v2 = get_unaligned<jint>(src++);
+            put_unaligned<jint>(dst++, bswap_32(v2));
+            put_unaligned<jint>(dst++, bswap_32(v1));
+        }
     }
 }
 
@@ -226,20 +291,11 @@ static void Memory_pokeInt(JNIEnv*, jclass, jint dstAddress, jint value, jboolea
 
 static jlong Memory_peekLong(JNIEnv*, jclass, jint srcAddress, jboolean swap) {
     jlong result;
+    const jlong* src = cast<const jlong*>(srcAddress);
     if ((srcAddress & LONG_ALIGNMENT_MASK) == 0) {
-        result = *cast<const jlong*>(srcAddress);
+        result = *src;
     } else {
-        // Handle unaligned memory access one byte at a time
-        const jbyte* src = cast<const jbyte*>(srcAddress);
-        jbyte* dst = reinterpret_cast<jbyte*>(&result);
-        dst[0] = src[0];
-        dst[1] = src[1];
-        dst[2] = src[2];
-        dst[3] = src[3];
-        dst[4] = src[4];
-        dst[5] = src[5];
-        dst[6] = src[6];
-        dst[7] = src[7];
+        result = get_unaligned<jlong>(src);
     }
     if (swap) {
         result = bswap_64(result);
@@ -248,23 +304,14 @@ static jlong Memory_peekLong(JNIEnv*, jclass, jint srcAddress, jboolean swap) {
 }
 
 static void Memory_pokeLong(JNIEnv*, jclass, jint dstAddress, jlong value, jboolean swap) {
+    jlong* dst = cast<jlong*>(dstAddress);
     if (swap) {
         value = bswap_64(value);
     }
     if ((dstAddress & LONG_ALIGNMENT_MASK) == 0) {
-        *cast<jlong*>(dstAddress) = value;
+        *dst = value;
     } else {
-        // Handle unaligned memory access one byte at a time
-        const jbyte* src = reinterpret_cast<const jbyte*>(&value);
-        jbyte* dst = cast<jbyte*>(dstAddress);
-        dst[0] = src[0];
-        dst[1] = src[1];
-        dst[2] = src[2];
-        dst[3] = src[3];
-        dst[4] = src[4];
-        dst[5] = src[5];
-        dst[6] = src[6];
-        dst[7] = src[7];
+        put_unaligned<jlong>(dst, value);
     }
 }
 
diff --git a/luni/src/main/native/libcore_io_OsConstants.cpp b/luni/src/main/native/libcore_io_OsConstants.cpp
index 942cfce..c432973 100644
--- a/luni/src/main/native/libcore_io_OsConstants.cpp
+++ b/luni/src/main/native/libcore_io_OsConstants.cpp
@@ -275,7 +275,9 @@ static void OsConstants_initConstants(JNIEnv* env, jclass c) {
     initConstant(env, c, "SIGRTMAX", SIGRTMAX);
     initConstant(env, c, "SIGRTMIN", SIGRTMIN);
     initConstant(env, c, "SIGSEGV", SIGSEGV);
+#if defined(SIGSTKFLT)
     initConstant(env, c, "SIGSTKFLT", SIGSTKFLT);
+#endif
     initConstant(env, c, "SIGSTOP", SIGSTOP);
     initConstant(env, c, "SIGSYS", SIGSYS);
     initConstant(env, c, "SIGTERM", SIGTERM);
diff --git a/luni/src/test/java/libcore/io/MemoryTest.java b/luni/src/test/java/libcore/io/MemoryTest.java
index a533f15..9a596fb 100644
--- a/luni/src/test/java/libcore/io/MemoryTest.java
+++ b/luni/src/test/java/libcore/io/MemoryTest.java
@@ -18,6 +18,7 @@
 package libcore.io;
 
 import dalvik.system.VMRuntime;
+import java.util.Arrays;
 import junit.framework.TestCase;
 
 public class MemoryTest extends TestCase {
@@ -28,65 +29,116 @@ public class MemoryTest extends TestCase {
             swappedValues[i] = Integer.reverseBytes(values[i]);
         }
 
-        int scale = 4;
+        int scale = SizeOf.INT;
         VMRuntime runtime = VMRuntime.getRuntime();
-        byte[] array = (byte[]) runtime.newNonMovableArray(byte.class, scale * values.length);
-        int ptr = (int) runtime.addressOf(array);
+        byte[] array = (byte[]) runtime.newNonMovableArray(byte.class, scale * values.length + 1);
+        int base_ptr = (int) runtime.addressOf(array);
 
-        // Regular copy.
-        Memory.pokeIntArray(ptr, values, 0, values.length, false);
-        assertIntsEqual(values, ptr, false);
-        assertIntsEqual(swappedValues, ptr, true);
+        for (int ptr_offset = 0; ptr_offset < 2; ++ptr_offset) {
+            int ptr = base_ptr + ptr_offset; // To test aligned and unaligned accesses.
+            Arrays.fill(array, (byte) 0);
 
-        // Swapped copy.
-        Memory.pokeIntArray(ptr, values, 0, values.length, true);
-        assertIntsEqual(values, ptr, true);
-        assertIntsEqual(swappedValues, ptr, false);
+            // Regular copy.
+            Memory.pokeIntArray(ptr, values, 0, values.length, false);
+            assertIntsEqual(values, ptr, false);
+            assertIntsEqual(swappedValues, ptr, true);
 
-        // Swapped copies of slices (to ensure we test non-zero offsets).
-        for (int i = 0; i < values.length; ++i) {
-            Memory.pokeIntArray(ptr + i * scale, values, i, 1, true);
+            // Swapped copy.
+            Memory.pokeIntArray(ptr, values, 0, values.length, true);
+            assertIntsEqual(values, ptr, true);
+            assertIntsEqual(swappedValues, ptr, false);
+
+            // Swapped copies of slices (to ensure we test non-zero offsets).
+            for (int i = 0; i < values.length; ++i) {
+                Memory.pokeIntArray(ptr + i * scale, values, i, 1, true);
+            }
+            assertIntsEqual(values, ptr, true);
+            assertIntsEqual(swappedValues, ptr, false);
         }
-        assertIntsEqual(values, ptr, true);
-        assertIntsEqual(swappedValues, ptr, false);
     }
 
     private void assertIntsEqual(int[] expectedValues, int ptr, boolean swap) {
         for (int i = 0; i < expectedValues.length; ++i) {
-            assertEquals(expectedValues[i], Memory.peekInt(ptr + 4 * i, swap));
+            assertEquals(expectedValues[i], Memory.peekInt(ptr + SizeOf.INT * i, swap));
         }
     }
 
+    public void testSetLongArray() {
+        long[] values = { 0x1020304050607080L, 0xffeeddccbbaa9988L };
+        long[] swappedValues = new long[values.length];
+        for (int i = 0; i < values.length; ++i) {
+            swappedValues[i] = Long.reverseBytes(values[i]);
+        }
+
+        int scale = SizeOf.LONG;
+        VMRuntime runtime = VMRuntime.getRuntime();
+        byte[] array = (byte[]) runtime.newNonMovableArray(byte.class, scale * values.length + 1);
+        int base_ptr = (int) runtime.addressOf(array);
+
+        for (int ptr_offset = 0; ptr_offset < 2; ++ptr_offset) {
+            int ptr = base_ptr + ptr_offset; // To test aligned and unaligned accesses.
+            Arrays.fill(array, (byte) 0);
+
+            // Regular copy.
+            Memory.pokeLongArray(ptr, values, 0, values.length, false);
+            assertLongsEqual(values, ptr, false);
+            assertLongsEqual(swappedValues, ptr, true);
+
+            // Swapped copy.
+            Memory.pokeLongArray(ptr, values, 0, values.length, true);
+            assertLongsEqual(values, ptr, true);
+            assertLongsEqual(swappedValues, ptr, false);
+
+            // Swapped copies of slices (to ensure we test non-zero offsets).
+            for (int i = 0; i < values.length; ++i) {
+                Memory.pokeLongArray(ptr + i * scale, values, i, 1, true);
+            }
+            assertLongsEqual(values, ptr, true);
+            assertLongsEqual(swappedValues, ptr, false);
+        }
+    }
+
+    private void assertLongsEqual(long[] expectedValues, int ptr, boolean swap) {
+      for (int i = 0; i < expectedValues.length; ++i) {
+        assertEquals(expectedValues[i], Memory.peekLong(ptr + SizeOf.LONG * i, swap));
+      }
+    }
+
     public void testSetShortArray() {
         short[] values = { 0x0001, 0x0020, 0x0300, 0x4000 };
         short[] swappedValues = { 0x0100, 0x2000, 0x0003, 0x0040 };
 
-        int scale = 2;
+        int scale = SizeOf.SHORT;
         VMRuntime runtime = VMRuntime.getRuntime();
-        byte[] array = (byte[]) runtime.newNonMovableArray(byte.class, scale * values.length);
-        int ptr = (int) runtime.addressOf(array);
+        byte[] array = (byte[]) runtime.newNonMovableArray(byte.class, scale * values.length + 1);
+        int base_ptr = (int) runtime.addressOf(array);
 
-        // Regular copy. Memset first so we start from a known state.
-        Memory.pokeShortArray(ptr, values, 0, values.length, false);
-        assertShortsEqual(values, ptr, false);
-        assertShortsEqual(swappedValues, ptr, true);
+        for (int ptr_offset = 0; ptr_offset < 2; ++ptr_offset) {
+            int ptr = base_ptr + ptr_offset; // To test aligned and unaligned accesses.
+            Arrays.fill(array, (byte) 0);
 
-        // Swapped copy.
-        Memory.pokeShortArray(ptr, values, 0, values.length, true);
-        assertShortsEqual(values, ptr, true);
-        assertShortsEqual(swappedValues, ptr, false);
+            // Regular copy.
+            Memory.pokeShortArray(ptr, values, 0, values.length, false);
+            assertShortsEqual(values, ptr, false);
+            assertShortsEqual(swappedValues, ptr, true);
 
-        // Swapped copies of slices (to ensure we test non-zero offsets).
-        for (int i = 0; i < values.length; ++i) {
-            Memory.pokeShortArray(ptr + i * scale, values, i, 1, true);
+            // Swapped copy.
+            Memory.pokeShortArray(ptr, values, 0, values.length, true);
+            assertShortsEqual(values, ptr, true);
+            assertShortsEqual(swappedValues, ptr, false);
+
+            // Swapped copies of slices (to ensure we test non-zero offsets).
+            for (int i = 0; i < values.length; ++i) {
+                Memory.pokeShortArray(ptr + i * scale, values, i, 1, true);
+            }
+            assertShortsEqual(values, ptr, true);
+            assertShortsEqual(swappedValues, ptr, false);
         }
-        assertShortsEqual(values, ptr, true);
-        assertShortsEqual(swappedValues, ptr, false);
     }
 
     private void assertShortsEqual(short[] expectedValues, int ptr, boolean swap) {
         for (int i = 0; i < expectedValues.length; ++i) {
-            assertEquals(expectedValues[i], Memory.peekShort(ptr + 2 * i, swap));
+            assertEquals(expectedValues[i], Memory.peekShort(ptr + SizeOf.SHORT * i, swap));
         }
     }
 }
-- 
cgit v1.1


From eb36a982128aa7e27adcc0d54af8790c44f5c039 Mon Sep 17 00:00:00 2001
From: Pavel Chupin <pavel.v.chupin@intel.com>
Date: Tue, 24 Apr 2012 12:05:50 +0400
Subject: 4.6: Disable unused-but-set-variable warning build

Author: Pavel Chupin <pavel.v.chupin@intel.com>
Reviewed-by: Lu, Hongjiu <hongjiu.lu@intel.com>
Reviewed-by: Beare, Bruce J <bruce.j.beare@intel.com>
---
 NativeCode.mk | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/NativeCode.mk b/NativeCode.mk
index 62ef803..85b38e1 100644
--- a/NativeCode.mk
+++ b/NativeCode.mk
@@ -75,7 +75,7 @@ core_cflags += '-DGCC_HIDDEN=__attribute__((visibility("hidden")))'
 
 include $(CLEAR_VARS)
 
-LOCAL_CFLAGS += -Wall -Wextra -Werror
+LOCAL_CFLAGS += -Wall -Wextra -Werror -Wno-unused-but-set-variable
 LOCAL_CFLAGS += $(core_cflags)
 ifeq ($(TARGET_ARCH),arm)
 # Ignore "note: the mangling of 'va_list' has changed in GCC 4.4"
-- 
cgit v1.1


From 17e2f4bad4068a1a6c7fbe338fa1fa1b6131bb9e Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Fri, 11 May 2012 17:20:49 -0700
Subject: Explain a #include of private zlib API.

Change-Id: Ifa6130bdbd91c02eb663cbad25db344eab873943
---
 luni/src/main/native/zip.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/luni/src/main/native/zip.h b/luni/src/main/native/zip.h
index 0f3c0c1..303c940 100644
--- a/luni/src/main/native/zip.h
+++ b/luni/src/main/native/zip.h
@@ -23,7 +23,7 @@
 #include "UniquePtr.h"
 #include "jni.h"
 #include "zlib.h"
-#include "zutil.h"
+#include "zutil.h" // For DEF_WBITS and DEF_MEM_LEVEL.
 
 static void throwExceptionForZlibError(JNIEnv* env, const char* exceptionClassName, int error) {
     if (error == Z_MEM_ERROR) {
-- 
cgit v1.1


From 811320db23eb8fa68b0ee8659b4448157a0680a5 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Fri, 11 May 2012 17:21:28 -0700
Subject: Add more tests for Object.wait.

Change-Id: Ifd8d80650a2714ead99c6d3426c902728d43b457
---
 luni/src/main/java/java/lang/Object.java           |  2 +-
 .../test/java/libcore/java/lang/OldObjectTest.java | 31 ++++++++++++++++++++--
 2 files changed, 30 insertions(+), 3 deletions(-)

diff --git a/luni/src/main/java/java/lang/Object.java b/luni/src/main/java/java/lang/Object.java
index 7f4b490..4bca034 100644
--- a/luni/src/main/java/java/lang/Object.java
+++ b/luni/src/main/java/java/lang/Object.java
@@ -361,7 +361,7 @@ public class Object {
      * @see java.lang.Thread
      */
     public final void wait() throws InterruptedException {
-        wait(0 ,0);
+        wait(0, 0);
     }
 
     /**
diff --git a/luni/src/test/java/libcore/java/lang/OldObjectTest.java b/luni/src/test/java/libcore/java/lang/OldObjectTest.java
index 08471b2..3ab0327 100644
--- a/luni/src/test/java/libcore/java/lang/OldObjectTest.java
+++ b/luni/src/test/java/libcore/java/lang/OldObjectTest.java
@@ -16,8 +16,6 @@
  */
 package libcore.java.lang;
 
-import dalvik.annotation.SideEffect;
-import java.util.Vector;
 import junit.framework.TestCase;
 
 public class OldObjectTest extends TestCase {
@@ -187,7 +185,36 @@ public class OldObjectTest extends TestCase {
             fail("InterruptedException was thrown.");
         }
         assertEquals(3, status);
+    }
+
+    public void test_waitJI_invalid() throws Exception {
+        Object o = new Object();
+        synchronized (o) {
+            try {
+                o.wait(-1, 0);
+                fail();
+            } catch (IllegalArgumentException expected) {
+            }
+
+            try {
+                o.wait(0, -1);
+                fail();
+            } catch (IllegalArgumentException expected) {
+            }
 
+            try {
+                o.wait(-1, -1);
+                fail();
+            } catch (IllegalArgumentException expected) {
+            }
+
+            // The ms timeout must fit in 32 bits.
+            try {
+                o.wait(Integer.MAX_VALUE + 1, 0);
+                fail();
+            } catch (IllegalArgumentException expected) {
+            }
+        }
     }
 
     public void test_waitJ() {
-- 
cgit v1.1


From f3d07392d4fbeb7b6762b08a523431c34fef750a Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Tue, 15 May 2012 13:10:04 -0700
Subject: AssertionError(Object) should only initCause if the object is a
 Throwable.

Bug: http://code.google.com/p/android/issues/detail?id=29378
Change-Id: I608901eed848ab496b8f54b784216b1362b561d2
---
 luni/src/main/java/java/lang/AssertionError.java   |  6 +++--
 .../java/libcore/java/lang/AssertionErrorTest.java | 27 ++++++++++++++++++++++
 2 files changed, 31 insertions(+), 2 deletions(-)
 create mode 100644 luni/src/test/java/libcore/java/lang/AssertionErrorTest.java

diff --git a/luni/src/main/java/java/lang/AssertionError.java b/luni/src/main/java/java/lang/AssertionError.java
index 3d0d2a4..077e57c 100644
--- a/luni/src/main/java/java/lang/AssertionError.java
+++ b/luni/src/main/java/java/lang/AssertionError.java
@@ -52,8 +52,10 @@ public class AssertionError extends Error {
      *            optionally the cause.
      */
     public AssertionError(Object detailMessage) {
-        super(String.valueOf(detailMessage),
-                (detailMessage instanceof Throwable ? (Throwable) detailMessage : null));
+        super(String.valueOf(detailMessage));
+        if (detailMessage instanceof Throwable) {
+            initCause((Throwable) detailMessage);
+        }
     }
 
     /**
diff --git a/luni/src/test/java/libcore/java/lang/AssertionErrorTest.java b/luni/src/test/java/libcore/java/lang/AssertionErrorTest.java
new file mode 100644
index 0000000..638b15b
--- /dev/null
+++ b/luni/src/test/java/libcore/java/lang/AssertionErrorTest.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed 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 libcore.java.lang;
+
+import junit.framework.TestCase;
+
+public final class AssertionErrorTest extends TestCase {
+    // http://code.google.com/p/android/issues/detail?id=29378
+    public void test_29378() throws Exception {
+        AssertionError ae = new AssertionError("hello");
+        ae.initCause(new Throwable());
+    }
+}
-- 
cgit v1.1


From 431d246358fa832bc2e759fcaec9c4ad9f0b09a7 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Tue, 15 May 2012 16:08:18 -0700
Subject: Fix BitSet.nextClearBit.

Bug: http://code.google.com/p/android/issues/detail?id=31036
Change-Id: I45762449b56773cb5eb323bda7728e8c63a50487
---
 luni/src/main/java/java/util/BitSet.java           |  2 +-
 .../test/java/tests/api/java/util/BitSetTest.java  | 27 ++++++++++++++++++++++
 2 files changed, 28 insertions(+), 1 deletion(-)

diff --git a/luni/src/main/java/java/util/BitSet.java b/luni/src/main/java/java/util/BitSet.java
index a841315..a4ee4c1 100644
--- a/luni/src/main/java/java/util/BitSet.java
+++ b/luni/src/main/java/java/util/BitSet.java
@@ -602,7 +602,7 @@ public class BitSet implements Serializable, Cloneable {
         while (++arrayIndex < longCount && bits[arrayIndex] == ALL_ONES) {
         }
         if (arrayIndex == longCount) {
-            return size();
+            return 64 * longCount;
         }
         return 64 * arrayIndex + Long.numberOfTrailingZeros(~bits[arrayIndex]);
     }
diff --git a/luni/src/test/java/tests/api/java/util/BitSetTest.java b/luni/src/test/java/tests/api/java/util/BitSetTest.java
index 172c6d1..e1abc48 100644
--- a/luni/src/test/java/tests/api/java/util/BitSetTest.java
+++ b/luni/src/test/java/tests/api/java/util/BitSetTest.java
@@ -1178,6 +1178,33 @@ public class BitSetTest extends junit.framework.TestCase {
         // if the index is larger than bs.size(), nextClearBit should return index
         assertEquals(513, bs.nextClearBit(513));
         assertEquals(800, bs.nextClearBit(800));
+
+        bs.clear();
+        assertEquals(0, bs.nextClearBit(0));
+        assertEquals(3, bs.nextClearBit(3));
+        assertEquals(64, bs.nextClearBit(64));
+        assertEquals(128, bs.nextClearBit(128));
+    }
+
+    // http://code.google.com/p/android/issues/detail?id=31036
+    public void test_31036_clear() {
+        BitSet bs = new BitSet(500);
+        for (int i = 0; i < 500; ++i) {
+            int nextClear = bs.nextClearBit(0);
+            assertEquals(i, nextClear);
+            bs.set(i);
+        }
+    }
+
+    // http://code.google.com/p/android/issues/detail?id=31036
+    public void test_31036_set() {
+        BitSet bs = new BitSet(500);
+        bs.set(0, 511);
+        for (int i = 0; i < 500; ++i) {
+            int nextSet = bs.nextSetBit(0);
+            assertEquals(i, nextSet);
+            bs.clear(i);
+        }
     }
 
     public void test_isEmpty() {
-- 
cgit v1.1


From da2fb9754a9ccfa954c1b554982f06e7cf7d680a Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Fri, 18 May 2012 09:37:47 -0700
Subject: Stop using -fvisibility=hidden.

It breaks backtraces, and backtraces are useful. (The debugger uses
the ELF debug info, so it doesn't care, but backtracing just uses the
symbols.)

Bug: 6447213
Change-Id: I2893191d7cec57a04bf7b3f4eea54e699df10507
---
 NativeCode.mk                                  | 3 ---
 luni/src/main/native/libcore_io_Posix.cpp      | 2 +-
 luni/src/main/native/libcore_net_RawSocket.cpp | 6 ++++--
 3 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/NativeCode.mk b/NativeCode.mk
index 2a222b1..fae0fce 100644
--- a/NativeCode.mk
+++ b/NativeCode.mk
@@ -65,9 +65,6 @@ $(foreach dir, \
 core_c_includes := $(sort libcore/include $(LOCAL_C_INCLUDES) $(JNI_H_INCLUDE))
 core_shared_libraries := $(sort $(LOCAL_SHARED_LIBRARIES))
 core_static_libraries := $(sort $(LOCAL_STATIC_LIBRARIES))
-core_cflags := -fvisibility=hidden
-core_cflags += '-DGCC_HIDDEN=__attribute__((visibility("hidden")))'
-core_cppflags := -fvisibility-inlines-hidden
 
 
 #
diff --git a/luni/src/main/native/libcore_io_Posix.cpp b/luni/src/main/native/libcore_io_Posix.cpp
index 30ca145..5a3382a 100644
--- a/luni/src/main/native/libcore_io_Posix.cpp
+++ b/luni/src/main/native/libcore_io_Posix.cpp
@@ -1102,7 +1102,7 @@ static void Posix_setsockoptGroupReq(JNIEnv* env, jobject, jobject javaFd, jint
     if (rc == -1 && errno == EINVAL) {
         // Maybe we're a 32-bit binary talking to a 64-bit kernel?
         // glibc doesn't automatically handle this.
-        struct GCC_HIDDEN group_req64 {
+        struct group_req64 {
             uint32_t gr_interface;
             uint32_t my_padding;
             sockaddr_storage gr_group;
diff --git a/luni/src/main/native/libcore_net_RawSocket.cpp b/luni/src/main/native/libcore_net_RawSocket.cpp
index 4e5059f..2e493ac 100644
--- a/luni/src/main/native/libcore_net_RawSocket.cpp
+++ b/luni/src/main/native/libcore_net_RawSocket.cpp
@@ -38,10 +38,10 @@
 #include <netinet/ip.h>
 #include <linux/udp.h>
 
-union GCC_HIDDEN sockunion {
+union sockunion {
     sockaddr sa;
     sockaddr_ll sll;
-} su;
+};
 
 /*
  * Creates a socket suitable for raw socket operations.  The socket is
@@ -61,6 +61,7 @@ static void RawSocket_create(JNIEnv* env, jclass, jobject fileDescriptor,
     return;
   }
 
+  sockunion su;
   memset(&su, 0, sizeof(su));
   su.sll.sll_family = PF_PACKET;
   su.sll.sll_protocol = htons(protocolType);
@@ -119,6 +120,7 @@ static int RawSocket_sendPacket(JNIEnv* env, jclass, jobject fileDescriptor,
     return 0;
   }
 
+  sockunion su;
   memset(&su, 0, sizeof(su));
   su.sll.sll_hatype = htons(1); // ARPHRD_ETHER
   su.sll.sll_halen = mac.size();
-- 
cgit v1.1


From 8ecba5fd3f3ab30aa57caf917963bed50087ea9c Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Tue, 7 Feb 2012 18:18:45 -0800
Subject: Fix an ICS DatagramPacket bug.

(cherry-picked from e50d82455c813210a2d452070f45fd38d9903159.)

Bug: http://code.google.com/p/android/issues/detail?id=24748
Change-Id: Id7772c3f27961c99d3e5e3856e79edb84483dd46
---
 luni/src/main/java/java/net/DatagramPacket.java    | 62 ++++++++++------------
 luni/src/main/java/java/net/DatagramSocket.java    |  5 +-
 luni/src/main/java/libcore/io/IoBridge.java        |  2 +-
 .../libcore/java/net/OldDatagramSocketTest.java    | 31 ++++++++---
 4 files changed, 55 insertions(+), 45 deletions(-)

diff --git a/luni/src/main/java/java/net/DatagramPacket.java b/luni/src/main/java/java/net/DatagramPacket.java
index 663585c..3b1bc36 100644
--- a/luni/src/main/java/java/net/DatagramPacket.java
+++ b/luni/src/main/java/java/net/DatagramPacket.java
@@ -26,26 +26,26 @@ package java.net;
  */
 public final class DatagramPacket {
 
-    byte[] data;
+    private byte[] data;
 
     /**
      * Length of the data to be sent or size of data that was received via
      * DatagramSocket#receive() method call.
      */
-    int length;
+    private int length;
 
     /**
-     * Size of internal buffer that is used to store received data. Should be
-     * greater or equal to "length" field.
+     * The last user-supplied length (as opposed to a length set by simply receiving a packet).
+     * This length (unlike 'length') is sticky, and survives until the user sets another length.
+     * It's used to limit the amount of data that will be taken from future packets.
      */
-    int capacity;
+    private int userSuppliedLength;
 
-    InetAddress address;
+    private InetAddress address;
 
-    int port = -1; // The default port number is -1
-
-    int offset = 0;
+    private int port = -1; // The default port number is -1
 
+    private int offset = 0;
 
     /**
      * Constructs a new {@code DatagramPacket} object to receive data up to
@@ -92,8 +92,7 @@ public final class DatagramPacket {
      * @param aPort
      *            the port of the target host.
      */
-    public DatagramPacket(byte[] data, int offset, int length,
-            InetAddress host, int aPort) {
+    public DatagramPacket(byte[] data, int offset, int length, InetAddress host, int aPort) {
         this(data, offset, length);
         setPort(aPort);
         address = host;
@@ -185,7 +184,7 @@ public final class DatagramPacket {
         this.data = data;
         this.offset = offset;
         this.length = byteCount;
-        this.capacity = byteCount;
+        this.userSuppliedLength = byteCount;
     }
 
     /**
@@ -197,21 +196,12 @@ public final class DatagramPacket {
      */
     public synchronized void setData(byte[] buf) {
         length = buf.length; // This will check for null
-        capacity = buf.length;
+        userSuppliedLength = length;
         data = buf;
         offset = 0;
     }
 
     /**
-     * Gets the current capacity value.
-     *
-     * @return the current capacity value
-     */
-    synchronized int getCapacity() {
-        return capacity;
-    }
-
-    /**
      * Sets the length of the datagram packet. This length plus the offset must
      * be lesser than or equal to the buffer size.
      *
@@ -219,21 +209,27 @@ public final class DatagramPacket {
      *            the length of this datagram packet.
      */
     public synchronized void setLength(int length) {
-        setLengthOnly(length);
-        this.capacity = length;
+        if (length < 0 || offset + length > data.length) {
+            throw new IndexOutOfBoundsException("length=" + length + ", offset=" + offset +
+                                                ", buffer size=" + data.length);
+        }
+        this.length = length;
+        this.userSuppliedLength = length;
     }
 
     /**
-     * An alternative to {@link #setLength(int)}, that doesn't reset the {@link #capacity}
-     * field.
-     *
-     * @param len the length of this datagram packet
+     * Resets 'length' to the last user-supplied length, ready to receive another packet.
+     * @hide for PlainDatagramSocketImpl
      */
-    synchronized void setLengthOnly(int length) {
-        if (length < 0 || offset + length > data.length) {
-            throw new IndexOutOfBoundsException("length=" + length + ", offset=" + offset +
-                    ", buffer size=" + data.length);
-        }
+    public void resetLengthForReceive() {
+        this.length = userSuppliedLength;
+    }
+
+    /**
+     * Sets 'length' without changing 'userSuppliedLength', after receiving a packet.
+     * @hide for IoBridge
+     */
+    public void setReceivedLength(int length) {
         this.length = length;
     }
 
diff --git a/luni/src/main/java/java/net/DatagramSocket.java b/luni/src/main/java/java/net/DatagramSocket.java
index 487a18a..2b468fa 100644
--- a/luni/src/main/java/java/net/DatagramSocket.java
+++ b/luni/src/main/java/java/net/DatagramSocket.java
@@ -249,11 +249,8 @@ public class DatagramSocket {
         if (pendingConnectException != null) {
             throw new SocketException("Pending connect failure", pendingConnectException);
         }
-
-        pack.setLength(pack.getCapacity());
+        pack.resetLengthForReceive();
         impl.receive(pack);
-        // pack's length field is now updated by native code call;
-        // pack's capacity field is unchanged
     }
 
     /**
diff --git a/luni/src/main/java/libcore/io/IoBridge.java b/luni/src/main/java/libcore/io/IoBridge.java
index db8d8ad..f95e8ec 100644
--- a/luni/src/main/java/libcore/io/IoBridge.java
+++ b/luni/src/main/java/libcore/io/IoBridge.java
@@ -525,7 +525,7 @@ public final class IoBridge {
             return -1;
         }
         if (packet != null) {
-            packet.setLength(byteCount);
+            packet.setReceivedLength(byteCount);
             if (!isConnected) {
                 packet.setAddress(srcAddress.getAddress());
                 packet.setPort(srcAddress.getPort());
diff --git a/luni/src/test/java/libcore/java/net/OldDatagramSocketTest.java b/luni/src/test/java/libcore/java/net/OldDatagramSocketTest.java
index 666a503..d51d461 100644
--- a/luni/src/test/java/libcore/java/net/OldDatagramSocketTest.java
+++ b/luni/src/test/java/libcore/java/net/OldDatagramSocketTest.java
@@ -804,9 +804,11 @@ public class OldDatagramSocketTest extends junit.framework./*Socket*/TestCase {
                     InetAddress localHost = InetAddress.getLocalHost();
                     Thread.sleep(1000);
                     DatagramSocket sds = new DatagramSocket(ports[1]);
-                    DatagramPacket rdp = new DatagramPacket("Test String"
-                            .getBytes(), 11, localHost, portNumber);
-                    sds.send(rdp);
+                    sds.send(new DatagramPacket("Test".getBytes("UTF-8"), "Test".length(), localHost, portNumber));
+                    sds.send(new DatagramPacket("Longer test".getBytes("UTF-8"), "Longer test".length(), localHost, portNumber));
+                    sds.send(new DatagramPacket("3 Test".getBytes("UTF-8"), "3 Test".length(), localHost, portNumber));
+                    sds.send(new DatagramPacket("4 Test".getBytes("UTF-8"), "4 Test".length(), localHost, portNumber));
+                    sds.send(new DatagramPacket("5".getBytes("UTF-8"), "5".length(), localHost, portNumber));
                     sds.close();
                 } catch (Exception e) {
                     throw new RuntimeException(e);
@@ -815,15 +817,30 @@ public class OldDatagramSocketTest extends junit.framework./*Socket*/TestCase {
         }
 
         try {
-            new Thread(new TestDGRcv(), "DGSender").start();
+            new Thread(new TestDGRcv(), "datagram receiver").start();
             ds = new java.net.DatagramSocket(portNumber);
             ds.setSoTimeout(6000);
-            byte rbuf[] = new byte[1000];
+            byte[] rbuf = new byte[1000];
             DatagramPacket rdp = new DatagramPacket(rbuf, rbuf.length);
+
+            // Receive the first packet.
+            ds.receive(rdp);
+            assertEquals("Test", new String(rbuf, 0, rdp.getLength()));
+            // Check that we can still receive a longer packet (http://code.google.com/p/android/issues/detail?id=24748).
             ds.receive(rdp);
+            assertEquals("Longer test", new String(rbuf, 0, rdp.getLength()));
+            // See what happens if we manually call DatagramPacket.setLength.
+            rdp.setLength(4);
+            ds.receive(rdp);
+            assertEquals("3 Te", new String(rbuf, 0, rdp.getLength()));
+            // And then another.
+            ds.receive(rdp);
+            assertEquals("4 Te", new String(rbuf, 0, rdp.getLength()));
+            // And then a packet shorter than the user-supplied length.
+            ds.receive(rdp);
+            assertEquals("5", new String(rbuf, 0, rdp.getLength()));
+
             ds.close();
-            assertEquals("Send/Receive failed to return correct data: "
-                    + new String(rbuf, 0, 11), "Test String", new String(rbuf, 0, 11));
         } finally {
             ds.close();
         }
-- 
cgit v1.1


From f0e583ce305f656c05aa2f7dc2878c2e314d418c Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Thu, 7 Jun 2012 12:32:53 -0700
Subject: Buffer System.in.

Android apps won't notice this, but command-line tools will. Console was
already doing this.

Bug: 6603218
Change-Id: I0f65f3154f5e3ec5c49a6a2c4c87f30a846bb008
---
 luni/src/main/java/java/lang/System.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/luni/src/main/java/java/lang/System.java b/luni/src/main/java/java/lang/System.java
index c65ebbb..f452186 100644
--- a/luni/src/main/java/java/lang/System.java
+++ b/luni/src/main/java/java/lang/System.java
@@ -34,6 +34,7 @@ package java.lang;
 
 import dalvik.system.VMRuntime;
 import dalvik.system.VMStack;
+import java.io.BufferedInputStream;
 import java.io.Console;
 import java.io.FileDescriptor;
 import java.io.FileInputStream;
@@ -83,10 +84,9 @@ public final class System {
     private static Properties systemProperties;
 
     static {
-        // TODO: all three streams are buffered in Harmony.
         err = new PrintStream(new FileOutputStream(FileDescriptor.err));
         out = new PrintStream(new FileOutputStream(FileDescriptor.out));
-        in = new FileInputStream(FileDescriptor.in);
+        in = new BufferedInputStream(new FileInputStream(FileDescriptor.in));
         lineSeparator = System.getProperty("line.separator");
     }
 
-- 
cgit v1.1


From 4718b07e482ccb083ce3dfff228d0615b96a8dd2 Mon Sep 17 00:00:00 2001
From: Kenny Root <kroot@google.com>
Date: Mon, 11 Jun 2012 16:54:08 -0700
Subject: Add OpenSSL provider for SHA1PRNG

Change-Id: I45a3c1c0089aa439629e4645f15b16bd35aa6f55
---
 .../harmony/xnet/provider/jsse/NativeCrypto.java   |   2 +
 .../xnet/provider/jsse/OpenSSLProvider.java        |   9 ++
 .../harmony/xnet/provider/jsse/OpenSSLRandom.java  |  41 ++++++++
 ...che_harmony_xnet_provider_jsse_NativeCrypto.cpp |  19 ++++
 .../libcore/java/security/SecureRandomTest.java    | 114 +++++++++++++++++++++
 .../tests/java/security/SecureRandom2Test.java     |  35 ++-----
 .../xnet/provider/jsse/NativeCryptoTest.java       |  21 ++++
 7 files changed, 212 insertions(+), 29 deletions(-)
 create mode 100644 luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLRandom.java
 create mode 100644 luni/src/test/java/libcore/java/security/SecureRandomTest.java

diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/NativeCrypto.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/NativeCrypto.java
index 759fc85..f3cc1ac 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/NativeCrypto.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/NativeCrypto.java
@@ -172,6 +172,8 @@ public final class NativeCrypto {
 
     public static native int RAND_load_file(String filename, long max_bytes);
 
+    public static native void RAND_bytes(byte[] output);
+
     // --- X509_NAME -----------------------------------------------------------
 
     public static int X509_NAME_hash(X500Principal principal) {
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLProvider.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLProvider.java
index 97753cf..4c88fc3 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLProvider.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLProvider.java
@@ -108,5 +108,14 @@ public final class OpenSSLProvider extends Provider {
         put("Alg.Alias.Signature.1.3.14.3.2.26with1.2.840.10040.4.3", "SHA1withDSA");
         put("Alg.Alias.Signature.DSAWithSHA1", "SHA1withDSA");
         put("Alg.Alias.Signature.1.2.840.10040.4.3", "SHA1withDSA");
+
+        // SecureRandom
+        /*
+         * We have to specify SHA1PRNG because various documentation mentions
+         * that algorithm by name instead of just recommending calling
+         * "new SecureRandom()"
+         */
+        put("SecureRandom.SHA1PRNG", OpenSSLRandom.class.getName());
+        put("SecureRandom.SHA1PRNG ImplementedIn", "Software");
     }
 }
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLRandom.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLRandom.java
new file mode 100644
index 0000000..fd011f0
--- /dev/null
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLRandom.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed 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.xnet.provider.jsse;
+
+import java.io.Serializable;
+import java.security.SecureRandomSpi;
+
+public class OpenSSLRandom extends SecureRandomSpi implements Serializable {
+    private static final long serialVersionUID = 8506210602917522860L;
+
+    @Override
+    protected void engineSetSeed(byte[] seed) {
+        NativeCrypto.RAND_seed(seed);
+    }
+
+    @Override
+    protected void engineNextBytes(byte[] bytes) {
+        NativeCrypto.RAND_bytes(bytes);
+    }
+
+    @Override
+    protected byte[] engineGenerateSeed(int numBytes) {
+        byte[] output = new byte[numBytes];
+        NativeCrypto.RAND_bytes(output);
+        return output;
+    }
+}
diff --git a/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp b/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
index 687c57e..0b07531 100644
--- a/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
+++ b/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
@@ -1828,6 +1828,24 @@ static jint NativeCrypto_RAND_load_file(JNIEnv* env, jclass, jstring filename, j
     return result;
 }
 
+static void NativeCrypto_RAND_bytes(JNIEnv* env, jclass, jbyteArray output) {
+    JNI_TRACE("NativeCrypto_RAND_bytes(%p)", output);
+
+    ScopedByteArrayRW outputBytes(env, output);
+    if (outputBytes.get() == NULL) {
+        return;
+    }
+
+    unsigned char* tmp = reinterpret_cast<unsigned char*>(outputBytes.get());
+    if (!RAND_bytes(tmp, outputBytes.size())) {
+        throwExceptionIfNecessary(env, "NativeCrypto_RAND_bytes");
+        JNI_TRACE("ctx=%p NativeCrypto_RAND_bytes => threw error", ctx);
+        return;
+    }
+
+    JNI_TRACE("NativeCrypto_RAND_bytes(%p) => success", output);
+}
+
 #ifdef WITH_JNI_TRACE
 /**
  * Based on example logging call back from SSL_CTX_set_info_callback man page
@@ -4269,6 +4287,7 @@ static JNINativeMethod sNativeCryptoMethods[] = {
     NATIVE_METHOD(NativeCrypto, EVP_CIPHER_CTX_cleanup, "(I)V"),
     NATIVE_METHOD(NativeCrypto, RAND_seed, "([B)V"),
     NATIVE_METHOD(NativeCrypto, RAND_load_file, "(Ljava/lang/String;J)I"),
+    NATIVE_METHOD(NativeCrypto, RAND_bytes, "([B)V"),
     NATIVE_METHOD(NativeCrypto, SSL_CTX_new, "()I"),
     NATIVE_METHOD(NativeCrypto, SSL_CTX_free, "(I)V"),
     NATIVE_METHOD(NativeCrypto, SSL_CTX_set_session_id_context, "(I[B)V"),
diff --git a/luni/src/test/java/libcore/java/security/SecureRandomTest.java b/luni/src/test/java/libcore/java/security/SecureRandomTest.java
new file mode 100644
index 0000000..43d1e55
--- /dev/null
+++ b/luni/src/test/java/libcore/java/security/SecureRandomTest.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed 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 libcore.java.security;
+
+import org.apache.harmony.xnet.provider.jsse.OpenSSLProvider;
+
+import java.security.Provider;
+import java.security.SecureRandom;
+import java.security.Security;
+import java.util.Arrays;
+import java.util.Set;
+
+import junit.framework.TestCase;
+
+public class SecureRandomTest extends TestCase {
+    private static final Class<? extends Provider> EXPECTED_PROVIDER = OpenSSLProvider.class;
+
+    private static final byte[] STATIC_SEED_BYTES = new byte[] {
+            0x0A, (byte) 0xA0, 0x01, 0x10, (byte) 0xFF, (byte) 0xF0, 0x0F
+    };
+
+    private static final long STATIC_SEED_LONG = 8506210602917522860L;
+
+    public void test_getInstance() throws Exception {
+        Provider[] providers = Security.getProviders();
+        for (Provider provider : providers) {
+            Set<Provider.Service> services = provider.getServices();
+            for (Provider.Service service : services) {
+                String type = service.getType();
+                if (!type.equals("SecureRandom")) {
+                    continue;
+                }
+
+                String algorithm = service.getAlgorithm();
+                try {
+                    SecureRandom sr1 = SecureRandom.getInstance(algorithm);
+                    assertEquals(algorithm, sr1.getAlgorithm());
+                    test_SecureRandom(sr1);
+
+                    // SecureRandom.getInstance(String, Provider)
+                    SecureRandom sr2 = SecureRandom.getInstance(algorithm, provider);
+                    assertEquals(algorithm, sr2.getAlgorithm());
+                    assertEquals(provider, sr2.getProvider());
+                    test_SecureRandom(sr2);
+
+                    // SecureRandom.getInstance(String, String)
+                    SecureRandom sr3 = SecureRandom.getInstance(algorithm, provider.getName());
+                    assertEquals(algorithm, sr3.getAlgorithm());
+                    assertEquals(provider, sr3.getProvider());
+                    test_SecureRandom(sr3);
+
+                    System.out.println("SecureRandomTest " + algorithm + " and provider "
+                            + provider.getName());
+                } catch (Exception e) {
+                    throw new Exception("Problem testing SecureRandom." + algorithm
+                            + ", provider: " + provider.getName(), e);
+                }
+            }
+        }
+    }
+
+    private void test_SecureRandom(SecureRandom sr) throws Exception {
+        byte[] out1 = new byte[20];
+        byte[] out2 = new byte[20];
+
+        sr.nextBytes(out1);
+        sr.nextBytes(out2);
+        assertFalse(Arrays.equals(out1, out2));
+
+        byte[] seed1 = sr.generateSeed(20);
+        byte[] seed2 = sr.generateSeed(20);
+        assertFalse(Arrays.equals(seed1, seed2));
+
+        sr.setSeed(STATIC_SEED_BYTES);
+        sr.nextBytes(out1);
+        sr.nextBytes(out2);
+        assertFalse(Arrays.equals(out1, out2));
+
+        sr.setSeed(STATIC_SEED_LONG);
+        sr.nextBytes(out1);
+        sr.nextBytes(out2);
+        assertFalse(Arrays.equals(out1, out2));
+    }
+
+    public void testGetCommonInstances_Success() throws Exception {
+        SecureRandom sr = SecureRandom.getInstance("SHA1PRNG");
+        assertNotNull(sr);
+        assertEquals(EXPECTED_PROVIDER, sr.getProvider().getClass())
+    }
+
+    public void testNewConstructors_Success() throws Exception {
+        SecureRandom sr1 = new SecureRandom();
+        assertEquals(EXPECTED_PROVIDER, sr1.getProvider().getClass());
+        test_SecureRandom(sr1);
+
+        SecureRandom sr2 = new SecureRandom(STATIC_SEED_BYTES);
+        assertEquals(EXPECTED_PROVIDER, sr2.getProvider().getClass());
+        test_SecureRandom(sr2);
+    }
+}
diff --git a/luni/src/test/java/org/apache/harmony/security/tests/java/security/SecureRandom2Test.java b/luni/src/test/java/org/apache/harmony/security/tests/java/security/SecureRandom2Test.java
index cf030c7..aa0ec67 100644
--- a/luni/src/test/java/org/apache/harmony/security/tests/java/security/SecureRandom2Test.java
+++ b/luni/src/test/java/org/apache/harmony/security/tests/java/security/SecureRandom2Test.java
@@ -301,40 +301,15 @@ public class SecureRandom2Test extends TestCase {
      * as it tends to be error prone and open up security holes.
      * See {@link SecureRandom} for more details about insecure seeding.
      *
-     * @see #testSameSeedGeneratesSameResultsWhenConstructorIsUsed()
+     * Note that this only works with the Harmony "Crypto" provider.
      */
     public void testSameSeedGeneratesSameResults() throws Exception {
         byte[] seed1 = { 'a', 'b', 'c' };
-        SecureRandom sr1 = SecureRandom.getInstance("SHA1PRNG");
+        SecureRandom sr1 = SecureRandom.getInstance("SHA1PRNG", "Crypto");
         sr1.setSeed(seed1);
 
         byte[] seed2 = { 'a', 'b', 'c' };
-        SecureRandom sr2 = SecureRandom.getInstance("SHA1PRNG");
-        sr2.setSeed(seed2);
-
-        assertTrue(sr1.nextLong() == sr2.nextLong());
-    }
-
-    /**
-     * Same tests as {@link #testSameSeedGeneratesSameResults()}, except
-     * here we use the constructor, not {@link SecureRandom#getInstance(String)}.
-     *
-     * Note that Android behaves differently than the reference implementation.
-     * This test fails on the reference implementation.
-     *
-     * In the future, it may make sense to change our implementation to
-     * match the reference implementation.  It may also make sense to
-     * disallow seeding {@code SecureRandom} completely, as it tends to
-     * be error prone and open up security holes.  See {@link SecureRandom}
-     * for more details about insecure seeding.
-     */
-    public void testSameSeedGeneratesSameResultsWhenConstructorIsUsed() {
-        byte[] seed1 = { 'a', 'b', 'c' };
-        SecureRandom sr1 = new SecureRandom();
-        sr1.setSeed(seed1);
-
-        byte[] seed2 = { 'a', 'b', 'c' };
-        SecureRandom sr2 = new SecureRandom();
+        SecureRandom sr2 = SecureRandom.getInstance("SHA1PRNG", "Crypto");
         sr2.setSeed(seed2);
 
         assertTrue(sr1.nextLong() == sr2.nextLong());
@@ -348,10 +323,12 @@ public class SecureRandom2Test extends TestCase {
      * SHA1PRNG, so users of {@code SecureRandom} should not assume
      * the same seed will always produce the same value.  This test
      * is not a guarantee of future compatibility.
+     *
+     * In fact, this test only works with the Harmony "Crypto" provider.
      */
     public void testAlwaysSameValueWithSameSeed() throws Exception {
         byte[] seed1 = { 'a', 'b', 'c' };
-        SecureRandom sr1 = SecureRandom.getInstance("SHA1PRNG");
+        SecureRandom sr1 = SecureRandom.getInstance("SHA1PRNG", "Crypto");
         sr1.setSeed(seed1);
 
         // This long value has no special meaning and may change in the future.
diff --git a/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/NativeCryptoTest.java b/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/NativeCryptoTest.java
index c8df4ab..51c00fe 100644
--- a/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/NativeCryptoTest.java
+++ b/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/NativeCryptoTest.java
@@ -1771,4 +1771,25 @@ public class NativeCryptoTest extends TestCase {
             // Success
         }
     }
+
+    public void test_RAND_bytes_Success() throws Exception {
+        byte[] output = new byte[32];
+        NativeCrypto.RAND_bytes(output);
+
+        boolean isZero = true;
+        for (int i = 0; i < output.length; i++) {
+            isZero &= (output[i] == 0);
+        }
+
+        assertFalse("Random output was zero. This is a very low probability event "
+                + "and probably indicates an error.", isZero);
+    }
+
+    public void test_RAND_bytes_Null_Failure() throws Exception {
+        byte[] output = null;
+        try {
+            NativeCrypto.RAND_bytes(output);
+            fail("Should be an error on null buffer input");
+        } catch (RuntimeException success) { }
+    }
 }
-- 
cgit v1.1


From 177714f960fc0c586930e23b4c98341b9b4eef56 Mon Sep 17 00:00:00 2001
From: Romain Guy <romainguy@google.com>
Date: Tue, 12 Jun 2012 12:46:47 -0700
Subject: Take the Buffer's position into account when accessing the array
 External bug: http://code.google.com/p/android/issues/detail?id=32588

Prior to this patch, our APIs would take into account a Buffer's position
if it was backed by native memory. The position would not be taken into
account for buffers backed by a Dalvik array.

Change-Id: Ibf0bfc14055742ec6ca9f40ab7082f8ae9bca7b6
---
 luni/src/main/java/java/nio/NIOAccess.java | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/luni/src/main/java/java/nio/NIOAccess.java b/luni/src/main/java/java/nio/NIOAccess.java
index 361a37f..36c41cf 100644
--- a/luni/src/main/java/java/nio/NIOAccess.java
+++ b/luni/src/main/java/java/nio/NIOAccess.java
@@ -28,7 +28,7 @@ final class NIOAccess {
      * different than what the Harmony implementation calls a "base
      * address."
      *
-     * @param Buffer b the Buffer to be queried
+     * @param b the Buffer to be queried
      * @return the native pointer to the Buffer's data at its current
      * position, or 0 if there is none
      */
@@ -44,7 +44,7 @@ final class NIOAccess {
      * Returns the underlying Java array containing the data of the
      * given Buffer, or null if the Buffer is not backed by a Java array.
      *
-     * @param Buffer b the Buffer to be queried
+     * @param b the Buffer to be queried
      * @return the Java array containing the Buffer's data, or null if
      * there is none
      */
@@ -55,13 +55,14 @@ final class NIOAccess {
     /**
      * Returns the offset in bytes from the start of the underlying
      * Java array object containing the data of the given Buffer to
-     * the actual start of the data. This method is only meaningful if
-     * getBaseArray() returns non-null.
+     * the actual start of the data. The start of the data takes into
+     * account the Buffer's current position. This method is only
+     * meaningful if getBaseArray() returns non-null.
      *
-     * @param Buffer b the Buffer to be queried
+     * @param b the Buffer to be queried
      * @return the data offset in bytes to the start of this Buffer's data
      */
     static int getBaseArrayOffset(Buffer b) {
-        return b.hasArray() ? (b.arrayOffset() << b._elementSizeShift) : 0;
+        return b.hasArray() ? ((b.arrayOffset() + b.position) << b._elementSizeShift) : 0;
     }
 }
-- 
cgit v1.1


From 84fb77d814b0ad04d70addb04847797925acf805 Mon Sep 17 00:00:00 2001
From: Kenny Root <kroot@google.com>
Date: Tue, 12 Jun 2012 17:10:19 -0700
Subject: Fix build

Missed commit amend

Change-Id: I0b6baffc5c4145a8a54487d9932f4b37127ceebc
---
 luni/src/test/java/libcore/java/security/SecureRandomTest.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/luni/src/test/java/libcore/java/security/SecureRandomTest.java b/luni/src/test/java/libcore/java/security/SecureRandomTest.java
index 43d1e55..8199120 100644
--- a/luni/src/test/java/libcore/java/security/SecureRandomTest.java
+++ b/luni/src/test/java/libcore/java/security/SecureRandomTest.java
@@ -99,7 +99,7 @@ public class SecureRandomTest extends TestCase {
     public void testGetCommonInstances_Success() throws Exception {
         SecureRandom sr = SecureRandom.getInstance("SHA1PRNG");
         assertNotNull(sr);
-        assertEquals(EXPECTED_PROVIDER, sr.getProvider().getClass())
+        assertEquals(EXPECTED_PROVIDER, sr.getProvider().getClass());
     }
 
     public void testNewConstructors_Success() throws Exception {
-- 
cgit v1.1


From 32c5676df786e29990b7fff9886b48b11555e004 Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Wed, 13 Jun 2012 09:19:08 -0700
Subject: CA certificate update: T-TeleSec GlobalRoot Class 3

Added    SHA1      : 55:A6:72:3E:CB:F2:EC:CD:C3:23:74:70:19:9D:2A:BE:11:E3:81:D1
         Subject   : C=DE, O=T-Systems Enterprise Services GmbH, OU=T-Systems Trust Center, CN=T-TeleSec GlobalRoot Class 3

Bug: http://code.google.com/p/android/issues/detail?id=33063
Change-Id: I6ab504f4b1a7ef318d02e7c6b8f6ffd77bf69716
---
 luni/src/main/files/cacerts/1e1eab7c.0 | 80 ++++++++++++++++++++++++++++++++++
 1 file changed, 80 insertions(+)
 create mode 100644 luni/src/main/files/cacerts/1e1eab7c.0

diff --git a/luni/src/main/files/cacerts/1e1eab7c.0 b/luni/src/main/files/cacerts/1e1eab7c.0
new file mode 100644
index 0000000..a7cf5f9
--- /dev/null
+++ b/luni/src/main/files/cacerts/1e1eab7c.0
@@ -0,0 +1,80 @@
+-----BEGIN CERTIFICATE-----
+MIIDwzCCAqugAwIBAgIBATANBgkqhkiG9w0BAQsFADCBgjELMAkGA1UEBhMCREUx
+KzApBgNVBAoMIlQtU3lzdGVtcyBFbnRlcnByaXNlIFNlcnZpY2VzIEdtYkgxHzAd
+BgNVBAsMFlQtU3lzdGVtcyBUcnVzdCBDZW50ZXIxJTAjBgNVBAMMHFQtVGVsZVNl
+YyBHbG9iYWxSb290IENsYXNzIDMwHhcNMDgxMDAxMTAyOTU2WhcNMzMxMDAxMjM1
+OTU5WjCBgjELMAkGA1UEBhMCREUxKzApBgNVBAoMIlQtU3lzdGVtcyBFbnRlcnBy
+aXNlIFNlcnZpY2VzIEdtYkgxHzAdBgNVBAsMFlQtU3lzdGVtcyBUcnVzdCBDZW50
+ZXIxJTAjBgNVBAMMHFQtVGVsZVNlYyBHbG9iYWxSb290IENsYXNzIDMwggEiMA0G
+CSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC9dZPwYiJvJK7genasfb3ZJNW4t/zN
+8ELg63iIVl6bmlQdTQyK9tPPcPRStdiTBONGhnFBSivwKixVA9ZIw+A5OO3yXDw/
+RLyTPWGrTs0NvvAgJ1gORH8EGoel15YUNpDQSXuhdfsaa3Ox+M6pCSzyU9XDFES4
+hqX2iys52qMzVNn6chr3IhUciJFrf2blw2qAsCTz34ZFiP0Zf3WHHx+xGwpzJFu5
+ZeAsVMhg02YXP+HMVDNzkQI6pn97djmiH5a2OK61yJN0HZ65tOVgnS9W0eDrXltM
+EnAMbEQgqxHY9Bn20pxSN+f6tsIxO0rUFJmtxxr1XV/6B7h8DR/Wgx6zAgMBAAGj
+QjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBS1
+A/d2O2GCahKqGFPrAyGUv/7OyjANBgkqhkiG9w0BAQsFAAOCAQEAVj3vlNW92nOy
+WL6ukK2YJ5f+AbGwUgC4TeQbIXQbfsDuXmkqJa9c1h3a0nnJ85cp4IaH3gRZD/FZ
+1GSFS5mvJQQeyUapl96Cshtwn5z2r3Ex3XsFpSzTucpH9sry9uetuUg/vBa3wW30
+6gmv7PO15wWeph6KU1HWk4HMdJP2udqmJQV0eVp+QD6CSyYRMG7hP0HHRwA11fXT
+91Q+gT3aSWqas+8QPebrb9HIIkfLzM8BMZLZGOMivgkeGj5asuRrDFR6fUNOuIml
+e9eiPZaGzPImNC1qkp2aGtAw4l1OBLBfiyB+d8E9lYLRRpo7PHi4b6HQDWSieB4p
+TpPDpFQUWw==
+-----END CERTIFICATE-----
+Certificate:
+    Data:
+        Version: 3 (0x2)
+        Serial Number: 1 (0x1)
+        Signature Algorithm: sha256WithRSAEncryption
+        Issuer: C=DE, O=T-Systems Enterprise Services GmbH, OU=T-Systems Trust Center, CN=T-TeleSec GlobalRoot Class 3
+        Validity
+            Not Before: Oct  1 10:29:56 2008 GMT
+            Not After : Oct  1 23:59:59 2033 GMT
+        Subject: C=DE, O=T-Systems Enterprise Services GmbH, OU=T-Systems Trust Center, CN=T-TeleSec GlobalRoot Class 3
+        Subject Public Key Info:
+            Public Key Algorithm: rsaEncryption
+            RSA Public Key: (2048 bit)
+                Modulus (2048 bit):
+                    00:bd:75:93:f0:62:22:6f:24:ae:e0:7a:76:ac:7d:
+                    bd:d9:24:d5:b8:b7:fc:cd:f0:42:e0:eb:78:88:56:
+                    5e:9b:9a:54:1d:4d:0c:8a:f6:d3:cf:70:f4:52:b5:
+                    d8:93:04:e3:46:86:71:41:4a:2b:f0:2a:2c:55:03:
+                    d6:48:c3:e0:39:38:ed:f2:5c:3c:3f:44:bc:93:3d:
+                    61:ab:4e:cd:0d:be:f0:20:27:58:0e:44:7f:04:1a:
+                    87:a5:d7:96:14:36:90:d0:49:7b:a1:75:fb:1a:6b:
+                    73:b1:f8:ce:a9:09:2c:f2:53:d5:c3:14:44:b8:86:
+                    a5:f6:8b:2b:39:da:a3:33:54:d9:fa:72:1a:f7:22:
+                    15:1c:88:91:6b:7f:66:e5:c3:6a:80:b0:24:f3:df:
+                    86:45:88:fd:19:7f:75:87:1f:1f:b1:1b:0a:73:24:
+                    5b:b9:65:e0:2c:54:c8:60:d3:66:17:3f:e1:cc:54:
+                    33:73:91:02:3a:a6:7f:7b:76:39:a2:1f:96:b6:38:
+                    ae:b5:c8:93:74:1d:9e:b9:b4:e5:60:9d:2f:56:d1:
+                    e0:eb:5e:5b:4c:12:70:0c:6c:44:20:ab:11:d8:f4:
+                    19:f6:d2:9c:52:37:e7:fa:b6:c2:31:3b:4a:d4:14:
+                    99:ad:c7:1a:f5:5d:5f:fa:07:b8:7c:0d:1f:d6:83:
+                    1e:b3
+                Exponent: 65537 (0x10001)
+        X509v3 extensions:
+            X509v3 Basic Constraints: critical
+                CA:TRUE
+            X509v3 Key Usage: critical
+                Certificate Sign, CRL Sign
+            X509v3 Subject Key Identifier: 
+                B5:03:F7:76:3B:61:82:6A:12:AA:18:53:EB:03:21:94:BF:FE:CE:CA
+    Signature Algorithm: sha256WithRSAEncryption
+        56:3d:ef:94:d5:bd:da:73:b2:58:be:ae:90:ad:98:27:97:fe:
+        01:b1:b0:52:00:b8:4d:e4:1b:21:74:1b:7e:c0:ee:5e:69:2a:
+        25:af:5c:d6:1d:da:d2:79:c9:f3:97:29:e0:86:87:de:04:59:
+        0f:f1:59:d4:64:85:4b:99:af:25:04:1e:c9:46:a9:97:de:82:
+        b2:1b:70:9f:9c:f6:af:71:31:dd:7b:05:a5:2c:d3:b9:ca:47:
+        f6:ca:f2:f6:e7:ad:b9:48:3f:bc:16:b7:c1:6d:f4:ea:09:af:
+        ec:f3:b5:e7:05:9e:a6:1e:8a:53:51:d6:93:81:cc:74:93:f6:
+        b9:da:a6:25:05:74:79:5a:7e:40:3e:82:4b:26:11:30:6e:e1:
+        3f:41:c7:47:00:35:d5:f5:d3:f7:54:3e:81:3d:da:49:6a:9a:
+        b3:ef:10:3d:e6:eb:6f:d1:c8:22:47:cb:cc:cf:01:31:92:d9:
+        18:e3:22:be:09:1e:1a:3e:5a:b2:e4:6b:0c:54:7a:7d:43:4e:
+        b8:89:a5:7b:d7:a2:3d:96:86:cc:f2:26:34:2d:6a:92:9d:9a:
+        1a:d0:30:e2:5d:4e:04:b0:5f:8b:20:7e:77:c1:3d:95:82:d1:
+        46:9a:3b:3c:78:b8:6f:a1:d0:0d:64:a2:78:1e:29:4e:93:c3:
+        a4:54:14:5b
+SHA1 Fingerprint=55:A6:72:3E:CB:F2:EC:CD:C3:23:74:70:19:9D:2A:BE:11:E3:81:D1
-- 
cgit v1.1


From 68618152969be1144d460add7349f0b89ae8f499 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Fri, 22 Jun 2012 18:41:27 -0700
Subject: Bring Random.nextGaussian in line with the specification.

Bug: 6126164
Change-Id: I36d5ccc776b15f7f4085da23c189f91507d57224
---
 luni/src/main/java/java/util/Random.java | 16 ++++++----------
 1 file changed, 6 insertions(+), 10 deletions(-)

diff --git a/luni/src/main/java/java/util/Random.java b/luni/src/main/java/java/util/Random.java
index 7ce74cc..cc9de58 100644
--- a/luni/src/main/java/java/util/Random.java
+++ b/luni/src/main/java/java/util/Random.java
@@ -140,25 +140,21 @@ public class Random implements Serializable {
      * section 3.4.1, subsection C, algorithm P.
      */
     public synchronized double nextGaussian() {
-        if (haveNextNextGaussian) { // if X1 has been returned, return the
-                                    // second Gaussian
+        if (haveNextNextGaussian) {
             haveNextNextGaussian = false;
             return nextNextGaussian;
         }
 
         double v1, v2, s;
         do {
-            v1 = 2 * nextDouble() - 1; // Generates two independent random
-                                        // variables U1, U2
+            v1 = 2 * nextDouble() - 1;
             v2 = 2 * nextDouble() - 1;
             s = v1 * v1 + v2 * v2;
-        } while (s >= 1);
-        double norm = Math.sqrt(-2 * Math.log(s) / s);
-        nextNextGaussian = v2 * norm; // should that not be norm instead
-                                        // of multiplier ?
+        } while (s >= 1 || s == 0);
+        double multiplier = StrictMath.sqrt(-2 * StrictMath.log(s) / s);
+        nextNextGaussian = v2 * multiplier;
         haveNextNextGaussian = true;
-        return v1 * norm; // should that not be norm instead of multiplier
-                            // ?
+        return v1 * multiplier;
     }
 
     /**
-- 
cgit v1.1


From 91348f798cddae22b59ee1a17bd24315c0897f6f Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Fri, 22 Jun 2012 17:47:28 -0700
Subject: Be more careful when parsing custom zone ids.

The old code was allowing invalid ids.

Bug: 6556561
Change-Id: I691d33fa133527a76bbffa4e3b56a023c389ca8f
---
 luni/src/main/java/java/util/TimeZone.java         | 99 +++++++---------------
 .../test/java/libcore/java/util/TimeZoneTest.java  | 33 +++++++-
 2 files changed, 63 insertions(+), 69 deletions(-)

diff --git a/luni/src/main/java/java/util/TimeZone.java b/luni/src/main/java/java/util/TimeZone.java
index 0abb609..e7253f7 100644
--- a/luni/src/main/java/java/util/TimeZone.java
+++ b/luni/src/main/java/java/util/TimeZone.java
@@ -18,6 +18,8 @@
 package java.util;
 
 import java.io.Serializable;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 import libcore.icu.TimeZones;
 import libcore.util.ZoneInfoDB;
 
@@ -28,7 +30,7 @@ import libcore.util.ZoneInfoDB;
  * <p>Most applications will use {@link #getDefault} which returns a {@code TimeZone} based on
  * the time zone where the program is running.
  *
- * <p>You can also get a specific {@code TimeZone} {@link #getTimeZone by id}.
+ * <p>You can also get a specific {@code TimeZone} {@link #getTimeZone by Olson ID}.
  *
  * <p>It is highly unlikely you'll ever want to use anything but the factory methods yourself.
  * Let classes like {@link Calendar} and {@link java.text.SimpleDateFormat} do the date
@@ -64,6 +66,8 @@ import libcore.util.ZoneInfoDB;
 public abstract class TimeZone implements Serializable, Cloneable {
     private static final long serialVersionUID = 3581463369166924961L;
 
+    private static final Pattern CUSTOM_ZONE_ID_PATTERN = Pattern.compile("^GMT[-+](\\d{1,2})(:?(\\d\\d))?$");
+
     /**
      * The short display name style, such as {@code PDT}. Requests for this
      * style may yield GMT offsets like {@code GMT-08:00}.
@@ -265,17 +269,18 @@ public abstract class TimeZone implements Serializable, Cloneable {
     public abstract int getRawOffset();
 
     /**
-     * Returns a {@code TimeZone} suitable for {@code id}, or {@code GMT} on failure.
+     * Returns a {@code TimeZone} corresponding to the given {@code id}, or {@code GMT} on failure.
      *
-     * <p>An id can be an Olson name of the form <i>Area</i>/<i>Location</i>, such
+     * <p>An ID can be an Olson name of the form <i>Area</i>/<i>Location</i>, such
      * as {@code America/Los_Angeles}. The {@link #getAvailableIDs} method returns
      * the supported names.
      *
-     * <p>This method can also create a custom {@code TimeZone} using the following
-     * syntax: {@code GMT[+|-]hh[[:]mm]}. For example, {@code TimeZone.getTimeZone("GMT+14:00")}
-     * would return an object with a raw offset of +14 hours from UTC, and which does <i>not</i>
-     * use daylight savings. These are rarely useful, because they don't correspond to time
-     * zones actually in use.
+     * <p>This method can also create a custom {@code TimeZone} given an ID with the following
+     * syntax: {@code GMT[+|-]hh[[:]mm]}. For example, {@code "GMT+05:00"}, {@code "GMT+0500"},
+     * {@code "GMT+5:00"}, {@code "GMT+500"}, {@code "GMT+05"}, and {@code "GMT+5"} all return
+     * an object with a raw offset of +5 hours from UTC, and which does <i>not</i> use daylight
+     * savings. These are rarely useful, because they don't correspond to time zones actually
+     * in use by humans.
      *
      * <p>Other than the special cases "UTC" and "GMT" (which are synonymous in this context,
      * both corresponding to UTC), Android does not support the deprecated three-letter time
@@ -296,66 +301,37 @@ public abstract class TimeZone implements Serializable, Cloneable {
     }
 
     /**
-     * Returns a new SimpleTimeZone for an id of the form "GMT[+|-]hh[[:]mm]", or null.
+     * Returns a new SimpleTimeZone for an ID of the form "GMT[+|-]hh[[:]mm]", or null.
      */
     private static TimeZone getCustomTimeZone(String id) {
-        char sign = id.charAt(3);
-        if (sign != '+' && sign != '-') {
-            return null;
-        }
-        int[] position = new int[1];
-        String formattedName = formatTimeZoneName(id, 4);
-        int hour = parseNumber(formattedName, 4, position);
-        if (hour < 0 || hour > 23) {
-            return null;
-        }
-        int index = position[0];
-        if (index == -1) {
+        Matcher m = CUSTOM_ZONE_ID_PATTERN.matcher(id);
+        if (!m.matches()) {
             return null;
         }
-        int raw = hour * 3600000;
-        if (index < formattedName.length() && formattedName.charAt(index) == ':') {
-            int minute = parseNumber(formattedName, index + 1, position);
-            if (position[0] == -1 || minute < 0 || minute > 59) {
-                return null;
-            }
-            raw += minute * 60000;
-        } else if (hour >= 30 || index > 6) {
-            raw = (hour / 100 * 3600000) + (hour % 100 * 60000);
-        }
-        if (sign == '-') {
-            raw = -raw;
-        }
-        return new SimpleTimeZone(raw, formattedName);
-    }
 
-    private static String formatTimeZoneName(String name, int offset) {
-        StringBuilder buf = new StringBuilder();
-        int index = offset, length = name.length();
-        buf.append(name.substring(0, offset));
-
-        while (index < length) {
-            if (Character.digit(name.charAt(index), 10) != -1) {
-                buf.append(name.charAt(index));
-                if ((length - (index + 1)) == 2) {
-                    buf.append(':');
-                }
-            } else if (name.charAt(index) == ':') {
-                buf.append(':');
+        int hour;
+        int minute = 0;
+        try {
+            hour = Integer.parseInt(m.group(1));
+            if (m.group(3) != null) {
+                minute = Integer.parseInt(m.group(3));
             }
-            index++;
+        } catch (NumberFormatException impossible) {
+            throw new AssertionError(impossible);
         }
 
-        if (buf.toString().indexOf(":") == -1) {
-            buf.append(':');
-            buf.append("00");
+        if (hour < 0 || hour > 23 || minute < 0 || minute > 59) {
+            return null;
         }
 
-        if (buf.toString().indexOf(":") == 5) {
-            buf.insert(4, '0');
+        char sign = id.charAt(3);
+        int raw = (hour * 3600000) + (minute * 60000);
+        if (sign == '-') {
+            raw = -raw;
         }
 
-        return buf.toString();
+        String cleanId = String.format("GMT%c%02d:%02d", sign, hour, minute);
+        return new SimpleTimeZone(raw, cleanId);
     }
 
     /**
@@ -377,17 +353,6 @@ public abstract class TimeZone implements Serializable, Cloneable {
      */
     public abstract boolean inDaylightTime(Date time);
 
-    private static int parseNumber(String string, int offset, int[] position) {
-        int index = offset, length = string.length(), digit, result = 0;
-        while (index < length
-                && (digit = Character.digit(string.charAt(index), 10)) != -1) {
-            index++;
-            result = result * 10 + digit;
-        }
-        position[0] = index == offset ? -1 : index;
-        return result;
-    }
-
     /**
      * Overrides the default time zone for the current process only.
      *
diff --git a/luni/src/test/java/libcore/java/util/TimeZoneTest.java b/luni/src/test/java/libcore/java/util/TimeZoneTest.java
index 39ac19d..9708c2a 100644
--- a/luni/src/test/java/libcore/java/util/TimeZoneTest.java
+++ b/luni/src/test/java/libcore/java/util/TimeZoneTest.java
@@ -144,8 +144,37 @@ public class TimeZoneTest extends junit.framework.TestCase {
 
     // http://code.google.com/p/android/issues/detail?id=11918
     public void testHasSameRules() throws Exception {
-        TimeZone denver = TimeZone.getTimeZone ("America/Denver") ;
-        TimeZone phoenix = TimeZone.getTimeZone ("America/Phoenix") ;
+        TimeZone denver = TimeZone.getTimeZone("America/Denver");
+        TimeZone phoenix = TimeZone.getTimeZone("America/Phoenix");
         assertFalse(denver.hasSameRules(phoenix));
     }
+
+    // http://b.corp.google.com/issue?id=6556561
+    public void testCustomZoneIds() throws Exception {
+        // These are all okay (and equivalent).
+        assertEquals("GMT+05:00", TimeZone.getTimeZone("GMT+05:00").getID());
+        assertEquals("GMT+05:00", TimeZone.getTimeZone("GMT+5:00").getID());
+        assertEquals("GMT+05:00", TimeZone.getTimeZone("GMT+0500").getID());
+        assertEquals("GMT+05:00", TimeZone.getTimeZone("GMT+500").getID());
+        assertEquals("GMT+05:00", TimeZone.getTimeZone("GMT+5").getID());
+        // These aren't.
+        assertEquals("GMT", TimeZone.getTimeZone("GMT+5.5").getID());
+        assertEquals("GMT", TimeZone.getTimeZone("GMT+5:5").getID());
+        assertEquals("GMT", TimeZone.getTimeZone("GMT+5:0").getID());
+        assertEquals("GMT", TimeZone.getTimeZone("GMT+5:005").getID());
+        assertEquals("GMT", TimeZone.getTimeZone("GMT+5:000").getID());
+        assertEquals("GMT", TimeZone.getTimeZone("GMT+005:00").getID());
+        assertEquals("GMT", TimeZone.getTimeZone("GMT+05:99").getID());
+        assertEquals("GMT", TimeZone.getTimeZone("GMT+28:00").getID());
+        assertEquals("GMT", TimeZone.getTimeZone("GMT+05:00.00").getID());
+        assertEquals("GMT", TimeZone.getTimeZone("GMT+05:00:00").getID());
+        assertEquals("GMT", TimeZone.getTimeZone("GMT+5:").getID());
+        assertEquals("GMT", TimeZone.getTimeZone("GMT+junk").getID());
+        assertEquals("GMT", TimeZone.getTimeZone("GMT+5junk").getID());
+        assertEquals("GMT", TimeZone.getTimeZone("GMT+5:junk").getID());
+        assertEquals("GMT", TimeZone.getTimeZone("GMT+5:00junk").getID());
+        assertEquals("GMT", TimeZone.getTimeZone("junkGMT+5:00").getID());
+        assertEquals("GMT", TimeZone.getTimeZone("junk").getID());
+        assertEquals("GMT", TimeZone.getTimeZone("gmt+5:00").getID());
+    }
 }
-- 
cgit v1.1


From 953dfe37db00b2610807c3f895c72183c7ce5b14 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Fri, 29 Jun 2012 15:31:18 -0700
Subject: Clarify the documentation of the Pattern character classes.

Android (via icu4c) supports the full Unicode TR-18 definitions
rather than the traditional ASCII-only ones. Document this fact.

Bug: http://code.google.com/p/android/issues/detail?id=21176
Change-Id: If9b94d4e7769ec1ef7c443a7db47bc7586f49b44
---
 luni/src/main/java/java/util/regex/Pattern.java     | 21 ++++++++++++++-------
 .../libcore/java/util/regex/OldMatcherTest.java     | 10 ++++++++++
 2 files changed, 24 insertions(+), 7 deletions(-)

diff --git a/luni/src/main/java/java/util/regex/Pattern.java b/luni/src/main/java/java/util/regex/Pattern.java
index 46984b9..cbd5965 100644
--- a/luni/src/main/java/java/util/regex/Pattern.java
+++ b/luni/src/main/java/java/util/regex/Pattern.java
@@ -82,16 +82,23 @@ import java.io.Serializable;
  * </table>
  * <p>Most of the time, the built-in character classes are more useful:
  * <table>
- * <tr> <td> \d </td> <td>Any digit character.</td> </tr>
- * <tr> <td> \D </td> <td>Any non-digit character.</td> </tr>
- * <tr> <td> \s </td> <td>Any whitespace character.</td> </tr>
- * <tr> <td> \S </td> <td>Any non-whitespace character.</td> </tr>
- * <tr> <td> \w </td> <td>Any word character.</td> </tr>
- * <tr> <td> \W </td> <td>Any non-word character.</td> </tr>
+ * <tr> <td> \d </td> <td>Any digit character (see note below).</td> </tr>
+ * <tr> <td> \D </td> <td>Any non-digit character (see note below).</td> </tr>
+ * <tr> <td> \s </td> <td>Any whitespace character (see note below).</td> </tr>
+ * <tr> <td> \S </td> <td>Any non-whitespace character (see note below).</td> </tr>
+ * <tr> <td> \w </td> <td>Any word character (see note below).</td> </tr>
+ * <tr> <td> \W </td> <td>Any non-word character (see note below).</td> </tr>
  * <tr> <td> \p{<i>NAME</i>} </td> <td> Any character in the class with the given <i>NAME</i>. </td> </tr>
  * <tr> <td> \P{<i>NAME</i>} </td> <td> Any character <i>not</i> in the named class. </td> </tr>
  * </table>
- * <p>There are a variety of named classes:
+ * <p>Note that these built-in classes don't just cover the traditional ASCII range. For example,
+ * <code>\w</code> is equivalent to the character class <code>[\p{Ll}\p{Lu}\p{Lt}\p{Lo}\p{Nd}]</code>.
+ * For more details see <a href="http://www.unicode.org/reports/tr18/#Compatibility_Properties">Unicode TR-18</a>,
+ * and bear in mind that the set of characters in each class can vary between Unicode releases.
+ * If you actually want to match only ASCII characters, specify the explicit characters you want;
+ * if you mean 0-9 use <code>[0-9]</code> rather than <code>\d</code>, which would also include
+ * Gurmukhi digits and so forth.
+ * <p>There are also a variety of named classes:
  * <ul>
  * <li><a href="../../lang/Character.html#unicode_categories">Unicode category names</a>,
  * prefixed by {@code Is}. For example {@code \p{IsLu}} for all uppercase letters.
diff --git a/luni/src/test/java/libcore/java/util/regex/OldMatcherTest.java b/luni/src/test/java/libcore/java/util/regex/OldMatcherTest.java
index 450b8d9..54f976d 100644
--- a/luni/src/test/java/libcore/java/util/regex/OldMatcherTest.java
+++ b/luni/src/test/java/libcore/java/util/regex/OldMatcherTest.java
@@ -579,4 +579,14 @@ public class OldMatcherTest extends TestCase {
         assertTrue(pattern.matcher("14pt").matches());
     }
 
+    public void testUnicodeCharacterClasses() throws Exception {
+        // http://code.google.com/p/android/issues/detail?id=21176
+        // We use the Unicode TR-18 definitions: http://www.unicode.org/reports/tr18/#Compatibility_Properties
+        assertTrue("\u0666".matches("\\d")); // ARABIC-INDIC DIGIT SIX
+        assertFalse("\u0666".matches("\\D")); // ARABIC-INDIC DIGIT SIX
+        assertTrue("\u1680".matches("\\s")); // OGHAM SPACE MARK
+        assertFalse("\u1680".matches("\\S")); // OGHAM SPACE MARK
+        assertTrue("\u00ea".matches("\\w")); // LATIN SMALL LETTER E WITH CIRCUMFLEX
+        assertFalse("\u00ea".matches("\\W")); // LATIN SMALL LETTER E WITH CIRCUMFLEX
+    }
 }
-- 
cgit v1.1


From eaa9fa7c28da311c3c06e698af7c59f1f1fe24f8 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Fri, 29 Jun 2012 16:19:05 -0700
Subject: Fix xpath documentation bug.

Bug: http://code.google.com/p/android/issues/detail?id=26168
Change-Id: Ib6f8b84d174fa884b0eace0305331c7b58e6166a
---
 luni/src/main/java/javax/xml/xpath/package.html | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/luni/src/main/java/javax/xml/xpath/package.html b/luni/src/main/java/javax/xml/xpath/package.html
index edeb448..202a29c 100644
--- a/luni/src/main/java/javax/xml/xpath/package.html
+++ b/luni/src/main/java/javax/xml/xpath/package.html
@@ -165,7 +165,7 @@ or more nodes from an XML document:</p>
 XPath xpath = XPathFactory.newInstance().newXPath();
 String expression = "/widgets/widget";
 InputSource inputSource = new InputSource("widgets.xml");
-NodeSet nodes = (NodeSet) xpath.evaluate(expression, inputSource, XPathConstants.NODESET);
+NodeList nodes = (NodeList) xpath.evaluate(expression, inputSource, XPathConstants.NODESET);
 </pre>
 
 <h3>XPath Expressions and Types</h3>
-- 
cgit v1.1


From 91cc423115fdfa682d9c4cd025dee06aaa145b3c Mon Sep 17 00:00:00 2001
From: Vladimir Marko <vmarko@google.com>
Date: Fri, 6 Jul 2012 12:45:42 +0100
Subject: Improve HttpResponseCache performance.

Avoid writing to HttpResponseCache.CacheRequestImpl.cacheOut
one byte at a time via inefficient FilterOutputStream write.

Bug: 6738383
Change-Id: I342d6dbffeefcf2e778f8f01fd79e367320aa7a7
---
 luni/src/main/java/libcore/net/http/HttpResponseCache.java | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/luni/src/main/java/libcore/net/http/HttpResponseCache.java b/luni/src/main/java/libcore/net/http/HttpResponseCache.java
index 7b95e1c..910461e 100644
--- a/luni/src/main/java/libcore/net/http/HttpResponseCache.java
+++ b/luni/src/main/java/libcore/net/http/HttpResponseCache.java
@@ -282,6 +282,13 @@ public final class HttpResponseCache extends ResponseCache implements ExtendedRe
                     super.close();
                     editor.commit();
                 }
+
+                @Override
+                public void write(byte[] buffer, int offset, int length) throws IOException {
+                    // Since we don't override "write(int oneByte)", we can write directly to "out"
+                    // and avoid the inefficient implementation from the FilterOutputStream.
+                    out.write(buffer, offset, length);
+                }
             };
         }
 
-- 
cgit v1.1


From 38846d115b17683a800b76b93c66c24f91cf6d91 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Mon, 9 Jul 2012 11:03:46 -0700
Subject: Fix SealedObject.readObject.

Using readUnshared on the byte[]s seems like a reasonable security precaution.
Using readUnshared on the algorithm Strings is just plain wrong.

Bug: http://code.google.com/p/android/issues/detail?id=4834
Change-Id: I73d32a14521de62ce9e19871fd30b619cf3ff6eb
---
 luni/src/main/java/javax/crypto/SealedObject.java  |  30 +++--
 .../java/libcore/util/SerializationTester.java     | 125 +++++++++++++++++++++
 .../tests/javax/crypto/SealedObjectTest.java       |  22 ++++
 3 files changed, 165 insertions(+), 12 deletions(-)
 create mode 100644 luni/src/test/java/libcore/util/SerializationTester.java

diff --git a/luni/src/main/java/javax/crypto/SealedObject.java b/luni/src/main/java/javax/crypto/SealedObject.java
index c9c1534..cfb970b 100644
--- a/luni/src/main/java/javax/crypto/SealedObject.java
+++ b/luni/src/main/java/javax/crypto/SealedObject.java
@@ -33,12 +33,12 @@ import java.security.NoSuchProviderException;
 /**
  * A {@code SealedObject} is a wrapper around a {@code serializable} object
  * instance and encrypts it using a cryptographic cipher.
- * <p>
- * Since a {@code SealedObject} instance is a serializable object itself it can
+ *
+ * <p>Since a {@code SealedObject} instance is serializable it can
  * either be stored or transmitted over an insecure channel.
- * <p>
- * The wrapped object can later be decrypted (unsealed) using the corresponding
- * key and then be deserialized to retrieve the original object.The sealed
+ *
+ * <p>The wrapped object can later be decrypted (unsealed) using the corresponding
+ * key and then be deserialized to retrieve the original object. The sealed
  * object itself keeps track of the cipher and corresponding parameters.
  */
 public class SealedObject implements Serializable {
@@ -46,19 +46,25 @@ public class SealedObject implements Serializable {
     private static final long serialVersionUID = 4482838265551344752L;
 
     /**
-     * The {@link AlgorithmParameters} in encoded format.
+     * The cipher's {@link AlgorithmParameters} in encoded format.
+     * Equivalent to {@code cipher.getParameters().getEncoded()},
+     * or null if the cipher did not use any parameters.
      */
     protected byte[] encodedParams;
+
     private byte[] encryptedContent;
     private String sealAlg;
     private String paramsAlg;
 
-    private void readObject(ObjectInputStream s)
-                throws IOException, ClassNotFoundException {
-        encodedParams = (byte []) s.readUnshared();
-        encryptedContent = (byte []) s.readUnshared();
-        sealAlg = (String) s.readUnshared();
-        paramsAlg = (String) s.readUnshared();
+    private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException {
+        // We do unshared reads here to ensure we have our own clones of the byte[]s.
+        encodedParams = (byte[]) s.readUnshared();
+        encryptedContent = (byte[]) s.readUnshared();
+        // These are regular shared reads because the algorithms used by a given stream are
+        // almost certain to the be same for each object, and String is immutable anyway,
+        // so there's no security concern about sharing.
+        sealAlg = (String) s.readObject();
+        paramsAlg = (String) s.readObject();
     }
 
     /**
diff --git a/luni/src/test/java/libcore/util/SerializationTester.java b/luni/src/test/java/libcore/util/SerializationTester.java
new file mode 100644
index 0000000..59f319c
--- /dev/null
+++ b/luni/src/test/java/libcore/util/SerializationTester.java
@@ -0,0 +1,125 @@
+/*
+ * Copyright (C) 2010 Google Inc.
+ *
+ * Licensed 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 libcore.util;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
+import static junit.framework.Assert.assertEquals;
+import static junit.framework.Assert.assertTrue;
+import static junit.framework.Assert.fail;
+import junit.framework.AssertionFailedError;
+
+public class SerializationTester<T> {
+    private final String golden;
+    private final T value;
+
+    public SerializationTester(T value, String golden) {
+        this.golden = golden;
+        this.value = value;
+    }
+
+    /**
+     * Returns true if {@code a} and {@code b} are equal. Override this if
+     * {@link Object#equals} isn't appropriate or sufficient for this tester's
+     * value type.
+     */
+    protected boolean equals(T a, T b) {
+        return a.equals(b);
+    }
+
+    /**
+     * Verifies that {@code deserialized} is valid. Implementations of this
+     * method may mutate {@code deserialized}.
+     */
+    protected void verify(T deserialized) throws Exception {}
+
+    public void test() {
+        try {
+            if (golden == null || golden.length() == 0) {
+                fail("No golden value supplied! Consider using this: "
+                        + hexEncode(serialize(value)));
+            }
+
+            @SuppressWarnings("unchecked") // deserialize should return the proper type
+            T deserialized = (T) deserialize(hexDecode(golden));
+            assertTrue("User-constructed value doesn't equal deserialized golden value",
+                    equals(value, deserialized));
+
+            @SuppressWarnings("unchecked") // deserialize should return the proper type
+            T reserialized = (T) deserialize(serialize(value));
+            assertTrue("User-constructed value doesn't equal itself, reserialized",
+                    equals(value, reserialized));
+
+            // just a sanity check! if this fails, verify() is probably broken
+            verify(value);
+            verify(deserialized);
+            verify(reserialized);
+
+        } catch (Exception e) {
+            Error failure = new AssertionFailedError();
+            failure.initCause(e);
+            throw failure;
+        }
+    }
+
+    private static byte[] serialize(Object object) throws IOException {
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        new ObjectOutputStream(out).writeObject(object);
+        return out.toByteArray();
+    }
+
+    private static Object deserialize(byte[] bytes) throws IOException, ClassNotFoundException {
+        ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(bytes));
+        Object result = in.readObject();
+        assertEquals(-1, in.read());
+        return result;
+    }
+
+    private static String hexEncode(byte[] bytes) {
+        StringBuilder result = new StringBuilder(bytes.length * 2);
+        for (byte b : bytes) {
+            result.append(String.format("%02x", b));
+        }
+        return result.toString();
+    }
+
+    private static byte[] hexDecode(String s) {
+        byte[] result = new byte[s.length() / 2];
+        for (int i = 0; i < result.length; i++) {
+            result[i] = (byte) Integer.parseInt(s.substring(i*2, i*2 + 2), 16);
+        }
+        return result;
+    }
+
+    /**
+     * Returns a serialized-and-deserialized copy of {@code object}.
+     */
+    public static Object reserialize(Object object) throws IOException, ClassNotFoundException {
+        return deserialize(serialize(object));
+    }
+
+    public static String serializeHex(Object object) throws IOException {
+        return hexEncode(serialize(object));
+    }
+
+    public static Object deserializeHex(String hex) throws IOException, ClassNotFoundException {
+        return deserialize(hexDecode(hex));
+    }
+}
diff --git a/luni/src/test/java/org/apache/harmony/crypto/tests/javax/crypto/SealedObjectTest.java b/luni/src/test/java/org/apache/harmony/crypto/tests/javax/crypto/SealedObjectTest.java
index b3b2931..3ea57bf 100644
--- a/luni/src/test/java/org/apache/harmony/crypto/tests/javax/crypto/SealedObjectTest.java
+++ b/luni/src/test/java/org/apache/harmony/crypto/tests/javax/crypto/SealedObjectTest.java
@@ -33,6 +33,7 @@ import java.io.Serializable;
 import java.security.InvalidKeyException;
 import java.security.Key;
 import java.security.NoSuchProviderException;
+import java.util.ArrayList;
 import java.util.Arrays;
 
 import javax.crypto.Cipher;
@@ -43,6 +44,8 @@ import javax.crypto.SealedObject;
 import javax.crypto.spec.IvParameterSpec;
 import javax.crypto.spec.SecretKeySpec;
 
+import libcore.util.SerializationTester;
+
 /**
  */
 public class SealedObjectTest extends TestCase {
@@ -291,4 +294,23 @@ public class SealedObjectTest extends TestCase {
         }
     }
 
+    // http://code.google.com/p/android/issues/detail?id=4834
+    public void testDeserialization() throws Exception {
+        // (Boilerplate so we can create SealedObject instances.)
+        KeyGenerator kg = KeyGenerator.getInstance("DES");
+        Key key = kg.generateKey();
+        Cipher cipher = Cipher.getInstance("DES");
+        cipher.init(Cipher.ENCRYPT_MODE, key);
+
+        // Incorrect use of readUnshared meant you couldn't have two SealedObjects
+        // with the same algorithm or parameters algorithm...
+        ArrayList<SealedObject> sealedObjects = new ArrayList<SealedObject>();
+        for (int i = 0; i < 10; ++i) {
+            sealedObjects.add(new SealedObject("hello", cipher));
+        }
+        String serializedForm = SerializationTester.serializeHex(sealedObjects);
+
+        // ...so this would throw "java.io.InvalidObjectException: Unshared read of back reference".
+        SerializationTester.deserializeHex(serializedForm);
+    }
 }
-- 
cgit v1.1


From ebac4e8fcafe084009925cfa7526e73fa4ed0487 Mon Sep 17 00:00:00 2001
From: Vladimir Marko <vmarko@google.com>
Date: Fri, 6 Jul 2012 12:45:42 +0100
Subject: Improve HttpResponseCache performance.

Avoid writing to HttpResponseCache.CacheRequestImpl.cacheOut
one byte at a time via inefficient FilterOutputStream write.

(cherry-picked from 91cc423115fdfa682d9c4cd025dee06aaa145b3c.)

Bug: 6738383
Change-Id: Ia657d7417cc292746968809f6896a5e790f1394d
---
 luni/src/main/java/libcore/net/http/HttpResponseCache.java | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/luni/src/main/java/libcore/net/http/HttpResponseCache.java b/luni/src/main/java/libcore/net/http/HttpResponseCache.java
index 56042b1..24aff87 100644
--- a/luni/src/main/java/libcore/net/http/HttpResponseCache.java
+++ b/luni/src/main/java/libcore/net/http/HttpResponseCache.java
@@ -262,6 +262,13 @@ public final class HttpResponseCache extends ResponseCache {
                     super.close();
                     editor.commit();
                 }
+
+                @Override
+                public void write(byte[] buffer, int offset, int length) throws IOException {
+                    // Since we don't override "write(int oneByte)", we can write directly to "out"
+                    // and avoid the inefficient implementation from the FilterOutputStream.
+                    out.write(buffer, offset, length);
+                }
             };
         }
 
-- 
cgit v1.1


From b0e6dc5464f959b3d42f37b32f4b01767f6fe506 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Wed, 11 Jul 2012 15:24:39 -0700
Subject: Fix NetworkInterface.getNetworkInterfaces /proc/net/if_inet6 parsing.

It turns out that some devices can have very large interface indexes,
and my code was incorrectly assuming they'd always fit in 8 bits.

Bug: http://code.google.com/p/android/issues/detail?id=34022
Change-Id: I388a46ffe45f9706a4e28fb3b2975c991a74d419
---
 luni/src/main/java/java/net/NetworkInterface.java | 18 +++++++++++++++---
 1 file changed, 15 insertions(+), 3 deletions(-)

diff --git a/luni/src/main/java/java/net/NetworkInterface.java b/luni/src/main/java/java/net/NetworkInterface.java
index e06b811..ad81f32 100644
--- a/luni/src/main/java/java/net/NetworkInterface.java
+++ b/luni/src/main/java/java/net/NetworkInterface.java
@@ -122,7 +122,9 @@ public final class NetworkInterface extends Object {
 
     private static void collectIpv6Addresses(String interfaceName, int interfaceIndex,
             List<InetAddress> addresses, List<InterfaceAddress> interfaceAddresses) throws SocketException {
-        // Format of /proc/net/if_inet6 (all numeric fields are implicit hex).
+        // Format of /proc/net/if_inet6.
+        // All numeric fields are implicit hex,
+        // but not necessarily two-digit (http://code.google.com/p/android/issues/detail?id=34022).
         // 1. IPv6 address
         // 2. interface index
         // 3. prefix length
@@ -130,6 +132,7 @@ public final class NetworkInterface extends Object {
         // 5. flags
         // 6. interface name
         // "00000000000000000000000000000001 01 80 10 80       lo"
+        // "fe800000000000000000000000000000 407 40 20 80    wlan0"
         BufferedReader in = null;
         try {
             in = new BufferedReader(new FileReader("/proc/net/if_inet6"));
@@ -139,13 +142,22 @@ public final class NetworkInterface extends Object {
                 if (!line.endsWith(suffix)) {
                     continue;
                 }
+
+                // Extract the IPv6 address.
                 byte[] addressBytes = new byte[16];
                 for (int i = 0; i < addressBytes.length; ++i) {
                     addressBytes[i] = (byte) Integer.parseInt(line.substring(2*i, 2*i + 2), 16);
                 }
-                short prefixLength = Short.parseShort(line.substring(36, 38), 16);
-                Inet6Address inet6Address = new Inet6Address(addressBytes, null, interfaceIndex);
 
+                // Extract the prefix length.
+                // Skip the IPv6 address and its trailing space.
+                int prefixLengthStart = 32 + 1;
+                // Skip the interface index and its trailing space.
+                prefixLengthStart = line.indexOf(' ', prefixLengthStart) + 1;
+                int prefixLengthEnd = line.indexOf(' ', prefixLengthStart);
+                short prefixLength = Short.parseShort(line.substring(prefixLengthStart, prefixLengthEnd), 16);
+
+                Inet6Address inet6Address = new Inet6Address(addressBytes, null, interfaceIndex);
                 addresses.add(inet6Address);
                 interfaceAddresses.add(new InterfaceAddress(inet6Address, prefixLength));
             }
-- 
cgit v1.1


From fec51846c02116a6ac02fac8ecf8ffb705a74b36 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Thu, 12 Jul 2012 13:52:12 -0700
Subject: Rewrite File.mkdirs, improve the documentation, and add tests.

Every time anyone stumbles across the File.mkdirs implementation,
usually because of some other problem, it takes us a few minutes
of head-scratching to convince ourselves that the recusive case
is correct. So let's rewrite it to be a little less unclear.

Also improve the documentation and add some tests. Turns out the
only mkdirs tests were implicit (where it's used for test setup)
or for special cases (like the empty path). Duh.

Change-Id: I78376fb1aaa72223c63c581d18c6682a50c84e23
---
 luni/src/main/java/java/io/File.java             | 66 +++++++++++++-----------
 luni/src/test/java/libcore/java/io/FileTest.java | 41 +++++++++++++++
 2 files changed, 78 insertions(+), 29 deletions(-)

diff --git a/luni/src/main/java/java/io/File.java b/luni/src/main/java/java/io/File.java
index 968f021..ac67e7c 100644
--- a/luni/src/main/java/java/io/File.java
+++ b/luni/src/main/java/java/io/File.java
@@ -855,57 +855,65 @@ public class File implements Serializable, Comparable<File> {
     }
 
     /**
-     * Creates the directory named by the trailing filename of this file. Does
-     * not create the complete path required to create this directory.
+     * Creates the directory named by this file, assuming its parents exist.
+     * Use {@link #mkdirs} if you also want to create missing parents.
      *
      * <p>Note that this method does <i>not</i> throw {@code IOException} on failure.
-     * Callers must check the return value.
+     * Callers must check the return value. Note also that this method returns
+     * false if the directory already existed. If you want to know whether the
+     * directory exists on return, either use {@code (f.mkdir() || f.isDirectory())}
+     * or simply ignore the return value from this method and simply call {@link #isDirectory}.
      *
-     * @return {@code true} if the directory has been created, {@code false}
-     *         otherwise.
-     * @see #mkdirs
+     * @return {@code true} if the directory was created,
+     *         {@code false} on failure or if the directory already existed.
      */
     public boolean mkdir() {
         try {
-            // On Android, we don't want default permissions to allow global access.
-            Libcore.os.mkdir(path, S_IRWXU);
+            mkdirErrno();
             return true;
         } catch (ErrnoException errnoException) {
             return false;
         }
     }
 
+    private void mkdirErrno() throws ErrnoException {
+        // On Android, we don't want default permissions to allow global access.
+        Libcore.os.mkdir(path, S_IRWXU);
+    }
+
     /**
-     * Creates the directory named by the trailing filename of this file,
-     * including the complete directory path required to create this directory.
+     * Creates the directory named by this file, creating missing parent
+     * directories if necessary.
+     * Use {@link #mkdir} if you don't want to create missing parents.
      *
      * <p>Note that this method does <i>not</i> throw {@code IOException} on failure.
-     * Callers must check the return value.
+     * Callers must check the return value. Note also that this method returns
+     * false if the directory already existed. If you want to know whether the
+     * directory exists on return, either use {@code (f.mkdirs() || f.isDirectory())}
+     * or simply ignore the return value from this method and simply call {@link #isDirectory}.
      *
-     * @return {@code true} if the necessary directories have been created,
-     *         {@code false} if the target directory already exists or one of
-     *         the directories can not be created.
-     * @see #mkdir
+     * @return {@code true} if the directory was created,
+     *         {@code false} on failure or if the directory already existed.
      */
     public boolean mkdirs() {
-        /* If the terminal directory already exists, answer false */
-        if (exists()) {
-            return false;
-        }
+        return mkdirs(false);
+    }
 
-        /* If the receiver can be created, answer true */
-        if (mkdir()) {
+    private boolean mkdirs(boolean resultIfExists) {
+        try {
+            // Try to create the directory directly.
+            mkdirErrno();
             return true;
-        }
-
-        String parentDir = getParent();
-        /* If there is no parent and we were not created, answer false */
-        if (parentDir == null) {
+        } catch (ErrnoException errnoException) {
+            if (errnoException.errno == ENOENT) {
+                // If the parent was missing, try to create it and then try again.
+                File parent = getParentFile();
+                return parent != null && parent.mkdirs(true) && mkdir();
+            } else if (errnoException.errno == EEXIST) {
+                return resultIfExists;
+            }
             return false;
         }
-
-        /* Otherwise, try to create a parent directory and then this directory */
-        return (new File(parentDir).mkdirs() && mkdir());
     }
 
     /**
diff --git a/luni/src/test/java/libcore/java/io/FileTest.java b/luni/src/test/java/libcore/java/io/FileTest.java
index 3cf621e..b2391ac 100644
--- a/luni/src/test/java/libcore/java/io/FileTest.java
+++ b/luni/src/test/java/libcore/java/io/FileTest.java
@@ -225,4 +225,45 @@ public class FileTest extends junit.framework.TestCase {
         assertTrue(new File("/").getTotalSpace() >= 0);
         assertTrue(new File("/").getUsableSpace() >= 0);
     }
+
+    public void test_mkdirs() throws Exception {
+        // Set up a directory to test in.
+        File base = createTemporaryDirectory();
+
+        // mkdirs returns true only if it _creates_ a directory.
+        // So we get false for a directory that already exists...
+        assertTrue(base.exists());
+        assertFalse(base.mkdirs());
+        // But true if we had to create something.
+        File a = new File(base, "a");
+        assertFalse(a.exists());
+        assertTrue(a.mkdirs());
+        assertTrue(a.exists());
+
+        // Test the recursive case where we need to create multiple parents.
+        File b = new File(a, "b");
+        File c = new File(b, "c");
+        File d = new File(c, "d");
+        assertTrue(a.exists());
+        assertFalse(b.exists());
+        assertFalse(c.exists());
+        assertFalse(d.exists());
+        assertTrue(d.mkdirs());
+        assertTrue(a.exists());
+        assertTrue(b.exists());
+        assertTrue(c.exists());
+        assertTrue(d.exists());
+
+        // Test the case where the 'directory' exists as a file.
+        File existsAsFile = new File(base, "existsAsFile");
+        existsAsFile.createNewFile();
+        assertTrue(existsAsFile.exists());
+        assertFalse(existsAsFile.mkdirs());
+
+        // Test the case where the parent exists as a file.
+        File badParent = new File(existsAsFile, "sub");
+        assertTrue(existsAsFile.exists());
+        assertFalse(badParent.exists());
+        assertFalse(badParent.mkdirs());
+    }
 }
-- 
cgit v1.1


From 91cd2eae0c1fd2e04d46876856b33b8324aa8b5f Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Thu, 12 Jul 2012 16:18:26 -0700
Subject: Fix Matcher.find(int) to ignore the region.

Also fix the tests, which were wrong.

Bug: 6404568
Change-Id: I8718aab754bdbc87c37d573d19c4999cc3c447ac
---
 luni/src/main/java/java/util/regex/Matcher.java    | 40 ++++------------------
 .../libcore/java/util/regex/OldMatcherTest.java    | 29 ++++++++++++----
 2 files changed, 29 insertions(+), 40 deletions(-)

diff --git a/luni/src/main/java/java/util/regex/Matcher.java b/luni/src/main/java/java/util/regex/Matcher.java
index 58bcf9e..cfd4432 100644
--- a/luni/src/main/java/java/util/regex/Matcher.java
+++ b/luni/src/main/java/java/util/regex/Matcher.java
@@ -50,11 +50,6 @@ public final class Matcher implements MatchResult {
     private int regionEnd;
 
     /**
-     * Holds the position where the next find operation will take place.
-     */
-    private int findPos;
-
-    /**
      * Holds the position where the next append operation will take place.
      */
     private int appendPos;
@@ -212,7 +207,6 @@ public final class Matcher implements MatchResult {
         resetForInput();
 
         matchFound = false;
-        findPos = regionStart;
         appendPos = 0;
 
         return this;
@@ -377,30 +371,17 @@ public final class Matcher implements MatchResult {
     }
 
     /**
-     * Returns the next occurrence of the {@link Pattern} in the input. The
-     * method starts the search from the given character in the input.
+     * Returns true if there is another match in the input, starting
+     * from the given position. The region is ignored.
      *
-     * @param start
-     *            The index in the input at which the find operation is to
-     *            begin. If this is less than the start of the region, it is
-     *            automatically adjusted to that value. If it is beyond the end
-     *            of the region, the method will fail.
-     * @return true if (and only if) a match has been found.
+     * @throws IndexOutOfBoundsException if {@code start < 0 || start > input.length()}
      */
     public boolean find(int start) {
-        findPos = start;
-
-        if (findPos < regionStart) {
-            findPos = regionStart;
-        } else if (findPos >= regionEnd) {
-            matchFound = false;
-            return false;
+        if (start < 0 || start > input.length()) {
+            throw new IndexOutOfBoundsException("start=" + start + "; length=" + input.length());
         }
 
-        matchFound = findImpl(address, input, findPos, matchOffsets);
-        if (matchFound) {
-            findPos = matchOffsets[1];
-        }
+        matchFound = findImpl(address, input, start, matchOffsets);
         return matchFound;
     }
 
@@ -414,9 +395,6 @@ public final class Matcher implements MatchResult {
      */
     public boolean find() {
         matchFound = findNextImpl(address, input, matchOffsets);
-        if (matchFound) {
-            findPos = matchOffsets[1];
-        }
         return matchFound;
     }
 
@@ -429,9 +407,6 @@ public final class Matcher implements MatchResult {
      */
     public boolean lookingAt() {
         matchFound = lookingAtImpl(address, input, matchOffsets);
-        if (matchFound) {
-            findPos = matchOffsets[1];
-        }
         return matchFound;
     }
 
@@ -444,9 +419,6 @@ public final class Matcher implements MatchResult {
      */
     public boolean matches() {
         matchFound = matchesImpl(address, input, matchOffsets);
-        if (matchFound) {
-            findPos = matchOffsets[1];
-        }
         return matchFound;
     }
 
diff --git a/luni/src/test/java/libcore/java/util/regex/OldMatcherTest.java b/luni/src/test/java/libcore/java/util/regex/OldMatcherTest.java
index 54f976d..07d99e9 100644
--- a/luni/src/test/java/libcore/java/util/regex/OldMatcherTest.java
+++ b/luni/src/test/java/libcore/java/util/regex/OldMatcherTest.java
@@ -247,19 +247,36 @@ public class OldMatcherTest extends TestCase {
             }
         }
 
-        // Starting index out of region
+        String string3 = "Brave new world";
         Pattern pat3 = Pattern.compile("new");
-        Matcher mat3 = pat3.matcher("Brave new world");
+        Matcher mat3 = pat3.matcher(string3);
+
+        // find(int) throws for out of range indexes.
+        try {
+            mat3.find(-1);
+            fail();
+        } catch (IndexOutOfBoundsException expected) {
+        }
+        assertFalse(mat3.find(string3.length()));
+        try {
+            mat3.find(string3.length() + 1);
+            fail();
+        } catch (IndexOutOfBoundsException expected) {
+        }
 
-        assertTrue(mat3.find(-1));
         assertTrue(mat3.find(6));
         assertFalse(mat3.find(7));
 
         mat3.region(7, 10);
+        assertFalse(mat3.find()); // No "new" in the region.
 
-        assertFalse(mat3.find(3));
-        assertFalse(mat3.find(6));
-        assertFalse(mat3.find(7));
+        assertTrue(mat3.find(3)); // find(int) ignores the region.
+        assertTrue(mat3.find(6)); // find(int) ignores the region.
+        assertFalse(mat3.find(7)); // No "new" >= 7.
+
+        mat3.region(1, 4);
+        assertFalse(mat3.find()); // No "new" in the region.
+        assertTrue(mat3.find(5)); // find(int) ignores the region.
     }
 
     public void testSEOLsymbols() {
-- 
cgit v1.1


From 7c935d4e4ca990334200cf5eb4fbcfac718c6b45 Mon Sep 17 00:00:00 2001
From: gcollins <gcollins@antennasoftware.com>
Date: Mon, 4 Jun 2012 17:26:45 -0400
Subject: CertificateRequest should handle case where certificate is requested
 but none is available.

Android SSL client was not handling a CertificateRequest where there was no cert to send.
It had a problem because it was assuming that if the CertificateMessage response is not null,
it means there is a cert included, which is not true (if it has no cert to send an empty CertificateMessage
is sent to the server). So I updated the CertificateVerify creation check to also check whether the CertificateMessage
contained any certs (ClientHandshakeImpl.java).
In testing I found that the same error was in the server code so I made the same change there
(ServerHandshakeImpl.java).
I added two test cases to SSLEngineTest - one to directly test the scenario (test_SSLEngine_clientAuthWantedNoClientCert)
and one to just double-check that the server would not allow the connection if setNeedClientAuth (test_SSLEngine_clientAuthNeededNoClientCert).

Bug: http://code.google.com/p/android/issues/detail?id=31903
Change-Id: Ideb57d6ccbcdd54ca24dc3063e60aba2653c8414
---
 .../xnet/provider/jsse/ClientHandshakeImpl.java    |  2 +-
 .../xnet/provider/jsse/ServerHandshakeImpl.java    |  2 +-
 .../java/libcore/javax/net/ssl/SSLEngineTest.java  | 45 ++++++++++++++++++++++
 3 files changed, 47 insertions(+), 2 deletions(-)

diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/ClientHandshakeImpl.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/ClientHandshakeImpl.java
index d21aa2c..71fd0ba 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/ClientHandshakeImpl.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/ClientHandshakeImpl.java
@@ -499,7 +499,7 @@ public class ClientHandshakeImpl extends HandshakeProtocol {
 
         // send certificate verify for all certificates except those containing
         // fixed DH parameters
-        if (clientCert != null && !clientKeyExchange.isEmpty()) {
+        if (clientCert != null && clientCert.certs.length > 0 && !clientKeyExchange.isEmpty()) {
             // Certificate verify
             String authType = clientKey.getAlgorithm();
             DigitalSignature ds = new DigitalSignature(authType);
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/ServerHandshakeImpl.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/ServerHandshakeImpl.java
index b6a65b4..5ee47cd 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/ServerHandshakeImpl.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/ServerHandshakeImpl.java
@@ -651,7 +651,7 @@ public class ServerHandshakeImpl extends HandshakeProtocol {
         } else {
             if ((parameters.getNeedClientAuth() && clientCert == null)
                     || clientKeyExchange == null
-                    || (clientCert != null
+                    || (clientCert != null && clientCert.certs.length > 0
                             && !clientKeyExchange.isEmpty()
                             && certificateVerify == null)) {
                 unexpectedMessage();
diff --git a/luni/src/test/java/libcore/javax/net/ssl/SSLEngineTest.java b/luni/src/test/java/libcore/javax/net/ssl/SSLEngineTest.java
index 5e91dc1..f8fb958 100644
--- a/luni/src/test/java/libcore/javax/net/ssl/SSLEngineTest.java
+++ b/luni/src/test/java/libcore/javax/net/ssl/SSLEngineTest.java
@@ -346,6 +346,51 @@ public class SSLEngineTest extends TestCase {
         c.close();
     }
 
+   /**
+    * http://code.google.com/p/android/issues/detail?id=31903
+    * This test case directly tests the fix for the issue.
+    */
+    public void test_SSLEngine_clientAuthWantedNoClientCert() throws Exception {
+        TestSSLContext clientAuthContext
+                = TestSSLContext.create(TestKeyStore.getClient(),
+                                        TestKeyStore.getServer());
+        TestSSLEnginePair p = TestSSLEnginePair.create(clientAuthContext,
+                                                       new TestSSLEnginePair.Hooks() {
+            @Override
+            void beforeBeginHandshake(SSLEngine client, SSLEngine server) {
+                server.setWantClientAuth(true);
+            }
+        });
+        assertConnected(p);
+        clientAuthContext.close();
+    }
+
+   /**
+    * http://code.google.com/p/android/issues/detail?id=31903
+    * This test case verifies that if the server requires a client cert
+    * (setNeedClientAuth) but the client does not provide one SSL connection
+    * establishment will fail
+    */
+    public void test_SSLEngine_clientAuthNeededNoClientCert() throws Exception {
+        boolean handshakeExceptionCaught = false;
+        TestSSLContext clientAuthContext
+                = TestSSLContext.create(TestKeyStore.getClient(),
+                                        TestKeyStore.getServer());
+        try {
+            TestSSLEnginePair.create(clientAuthContext,
+                             new TestSSLEnginePair.Hooks() {
+                @Override
+                void beforeBeginHandshake(SSLEngine client, SSLEngine server) {
+                    server.setNeedClientAuth(true);
+                }
+            });
+            fail();
+        } catch (SSLHandshakeException expected) {
+        } finally {
+            clientAuthContext.close();
+        }
+    }
+
     public void test_SSLEngine_getEnableSessionCreation() throws Exception {
         TestSSLContext c = TestSSLContext.create();
         SSLEngine e = c.clientContext.createSSLEngine();
-- 
cgit v1.1


From 47cc9f97b6c91463b58e80996d36337caae91693 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Wed, 18 Jul 2012 14:53:15 -0700
Subject: OldDateFormatTest is flaky; improve its output.

Hopefully this will let us debug the flakiness.

Bug: 6838286
Change-Id: I501c4ad726e5d8f0e11b4e69feace97dc70cc775
---
 .../java/libcore/java/text/OldDateFormatTest.java  | 28 +++++++++-------------
 1 file changed, 11 insertions(+), 17 deletions(-)

diff --git a/luni/src/test/java/libcore/java/text/OldDateFormatTest.java b/luni/src/test/java/libcore/java/text/OldDateFormatTest.java
index f614d6f..6b3885c 100644
--- a/luni/src/test/java/libcore/java/text/OldDateFormatTest.java
+++ b/luni/src/test/java/libcore/java/text/OldDateFormatTest.java
@@ -203,7 +203,7 @@ public class OldDateFormatTest extends junit.framework.TestCase {
     /**
      * java.text.DateFormat#parse(String)
      */
-    public void test_parseLString() {
+    public void test_parseLString() throws Exception {
         DateFormat format = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT, Locale.US);
 
         try {
@@ -338,35 +338,29 @@ public class OldDateFormatTest extends junit.framework.TestCase {
         try {
             format.parse("January 31 1970 7:52:34 AM PST");
             fail("ParseException was not thrown.");
-        } catch(ParseException pe) {
-            //expected
+        } catch (ParseException expected) {
         }
 
         try {
             format.parse("January 31 1970");
             fail("ParseException was not thrown.");
-        } catch(ParseException pe) {
-            //expected
+        } catch (ParseException expected) {
         }
 
         format = DateFormat.getDateTimeInstance(DateFormat.FULL, DateFormat.FULL, Locale.US);
-        try {
-            Date date = format.parse(format.format(current).toString());
-            assertEquals(current.getDate(), date.getDate());
-            assertEquals(current.getDay(), date.getDay());
-            assertEquals(current.getMonth(), date.getMonth());
-            assertEquals(current.getYear(), date.getYear());
-            assertEquals(current.getHours(), date.getHours());
-            assertEquals(current.getMinutes(), date.getMinutes());
-        } catch(ParseException pe) {
-            fail("ParseException was thrown for current Date.");
+        String formatPattern = ((SimpleDateFormat) format).toPattern();
+        String formattedCurrent = format.format(current);
+        Date date = format.parse(formattedCurrent);
+        // Date has millisecond accuracy, but humans don't use time formats that precise.
+        if (date.getTime() / 1000 != current.getTime() / 1000) {
+            fail(date.getTime() + " != " + current.getTime() +
+                    "; " + formatPattern + "; " + formattedCurrent);
         }
 
         try {
             format.parse("January 16, 1970 8:03:52 PM CET");
             fail("ParseException was not thrown.");
-        } catch(ParseException pe) {
-            //expected
+        } catch (ParseException expected) {
         }
     }
 
-- 
cgit v1.1


From 903b3f5b6a6e524cb4d88b83ea32e7c355392271 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Wed, 18 Jul 2012 18:06:40 -0700
Subject: Start removing Support_PortManager.

A bad idea, badly implemented.

Bug: 2441548
Change-Id: I34c990f6fd9d746771846f186a7ab3ab59e78a9f
---
 .../libcore/java/net/OldDatagramPacketTest.java    | 69 ++++++----------------
 .../java/libcore/java/net/OldServerSocketTest.java | 21 +++----
 .../libcore/java/net/OldURLClassLoaderTest.java    |  7 +--
 .../nio/channels/OldServerSocketChannelTest.java   | 11 +---
 .../java/nio/channels/OldSocketChannelTest.java    | 32 ++++------
 .../java/libcore/java/util/OldScannerTest.java     | 10 +---
 .../luni/tests/java/net/URLConnectionTest.java     |  4 +-
 .../api/javax/net/ssl/SSLSocketFactoryTest.java    |  5 +-
 .../java/tests/support/Support_TestWebServer.java  | 46 +++------------
 9 files changed, 55 insertions(+), 150 deletions(-)

diff --git a/luni/src/test/java/libcore/java/net/OldDatagramPacketTest.java b/luni/src/test/java/libcore/java/net/OldDatagramPacketTest.java
index a77a44d..8ca4067 100644
--- a/luni/src/test/java/libcore/java/net/OldDatagramPacketTest.java
+++ b/luni/src/test/java/libcore/java/net/OldDatagramPacketTest.java
@@ -21,71 +21,40 @@ import java.io.IOException;
 import java.net.DatagramPacket;
 import java.net.DatagramSocket;
 import java.net.InetAddress;
-import tests.support.Support_PortManager;
 
 public class OldDatagramPacketTest extends junit.framework.TestCase {
 
-    DatagramPacket dp;
-
-    volatile boolean started = false;
-
-    public void test_getPort() throws IOException {
-        dp = new DatagramPacket("Hello".getBytes(), 5, InetAddress.getLocalHost(), 1000);
+    public void test_getPort() throws Exception {
+        DatagramPacket dp = new DatagramPacket("Hello".getBytes(), 5, InetAddress.getLocalHost(), 1000);
         assertEquals("Incorrect port returned", 1000, dp.getPort());
 
-        InetAddress localhost = InetAddress.getByName("localhost");
-
-        int[] ports = Support_PortManager.getNextPortsForUDP(2);
-        final int port = ports[0];
-        final Object lock = new Object();
-
+        final DatagramSocket ss = new DatagramSocket();
         Thread thread = new Thread(new Runnable() {
             public void run() {
-                DatagramSocket socket = null;
                 try {
-                    socket = new DatagramSocket(port);
-                    synchronized (lock) {
-                        started = true;
-                        lock.notifyAll();
-                    }
-                    socket.setSoTimeout(3000);
-                    DatagramPacket packet = new DatagramPacket(new byte[256],
-                            256);
-                    socket.receive(packet);
-                    socket.send(packet);
-                    socket.close();
+                    DatagramPacket packet = new DatagramPacket(new byte[256], 256);
+                    ss.setSoTimeout(3000);
+                    ss.receive(packet);
+                    ss.send(packet);
                 } catch (IOException e) {
                     System.out.println("thread exception: " + e);
-                    if (socket != null)
-                        socket.close();
                 }
             }
         });
         thread.start();
 
-        DatagramSocket socket = null;
+        DatagramSocket cs = new DatagramSocket();
         try {
-            socket = new DatagramSocket(ports[1]);
-            socket.setSoTimeout(3000);
-            DatagramPacket packet = new DatagramPacket(new byte[] { 1, 2, 3, 4,
-                    5, 6 }, 6, localhost, port);
-            synchronized (lock) {
-                try {
-                    if (!started)
-                        lock.wait();
-                } catch (InterruptedException e) {
-                    fail(e.toString());
-                }
-            }
-            socket.send(packet);
-            socket.receive(packet);
-            socket.close();
-            assertTrue("datagram received wrong port: " + packet.getPort(),
-                    packet.getPort() == port);
+            byte[] bytes = new byte[] { 1, 2, 3, 4, 5, 6 };
+            DatagramPacket packet = new DatagramPacket(bytes, 6, InetAddress.getByName("localhost"), ss.getLocalPort());
+            cs.send(packet);
+            cs.setSoTimeout(3000);
+            cs.receive(packet);
+            cs.close();
+            assertEquals(packet.getPort(), ss.getLocalPort());
         } finally {
-            if (socket != null) {
-                socket.close();
-            }
+            cs.close();
+            ss.close();
         }
     }
 
@@ -104,7 +73,7 @@ public class OldDatagramPacketTest extends junit.framework.TestCase {
     }
 
     public void test_setData$BII() {
-        dp = new DatagramPacket("Hello".getBytes(), 5);
+        DatagramPacket dp = new DatagramPacket("Hello".getBytes(), 5);
         try {
             dp.setData(null, 2, 3);
             fail("NullPointerException was not thrown.");
@@ -113,7 +82,7 @@ public class OldDatagramPacketTest extends junit.framework.TestCase {
     }
 
     public void test_setData$B() {
-        dp = new DatagramPacket("Hello".getBytes(), 5);
+        DatagramPacket dp = new DatagramPacket("Hello".getBytes(), 5);
         try {
             dp.setData(null);
             fail("NullPointerException was not thrown.");
diff --git a/luni/src/test/java/libcore/java/net/OldServerSocketTest.java b/luni/src/test/java/libcore/java/net/OldServerSocketTest.java
index cf35489..6518897 100644
--- a/luni/src/test/java/libcore/java/net/OldServerSocketTest.java
+++ b/luni/src/test/java/libcore/java/net/OldServerSocketTest.java
@@ -33,7 +33,6 @@ import java.nio.channels.IllegalBlockingModeException;
 import java.nio.channels.ServerSocketChannel;
 import java.security.Permission;
 import java.util.Properties;
-import tests.support.Support_PortManager;
 
 public class OldServerSocketTest extends OldSocketTestCase {
 
@@ -86,10 +85,9 @@ public class OldServerSocketTest extends OldSocketTestCase {
     }
 
     public void test_ConstructorII() throws IOException {
-        int freePortNumber = Support_PortManager.getNextPort();
-        s = new ServerSocket(freePortNumber, 1);
+        s = new ServerSocket(0, 1);
         s.setSoTimeout(2000);
-        startClient(freePortNumber);
+        startClient(s.getLocalPort());
         sconn = s.accept();
         sconn.close();
         s.close();
@@ -133,10 +131,9 @@ public class OldServerSocketTest extends OldSocketTestCase {
     }
 
     public void test_ConstructorI() throws Exception {
-        int portNumber = Support_PortManager.getNextPort();
-        s = new ServerSocket(portNumber);
+        s = new ServerSocket(0);
         try {
-            new ServerSocket(portNumber);
+            new ServerSocket(s.getLocalPort());
             fail("IOException was not thrown.");
         } catch(IOException ioe) {
             //expected
@@ -162,11 +159,9 @@ public class OldServerSocketTest extends OldSocketTestCase {
     }
 
     public void test_ConstructorIILjava_net_InetAddress() throws IOException {
-        int freePortNumber = Support_PortManager.getNextPort();
-
-        ServerSocket ss = new ServerSocket(freePortNumber, 10, InetAddress.getLocalHost());
+        ServerSocket ss = new ServerSocket(0, 10, InetAddress.getLocalHost());
         try {
-            new ServerSocket(freePortNumber, 10, InetAddress.getLocalHost());
+            new ServerSocket(ss.getLocalPort(), 10, InetAddress.getLocalHost());
             fail("IOException was not thrown.");
         } catch(IOException expected) {
         }
@@ -217,9 +212,7 @@ public class OldServerSocketTest extends OldSocketTestCase {
     }
 
     public void test_accept() throws IOException {
-        int portNumber = Support_PortManager.getNextPort();
-
-        ServerSocket newSocket = new ServerSocket(portNumber);
+        ServerSocket newSocket = new ServerSocket(0);
         newSocket.setSoTimeout(500);
         try {
             Socket accepted = newSocket.accept();
diff --git a/luni/src/test/java/libcore/java/net/OldURLClassLoaderTest.java b/luni/src/test/java/libcore/java/net/OldURLClassLoaderTest.java
index 2646f98..3a5608c 100644
--- a/luni/src/test/java/libcore/java/net/OldURLClassLoaderTest.java
+++ b/luni/src/test/java/libcore/java/net/OldURLClassLoaderTest.java
@@ -35,7 +35,6 @@ import java.util.List;
 import java.util.jar.Manifest;
 import org.apache.harmony.security.tests.support.TestCertUtils;
 import tests.support.Support_Configuration;
-import tests.support.Support_PortManager;
 import tests.support.Support_TestWebData;
 import tests.support.Support_TestWebServer;
 import tests.support.resource.Support_Resources;
@@ -210,13 +209,12 @@ public class OldURLClassLoaderTest extends junit.framework.TestCase {
 
     @SideEffect("Support_TestWebServer requires isolation.")
     public void test_findResourceLjava_lang_String() throws Exception {
-        int port = Support_PortManager.getNextPort();
         File tmp = File.createTempFile("test", ".txt");
 
         Support_TestWebServer server = new Support_TestWebServer();
         try {
 
-            server.initServer(port, tmp.getAbsolutePath(), "text/html");
+            int port = server.initServer(tmp.getAbsolutePath(), "text/html");
 
             URL[] urls = { new URL("http://localhost:" + port + "/") };
             ucl = new URLClassLoader(urls);
@@ -244,9 +242,8 @@ public class OldURLClassLoaderTest extends junit.framework.TestCase {
         tempFile2.deleteOnExit();
 
         Support_TestWebServer server = new Support_TestWebServer();
-        int port = Support_PortManager.getNextPort();
         try {
-            server.initServer(port, false);
+            int port = server.initServer();
 
             String tempPath1 = tempFile1.getParentFile().getAbsolutePath() + "/";
             InputStream is = getClass().getResourceAsStream(
diff --git a/luni/src/test/java/libcore/java/nio/channels/OldServerSocketChannelTest.java b/luni/src/test/java/libcore/java/nio/channels/OldServerSocketChannelTest.java
index fb63512..51f288a 100644
--- a/luni/src/test/java/libcore/java/nio/channels/OldServerSocketChannelTest.java
+++ b/luni/src/test/java/libcore/java/nio/channels/OldServerSocketChannelTest.java
@@ -25,26 +25,17 @@ import java.nio.channels.ServerSocketChannel;
 import java.nio.channels.SocketChannel;
 import java.nio.channels.spi.SelectorProvider;
 import junit.framework.TestCase;
-import tests.support.Support_PortManager;
 
-/*
- * test for ServerSocketChannel
- */
 public class OldServerSocketChannelTest extends TestCase {
 
     private static final int TIME_UNIT = 200;
 
-    private InetSocketAddress localAddr1;
-
     private ServerSocketChannel serverChannel;
 
     private SocketChannel clientChannel;
 
     protected void setUp() throws Exception {
         super.setUp();
-        this.localAddr1 = new InetSocketAddress(
-                "127.0.0.1", Support_PortManager
-                        .getNextPort());
         this.serverChannel = ServerSocketChannel.open();
         this.clientChannel = SocketChannel.open();
     }
@@ -87,7 +78,7 @@ public class OldServerSocketChannelTest extends TestCase {
     public void test_accept_Block_NoConnect_interrupt() throws IOException {
         assertTrue(this.serverChannel.isBlocking());
         ServerSocket gotSocket = this.serverChannel.socket();
-        gotSocket.bind(localAddr1);
+        gotSocket.bind(null);
 
         class MyThread extends Thread {
             public String errMsg = null;
diff --git a/luni/src/test/java/libcore/java/nio/channels/OldSocketChannelTest.java b/luni/src/test/java/libcore/java/nio/channels/OldSocketChannelTest.java
index f182375..750be35 100644
--- a/luni/src/test/java/libcore/java/nio/channels/OldSocketChannelTest.java
+++ b/luni/src/test/java/libcore/java/nio/channels/OldSocketChannelTest.java
@@ -35,11 +35,7 @@ import java.nio.channels.UnresolvedAddressException;
 import java.nio.channels.UnsupportedAddressTypeException;
 import java.nio.channels.spi.SelectorProvider;
 import junit.framework.TestCase;
-import tests.support.Support_PortManager;
 
-/**
- * Tests for SocketChannel and its default implementation.
- */
 public class OldSocketChannelTest extends TestCase {
 
     private static final int CAPACITY_NORMAL = 200;
@@ -58,11 +54,10 @@ public class OldSocketChannelTest extends TestCase {
 
     protected void setUp() throws Exception {
         super.setUp();
-        this.localAddr1 = new InetSocketAddress("127.0.0.1",
-                Support_PortManager.getNextPort());
         this.channel1 = SocketChannel.open();
         this.channel2 = SocketChannel.open();
-        this.server1 = new ServerSocket(localAddr1.getPort());
+        this.server1 = new ServerSocket(0);
+        this.localAddr1 = (InetSocketAddress) server1.getLocalSocketAddress();
     }
 
     protected void tearDown() throws Exception {
@@ -292,12 +287,9 @@ public class OldSocketChannelTest extends TestCase {
         server.start();
         Thread.currentThread().sleep(1000);
 
-        InetSocketAddress address = new InetSocketAddress(InetAddress
-                .getByName("localhost"), port);
-
         // First test with array based byte buffer
         SocketChannel sc = SocketChannel.open();
-        sc.connect(address);
+        sc.connect(server.getLocalSocketAddress());
 
         ByteBuffer buf = ByteBuffer.allocate(data.length);
         buf.limit(data.length / 2);
@@ -313,7 +305,7 @@ public class OldSocketChannelTest extends TestCase {
 
         // Now test with direct byte buffer
         sc = SocketChannel.open();
-        sc.connect(address);
+        sc.connect(server.getLocalSocketAddress());
 
         buf = ByteBuffer.allocateDirect(data.length);
         buf.limit(data.length / 2);
@@ -339,17 +331,15 @@ public class OldSocketChannelTest extends TestCase {
     }
 
     public static boolean done = false;
-    public static int port = Support_PortManager.getNextPort();
     public static byte[] data = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
 
     static class ServerThread extends Thread {
-        @Override
-        public void run() {
+        private ServerSocketChannel ssc;
+
+        @Override public void run() {
             try {
-                ServerSocketChannel ssc = ServerSocketChannel.open();
-                InetSocketAddress addr = new InetSocketAddress(InetAddress
-                        .getByAddress(new byte[] {0, 0, 0, 0}), port);
-                ssc.socket().bind(addr, 0);
+                ssc = ServerSocketChannel.open();
+                ssc.socket().bind(null, 0);
 
                 ByteBuffer buf = ByteBuffer.allocate(10);
                 buf.put(data);
@@ -363,6 +353,10 @@ public class OldSocketChannelTest extends TestCase {
                 // ignore
             }
         }
+
+        public SocketAddress getLocalSocketAddress() {
+            return ssc.socket().getLocalSocketAddress();
+        }
     }
 
     class MockSocketChannel extends SocketChannel {
diff --git a/luni/src/test/java/libcore/java/util/OldScannerTest.java b/luni/src/test/java/libcore/java/util/OldScannerTest.java
index b51cfbc..9bac1f4 100644
--- a/luni/src/test/java/libcore/java/util/OldScannerTest.java
+++ b/luni/src/test/java/libcore/java/util/OldScannerTest.java
@@ -28,7 +28,6 @@ import java.util.Scanner;
 import java.util.regex.MatchResult;
 import java.util.regex.Pattern;
 import junit.framework.TestCase;
-import tests.support.Support_PortManager;
 
 public final class OldScannerTest extends TestCase {
 
@@ -492,15 +491,12 @@ public final class OldScannerTest extends TestCase {
         assertEquals(102400, matchResult.end());
     }
 
-    public void test_Constructor_LReadableByteChannel()
-            throws IOException {
-        InetSocketAddress localAddr = new InetSocketAddress("127.0.0.1",
-                Support_PortManager.getNextPort());
+    public void test_Constructor_LReadableByteChannel() throws IOException {
         ServerSocketChannel ssc = ServerSocketChannel.open();
-        ssc.socket().bind(localAddr);
+        ssc.socket().bind(null);
 
         SocketChannel sc = SocketChannel.open();
-        sc.connect(localAddr);
+        sc.connect(ssc.socket().getLocalSocketAddress());
         sc.configureBlocking(false);
         assertFalse(sc.isBlocking());
 
diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/net/URLConnectionTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/net/URLConnectionTest.java
index 9f414c3..ab675e2 100644
--- a/luni/src/test/java/org/apache/harmony/luni/tests/java/net/URLConnectionTest.java
+++ b/luni/src/test/java/org/apache/harmony/luni/tests/java/net/URLConnectionTest.java
@@ -19,7 +19,6 @@ package org.apache.harmony.luni.tests.java.net;
 import dalvik.annotation.BrokenTest;
 import junit.framework.TestCase;
 import tests.support.Support_Configuration;
-import tests.support.Support_PortManager;
 import tests.support.Support_TestWebData;
 import tests.support.Support_TestWebServer;
 import tests.support.resource.Support_Resources;
@@ -222,9 +221,8 @@ public class URLConnectionTest extends TestCase {
 
 //        ftpURL = new URL(Support_Configuration.testFTPURL);
 
-        port = Support_PortManager.getNextPort();
         server = new Support_TestWebServer();
-        server.initServer(port, false);
+        port = server.initServer();
         url = new URL("http://localhost:" + port + "/test1");
         uc = url.openConnection();
         url2 =  new URL("http://localhost:" + port + "/test2");
diff --git a/luni/src/test/java/tests/api/javax/net/ssl/SSLSocketFactoryTest.java b/luni/src/test/java/tests/api/javax/net/ssl/SSLSocketFactoryTest.java
index 02abcc2..0d91116 100644
--- a/luni/src/test/java/tests/api/javax/net/ssl/SSLSocketFactoryTest.java
+++ b/luni/src/test/java/tests/api/javax/net/ssl/SSLSocketFactoryTest.java
@@ -25,16 +25,13 @@ import javax.net.ssl.SSLSocketFactory;
 
 import junit.framework.TestCase;
 
-import tests.support.Support_PortManager;
-
 public class SSLSocketFactoryTest extends TestCase {
 
     private ServerSocket ss;
 
     protected int startServer(String name) {
-        int portNumber = Support_PortManager.getNextPort();
         try {
-            ss = new ServerSocket(portNumber);
+            ss = new ServerSocket(0);
         } catch (IOException e) {
             fail(name + ": " + e);
         }
diff --git a/support/src/test/java/tests/support/Support_TestWebServer.java b/support/src/test/java/tests/support/Support_TestWebServer.java
index 4d6b0d1..5f3cd85 100644
--- a/support/src/test/java/tests/support/Support_TestWebServer.java
+++ b/support/src/test/java/tests/support/Support_TestWebServer.java
@@ -94,51 +94,21 @@ public class Support_TestWebServer implements Support_HttpConstants {
     }
 
     /**
-     * Initialize a new server with default port and timeout.
-     * @param log Set true if you want trace output
-     */
-    public int initServer(boolean log) throws Exception {
-        return initServer(0, DEFAULT_TIMEOUT, log);
-    }
-
-    /**
-     * Initialize a new server with default timeout.
-     * @param port Sets the server to listen on this port, or 0 to let the OS choose.
-     *             Hard-coding ports is evil, so always pass 0.
-     * @param log Set true if you want trace output
-     */
-    public int initServer(int port, boolean log) throws Exception {
-        return initServer(port, DEFAULT_TIMEOUT, log);
-    }
-
-    /**
-     * Initialize a new server with default timeout and disabled log.
-     * @param port Sets the server to listen on this port, or 0 to let the OS choose.
-     *             Hard-coding ports is evil, so always pass 0.
      * @param servePath the path to the dynamic web test data
      * @param contentType the type of the dynamic web test data
      */
-    public int initServer(int port, String servePath, String contentType)
-            throws Exception {
+    public int initServer(String servePath, String contentType) throws Exception {
         Support_TestWebData.initDynamicTestWebData(servePath, contentType);
-        return initServer(port, DEFAULT_TIMEOUT, false);
+        return initServer();
     }
 
-    /**
-     * Initialize a new server with default port and timeout.
-     * @param port Sets the server to listen on this port, or 0 to let the OS choose.
-     *             Hard-coding ports is evil, so always pass 0.
-     * @param timeout Indicates the period of time to wait until a socket is
-     *                closed
-     * @param log Set true if you want trace output
-     */
-    public int initServer(int port, int timeout, boolean log) throws Exception {
-        mTimeout = timeout;
-        mLog = log;
+    public int initServer() throws Exception {
+        mTimeout = DEFAULT_TIMEOUT;
+        mLog = false;
         keepAlive = true;
         if (acceptT == null) {
             acceptT = new AcceptThread();
-            mPort = acceptT.init(port);
+            mPort = acceptT.init();
             acceptT.start();
         }
         return mPort;
@@ -253,8 +223,8 @@ public class Support_TestWebServer implements Support_HttpConstants {
          * @param port the port to use, or 0 to let the OS choose.
          * Hard-coding ports is evil, so always pass 0!
          */
-        public int init(int port) throws IOException {
-            ss = new ServerSocket(port);
+        public int init() throws IOException {
+            ss = new ServerSocket(0);
             ss.setSoTimeout(5000);
             ss.setReuseAddress(true);
             return ss.getLocalPort();
-- 
cgit v1.1


From 8a545afcbad15fdd805b9b7790d3d1aa6323fd9e Mon Sep 17 00:00:00 2001
From: Narayan Kamath <narayan@google.com>
Date: Thu, 19 Jul 2012 09:29:17 +0100
Subject: Add NPN related logging to native crypto

Also fixes a compilation error when logging macros
are expanded.

Change-Id: I1e422917cdb6fec56398344ee096eb50ab519668
---
 .../native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp     | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp b/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
index 0b07531..923b18f 100644
--- a/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
+++ b/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
@@ -1839,7 +1839,7 @@ static void NativeCrypto_RAND_bytes(JNIEnv* env, jclass, jbyteArray output) {
     unsigned char* tmp = reinterpret_cast<unsigned char*>(outputBytes.get());
     if (!RAND_bytes(tmp, outputBytes.size())) {
         throwExceptionIfNecessary(env, "NativeCrypto_RAND_bytes");
-        JNI_TRACE("ctx=%p NativeCrypto_RAND_bytes => threw error", ctx);
+        JNI_TRACE("tmp=%p NativeCrypto_RAND_bytes => threw error", tmp);
         return;
     }
 
@@ -3200,8 +3200,10 @@ static int next_proto_select_callback(SSL* ssl, unsigned char **out, unsigned ch
     SSL_set_mode(ssl, SSL_MODE_HANDSHAKE_CUTTHROUGH);
 
     AppData* appData = toAppData(ssl);
+    JNI_TRACE("AppData=%p", appData);
     unsigned char* npnProtocols = reinterpret_cast<unsigned char*>(appData->npnProtocolsData);
     size_t npnProtocolsLength = appData->npnProtocolsLength;
+    JNI_TRACE("npn_protocols=%p, length=%d", npnProtocols, npnProtocolsLength);
 
     int status = SSL_select_next_proto(out, outlen, in, inlen, npnProtocols, npnProtocolsLength);
     switch (status) {
-- 
cgit v1.1


From 459a8ccbcc3dfde730780244e2122a734858acee Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Thu, 19 Jul 2012 14:22:19 -0700
Subject: Address flakiness of doFinal and unwrap CipherTests

The tests occasionally did not throw BadPaddingException when
expected. This seems to be because in those cases the random generated
keys were creating cipher text that appeared to be correctly PKCS#5
padded. In reproducing this in the doFinal case, this happened within
a few hundred runs.

Bug: 6301793
Change-Id: Ibd2d9bdd2fe88bccb20089ef653763849f45ff4c
---
 expectations/knownfailures.txt                     |   5 -
 .../crypto/tests/javax/crypto/CipherTest.java      | 218 +++++++++++----------
 2 files changed, 113 insertions(+), 110 deletions(-)

diff --git a/expectations/knownfailures.txt b/expectations/knownfailures.txt
index ae650ea..fe110ea 100644
--- a/expectations/knownfailures.txt
+++ b/expectations/knownfailures.txt
@@ -54,11 +54,6 @@
   bug: 3473300
 },
 {
-  description: "CipherTest.test_doFinal() is flaky",
-  name: "org.apache.harmony.crypto.tests.javax.crypto.CipherTest#test_doFinal",
-  bug: 3469872
-},
-{
   name: "libcore.java.lang.StringTest#testCaseMapping_en_US",
   bug: 3387655
 },
diff --git a/luni/src/test/java/org/apache/harmony/crypto/tests/javax/crypto/CipherTest.java b/luni/src/test/java/org/apache/harmony/crypto/tests/javax/crypto/CipherTest.java
index 0507147..4096a30 100644
--- a/luni/src/test/java/org/apache/harmony/crypto/tests/javax/crypto/CipherTest.java
+++ b/luni/src/test/java/org/apache/harmony/crypto/tests/javax/crypto/CipherTest.java
@@ -19,10 +19,8 @@ package org.apache.harmony.crypto.tests.javax.crypto;
 
 import java.io.ByteArrayOutputStream;
 import java.io.File;
-import java.io.IOException;
 import java.io.InputStream;
 import java.math.BigInteger;
-import java.net.MalformedURLException;
 import java.net.URL;
 import java.nio.ByteBuffer;
 import java.nio.ReadOnlyBufferException;
@@ -36,7 +34,6 @@ import java.security.Provider;
 import java.security.SecureRandom;
 import java.security.Security;
 import java.security.cert.Certificate;
-import java.security.cert.CertificateException;
 import java.security.cert.CertificateFactory;
 import java.security.spec.AlgorithmParameterSpec;
 import java.security.spec.RSAKeyGenParameterSpec;
@@ -45,43 +42,45 @@ import javax.crypto.BadPaddingException;
 import javax.crypto.Cipher;
 import javax.crypto.CipherSpi;
 import javax.crypto.IllegalBlockSizeException;
-import javax.crypto.KeyGenerator;
-import javax.crypto.NoSuchPaddingException;
 import javax.crypto.SecretKeyFactory;
 import javax.crypto.ShortBufferException;
 import javax.crypto.spec.DESedeKeySpec;
 import javax.crypto.spec.IvParameterSpec;
+import javax.crypto.spec.SecretKeySpec;
 import org.apache.harmony.crypto.tests.support.MyCipher;
 import tests.support.resource.Support_Resources;
 
 public class CipherTest extends junit.framework.TestCase {
 
-    static Key cipherKey;
-    static final String algorithm = "DESede";
-    static final int keyLen = 168;
+    private static final Key CIPHER_KEY_3DES;
+    private static final String ALGORITHM_3DES = "DESede";
 
-    static Key cipherKeyDES;
-    static final String algorithmDES = "DES";
-    static final int keyLenDES = 56;
+    private static final Key CIPHER_KEY_DES;
+    private static final String ALGORITHM_DES = "DES";
 
     static {
         try {
-            KeyGenerator kg = KeyGenerator.getInstance(algorithm);
-            kg.init(keyLen, new SecureRandom());
-            cipherKey = kg.generateKey();
+            byte[] encoded_3des = {
+                (byte) -57,  (byte) -108, (byte) -42, (byte) 47,
+                (byte) 42,   (byte) -12,  (byte) -53, (byte) -83,
+                (byte) -123, (byte) 91,   (byte) -99, (byte) -101,
+                (byte) 93,   (byte) -62,  (byte) -42, (byte) -128,
+                (byte) -2,   (byte) 47,   (byte) -8,  (byte) 69,
+                (byte) -68,  (byte) 69,   (byte) 81,  (byte) 74,
+            };
+            CIPHER_KEY_3DES = new SecretKeySpec(encoded_3des, ALGORITHM_3DES);
+
+            byte[] encoded_des = {
+                (byte) 2,   (byte) 41,  (byte) -77, (byte) 107,
+                (byte) -99, (byte) -63, (byte) -42, (byte) -89,
+            };
+            CIPHER_KEY_DES = new SecretKeySpec(encoded_des, ALGORITHM_DES);
 
-            kg = KeyGenerator.getInstance(algorithmDES);
-            kg.init(keyLenDES, new SecureRandom());
-            cipherKeyDES = kg.generateKey();
         } catch (Exception e) {
-            fail("No key " + e);
+            throw new AssertionError(e);
         }
     }
 
-    @Override protected void setUp() throws Exception {
-        super.setUp();
-    }
-
     /**
      * javax.crypto.Cipher#getInstance(java.lang.String)
      */
@@ -205,7 +204,7 @@ public class CipherTest extends junit.framework.TestCase {
     public void test_getOutputSizeI() throws Exception {
 
         SecureRandom sr = new SecureRandom();
-        Cipher cipher = Cipher.getInstance(algorithm + "/ECB/PKCS5Padding");
+        Cipher cipher = Cipher.getInstance(ALGORITHM_3DES + "/ECB/PKCS5Padding");
 
         try {
             cipher.getOutputSize(25);
@@ -213,7 +212,7 @@ public class CipherTest extends junit.framework.TestCase {
         } catch (IllegalStateException expected) {
         }
 
-        cipher.init(Cipher.ENCRYPT_MODE, cipherKey, sr);
+        cipher.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_3DES, sr);
 
         // A 25-byte input could result in at least 4 8-byte blocks
         int result = cipher.getOutputSize(25);
@@ -228,13 +227,13 @@ public class CipherTest extends junit.framework.TestCase {
      * javax.crypto.Cipher#init(int, java.security.Key)
      */
     public void test_initWithKey() throws Exception {
-        Cipher cipher = Cipher.getInstance(algorithm + "/ECB/PKCS5Padding");
-        cipher.init(Cipher.ENCRYPT_MODE, cipherKey);
+        Cipher cipher = Cipher.getInstance(ALGORITHM_3DES + "/ECB/PKCS5Padding");
+        cipher.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_3DES);
 
 
         cipher = Cipher.getInstance("DES/CBC/NoPadding");
         try {
-            cipher.init(Cipher.ENCRYPT_MODE, cipherKey);
+            cipher.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_3DES);
             fail();
         } catch (InvalidKeyException expected) {
         }
@@ -246,12 +245,12 @@ public class CipherTest extends junit.framework.TestCase {
      */
     public void test_initWithSecureRandom() throws Exception {
         SecureRandom sr = new SecureRandom();
-        Cipher cipher = Cipher.getInstance(algorithm + "/ECB/PKCS5Padding");
-        cipher.init(Cipher.ENCRYPT_MODE, cipherKey, sr);
+        Cipher cipher = Cipher.getInstance(ALGORITHM_3DES + "/ECB/PKCS5Padding");
+        cipher.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_3DES, sr);
 
         cipher = Cipher.getInstance("DES/CBC/NoPadding");
         try {
-            cipher.init(Cipher.ENCRYPT_MODE, cipherKey, sr);
+            cipher.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_3DES, sr);
             fail();
         } catch (InvalidKeyException expected) {
         }
@@ -272,9 +271,9 @@ public class CipherTest extends junit.framework.TestCase {
         sr.nextBytes(iv);
         ap = new IvParameterSpec(iv);
 
-        cipher = Cipher.getInstance(algorithm + "/CBC/PKCS5Padding");
+        cipher = Cipher.getInstance(ALGORITHM_3DES + "/CBC/PKCS5Padding");
 
-        cipher.init(Cipher.ENCRYPT_MODE, cipherKey, ap);
+        cipher.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_3DES, ap);
 
         byte[] cipherIV = cipher.getIV();
 
@@ -282,7 +281,7 @@ public class CipherTest extends junit.framework.TestCase {
 
         cipher = Cipher.getInstance("DES/CBC/NoPadding");
         try {
-            cipher.init(Cipher.ENCRYPT_MODE, cipherKey, ap);
+            cipher.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_3DES, ap);
             fail();
         } catch (InvalidKeyException expected) {
         }
@@ -291,7 +290,7 @@ public class CipherTest extends junit.framework.TestCase {
         ap = new RSAKeyGenParameterSpec(10, new BigInteger("10"));
 
         try {
-            cipher.init(Cipher.ENCRYPT_MODE, cipherKeyDES, ap);
+            cipher.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES, ap);
             fail();
         } catch (InvalidAlgorithmParameterException expected) {
         }
@@ -313,16 +312,16 @@ public class CipherTest extends junit.framework.TestCase {
         sr.nextBytes(iv);
         ap = new IvParameterSpec(iv);
 
-        cipher = Cipher.getInstance(algorithm + "/CBC/PKCS5Padding");
+        cipher = Cipher.getInstance(ALGORITHM_3DES + "/CBC/PKCS5Padding");
 
-        cipher.init(Cipher.ENCRYPT_MODE, cipherKey, ap, sr);
+        cipher.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_3DES, ap, sr);
 
         byte[] cipherIV = cipher.getIV();
 
         assertTrue("IVs differ", Arrays.equals(cipherIV, iv));
         cipher = Cipher.getInstance("DES/CBC/NoPadding");
         try {
-            cipher.init(Cipher.ENCRYPT_MODE, cipherKey, ap, sr);
+            cipher.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_3DES, ap, sr);
             fail();
         } catch (InvalidKeyException expected) {
         }
@@ -331,7 +330,7 @@ public class CipherTest extends junit.framework.TestCase {
         ap = new RSAKeyGenParameterSpec(10, new BigInteger("10"));
 
         try {
-            cipher.init(Cipher.ENCRYPT_MODE, cipherKeyDES, ap, sr);
+            cipher.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES, ap, sr);
             fail();
         } catch (InvalidAlgorithmParameterException expected) {
         }
@@ -447,7 +446,7 @@ public class CipherTest extends junit.framework.TestCase {
         byte[] b1 = new byte[30];
 
         Cipher c = Cipher.getInstance("DES/CBC/NoPadding");
-        c.init(Cipher.ENCRYPT_MODE, cipherKeyDES);
+        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES);
         c.update(b, 0, 10, b1, 5);
         try {
             c.doFinal();
@@ -463,8 +462,9 @@ public class CipherTest extends junit.framework.TestCase {
         }
 
         c = Cipher.getInstance("DES/CBC/NoPadding");
-        c.init(Cipher.ENCRYPT_MODE, cipherKeyDES);
-        c.doFinal(b, 0, 16, b1, 0);
+        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES);
+        int len = c.doFinal(b, 0, 16, b1, 0);
+        assertEquals(16, len);
 
         SecureRandom sr = new SecureRandom();
         byte[] iv = new byte[8];
@@ -472,7 +472,7 @@ public class CipherTest extends junit.framework.TestCase {
         AlgorithmParameterSpec ap = new IvParameterSpec(iv);
 
         c = Cipher.getInstance("DES/CBC/PKCS5Padding");
-        c.init(Cipher.DECRYPT_MODE, cipherKeyDES, ap);
+        c.init(Cipher.DECRYPT_MODE, CIPHER_KEY_DES, ap);
 
         c.update(b1, 0, 24, b, 0);
         try {
@@ -516,7 +516,7 @@ public class CipherTest extends junit.framework.TestCase {
         } catch (IllegalStateException expected) {
         }
 
-        c.init(Cipher.ENCRYPT_MODE, cipherKey);
+        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_3DES);
         try {
             c.update(b, 0, 10, b1, 5);
             fail();
@@ -535,7 +535,7 @@ public class CipherTest extends junit.framework.TestCase {
         byte[] b1 = new byte[30];
 
         Cipher c = Cipher.getInstance("DES/CBC/NoPadding");
-        c.init(Cipher.ENCRYPT_MODE, cipherKeyDES);
+        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES);
         try {
             c.doFinal(b, 0, 10, b1, 5);
             fail();
@@ -550,8 +550,9 @@ public class CipherTest extends junit.framework.TestCase {
         }
 
         c = Cipher.getInstance("DES/CBC/NoPadding");
-        c.init(Cipher.ENCRYPT_MODE, cipherKeyDES);
-        c.doFinal(b, 0, 16, b1, 0);
+        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES);
+        int len = c.doFinal(b, 0, 16, b1, 0);
+        assertEquals(16, len);
 
         SecureRandom sr = new SecureRandom();
         byte[] iv = new byte[8];
@@ -559,7 +560,7 @@ public class CipherTest extends junit.framework.TestCase {
         AlgorithmParameterSpec ap = new IvParameterSpec(iv);
 
         c = Cipher.getInstance("DES/CBC/PKCS5Padding");
-        c.init(Cipher.DECRYPT_MODE, cipherKeyDES, ap);
+        c.init(Cipher.DECRYPT_MODE, CIPHER_KEY_DES, ap);
 
         try {
             c.doFinal(b1, 0, 24, new byte[42], 0);
@@ -569,7 +570,7 @@ public class CipherTest extends junit.framework.TestCase {
 
         b1 = new byte[6];
         c = Cipher.getInstance("DESede");
-        c.init(Cipher.ENCRYPT_MODE, cipherKey);
+        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_3DES);
         try {
             c.doFinal(b, 3, 6, b1, 5);
             fail();
@@ -651,7 +652,7 @@ public class CipherTest extends junit.framework.TestCase {
         ByteBuffer bOutput = ByteBuffer.allocate(64);
 
         Cipher c = Cipher.getInstance("DES/CBC/NoPadding");
-        c.init(Cipher.ENCRYPT_MODE, cipherKeyDES);
+        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES);
         bInput.put(b, 0, 10);
         try {
             c.doFinal(bInput, bOutput);
@@ -667,10 +668,11 @@ public class CipherTest extends junit.framework.TestCase {
         }
 
         c = Cipher.getInstance("DES/CBC/NoPadding");
-        c.init(Cipher.ENCRYPT_MODE, cipherKeyDES);
+        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES);
         bInput = ByteBuffer.allocate(16);
         bInput.put(b, 0, 16);
-        c.doFinal(bInput, bOutput);
+        int len = c.doFinal(bInput, bOutput);
+        assertEquals(0, len);
 
         SecureRandom sr = new SecureRandom();
         byte[] iv = new byte[8];
@@ -678,7 +680,7 @@ public class CipherTest extends junit.framework.TestCase {
         AlgorithmParameterSpec ap = new IvParameterSpec(iv);
 
         c = Cipher.getInstance("DES/CBC/PKCS5Padding");
-        c.init(Cipher.DECRYPT_MODE, cipherKeyDES, ap);
+        c.init(Cipher.DECRYPT_MODE, CIPHER_KEY_DES, ap);
         bInput = ByteBuffer.allocate(64);
 
         try {
@@ -688,7 +690,7 @@ public class CipherTest extends junit.framework.TestCase {
         }
 
         c = Cipher.getInstance("DES/CBC/NoPadding");
-        c.init(Cipher.ENCRYPT_MODE, cipherKeyDES);
+        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES);
         bInput.put(b, 0, 16);
         try {
             c.doFinal(bInput, bInput);
@@ -697,7 +699,7 @@ public class CipherTest extends junit.framework.TestCase {
         }
 
         c = Cipher.getInstance("DES/CBC/NoPadding");
-        c.init(Cipher.ENCRYPT_MODE, cipherKeyDES);
+        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES);
         bInput.put(b, 0, 16);
         try {
             c.doFinal(bInput, bOutput.asReadOnlyBuffer());
@@ -709,7 +711,7 @@ public class CipherTest extends junit.framework.TestCase {
         bInput.put(b, 0, 16);
         bOutput = ByteBuffer.allocate(8);
         c = Cipher.getInstance("DESede");
-        c.init(Cipher.ENCRYPT_MODE, cipherKey);
+        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_3DES);
         try {
             c.doFinal(bInput, bOutput);
             fail();
@@ -724,17 +726,17 @@ public class CipherTest extends junit.framework.TestCase {
         AlgorithmParameterSpec ap = new IvParameterSpec(iv);
 
         Cipher c = Cipher.getInstance("DES/CBC/PKCS5Padding");
-        c.init(Cipher.DECRYPT_MODE, cipherKeyDES, ap);
+        c.init(Cipher.DECRYPT_MODE, CIPHER_KEY_DES, ap);
         assertNotNull(c.getParameters());
 
         try {
-            c.init(Cipher.DECRYPT_MODE, cipherKey, ap);
+            c.init(Cipher.DECRYPT_MODE, CIPHER_KEY_3DES, ap);
             fail();
         } catch (InvalidKeyException expected) {
         }
 
         try {
-            c.init(Cipher.DECRYPT_MODE, cipherKeyDES, (AlgorithmParameters)null);
+            c.init(Cipher.DECRYPT_MODE, CIPHER_KEY_DES, (AlgorithmParameters)null);
             fail();
         } catch (InvalidAlgorithmParameterException expected) {
         }
@@ -747,22 +749,22 @@ public class CipherTest extends junit.framework.TestCase {
         AlgorithmParameterSpec ap = new IvParameterSpec(iv);
 
         Cipher c = Cipher.getInstance("DES/CBC/PKCS5Padding");
-        c.init(Cipher.DECRYPT_MODE, cipherKeyDES, ap, sr);
+        c.init(Cipher.DECRYPT_MODE, CIPHER_KEY_DES, ap, sr);
         assertNotNull(c.getParameters());
 
         try {
-            c.init(Cipher.DECRYPT_MODE, cipherKey, ap, new SecureRandom());
+            c.init(Cipher.DECRYPT_MODE, CIPHER_KEY_3DES, ap, new SecureRandom());
             fail();
         } catch (InvalidKeyException expected) {
         }
 
         try {
-            c.init(Cipher.DECRYPT_MODE, cipherKeyDES, (AlgorithmParameters)null, sr);
+            c.init(Cipher.DECRYPT_MODE, CIPHER_KEY_DES, (AlgorithmParameters)null, sr);
             fail();
         } catch (InvalidAlgorithmParameterException expected) {
         }
 
-        c.init(Cipher.DECRYPT_MODE, cipherKeyDES, ap, (SecureRandom)null);
+        c.init(Cipher.DECRYPT_MODE, CIPHER_KEY_DES, ap, (SecureRandom)null);
         assertNotNull(c.getParameters());
     }
 
@@ -834,9 +836,9 @@ public class CipherTest extends junit.framework.TestCase {
 
         Cipher c = Cipher.getInstance("DES/CBC/PKCS5Padding");
 
-        c.init(Cipher.WRAP_MODE, cipherKeyDES, ap, sr);
-        byte[] arDES = c.wrap(cipherKeyDES);
-        byte[] ar    = c.wrap(cipherKey);
+        c.init(Cipher.WRAP_MODE, CIPHER_KEY_DES, ap, sr);
+        byte[] arDES = c.wrap(CIPHER_KEY_DES);
+        byte[] ar    = c.wrap(CIPHER_KEY_3DES);
 
         try {
             c.unwrap(arDES, "DES", Cipher.SECRET_KEY);
@@ -844,9 +846,9 @@ public class CipherTest extends junit.framework.TestCase {
         } catch (IllegalStateException expected) {
         }
 
-        c.init(Cipher.UNWRAP_MODE, cipherKeyDES, ap, sr);
-        assertTrue(cipherKeyDES.equals(c.unwrap(arDES, "DES", Cipher.SECRET_KEY)));
-        assertFalse(cipherKeyDES.equals(c.unwrap(ar, "DES", Cipher.SECRET_KEY)));
+        c.init(Cipher.UNWRAP_MODE, CIPHER_KEY_DES, ap, sr);
+        assertTrue(CIPHER_KEY_DES.equals(c.unwrap(arDES, "DES", Cipher.SECRET_KEY)));
+        assertFalse(CIPHER_KEY_DES.equals(c.unwrap(ar, "DES", Cipher.SECRET_KEY)));
 
         try {
             c.unwrap(arDES, "RSA38", Cipher.PUBLIC_KEY);
@@ -855,7 +857,7 @@ public class CipherTest extends junit.framework.TestCase {
         }
 
         c = Cipher.getInstance("DESede/CBC/PKCS5Padding");
-        c.init(Cipher.UNWRAP_MODE, cipherKey, ap, sr);
+        c.init(Cipher.UNWRAP_MODE, CIPHER_KEY_3DES, ap, sr);
         try {
             c.unwrap(arDES, "DESede", Cipher.SECRET_KEY);
             fail();
@@ -869,7 +871,7 @@ public class CipherTest extends junit.framework.TestCase {
         ByteBuffer bOutput = ByteBuffer.allocate(256);
 
         Cipher c = Cipher.getInstance("DES/CBC/NoPadding");
-        c.init(Cipher.ENCRYPT_MODE, cipherKeyDES);
+        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES);
         bInput.put(b, 0, 10);
         bInput.rewind();
         bOutput.rewind();
@@ -883,7 +885,7 @@ public class CipherTest extends junit.framework.TestCase {
         }
 
         c = Cipher.getInstance("DES/CBC/NoPadding");
-        c.init(Cipher.ENCRYPT_MODE, cipherKeyDES);
+        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES);
         bInput = ByteBuffer.allocate(16);
         bInput.put(b, 0, 16);
         bInput.rewind();
@@ -896,11 +898,11 @@ public class CipherTest extends junit.framework.TestCase {
         AlgorithmParameterSpec ap = new IvParameterSpec(iv);
 
         c = Cipher.getInstance("DES/CBC/PKCS5Padding");
-        c.init(Cipher.DECRYPT_MODE, cipherKeyDES, ap);
+        c.init(Cipher.DECRYPT_MODE, CIPHER_KEY_DES, ap);
         bInput = ByteBuffer.allocate(64);
 
         c = Cipher.getInstance("DES/CBC/NoPadding");
-        c.init(Cipher.ENCRYPT_MODE, cipherKeyDES);
+        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES);
         bInput.put(b, 0, 16);
         bInput.rewind();
         try {
@@ -910,7 +912,7 @@ public class CipherTest extends junit.framework.TestCase {
         }
 
         c = Cipher.getInstance("DES/CBC/NoPadding");
-        c.init(Cipher.ENCRYPT_MODE, cipherKeyDES);
+        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES);
         bInput.put(b, 0, 16);
         bInput.rewind();
         bOutput.rewind();
@@ -925,7 +927,7 @@ public class CipherTest extends junit.framework.TestCase {
         bInput.rewind();
         bOutput = ByteBuffer.allocate(8);
         c = Cipher.getInstance("DESede");
-        c.init(Cipher.ENCRYPT_MODE, cipherKey);
+        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_3DES);
         try {
             c.update(bInput, bOutput);
             fail();
@@ -956,9 +958,9 @@ public class CipherTest extends junit.framework.TestCase {
 
         Cipher c = Cipher.getInstance("DES/CBC/PKCS5Padding");
 
-        c.init(Cipher.WRAP_MODE, cipherKeyDES, ap, sr);
-        assertNotNull(c.wrap(cipherKeyDES));
-        assertNotNull(c.wrap(cipherKey));
+        c.init(Cipher.WRAP_MODE, CIPHER_KEY_DES, ap, sr);
+        assertNotNull(c.wrap(CIPHER_KEY_DES));
+        assertNotNull(c.wrap(CIPHER_KEY_3DES));
         String certName = Support_Resources.getURL("test.cert");
         InputStream is = new URL(certName).openConnection().getInputStream();
         CertificateFactory cf = CertificateFactory.getInstance("X.509");
@@ -967,22 +969,22 @@ public class CipherTest extends junit.framework.TestCase {
         assertNotNull(c.wrap(cert.getPublicKey()));
 
         c = Cipher.getInstance("DES/CBC/NoPadding");
-        c.init(Cipher.WRAP_MODE, cipherKeyDES, ap, sr);
+        c.init(Cipher.WRAP_MODE, CIPHER_KEY_DES, ap, sr);
         try {
             assertNotNull(c.wrap(cert.getPublicKey()));
             fail();
         } catch (IllegalBlockSizeException expected) {
         }
 
-        c.init(Cipher.DECRYPT_MODE, cipherKeyDES, ap, sr);
+        c.init(Cipher.DECRYPT_MODE, CIPHER_KEY_DES, ap, sr);
 
         try {
-            c.wrap(cipherKeyDES);
+            c.wrap(CIPHER_KEY_DES);
             fail();
         } catch (IllegalStateException expected) {
         }
 
-        c.init(Cipher.WRAP_MODE, cipherKeyDES, ap, sr);
+        c.init(Cipher.WRAP_MODE, CIPHER_KEY_DES, ap, sr);
         try {
             c.wrap(new Mock_Key());
             fail();
@@ -995,7 +997,7 @@ public class CipherTest extends junit.framework.TestCase {
         byte[] b1 = new byte[30];
 
         Cipher c = Cipher.getInstance("DES/CBC/NoPadding");
-        c.init(Cipher.ENCRYPT_MODE, cipherKeyDES);
+        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES);
         c.update(b, 0, 10);
         try {
             c.doFinal(b1, 5);
@@ -1011,9 +1013,10 @@ public class CipherTest extends junit.framework.TestCase {
         }
 
         c = Cipher.getInstance("DES/CBC/NoPadding");
-        c.init(Cipher.ENCRYPT_MODE, cipherKeyDES);
+        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES);
         c.update(b, 3, 8);
-        c.doFinal(b1, 0);
+        int len = c.doFinal(b1, 0);
+        assertEquals(0, len);
 
         SecureRandom sr = new SecureRandom();
         byte[] iv = new byte[8];
@@ -1021,7 +1024,7 @@ public class CipherTest extends junit.framework.TestCase {
         AlgorithmParameterSpec ap = new IvParameterSpec(iv);
 
         c = Cipher.getInstance("DES/CBC/PKCS5Padding");
-        c.init(Cipher.DECRYPT_MODE, cipherKeyDES, ap);
+        c.init(Cipher.DECRYPT_MODE, CIPHER_KEY_DES, ap);
 
         c.update(b1, 0, 24);
         try {
@@ -1032,7 +1035,7 @@ public class CipherTest extends junit.framework.TestCase {
 
         b1 = new byte[6];
         c = Cipher.getInstance("DESede");
-        c.init(Cipher.ENCRYPT_MODE, cipherKey);
+        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_3DES);
         c.update(b, 3, 6);
         try {
             c.doFinal(b1, 5);
@@ -1049,7 +1052,7 @@ public class CipherTest extends junit.framework.TestCase {
         byte[] bI4 = {1,2,3};
 
         Cipher c = Cipher.getInstance("DES/CBC/NoPadding");
-        c.init(Cipher.ENCRYPT_MODE, cipherKeyDES);
+        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES);
         try {
             c.doFinal(bI1);
             fail();
@@ -1064,10 +1067,12 @@ public class CipherTest extends junit.framework.TestCase {
         }
 
         c = Cipher.getInstance("DES/CBC/NoPadding");
-        c.init(Cipher.ENCRYPT_MODE, cipherKeyDES);
-        c.doFinal(bI2);
-        c.init(Cipher.ENCRYPT_MODE, cipherKeyDES);
-        c.doFinal(bI3, 0, 16, b1, 0);
+        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES);
+        int len1 = c.doFinal(bI2).length;
+        assertEquals(16, len1);
+        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES);
+        int len2 = c.doFinal(bI3, 0, 16, b1, 0);
+        assertEquals(16, len2);
 
         SecureRandom sr = new SecureRandom();
         byte[] iv = new byte[8];
@@ -1075,7 +1080,7 @@ public class CipherTest extends junit.framework.TestCase {
         AlgorithmParameterSpec ap = new IvParameterSpec(iv);
 
         c = Cipher.getInstance("DES/CBC/PKCS5Padding");
-        c.init(Cipher.DECRYPT_MODE, cipherKeyDES, ap);
+        c.init(Cipher.DECRYPT_MODE, CIPHER_KEY_DES, ap);
 
         try {
             c.doFinal(b1);
@@ -1089,7 +1094,7 @@ public class CipherTest extends junit.framework.TestCase {
         byte[] b1 = new byte[30];
 
         Cipher c = Cipher.getInstance("DES/CBC/NoPadding");
-        c.init(Cipher.ENCRYPT_MODE, cipherKeyDES);
+        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES);
         try {
             c.doFinal(b, 0, 10);
             fail();
@@ -1104,10 +1109,12 @@ public class CipherTest extends junit.framework.TestCase {
         }
 
         c = Cipher.getInstance("DES/CBC/NoPadding");
-        c.init(Cipher.ENCRYPT_MODE, cipherKeyDES);
-        c.doFinal(b, 0, 16);
-        c.init(Cipher.ENCRYPT_MODE, cipherKeyDES);
-        c.doFinal(b, 0, 16, b1, 0);
+        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES);
+        int len1 = c.doFinal(b, 0, 16).length;
+        assertEquals(16, len1);
+        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES);
+        int len2 = c.doFinal(b, 0, 16, b1, 0);
+        assertEquals(16, len2);
 
         SecureRandom sr = new SecureRandom();
         byte[] iv = new byte[8];
@@ -1115,7 +1122,7 @@ public class CipherTest extends junit.framework.TestCase {
         AlgorithmParameterSpec ap = new IvParameterSpec(iv);
 
         c = Cipher.getInstance("DES/CBC/PKCS5Padding");
-        c.init(Cipher.DECRYPT_MODE, cipherKeyDES, ap);
+        c.init(Cipher.DECRYPT_MODE, CIPHER_KEY_DES, ap);
 
         try {
             c.doFinal(b1, 0, 24);
@@ -1129,7 +1136,7 @@ public class CipherTest extends junit.framework.TestCase {
         byte[] b1 = new byte[30];
 
         Cipher c = Cipher.getInstance("DES/CBC/NoPadding");
-        c.init(Cipher.ENCRYPT_MODE, cipherKeyDES);
+        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES);
         try {
             c.doFinal(b, 0, 10, b1);
             fail();
@@ -1144,8 +1151,9 @@ public class CipherTest extends junit.framework.TestCase {
         }
 
         c = Cipher.getInstance("DES/CBC/NoPadding");
-        c.init(Cipher.ENCRYPT_MODE, cipherKeyDES);
-        c.doFinal(b, 0, 16, b1);
+        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES);
+        int len = c.doFinal(b, 0, 16, b1);
+        assertEquals(16, len);
 
         SecureRandom sr = new SecureRandom();
         byte[] iv = new byte[8];
@@ -1153,7 +1161,7 @@ public class CipherTest extends junit.framework.TestCase {
         AlgorithmParameterSpec ap = new IvParameterSpec(iv);
 
         c = Cipher.getInstance("DES/CBC/PKCS5Padding");
-        c.init(Cipher.DECRYPT_MODE, cipherKeyDES, ap);
+        c.init(Cipher.DECRYPT_MODE, CIPHER_KEY_DES, ap);
 
         try {
             c.doFinal(b1, 0, 24, new byte[42]);
@@ -1163,7 +1171,7 @@ public class CipherTest extends junit.framework.TestCase {
 
         b1 = new byte[6];
         c = Cipher.getInstance("DESede");
-        c.init(Cipher.ENCRYPT_MODE, cipherKey);
+        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_3DES);
         try {
             c.doFinal(b, 3, 6, b1);
             fail();
@@ -1193,7 +1201,7 @@ public class CipherTest extends junit.framework.TestCase {
         }
 
         c = Cipher.getInstance("DES/CBC/NoPadding");
-        c.init(Cipher.ENCRYPT_MODE, cipherKeyDES);
+        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES);
         c.update(b, 0, 16, b1);
 
         b1 = new byte[3];
-- 
cgit v1.1


From b7705a4629bb74a5bb19d97bf0b4dd4c74cecd9e Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Thu, 19 Jul 2012 17:07:26 -0700
Subject: TLS + SNI + proxy => bug : the SNI at the TLS layer is the hostname
 of the proxy instead of the hostname in the URL

Bug: http://code.google.com/p/android/issues/detail?id=35050

Change-Id: Ia12f54e0521cf98eac184d80744192c1f782e7c2
---
 luni/src/main/java/libcore/net/http/HttpConnection.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/luni/src/main/java/libcore/net/http/HttpConnection.java b/luni/src/main/java/libcore/net/http/HttpConnection.java
index 66dec4d..2f92706 100644
--- a/luni/src/main/java/libcore/net/http/HttpConnection.java
+++ b/luni/src/main/java/libcore/net/http/HttpConnection.java
@@ -201,7 +201,7 @@ final class HttpConnection {
             OpenSSLSocketImpl openSslSocket = (OpenSSLSocketImpl) unverifiedSocket;
             openSslSocket.setEnabledCompressionMethods(new String[] { "ZLIB"});
             openSslSocket.setUseSessionTickets(true);
-            openSslSocket.setHostname(address.socketHost);
+            openSslSocket.setHostname(address.uriHost);
             // use SSLSocketFactory default enabled protocols
         } else {
             unverifiedSocket.setEnabledProtocols(new String [] { "SSLv3" });
-- 
cgit v1.1


From 514d3165e7a487224c1a20f1a55e8011eaf3e037 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Thu, 19 Jul 2012 18:20:19 -0700
Subject: Second chunk of Support_PortManager removal.

Bug: 2441548
Change-Id: Id5fb5785259700db637c17522c105e6b0bb6b89f
---
 .../api/javax/net/ServerSocketFactoryTest.java     | 139 +++----------
 .../tests/api/javax/net/SocketFactoryTest.java     | 230 ++++++---------------
 2 files changed, 97 insertions(+), 272 deletions(-)

diff --git a/luni/src/test/java/tests/api/javax/net/ServerSocketFactoryTest.java b/luni/src/test/java/tests/api/javax/net/ServerSocketFactoryTest.java
index 053200f..34d7aed 100644
--- a/luni/src/test/java/tests/api/javax/net/ServerSocketFactoryTest.java
+++ b/luni/src/test/java/tests/api/javax/net/ServerSocketFactoryTest.java
@@ -30,158 +30,77 @@ import javax.net.ServerSocketFactory;
 
 import junit.framework.TestCase;
 
-import tests.support.Support_PortManager;
-
-
-/**
- * Tests for <code>ServerSocketFactory</code> class constructors and methods.
- */
 public class ServerSocketFactoryTest extends TestCase {
 
-    /**
-     * javax.net.SocketFactory#SocketFactory()
-     */
     public void test_Constructor() {
-        try {
-            ServerSocketFactory sf = new MyServerSocketFactory();
-        } catch (Exception e) {
-            fail("Unexpected exception " + e.toString());
-        }
+        ServerSocketFactory sf = new MyServerSocketFactory();
     }
 
-    /**
-     * javax.net.ServerSocketFactory#createServerSocket()
-     */
-    public final void test_createServerSocket_01() {
+    public final void test_createServerSocket() throws Exception {
         ServerSocketFactory sf = ServerSocketFactory.getDefault();
-        try {
-            ServerSocket ss = sf.createServerSocket();
-            assertNotNull(ss);
-        } catch (SocketException e) {
-        } catch (Exception e) {
-            fail(e.toString());
-        }
+        ServerSocket ss = sf.createServerSocket();
+        assertNotNull(ss);
+        ss.close();
     }
 
-    /**
-     * javax.net.ServerSocketFactory#createServerSocket(int port)
-     */
-    public final void test_createServerSocket_02() {
+    public final void test_createServerSocket_I() throws Exception {
         ServerSocketFactory sf = ServerSocketFactory.getDefault();
-        int portNumber = Support_PortManager.getNextPort();
-
-        try {
-            ServerSocket ss = sf.createServerSocket(portNumber);
-            assertNotNull(ss);
-        } catch (Exception ex) {
-            fail("Unexpected exception: " + ex);
-        }
+        ServerSocket ss = sf.createServerSocket(0);
+        assertNotNull(ss);
 
         try {
-            sf.createServerSocket(portNumber);
+            sf.createServerSocket(ss.getLocalPort());
             fail("IOException wasn't thrown");
-        } catch (IOException ioe) {
-            //expected
-        } catch (Exception ex) {
-            fail(ex + " was thrown instead of IOException");
+        } catch (IOException expected) {
         }
 
+        ss.close();
+
         try {
             sf.createServerSocket(-1);
             fail("IllegalArgumentException wasn't thrown");
-        } catch (IllegalArgumentException ioe) {
-            //expected
-        } catch (Exception ex) {
-            fail(ex + " was thrown instead of IllegalArgumentException");
+        } catch (IllegalArgumentException expected) {
         }
     }
 
-    /**
-     * javax.net.ServerSocketFactory#createServerSocket(int port, int backlog)
-     */
-    public final void test_createServerSocket_03() {
+    public final void test_createServerSocket_II() throws Exception {
         ServerSocketFactory sf = ServerSocketFactory.getDefault();
-        int portNumber = Support_PortManager.getNextPort();
-
-        try {
-            ServerSocket ss = sf.createServerSocket(portNumber, 0);
-            assertNotNull(ss);
-        } catch (Exception ex) {
-            fail("Unexpected exception: " + ex);
-        }
+        ServerSocket ss = sf.createServerSocket(0, 0);
+        assertNotNull(ss);
 
         try {
-            sf.createServerSocket(portNumber, 0);
+            sf.createServerSocket(ss.getLocalPort(), 0);
             fail("IOException wasn't thrown");
-        } catch (IOException ioe) {
-            //expected
-        } catch (Exception ex) {
-            fail(ex + " was thrown instead of IOException");
+        } catch (IOException expected) {
         }
 
+        ss.close();
+
         try {
             sf.createServerSocket(65536, 0);
             fail("IllegalArgumentException wasn't thrown");
-        } catch (IllegalArgumentException ioe) {
-            //expected
-        } catch (Exception ex) {
-            fail(ex + " was thrown instead of IllegalArgumentException");
+        } catch (IllegalArgumentException expected) {
         }
     }
 
-    /**
-     * javax.net.ServerSocketFactory#createServerSocket(int port, int backlog, InetAddress ifAddress)
-     */
-    public final void test_createServerSocket_04() {
+    public final void test_createServerSocket_IIInetAddress() throws Exception {
         ServerSocketFactory sf = ServerSocketFactory.getDefault();
-        int portNumber = Support_PortManager.getNextPort();
 
-        try {
-            ServerSocket ss = sf.createServerSocket(portNumber, 0, InetAddress.getLocalHost());
-            assertNotNull(ss);
-        } catch (Exception ex) {
-            fail("Unexpected exception: " + ex);
-        }
+        ServerSocket ss = sf.createServerSocket(0, 0, InetAddress.getLocalHost());
+        assertNotNull(ss);
 
         try {
-            sf.createServerSocket(portNumber, 0, InetAddress.getLocalHost());
+            sf.createServerSocket(ss.getLocalPort(), 0, InetAddress.getLocalHost());
             fail("IOException wasn't thrown");
-        } catch (IOException ioe) {
-            //expected
-        } catch (Exception ex) {
-            fail(ex + " was thrown instead of IOException");
+        } catch (IOException expected) {
         }
 
+        ss.close();
+
         try {
             sf.createServerSocket(Integer.MAX_VALUE, 0, InetAddress.getLocalHost());
             fail("IllegalArgumentException wasn't thrown");
-        } catch (IllegalArgumentException ioe) {
-            //expected
-        } catch (Exception ex) {
-            fail(ex + " was thrown instead of IllegalArgumentException");
-        }
-    }
-
-    /**
-     * javax.net.ServerSocketFactory#getDefault()
-     */
-    public final void test_getDefault() {
-        ServerSocketFactory sf = ServerSocketFactory.getDefault();
-        ServerSocket s;
-        try {
-            s = sf.createServerSocket(0);
-            s.close();
-        } catch (IOException e) {
-        }
-        try {
-            s = sf.createServerSocket(0, 50);
-            s.close();
-        } catch (IOException e) {
-        }
-        try {
-            s = sf.createServerSocket(0, 50, InetAddress.getLocalHost());
-            s.close();
-        } catch (IOException e) {
+        } catch (IllegalArgumentException expected) {
         }
     }
 }
diff --git a/luni/src/test/java/tests/api/javax/net/SocketFactoryTest.java b/luni/src/test/java/tests/api/javax/net/SocketFactoryTest.java
index 2250602..e939a9b 100644
--- a/luni/src/test/java/tests/api/javax/net/SocketFactoryTest.java
+++ b/luni/src/test/java/tests/api/javax/net/SocketFactoryTest.java
@@ -33,200 +33,135 @@ import javax.net.SocketFactory;
 
 import junit.framework.TestCase;
 
-import tests.support.Support_PortManager;
-
-
-/**
- * Tests for <code>SocketFactory</code> class methods.
- */
 public class SocketFactoryTest extends TestCase {
 
-    /**
-     * javax.net.SocketFactory#SocketFactory()
-     */
-    public void test_Constructor() {
-        try {
-            MySocketFactory sf = new MySocketFactory();
-        } catch (Exception e) {
-            fail("Unexpected exception " + e.toString());
-        }
+    public void test_Constructor() throws Exception {
+        new MySocketFactory();
     }
 
-    /**
-     * javax.net.SocketFactory#createSocket()
-     */
-    public final void test_createSocket_01() {
+    public final void test_createSocket() throws Exception {
         SocketFactory sf = SocketFactory.getDefault();
 
-        try {
-            Socket s = sf.createSocket();
-            assertNotNull(s);
-            assertEquals(-1, s.getLocalPort());
-            assertEquals(0, s.getPort());
-        } catch (Exception e) {
-            fail("Unexpected exception: " + e);
-        }
+        Socket s = sf.createSocket();
+        assertNotNull(s);
+        assertEquals(-1, s.getLocalPort());
+        assertEquals(0, s.getPort());
 
         MySocketFactory msf = new MySocketFactory();
         try {
             msf.createSocket();
             fail("No expected SocketException");
-        } catch (SocketException e) {
-        } catch (IOException e) {
-            fail(e.toString());
+        } catch (SocketException expected) {
         }
     }
 
-    /**
-     * javax.net.SocketFactory#createSocket(String host, int port)
-     */
-    public final void test_createSocket_02() {
+    public final void test_createSocket_StringI() throws Exception {
         SocketFactory sf = SocketFactory.getDefault();
-        int portNumber = Support_PortManager.getNextPort();
-        int sport = startServer("Cons String,I");
+        int sport = new ServerSocket(0).getLocalPort();
         int[] invalidPorts = {Integer.MIN_VALUE, -1, 65536, Integer.MAX_VALUE};
 
-        try {
-            Socket s = sf.createSocket(InetAddress.getLocalHost().getHostName(), sport);
-            assertNotNull(s);
-            assertTrue("Failed to create socket", s.getPort() == sport);
-        } catch (Exception e) {
-            fail("Unexpected exception: " + e);
-        }
+        Socket s = sf.createSocket(InetAddress.getLocalHost().getHostName(), sport);
+        assertNotNull(s);
+        assertTrue("Failed to create socket", s.getPort() == sport);
 
         try {
-            Socket s = sf.createSocket("bla-bla", sport);
+            sf.createSocket("bla-bla", sport);
             fail("UnknownHostException wasn't thrown");
-        } catch (UnknownHostException uhe) {
-            //expected
-        } catch (Exception e) {
-            fail(e + " was thrown instead of UnknownHostException");
+        } catch (UnknownHostException expected) {
         }
 
         for (int i = 0; i < invalidPorts.length; i++) {
             try {
-                Socket s = sf.createSocket(InetAddress.getLocalHost().getHostName(), invalidPorts[i]);
+                sf.createSocket(InetAddress.getLocalHost().getHostName(), invalidPorts[i]);
                 fail("IllegalArgumentException wasn't thrown for " + invalidPorts[i]);
-            } catch (IllegalArgumentException iae) {
-                //expected
-            } catch (Exception e) {
-                fail(e + " was thrown instead of IllegalArgumentException for " + invalidPorts[i]);
+            } catch (IllegalArgumentException expected) {
             }
         }
 
         try {
-            Socket s = sf.createSocket(InetAddress.getLocalHost().getHostName(), portNumber);
+            sf.createSocket(InetAddress.getLocalHost().getHostName(), s.getLocalPort());
             fail("IOException wasn't thrown");
-        } catch (IOException ioe) {
-            //expected
+        } catch (IOException expected) {
         }
 
         SocketFactory f = SocketFactory.getDefault();
         try {
-            Socket s = f.createSocket("localhost", 8082);
+            f.createSocket(InetAddress.getLocalHost().getHostName(), 8082);
             fail("IOException wasn't thrown ...");
-        } catch (IOException e) {
+        } catch (IOException expected) {
         }
     }
 
-    /**
-     * javax.net.SocketFactory#createSocket(InetAddress host, int port)
-     */
-    public final void test_createSocket_03() {
+    public final void test_createSocket_InetAddressI() throws Exception {
         SocketFactory sf = SocketFactory.getDefault();
-        int portNumber = Support_PortManager.getNextPort();
-        int sport = startServer("Cons InetAddress,I");
+        int sport = new ServerSocket(0).getLocalPort();
         int[] invalidPorts = {Integer.MIN_VALUE, -1, 65536, Integer.MAX_VALUE};
 
-        try {
-            Socket s = sf.createSocket(InetAddress.getLocalHost(), sport);
-            assertNotNull(s);
-            assertTrue("Failed to create socket", s.getPort() == sport);
-        } catch (Exception e) {
-            fail("Unexpected exception: " + e);
-        }
+        Socket s = sf.createSocket(InetAddress.getLocalHost(), sport);
+        assertNotNull(s);
+        assertTrue("Failed to create socket", s.getPort() == sport);
 
         for (int i = 0; i < invalidPorts.length; i++) {
             try {
-                Socket s = sf.createSocket(InetAddress.getLocalHost(), invalidPorts[i]);
+                sf.createSocket(InetAddress.getLocalHost(), invalidPorts[i]);
                 fail("IllegalArgumentException wasn't thrown for " + invalidPorts[i]);
-            } catch (IllegalArgumentException iae) {
-                //expected
-            } catch (Exception e) {
-                fail(e + " was thrown instead of IllegalArgumentException for " + invalidPorts[i]);
+            } catch (IllegalArgumentException expected) {
             }
         }
 
         try {
-            Socket s = sf.createSocket(InetAddress.getLocalHost(), portNumber);
+            sf.createSocket(InetAddress.getLocalHost(), s.getLocalPort());
             fail("IOException wasn't thrown");
-        } catch (IOException ioe) {
-            //expected
+        } catch (IOException expected) {
         }
 
         SocketFactory f = SocketFactory.getDefault();
         try {
-            Socket s = f.createSocket(InetAddress.getLocalHost(), 8081);
+            f.createSocket(InetAddress.getLocalHost(), 8081);
             fail("IOException wasn't thrown ...");
-        } catch (IOException e) {
+        } catch (IOException expected) {
         }
     }
 
-    /**
-     * javax.net.SocketFactory#createSocket(InetAddress address, int port,
-     *                                             InetAddress localAddress, int localPort)
-     */
-    public final void test_createSocket_04() {
+    public final void test_createSocket_InetAddressIInetAddressI() throws Exception {
         SocketFactory sf = SocketFactory.getDefault();
-        int portNumber = Support_PortManager.getNextPort();
-        int sport = startServer("Cons InetAddress,I,InetAddress,I");
+        int sport = new ServerSocket(0).getLocalPort();
         int[] invalidPorts = {Integer.MIN_VALUE, -1, 65536, Integer.MAX_VALUE};
 
-        try {
-            Socket s = sf.createSocket(InetAddress.getLocalHost(), sport,
-                                       InetAddress.getLocalHost(), portNumber);
-            assertNotNull(s);
-            assertTrue("1: Failed to create socket", s.getPort() == sport);
-            assertTrue("2: Failed to create socket", s.getLocalPort() == portNumber);
-        } catch (Exception e) {
-            fail("Unexpected exception: " + e);
-        }
+        Socket s = sf.createSocket(InetAddress.getLocalHost(), sport,
+                                   InetAddress.getLocalHost(), 0);
+        assertNotNull(s);
+        assertTrue("1: Failed to create socket", s.getPort() == sport);
+        int portNumber = s.getLocalPort();
 
         for (int i = 0; i < invalidPorts.length; i++) {
             try {
-                Socket s = sf.createSocket(InetAddress.getLocalHost(), invalidPorts[i],
-                                           InetAddress.getLocalHost(), portNumber);
+              sf.createSocket(InetAddress.getLocalHost(), invalidPorts[i],
+                              InetAddress.getLocalHost(), portNumber);
                 fail("IllegalArgumentException wasn't thrown for " + invalidPorts[i]);
-            } catch (IllegalArgumentException iae) {
-                //expected
-            } catch (Exception e) {
-                fail(e + " was thrown instead of IllegalArgumentException for " + invalidPorts[i]);
+            } catch (IllegalArgumentException expected) {
             }
 
             try {
-                Socket s = sf.createSocket(InetAddress.getLocalHost(), sport,
-                                           InetAddress.getLocalHost(), invalidPorts[i]);
+                sf.createSocket(InetAddress.getLocalHost(), sport,
+                                InetAddress.getLocalHost(), invalidPorts[i]);
                 fail("IllegalArgumentException wasn't thrown for " + invalidPorts[i]);
-            } catch (IllegalArgumentException iae) {
-                //expected
-            } catch (Exception e) {
-                fail(e + " was thrown instead of IllegalArgumentException for " + invalidPorts[i]);
+            } catch (IllegalArgumentException expected) {
             }
         }
 
         try {
-            Socket s = sf.createSocket(InetAddress.getLocalHost(), sport,
-                                       InetAddress.getLocalHost(), portNumber);
+            sf.createSocket(InetAddress.getLocalHost(), sport,
+                            InetAddress.getLocalHost(), portNumber);
             fail("IOException wasn't thrown");
-        } catch (IOException ioe) {
-            //expected
+        } catch (IOException expected) {
         }
 
         SocketFactory f = SocketFactory.getDefault();
         try {
-            Socket s = f.createSocket(InetAddress.getLocalHost(), 8081, InetAddress.getLocalHost(), 8082);
+            f.createSocket(InetAddress.getLocalHost(), 8081, InetAddress.getLocalHost(), 8082);
             fail("IOException wasn't thrown ...");
-        } catch (IOException e) {
+        } catch (IOException expected) {
         }
     }
 
@@ -234,59 +169,41 @@ public class SocketFactoryTest extends TestCase {
      * javax.net.SocketFactory#createSocket(String host, int port,
      *                                             InetAddress localHost, int localPort)
      */
-    public final void test_createSocket_05() {
+    public final void test_createSocket_05() throws Exception {
         SocketFactory sf = SocketFactory.getDefault();
-        int portNumber = Support_PortManager.getNextPort();
-        int sport = startServer("Cons String,I,InetAddress,I");
+        int sport = new ServerSocket(0).getLocalPort();
         int[] invalidPorts = {Integer.MIN_VALUE, -1, 65536, Integer.MAX_VALUE};
 
-        try {
-            Socket s = sf.createSocket(InetAddress.getLocalHost().getHostName(), sport,
-                                       InetAddress.getLocalHost(), portNumber);
-            assertNotNull(s);
-            assertTrue("1: Failed to create socket", s.getPort() == sport);
-            assertTrue("2: Failed to create socket", s.getLocalPort() == portNumber);
-        } catch (Exception e) {
-            fail("Unexpected exception: " + e);
-        }
+        Socket s = sf.createSocket(InetAddress.getLocalHost().getHostName(), sport,
+                                   InetAddress.getLocalHost(), 0);
+        assertNotNull(s);
+        assertTrue("1: Failed to create socket", s.getPort() == sport);
 
-        portNumber = Support_PortManager.getNextPort();
         try {
-            Socket s = sf.createSocket("bla-bla", sport, InetAddress.getLocalHost(), portNumber);
+            sf.createSocket("bla-bla", sport, InetAddress.getLocalHost(), 0);
             fail("UnknownHostException wasn't thrown");
-        } catch (UnknownHostException uhe) {
-            //expected
-        } catch (Exception e) {
-            fail(e + " was thrown instead of UnknownHostException");
+        } catch (UnknownHostException expected) {
         }
 
         for (int i = 0; i < invalidPorts.length; i++) {
-            portNumber = Support_PortManager.getNextPort();
             try {
-                Socket s = sf.createSocket(InetAddress.getLocalHost().getHostName(), invalidPorts[i],
-                                           InetAddress.getLocalHost(), portNumber);
+                sf.createSocket(InetAddress.getLocalHost().getHostName(), invalidPorts[i],
+                                InetAddress.getLocalHost(), 0);
                 fail("IllegalArgumentException wasn't thrown for " + invalidPorts[i]);
-            } catch (IllegalArgumentException iae) {
-                //expected
-            } catch (Exception e) {
-                fail(e + " was thrown instead of IllegalArgumentException for " + invalidPorts[i]);
+            } catch (IllegalArgumentException expected) {
             }
             try {
-                Socket s = sf.createSocket(InetAddress.getLocalHost().getHostName(), sport,
-                                           InetAddress.getLocalHost(), invalidPorts[i]);
+                sf.createSocket(InetAddress.getLocalHost().getHostName(), sport,
+                                InetAddress.getLocalHost(), invalidPorts[i]);
                 fail("IllegalArgumentException wasn't thrown for " + invalidPorts[i]);
-            } catch (IllegalArgumentException iae) {
-                //expected
-            } catch (Exception e) {
-                fail(e + " was thrown instead of IllegalArgumentException for " + invalidPorts[i]);
+            } catch (IllegalArgumentException expected) {
             }
         }
 
-        SocketFactory f = SocketFactory.getDefault();
         try {
-            Socket s = f.createSocket("localhost", 8081, InetAddress.getLocalHost(), 8082);
+            sf.createSocket(InetAddress.getLocalHost().getHostName(), 8081, InetAddress.getLocalHost(), 8082);
             fail("IOException wasn't thrown ...");
-        } catch (IOException e) {
+        } catch (IOException expected) {
         }
     }
 
@@ -297,12 +214,12 @@ public class SocketFactoryTest extends TestCase {
         SocketFactory sf = SocketFactory.getDefault();
         Socket s;
         try {
-            s = sf.createSocket("localhost", 8082);
+            s = sf.createSocket(InetAddress.getLocalHost().getHostName(), 8082);
             s.close();
         } catch (IOException e) {
         }
         try {
-            s = sf.createSocket("localhost", 8081, InetAddress.getLocalHost(), 8082);
+            s = sf.createSocket(InetAddress.getLocalHost().getHostName(), 8081, InetAddress.getLocalHost(), 8082);
             s.close();
         } catch (IOException e) {
         }
@@ -317,17 +234,6 @@ public class SocketFactoryTest extends TestCase {
         } catch (IOException e) {
         }
     }
-
-    protected int startServer(String name) {
-        int portNumber = Support_PortManager.getNextPort();
-        ServerSocket ss = null;
-        try {
-            ss = new ServerSocket(portNumber);
-        } catch (IOException e) {
-            fail(name + ": " + e);
-        }
-        return ss.getLocalPort();
-    }
 }
 
 class MySocketFactory extends SocketFactory {
-- 
cgit v1.1


From bd8d745469c817f0865237fe4e5ca85b0e75f071 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Fri, 20 Jul 2012 17:46:50 -0700
Subject: Remove another batch of Support_PortManager cruft.

Bug: 2441548
Change-Id: I24331a5e89690d6b2d5b7f4dba1616d8b55b374d
---
 .../javax/net/ssl/HandshakeCompletedEventTest.java | 49 +++++------
 .../api/javax/net/ssl/SSLServerSocketTest.java     | 99 ++++++----------------
 .../tests/api/javax/net/ssl/SSLSessionTest.java    | 55 +++++-------
 .../tests/api/javax/net/ssl/SSLSocketTest.java     | 33 +++-----
 4 files changed, 82 insertions(+), 154 deletions(-)

diff --git a/luni/src/test/java/tests/api/javax/net/ssl/HandshakeCompletedEventTest.java b/luni/src/test/java/tests/api/javax/net/ssl/HandshakeCompletedEventTest.java
index 8a02f9c..c075cea 100644
--- a/luni/src/test/java/tests/api/javax/net/ssl/HandshakeCompletedEventTest.java
+++ b/luni/src/test/java/tests/api/javax/net/ssl/HandshakeCompletedEventTest.java
@@ -42,7 +42,6 @@ import javax.security.cert.X509Certificate;
 import junit.framework.TestCase;
 import libcore.io.Base64;
 import org.apache.harmony.xnet.tests.support.mySSLSession;
-import tests.support.Support_PortManager;
 
 /**
  * Tests for <code>HandshakeCompletedEvent</code> class constructors and methods.
@@ -50,7 +49,7 @@ import tests.support.Support_PortManager;
  */
 public class HandshakeCompletedEventTest extends TestCase {
 
-    String certificate = "-----BEGIN CERTIFICATE-----\n"
+    private String certificate = "-----BEGIN CERTIFICATE-----\n"
         + "MIICZTCCAdICBQL3AAC2MA0GCSqGSIb3DQEBAgUAMF8xCzAJBgNVBAYTAlVTMSAw\n"
         + "HgYDVQQKExdSU0EgRGF0YSBTZWN1cml0eSwgSW5jLjEuMCwGA1UECxMlU2VjdXJl\n"
         + "IFNlcnZlciBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAeFw05NzAyMjAwMDAwMDBa\n"
@@ -200,11 +199,10 @@ public class HandshakeCompletedEventTest extends TestCase {
     // TrustManager
 
 
-    SSLSocket socket;
-    SSLSocket serverSocket;
-    MyHandshakeListener listener;
-    int port = Support_PortManager.getNextPort();
-    String host = "localhost";
+    private SSLSocket socket;
+    private SSLServerSocket serverSocket;
+    private MyHandshakeListener listener;
+    private String host = "localhost";
 
     private String PASSWORD = "android";
 
@@ -398,35 +396,34 @@ public class HandshakeCompletedEventTest extends TestCase {
 
         private boolean provideKeys;
 
-        public TestServer(boolean provideKeys, int clientAuth, String keys) {
+        public TestServer(boolean provideKeys, int clientAuth, String keys) throws Exception {
             this.keys = keys;
             this.clientAuth = clientAuth;
             this.provideKeys = provideKeys;
 
             trustManager = new TestTrustManager();
-        }
 
-        public void run() {
-            try {
-                KeyManager[] keyManagers = provideKeys ? getKeyManagers(keys) : null;
-                TrustManager[] trustManagers = new TrustManager[] { trustManager };
+            KeyManager[] keyManagers = provideKeys ? getKeyManagers(keys) : null;
+            TrustManager[] trustManagers = new TrustManager[] { trustManager };
 
-                SSLContext sslContext = SSLContext.getInstance("TLS");
-                sslContext.init(keyManagers, trustManagers, null);
+            SSLContext sslContext = SSLContext.getInstance("TLS");
+            sslContext.init(keyManagers, trustManagers, null);
 
-                SSLServerSocket serverSocket = (SSLServerSocket)
-                        sslContext.getServerSocketFactory().createServerSocket();
+            serverSocket = (SSLServerSocket) sslContext.getServerSocketFactory().createServerSocket();
 
-                if (clientAuth == CLIENT_AUTH_WANTED) {
-                    serverSocket.setWantClientAuth(true);
-                } else if (clientAuth == CLIENT_AUTH_NEEDED) {
-                    serverSocket.setNeedClientAuth(true);
-                } else {
-                    serverSocket.setWantClientAuth(false);
-                }
+            if (clientAuth == CLIENT_AUTH_WANTED) {
+                serverSocket.setWantClientAuth(true);
+            } else if (clientAuth == CLIENT_AUTH_NEEDED) {
+                serverSocket.setNeedClientAuth(true);
+            } else {
+                serverSocket.setWantClientAuth(false);
+            }
 
-                serverSocket.bind(new InetSocketAddress(port));
+            serverSocket.bind(new InetSocketAddress(0));
+        }
 
+        public void run() {
+            try {
                 SSLSocket clientSocket = (SSLSocket)serverSocket.accept();
 
                 InputStream istream = clientSocket.getInputStream();
@@ -497,7 +494,7 @@ public class HandshakeCompletedEventTest extends TestCase {
 
                 SSLSocket socket = (SSLSocket)sslContext.getSocketFactory().createSocket();
 
-                socket.connect(new InetSocketAddress(port));
+                socket.connect(serverSocket.getLocalSocketAddress());
                 socket.addHandshakeCompletedListener(listener);
                 socket.startHandshake();
 
diff --git a/luni/src/test/java/tests/api/javax/net/ssl/SSLServerSocketTest.java b/luni/src/test/java/tests/api/javax/net/ssl/SSLServerSocketTest.java
index cc96782..5086f65 100644
--- a/luni/src/test/java/tests/api/javax/net/ssl/SSLServerSocketTest.java
+++ b/luni/src/test/java/tests/api/javax/net/ssl/SSLServerSocketTest.java
@@ -20,8 +20,6 @@ import junit.framework.TestCase;
 
 import libcore.io.Base64;
 
-import tests.support.Support_PortManager;
-
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.io.InputStream;
@@ -120,127 +118,78 @@ public class SSLServerSocketTest extends TestCase {
     /**
      * javax.net.ssl.SSLServerSocket#SSLServerSocket()
      */
-    public void testConstructor_01() {
-        try {
-            SSLServerSocket ssl = new mySSLServerSocket();
-        } catch (Exception ex) {
-            fail("Unexpected exception was thrown " + ex);
-        }
+    public void testConstructor() throws Exception {
+        SSLServerSocket ssl = new mySSLServerSocket();
     }
 
     /**
      * javax.net.ssl.SSLServerSocket#SSLServerSocket(int port)
      */
-    public void testConstructor_02() {
-        SSLServerSocket ssl;
-        int portNumber = Support_PortManager.getNextPort();
+    public void testConstructor_I() throws Exception {
         int[] port_invalid = {-1, 65536, Integer.MIN_VALUE, Integer.MAX_VALUE};
 
-        try {
-            ssl = new mySSLServerSocket(portNumber);
-            assertEquals(portNumber, ssl.getLocalPort());
-        } catch (Exception ex) {
-            fail("Unexpected exception was thrown " + ex);
-        }
+        SSLServerSocket ssl = new mySSLServerSocket(0);
 
         for (int i = 0; i < port_invalid.length; i++) {
             try {
-                ssl = new mySSLServerSocket(port_invalid[i]);
+                new mySSLServerSocket(port_invalid[i]);
                 fail("IllegalArgumentException should be thrown");
-            } catch (IllegalArgumentException iae) {
-                //expected
-            } catch (Exception e) {
-                fail(e + " was thrown instead of IllegalArgumentException");
+            } catch (IllegalArgumentException expected) {
             }
         }
 
         try {
-            ssl = new mySSLServerSocket(portNumber);
-            new mySSLServerSocket(portNumber);
+            new mySSLServerSocket(ssl.getLocalPort());
             fail("IOException Expected when opening an already opened port");
-        } catch (IOException ioe) {
-            // expected
-        } catch (Exception ex) {
-            fail("Unexpected exception was thrown " + ex);
+        } catch (IOException expected) {
         }
     }
 
     /**
      * javax.net.ssl.SSLServerSocket#SSLServerSocket(int port, int backlog)
      */
-    public void testConstructor_03() {
-        mySSLServerSocket ssl;
-        int portNumber = Support_PortManager.getNextPort();
+    public void testConstructor_II() throws Exception {
+        mySSLServerSocket ssl = new mySSLServerSocket(0, 1);
         int[] port_invalid = {-1, Integer.MIN_VALUE, Integer.MAX_VALUE};
 
-        try {
-            ssl = new mySSLServerSocket(portNumber, 1);
-            assertEquals(portNumber, ssl.getLocalPort());
-        } catch (Exception ex) {
-            fail("Unexpected exception was thrown");
-        }
-
         for (int i = 0; i < port_invalid.length; i++) {
             try {
-                ssl = new mySSLServerSocket(port_invalid[i], 1);
+                new mySSLServerSocket(port_invalid[i], 1);
                 fail("IllegalArgumentException should be thrown");
-            } catch (IllegalArgumentException iae) {
-                // expected
-            } catch (Exception e) {
-                fail(e + " was thrown instead of IllegalArgumentException");
+            } catch (IllegalArgumentException expected) {
             }
         }
 
-        portNumber = Support_PortManager.getNextPort();
         try {
-            ssl = new mySSLServerSocket(portNumber, 1);
-            new mySSLServerSocket(portNumber, 1);
+            new mySSLServerSocket(ssl.getLocalPort(), 1);
             fail("IOException should be thrown");
-        } catch (IOException ioe) {
+        } catch (IOException expected) {
         }
     }
 
     /**
      * javax.net.ssl.SSLServerSocket#SSLServerSocket(int port, int backlog, InetAddress address)
      */
-    public void testConstructor_04() {
-        mySSLServerSocket ssl;
-        InetAddress ia = null;
-        int portNumber = Support_PortManager.getNextPort();
-        int[] port_invalid = {-1, 65536, Integer.MIN_VALUE, Integer.MAX_VALUE};
+    public void testConstructor_IIInetAddress() throws Exception {
+        // A null InetAddress is okay.
+        new mySSLServerSocket(0, 0, null);
 
-        try {
-            ssl = new mySSLServerSocket(portNumber, 0, ia);
-            assertEquals(portNumber, ssl.getLocalPort());
-        } catch (Exception ex) {
-            fail("Unexpected exception was thrown");
-        }
+        int[] port_invalid = {-1, 65536, Integer.MIN_VALUE, Integer.MAX_VALUE};
 
-        portNumber = Support_PortManager.getNextPort();
-        try {
-            ssl = new mySSLServerSocket(portNumber, 0, InetAddress.getLocalHost());
-            assertEquals(portNumber, ssl.getLocalPort());
-        } catch (Exception ex) {
-            fail("Unexpected exception was thrown");
-        }
+        mySSLServerSocket ssl = new mySSLServerSocket(0, 0, InetAddress.getLocalHost());
 
         for (int i = 0; i < port_invalid.length; i++) {
             try {
-                ssl = new mySSLServerSocket(port_invalid[i], 1, InetAddress.getLocalHost());
+                new mySSLServerSocket(port_invalid[i], 1, InetAddress.getLocalHost());
                 fail("IllegalArgumentException should be thrown");
-            } catch (IllegalArgumentException iae) {
-                // expected
-            } catch (Exception e) {
-                fail(e + " was thrown instead of IllegalArgumentException");
+            } catch (IllegalArgumentException expected) {
             }
         }
 
-        portNumber = Support_PortManager.getNextPort();
         try {
-           ssl = new mySSLServerSocket(portNumber, 0, InetAddress.getLocalHost());
-           new mySSLServerSocket(portNumber, 0, InetAddress.getLocalHost());
-           fail("IOException should be thrown for");
-        } catch (IOException ioe) {
+            new mySSLServerSocket(ssl.getLocalPort(), 0, InetAddress.getLocalHost());
+            fail("IOException should be thrown for");
+        } catch (IOException expected) {
         }
     }
 
diff --git a/luni/src/test/java/tests/api/javax/net/ssl/SSLSessionTest.java b/luni/src/test/java/tests/api/javax/net/ssl/SSLSessionTest.java
index ec23cae..5084422 100644
--- a/luni/src/test/java/tests/api/javax/net/ssl/SSLSessionTest.java
+++ b/luni/src/test/java/tests/api/javax/net/ssl/SSLSessionTest.java
@@ -39,12 +39,7 @@ import junit.framework.TestCase;
 import libcore.io.Base64;
 import tests.api.javax.net.ssl.HandshakeCompletedEventTest.MyHandshakeListener;
 import tests.api.javax.net.ssl.HandshakeCompletedEventTest.TestTrustManager;
-import tests.support.Support_PortManager;
 
-/**
- * Tests for SSLSession class
- *
- */
 public class SSLSessionTest extends TestCase {
 
     // set to true if on Android, false if on RI
@@ -57,7 +52,7 @@ public class SSLSessionTest extends TestCase {
     public void test_getPeerHost() throws Exception {
         SSLSession s = clientSession;
         assertEquals(InetAddress.getLocalHost().getHostName(), s.getPeerHost());
-        assertEquals(port, s.getPeerPort());
+        assertEquals(serverSocket.getLocalPort(), s.getPeerPort());
     }
 
     /**
@@ -258,12 +253,10 @@ public class SSLSessionTest extends TestCase {
     TestClient client;
 
     @Override
-    protected void setUp() {
-        port = Support_PortManager.getNextPort();
+    protected void setUp() throws Exception {
         String serverKeys = (useBKS ? SERVER_KEYS_BKS : SERVER_KEYS_JKS);
         String clientKeys = (useBKS ? CLIENT_KEYS_BKS : CLIENT_KEYS_JKS);
-        server = new TestServer(true,
-                TestServer.CLIENT_AUTH_WANTED, serverKeys);
+        server = new TestServer(true, TestServer.CLIENT_AUTH_WANTED, serverKeys);
         client = new TestClient(true, clientKeys);
 
         serverThread = new Thread(server);
@@ -453,8 +446,7 @@ public class SSLSessionTest extends TestCase {
             + "NMGpCX6qmjbkJQLVK/Yfo1ePaUexPSOX0G9m8+DoV3iyNw6at01NRw==";
 
 
-    int port;
-    SSLSocket serverSocket;
+    SSLServerSocket serverSocket;
     MyHandshakeListener listener;
     String host = "localhost";
     boolean notFinished = true;
@@ -489,36 +481,35 @@ public class SSLSessionTest extends TestCase {
 
         private KeyStore store;
 
-        public TestServer(boolean provideKeys, int clientAuth, String keys) {
+        public TestServer(boolean provideKeys, int clientAuth, String keys) throws Exception {
             this.keys = keys;
             this.clientAuth = clientAuth;
             this.provideKeys = provideKeys;
 
             trustManager = new TestTrustManager();
-        }
 
-        public void run() {
-            try {
-                store = provideKeys ? getKeyStore(keys) : null;
-                KeyManager[] keyManagers = store != null ? getKeyManagers(store) : null;
-                TrustManager[] trustManagers = new TrustManager[] { trustManager };
+            store = provideKeys ? getKeyStore(keys) : null;
+            KeyManager[] keyManagers = store != null ? getKeyManagers(store) : null;
+            TrustManager[] trustManagers = new TrustManager[] { trustManager };
 
-                SSLContext sslContext = SSLContext.getInstance("TLS");
-                sslContext.init(keyManagers, trustManagers, null);
+            SSLContext sslContext = SSLContext.getInstance("TLS");
+            sslContext.init(keyManagers, trustManagers, null);
 
-                SSLServerSocket serverSocket = (SSLServerSocket)sslContext
-                        .getServerSocketFactory().createServerSocket();
+            serverSocket = (SSLServerSocket)sslContext.getServerSocketFactory().createServerSocket();
 
-                if (clientAuth == CLIENT_AUTH_WANTED) {
-                    serverSocket.setWantClientAuth(true);
-                } else if (clientAuth == CLIENT_AUTH_NEEDED) {
-                    serverSocket.setNeedClientAuth(true);
-                } else {
-                    serverSocket.setWantClientAuth(false);
-                }
+            if (clientAuth == CLIENT_AUTH_WANTED) {
+                serverSocket.setWantClientAuth(true);
+            } else if (clientAuth == CLIENT_AUTH_NEEDED) {
+                serverSocket.setNeedClientAuth(true);
+            } else {
+                serverSocket.setWantClientAuth(false);
+            }
 
-                serverSocket.bind(new InetSocketAddress(port));
+            serverSocket.bind(null);
+        }
 
+        public void run() {
+            try {
                 SSLSocket clientSocket = (SSLSocket)serverSocket.accept();
 
                 InputStream istream = clientSocket.getInputStream();
@@ -589,7 +580,7 @@ public class SSLSessionTest extends TestCase {
 
                 SSLSocket socket = (SSLSocket)clientSslContext.getSocketFactory().createSocket();
 
-                socket.connect(new InetSocketAddress(port));
+                socket.connect(serverSocket.getLocalSocketAddress());
                 OutputStream ostream = socket.getOutputStream();
                 ostream.write(testData.getBytes());
                 ostream.flush();
diff --git a/luni/src/test/java/tests/api/javax/net/ssl/SSLSocketTest.java b/luni/src/test/java/tests/api/javax/net/ssl/SSLSocketTest.java
index ab60f72..b4cbde2 100644
--- a/luni/src/test/java/tests/api/javax/net/ssl/SSLSocketTest.java
+++ b/luni/src/test/java/tests/api/javax/net/ssl/SSLSocketTest.java
@@ -38,7 +38,6 @@ import javax.security.cert.X509Certificate;
 import junit.framework.TestCase;
 import libcore.io.Base64;
 import tests.api.javax.net.ssl.HandshakeCompletedEventTest.TestTrustManager;
-import tests.support.Support_PortManager;
 import libcore.java.security.StandardNames;
 
 public class SSLSocketTest extends TestCase {
@@ -51,7 +50,7 @@ public class SSLSocketTest extends TestCase {
     /**
      * javax.net.ssl.SSLSocket#SSLSocket()
      */
-    public void testConstructor_01() throws Exception {
+    public void testConstructor() throws Exception {
         SSLSocket ssl = getSSLSocket();
         assertNotNull(ssl);
         ssl.close();
@@ -60,7 +59,7 @@ public class SSLSocketTest extends TestCase {
     /**
      * javax.net.ssl.SSLSocket#SSLSocket(InetAddress address, int port)
      */
-    public void testConstructor_02() throws UnknownHostException, IOException {
+    public void testConstructor_InetAddressI() throws Exception {
         int sport = startServer("Cons InetAddress,I");
         int[] invalidPort = {-1, Integer.MIN_VALUE, 65536, Integer.MAX_VALUE};
 
@@ -88,15 +87,13 @@ public class SSLSocketTest extends TestCase {
      * javax.net.ssl.SSLSocket#SSLSocket(InetAddress address, int port,
      *                                          InetAddress clientAddress, int clientPort)
      */
-    public void testConstructor_03() throws UnknownHostException, IOException {
+    public void testConstructor_InetAddressIInetAddressI() throws Exception {
         int sport = startServer("Cons InetAddress,I,InetAddress,I");
-        int portNumber = Support_PortManager.getNextPort();
 
         SSLSocket ssl = getSSLSocket(InetAddress.getLocalHost(), sport,
-                                     InetAddress.getLocalHost(), portNumber);
+                                     InetAddress.getLocalHost(), 0);
         assertNotNull(ssl);
         assertEquals(sport, ssl.getPort());
-        assertEquals(portNumber, ssl.getLocalPort());
         ssl.close();
 
         try {
@@ -137,7 +134,7 @@ public class SSLSocketTest extends TestCase {
     /**
      * javax.net.ssl.SSLSocket#SSLSocket(String host, int port)
      */
-    public void testConstructor_04() throws UnknownHostException, IOException {
+    public void testConstructor_StringI() throws Exception {
         int sport = startServer("Cons String,I");
         int[] invalidPort = {-1, Integer.MIN_VALUE, 65536, Integer.MAX_VALUE};
 
@@ -171,28 +168,25 @@ public class SSLSocketTest extends TestCase {
      * javax.net.ssl.SSLSocket#SSLSocket(String host, int port, InetAddress clientAddress,
      *           int clientPort)
      */
-    public void testConstructor_05() throws UnknownHostException, IOException {
+    public void testConstructor_StringIInetAddressI() throws Exception {
         int sport = startServer("Cons String,I,InetAddress,I");
-        int portNumber = Support_PortManager.getNextPort();
         int[] invalidPort = {-1, Integer.MIN_VALUE, 65536, Integer.MAX_VALUE};
 
         SSLSocket ssl = getSSLSocket(InetAddress.getLocalHost().getHostName(), sport,
-                                     InetAddress.getLocalHost(), portNumber);
+                                     InetAddress.getLocalHost(), 0);
         assertNotNull(ssl);
         assertEquals(sport, ssl.getPort());
-        assertEquals(portNumber, ssl.getLocalPort());
 
         try {
-            getSSLSocket("localhost", 8081, InetAddress.getLocalHost(), 8082);
+            getSSLSocket(InetAddress.getLocalHost().getHostName(), 8081, InetAddress.getLocalHost(), 8082);
             fail();
         } catch (IOException expected) {
         }
 
         for (int i = 0; i < invalidPort.length; i++) {
-            portNumber = Support_PortManager.getNextPort();
             try {
                 getSSLSocket(InetAddress.getLocalHost().getHostName(), invalidPort[i],
-                             InetAddress.getLocalHost(), portNumber);
+                             InetAddress.getLocalHost(), 0);
                 fail();
             } catch (IllegalArgumentException expected) {
             }
@@ -204,9 +198,8 @@ public class SSLSocketTest extends TestCase {
             }
         }
 
-        portNumber = Support_PortManager.getNextPort();
         try {
-            getSSLSocket("bla-bla", sport, InetAddress.getLocalHost(), portNumber);
+            getSSLSocket("bla-bla", sport, InetAddress.getLocalHost(), 0);
             fail();
         } catch (UnknownHostException expected) {
         }
@@ -422,12 +415,10 @@ public class SSLSocketTest extends TestCase {
         ssl.close();
     }
 
-    boolean useBKS = !StandardNames.IS_RI;
+    private boolean useBKS = !StandardNames.IS_RI;
 
     private String PASSWORD = "android";
 
-    private int port = Support_PortManager.getNextPort();
-
     private boolean serverReady = false;
 
     /**
@@ -551,7 +542,7 @@ public class SSLSocketTest extends TestCase {
                 SSLServerSocket serverSocket = (SSLServerSocket)
                         sslContext.getServerSocketFactory().createServerSocket();
                 try {
-                    serverSocket.bind(new InetSocketAddress(port));
+                    serverSocket.bind(new InetSocketAddress(0));
                     sport = serverSocket.getLocalPort();
                     serverReady = true;
 
-- 
cgit v1.1


From 5ce432f9499d4bda65eb85448f60523313a8f669 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Mon, 23 Jul 2012 11:06:41 -0700
Subject: Add a test for Method.getParameterAnnotations.

Note that this wouldn't tickle the bug because dx always points
to an empty list rather than using a 0 offset.

Bug: http://code.google.com/p/android/issues/detail?id=35304
Change-Id: Ia60be0d2f7f799425dd5918f475bf538c42dc89d
---
 .../annotation/tests/java/lang/annotation/AnnotationTest.java | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/luni/src/test/java/org/apache/harmony/annotation/tests/java/lang/annotation/AnnotationTest.java b/luni/src/test/java/org/apache/harmony/annotation/tests/java/lang/annotation/AnnotationTest.java
index 33ce8fb..8395c00 100644
--- a/luni/src/test/java/org/apache/harmony/annotation/tests/java/lang/annotation/AnnotationTest.java
+++ b/luni/src/test/java/org/apache/harmony/annotation/tests/java/lang/annotation/AnnotationTest.java
@@ -126,6 +126,17 @@ public class AnnotationTest extends TestCase {
                 m2.getDeclaredAnnotations()[0].hashCode());
 
     }
+
+    public static void test35304() throws Exception {
+        Class c = AnnotationTest.class;
+        Class[] parameterTypes = new Class[] { String.class, String.class };
+        Annotation[][] annotations = c.getDeclaredMethod("test35304_method", parameterTypes).getParameterAnnotations();
+        assertEquals(2, annotations.length); // Two parameters.
+        assertEquals(0, annotations[0].length); // No annotations on the first.
+        assertEquals(1, annotations[1].length); // One annotation on the second.
+    }
+
+    private static String test35304_method(String s1, @Deprecated String s2) { return null; }
 }
 
 class AnnotatedClass2 {
-- 
cgit v1.1


From 5ec69b20ab9b3e2dcbe225d548168b09afbbbac2 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Mon, 23 Jul 2012 16:32:51 -0700
Subject: Clean up ICU error reporting.

Throw all ICU exceptions from the native side, and include the name of the
function that failed.

Bug: 5037042
Change-Id: I49b5493a7e7365226d612479294b5b8f47ec4e8c
---
 .../java/java/nio/charset/CharsetDecoderICU.java   | 37 ++++++-----
 .../java/java/nio/charset/CharsetEncoderICU.java   | 31 ++++------
 luni/src/main/java/java/sql/DataTruncation.java    |  4 +-
 luni/src/main/java/libcore/icu/ErrorCode.java      | 71 ----------------------
 luni/src/main/java/libcore/icu/ICU.java            | 13 ++++
 .../src/main/java/libcore/icu/NativeConverter.java | 24 ++++----
 luni/src/main/native/JniException.cpp              | 17 ++++--
 luni/src/main/native/JniException.h                |  2 +-
 luni/src/main/native/java_text_Bidi.cpp            | 12 ++--
 luni/src/main/native/java_util_regex_Matcher.cpp   |  4 +-
 luni/src/main/native/libcore_icu_ICU.cpp           |  5 +-
 .../native/libcore_icu_NativeBreakIterator.cpp     |  6 +-
 .../main/native/libcore_icu_NativeCollation.cpp    | 20 +++---
 .../main/native/libcore_icu_NativeConverter.cpp    | 53 ++++++++++++----
 .../native/libcore_icu_NativeDecimalFormat.cpp     | 13 ++--
 .../main/native/libcore_icu_NativeNormalizer.cpp   |  4 +-
 .../main/native/libcore_icu_NativePluralRules.cpp  |  2 +-
 luni/src/main/native/libcore_icu_TimeZones.cpp     |  4 +-
 18 files changed, 147 insertions(+), 175 deletions(-)
 delete mode 100644 luni/src/main/java/libcore/icu/ErrorCode.java

diff --git a/luni/src/main/java/java/nio/charset/CharsetDecoderICU.java b/luni/src/main/java/java/nio/charset/CharsetDecoderICU.java
index 3ad46d7..8b32efa 100644
--- a/luni/src/main/java/java/nio/charset/CharsetDecoderICU.java
+++ b/luni/src/main/java/java/nio/charset/CharsetDecoderICU.java
@@ -16,7 +16,7 @@ package java.nio.charset;
 
 import java.nio.ByteBuffer;
 import java.nio.CharBuffer;
-import libcore.icu.ErrorCode;
+import libcore.icu.ICU;
 import libcore.icu.NativeConverter;
 import libcore.util.EmptyArray;
 
@@ -46,7 +46,6 @@ final class CharsetDecoderICU extends CharsetDecoder {
     // is inherently thread-unsafe so we don't have to worry about synchronization.
     private int inEnd;
     private int outEnd;
-    private int ec;
 
     public static CharsetDecoderICU newInstance(Charset cs, String icuCanonicalName) {
         // This complexity is necessary to ensure that even if the constructor, superclass
@@ -84,10 +83,7 @@ final class CharsetDecoderICU extends CharsetDecoder {
     }
 
     private void updateCallback() {
-        ec = NativeConverter.setCallbackDecode(converterHandle, this);
-        if (ErrorCode.isFailure(ec)) {
-            throw ErrorCode.throwException(ec);
-        }
+        NativeConverter.setCallbackDecode(converterHandle, this);
     }
 
     @Override protected void implReset() {
@@ -99,7 +95,6 @@ final class CharsetDecoderICU extends CharsetDecoder {
         input = null;
         allocatedInput = null;
         allocatedOutput = null;
-        ec = 0;
         inEnd = 0;
         outEnd = 0;
     }
@@ -114,16 +109,14 @@ final class CharsetDecoderICU extends CharsetDecoder {
             data[OUTPUT_OFFSET] = getArray(out);
             data[INVALID_BYTES] = 0; // Make sure we don't see earlier errors.
 
-            ec = NativeConverter.decode(converterHandle, input, inEnd, output, outEnd, data, true);
-            if (ErrorCode.isFailure(ec)) {
-                if (ec == ErrorCode.U_BUFFER_OVERFLOW_ERROR) {
+            int error = NativeConverter.decode(converterHandle, input, inEnd, output, outEnd, data, true);
+            if (ICU.U_FAILURE(error)) {
+                if (error == ICU.U_BUFFER_OVERFLOW_ERROR) {
                     return CoderResult.OVERFLOW;
-                } else if (ec == ErrorCode.U_TRUNCATED_CHAR_FOUND) {
+                } else if (error == ICU.U_TRUNCATED_CHAR_FOUND) {
                     if (data[INPUT_OFFSET] > 0) {
                         return CoderResult.malformedForLength(data[INPUT_OFFSET]);
                     }
-                } else {
-                    throw ErrorCode.throwException(ec);
                 }
             }
             return CoderResult.UNDERFLOW;
@@ -142,13 +135,17 @@ final class CharsetDecoderICU extends CharsetDecoder {
         data[OUTPUT_OFFSET]= getArray(out);
 
         try {
-            ec = NativeConverter.decode(converterHandle, input, inEnd, output, outEnd, data, false);
-            if (ec == ErrorCode.U_BUFFER_OVERFLOW_ERROR) {
-                return CoderResult.OVERFLOW;
-            } else if (ec == ErrorCode.U_INVALID_CHAR_FOUND) {
-                return CoderResult.unmappableForLength(data[INVALID_BYTES]);
-            } else if (ec == ErrorCode.U_ILLEGAL_CHAR_FOUND) {
-                return CoderResult.malformedForLength(data[INVALID_BYTES]);
+            int error = NativeConverter.decode(converterHandle, input, inEnd, output, outEnd, data, false);
+            if (ICU.U_FAILURE(error)) {
+                if (error == ICU.U_BUFFER_OVERFLOW_ERROR) {
+                    return CoderResult.OVERFLOW;
+                } else if (error == ICU.U_INVALID_CHAR_FOUND) {
+                    return CoderResult.unmappableForLength(data[INVALID_BYTES]);
+                } else if (error == ICU.U_ILLEGAL_CHAR_FOUND) {
+                    return CoderResult.malformedForLength(data[INVALID_BYTES]);
+                } else {
+                    throw new AssertionError(error);
+                }
             }
             // Decoding succeeded: give us more data.
             return CoderResult.UNDERFLOW;
diff --git a/luni/src/main/java/java/nio/charset/CharsetEncoderICU.java b/luni/src/main/java/java/nio/charset/CharsetEncoderICU.java
index cf071ca..76807b0 100644
--- a/luni/src/main/java/java/nio/charset/CharsetEncoderICU.java
+++ b/luni/src/main/java/java/nio/charset/CharsetEncoderICU.java
@@ -18,7 +18,7 @@ import java.nio.ByteBuffer;
 import java.nio.CharBuffer;
 import java.util.HashMap;
 import java.util.Map;
-import libcore.icu.ErrorCode;
+import libcore.icu.ICU;
 import libcore.icu.NativeConverter;
 import libcore.util.EmptyArray;
 
@@ -61,7 +61,6 @@ final class CharsetEncoderICU extends CharsetEncoder {
     // is inherently thread-unsafe so we don't have to worry about synchronization.
     private int inEnd;
     private int outEnd;
-    private int ec;
 
     public static CharsetEncoderICU newInstance(Charset cs, String icuCanonicalName) {
         // This complexity is necessary to ensure that even if the constructor, superclass
@@ -112,10 +111,7 @@ final class CharsetEncoderICU extends CharsetEncoder {
     }
 
     private void updateCallback() {
-        ec = NativeConverter.setCallbackEncode(converterHandle, this);
-        if (ErrorCode.isFailure(ec)) {
-            throw ErrorCode.throwException(ec);
-        }
+        NativeConverter.setCallbackEncode(converterHandle, this);
     }
 
     @Override protected void implReset() {
@@ -127,7 +123,6 @@ final class CharsetEncoderICU extends CharsetEncoder {
         input = null;
         allocatedInput = null;
         allocatedOutput = null;
-        ec = 0;
         inEnd = 0;
         outEnd = 0;
     }
@@ -142,16 +137,14 @@ final class CharsetEncoderICU extends CharsetEncoder {
             data[OUTPUT_OFFSET] = getArray(out);
             data[INVALID_CHARS] = 0; // Make sure we don't see earlier errors.
 
-            ec = NativeConverter.encode(converterHandle, input, inEnd, output, outEnd, data, true);
-            if (ErrorCode.isFailure(ec)) {
-                if (ec == ErrorCode.U_BUFFER_OVERFLOW_ERROR) {
+            int error = NativeConverter.encode(converterHandle, input, inEnd, output, outEnd, data, true);
+            if (ICU.U_FAILURE(error)) {
+                if (error == ICU.U_BUFFER_OVERFLOW_ERROR) {
                     return CoderResult.OVERFLOW;
-                } else if (ec == ErrorCode.U_TRUNCATED_CHAR_FOUND) {
+                } else if (error == ICU.U_TRUNCATED_CHAR_FOUND) {
                     if (data[INPUT_OFFSET] > 0) {
                         return CoderResult.malformedForLength(data[INPUT_OFFSET]);
                     }
-                } else {
-                    throw ErrorCode.throwException(ec);
                 }
             }
             return CoderResult.UNDERFLOW;
@@ -171,16 +164,16 @@ final class CharsetEncoderICU extends CharsetEncoder {
         data[INVALID_CHARS] = 0; // Make sure we don't see earlier errors.
 
         try {
-            ec = NativeConverter.encode(converterHandle, input, inEnd, output, outEnd, data, false);
-            if (ErrorCode.isFailure(ec)) {
-                if (ec == ErrorCode.U_BUFFER_OVERFLOW_ERROR) {
+            int error = NativeConverter.encode(converterHandle, input, inEnd, output, outEnd, data, false);
+            if (ICU.U_FAILURE(error)) {
+                if (error == ICU.U_BUFFER_OVERFLOW_ERROR) {
                     return CoderResult.OVERFLOW;
-                } else if (ec == ErrorCode.U_INVALID_CHAR_FOUND) {
+                } else if (error == ICU.U_INVALID_CHAR_FOUND) {
                     return CoderResult.unmappableForLength(data[INVALID_CHARS]);
-                } else if (ec == ErrorCode.U_ILLEGAL_CHAR_FOUND) {
+                } else if (error == ICU.U_ILLEGAL_CHAR_FOUND) {
                     return CoderResult.malformedForLength(data[INVALID_CHARS]);
                 } else {
-                    throw new AssertionError("unexpected failure: " + ec);
+                    throw new AssertionError(error);
                 }
             }
             // Decoding succeeded: give us more data.
diff --git a/luni/src/main/java/java/sql/DataTruncation.java b/luni/src/main/java/java/sql/DataTruncation.java
index b01100e..c1bf11c 100644
--- a/luni/src/main/java/java/sql/DataTruncation.java
+++ b/luni/src/main/java/java/sql/DataTruncation.java
@@ -49,7 +49,7 @@ public class DataTruncation extends SQLWarning implements Serializable {
 
     /**
      * Creates the {@code DataTruncation} object. The reason is set to {@code
-     * "Data truncation"}, the {@code ErrorCode} is set to the {@code
+     * "Data truncation"}, the error code is set to the {@code
      * SQLException} default value, and the other fields are set to the values
      * supplied as arguments.
      *
@@ -79,7 +79,7 @@ public class DataTruncation extends SQLWarning implements Serializable {
 
     /**
      * Creates a DataTruncation. The Reason is set to "Data truncation", the
-     * ErrorCode is set to the SQLException default value and other fields are
+     * error code is set to the SQLException default value and other fields are
      * set to the values supplied on this method.
      *
      * @param index
diff --git a/luni/src/main/java/libcore/icu/ErrorCode.java b/luni/src/main/java/libcore/icu/ErrorCode.java
deleted file mode 100644
index c093af2..0000000
--- a/luni/src/main/java/libcore/icu/ErrorCode.java
+++ /dev/null
@@ -1,71 +0,0 @@
-/**
-******************************************************************************
-* Copyright (C) 1996-2005, International Business Machines Corporation and   *
-* others. All Rights Reserved.                                               *
-******************************************************************************
-*
-******************************************************************************
-*/
-
-package libcore.icu;
-
-/**
- * Error exception class mapping ICU error codes of the enum UErrorCode
- * @author syn wee quek
-*/
-public final class ErrorCode extends Exception {
-    public static boolean isFailure(int error) {
-        return error > U_ZERO_ERROR && error < U_ERROR_LIMIT;
-    }
-
-    public static RuntimeException throwException(int error) {
-        if (error <= U_ZERO_ERROR && error >= U_ERROR_LIMIT) {
-            return null;
-        }
-        switch (error) {
-        case U_ILLEGAL_ARGUMENT_ERROR:
-            return new IllegalArgumentException(ERROR_NAMES[error]);
-        case U_INDEX_OUTOFBOUNDS_ERROR:
-        case U_BUFFER_OVERFLOW_ERROR:
-            return new ArrayIndexOutOfBoundsException(ERROR_NAMES[error]);
-        case U_UNSUPPORTED_ERROR:
-            return new UnsupportedOperationException(ERROR_NAMES[error]);
-        }
-        throw new RuntimeException(ERROR_NAMES[error]);
-    }
-
-    // The errors needed by our CharsetDecoderICU/CharsetEncoderICU.
-    public static final int U_ZERO_ERROR = 0;
-    private static final int U_ILLEGAL_ARGUMENT_ERROR = 1;
-    private static final int U_INDEX_OUTOFBOUNDS_ERROR = 8;
-    public static final int U_INVALID_CHAR_FOUND = 10;
-    public static final int U_TRUNCATED_CHAR_FOUND = 11;
-    public static final int U_ILLEGAL_CHAR_FOUND = 12;
-    public static final int U_BUFFER_OVERFLOW_ERROR = 15;
-    private static final int U_UNSUPPORTED_ERROR = 16;
-    private static final int U_ERROR_LIMIT = 21;
-
-    // TODO: this list is incomplete; get these from native code!
-    private static final String ERROR_NAMES[] = {
-        "U_ZERO_ERROR",
-        "U_ILLEGAL_ARGUMENT_ERROR",
-        "U_MISSING_RESOURCE_ERROR",
-        "U_INVALID_FORMAT_ERROR",
-        "U_FILE_ACCESS_ERROR",
-        "U_INTERNAL_PROGRAM_ERROR",
-        "U_MESSAGE_PARSE_ERROR",
-        "U_MEMORY_ALLOCATION_ERROR",
-        "U_INDEX_OUTOFBOUNDS_ERROR",
-        "U_PARSE_ERROR",
-        "U_INVALID_CHAR_FOUND",
-        "U_TRUNCATED_CHAR_FOUND",
-        "U_ILLEGAL_CHAR_FOUND",
-        "U_INVALID_TABLE_FORMAT",
-        "U_INVALID_TABLE_FILE",
-        "U_BUFFER_OVERFLOW_ERROR",
-        "U_UNSUPPORTED_ERROR",
-        "U_RESOURCE_TYPE_MISMATCH",
-        "U_ILLEGAL_ESCAPE_SEQUENCE",
-        "U_UNSUPPORTED_ESCAPE_SEQUENCE"
-    };
-}
diff --git a/luni/src/main/java/libcore/icu/ICU.java b/luni/src/main/java/libcore/icu/ICU.java
index 7f3303e..9984414 100644
--- a/luni/src/main/java/libcore/icu/ICU.java
+++ b/luni/src/main/java/libcore/icu/ICU.java
@@ -142,6 +142,19 @@ public final class ICU {
     public static native String toLowerCase(String s, String localeName);
     public static native String toUpperCase(String s, String localeName);
 
+    // --- Errors.
+
+    // Just the subset of error codes needed by CharsetDecoderICU/CharsetEncoderICU.
+    public static final int U_ZERO_ERROR = 0;
+    public static final int U_INVALID_CHAR_FOUND = 10;
+    public static final int U_TRUNCATED_CHAR_FOUND = 11;
+    public static final int U_ILLEGAL_CHAR_FOUND = 12;
+    public static final int U_BUFFER_OVERFLOW_ERROR = 15;
+
+    public static boolean U_FAILURE(int error) {
+      return error > U_ZERO_ERROR;
+    }
+
     // --- Native methods accessing ICU's database.
 
     private static native String[] getAvailableBreakIteratorLocalesNative();
diff --git a/luni/src/main/java/libcore/icu/NativeConverter.java b/luni/src/main/java/libcore/icu/NativeConverter.java
index 2d8630c..e18f483 100644
--- a/luni/src/main/java/libcore/icu/NativeConverter.java
+++ b/luni/src/main/java/libcore/icu/NativeConverter.java
@@ -54,19 +54,19 @@ public final class NativeConverter {
         }
     }
 
-    public static int setCallbackDecode(long converterHandle, CharsetDecoder decoder) {
-        return setCallbackDecode(converterHandle,
-                translateCodingErrorAction(decoder.malformedInputAction()),
-                translateCodingErrorAction(decoder.unmappableCharacterAction()),
-                decoder.replacement());
+    public static void setCallbackDecode(long converterHandle, CharsetDecoder decoder) {
+        setCallbackDecode(converterHandle,
+                          translateCodingErrorAction(decoder.malformedInputAction()),
+                          translateCodingErrorAction(decoder.unmappableCharacterAction()),
+                          decoder.replacement());
     }
-    private static native int setCallbackDecode(long converterHandle, int onMalformedInput, int onUnmappableInput, String subChars);
+    private static native void setCallbackDecode(long converterHandle, int onMalformedInput, int onUnmappableInput, String subChars);
 
-    public static int setCallbackEncode(long converterHandle, CharsetEncoder encoder) {
-        return setCallbackEncode(converterHandle,
-                translateCodingErrorAction(encoder.malformedInputAction()),
-                translateCodingErrorAction(encoder.unmappableCharacterAction()),
-                encoder.replacement());
+    public static void setCallbackEncode(long converterHandle, CharsetEncoder encoder) {
+        setCallbackEncode(converterHandle,
+                          translateCodingErrorAction(encoder.malformedInputAction()),
+                          translateCodingErrorAction(encoder.unmappableCharacterAction()),
+                          encoder.replacement());
     }
-    private static native int setCallbackEncode(long converterHandle, int onMalformedInput, int onUnmappableInput, byte[] subBytes);
+    private static native void setCallbackEncode(long converterHandle, int onMalformedInput, int onUnmappableInput, byte[] subBytes);
 }
diff --git a/luni/src/main/native/JniException.cpp b/luni/src/main/native/JniException.cpp
index 6626448..c733db4 100644
--- a/luni/src/main/native/JniException.cpp
+++ b/luni/src/main/native/JniException.cpp
@@ -17,22 +17,27 @@
 #include "JniException.h"
 #include "JNIHelp.h"
 
-bool maybeThrowIcuException(JNIEnv* env, UErrorCode error) {
+bool maybeThrowIcuException(JNIEnv* env, const char* function, UErrorCode error) {
     if (U_SUCCESS(error)) {
         return false;
     }
-    const char* message = u_errorName(error);
+    const char* exceptionClass;
     switch (error) {
     case U_ILLEGAL_ARGUMENT_ERROR:
-        return jniThrowException(env, "java/lang/IllegalArgumentException", message);
+        exceptionClass = "java/lang/IllegalArgumentException";
+        break;
     case U_INDEX_OUTOFBOUNDS_ERROR:
     case U_BUFFER_OVERFLOW_ERROR:
-        return jniThrowException(env, "java/lang/ArrayIndexOutOfBoundsException", message);
+        exceptionClass = "java/lang/ArrayIndexOutOfBoundsException";
+        break;
     case U_UNSUPPORTED_ERROR:
-        return jniThrowException(env, "java/lang/UnsupportedOperationException", message);
+        exceptionClass = "java/lang/UnsupportedOperationException";
+        break;
     default:
-        return jniThrowRuntimeException(env, message);
+        exceptionClass = "java/lang/RuntimeException";
+        break;
     }
+    return jniThrowExceptionFmt(env, exceptionClass, "%s failed: %s", function, u_errorName(error));
 }
 
 void jniThrowExceptionWithErrno(JNIEnv* env, const char* exceptionClassName, int error) {
diff --git a/luni/src/main/native/JniException.h b/luni/src/main/native/JniException.h
index b3447d2..cece2aa 100644
--- a/luni/src/main/native/JniException.h
+++ b/luni/src/main/native/JniException.h
@@ -25,6 +25,6 @@ void jniThrowExceptionWithErrno(JNIEnv* env, const char* exceptionClassName, int
 void jniThrowOutOfMemoryError(JNIEnv* env, const char* message);
 void jniThrowSocketException(JNIEnv* env, int error);
 
-bool maybeThrowIcuException(JNIEnv* env, UErrorCode error);
+bool maybeThrowIcuException(JNIEnv* env, const char* function, UErrorCode error);
 
 #endif  // JNI_EXCEPTION_H_included
diff --git a/luni/src/main/native/java_text_Bidi.cpp b/luni/src/main/native/java_text_Bidi.cpp
index 93c02bb..01bca09 100644
--- a/luni/src/main/native/java_text_Bidi.cpp
+++ b/luni/src/main/native/java_text_Bidi.cpp
@@ -88,18 +88,18 @@ static void Bidi_ubidi_setPara(JNIEnv* env, jclass, jlong ptr, jcharArray text,
     }
     UErrorCode err = U_ZERO_ERROR;
     ubidi_setPara(data->uBiDi(), chars.get(), length, paraLevel, data->embeddingLevels(), &err);
-    maybeThrowIcuException(env, err);
+    maybeThrowIcuException(env, "ubidi_setPara", err);
 }
 
 static jlong Bidi_ubidi_setLine(JNIEnv* env, jclass, jlong ptr, jint start, jint limit) {
     UErrorCode status = U_ZERO_ERROR;
     UBiDi* sized = ubidi_openSized(limit - start, 0, &status);
-    if (maybeThrowIcuException(env, status)) {
+    if (maybeThrowIcuException(env, "ubidi_openSized", status)) {
         return 0;
     }
     UniquePtr<BiDiData> lineData(new BiDiData(sized));
     ubidi_setLine(uBiDi(ptr), start, limit, lineData->uBiDi(), &status);
-    maybeThrowIcuException(env, status);
+    maybeThrowIcuException(env, "ubidi_setLine", status);
     return reinterpret_cast<uintptr_t>(lineData.release());
 }
 
@@ -118,7 +118,7 @@ static jbyte Bidi_ubidi_getParaLevel(JNIEnv*, jclass, jlong ptr) {
 static jbyteArray Bidi_ubidi_getLevels(JNIEnv* env, jclass, jlong ptr) {
     UErrorCode status = U_ZERO_ERROR;
     const UBiDiLevel* levels = ubidi_getLevels(uBiDi(ptr), &status);
-    if (maybeThrowIcuException(env, status)) {
+    if (maybeThrowIcuException(env, "ubidi_getLevels", status)) {
         return NULL;
     }
     int len = ubidi_getLength(uBiDi(ptr));
@@ -130,7 +130,7 @@ static jbyteArray Bidi_ubidi_getLevels(JNIEnv* env, jclass, jlong ptr) {
 static jint Bidi_ubidi_countRuns(JNIEnv* env, jclass, jlong ptr) {
     UErrorCode status = U_ZERO_ERROR;
     int count = ubidi_countRuns(uBiDi(ptr), &status);
-    maybeThrowIcuException(env, status);
+    maybeThrowIcuException(env, "ubidi_countRuns", status);
     return count;
 }
 
@@ -141,7 +141,7 @@ static jobjectArray Bidi_ubidi_getRuns(JNIEnv* env, jclass, jlong ptr) {
     UBiDi* ubidi = uBiDi(ptr);
     UErrorCode status = U_ZERO_ERROR;
     int runCount = ubidi_countRuns(ubidi, &status);
-    if (maybeThrowIcuException(env, status)) {
+    if (maybeThrowIcuException(env, "ubidi_countRuns", status)) {
         return NULL;
     }
     jmethodID bidiRunConstructor = env->GetMethodID(JniConstants::bidiRunClass, "<init>", "(III)V");
diff --git a/luni/src/main/native/java_util_regex_Matcher.cpp b/luni/src/main/native/java_util_regex_Matcher.cpp
index 0f91bd5..6116d2b 100644
--- a/luni/src/main/native/java_util_regex_Matcher.cpp
+++ b/luni/src/main/native/java_util_regex_Matcher.cpp
@@ -71,7 +71,7 @@ public:
         if (mJavaInput) {
             mEnv->ReleaseStringChars(mJavaInput, mChars);
         }
-        maybeThrowIcuException(mEnv, mStatus);
+        maybeThrowIcuException(mEnv, "utext_close", mStatus);
     }
 
     RegexMatcher* operator->() {
@@ -173,7 +173,7 @@ static jint Matcher_openImpl(JNIEnv* env, jclass, jint patternAddr) {
     RegexPattern* pattern = reinterpret_cast<RegexPattern*>(static_cast<uintptr_t>(patternAddr));
     UErrorCode status = U_ZERO_ERROR;
     RegexMatcher* result = pattern->matcher(status);
-    maybeThrowIcuException(env, status);
+    maybeThrowIcuException(env, "RegexPattern::matcher", status);
     return static_cast<jint>(reinterpret_cast<uintptr_t>(result));
 }
 
diff --git a/luni/src/main/native/libcore_icu_ICU.cpp b/luni/src/main/native/libcore_icu_ICU.cpp
index 5a07694..26e3e89 100644
--- a/luni/src/main/native/libcore_icu_ICU.cpp
+++ b/luni/src/main/native/libcore_icu_ICU.cpp
@@ -543,9 +543,12 @@ static jobject ICU_getAvailableCurrencyCodes(JNIEnv* env, jclass) {
     UErrorCode status = U_ZERO_ERROR;
     UEnumeration* e(ucurr_openISOCurrencies(UCURR_COMMON|UCURR_NON_DEPRECATED, &status));
     EnumerationCounter counter(uenum_count(e, &status));
+    if (maybeThrowIcuException(env, "uenum_count", status)) {
+        return NULL;
+    }
     EnumerationGetter getter(e, &status);
     jobject result = toStringArray16(env, &counter, &getter);
-    maybeThrowIcuException(env, status);
+    maybeThrowIcuException(env, "uenum_unext", status);
     uenum_close(e);
     return result;
 }
diff --git a/luni/src/main/native/libcore_icu_NativeBreakIterator.cpp b/luni/src/main/native/libcore_icu_NativeBreakIterator.cpp
index d93c229..5865081 100644
--- a/luni/src/main/native/libcore_icu_NativeBreakIterator.cpp
+++ b/luni/src/main/native/libcore_icu_NativeBreakIterator.cpp
@@ -55,14 +55,14 @@ public:
         size_t charCount = env->GetStringLength(mString);
         UErrorCode status = U_ZERO_ERROR;
         ubrk_setText(mIt, mChars, charCount, &status);
-        maybeThrowIcuException(env, status);
+        maybeThrowIcuException(env, "ubrk_setText", status);
     }
 
     BreakIteratorPeer* clone(JNIEnv* env) {
         UErrorCode status = U_ZERO_ERROR;
         jint bufferSize = U_BRK_SAFECLONE_BUFFERSIZE;
         UBreakIterator* it = ubrk_safeClone(mIt, NULL, &bufferSize, &status);
-        if (maybeThrowIcuException(env, status)) {
+        if (maybeThrowIcuException(env, "ubrk_safeClone", status)) {
             return NULL;
         }
         BreakIteratorPeer* result = new BreakIteratorPeer(it);
@@ -120,7 +120,7 @@ static jint makeIterator(JNIEnv* env, jstring locale, UBreakIteratorType type) {
         return 0;
     }
     UBreakIterator* it = ubrk_open(type, localeChars.c_str(), NULL, 0, &status);
-    if (maybeThrowIcuException(env, status)) {
+    if (maybeThrowIcuException(env, "ubrk_open", status)) {
         return 0;
     }
     return (new BreakIteratorPeer(it))->toAddress();
diff --git a/luni/src/main/native/libcore_icu_NativeCollation.cpp b/luni/src/main/native/libcore_icu_NativeCollation.cpp
index 3ed49e9..32b1cc4 100644
--- a/luni/src/main/native/libcore_icu_NativeCollation.cpp
+++ b/luni/src/main/native/libcore_icu_NativeCollation.cpp
@@ -50,7 +50,7 @@ static jint NativeCollation_compare(JNIEnv* env, jclass, jint address, jstring j
 static jint NativeCollation_getAttribute(JNIEnv* env, jclass, jint address, jint type) {
     UErrorCode status = U_ZERO_ERROR;
     jint result = ucol_getAttribute(toCollator(address), (UColAttribute) type, &status);
-    maybeThrowIcuException(env, status);
+    maybeThrowIcuException(env, "ucol_getAttribute", status);
     return result;
 }
 
@@ -61,7 +61,7 @@ static jint NativeCollation_getCollationElementIterator(JNIEnv* env, jclass, jin
     }
     UErrorCode status = U_ZERO_ERROR;
     UCollationElements* result = ucol_openElements(toCollator(address), source.get(), source.size(), &status);
-    maybeThrowIcuException(env, status);
+    maybeThrowIcuException(env, "ucol_openElements", status);
     return static_cast<jint>(reinterpret_cast<uintptr_t>(result));
 }
 
@@ -106,7 +106,7 @@ static jbyteArray NativeCollation_getSortKey(JNIEnv* env, jclass, jint address,
 static jint NativeCollation_next(JNIEnv* env, jclass, jint address) {
     UErrorCode status = U_ZERO_ERROR;
     jint result = ucol_next(toCollationElements(address), &status);
-    maybeThrowIcuException(env, status);
+    maybeThrowIcuException(env, "ucol_next", status);
     return result;
 }
 
@@ -117,7 +117,7 @@ static jint NativeCollation_openCollator(JNIEnv* env, jclass, jstring localeName
     }
     UErrorCode status = U_ZERO_ERROR;
     UCollator* c = ucol_open(localeChars.c_str(), &status);
-    maybeThrowIcuException(env, status);
+    maybeThrowIcuException(env, "ucol_open", status);
     return static_cast<jint>(reinterpret_cast<uintptr_t>(c));
 }
 
@@ -129,14 +129,14 @@ static jint NativeCollation_openCollatorFromRules(JNIEnv* env, jclass, jstring j
     UErrorCode status = U_ZERO_ERROR;
     UCollator* c = ucol_openRules(rules.get(), rules.size(),
             UColAttributeValue(mode), UCollationStrength(strength), NULL, &status);
-    maybeThrowIcuException(env, status);
+    maybeThrowIcuException(env, "ucol_openRules", status);
     return static_cast<jint>(reinterpret_cast<uintptr_t>(c));
 }
 
 static jint NativeCollation_previous(JNIEnv* env, jclass, jint address) {
     UErrorCode status = U_ZERO_ERROR;
     jint result = ucol_previous(toCollationElements(address), &status);
-    maybeThrowIcuException(env, status);
+    maybeThrowIcuException(env, "ucol_previous", status);
     return result;
 }
 
@@ -148,20 +148,20 @@ static jint NativeCollation_safeClone(JNIEnv* env, jclass, jint address) {
     UErrorCode status = U_ZERO_ERROR;
     jint bufferSize = U_COL_SAFECLONE_BUFFERSIZE;
     UCollator* c = ucol_safeClone(toCollator(address), NULL, &bufferSize, &status);
-    maybeThrowIcuException(env, status);
+    maybeThrowIcuException(env, "ucol_safeClone", status);
     return static_cast<jint>(reinterpret_cast<uintptr_t>(c));
 }
 
 static void NativeCollation_setAttribute(JNIEnv* env, jclass, jint address, jint type, jint value) {
     UErrorCode status = U_ZERO_ERROR;
     ucol_setAttribute(toCollator(address), (UColAttribute)type, (UColAttributeValue)value, &status);
-    maybeThrowIcuException(env, status);
+    maybeThrowIcuException(env, "ucol_setAttribute", status);
 }
 
 static void NativeCollation_setOffset(JNIEnv* env, jclass, jint address, jint offset) {
     UErrorCode status = U_ZERO_ERROR;
     ucol_setOffset(toCollationElements(address), offset, &status);
-    maybeThrowIcuException(env, status);
+    maybeThrowIcuException(env, "ucol_setOffset", status);
 }
 
 static void NativeCollation_setText(JNIEnv* env, jclass, jint address, jstring javaSource) {
@@ -171,7 +171,7 @@ static void NativeCollation_setText(JNIEnv* env, jclass, jint address, jstring j
     }
     UErrorCode status = U_ZERO_ERROR;
     ucol_setText(toCollationElements(address), source.get(), source.size(), &status);
-    maybeThrowIcuException(env, status);
+    maybeThrowIcuException(env, "ucol_setText", status);
 }
 
 static JNINativeMethod gMethods[] = {
diff --git a/luni/src/main/native/libcore_icu_NativeConverter.cpp b/luni/src/main/native/libcore_icu_NativeConverter.cpp
index 5b3761e..6b08ee0 100644
--- a/luni/src/main/native/libcore_icu_NativeConverter.cpp
+++ b/luni/src/main/native/libcore_icu_NativeConverter.cpp
@@ -74,7 +74,7 @@ static jlong NativeConverter_openConverter(JNIEnv* env, jclass, jstring converte
     }
     UErrorCode status = U_ZERO_ERROR;
     UConverter* cnv = ucnv_open(converterNameChars.c_str(), &status);
-    maybeThrowIcuException(env, status);
+    maybeThrowIcuException(env, "ucnv_open", status);
     return reinterpret_cast<uintptr_t>(cnv);
 }
 
@@ -82,24 +82,36 @@ static void NativeConverter_closeConverter(JNIEnv*, jclass, jlong address) {
     ucnv_close(toUConverter(address));
 }
 
+static bool shouldCodecThrow(jboolean flush, UErrorCode error) {
+    if (flush) {
+        return (error != U_BUFFER_OVERFLOW_ERROR && error != U_TRUNCATED_CHAR_FOUND);
+    } else {
+        return (error != U_BUFFER_OVERFLOW_ERROR && error != U_INVALID_CHAR_FOUND && error != U_ILLEGAL_CHAR_FOUND);
+    }
+}
+
 static jint NativeConverter_encode(JNIEnv* env, jclass, jlong address,
         jcharArray source, jint sourceEnd, jbyteArray target, jint targetEnd,
         jintArray data, jboolean flush) {
 
     UConverter* cnv = toUConverter(address);
     if (cnv == NULL) {
+        maybeThrowIcuException(env, "toUConverter", U_ILLEGAL_ARGUMENT_ERROR);
         return U_ILLEGAL_ARGUMENT_ERROR;
     }
     ScopedCharArrayRO uSource(env, source);
     if (uSource.get() == NULL) {
+        maybeThrowIcuException(env, "uSource", U_ILLEGAL_ARGUMENT_ERROR);
         return U_ILLEGAL_ARGUMENT_ERROR;
     }
     ScopedByteArrayRW uTarget(env, target);
     if (uTarget.get() == NULL) {
+        maybeThrowIcuException(env, "uTarget", U_ILLEGAL_ARGUMENT_ERROR);
         return U_ILLEGAL_ARGUMENT_ERROR;
     }
     ScopedIntArrayRW myData(env, data);
     if (myData.get() == NULL) {
+        maybeThrowIcuException(env, "myData", U_ILLEGAL_ARGUMENT_ERROR);
         return U_ILLEGAL_ARGUMENT_ERROR;
     }
 
@@ -125,6 +137,11 @@ static jint NativeConverter_encode(JNIEnv* env, jclass, jlong address,
             myData[2] = invalidUCharCount;
         }
     }
+
+    // Managed code handles some cases; throw all other errors.
+    if (shouldCodecThrow(flush, errorCode)) {
+        maybeThrowIcuException(env, "ucnv_fromUnicode", errorCode);
+    }
     return errorCode;
 }
 
@@ -134,18 +151,22 @@ static jint NativeConverter_decode(JNIEnv* env, jclass, jlong address,
 
     UConverter* cnv = toUConverter(address);
     if (cnv == NULL) {
+        maybeThrowIcuException(env, "toUConverter", U_ILLEGAL_ARGUMENT_ERROR);
         return U_ILLEGAL_ARGUMENT_ERROR;
     }
     ScopedByteArrayRO uSource(env, source);
     if (uSource.get() == NULL) {
+        maybeThrowIcuException(env, "uSource", U_ILLEGAL_ARGUMENT_ERROR);
         return U_ILLEGAL_ARGUMENT_ERROR;
     }
     ScopedCharArrayRW uTarget(env, target);
     if (uTarget.get() == NULL) {
+        maybeThrowIcuException(env, "uTarget", U_ILLEGAL_ARGUMENT_ERROR);
         return U_ILLEGAL_ARGUMENT_ERROR;
     }
     ScopedIntArrayRW myData(env, data);
     if (myData.get() == NULL) {
+        maybeThrowIcuException(env, "myData", U_ILLEGAL_ARGUMENT_ERROR);
         return U_ILLEGAL_ARGUMENT_ERROR;
     }
 
@@ -172,6 +193,10 @@ static jint NativeConverter_decode(JNIEnv* env, jclass, jlong address,
         }
     }
 
+    // Managed code handles some cases; throw all other errors.
+    if (shouldCodecThrow(flush, errorCode)) {
+        maybeThrowIcuException(env, "ucnv_toUnicode", errorCode);
+    }
     return errorCode;
 }
 
@@ -387,11 +412,12 @@ static UConverterFromUCallback getFromUCallback(int32_t mode) {
     abort();
 }
 
-static jint NativeConverter_setCallbackEncode(JNIEnv* env, jclass, jlong address,
+static void NativeConverter_setCallbackEncode(JNIEnv* env, jclass, jlong address,
         jint onMalformedInput, jint onUnmappableInput, jbyteArray javaReplacement) {
     UConverter* cnv = toUConverter(address);
-    if (!cnv) {
-        return U_ILLEGAL_ARGUMENT_ERROR;
+    if (cnv == NULL) {
+        maybeThrowIcuException(env, "toUConverter", U_ILLEGAL_ARGUMENT_ERROR);
+        return;
     }
 
     UConverterFromUCallback oldCallback = NULL;
@@ -409,14 +435,15 @@ static jint NativeConverter_setCallbackEncode(JNIEnv* env, jclass, jlong address
 
     ScopedByteArrayRO replacementBytes(env, javaReplacement);
     if (replacementBytes.get() == NULL) {
-        return U_ILLEGAL_ARGUMENT_ERROR;
+        maybeThrowIcuException(env, "replacementBytes", U_ILLEGAL_ARGUMENT_ERROR);
+        return;
     }
     memcpy(callbackContext->replacementBytes, replacementBytes.get(), replacementBytes.size());
     callbackContext->replacementByteCount = replacementBytes.size();
 
     UErrorCode errorCode = U_ZERO_ERROR;
     ucnv_setFromUCallBack(cnv, CHARSET_ENCODER_CALLBACK, callbackContext, NULL, NULL, &errorCode);
-    return errorCode;
+    maybeThrowIcuException(env, "ucnv_setFromUCallBack", errorCode);
 }
 
 static void decoderIgnoreCallback(const void*, UConverterToUnicodeArgs*, const char*, int32_t, UConverterCallbackReason, UErrorCode* err) {
@@ -469,11 +496,12 @@ static void CHARSET_DECODER_CALLBACK(const void* rawContext, UConverterToUnicode
     }
 }
 
-static jint NativeConverter_setCallbackDecode(JNIEnv* env, jclass, jlong address,
+static void NativeConverter_setCallbackDecode(JNIEnv* env, jclass, jlong address,
         jint onMalformedInput, jint onUnmappableInput, jstring javaReplacement) {
     UConverter* cnv = toUConverter(address);
     if (cnv == NULL) {
-        return U_ILLEGAL_ARGUMENT_ERROR;
+        maybeThrowIcuException(env, "toConverter", U_ILLEGAL_ARGUMENT_ERROR);
+        return;
     }
 
     UConverterToUCallback oldCallback;
@@ -491,14 +519,15 @@ static jint NativeConverter_setCallbackDecode(JNIEnv* env, jclass, jlong address
 
     ScopedStringChars replacement(env, javaReplacement);
     if (replacement.get() == NULL) {
-        return U_ILLEGAL_ARGUMENT_ERROR;
+        maybeThrowIcuException(env, "replacement", U_ILLEGAL_ARGUMENT_ERROR);
+        return;
     }
     u_strncpy(callbackContext->replacementChars, replacement.get(), replacement.size());
     callbackContext->replacementCharCount = replacement.size();
 
     UErrorCode errorCode = U_ZERO_ERROR;
     ucnv_setToUCallBack(cnv, CHARSET_DECODER_CALLBACK, callbackContext, NULL, NULL, &errorCode);
-    return errorCode;
+    maybeThrowIcuException(env, "ucnv_setToUCallBack", errorCode);
 }
 
 static jfloat NativeConverter_getAveCharsPerByte(JNIEnv* env, jclass, jlong handle) {
@@ -605,8 +634,8 @@ static JNINativeMethod gMethods[] = {
     NATIVE_METHOD(NativeConverter, openConverter, "(Ljava/lang/String;)J"),
     NATIVE_METHOD(NativeConverter, resetByteToChar, "(J)V"),
     NATIVE_METHOD(NativeConverter, resetCharToByte, "(J)V"),
-    NATIVE_METHOD(NativeConverter, setCallbackDecode, "(JIILjava/lang/String;)I"),
-    NATIVE_METHOD(NativeConverter, setCallbackEncode, "(JII[B)I"),
+    NATIVE_METHOD(NativeConverter, setCallbackDecode, "(JIILjava/lang/String;)V"),
+    NATIVE_METHOD(NativeConverter, setCallbackEncode, "(JII[B)V"),
 };
 void register_libcore_icu_NativeConverter(JNIEnv* env) {
     jniRegisterNativeMethods(env, "libcore/icu/NativeConverter", gMethods, NELEM(gMethods));
diff --git a/luni/src/main/native/libcore_icu_NativeDecimalFormat.cpp b/luni/src/main/native/libcore_icu_NativeDecimalFormat.cpp
index 1fe4055..dead1a8 100644
--- a/luni/src/main/native/libcore_icu_NativeDecimalFormat.cpp
+++ b/luni/src/main/native/libcore_icu_NativeDecimalFormat.cpp
@@ -122,7 +122,7 @@ static jint NativeDecimalFormat_open(JNIEnv* env, jclass, jstring pattern0,
     if (fmt == NULL) {
         delete symbols;
     }
-    maybeThrowIcuException(env, status);
+    maybeThrowIcuException(env, "DecimalFormat::DecimalFormat", status);
     return static_cast<jint>(reinterpret_cast<uintptr_t>(fmt));
 }
 
@@ -144,7 +144,7 @@ static void NativeDecimalFormat_setSymbol(JNIEnv* env, jclass, jint addr, jint j
     UErrorCode status = U_ZERO_ERROR;
     UNumberFormatSymbol symbol = static_cast<UNumberFormatSymbol>(javaSymbol);
     unum_setSymbol(toUNumberFormat(addr), symbol, value.get(), value.size(), &status);
-    maybeThrowIcuException(env, status);
+    maybeThrowIcuException(env, "unum_setSymbol", status);
 }
 
 static void NativeDecimalFormat_setAttribute(JNIEnv*, jclass, jint addr, jint javaAttr, jint value) {
@@ -165,7 +165,7 @@ static void NativeDecimalFormat_setTextAttribute(JNIEnv* env, jclass, jint addr,
     UErrorCode status = U_ZERO_ERROR;
     UNumberFormatTextAttribute attr = static_cast<UNumberFormatTextAttribute>(javaAttr);
     unum_setTextAttribute(toUNumberFormat(addr), attr, value.get(), value.size(), &status);
-    maybeThrowIcuException(env, status);
+    maybeThrowIcuException(env, "unum_setTextAttribute", status);
 }
 
 static jstring NativeDecimalFormat_getTextAttribute(JNIEnv* env, jclass, jint addr, jint javaAttr) {
@@ -184,7 +184,7 @@ static jstring NativeDecimalFormat_getTextAttribute(JNIEnv* env, jclass, jint ad
         chars.reset(new UChar[charCount]);
         charCount = unum_getTextAttribute(fmt, attr, chars.get(), charCount, &status);
     }
-    return maybeThrowIcuException(env, status) ? NULL : env->NewString(chars.get(), charCount);
+    return maybeThrowIcuException(env, "unum_getTextAttribute", status) ? NULL : env->NewString(chars.get(), charCount);
 }
 
 static void NativeDecimalFormat_applyPatternImpl(JNIEnv* env, jclass, jint addr, jboolean localized, jstring pattern0) {
@@ -195,12 +195,15 @@ static void NativeDecimalFormat_applyPatternImpl(JNIEnv* env, jclass, jint addr,
     ScopedJavaUnicodeString pattern(env, pattern0);
     DecimalFormat* fmt = toDecimalFormat(addr);
     UErrorCode status = U_ZERO_ERROR;
+    const char* function;
     if (localized) {
+        function = "DecimalFormat::applyLocalizedPattern";
         fmt->applyLocalizedPattern(pattern.unicodeString(), status);
     } else {
+        function = "DecimalFormat::applyPattern";
         fmt->applyPattern(pattern.unicodeString(), status);
     }
-    maybeThrowIcuException(env, status);
+    maybeThrowIcuException(env, function, status);
 }
 
 static jstring NativeDecimalFormat_toPatternImpl(JNIEnv* env, jclass, jint addr, jboolean localized) {
diff --git a/luni/src/main/native/libcore_icu_NativeNormalizer.cpp b/luni/src/main/native/libcore_icu_NativeNormalizer.cpp
index 58f460c..693e944 100644
--- a/luni/src/main/native/libcore_icu_NativeNormalizer.cpp
+++ b/luni/src/main/native/libcore_icu_NativeNormalizer.cpp
@@ -28,7 +28,7 @@ static jstring NativeNormalizer_normalizeImpl(JNIEnv* env, jclass, jstring s, ji
     UErrorCode status = U_ZERO_ERROR;
     UnicodeString dst;
     Normalizer::normalize(src.unicodeString(), mode, 0, dst, status);
-    maybeThrowIcuException(env, status);
+    maybeThrowIcuException(env, "Normalizer::normalize", status);
     return dst.isBogus() ? NULL : env->NewString(dst.getBuffer(), dst.length());
 }
 
@@ -37,7 +37,7 @@ static jboolean NativeNormalizer_isNormalizedImpl(JNIEnv* env, jclass, jstring s
     UNormalizationMode mode = static_cast<UNormalizationMode>(intMode);
     UErrorCode status = U_ZERO_ERROR;
     UBool result = Normalizer::isNormalized(src.unicodeString(), mode, status);
-    maybeThrowIcuException(env, status);
+    maybeThrowIcuException(env, "Normalizer::isNormalized", status);
     return result;
 }
 
diff --git a/luni/src/main/native/libcore_icu_NativePluralRules.cpp b/luni/src/main/native/libcore_icu_NativePluralRules.cpp
index a7164d0..df228ff 100644
--- a/luni/src/main/native/libcore_icu_NativePluralRules.cpp
+++ b/luni/src/main/native/libcore_icu_NativePluralRules.cpp
@@ -34,7 +34,7 @@ static jint NativePluralRules_forLocaleImpl(JNIEnv* env, jclass, jstring localeN
     Locale locale = Locale::createFromName(ScopedUtfChars(env, localeName).c_str());
     UErrorCode status = U_ZERO_ERROR;
     PluralRules* result = PluralRules::forLocale(locale, status);
-    maybeThrowIcuException(env, status);
+    maybeThrowIcuException(env, "PluralRules::forLocale", status);
     return reinterpret_cast<uintptr_t>(result);
 }
 
diff --git a/luni/src/main/native/libcore_icu_TimeZones.cpp b/luni/src/main/native/libcore_icu_TimeZones.cpp
index b543238..15c18c5 100644
--- a/luni/src/main/native/libcore_icu_TimeZones.cpp
+++ b/luni/src/main/native/libcore_icu_TimeZones.cpp
@@ -43,14 +43,14 @@ static jobjectArray TimeZones_forCountryCode(JNIEnv* env, jclass, jstring countr
     }
     UErrorCode status = U_ZERO_ERROR;
     int32_t idCount = ids->count(status);
-    if (maybeThrowIcuException(env, status)) {
+    if (maybeThrowIcuException(env, "StringEnumeration::count", status)) {
         return NULL;
     }
 
     jobjectArray result = env->NewObjectArray(idCount, JniConstants::stringClass, NULL);
     for (int32_t i = 0; i < idCount; ++i) {
         const UnicodeString* id = ids->snext(status);
-        if (maybeThrowIcuException(env, status)) {
+        if (maybeThrowIcuException(env, "StringEnumeration::snext", status)) {
             return NULL;
         }
         ScopedLocalRef<jstring> idString(env, env->NewString(id->getBuffer(), id->length()));
-- 
cgit v1.1


From fc7d051b4a8a79687a13228184f03a82270b262b Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Mon, 23 Jul 2012 17:21:12 -0700
Subject: Provider should enumerate services in the order they are added

Bug: http://code.google.com/p/android/issues/detail?id=21449
Change-Id: Ie520a8b47adab0583ed1c5cb0da7f43c2eb452ee
---
 luni/src/main/java/java/security/Provider.java     |  85 ++--
 .../apache/harmony/luni/util/TwoKeyHashMap.java    | 566 ---------------------
 .../java/libcore/java/security/ProviderTest.java   |  52 +-
 3 files changed, 95 insertions(+), 608 deletions(-)
 delete mode 100644 luni/src/main/java/org/apache/harmony/luni/util/TwoKeyHashMap.java

diff --git a/luni/src/main/java/java/security/Provider.java b/luni/src/main/java/java/security/Provider.java
index 2de3751..018e268 100644
--- a/luni/src/main/java/java/security/Provider.java
+++ b/luni/src/main/java/java/security/Provider.java
@@ -27,12 +27,13 @@ import java.util.Enumeration;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.Properties;
 import java.util.Set;
-import org.apache.harmony.luni.util.TwoKeyHashMap;
 import org.apache.harmony.security.fortress.Services;
 
 /**
@@ -57,18 +58,18 @@ public abstract class Provider extends Properties {
 
     // Contains "Service.Algorithm" and Provider.Service classes added using
     // putService()
-    private transient TwoKeyHashMap<String, String, Service> serviceTable;
+    private transient LinkedHashMap<String, Service> serviceTable;
 
     // Contains "Service.Alias" and Provider.Service classes added using
     // putService()
-    private transient TwoKeyHashMap<String, String, Service> aliasTable;
+    private transient LinkedHashMap<String, Service> aliasTable;
 
     // Contains "Service.Algorithm" and Provider.Service classes added using
     // put()
-    private transient TwoKeyHashMap<String, String, Service> propertyServiceTable;
+    private transient LinkedHashMap<String, Service> propertyServiceTable;
 
     // Contains "Service.Alias" and Provider.Service classes added using put()
-    private transient TwoKeyHashMap<String, String, Service> propertyAliasTable;
+    private transient LinkedHashMap<String, Service> propertyAliasTable;
 
     // The properties changed via put()
     private transient Properties changedProperties;
@@ -414,22 +415,22 @@ public abstract class Provider extends Properties {
             return returnedService;
         }
 
-        String alg = algorithm.toUpperCase(Locale.US);
+        String key = key(type, algorithm);
         Object o = null;
         if (serviceTable != null) {
-            o = serviceTable.get(type, alg);
+            o = serviceTable.get(key);
         }
         if (o == null && aliasTable != null) {
-            o = aliasTable.get(type, alg);
+            o = aliasTable.get(key);
         }
         if (o == null) {
             updatePropertyServiceTable();
         }
         if (o == null && propertyServiceTable != null) {
-            o = propertyServiceTable.get(type, alg);
+            o = propertyServiceTable.get(key);
         }
         if (o == null && propertyAliasTable != null) {
-            o = propertyAliasTable.get(type, alg);
+            o = propertyAliasTable.get(key);
         }
 
         if (o != null) {
@@ -454,9 +455,9 @@ public abstract class Provider extends Properties {
             return lastServicesSet;
         }
         if (serviceTable != null) {
-            lastServicesSet = new HashSet<Service>(serviceTable.values());
+            lastServicesSet = new LinkedHashSet<Service>(serviceTable.values());
         } else {
-            lastServicesSet = new HashSet<Service>();
+            lastServicesSet = new LinkedHashSet<Service>();
         }
         if (propertyServiceTable != null) {
             lastServicesSet.addAll(propertyServiceTable.values());
@@ -481,15 +482,15 @@ public abstract class Provider extends Properties {
         }
         servicesChanged();
         if (serviceTable == null) {
-            serviceTable = new TwoKeyHashMap<String, String, Service>(128);
+            serviceTable = new LinkedHashMap<String, Service>(128);
         }
-        serviceTable.put(s.type, s.algorithm.toUpperCase(Locale.US), s);
+        serviceTable.put(key(s.type, s.algorithm), s);
         if (s.aliases != null) {
             if (aliasTable == null) {
-                aliasTable = new TwoKeyHashMap<String, String, Service>(256);
+                aliasTable = new LinkedHashMap<String, Service>(256);
             }
             for (String alias : s.getAliases()) {
-                aliasTable.put(s.type, alias.toUpperCase(Locale.US), s);
+                aliasTable.put(key(s.type, alias), s);
             }
         }
         serviceInfoToProperties(s);
@@ -510,11 +511,11 @@ public abstract class Provider extends Properties {
         }
         servicesChanged();
         if (serviceTable != null) {
-            serviceTable.remove(s.type, s.algorithm.toUpperCase(Locale.US));
+            serviceTable.remove(key(s.type, s.algorithm));
         }
         if (aliasTable != null && s.aliases != null) {
             for (String alias: s.getAliases()) {
-                aliasTable.remove(s.type, alias.toUpperCase(Locale.US));
+                aliasTable.remove(key(s.type, alias));
             }
         }
         serviceInfoFromProperties(s);
@@ -584,7 +585,7 @@ public abstract class Provider extends Properties {
             serviceName = service_alias.substring(0, i);
             aliasName = service_alias.substring(i + 1);
             if (propertyAliasTable != null) {
-                propertyAliasTable.remove(serviceName, aliasName.toUpperCase(Locale.US));
+                propertyAliasTable.remove(key(serviceName, aliasName));
             }
             if (propertyServiceTable != null) {
                 for (Iterator<Service> it = propertyServiceTable.values().iterator(); it
@@ -608,12 +609,11 @@ public abstract class Provider extends Properties {
             serviceName = k.substring(0, j);
             algorithm = k.substring(j + 1);
             if (propertyServiceTable != null) {
-                Provider.Service ser = propertyServiceTable.remove(serviceName,
-                        algorithm.toUpperCase(Locale.US));
+                Provider.Service ser = propertyServiceTable.remove(key(serviceName, algorithm));
                 if (ser != null && propertyAliasTable != null
                         && ser.aliases != null) {
                     for (String alias : ser.aliases) {
-                        propertyAliasTable.remove(serviceName, alias.toUpperCase(Locale.US));
+                        propertyAliasTable.remove(key(serviceName, alias));
                     }
                 }
             }
@@ -624,7 +624,7 @@ public abstract class Provider extends Properties {
             serviceName = k.substring(0, j);
             algorithm = k.substring(j + 1, i);
             if (propertyServiceTable != null) {
-                Object o = propertyServiceTable.get(serviceName, algorithm.toUpperCase(Locale.US));
+                Object o = propertyServiceTable.get(key(serviceName, algorithm));
                 if (o != null) {
                     s = (Provider.Service) o;
                     s.attributes.remove(attribute);
@@ -667,20 +667,20 @@ public abstract class Provider extends Properties {
                 serviceName = service_alias.substring(0, i);
                 aliasName = service_alias.substring(i + 1);
                 algorithm = value;
-                String algUp = algorithm.toUpperCase(Locale.US);
+                String propertyServiceTableKey = key(serviceName, algorithm);
                 Object o = null;
                 if (propertyServiceTable == null) {
-                    propertyServiceTable = new TwoKeyHashMap<String, String, Service>(128);
+                    propertyServiceTable = new LinkedHashMap<String, Service>(128);
                 } else {
-                    o = propertyServiceTable.get(serviceName, algUp);
+                    o = propertyServiceTable.get(propertyServiceTableKey);
                 }
                 if (o != null) {
                     s = (Provider.Service) o;
                     s.addAlias(aliasName);
                     if (propertyAliasTable == null) {
-                        propertyAliasTable = new TwoKeyHashMap<String, String, Service>(256);
+                        propertyAliasTable = new LinkedHashMap<String, Service>(256);
                     }
-                    propertyAliasTable.put(serviceName, aliasName.toUpperCase(Locale.US), s);
+                    propertyAliasTable.put(key(serviceName, aliasName), s);
                 } else {
                     String className = (String) changedProperties
                             .get(serviceName + "." + algorithm);
@@ -689,11 +689,11 @@ public abstract class Provider extends Properties {
                         l.add(aliasName);
                         s = new Provider.Service(this, serviceName, algorithm,
                                 className, l, new HashMap<String, String>());
-                        propertyServiceTable.put(serviceName, algUp, s);
+                        propertyServiceTable.put(propertyServiceTableKey, s);
                         if (propertyAliasTable == null) {
-                            propertyAliasTable = new TwoKeyHashMap<String, String, Service>(256);
+                            propertyAliasTable = new LinkedHashMap<String, Service>(256);
                         }
-                        propertyAliasTable.put(serviceName, aliasName.toUpperCase(Locale.US), s);
+                        propertyAliasTable.put(key(serviceName, aliasName), s);
                     }
                 }
                 continue;
@@ -706,10 +706,10 @@ public abstract class Provider extends Properties {
             if (i == -1) { // <crypto_service>.<algorithm_or_type>=<className>
                 serviceName = key.substring(0, j);
                 algorithm = key.substring(j + 1);
-                String alg = algorithm.toUpperCase(Locale.US);
+                String propertyServiceTableKey = key(serviceName, algorithm);
                 Object o = null;
                 if (propertyServiceTable != null) {
-                    o = propertyServiceTable.get(serviceName, alg);
+                    o = propertyServiceTable.get(propertyServiceTableKey);
                 }
                 if (o != null) {
                     s = (Provider.Service) o;
@@ -719,21 +719,20 @@ public abstract class Provider extends Properties {
                             value, Collections.<String>emptyList(),
                             Collections.<String,String>emptyMap());
                     if (propertyServiceTable == null) {
-                        propertyServiceTable = new TwoKeyHashMap<String, String, Service>(128);
+                        propertyServiceTable = new LinkedHashMap<String, Service>(128);
                     }
-                    propertyServiceTable.put(serviceName, alg, s);
+                    propertyServiceTable.put(propertyServiceTableKey, s);
 
                 }
             } else {
-                // <crypto_service>.<algorithm_or_type>
-                // <attribute_name>=<attrValue>
+                // <crypto_service>.<algorithm_or_type> <attribute_name>=<attrValue>
                 serviceName = key.substring(0, j);
                 algorithm = key.substring(j + 1, i);
                 String attribute = key.substring(i + 1);
-                String alg = algorithm.toUpperCase(Locale.US);
+                String propertyServiceTableKey = key(serviceName, algorithm);
                 Object o = null;
                 if (propertyServiceTable != null) {
-                    o = propertyServiceTable.get(serviceName, alg);
+                    o = propertyServiceTable.get(propertyServiceTableKey);
                 }
                 if (o != null) {
                     s = (Provider.Service) o;
@@ -747,9 +746,9 @@ public abstract class Provider extends Properties {
                         s = new Provider.Service(this, serviceName, algorithm,
                                 className, new ArrayList<String>(), m);
                         if (propertyServiceTable == null) {
-                            propertyServiceTable = new TwoKeyHashMap<String, String, Service>(128);
+                            propertyServiceTable = new LinkedHashMap<String, Service>(128);
                         }
-                        propertyServiceTable.put(serviceName, alg, s);
+                        propertyServiceTable.put(propertyServiceTableKey, s);
                     }
                 }
             }
@@ -794,6 +793,10 @@ public abstract class Provider extends Properties {
         return null;
     }
 
+    private static String key(String type, String algorithm) {
+        return type + '.' + algorithm.toUpperCase(Locale.US);
+    }
+
     /**
      * {@code Service} represents a service in the Java Security infrastructure.
      * Each service describes its type, the algorithm it implements, to which
diff --git a/luni/src/main/java/org/apache/harmony/luni/util/TwoKeyHashMap.java b/luni/src/main/java/org/apache/harmony/luni/util/TwoKeyHashMap.java
deleted file mode 100644
index 35e6c62..0000000
--- a/luni/src/main/java/org/apache/harmony/luni/util/TwoKeyHashMap.java
+++ /dev/null
@@ -1,566 +0,0 @@
-/*
- *  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.luni.util;
-
-import java.util.AbstractCollection;
-import java.util.AbstractMap;
-import java.util.AbstractSet;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.ConcurrentModificationException;
-import java.util.Iterator;
-import java.util.Map;
-import java.util.NoSuchElementException;
-import java.util.Set;
-
-/**
- *
- * Reductive hash with two keys
- *
- */
-public class TwoKeyHashMap<E, K, V> extends AbstractMap<String, V> {
-
-    static final float DEFAULT_LOAD_FACTOR = 0.75f;
-    static final int DEFAULT_INITIAL_SIZE = 16;
-
-    private Set<Map.Entry<String, V>> entrySet;
-    private Collection<V> values;
-    private int size;
-    private int arrSize;
-    private int modCount;
-
-    private Entry<E, K, V>[] arr;
-
-    private float loadFactor;
-    int threshold = 0;
-
-    /**
-     * Constructs an empty HashMap
-     */
-    public TwoKeyHashMap() {
-        this(DEFAULT_INITIAL_SIZE, DEFAULT_LOAD_FACTOR);
-    }
-
-    /**
-     * Constructs an empty HashMap
-     *
-     * @param initialCapacity
-     */
-    public TwoKeyHashMap(int initialCapacity) {
-        this(initialCapacity, DEFAULT_LOAD_FACTOR);
-    }
-
-    /**
-     * Constructs an empty HashMap
-     *
-     * @param initialCapacity
-     * @param initialLoadFactor
-     */
-    @SuppressWarnings("unchecked")
-    public TwoKeyHashMap(int initialCapacity, float initialLoadFactor) {
-        if (initialCapacity < 0) {
-            throw new IllegalArgumentException("initialCapacity should be >= 0");
-        }
-        if (initialLoadFactor <= 0) {
-            throw new IllegalArgumentException(
-                    "initialLoadFactor should be > 0");
-        }
-        loadFactor = initialLoadFactor;
-        if (initialCapacity == Integer.MAX_VALUE) {
-            initialCapacity--;
-        }
-        arrSize = initialCapacity > 0 ? initialCapacity : 1;
-        threshold = (int) (arrSize * loadFactor);
-        arr = new Entry[arrSize + 1];
-    }
-
-    /**
-     * Returns a collection view of the values
-     */
-    public Collection<V> values() {
-        if (values == null) {
-            values = new ValuesCollectionImpl();
-        }
-        return values;
-    }
-
-    /**
-     * Returns a collection view of the mappings
-     */
-    public Set<Map.Entry<String, V>> entrySet() {
-        if (entrySet == null) {
-            entrySet = new EntrySetImpl();
-        }
-        return entrySet;
-    }
-
-    /**
-     * Clears the map
-     */
-    public void clear() {
-        modCount++;
-        size = 0;
-        Arrays.fill(arr, 0, arr.length, null);
-    }
-
-    /**
-     * Removes the mapping for the keys
-     *
-     * @param key1
-     * @param key2
-     * @return
-     */
-    public V remove(Object key1, Object key2) {
-        Entry<E, K, V> e = removeEntry(key1, key2);
-        return (e != null) ? e.value : null;
-    }
-
-    /**
-     * Associates the specified value with the specified keys in this map
-     *
-     * @param key1
-     * @param key2
-     * @param value
-     * @return
-     */
-    public V put(E key1, K key2, V value) {
-        if (key1 == null && key2 == null) {
-            int index = arrSize;
-            if (arr[index] == null) {
-                arr[index] = createEntry(0, null, null, value, null);
-                size++;
-                modCount++;
-                return null;
-            } else {
-                V oldValue = arr[index].value;
-                arr[index].value = value;
-                return oldValue;
-            }
-        }
-
-        int hash = key1.hashCode() + key2.hashCode();
-        int index = (hash & 0x7fffffff) % arrSize;
-        Entry<E, K, V> e = arr[index];
-
-        while (e != null) {
-            if (hash == e.hash && key1.equals(e.getKey1())
-                    && key2.equals(e.getKey2())) {
-                V oldValue = e.value;
-                e.value = value;
-                return oldValue;
-            }
-            e = e.next;
-        }
-
-        arr[index] = createEntry(hash, key1, key2, value, arr[index]);
-        size++;
-        modCount++;
-
-        if (size > threshold) {
-            rehash();
-        }
-        return null;
-    }
-
-    /**
-     * Rehash the map
-     *
-     */
-    @SuppressWarnings("unchecked")
-    void rehash() {
-        int newArrSize = (arrSize + 1) * 2 + 1;
-        if (newArrSize < 0) {
-            newArrSize = Integer.MAX_VALUE - 1;
-        }
-        Entry<E, K, V>[] newArr = new Entry[newArrSize + 1];
-
-        for (int i = 0; i < arr.length - 1; i++) {
-            Entry<E, K, V> entry = arr[i];
-            while (entry != null) {
-                Entry<E, K, V> next = entry.next;
-
-                int newIndex = (entry.hash & 0x7fffffff) % newArrSize;
-                entry.next = newArr[newIndex];
-                newArr[newIndex] = entry;
-
-                entry = next;
-            }
-        }
-        newArr[newArrSize] = arr[arrSize]; // move null entry
-        arrSize = newArrSize;
-
-        // The maximum array size is reached, increased loadFactor
-        // will keep array from further growing
-        if (arrSize == Integer.MAX_VALUE) {
-            loadFactor *= 10;
-        }
-        threshold = (int) (arrSize * loadFactor);
-        arr = newArr;
-    }
-
-    /**
-     * Returns true if this map contains a mapping for {@code key1} and {@code key2}.
-     */
-    public boolean containsKey(Object key1, Object key2) {
-        return findEntry(key1, key2) != null;
-    }
-
-    /**
-     * Return the value by keys
-     *
-     * @param key1
-     * @param key2
-     * @return
-     */
-    public V get(Object key1, Object key2) {
-        Entry<E, K, V> e = findEntry(key1, key2);
-        if (e != null) {
-            return e.value;
-        }
-        return null;
-    }
-
-    /**
-     * Returns true if this map contains no key-value mappings
-     */
-    public boolean isEmpty() {
-        return size == 0;
-    }
-
-    /**
-     * Returns the number of mappings
-     */
-    public int size() {
-        return size;
-    }
-
-    /**
-     * Creates new entry
-     *
-     * @param hashCode
-     * @param key1
-     * @param key2
-     * @param value
-     * @param next
-     * @return
-     */
-    Entry<E, K, V> createEntry(int hashCode, E key1, K key2, V value,
-            Entry<E, K, V> next) {
-        return new Entry<E, K, V>(hashCode, key1, key2, value, next);
-    }
-
-    /**
-     * Creates entries iterator
-     *
-     * @return
-     */
-    Iterator<Map.Entry<String, V>> createEntrySetIterator() {
-        return new EntryIteratorImpl();
-    }
-
-    /**
-     * Creates values iterator
-     *
-     * @return
-     */
-    Iterator<V> createValueCollectionIterator() {
-        return new ValueIteratorImpl();
-    }
-
-    /**
-     * Entry implementation for the TwoKeyHashMap class
-     *
-     */
-    public static class Entry<E, K, V> implements Map.Entry<String, V> {
-        int hash;
-        E key1;
-        K key2;
-        V value;
-        Entry<E, K, V> next;
-
-        public Entry(int hash, E key1, K key2, V value, Entry<E, K, V> next) {
-            this.hash = hash;
-            this.key1 = key1;
-            this.key2 = key2;
-            this.value = value;
-            this.next = next;
-        }
-
-        public String getKey() {
-            return key1.toString() + key2.toString();
-        }
-
-        public E getKey1() {
-            return key1;
-        }
-
-        public K getKey2() {
-            return key2;
-        }
-
-        public V getValue() {
-            return value;
-        }
-
-        public V setValue(V value) {
-            V oldValue = this.value;
-            this.value = value;
-            return oldValue;
-        }
-
-        public boolean equals(Object obj) {
-            if (!(obj instanceof Entry)) {
-                return false;
-            }
-
-            Entry<?, ?, ?> e = (Entry<?, ?, ?>) obj;
-            Object getKey1 = e.getKey1();
-            Object getKey2 = e.getKey2();
-            Object getValue = e.getValue();
-            if ((key1 == null && getKey1 != null)
-                    || (key2 == null && getKey2 != null)
-                    || (value == null && getValue != null)
-                    || !key1.equals(e.getKey1()) || !key2.equals(e.getKey2())
-                    || !value.equals(getValue)) {
-                return false;
-            }
-            return true;
-        }
-
-        public int hashCode() {
-            int hash1 = (key1 == null ? 0 : key1.hashCode());
-            int hash2 = (key2 == null ? 0 : key2.hashCode());
-            return (hash1 + hash2) ^ (value == null ? 0 : value.hashCode());
-        }
-
-    }
-
-    class EntrySetImpl extends AbstractSet<Map.Entry<String, V>> {
-        public int size() {
-            return size;
-        }
-
-        public void clear() {
-            TwoKeyHashMap.this.clear();
-        }
-
-        public boolean isEmpty() {
-            return size == 0;
-        }
-
-        public boolean contains(Object obj) {
-            if (!(obj instanceof Entry)) {
-                return false;
-            }
-
-            Entry<?, ?, ?> entry = (Entry<?, ?, ?>) obj;
-            Entry<E, K, V> entry2 = findEntry(entry.getKey1(), entry.getKey2());
-            if (entry2 == null) {
-                return false;
-            }
-            Object value = entry.getValue();
-            Object value2 = entry2.getValue();
-            return value == null ? value2 == null : value.equals(value2);
-        }
-
-        public boolean remove(Object obj) {
-            if (!(obj instanceof Entry)) {
-                return false;
-            }
-            return removeEntry(((Entry) obj).getKey1(), ((Entry) obj).getKey2()) != null;
-        }
-
-        public Iterator<Map.Entry<String, V>> iterator() {
-            return createEntrySetIterator();
-        }
-    }
-
-    // Iterates Entries inside the Map
-    class EntryIteratorImpl implements Iterator<Map.Entry<String, V>> {
-        private int startModCount;
-        private boolean found;
-        private int curr = -1;
-        private int returned_index = -1;
-        private Entry<E, K, V> curr_entry;
-        private Entry<E, K, V> returned_entry;
-
-        EntryIteratorImpl() {
-            startModCount = modCount;
-        }
-
-        public boolean hasNext() {
-            if (found) {
-                return true;
-            }
-            if (curr_entry != null) {
-                curr_entry = curr_entry.next;
-            }
-            if (curr_entry == null) {
-                for (curr++; curr < arr.length && arr[curr] == null; curr++) {
-                }
-
-                if (curr < arr.length) {
-                    curr_entry = arr[curr];
-                }
-            }
-            return found = (curr_entry != null);
-        }
-
-        public Map.Entry<String, V> next() {
-            if (modCount != startModCount) {
-                throw new ConcurrentModificationException();
-            }
-            if (!hasNext()) {
-                throw new NoSuchElementException();
-            }
-
-            found = false;
-            returned_index = curr;
-            returned_entry = curr_entry;
-            return (Map.Entry<String, V>) curr_entry;
-        }
-
-        public void remove() {
-            if (returned_index == -1) {
-                throw new IllegalStateException();
-            }
-
-            if (modCount != startModCount) {
-                throw new ConcurrentModificationException();
-            }
-
-            Entry<E, K, V> p = null;
-            Entry<E, K, V> e = arr[returned_index];
-            while (e != returned_entry) {
-                p = e;
-                e = e.next;
-            }
-            if (p != null) {
-                p.next = returned_entry.next;
-            } else {
-                arr[returned_index] = returned_entry.next;
-            }
-            size--;
-            modCount++;
-            startModCount++;
-            returned_index = -1;
-        }
-    }
-
-    private final Entry<E, K, V> findEntry(Object key1, Object key2) {
-        if (key1 == null && key2 == null) {
-            return arr[arrSize];
-        }
-
-        int hash = key1.hashCode() + key2.hashCode();
-        int index = (hash & 0x7fffffff) % arrSize;
-        Entry<E, K, V> e = arr[index];
-
-        while (e != null) {
-            if (hash == e.hash && key1.equals(e.getKey1())
-                    && key2.equals(e.getKey2())) {
-                return e;
-            }
-            e = e.next;
-        }
-        return null;
-    }
-
-    // Removes entry
-    private final Entry<E, K, V> removeEntry(Object key1, Object key2) {
-        if (key1 == null && key2 == null) {
-            int index = arrSize;
-            if (arr[index] != null) {
-                Entry<E, K, V> ret = arr[index];
-                arr[index] = null;
-                size--;
-                modCount++;
-                return ret;
-            }
-            return null;
-        }
-
-        int hash = key1.hashCode() + key2.hashCode();
-        int index = (hash & 0x7fffffff) % arrSize;
-
-        Entry<E, K, V> e = arr[index];
-        Entry<E, K, V> prev = e;
-        while (e != null) {
-            if (hash == e.hash && key1.equals(e.getKey1())
-                    && key2.equals(e.getKey2())) {
-                if (prev == e) {
-                    arr[index] = e.next;
-                } else {
-                    prev.next = e.next;
-                }
-                size--;
-                modCount++;
-                return e;
-            }
-
-            prev = e;
-            e = e.next;
-        }
-        return null;
-    }
-
-    /**
-     * An instance is returned by the values() call.
-     */
-    class ValuesCollectionImpl extends AbstractCollection<V> {
-        public int size() {
-            return size;
-        }
-
-        public void clear() {
-            TwoKeyHashMap.this.clear();
-        }
-
-        public boolean isEmpty() {
-            return size == 0;
-        }
-
-        public Iterator<V> iterator() {
-            return createValueCollectionIterator();
-        }
-
-        public boolean contains(Object obj) {
-            return containsValue(obj);
-        }
-    }
-
-    class ValueIteratorImpl implements Iterator<V> {
-        private EntryIteratorImpl itr;
-
-        ValueIteratorImpl() {
-            this.itr = new EntryIteratorImpl();
-        }
-
-        public V next() {
-            return itr.next().getValue();
-        }
-
-        public void remove() {
-            itr.remove();
-        }
-
-        public boolean hasNext() {
-            return itr.hasNext();
-        }
-    }
-}
diff --git a/luni/src/test/java/libcore/java/security/ProviderTest.java b/luni/src/test/java/libcore/java/security/ProviderTest.java
index 695908b..78608d0 100644
--- a/luni/src/test/java/libcore/java/security/ProviderTest.java
+++ b/luni/src/test/java/libcore/java/security/ProviderTest.java
@@ -17,14 +17,20 @@
 package libcore.java.security;
 
 import java.security.Provider;
+import java.security.SecureRandom;
+import java.security.SecureRandomSpi;
+import java.security.Security;
+import java.security.Provider;
+import java.security.SecureRandom;
+import java.security.SecureRandomSpi;
 import java.security.Security;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
-import java.util.Map;
 import java.util.Map.Entry;
+import java.util.Map;
 import java.util.Set;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
@@ -195,4 +201,48 @@ public class ProviderTest extends TestCase {
             }
         }
     }
+
+    /**
+     * http://code.google.com/p/android/issues/detail?id=21449
+     */
+    public void testSecureRandomImplementationOrder() {
+        Provider srp = new SRProvider();
+        try {
+            int position = Security.insertProviderAt(srp, 1); // first is one, not zero
+            assertEquals(1, position);
+            SecureRandom sr = new SecureRandom();
+            if (!sr.getAlgorithm().equals("SecureRandom1")) {
+                throw new IllegalStateException("Expected SecureRandom1");
+            }
+        } finally {
+            Security.removeProvider(srp.getName());
+        }
+    }
+
+    public static class SRProvider extends Provider {
+
+        SRProvider() {
+            super("SRProvider", 1.42, "SecureRandom Provider");
+            put("SecureRandom.SecureRandom1", SecureRandom1.class.getName());
+            put("SecureRandom.SecureRandom2", SecureRandom2.class.getName());
+            put("SecureRandom.SecureRandom3", SecureRandom3.class.getName());
+        }
+    }
+
+    public static abstract class AbstractSecureRandom extends SecureRandomSpi {
+        protected void engineSetSeed(byte[] seed) {
+            throw new UnsupportedOperationException();
+        }
+        protected void engineNextBytes(byte[] bytes) {
+            throw new UnsupportedOperationException();
+        }
+        protected byte[] engineGenerateSeed(int numBytes) {
+            throw new UnsupportedOperationException();
+        }
+    }
+
+    public static class SecureRandom1 extends AbstractSecureRandom {}
+    public static class SecureRandom2 extends AbstractSecureRandom {}
+    public static class SecureRandom3 extends AbstractSecureRandom {}
+
 }
-- 
cgit v1.1


From 26010ab930a2cee3bf10b9612cf070183c21228b Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Mon, 23 Jul 2012 17:37:18 -0700
Subject: Declare that various Posix methods can throw SocketException.

Bug: 5177516
Change-Id: Icf2f06c7df6686dd1f54a930bc3fa50b1ce4e1d4
---
 .../main/java/java/net/PlainDatagramSocketImpl.java   |  2 ++
 luni/src/main/java/libcore/io/BlockGuardOs.java       | 12 ++++++------
 luni/src/main/java/libcore/io/ForwardingOs.java       | 15 ++++++++-------
 luni/src/main/java/libcore/io/Os.java                 | 15 ++++++++-------
 luni/src/main/java/libcore/io/Posix.java              | 19 ++++++++++---------
 5 files changed, 34 insertions(+), 29 deletions(-)

diff --git a/luni/src/main/java/java/net/PlainDatagramSocketImpl.java b/luni/src/main/java/java/net/PlainDatagramSocketImpl.java
index 5d01469..3226527 100644
--- a/luni/src/main/java/java/net/PlainDatagramSocketImpl.java
+++ b/luni/src/main/java/java/net/PlainDatagramSocketImpl.java
@@ -216,6 +216,8 @@ public class PlainDatagramSocketImpl extends DatagramSocketImpl {
             Libcore.os.connect(fd, InetAddress.UNSPECIFIED, 0);
         } catch (ErrnoException errnoException) {
             throw new AssertionError(errnoException);
+        } catch (SocketException ignored) {
+            // Thrown if the socket has already been closed, but this method can't throw anything.
         }
         connectedPort = -1;
         connectedAddress = null;
diff --git a/luni/src/main/java/libcore/io/BlockGuardOs.java b/luni/src/main/java/libcore/io/BlockGuardOs.java
index 4f2858d..61c9765 100644
--- a/luni/src/main/java/libcore/io/BlockGuardOs.java
+++ b/luni/src/main/java/libcore/io/BlockGuardOs.java
@@ -50,7 +50,7 @@ public class BlockGuardOs extends ForwardingOs {
         }
     }
 
-    @Override public FileDescriptor accept(FileDescriptor fd, InetSocketAddress peerAddress) throws ErrnoException {
+    @Override public FileDescriptor accept(FileDescriptor fd, InetSocketAddress peerAddress) throws ErrnoException, SocketException {
         BlockGuard.getThreadPolicy().onNetwork();
         return tagSocket(os.accept(fd, peerAddress));
     }
@@ -80,7 +80,7 @@ public class BlockGuardOs extends ForwardingOs {
         return linger.isOn() && linger.l_linger > 0;
     }
 
-    @Override public void connect(FileDescriptor fd, InetAddress address, int port) throws ErrnoException {
+    @Override public void connect(FileDescriptor fd, InetAddress address, int port) throws ErrnoException, SocketException {
         BlockGuard.getThreadPolicy().onNetwork();
         os.connect(fd, address, port);
     }
@@ -154,22 +154,22 @@ public class BlockGuardOs extends ForwardingOs {
         return os.readv(fd, buffers, offsets, byteCounts);
     }
 
-    @Override public int recvfrom(FileDescriptor fd, ByteBuffer buffer, int flags, InetSocketAddress srcAddress) throws ErrnoException {
+    @Override public int recvfrom(FileDescriptor fd, ByteBuffer buffer, int flags, InetSocketAddress srcAddress) throws ErrnoException, SocketException {
         BlockGuard.getThreadPolicy().onNetwork();
         return os.recvfrom(fd, buffer, flags, srcAddress);
     }
 
-    @Override public int recvfrom(FileDescriptor fd, byte[] bytes, int byteOffset, int byteCount, int flags, InetSocketAddress srcAddress) throws ErrnoException {
+    @Override public int recvfrom(FileDescriptor fd, byte[] bytes, int byteOffset, int byteCount, int flags, InetSocketAddress srcAddress) throws ErrnoException, SocketException {
         BlockGuard.getThreadPolicy().onNetwork();
         return os.recvfrom(fd, bytes, byteOffset, byteCount, flags, srcAddress);
     }
 
-    @Override public int sendto(FileDescriptor fd, ByteBuffer buffer, int flags, InetAddress inetAddress, int port) throws ErrnoException {
+    @Override public int sendto(FileDescriptor fd, ByteBuffer buffer, int flags, InetAddress inetAddress, int port) throws ErrnoException, SocketException {
         BlockGuard.getThreadPolicy().onNetwork();
         return os.sendto(fd, buffer, flags, inetAddress, port);
     }
 
-    @Override public int sendto(FileDescriptor fd, byte[] bytes, int byteOffset, int byteCount, int flags, InetAddress inetAddress, int port) throws ErrnoException {
+    @Override public int sendto(FileDescriptor fd, byte[] bytes, int byteOffset, int byteCount, int flags, InetAddress inetAddress, int port) throws ErrnoException, SocketException {
         // We permit datagrams without hostname lookups.
         if (inetAddress != null) {
             BlockGuard.getThreadPolicy().onNetwork();
diff --git a/luni/src/main/java/libcore/io/ForwardingOs.java b/luni/src/main/java/libcore/io/ForwardingOs.java
index 2c8e562..39b9861 100644
--- a/luni/src/main/java/libcore/io/ForwardingOs.java
+++ b/luni/src/main/java/libcore/io/ForwardingOs.java
@@ -20,6 +20,7 @@ import java.io.FileDescriptor;
 import java.net.InetAddress;
 import java.net.InetSocketAddress;
 import java.net.SocketAddress;
+import java.net.SocketException;
 import java.nio.ByteBuffer;
 import libcore.util.MutableInt;
 import libcore.util.MutableLong;
@@ -34,12 +35,12 @@ public class ForwardingOs implements Os {
         this.os = os;
     }
 
-    public FileDescriptor accept(FileDescriptor fd, InetSocketAddress peerAddress) throws ErrnoException { return os.accept(fd, peerAddress); }
+    public FileDescriptor accept(FileDescriptor fd, InetSocketAddress peerAddress) throws ErrnoException, SocketException { return os.accept(fd, peerAddress); }
     public boolean access(String path, int mode) throws ErrnoException { return os.access(path, mode); }
-    public void bind(FileDescriptor fd, InetAddress address, int port) throws ErrnoException { os.bind(fd, address, port); }
+    public void bind(FileDescriptor fd, InetAddress address, int port) throws ErrnoException, SocketException { os.bind(fd, address, port); }
     public void chmod(String path, int mode) throws ErrnoException { os.chmod(path, mode); }
     public void close(FileDescriptor fd) throws ErrnoException { os.close(fd); }
-    public void connect(FileDescriptor fd, InetAddress address, int port) throws ErrnoException { os.connect(fd, address, port); }
+    public void connect(FileDescriptor fd, InetAddress address, int port) throws ErrnoException, SocketException { os.connect(fd, address, port); }
     public FileDescriptor dup(FileDescriptor oldFd) throws ErrnoException { return os.dup(oldFd); }
     public FileDescriptor dup2(FileDescriptor oldFd, int newFd) throws ErrnoException { return os.dup2(oldFd, newFd); }
     public String[] environ() { return os.environ(); }
@@ -95,13 +96,13 @@ public class ForwardingOs implements Os {
     public int read(FileDescriptor fd, ByteBuffer buffer) throws ErrnoException { return os.read(fd, buffer); }
     public int read(FileDescriptor fd, byte[] bytes, int byteOffset, int byteCount) throws ErrnoException { return os.read(fd, bytes, byteOffset, byteCount); }
     public int readv(FileDescriptor fd, Object[] buffers, int[] offsets, int[] byteCounts) throws ErrnoException { return os.readv(fd, buffers, offsets, byteCounts); }
-    public int recvfrom(FileDescriptor fd, ByteBuffer buffer, int flags, InetSocketAddress srcAddress) throws ErrnoException { return os.recvfrom(fd, buffer, flags, srcAddress); }
-    public int recvfrom(FileDescriptor fd, byte[] bytes, int byteOffset, int byteCount, int flags, InetSocketAddress srcAddress) throws ErrnoException { return os.recvfrom(fd, bytes, byteOffset, byteCount, flags, srcAddress); }
+    public int recvfrom(FileDescriptor fd, ByteBuffer buffer, int flags, InetSocketAddress srcAddress) throws ErrnoException, SocketException { return os.recvfrom(fd, buffer, flags, srcAddress); }
+    public int recvfrom(FileDescriptor fd, byte[] bytes, int byteOffset, int byteCount, int flags, InetSocketAddress srcAddress) throws ErrnoException, SocketException { return os.recvfrom(fd, bytes, byteOffset, byteCount, flags, srcAddress); }
     public void remove(String path) throws ErrnoException { os.remove(path); }
     public void rename(String oldPath, String newPath) throws ErrnoException { os.rename(oldPath, newPath); }
     public long sendfile(FileDescriptor outFd, FileDescriptor inFd, MutableLong inOffset, long byteCount) throws ErrnoException { return os.sendfile(outFd, inFd, inOffset, byteCount); }
-    public int sendto(FileDescriptor fd, ByteBuffer buffer, int flags, InetAddress inetAddress, int port) throws ErrnoException { return os.sendto(fd, buffer, flags, inetAddress, port); }
-    public int sendto(FileDescriptor fd, byte[] bytes, int byteOffset, int byteCount, int flags, InetAddress inetAddress, int port) throws ErrnoException { return os.sendto(fd, bytes, byteOffset, byteCount, flags, inetAddress, port); }
+    public int sendto(FileDescriptor fd, ByteBuffer buffer, int flags, InetAddress inetAddress, int port) throws ErrnoException, SocketException { return os.sendto(fd, buffer, flags, inetAddress, port); }
+    public int sendto(FileDescriptor fd, byte[] bytes, int byteOffset, int byteCount, int flags, InetAddress inetAddress, int port) throws ErrnoException, SocketException { return os.sendto(fd, bytes, byteOffset, byteCount, flags, inetAddress, port); }
     public void setegid(int egid) throws ErrnoException { os.setegid(egid); }
     public void seteuid(int euid) throws ErrnoException { os.seteuid(euid); }
     public void setgid(int gid) throws ErrnoException { os.setgid(gid); }
diff --git a/luni/src/main/java/libcore/io/Os.java b/luni/src/main/java/libcore/io/Os.java
index d637b67..5fdc7be 100644
--- a/luni/src/main/java/libcore/io/Os.java
+++ b/luni/src/main/java/libcore/io/Os.java
@@ -20,17 +20,18 @@ import java.io.FileDescriptor;
 import java.net.InetAddress;
 import java.net.InetSocketAddress;
 import java.net.SocketAddress;
+import java.net.SocketException;
 import java.nio.ByteBuffer;
 import libcore.util.MutableInt;
 import libcore.util.MutableLong;
 
 public interface Os {
-    public FileDescriptor accept(FileDescriptor fd, InetSocketAddress peerAddress) throws ErrnoException;
+    public FileDescriptor accept(FileDescriptor fd, InetSocketAddress peerAddress) throws ErrnoException, SocketException;
     public boolean access(String path, int mode) throws ErrnoException;
-    public void bind(FileDescriptor fd, InetAddress address, int port) throws ErrnoException;
+    public void bind(FileDescriptor fd, InetAddress address, int port) throws ErrnoException, SocketException;
     public void chmod(String path, int mode) throws ErrnoException;
     public void close(FileDescriptor fd) throws ErrnoException;
-    public void connect(FileDescriptor fd, InetAddress address, int port) throws ErrnoException;
+    public void connect(FileDescriptor fd, InetAddress address, int port) throws ErrnoException, SocketException;
     public FileDescriptor dup(FileDescriptor oldFd) throws ErrnoException;
     public FileDescriptor dup2(FileDescriptor oldFd, int newFd) throws ErrnoException;
     public String[] environ();
@@ -88,12 +89,12 @@ public interface Os {
     public int read(FileDescriptor fd, ByteBuffer buffer) throws ErrnoException;
     public int read(FileDescriptor fd, byte[] bytes, int byteOffset, int byteCount) throws ErrnoException;
     public int readv(FileDescriptor fd, Object[] buffers, int[] offsets, int[] byteCounts) throws ErrnoException;
-    public int recvfrom(FileDescriptor fd, ByteBuffer buffer, int flags, InetSocketAddress srcAddress) throws ErrnoException;
-    public int recvfrom(FileDescriptor fd, byte[] bytes, int byteOffset, int byteCount, int flags, InetSocketAddress srcAddress) throws ErrnoException;
+    public int recvfrom(FileDescriptor fd, ByteBuffer buffer, int flags, InetSocketAddress srcAddress) throws ErrnoException, SocketException;
+    public int recvfrom(FileDescriptor fd, byte[] bytes, int byteOffset, int byteCount, int flags, InetSocketAddress srcAddress) throws ErrnoException, SocketException;
     public void remove(String path) throws ErrnoException;
     public void rename(String oldPath, String newPath) throws ErrnoException;
-    public int sendto(FileDescriptor fd, ByteBuffer buffer, int flags, InetAddress inetAddress, int port) throws ErrnoException;
-    public int sendto(FileDescriptor fd, byte[] bytes, int byteOffset, int byteCount, int flags, InetAddress inetAddress, int port) throws ErrnoException;
+    public int sendto(FileDescriptor fd, ByteBuffer buffer, int flags, InetAddress inetAddress, int port) throws ErrnoException, SocketException;
+    public int sendto(FileDescriptor fd, byte[] bytes, int byteOffset, int byteCount, int flags, InetAddress inetAddress, int port) throws ErrnoException, SocketException;
     public long sendfile(FileDescriptor outFd, FileDescriptor inFd, MutableLong inOffset, long byteCount) throws ErrnoException;
     public void setegid(int egid) throws ErrnoException;
     public void seteuid(int euid) throws ErrnoException;
diff --git a/luni/src/main/java/libcore/io/Posix.java b/luni/src/main/java/libcore/io/Posix.java
index 7bbf49f..0fc9f38 100644
--- a/luni/src/main/java/libcore/io/Posix.java
+++ b/luni/src/main/java/libcore/io/Posix.java
@@ -20,6 +20,7 @@ import java.io.FileDescriptor;
 import java.net.InetAddress;
 import java.net.InetSocketAddress;
 import java.net.SocketAddress;
+import java.net.SocketException;
 import java.nio.ByteBuffer;
 import java.nio.NioUtils;
 import libcore.util.MutableInt;
@@ -28,12 +29,12 @@ import libcore.util.MutableLong;
 public final class Posix implements Os {
     Posix() { }
 
-    public native FileDescriptor accept(FileDescriptor fd, InetSocketAddress peerAddress) throws ErrnoException;
+    public native FileDescriptor accept(FileDescriptor fd, InetSocketAddress peerAddress) throws ErrnoException, SocketException;
     public native boolean access(String path, int mode) throws ErrnoException;
-    public native void bind(FileDescriptor fd, InetAddress address, int port) throws ErrnoException;
+    public native void bind(FileDescriptor fd, InetAddress address, int port) throws ErrnoException, SocketException;
     public native void chmod(String path, int mode) throws ErrnoException;
     public native void close(FileDescriptor fd) throws ErrnoException;
-    public native void connect(FileDescriptor fd, InetAddress address, int port) throws ErrnoException;
+    public native void connect(FileDescriptor fd, InetAddress address, int port) throws ErrnoException, SocketException;
     public native FileDescriptor dup(FileDescriptor oldFd) throws ErrnoException;
     public native FileDescriptor dup2(FileDescriptor oldFd, int newFd) throws ErrnoException;
     public native String[] environ();
@@ -119,33 +120,33 @@ public final class Posix implements Os {
     }
     private native int readBytes(FileDescriptor fd, Object buffer, int offset, int byteCount) throws ErrnoException;
     public native int readv(FileDescriptor fd, Object[] buffers, int[] offsets, int[] byteCounts) throws ErrnoException;
-    public int recvfrom(FileDescriptor fd, ByteBuffer buffer, int flags, InetSocketAddress srcAddress) throws ErrnoException {
+    public int recvfrom(FileDescriptor fd, ByteBuffer buffer, int flags, InetSocketAddress srcAddress) throws ErrnoException, SocketException {
         if (buffer.isDirect()) {
             return recvfromBytes(fd, buffer, buffer.position(), buffer.remaining(), flags, srcAddress);
         } else {
             return recvfromBytes(fd, NioUtils.unsafeArray(buffer), NioUtils.unsafeArrayOffset(buffer) + buffer.position(), buffer.remaining(), flags, srcAddress);
         }
     }
-    public int recvfrom(FileDescriptor fd, byte[] bytes, int byteOffset, int byteCount, int flags, InetSocketAddress srcAddress) throws ErrnoException {
+    public int recvfrom(FileDescriptor fd, byte[] bytes, int byteOffset, int byteCount, int flags, InetSocketAddress srcAddress) throws ErrnoException, SocketException {
         // This indirection isn't strictly necessary, but ensures that our public interface is type safe.
         return recvfromBytes(fd, bytes, byteOffset, byteCount, flags, srcAddress);
     }
-    private native int recvfromBytes(FileDescriptor fd, Object buffer, int byteOffset, int byteCount, int flags, InetSocketAddress srcAddress) throws ErrnoException;
+    private native int recvfromBytes(FileDescriptor fd, Object buffer, int byteOffset, int byteCount, int flags, InetSocketAddress srcAddress) throws ErrnoException, SocketException;
     public native void remove(String path) throws ErrnoException;
     public native void rename(String oldPath, String newPath) throws ErrnoException;
     public native long sendfile(FileDescriptor outFd, FileDescriptor inFd, MutableLong inOffset, long byteCount) throws ErrnoException;
-    public int sendto(FileDescriptor fd, ByteBuffer buffer, int flags, InetAddress inetAddress, int port) throws ErrnoException {
+    public int sendto(FileDescriptor fd, ByteBuffer buffer, int flags, InetAddress inetAddress, int port) throws ErrnoException, SocketException {
         if (buffer.isDirect()) {
             return sendtoBytes(fd, buffer, buffer.position(), buffer.remaining(), flags, inetAddress, port);
         } else {
             return sendtoBytes(fd, NioUtils.unsafeArray(buffer), NioUtils.unsafeArrayOffset(buffer) + buffer.position(), buffer.remaining(), flags, inetAddress, port);
         }
     }
-    public int sendto(FileDescriptor fd, byte[] bytes, int byteOffset, int byteCount, int flags, InetAddress inetAddress, int port) throws ErrnoException {
+    public int sendto(FileDescriptor fd, byte[] bytes, int byteOffset, int byteCount, int flags, InetAddress inetAddress, int port) throws ErrnoException, SocketException {
         // This indirection isn't strictly necessary, but ensures that our public interface is type safe.
         return sendtoBytes(fd, bytes, byteOffset, byteCount, flags, inetAddress, port);
     }
-    private native int sendtoBytes(FileDescriptor fd, Object buffer, int byteOffset, int byteCount, int flags, InetAddress inetAddress, int port) throws ErrnoException;
+    private native int sendtoBytes(FileDescriptor fd, Object buffer, int byteOffset, int byteCount, int flags, InetAddress inetAddress, int port) throws ErrnoException, SocketException;
     public native void setegid(int egid) throws ErrnoException;
     public native void seteuid(int euid) throws ErrnoException;
     public native void setgid(int gid) throws ErrnoException;
-- 
cgit v1.1


From df9f5967a3b8dc2f61183d155791393b67980511 Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Mon, 23 Jul 2012 17:44:12 -0700
Subject: Fix OpenSSLSocketImpl.close race

Move the NativeCrypto.SSL_interrupt call within the close
synchronization. Otherwise there can be problems if
NativeCrypto_SSL_interrupt tries to use the SSL* and another thread
has called NativeCrypto_SSL_free.

Bug: 6707288
Change-Id: Id8b0311b10124f2a08f8e0f24595a6ee46805c33
---
 .../java/org/apache/harmony/xnet/provider/jsse/OpenSSLSocketImpl.java | 4 ++--
 .../native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp     | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLSocketImpl.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLSocketImpl.java
index 4c92952..6334d41 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLSocketImpl.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLSocketImpl.java
@@ -914,12 +914,12 @@ public class OpenSSLSocketImpl
             }
         }
 
-        NativeCrypto.SSL_interrupt(sslNativePointer);
-
         synchronized (this) {
             synchronized (writeLock) {
                 synchronized (readLock) {
 
+                    NativeCrypto.SSL_interrupt(sslNativePointer);
+
                     // Shut down the SSL connection, per se.
                     try {
                         if (handshakeStarted) {
diff --git a/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp b/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
index 687c57e..7dabc5d 100644
--- a/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
+++ b/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
@@ -3933,7 +3933,7 @@ static void NativeCrypto_SSL_write(JNIEnv* env, jclass, jint ssl_address, jobjec
 }
 
 /**
- * Interrupt any pending IO before closing the socket.
+ * Interrupt any pending I/O before closing the socket.
  */
 static void NativeCrypto_SSL_interrupt(
         JNIEnv* env, jclass, jint ssl_address) {
-- 
cgit v1.1


From fc1332710b0af3bbe658535a257048cf8c7577f2 Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Mon, 23 Jul 2012 19:03:00 -0700
Subject: Fix flakey test_SSLSocket_setSoTimeout_basic by using a full second
 timeout

Change-Id: I5b7d57f012dcef0047cf292f311ee3fa49700414
---
 luni/src/test/java/libcore/javax/net/ssl/SSLSocketTest.java | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/luni/src/test/java/libcore/javax/net/ssl/SSLSocketTest.java b/luni/src/test/java/libcore/javax/net/ssl/SSLSocketTest.java
index 90cdeb9..8b9cb11 100644
--- a/luni/src/test/java/libcore/javax/net/ssl/SSLSocketTest.java
+++ b/luni/src/test/java/libcore/javax/net/ssl/SSLSocketTest.java
@@ -1054,9 +1054,10 @@ public class SSLSocketTest extends TestCase {
         assertEquals(0, wrapping.getSoTimeout());
 
         // setting wrapper sets underlying and ...
-        wrapping.setSoTimeout(10);
-        assertEquals(10, wrapping.getSoTimeout());
-        assertEquals(10, underlying.getSoTimeout());
+        int expectedTimeoutMillis = 1000;  // Using a small value such as 10 was affected by rounding
+        wrapping.setSoTimeout(expectedTimeoutMillis);
+        assertEquals(expectedTimeoutMillis, wrapping.getSoTimeout());
+        assertEquals(expectedTimeoutMillis, underlying.getSoTimeout());
 
         // ... getting wrapper inspects underlying
         underlying.setSoTimeout(0);
-- 
cgit v1.1


From 52ec5bcc7d5d042d7ba6d0244d98ee72007a95e4 Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Mon, 23 Jul 2012 23:33:56 -0700
Subject: Signature.verify should not throw if called twice

Bug: http://code.google.com/p/android/issues/detail?id=34933
Change-Id: Iad18e46729dcd283f4cecd65994ac7b741bd3036
---
 .../harmony/xnet/provider/jsse/OpenSSLSignature.java       |  2 +-
 .../src/test/java/libcore/java/security/SignatureTest.java | 14 +++++++++++---
 2 files changed, 12 insertions(+), 4 deletions(-)

diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLSignature.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLSignature.java
index 370e7a4..d9746c6 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLSignature.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLSignature.java
@@ -241,7 +241,7 @@ public class OpenSSLSignature extends Signature {
                     key.getPkeyContext());
             return result == 1;
         } catch (Exception ex) {
-            throw new SignatureException(ex);
+            return false;
         } finally {
             /*
              * Java expects the digest context to be reset completely after
diff --git a/luni/src/test/java/libcore/java/security/SignatureTest.java b/luni/src/test/java/libcore/java/security/SignatureTest.java
index 7364c93..2cd9982 100644
--- a/luni/src/test/java/libcore/java/security/SignatureTest.java
+++ b/luni/src/test/java/libcore/java/security/SignatureTest.java
@@ -112,12 +112,20 @@ public class SignatureTest extends TestCase {
         sig.initSign(keyPair.getPrivate());
         sig.update(DATA);
         byte[] signature = sig.sign();
-        assertNotNull(signature);
-        assertTrue(signature.length > 0);
+        assertNotNull(sig.getAlgorithm(), signature);
+        assertTrue(sig.getAlgorithm(), signature.length > 0);
 
         sig.initVerify(keyPair.getPublic());
         sig.update(DATA);
-        assertTrue(sig.verify(signature));
+        assertTrue(sig.getAlgorithm(), sig.verify(signature));
+
+        // After verify, should be reusable as if we are after initVerify
+        sig.update(DATA);
+        assertTrue(sig.getAlgorithm(), sig.verify(signature));
+
+        // Calling Signature.verify a second time should not throw
+        // http://code.google.com/p/android/issues/detail?id=34933
+        sig.verify(signature);
     }
 
     private static final byte[] PK_BYTES = hexToBytes(
-- 
cgit v1.1


From 459718ce7114a918efcc7d464e4209dbfade6a86 Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Fri, 20 Jul 2012 17:40:56 -0700
Subject: Tolerate cache files being removed from underneath DiskLruCache

Bug: 6777079
Change-Id: I2f950ab6d847dd63061aeb449fc5d46ab9e6c50a
---
 luni/src/main/java/libcore/io/DiskLruCache.java    | 12 ++++++++++-
 .../java/libcore/net/http/HttpResponseCache.java   |  2 +-
 .../src/test/java/libcore/io/DiskLruCacheTest.java | 24 +++++++++++++++++++++-
 3 files changed, 35 insertions(+), 3 deletions(-)

diff --git a/luni/src/main/java/libcore/io/DiskLruCache.java b/luni/src/main/java/libcore/io/DiskLruCache.java
index 4699766..b7d246d 100644
--- a/luni/src/main/java/libcore/io/DiskLruCache.java
+++ b/luni/src/main/java/libcore/io/DiskLruCache.java
@@ -458,9 +458,14 @@ public final class DiskLruCache implements Closeable {
         // if this edit is creating the entry for the first time, every index must have a value
         if (success && !entry.readable) {
             for (int i = 0; i < valueCount; i++) {
+                if (!editor.written[i]) {
+                    editor.abort();
+                    throw new IllegalStateException("Newly created entry didn't create value for index " + i);
+                }
                 if (!entry.getDirtyFile(i).exists()) {
                     editor.abort();
-                    throw new IllegalStateException("edit didn't create file " + i);
+                    System.logW("DiskLruCache: Newly created entry doesn't have file for index " + i);
+                    return;
                 }
             }
         }
@@ -659,10 +664,12 @@ public final class DiskLruCache implements Closeable {
      */
     public final class Editor {
         private final Entry entry;
+        private final boolean[] written;
         private boolean hasErrors;
 
         private Editor(Entry entry) {
             this.entry = entry;
+            this.written = (entry.readable) ? null : new boolean[valueCount];
         }
 
         /**
@@ -702,6 +709,9 @@ public final class DiskLruCache implements Closeable {
                 if (entry.currentEditor != this) {
                     throw new IllegalStateException();
                 }
+                if (!entry.readable) {
+                    written[index] = true;
+                }
                 return new FaultHidingOutputStream(new FileOutputStream(entry.getDirtyFile(index)));
             }
         }
diff --git a/luni/src/main/java/libcore/net/http/HttpResponseCache.java b/luni/src/main/java/libcore/net/http/HttpResponseCache.java
index 910461e..2130fd1 100644
--- a/luni/src/main/java/libcore/net/http/HttpResponseCache.java
+++ b/luni/src/main/java/libcore/net/http/HttpResponseCache.java
@@ -426,7 +426,7 @@ public final class HttpResponseCache extends ResponseCache implements ExtendedRe
         }
 
         public void writeTo(DiskLruCache.Editor editor) throws IOException {
-            OutputStream out = editor.newOutputStream(0);
+            OutputStream out = editor.newOutputStream(ENTRY_METADATA);
             Writer writer = new BufferedWriter(new OutputStreamWriter(out, Charsets.UTF_8));
 
             writer.write(uri + '\n');
diff --git a/luni/src/test/java/libcore/io/DiskLruCacheTest.java b/luni/src/test/java/libcore/io/DiskLruCacheTest.java
index 03a6932..2796b65 100644
--- a/luni/src/test/java/libcore/io/DiskLruCacheTest.java
+++ b/luni/src/test/java/libcore/io/DiskLruCacheTest.java
@@ -349,6 +349,28 @@ public final class DiskLruCacheTest extends TestCase {
         creator2.commit();
     }
 
+    public void testCreateNewEntryWithMissingFileAborts() throws Exception {
+        DiskLruCache.Editor creator = cache.edit("k1");
+        creator.set(0, "A");
+        creator.set(1, "A");
+        assertTrue(getDirtyFile("k1", 0).exists());
+        assertTrue(getDirtyFile("k1", 1).exists());
+        assertTrue(getDirtyFile("k1", 0).delete());
+        assertFalse(getDirtyFile("k1", 0).exists());
+        creator.commit();  // silently abort if file does not exist due to I/O issue
+
+        assertFalse(getCleanFile("k1", 0).exists());
+        assertFalse(getCleanFile("k1", 1).exists());
+        assertFalse(getDirtyFile("k1", 0).exists());
+        assertFalse(getDirtyFile("k1", 1).exists());
+        assertNull(cache.get("k1"));
+
+        DiskLruCache.Editor creator2 = cache.edit("k1");
+        creator2.set(0, "B");
+        creator2.set(1, "C");
+        creator2.commit();
+    }
+
     public void testRevertWithTooFewValues() throws Exception {
         DiskLruCache.Editor creator = cache.edit("k1");
         creator.set(1, "A");
@@ -805,4 +827,4 @@ public final class DiskLruCacheTest extends TestCase {
         assertTrue(getCleanFile(key, 1).exists());
         snapshot.close();
     }
-}
\ No newline at end of file
+}
-- 
cgit v1.1


From 3827b65b1937acfbf3abbc449f8ba0ffc60f3cf3 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Tue, 24 Jul 2012 14:02:00 -0700
Subject: Fix URLConnectionTest#test_getAllowUserInteraction.

Also improve the documentation, make it possible to run these tests
individually outside of CTS with vogar, and remove a few more URLs of
external web servers.

We should clean up all tests to remove all reliance on external web servers.

Bug: http://code.google.com/p/android/issues/detail?id=35400
Change-Id: I28e78b7375ee554b3afe98e5249676e8bbbbec0e
---
 luni/src/main/java/java/net/URLConnection.java     |  36 ++-----
 .../java/libcore/net/url/FileURLConnection.java    |  14 +--
 .../luni/tests/java/net/URLConnectionTest.java     | 111 ++++-----------------
 .../java/tests/support/Support_Configuration.java  |  10 --
 .../tests/support/resource/Support_Resources.java  |  20 +++-
 5 files changed, 52 insertions(+), 139 deletions(-)

diff --git a/luni/src/main/java/java/net/URLConnection.java b/luni/src/main/java/java/net/URLConnection.java
index 7cf71d5..c832bfb 100644
--- a/luni/src/main/java/java/net/URLConnection.java
+++ b/luni/src/main/java/java/net/URLConnection.java
@@ -123,8 +123,8 @@ public abstract class URLConnection {
     protected boolean doInput = true;
 
     /**
-     * Specifies whether this {@code URLConnection} allows user interaction as
-     * it is needed for authentication purposes.
+     * Unused by Android. This field can be accessed via {@link #getAllowUserInteraction}
+     * and {@link #setAllowUserInteraction}.
      */
     protected boolean allowUserInteraction = defaultAllowUserInteraction;
 
@@ -167,11 +167,7 @@ public abstract class URLConnection {
     public abstract void connect() throws IOException;
 
     /**
-     * Returns the option value which indicates whether user interaction is allowed
-     * on this {@code URLConnection}.
-     *
-     * @return the value of the option {@code allowUserInteraction}.
-     * @see #allowUserInteraction
+     * Returns {@code allowUserInteraction}. Unused by Android.
      */
     public boolean getAllowUserInteraction() {
         return allowUserInteraction;
@@ -342,11 +338,7 @@ public abstract class URLConnection {
     }
 
     /**
-     * Returns the default setting whether this connection allows user interaction.
-     *
-     * @return the value of the default setting {@code
-     *         defaultAllowUserInteraction}.
-     * @see #allowUserInteraction
+     * Returns the default value of {@code allowUserInteraction}. Unused by Android.
      */
     public static boolean getDefaultAllowUserInteraction() {
         return defaultAllowUserInteraction;
@@ -804,16 +796,7 @@ public abstract class URLConnection {
     }
 
     /**
-     * Sets the flag indicating whether this connection allows user interaction
-     * or not. This method can only be called prior to the connection
-     * establishment.
-     *
-     * @param newValue
-     *            the value of the flag to be set.
-     * @throws IllegalStateException
-     *             if this method attempts to change the flag after the
-     *             connection has been established.
-     * @see #allowUserInteraction
+     * Sets {@code allowUserInteraction}. Unused by Android.
      */
     public void setAllowUserInteraction(boolean newValue) {
         checkNotConnected();
@@ -837,14 +820,7 @@ public abstract class URLConnection {
     }
 
     /**
-     * Sets the default value for the flag indicating whether this connection
-     * allows user interaction or not. Existing {@code URLConnection}s are
-     * unaffected.
-     *
-     * @param allows
-     *            the default value of the flag to be used for new connections.
-     * @see #defaultAllowUserInteraction
-     * @see #allowUserInteraction
+     * Sets the default value for {@code allowUserInteraction}. Unused by Android.
      */
     public static void setDefaultAllowUserInteraction(boolean allows) {
         defaultAllowUserInteraction = allows;
diff --git a/luni/src/main/java/libcore/net/url/FileURLConnection.java b/luni/src/main/java/libcore/net/url/FileURLConnection.java
index bc41169..b4654cd 100644
--- a/luni/src/main/java/libcore/net/url/FileURLConnection.java
+++ b/luni/src/main/java/libcore/net/url/FileURLConnection.java
@@ -38,7 +38,7 @@ import libcore.net.UriCodec;
  */
 public class FileURLConnection extends URLConnection {
 
-    String fileName;
+    private String filename;
 
     private InputStream is;
 
@@ -56,11 +56,11 @@ public class FileURLConnection extends URLConnection {
      */
     public FileURLConnection(URL url) {
         super(url);
-        fileName = url.getFile();
-        if (fileName == null) {
-            fileName = "";
+        filename = url.getFile();
+        if (filename == null) {
+            filename = "";
         }
-        fileName = UriCodec.decode(fileName);
+        filename = UriCodec.decode(filename);
     }
 
     /**
@@ -73,7 +73,7 @@ public class FileURLConnection extends URLConnection {
      */
     @Override
     public void connect() throws IOException {
-        File f = new File(fileName);
+        File f = new File(filename);
         if (f.isDirectory()) {
             isDir = true;
             is = getDirectoryListing(f);
@@ -196,7 +196,7 @@ public class FileURLConnection extends URLConnection {
     @Override
     public java.security.Permission getPermission() throws IOException {
         if (permission == null) {
-            String path = fileName;
+            String path = filename;
             if (File.separatorChar != '/') {
                 path = path.replace('/', File.separatorChar);
             }
diff --git a/luni/src/test/java/org/apache/harmony/luni/tests/java/net/URLConnectionTest.java b/luni/src/test/java/org/apache/harmony/luni/tests/java/net/URLConnectionTest.java
index ab675e2..07e3de5 100644
--- a/luni/src/test/java/org/apache/harmony/luni/tests/java/net/URLConnectionTest.java
+++ b/luni/src/test/java/org/apache/harmony/luni/tests/java/net/URLConnectionTest.java
@@ -219,8 +219,6 @@ public class URLConnectionTest extends TestCase {
     public void setUp() throws Exception {
         super.setUp();
 
-//        ftpURL = new URL(Support_Configuration.testFTPURL);
-
         server = new Support_TestWebServer();
         port = server.initServer();
         url = new URL("http://localhost:" + port + "/test1");
@@ -241,9 +239,6 @@ public class URLConnectionTest extends TestCase {
         server.close();
         ((HttpURLConnection) uc).disconnect();
         ((HttpURLConnection) uc2).disconnect();
-//        if (((FtpURLConnection) ftpURLCon).getInputStream() !=  null) {
-//        ((FtpURLConnection) ftpURLCon).getInputStream().close();
-//        }
     }
 
     /**
@@ -310,66 +305,21 @@ public class URLConnectionTest extends TestCase {
         // TODO: test User-Agent?
     }
 
-    /**
-     * @throws IOException
-     * {@link java.net.URLConnection#getAllowUserInteraction()}
-     */
-    public void test_getAllowUserInteraction() throws IOException {
+    public void test_getAllowUserInteraction() throws Exception {
         uc.setAllowUserInteraction(false);
-        assertFalse("getAllowUserInteraction should have returned false", uc
-                .getAllowUserInteraction());
+        assertFalse(uc.getAllowUserInteraction());
 
         uc.setAllowUserInteraction(true);
-        assertTrue("getAllowUserInteraction should have returned true", uc
-                .getAllowUserInteraction());
+        assertTrue(uc.getAllowUserInteraction());
 
         uc.connect();
 
+        // Can't call the setter after connecting.
         try {
             uc.setAllowUserInteraction(false);
-            fail("Exception expected");
-        } catch (IllegalStateException e) {
-            //ok
+            fail();
+        } catch (IllegalStateException expected) {
         }
-
-        // test if setAllowUserInteraction works
-        URL serverURL = new URL("http://onearth.jpl.nasa.gov/landsat.cgi");
-
-        // connect to server
-        URLConnection uc2 = serverURL.openConnection();
-        HttpURLConnection conn = (HttpURLConnection) uc2;
-        uc2.setAllowUserInteraction(true);
-
-        uc2.setDoInput(true);
-        uc2.setDoOutput(true);
-
-        // get reference to stream to post to
-        OutputStream os = uc2.getOutputStream();
-
-        InputStream in = uc2.getInputStream();
-
-
-        int contentLength = uc2.getContentLength();
-        String contentType = uc2.getContentType();
-        int numBytesRead = 0;
-        int allBytesRead = 0;
-
-        byte[] buffer = new byte[4096];
-
-        do {
-
-        numBytesRead = in.read(buffer);
-        allBytesRead += allBytesRead + numBytesRead;
-
-        } while (numBytesRead > 0);
-
-        assertTrue(allBytesRead > 0);
-
-        uc2.connect();
-
-        numBytesRead = in.read(buffer);
-
-        assertEquals(-1, numBytesRead);
     }
 
     /**
@@ -407,8 +357,9 @@ public class URLConnectionTest extends TestCase {
             buf = r.readLine();
             assertTrue("Incorrect content returned from fileURL: "+buf,
                     testString.equals(buf.trim()));
+            i.close();
         } else {
-            fail("Some unkown type is returned "+obj.toString());
+            fail("Some unknown type is returned "+obj.toString());
         }
 
         //Exception test
@@ -476,6 +427,8 @@ public class URLConnectionTest extends TestCase {
         } catch (NullPointerException e) {
             // expected
         }
+
+        fileURLCon.getInputStream().close();
     }
 
     /**
@@ -514,43 +467,28 @@ public class URLConnectionTest extends TestCase {
     /**
      * {@link java.net.URLConnection#getContentLength()}
      */
-    public void test_getContentLength() {
-        assertEquals(testString.getBytes().length,
-                fileURLCon.getContentLength());
+    public void test_getContentLength() throws Exception {
+        assertEquals(testString.getBytes().length, fileURLCon.getContentLength());
         assertEquals(Support_TestWebData.test1.length, uc.getContentLength());
         assertEquals(Support_TestWebData.test2.length, uc2.getContentLength());
 
         assertNotNull(jarURLCon.getContentLength());
         assertNotNull(gifURLCon.getContentLength());
-    }
 
-    /**
-     * {@link java.net.URLConnection#getContentType()}
-     */
-    public void test_getContentType() throws IOException, MalformedURLException {
+        fileURLCon.getInputStream().close();
+    }
 
+    public void test_getContentType() throws Exception {
         assertTrue("getContentType failed: " + fileURLCon.getContentType(),
                 fileURLCon.getContentType().contains("text/plain"));
 
+        fileURLCon.getInputStream().close();
+
         URLConnection htmlFileCon = openHTMLFile();
         String contentType = htmlFileCon.getContentType();
         if (contentType != null) {
             assertTrue(contentType.equalsIgnoreCase("text/html"));
         }
-
-
-        /*
-        contentType = uc.getContentType();
-        if (contentType != null) {
-        assertTrue(contentType.equalsIgnoreCase("text/html"));
-        }
-
-        contentType = gifURLCon.getContentType();
-        if (contentType != null) {
-        assertTrue(contentType.equalsIgnoreCase("image/gif"));
-        }
-        */
-
     }
 
     /**
@@ -614,15 +552,13 @@ public class URLConnectionTest extends TestCase {
         assertFalse("Should have been set to false", uc2.getDoInput());
 
         fileURLCon.connect();
-        fileURLCon.getInputStream();
+        fileURLCon.getInputStream().close();
 
         uc2.connect();
         try {
             uc2.getInputStream();
-        } catch (Throwable e) {
-            // ok
+        } catch (Throwable expected) {
         }
-
     }
 
     /**
@@ -917,8 +853,7 @@ public class URLConnectionTest extends TestCase {
 
     public void test_getOutputStream() throws IOException {
         String posted = "this is a test";
-        URLConnection uc3 = new URL(Support_Configuration.hTTPURLgoogle)
-                .openConnection();
+        URLConnection uc3 = new URL("http://www.google.com/ie").openConnection();
         uc3.setDoOutput(true);
         uc3.connect();
 
@@ -931,18 +866,16 @@ public class URLConnectionTest extends TestCase {
 
         int code = ((HttpURLConnection) uc3).getResponseCode();
 
-
         // writing to url not allowed
         assertEquals("Got different responseCode ", 405, code);
 
-
         // try exception testing
         try {
             fileURLCon.setDoOutput(true);
             fileURLCon.connect();
+            fileURLCon.getInputStream().close();
             fileURLCon.getOutputStream();
-        } catch (UnknownServiceException e) {
-            // ok cannot write to fileURL
+        } catch (UnknownServiceException expected) {
         }
 
         ((HttpURLConnection) uc2).disconnect();
diff --git a/support/src/test/java/tests/support/Support_Configuration.java b/support/src/test/java/tests/support/Support_Configuration.java
index fed0bc8..9cb617d 100644
--- a/support/src/test/java/tests/support/Support_Configuration.java
+++ b/support/src/test/java/tests/support/Support_Configuration.java
@@ -91,18 +91,8 @@ public class Support_Configuration {
     // than one addresses returned for this host name as needed by a test
     // END android-changed
 
-    public static String testURL = "harmony.apache.org";
-
-    public static String hTTPURLwExpiration = "http://phpwiki.sourceforge.net/phpwiki-1.2/";
-
     public static String hTTPURLwLastModified = "http://www.php.net/manual/en/function.explode.php";
 
-    public static String hTTPURLyahoo = "http://news.yahoo.com/";
-
-    public static String hTTPURLgoogle = "http://www.google.com/ie";
-
-    public static String testContentEncoding = "http://www.amazon.com/";
-
     public static int SpecialInetTestAddressNumber = 4;
 
     /**
diff --git a/support/src/test/java/tests/support/resource/Support_Resources.java b/support/src/test/java/tests/support/resource/Support_Resources.java
index 80a53fb..ddcb881 100644
--- a/support/src/test/java/tests/support/resource/Support_Resources.java
+++ b/support/src/test/java/tests/support/resource/Support_Resources.java
@@ -18,6 +18,7 @@
 package tests.support.resource;
 
 import java.io.File;
+import java.io.FileInputStream;
 import java.io.FileNotFoundException;
 import java.io.FileOutputStream;
 import java.io.IOException;
@@ -34,12 +35,25 @@ public class Support_Resources {
     public static final String RESOURCE_PACKAGE_NAME = "tests.resources";
 
     public static InputStream getStream(String name) {
+        // If we have the resources packaged up in our jar file, get them that way.
         String path = RESOURCE_PACKAGE + name;
         InputStream result = Support_Resources.class.getResourceAsStream(path);
-        if (result == null) {
-            throw new IllegalArgumentException("No such resource: " + path);
+        if (result != null) {
+            return result;
         }
-        return result;
+        // Otherwise, if we're in an Android build tree, get the files directly.
+        String ANDROID_BUILD_TOP = System.getenv("ANDROID_BUILD_TOP");
+        if (ANDROID_BUILD_TOP != null) {
+            File resource = new File(ANDROID_BUILD_TOP + "/libcore/support/src/test/java" + path);
+            if (resource.exists()) {
+                try {
+                    return new FileInputStream(resource);
+                } catch (IOException ex) {
+                    throw new IllegalArgumentException("Couldn't open: " + resource, ex);
+                }
+            }
+        }
+        throw new IllegalArgumentException("No such resource: " + path);
     }
 
     public static String getURL(String name) {
-- 
cgit v1.1


From d77eccc93cbf92c400ebd114ea8e91413b882d69 Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Tue, 24 Jul 2012 17:20:47 -0700
Subject: Address more CipherTest flakiness due to random IV values

In a recent change, we stopped generating random keys to prevent
flakiness in the BadPaddingException test cases. This change removes
the use of random initialization vector (IV) values. There still are
uses of SecureRandom where the API being tested requires it, but I
visually checked that none of the BadPaddingException cases fall in
this category.

Bug: 6873673

(cherry-picked from f19b9c467fb584a79463357e160c0a41c80d05c8)

Change-Id: Id09c322683972751e326569485330c23051ccf0c
---
 .../crypto/tests/javax/crypto/CipherTest.java      | 141 ++++++---------------
 1 file changed, 37 insertions(+), 104 deletions(-)

diff --git a/luni/src/test/java/org/apache/harmony/crypto/tests/javax/crypto/CipherTest.java b/luni/src/test/java/org/apache/harmony/crypto/tests/javax/crypto/CipherTest.java
index 4096a30..88fcdd7 100644
--- a/luni/src/test/java/org/apache/harmony/crypto/tests/javax/crypto/CipherTest.java
+++ b/luni/src/test/java/org/apache/harmony/crypto/tests/javax/crypto/CipherTest.java
@@ -57,6 +57,9 @@ public class CipherTest extends junit.framework.TestCase {
 
     private static final Key CIPHER_KEY_DES;
     private static final String ALGORITHM_DES = "DES";
+    private static final byte[] IV = new byte[] {
+        (byte) 0,  (byte) 1, (byte) 2, (byte) 3, (byte) 4, (byte) 5, (byte) 6, (byte) 7,
+    };
 
     static {
         try {
@@ -203,7 +206,6 @@ public class CipherTest extends junit.framework.TestCase {
      */
     public void test_getOutputSizeI() throws Exception {
 
-        SecureRandom sr = new SecureRandom();
         Cipher cipher = Cipher.getInstance(ALGORITHM_3DES + "/ECB/PKCS5Padding");
 
         try {
@@ -212,7 +214,7 @@ public class CipherTest extends junit.framework.TestCase {
         } catch (IllegalStateException expected) {
         }
 
-        cipher.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_3DES, sr);
+        cipher.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_3DES, new SecureRandom());
 
         // A 25-byte input could result in at least 4 8-byte blocks
         int result = cipher.getOutputSize(25);
@@ -244,13 +246,12 @@ public class CipherTest extends junit.framework.TestCase {
      *        java.security.SecureRandom)
      */
     public void test_initWithSecureRandom() throws Exception {
-        SecureRandom sr = new SecureRandom();
         Cipher cipher = Cipher.getInstance(ALGORITHM_3DES + "/ECB/PKCS5Padding");
-        cipher.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_3DES, sr);
+        cipher.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_3DES, new SecureRandom());
 
         cipher = Cipher.getInstance("DES/CBC/NoPadding");
         try {
-            cipher.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_3DES, sr);
+            cipher.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_3DES, new SecureRandom());
             fail();
         } catch (InvalidKeyException expected) {
         }
@@ -261,23 +262,12 @@ public class CipherTest extends junit.framework.TestCase {
      *        java.security.spec.AlgorithmParameterSpec)
      */
     public void test_initWithAlgorithmParameterSpec() throws Exception {
-        SecureRandom sr = new SecureRandom();
-        Cipher cipher = null;
-
-        byte[] iv = null;
-        AlgorithmParameterSpec ap = null;
-
-        iv = new byte[8];
-        sr.nextBytes(iv);
-        ap = new IvParameterSpec(iv);
-
-        cipher = Cipher.getInstance(ALGORITHM_3DES + "/CBC/PKCS5Padding");
+        AlgorithmParameterSpec ap = new IvParameterSpec(IV);
 
+        Cipher cipher = Cipher.getInstance(ALGORITHM_3DES + "/CBC/PKCS5Padding");
         cipher.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_3DES, ap);
-
         byte[] cipherIV = cipher.getIV();
-
-        assertTrue("IVs differ", Arrays.equals(cipherIV, iv));
+        assertTrue("IVs differ", Arrays.equals(cipherIV, IV));
 
         cipher = Cipher.getInstance("DES/CBC/NoPadding");
         try {
@@ -288,7 +278,6 @@ public class CipherTest extends junit.framework.TestCase {
 
         cipher = Cipher.getInstance("DES/CBC/NoPadding");
         ap = new RSAKeyGenParameterSpec(10, new BigInteger("10"));
-
         try {
             cipher.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES, ap);
             fail();
@@ -302,26 +291,16 @@ public class CipherTest extends junit.framework.TestCase {
      *        java.security.SecureRandom)
      */
     public void test_initWithKeyAlgorithmParameterSpecSecureRandom() throws Exception {
-        SecureRandom sr = new SecureRandom();
-        Cipher cipher = null;
-
-        byte[] iv = null;
-        AlgorithmParameterSpec ap = null;
-
-        iv = new byte[8];
-        sr.nextBytes(iv);
-        ap = new IvParameterSpec(iv);
-
-        cipher = Cipher.getInstance(ALGORITHM_3DES + "/CBC/PKCS5Padding");
-
-        cipher.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_3DES, ap, sr);
+        AlgorithmParameterSpec ap = new IvParameterSpec(IV);
 
+        Cipher cipher = Cipher.getInstance(ALGORITHM_3DES + "/CBC/PKCS5Padding");
+        cipher.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_3DES, ap, new SecureRandom());
         byte[] cipherIV = cipher.getIV();
+        assertTrue("IVs differ", Arrays.equals(cipherIV, IV));
 
-        assertTrue("IVs differ", Arrays.equals(cipherIV, iv));
         cipher = Cipher.getInstance("DES/CBC/NoPadding");
         try {
-            cipher.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_3DES, ap, sr);
+            cipher.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_3DES, ap, new SecureRandom());
             fail();
         } catch (InvalidKeyException expected) {
         }
@@ -330,7 +309,7 @@ public class CipherTest extends junit.framework.TestCase {
         ap = new RSAKeyGenParameterSpec(10, new BigInteger("10"));
 
         try {
-            cipher.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES, ap, sr);
+            cipher.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES, ap, new SecureRandom());
             fail();
         } catch (InvalidAlgorithmParameterException expected) {
         }
@@ -466,11 +445,7 @@ public class CipherTest extends junit.framework.TestCase {
         int len = c.doFinal(b, 0, 16, b1, 0);
         assertEquals(16, len);
 
-        SecureRandom sr = new SecureRandom();
-        byte[] iv = new byte[8];
-        sr.nextBytes(iv);
-        AlgorithmParameterSpec ap = new IvParameterSpec(iv);
-
+        AlgorithmParameterSpec ap = new IvParameterSpec(IV);
         c = Cipher.getInstance("DES/CBC/PKCS5Padding");
         c.init(Cipher.DECRYPT_MODE, CIPHER_KEY_DES, ap);
 
@@ -554,14 +529,9 @@ public class CipherTest extends junit.framework.TestCase {
         int len = c.doFinal(b, 0, 16, b1, 0);
         assertEquals(16, len);
 
-        SecureRandom sr = new SecureRandom();
-        byte[] iv = new byte[8];
-        sr.nextBytes(iv);
-        AlgorithmParameterSpec ap = new IvParameterSpec(iv);
-
+        AlgorithmParameterSpec ap = new IvParameterSpec(IV);
         c = Cipher.getInstance("DES/CBC/PKCS5Padding");
         c.init(Cipher.DECRYPT_MODE, CIPHER_KEY_DES, ap);
-
         try {
             c.doFinal(b1, 0, 24, new byte[42], 0);
             fail();
@@ -674,15 +644,11 @@ public class CipherTest extends junit.framework.TestCase {
         int len = c.doFinal(bInput, bOutput);
         assertEquals(0, len);
 
-        SecureRandom sr = new SecureRandom();
-        byte[] iv = new byte[8];
-        sr.nextBytes(iv);
-        AlgorithmParameterSpec ap = new IvParameterSpec(iv);
+        AlgorithmParameterSpec ap = new IvParameterSpec(IV);
 
         c = Cipher.getInstance("DES/CBC/PKCS5Padding");
         c.init(Cipher.DECRYPT_MODE, CIPHER_KEY_DES, ap);
         bInput = ByteBuffer.allocate(64);
-
         try {
             c.doFinal(bOutput, bInput);
             fail();
@@ -720,10 +686,7 @@ public class CipherTest extends junit.framework.TestCase {
     }
 
     public void test_initWithKeyAlgorithmParameters() throws Exception {
-        SecureRandom sr = new SecureRandom();
-        byte[] iv = new byte[8];
-        sr.nextBytes(iv);
-        AlgorithmParameterSpec ap = new IvParameterSpec(iv);
+        AlgorithmParameterSpec ap = new IvParameterSpec(IV);
 
         Cipher c = Cipher.getInstance("DES/CBC/PKCS5Padding");
         c.init(Cipher.DECRYPT_MODE, CIPHER_KEY_DES, ap);
@@ -743,13 +706,10 @@ public class CipherTest extends junit.framework.TestCase {
     }
 
     public void test_initWithKeyAlgorithmParametersSecureRandom() throws Exception {
-        SecureRandom sr = new SecureRandom();
-        byte[] iv = new byte[8];
-        sr.nextBytes(iv);
-        AlgorithmParameterSpec ap = new IvParameterSpec(iv);
+        AlgorithmParameterSpec ap = new IvParameterSpec(IV);
 
         Cipher c = Cipher.getInstance("DES/CBC/PKCS5Padding");
-        c.init(Cipher.DECRYPT_MODE, CIPHER_KEY_DES, ap, sr);
+        c.init(Cipher.DECRYPT_MODE, CIPHER_KEY_DES, ap, new SecureRandom());
         assertNotNull(c.getParameters());
 
         try {
@@ -759,7 +719,8 @@ public class CipherTest extends junit.framework.TestCase {
         }
 
         try {
-            c.init(Cipher.DECRYPT_MODE, CIPHER_KEY_DES, (AlgorithmParameters)null, sr);
+            c.init(Cipher.DECRYPT_MODE, CIPHER_KEY_DES, (AlgorithmParameters)null,
+                   new SecureRandom());
             fail();
         } catch (InvalidAlgorithmParameterException expected) {
         }
@@ -829,14 +790,11 @@ public class CipherTest extends junit.framework.TestCase {
     }
 
     public void test_unwrap$BLjava_lang_StringI() throws Exception {
-        SecureRandom sr = new SecureRandom();
-        byte[] iv = new byte[8];
-        sr.nextBytes(iv);
-        AlgorithmParameterSpec ap = new IvParameterSpec(iv);
+        AlgorithmParameterSpec ap = new IvParameterSpec(IV);
 
         Cipher c = Cipher.getInstance("DES/CBC/PKCS5Padding");
 
-        c.init(Cipher.WRAP_MODE, CIPHER_KEY_DES, ap, sr);
+        c.init(Cipher.WRAP_MODE, CIPHER_KEY_DES, ap, new SecureRandom());
         byte[] arDES = c.wrap(CIPHER_KEY_DES);
         byte[] ar    = c.wrap(CIPHER_KEY_3DES);
 
@@ -846,7 +804,7 @@ public class CipherTest extends junit.framework.TestCase {
         } catch (IllegalStateException expected) {
         }
 
-        c.init(Cipher.UNWRAP_MODE, CIPHER_KEY_DES, ap, sr);
+        c.init(Cipher.UNWRAP_MODE, CIPHER_KEY_DES, ap, new SecureRandom());
         assertTrue(CIPHER_KEY_DES.equals(c.unwrap(arDES, "DES", Cipher.SECRET_KEY)));
         assertFalse(CIPHER_KEY_DES.equals(c.unwrap(ar, "DES", Cipher.SECRET_KEY)));
 
@@ -857,7 +815,7 @@ public class CipherTest extends junit.framework.TestCase {
         }
 
         c = Cipher.getInstance("DESede/CBC/PKCS5Padding");
-        c.init(Cipher.UNWRAP_MODE, CIPHER_KEY_3DES, ap, sr);
+        c.init(Cipher.UNWRAP_MODE, CIPHER_KEY_3DES, ap, new SecureRandom());
         try {
             c.unwrap(arDES, "DESede", Cipher.SECRET_KEY);
             fail();
@@ -892,10 +850,7 @@ public class CipherTest extends junit.framework.TestCase {
         bOutput.rewind();
         c.update(bInput, bOutput);
 
-        SecureRandom sr = new SecureRandom();
-        byte[] iv = new byte[8];
-        sr.nextBytes(iv);
-        AlgorithmParameterSpec ap = new IvParameterSpec(iv);
+        AlgorithmParameterSpec ap = new IvParameterSpec(IV);
 
         c = Cipher.getInstance("DES/CBC/PKCS5Padding");
         c.init(Cipher.DECRYPT_MODE, CIPHER_KEY_DES, ap);
@@ -951,14 +906,11 @@ public class CipherTest extends junit.framework.TestCase {
     }
 
     public void test_wrap_java_security_Key() throws Exception {
-        SecureRandom sr = new SecureRandom();
-        byte[] iv = new byte[8];
-        sr.nextBytes(iv);
-        AlgorithmParameterSpec ap = new IvParameterSpec(iv);
+        AlgorithmParameterSpec ap = new IvParameterSpec(IV);
 
         Cipher c = Cipher.getInstance("DES/CBC/PKCS5Padding");
 
-        c.init(Cipher.WRAP_MODE, CIPHER_KEY_DES, ap, sr);
+        c.init(Cipher.WRAP_MODE, CIPHER_KEY_DES, ap, new SecureRandom());
         assertNotNull(c.wrap(CIPHER_KEY_DES));
         assertNotNull(c.wrap(CIPHER_KEY_3DES));
         String certName = Support_Resources.getURL("test.cert");
@@ -969,14 +921,14 @@ public class CipherTest extends junit.framework.TestCase {
         assertNotNull(c.wrap(cert.getPublicKey()));
 
         c = Cipher.getInstance("DES/CBC/NoPadding");
-        c.init(Cipher.WRAP_MODE, CIPHER_KEY_DES, ap, sr);
+        c.init(Cipher.WRAP_MODE, CIPHER_KEY_DES, ap, new SecureRandom());
         try {
             assertNotNull(c.wrap(cert.getPublicKey()));
             fail();
         } catch (IllegalBlockSizeException expected) {
         }
 
-        c.init(Cipher.DECRYPT_MODE, CIPHER_KEY_DES, ap, sr);
+        c.init(Cipher.DECRYPT_MODE, CIPHER_KEY_DES, ap, new SecureRandom());
 
         try {
             c.wrap(CIPHER_KEY_DES);
@@ -984,7 +936,7 @@ public class CipherTest extends junit.framework.TestCase {
         } catch (IllegalStateException expected) {
         }
 
-        c.init(Cipher.WRAP_MODE, CIPHER_KEY_DES, ap, sr);
+        c.init(Cipher.WRAP_MODE, CIPHER_KEY_DES, ap, new SecureRandom());
         try {
             c.wrap(new Mock_Key());
             fail();
@@ -1018,14 +970,10 @@ public class CipherTest extends junit.framework.TestCase {
         int len = c.doFinal(b1, 0);
         assertEquals(0, len);
 
-        SecureRandom sr = new SecureRandom();
-        byte[] iv = new byte[8];
-        sr.nextBytes(iv);
-        AlgorithmParameterSpec ap = new IvParameterSpec(iv);
+        AlgorithmParameterSpec ap = new IvParameterSpec(IV);
 
         c = Cipher.getInstance("DES/CBC/PKCS5Padding");
         c.init(Cipher.DECRYPT_MODE, CIPHER_KEY_DES, ap);
-
         c.update(b1, 0, 24);
         try {
             c.doFinal(b, 0);
@@ -1074,14 +1022,9 @@ public class CipherTest extends junit.framework.TestCase {
         int len2 = c.doFinal(bI3, 0, 16, b1, 0);
         assertEquals(16, len2);
 
-        SecureRandom sr = new SecureRandom();
-        byte[] iv = new byte[8];
-        sr.nextBytes(iv);
-        AlgorithmParameterSpec ap = new IvParameterSpec(iv);
-
+        AlgorithmParameterSpec ap = new IvParameterSpec(IV);
         c = Cipher.getInstance("DES/CBC/PKCS5Padding");
         c.init(Cipher.DECRYPT_MODE, CIPHER_KEY_DES, ap);
-
         try {
             c.doFinal(b1);
             fail();
@@ -1116,14 +1059,9 @@ public class CipherTest extends junit.framework.TestCase {
         int len2 = c.doFinal(b, 0, 16, b1, 0);
         assertEquals(16, len2);
 
-        SecureRandom sr = new SecureRandom();
-        byte[] iv = new byte[8];
-        sr.nextBytes(iv);
-        AlgorithmParameterSpec ap = new IvParameterSpec(iv);
-
+        AlgorithmParameterSpec ap = new IvParameterSpec(IV);
         c = Cipher.getInstance("DES/CBC/PKCS5Padding");
         c.init(Cipher.DECRYPT_MODE, CIPHER_KEY_DES, ap);
-
         try {
             c.doFinal(b1, 0, 24);
             fail();
@@ -1155,14 +1093,9 @@ public class CipherTest extends junit.framework.TestCase {
         int len = c.doFinal(b, 0, 16, b1);
         assertEquals(16, len);
 
-        SecureRandom sr = new SecureRandom();
-        byte[] iv = new byte[8];
-        sr.nextBytes(iv);
-        AlgorithmParameterSpec ap = new IvParameterSpec(iv);
-
+        AlgorithmParameterSpec ap = new IvParameterSpec(IV);
         c = Cipher.getInstance("DES/CBC/PKCS5Padding");
         c.init(Cipher.DECRYPT_MODE, CIPHER_KEY_DES, ap);
-
         try {
             c.doFinal(b1, 0, 24, new byte[42]);
             fail();
-- 
cgit v1.1


From cb2b8297a922992f27e0bcee9437e1b7a05483de Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Wed, 25 Jul 2012 11:50:16 -0700
Subject: Improve the assertion detail in flaky ThreadsTest.

Bug: 6595290
Change-Id: I2a0df0e5cf44ad7d468b1957694720a49a481459
---
 .../java/tests/api/org/apache/harmony/kernel/dalvik/ThreadsTest.java | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/luni/src/test/java/tests/api/org/apache/harmony/kernel/dalvik/ThreadsTest.java b/luni/src/test/java/tests/api/org/apache/harmony/kernel/dalvik/ThreadsTest.java
index 286d4ab..bdc580d 100644
--- a/luni/src/test/java/tests/api/org/apache/harmony/kernel/dalvik/ThreadsTest.java
+++ b/luni/src/test/java/tests/api/org/apache/harmony/kernel/dalvik/ThreadsTest.java
@@ -187,11 +187,10 @@ public class ThreadsTest extends TestCase {
                 if (! completed) {
                     try {
                         wait(maxWaitMillis);
-                    } catch (InterruptedException ex) {
-                        // Ignore it.
+                    } catch (InterruptedException ignored) {
                     }
                     if (! completed) {
-                        Assert.fail("parker hanging");
+                        Assert.fail("parker hung for more than " + maxWaitMillis + " ms");
                     }
                 }
 
-- 
cgit v1.1


From a57c521b9d250f909508af771b96c0011676a968 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Thu, 26 Jul 2012 10:32:29 -0700
Subject: Make ZipFileTest#testHugeZipFile faster, and reduce ZipFile memory
 usage.

This test was timing out because of unbuffered I/O.

ZipFile was creating an unnecessary byte[] when writing out the central
directory. In the case of these tests, that was an extra 3MiB of heap!

Bug: 6481730
Change-Id: I75acac35c556ad5fdc8b06bc616c11244d6b6c55
---
 luni/src/main/java/java/util/zip/ZipOutputStream.java     | 4 ++--
 luni/src/test/java/libcore/java/util/zip/ZipFileTest.java | 5 +++--
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/luni/src/main/java/java/util/zip/ZipOutputStream.java b/luni/src/main/java/java/util/zip/ZipOutputStream.java
index 9a56fa2..47db8f6 100644
--- a/luni/src/main/java/java/util/zip/ZipOutputStream.java
+++ b/luni/src/main/java/java/util/zip/ZipOutputStream.java
@@ -248,8 +248,8 @@ public class ZipOutputStream extends DeflaterOutputStream implements ZipConstant
         } else {
             writeShort(cDir, 0);
         }
-        // Write the central dir
-        out.write(cDir.toByteArray());
+        // Write the central directory.
+        cDir.writeTo(out);
         cDir = null;
     }
 
diff --git a/luni/src/test/java/libcore/java/util/zip/ZipFileTest.java b/luni/src/test/java/libcore/java/util/zip/ZipFileTest.java
index b7a6050..7e8286e 100644
--- a/luni/src/test/java/libcore/java/util/zip/ZipFileTest.java
+++ b/luni/src/test/java/libcore/java/util/zip/ZipFileTest.java
@@ -16,6 +16,7 @@
 
 package libcore.java.util.zip;
 
+import java.io.BufferedOutputStream;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
@@ -114,9 +115,9 @@ public final class ZipFileTest extends TestCase {
           File result = File.createTempFile("ZipFileTest", "zip");
           result.deleteOnExit();
 
-          ZipOutputStream out = new ZipOutputStream(new FileOutputStream(result));
+          ZipOutputStream out = new ZipOutputStream(new BufferedOutputStream(new FileOutputStream(result)));
           for (int i = 0; i < count; ++i) {
-              ZipEntry entry = new ZipEntry(Integer.toString(i));
+              ZipEntry entry = new ZipEntry(Integer.toHexString(i));
               out.putNextEntry(entry);
               out.closeEntry();
           }
-- 
cgit v1.1


From 26841c0bb838d54fea2e1a06390e413fab561e27 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Thu, 26 Jul 2012 12:11:45 -0700
Subject: Remove useless checkIndex calls from the asXBuffer adapter classes.

Also add tests that we throw the expected exceptions.

Bug: 6085292
Change-Id: Ibcc44bdb546cba5365cdf557847e068fea77e1ca
---
 .../java/java/nio/CharToByteBufferAdapter.java     |  1 -
 .../java/java/nio/DoubleToByteBufferAdapter.java   |  1 -
 .../java/java/nio/FloatToByteBufferAdapter.java    |  1 -
 .../main/java/java/nio/IntToByteBufferAdapter.java |  1 -
 .../java/java/nio/LongToByteBufferAdapter.java     |  1 -
 .../java/java/nio/ShortToByteBufferAdapter.java    |  1 -
 .../src/test/java/libcore/java/nio/BufferTest.java | 70 ++++++++++++++++++++++
 7 files changed, 70 insertions(+), 6 deletions(-)

diff --git a/luni/src/main/java/java/nio/CharToByteBufferAdapter.java b/luni/src/main/java/java/nio/CharToByteBufferAdapter.java
index b9100a2..86c7186 100644
--- a/luni/src/main/java/java/nio/CharToByteBufferAdapter.java
+++ b/luni/src/main/java/java/nio/CharToByteBufferAdapter.java
@@ -93,7 +93,6 @@ final class CharToByteBufferAdapter extends CharBuffer {
 
     @Override
     public char get(int index) {
-        checkIndex(index);
         return byteBuffer.getChar(index * SizeOf.CHAR);
     }
 
diff --git a/luni/src/main/java/java/nio/DoubleToByteBufferAdapter.java b/luni/src/main/java/java/nio/DoubleToByteBufferAdapter.java
index 8b1e084..ead4ef0 100644
--- a/luni/src/main/java/java/nio/DoubleToByteBufferAdapter.java
+++ b/luni/src/main/java/java/nio/DoubleToByteBufferAdapter.java
@@ -93,7 +93,6 @@ final class DoubleToByteBufferAdapter extends DoubleBuffer {
 
     @Override
     public double get(int index) {
-        checkIndex(index);
         return byteBuffer.getDouble(index * SizeOf.DOUBLE);
     }
 
diff --git a/luni/src/main/java/java/nio/FloatToByteBufferAdapter.java b/luni/src/main/java/java/nio/FloatToByteBufferAdapter.java
index 0ed944b..f7733c1 100644
--- a/luni/src/main/java/java/nio/FloatToByteBufferAdapter.java
+++ b/luni/src/main/java/java/nio/FloatToByteBufferAdapter.java
@@ -92,7 +92,6 @@ final class FloatToByteBufferAdapter extends FloatBuffer {
 
     @Override
     public float get(int index) {
-        checkIndex(index);
         return byteBuffer.getFloat(index * SizeOf.FLOAT);
     }
 
diff --git a/luni/src/main/java/java/nio/IntToByteBufferAdapter.java b/luni/src/main/java/java/nio/IntToByteBufferAdapter.java
index 1af5f86..29aff41 100644
--- a/luni/src/main/java/java/nio/IntToByteBufferAdapter.java
+++ b/luni/src/main/java/java/nio/IntToByteBufferAdapter.java
@@ -93,7 +93,6 @@ final class IntToByteBufferAdapter extends IntBuffer {
 
     @Override
     public int get(int index) {
-        checkIndex(index);
         return byteBuffer.getInt(index * SizeOf.INT);
     }
 
diff --git a/luni/src/main/java/java/nio/LongToByteBufferAdapter.java b/luni/src/main/java/java/nio/LongToByteBufferAdapter.java
index e8bf8df..7fb033b 100644
--- a/luni/src/main/java/java/nio/LongToByteBufferAdapter.java
+++ b/luni/src/main/java/java/nio/LongToByteBufferAdapter.java
@@ -93,7 +93,6 @@ final class LongToByteBufferAdapter extends LongBuffer {
 
     @Override
     public long get(int index) {
-        checkIndex(index);
         return byteBuffer.getLong(index * SizeOf.LONG);
     }
 
diff --git a/luni/src/main/java/java/nio/ShortToByteBufferAdapter.java b/luni/src/main/java/java/nio/ShortToByteBufferAdapter.java
index ee36709..e53e355 100644
--- a/luni/src/main/java/java/nio/ShortToByteBufferAdapter.java
+++ b/luni/src/main/java/java/nio/ShortToByteBufferAdapter.java
@@ -92,7 +92,6 @@ final class ShortToByteBufferAdapter extends ShortBuffer {
 
     @Override
     public short get(int index) {
-        checkIndex(index);
         return byteBuffer.getShort(index * SizeOf.SHORT);
     }
 
diff --git a/luni/src/test/java/libcore/java/nio/BufferTest.java b/luni/src/test/java/libcore/java/nio/BufferTest.java
index 06a8e94..41ee3f7 100644
--- a/luni/src/test/java/libcore/java/nio/BufferTest.java
+++ b/luni/src/test/java/libcore/java/nio/BufferTest.java
@@ -675,4 +675,74 @@ public class BufferTest extends TestCase {
         }
         assertFalse(bb.hasArray());
     }
+
+    public void testBug6085292() {
+        ByteBuffer b = ByteBuffer.allocateDirect(1);
+
+        try {
+            b.asCharBuffer().get();
+            fail();
+        } catch (BufferUnderflowException expected) {
+        }
+        try {
+            b.asCharBuffer().get(0);
+            fail();
+        } catch (IndexOutOfBoundsException expected) {
+        }
+
+        try {
+            b.asDoubleBuffer().get();
+            fail();
+        } catch (BufferUnderflowException expected) {
+        }
+        try {
+            b.asDoubleBuffer().get(0);
+            fail();
+        } catch (IndexOutOfBoundsException expected) {
+        }
+
+        try {
+            b.asFloatBuffer().get();
+            fail();
+        } catch (BufferUnderflowException expected) {
+        }
+        try {
+            b.asFloatBuffer().get(0);
+            fail();
+        } catch (IndexOutOfBoundsException expected) {
+        }
+
+        try {
+            b.asIntBuffer().get();
+            fail();
+        } catch (BufferUnderflowException expected) {
+        }
+        try {
+            b.asIntBuffer().get(0);
+            fail();
+        } catch (IndexOutOfBoundsException expected) {
+        }
+
+        try {
+            b.asLongBuffer().get();
+            fail();
+        } catch (BufferUnderflowException expected) {
+        }
+        try {
+            b.asLongBuffer().get(0);
+            fail();
+        } catch (IndexOutOfBoundsException expected) {
+        }
+
+        try {
+            b.asShortBuffer().get();
+            fail();
+        } catch (BufferUnderflowException expected) {
+        }
+        try {
+            b.asShortBuffer().get(0);
+            fail();
+        } catch (IndexOutOfBoundsException expected) {
+        }
+    }
 }
-- 
cgit v1.1


From 3441ddaa2ce320360292702dd63dad052cb6999d Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Thu, 26 Jul 2012 12:21:51 -0700
Subject: Fix even more CipherTest flakiness due to implicit random IV values

When Cipher.init is not passed AlgorithmParameters, it will implicitly
generate what it needs, leading to random values that occasionally
caused BadPaddingException not to be thrown when expected. Disable
that behavior by explictly passing in the static IV value.

Bug: 6354967
Change-Id: I804c7e30e1c29b92780a9b6271c35505835d58f5
---
 .../crypto/tests/javax/crypto/CipherTest.java      | 49 +++++++++++-----------
 1 file changed, 24 insertions(+), 25 deletions(-)

diff --git a/luni/src/test/java/org/apache/harmony/crypto/tests/javax/crypto/CipherTest.java b/luni/src/test/java/org/apache/harmony/crypto/tests/javax/crypto/CipherTest.java
index 88fcdd7..7442210 100644
--- a/luni/src/test/java/org/apache/harmony/crypto/tests/javax/crypto/CipherTest.java
+++ b/luni/src/test/java/org/apache/harmony/crypto/tests/javax/crypto/CipherTest.java
@@ -423,9 +423,10 @@ public class CipherTest extends junit.framework.TestCase {
 
         byte[] b = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};
         byte[] b1 = new byte[30];
+        AlgorithmParameterSpec ap = new IvParameterSpec(IV);
 
         Cipher c = Cipher.getInstance("DES/CBC/NoPadding");
-        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES);
+        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES, ap);
         c.update(b, 0, 10, b1, 5);
         try {
             c.doFinal();
@@ -441,13 +442,13 @@ public class CipherTest extends junit.framework.TestCase {
         }
 
         c = Cipher.getInstance("DES/CBC/NoPadding");
-        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES);
+        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES, ap);
         int len = c.doFinal(b, 0, 16, b1, 0);
         assertEquals(16, len);
 
-        AlgorithmParameterSpec ap = new IvParameterSpec(IV);
         c = Cipher.getInstance("DES/CBC/PKCS5Padding");
         c.init(Cipher.DECRYPT_MODE, CIPHER_KEY_DES, ap);
+        assertTrue(Arrays.equals(c.getIV(), IV));
 
         c.update(b1, 0, 24, b, 0);
         try {
@@ -508,9 +509,10 @@ public class CipherTest extends junit.framework.TestCase {
     public void testDoFinalbyteArrayintintbyteArrayint() throws Exception {
         byte[] b = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};
         byte[] b1 = new byte[30];
+        AlgorithmParameterSpec ap = new IvParameterSpec(IV);
 
         Cipher c = Cipher.getInstance("DES/CBC/NoPadding");
-        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES);
+        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES, ap);
         try {
             c.doFinal(b, 0, 10, b1, 5);
             fail();
@@ -525,11 +527,10 @@ public class CipherTest extends junit.framework.TestCase {
         }
 
         c = Cipher.getInstance("DES/CBC/NoPadding");
-        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES);
+        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES, ap);
         int len = c.doFinal(b, 0, 16, b1, 0);
         assertEquals(16, len);
 
-        AlgorithmParameterSpec ap = new IvParameterSpec(IV);
         c = Cipher.getInstance("DES/CBC/PKCS5Padding");
         c.init(Cipher.DECRYPT_MODE, CIPHER_KEY_DES, ap);
         try {
@@ -620,9 +621,10 @@ public class CipherTest extends junit.framework.TestCase {
         byte[] b = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};
         ByteBuffer bInput = ByteBuffer.allocate(64);
         ByteBuffer bOutput = ByteBuffer.allocate(64);
+        AlgorithmParameterSpec ap = new IvParameterSpec(IV);
 
         Cipher c = Cipher.getInstance("DES/CBC/NoPadding");
-        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES);
+        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES, ap);
         bInput.put(b, 0, 10);
         try {
             c.doFinal(bInput, bOutput);
@@ -638,14 +640,12 @@ public class CipherTest extends junit.framework.TestCase {
         }
 
         c = Cipher.getInstance("DES/CBC/NoPadding");
-        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES);
+        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES, ap);
         bInput = ByteBuffer.allocate(16);
         bInput.put(b, 0, 16);
         int len = c.doFinal(bInput, bOutput);
         assertEquals(0, len);
 
-        AlgorithmParameterSpec ap = new IvParameterSpec(IV);
-
         c = Cipher.getInstance("DES/CBC/PKCS5Padding");
         c.init(Cipher.DECRYPT_MODE, CIPHER_KEY_DES, ap);
         bInput = ByteBuffer.allocate(64);
@@ -947,9 +947,10 @@ public class CipherTest extends junit.framework.TestCase {
     public void test_doFinal$BI() throws Exception {
         byte[] b = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};
         byte[] b1 = new byte[30];
+        AlgorithmParameterSpec ap = new IvParameterSpec(IV);
 
         Cipher c = Cipher.getInstance("DES/CBC/NoPadding");
-        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES);
+        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES, ap);
         c.update(b, 0, 10);
         try {
             c.doFinal(b1, 5);
@@ -965,13 +966,11 @@ public class CipherTest extends junit.framework.TestCase {
         }
 
         c = Cipher.getInstance("DES/CBC/NoPadding");
-        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES);
+        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES, ap);
         c.update(b, 3, 8);
         int len = c.doFinal(b1, 0);
         assertEquals(0, len);
 
-        AlgorithmParameterSpec ap = new IvParameterSpec(IV);
-
         c = Cipher.getInstance("DES/CBC/PKCS5Padding");
         c.init(Cipher.DECRYPT_MODE, CIPHER_KEY_DES, ap);
         c.update(b1, 0, 24);
@@ -998,9 +997,10 @@ public class CipherTest extends junit.framework.TestCase {
         byte[] bI2 = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16};
         byte[] bI3 = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};
         byte[] bI4 = {1,2,3};
+        AlgorithmParameterSpec ap = new IvParameterSpec(IV);
 
         Cipher c = Cipher.getInstance("DES/CBC/NoPadding");
-        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES);
+        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES, ap);
         try {
             c.doFinal(bI1);
             fail();
@@ -1015,14 +1015,13 @@ public class CipherTest extends junit.framework.TestCase {
         }
 
         c = Cipher.getInstance("DES/CBC/NoPadding");
-        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES);
+        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES, ap);
         int len1 = c.doFinal(bI2).length;
         assertEquals(16, len1);
-        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES);
+        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES, ap);
         int len2 = c.doFinal(bI3, 0, 16, b1, 0);
         assertEquals(16, len2);
 
-        AlgorithmParameterSpec ap = new IvParameterSpec(IV);
         c = Cipher.getInstance("DES/CBC/PKCS5Padding");
         c.init(Cipher.DECRYPT_MODE, CIPHER_KEY_DES, ap);
         try {
@@ -1035,9 +1034,10 @@ public class CipherTest extends junit.framework.TestCase {
     public void test_doFinal$BII() throws Exception {
         byte[] b = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};
         byte[] b1 = new byte[30];
+        AlgorithmParameterSpec ap = new IvParameterSpec(IV);
 
         Cipher c = Cipher.getInstance("DES/CBC/NoPadding");
-        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES);
+        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES, ap);
         try {
             c.doFinal(b, 0, 10);
             fail();
@@ -1052,14 +1052,13 @@ public class CipherTest extends junit.framework.TestCase {
         }
 
         c = Cipher.getInstance("DES/CBC/NoPadding");
-        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES);
+        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES, ap);
         int len1 = c.doFinal(b, 0, 16).length;
         assertEquals(16, len1);
-        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES);
+        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES, ap);
         int len2 = c.doFinal(b, 0, 16, b1, 0);
         assertEquals(16, len2);
 
-        AlgorithmParameterSpec ap = new IvParameterSpec(IV);
         c = Cipher.getInstance("DES/CBC/PKCS5Padding");
         c.init(Cipher.DECRYPT_MODE, CIPHER_KEY_DES, ap);
         try {
@@ -1072,9 +1071,10 @@ public class CipherTest extends junit.framework.TestCase {
     public void test_doFinal$BII$B() throws Exception {
         byte[] b = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};
         byte[] b1 = new byte[30];
+        AlgorithmParameterSpec ap = new IvParameterSpec(IV);
 
         Cipher c = Cipher.getInstance("DES/CBC/NoPadding");
-        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES);
+        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES, ap);
         try {
             c.doFinal(b, 0, 10, b1);
             fail();
@@ -1089,11 +1089,10 @@ public class CipherTest extends junit.framework.TestCase {
         }
 
         c = Cipher.getInstance("DES/CBC/NoPadding");
-        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES);
+        c.init(Cipher.ENCRYPT_MODE, CIPHER_KEY_DES, ap);
         int len = c.doFinal(b, 0, 16, b1);
         assertEquals(16, len);
 
-        AlgorithmParameterSpec ap = new IvParameterSpec(IV);
         c = Cipher.getInstance("DES/CBC/PKCS5Padding");
         c.init(Cipher.DECRYPT_MODE, CIPHER_KEY_DES, ap);
         try {
-- 
cgit v1.1


From d1725822187cb9bbe4d93fe39135b17ecb3130ee Mon Sep 17 00:00:00 2001
From: Geremy Condra <gcondra@google.com>
Date: Thu, 26 Jul 2012 16:35:12 -0700
Subject: Tests for the CertBlacklist.

Change-Id: Id453884228d10374b03f06c5fc795b68811ecc56
---
 .../com/android/org/bouncycastle/jce/provider/CertBlacklistTest.java    | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/luni/src/test/java/com/android/org/bouncycastle/jce/provider/CertBlacklistTest.java b/luni/src/test/java/com/android/org/bouncycastle/jce/provider/CertBlacklistTest.java
index 85e360e..bd12aea 100644
--- a/luni/src/test/java/com/android/org/bouncycastle/jce/provider/CertBlacklistTest.java
+++ b/luni/src/test/java/com/android/org/bouncycastle/jce/provider/CertBlacklistTest.java
@@ -64,7 +64,7 @@ public class CertBlacklistTest extends TestCase {
         // convert the results to a hashset of strings
         Set<String> results = new HashSet<String>();
         for (byte[] value: arr) {
-            results.add(new String(Hex.encode(value)));
+            results.add(new String(value));
         }
         return results;
     }
-- 
cgit v1.1


From 05895faacf43e6fd2bcd57baed31832f6888cb31 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Thu, 26 Jul 2012 17:28:06 -0700
Subject: Fix deserialization of transient fields.

We need to read field data in the stream, but if the field is (now)
transient, we should just ignore the request to set it.

Bug: 4471249
Change-Id: I5336fdeaaef73e912a48be53af75fd9d1b29fccf
---
 luni/src/main/java/java/io/ObjectInputStream.java         |  8 ++++++--
 luni/src/main/java/java/io/ObjectStreamClass.java         |  8 +++-----
 luni/src/test/java/libcore/java/io/SerializationTest.java | 10 ++++++++++
 3 files changed, 19 insertions(+), 7 deletions(-)

diff --git a/luni/src/main/java/java/io/ObjectInputStream.java b/luni/src/main/java/java/io/ObjectInputStream.java
index 4541f1b..acf00af 100644
--- a/luni/src/main/java/java/io/ObjectInputStream.java
+++ b/luni/src/main/java/java/io/ObjectInputStream.java
@@ -23,6 +23,7 @@ import java.lang.reflect.Array;
 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
 import java.lang.reflect.Proxy;
 import java.security.PrivilegedAction;
 import java.util.ArrayList;
@@ -1089,8 +1090,11 @@ public class ObjectInputStream extends InputStream implements ObjectInput, Objec
 
         for (ObjectStreamField fieldDesc : fields) {
             Field field = classDesc.getReflectionField(fieldDesc);
-            // We may not have been able to find the field, but we still need to read the value
-            // and do the other checking, so there's no null check on 'field' here.
+            if (Modifier.isTransient(field.getModifiers())) {
+                field = null; // No setting transient fields! (http://b/4471249)
+            }
+            // We may not have been able to find the field, or it may be transient, but we still
+            // need to read the value and do the other checking...
             try {
                 Class<?> type = fieldDesc.getTypeInternal();
                 if (type == byte.class) {
diff --git a/luni/src/main/java/java/io/ObjectStreamClass.java b/luni/src/main/java/java/io/ObjectStreamClass.java
index e87fcd4..a28489a 100644
--- a/luni/src/main/java/java/io/ObjectStreamClass.java
+++ b/luni/src/main/java/java/io/ObjectStreamClass.java
@@ -481,16 +481,14 @@ public class ObjectStreamClass implements Serializable {
                 Field field = fields[i];
                 int modifiers = field.getModifiers() & FIELD_MODIFIERS_MASK;
 
-                boolean skip = Modifier.isPrivate(modifiers)
-                        && (Modifier.isTransient(modifiers) || Modifier
-                                .isStatic(modifiers));
+                boolean skip = Modifier.isPrivate(modifiers) &&
+                        (Modifier.isTransient(modifiers) || Modifier.isStatic(modifiers));
                 if (!skip) {
                     // write name, modifier & "descriptor" of all but private
                     // static and private transient
                     output.writeUTF(field.getName());
                     output.writeInt(modifiers);
-                    output
-                            .writeUTF(descriptorForFieldSignature(getFieldSignature(field)));
+                    output.writeUTF(descriptorForFieldSignature(getFieldSignature(field)));
                 }
             }
 
diff --git a/luni/src/test/java/libcore/java/io/SerializationTest.java b/luni/src/test/java/libcore/java/io/SerializationTest.java
index 434dd56..d452c11 100644
--- a/luni/src/test/java/libcore/java/io/SerializationTest.java
+++ b/luni/src/test/java/libcore/java/io/SerializationTest.java
@@ -18,6 +18,8 @@ package libcore.java.io;
 
 import java.io.IOException;
 import java.io.InvalidClassException;
+import java.io.ObjectStreamClass;
+import java.io.ObjectStreamField;
 import java.io.Serializable;
 import junit.framework.TestCase;
 import libcore.util.SerializationTester;
@@ -26,6 +28,13 @@ public final class SerializationTest extends TestCase {
 
     // http://b/4471249
     public void testSerializeFieldMadeTransient() throws Exception {
+        // Does ObjectStreamClass have the right idea?
+        ObjectStreamClass osc = ObjectStreamClass.lookup(FieldMadeTransient.class);
+        ObjectStreamField[] fields = osc.getFields();
+        assertEquals(1, fields.length);
+        assertEquals("nonTransientInt", fields[0].getName());
+        assertEquals(int.class, fields[0].getType());
+
         // this was created by serializing a FieldMadeTransient with a non-0 transientInt
         String s = "aced0005737200346c6962636f72652e6a6176612e696f2e53657269616c697a6174696f6e54657"
                 + "374244669656c644d6164655472616e7369656e74000000000000000002000149000c7472616e736"
@@ -37,6 +46,7 @@ public final class SerializationTest extends TestCase {
     static class FieldMadeTransient implements Serializable {
         private static final long serialVersionUID = 0L;
         private transient int transientInt;
+        private int nonTransientInt;
     }
 
     public void testSerialVersionUidChange() throws Exception {
-- 
cgit v1.1


From 0dc81a43663d3e66da8750b69ff2aa78eec461f9 Mon Sep 17 00:00:00 2001
From: Geremy Condra <gcondra@google.com>
Date: Thu, 26 Jul 2012 19:32:21 -0700
Subject: Add test for isPubkeyBlacklisted

This adds a negative and positive test for pubkey blacklisting.

Change-Id: I20b23e041db624354f4b4eeab83c6fc51e3222b6
---
 .../jce/provider/CertBlacklistTest.java            | 72 +++++++++++++++++++++-
 1 file changed, 71 insertions(+), 1 deletion(-)

diff --git a/luni/src/test/java/com/android/org/bouncycastle/jce/provider/CertBlacklistTest.java b/luni/src/test/java/com/android/org/bouncycastle/jce/provider/CertBlacklistTest.java
index bd12aea..b374f56 100644
--- a/luni/src/test/java/com/android/org/bouncycastle/jce/provider/CertBlacklistTest.java
+++ b/luni/src/test/java/com/android/org/bouncycastle/jce/provider/CertBlacklistTest.java
@@ -16,15 +16,24 @@
 
 package com.android.org.bouncycastle.jce.provider;
 
+import java.io.ByteArrayInputStream;
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.FileNotFoundException;
+import java.io.InputStream;
 import java.io.IOException;
 import java.math.BigInteger;
+import java.security.cert.CertificateFactory;
+import java.security.cert.Certificate;
+import java.security.MessageDigest;
+import java.security.PrivateKey;
+import java.security.PublicKey;
 import java.util.HashSet;
 import java.util.Set;
 import junit.framework.TestCase;
 import com.android.org.bouncycastle.jce.provider.CertBlacklist;
+import com.android.org.bouncycastle.crypto.Digest;
+import com.android.org.bouncycastle.util.encoders.Base64;
 import com.android.org.bouncycastle.util.encoders.Hex;
 
 public class CertBlacklistTest extends TestCase {
@@ -34,6 +43,25 @@ public class CertBlacklistTest extends TestCase {
     private Set<String> DEFAULT_PUBKEYS;
     private Set<String> DEFAULT_SERIALS;
 
+    public static final String TEST_CERT = "" +
+                    "MIIDsjCCAxugAwIBAgIJAPLf2gS0zYGUMA0GCSqGSIb3DQEBBQUAMIGYMQswCQYDVQQGEwJVUzET" +
+                    "MBEGA1UECBMKQ2FsaWZvcm5pYTEWMBQGA1UEBxMNTW91bnRhaW4gVmlldzEPMA0GA1UEChMGR29v" +
+                    "Z2xlMRAwDgYDVQQLEwd0ZXN0aW5nMRYwFAYDVQQDEw1HZXJlbXkgQ29uZHJhMSEwHwYJKoZIhvcN" +
+                    "AQkBFhJnY29uZHJhQGdvb2dsZS5jb20wHhcNMTIwNzE0MTc1MjIxWhcNMTIwODEzMTc1MjIxWjCB" +
+                    "mDELMAkGA1UEBhMCVVMxEzARBgNVBAgTCkNhbGlmb3JuaWExFjAUBgNVBAcTDU1vdW50YWluIFZp" +
+                    "ZXcxDzANBgNVBAoTBkdvb2dsZTEQMA4GA1UECxMHdGVzdGluZzEWMBQGA1UEAxMNR2VyZW15IENv" +
+                    "bmRyYTEhMB8GCSqGSIb3DQEJARYSZ2NvbmRyYUBnb29nbGUuY29tMIGfMA0GCSqGSIb3DQEBAQUA" +
+                    "A4GNADCBiQKBgQCjGGHATBYlmas+0sEECkno8LZ1KPglb/mfe6VpCT3GhSr+7br7NG/ZwGZnEhLq" +
+                    "E7YIH4fxltHmQC3Tz+jM1YN+kMaQgRRjo/LBCJdOKaMwUbkVynAH6OYsKevjrOPk8lfM5SFQzJMG" +
+                    "sA9+Tfopr5xg0BwZ1vA/+E3mE7Tr3M2UvwIDAQABo4IBADCB/TAdBgNVHQ4EFgQUhzkS9E6G+x8W" +
+                    "L4EsmRjDxu28tHUwgc0GA1UdIwSBxTCBwoAUhzkS9E6G+x8WL4EsmRjDxu28tHWhgZ6kgZswgZgx" +
+                    "CzAJBgNVBAYTAlVTMRMwEQYDVQQIEwpDYWxpZm9ybmlhMRYwFAYDVQQHEw1Nb3VudGFpbiBWaWV3" +
+                    "MQ8wDQYDVQQKEwZHb29nbGUxEDAOBgNVBAsTB3Rlc3RpbmcxFjAUBgNVBAMTDUdlcmVteSBDb25k" +
+                    "cmExITAfBgkqhkiG9w0BCQEWEmdjb25kcmFAZ29vZ2xlLmNvbYIJAPLf2gS0zYGUMAwGA1UdEwQF" +
+                    "MAMBAf8wDQYJKoZIhvcNAQEFBQADgYEAYiugFDmbDOQ2U/+mqNt7o8ftlEo9SJrns6O8uTtK6AvR" +
+                    "orDrR1AXTXkuxwLSbmVfedMGOZy7Awh7iZa8hw5x9XmUudfNxvmrKVEwGQY2DZ9PXbrnta/dwbhK" +
+                    "mWfoepESVbo7CKIhJp8gRW0h1Z55ETXD57aGJRvQS4pxkP8ANhM=";
+
     public CertBlacklistTest() throws IOException {
         tmpFile = File.createTempFile("test", "");
         DEFAULT_PUBKEYS = getDefaultPubkeys();
@@ -82,6 +110,13 @@ public class CertBlacklistTest extends TestCase {
         return results;
     }
 
+    private String getHash(PublicKey publicKey) throws Exception {
+        byte[] encoded = publicKey.getEncoded();
+        MessageDigest digest = MessageDigest.getInstance("SHA1");
+        byte[] hexlifiedHash = Hex.encode(digest.digest(encoded));
+        return new String(hexlifiedHash);
+    }
+
     private Set<String> getDefaultPubkeys() throws IOException {
         return getPubkeyBlacklist("");
     }
@@ -116,7 +151,14 @@ public class CertBlacklistTest extends TestCase {
         blacklistToFile(result.toString());
     }
 
-    public void testPubkeyBlacklistLegit() throws IOException {
+    private PublicKey createPublicKey(String cert) throws Exception {
+        byte[] derCert = Base64.decode(cert.getBytes());
+        InputStream istream = new ByteArrayInputStream(derCert);
+        CertificateFactory cf = CertificateFactory.getInstance("X.509");
+        return cf.generateCertificate(istream).getPublicKey();
+    }
+
+    public void testPubkeyBlacklistLegit() throws Exception {
         // build the blacklist
         HashSet<String> bl = new HashSet<String>();
         bl.add("6ccabd7db47e94a5759901b6a7dfd45d1c091ccc");
@@ -128,6 +170,34 @@ public class CertBlacklistTest extends TestCase {
         assertEquals(bl, getCurrentPubkeyBlacklist());
     }
 
+    public void testLegitPubkeyIsntBlacklisted() throws Exception {
+        // build the public key
+        PublicKey pk = createPublicKey(TEST_CERT);
+        // write that to the test blacklist
+        writeBlacklist(new HashSet<String>());
+        // set our blacklist path
+        CertBlacklist bl = new CertBlacklist(tmpFile.getCanonicalPath(),
+                                             CertBlacklist.DEFAULT_SERIAL_BLACKLIST_PATH);
+        // check to make sure it isn't blacklisted
+        assertEquals(bl.isPublicKeyBlackListed(pk), false);
+    }
+
+    public void testPubkeyIsBlacklisted() throws Exception {
+        // build the public key
+        PublicKey pk = createPublicKey(TEST_CERT);
+        // get its hash
+        String hash = getHash(pk);
+        // write that to the test blacklist
+        HashSet<String> testBlackList = new HashSet<String>();
+        testBlackList.add(hash);
+        writeBlacklist(testBlackList);
+        // set our blacklist path
+        CertBlacklist bl = new CertBlacklist(tmpFile.getCanonicalPath(),
+                                             CertBlacklist.DEFAULT_SERIAL_BLACKLIST_PATH);
+        // check to make sure it isn't blacklited
+        assertTrue(bl.isPublicKeyBlackListed(pk));
+    }
+
     public void testSerialBlacklistLegit() throws IOException {
         // build the blacklist
         HashSet<String> bl = new HashSet<String>();
-- 
cgit v1.1


From 8155888a2c4e7cc28596deec28433e1984cfaf11 Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Tue, 24 Jul 2012 17:08:44 -0700
Subject: Fix HttpURLConnection CloseGuard warning due to lack of close on
 GZIPInputStream

java.lang.Throwable: Explicit termination method 'end' not called
       at dalvik.system.CloseGuard.open(CloseGuard.java:184)
       at java.util.zip.Inflater.<init>(Inflater.java:82)
       at java.util.zip.GZIPInputStream.<init>(GZIPInputStream.java:96)
       at java.util.zip.GZIPInputStream.<init>(GZIPInputStream.java:81)
       at libcore.net.http.HttpEngine.initContentStream(HttpEngine.java:523)
       at libcore.net.http.HttpEngine.readResponse(HttpEngine.java:831)
       at libcore.net.http.HttpURLConnectionImpl.getResponse(HttpURLConnectionImpl.java:274)
       at libcore.net.http.HttpURLConnectionImpl.getResponseCode(HttpURLConnectionImpl.java:486)
       at ...

Bug: 6602529
Change-Id: I9b49cbca561f8780d08844e566820087fdffc4d7
---
 dalvik/src/main/java/dalvik/system/CloseGuard.java |  4 +-
 .../libcore/net/http/HttpURLConnectionImpl.java    |  9 +++++
 .../java/libcore/java/net/URLConnectionTest.java   | 47 ++++++++++++++++++++++
 3 files changed, 58 insertions(+), 2 deletions(-)

diff --git a/dalvik/src/main/java/dalvik/system/CloseGuard.java b/dalvik/src/main/java/dalvik/system/CloseGuard.java
index 136be2f..df36867 100644
--- a/dalvik/src/main/java/dalvik/system/CloseGuard.java
+++ b/dalvik/src/main/java/dalvik/system/CloseGuard.java
@@ -197,7 +197,7 @@ public final class CloseGuard {
     /**
      * If CloseGuard is enabled, logs a warning if the caller did not
      * properly cleanup by calling an explicit close method
-     * before finalization. If CloseGuard is disable, no action is
+     * before finalization. If CloseGuard is disabled, no action is
      * performed.
      */
     public void warnIfOpen() {
@@ -223,7 +223,7 @@ public final class CloseGuard {
      * Default Reporter which reports CloseGuard violations to the log.
      */
     private static final class DefaultReporter implements Reporter {
-        public void report (String message, Throwable allocationSite) {
+        @Override public void report (String message, Throwable allocationSite) {
             System.logW(message, allocationSite);
         }
     }
diff --git a/luni/src/main/java/libcore/net/http/HttpURLConnectionImpl.java b/luni/src/main/java/libcore/net/http/HttpURLConnectionImpl.java
index a59df55..260a9ad 100644
--- a/luni/src/main/java/libcore/net/http/HttpURLConnectionImpl.java
+++ b/luni/src/main/java/libcore/net/http/HttpURLConnectionImpl.java
@@ -36,6 +36,7 @@ import java.security.Permission;
 import java.util.List;
 import java.util.Map;
 import libcore.io.Base64;
+import libcore.io.IoUtils;
 
 /**
  * This implementation uses HttpEngine to send requests and receive responses.
@@ -87,6 +88,14 @@ class HttpURLConnectionImpl extends HttpURLConnection {
     @Override public final void disconnect() {
         // Calling disconnect() before a connection exists should have no effect.
         if (httpEngine != null) {
+            // We close the response body here instead of in
+            // HttpEngine.release because that is called when input
+            // has been completely read from the underlying socket.
+            // However the response body can be a GZIPInputStream that
+            // still has unread data.
+            if (httpEngine.hasResponse()) {
+                IoUtils.closeQuietly(httpEngine.getResponseBody());
+            }
             httpEngine.release(false);
         }
     }
diff --git a/luni/src/test/java/libcore/java/net/URLConnectionTest.java b/luni/src/test/java/libcore/java/net/URLConnectionTest.java
index 347242a..a1747fa 100644
--- a/luni/src/test/java/libcore/java/net/URLConnectionTest.java
+++ b/luni/src/test/java/libcore/java/net/URLConnectionTest.java
@@ -24,7 +24,9 @@ import static com.google.mockwebserver.SocketPolicy.DISCONNECT_AT_END;
 import static com.google.mockwebserver.SocketPolicy.DISCONNECT_AT_START;
 import static com.google.mockwebserver.SocketPolicy.SHUTDOWN_INPUT_AT_END;
 import static com.google.mockwebserver.SocketPolicy.SHUTDOWN_OUTPUT_AT_END;
+import dalvik.system.CloseGuard;
 import java.io.ByteArrayOutputStream;
+import java.io.Closeable;
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
@@ -76,6 +78,7 @@ import javax.net.ssl.SSLSocketFactory;
 import javax.net.ssl.TrustManager;
 import javax.net.ssl.X509TrustManager;
 import junit.framework.TestCase;
+import libcore.java.lang.ref.FinalizationTester;
 import libcore.java.security.TestKeyStore;
 import libcore.javax.net.ssl.TestSSLContext;
 import libcore.net.http.HttpResponseCache;
@@ -818,6 +821,50 @@ public final class URLConnectionTest extends TestCase {
         assertEquals(200, connection.getResponseCode());
     }
 
+    public void testDisconnectAfterOnlyResponseCodeCausesNoCloseGuardWarning() throws IOException {
+        CloseGuardGuard guard = new CloseGuardGuard();
+        try {
+            server.enqueue(new MockResponse()
+                           .setBody(gzip("ABCABCABC".getBytes("UTF-8")))
+                           .addHeader("Content-Encoding: gzip"));
+            server.play();
+
+            HttpURLConnection connection = (HttpURLConnection) server.getUrl("/").openConnection();
+            assertEquals(200, connection.getResponseCode());
+            connection.disconnect();
+            connection = null;
+            assertFalse(guard.wasCloseGuardCalled());
+        } finally {
+            guard.close();
+        }
+    }
+
+    public static class CloseGuardGuard implements Closeable, CloseGuard.Reporter  {
+        private final CloseGuard.Reporter oldReporter = CloseGuard.getReporter();
+
+        private AtomicBoolean closeGuardCalled = new AtomicBoolean();
+
+        public CloseGuardGuard() {
+            CloseGuard.setReporter(this);
+        }
+
+        @Override public void report(String message, Throwable allocationSite) {
+            oldReporter.report(message, allocationSite);
+            closeGuardCalled.set(true);
+        }
+
+        public boolean wasCloseGuardCalled() {
+            // FinalizationTester.induceFinalization();
+            close();
+            return closeGuardCalled.get();
+        }
+
+        @Override public void close() {
+            CloseGuard.setReporter(oldReporter);
+        }
+
+    }
+
     public void testDefaultRequestProperty() throws Exception {
         URLConnection.setDefaultRequestProperty("X-testSetDefaultRequestProperty", "A");
         assertNull(URLConnection.getDefaultRequestProperty("X-setDefaultRequestProperty"));
-- 
cgit v1.1


From 1178c18725d276d6403ebc7fa9fc323a8643ce25 Mon Sep 17 00:00:00 2001
From: Geremy Condra <gcondra@google.com>
Date: Thu, 26 Jul 2012 16:35:12 -0700
Subject: Tests for the CertBlacklist.

(cherry picked from commit d1725822187cb9bbe4d93fe39135b17ecb3130ee)
(cherry picked from commit f9ace732615171a9852c86ad4bcb7cf7616c1052)
Bug: http://code.google.com/p/android/issues/detail?id=35547

Change-Id: I68cf95f1b8cd17df2236b49396edf4718026d5df
---
 .../com/android/org/bouncycastle/jce/provider/CertBlacklistTest.java    | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/luni/src/test/java/com/android/org/bouncycastle/jce/provider/CertBlacklistTest.java b/luni/src/test/java/com/android/org/bouncycastle/jce/provider/CertBlacklistTest.java
index 85e360e..bd12aea 100644
--- a/luni/src/test/java/com/android/org/bouncycastle/jce/provider/CertBlacklistTest.java
+++ b/luni/src/test/java/com/android/org/bouncycastle/jce/provider/CertBlacklistTest.java
@@ -64,7 +64,7 @@ public class CertBlacklistTest extends TestCase {
         // convert the results to a hashset of strings
         Set<String> results = new HashSet<String>();
         for (byte[] value: arr) {
-            results.add(new String(Hex.encode(value)));
+            results.add(new String(value));
         }
         return results;
     }
-- 
cgit v1.1


From bd8dfd99b523583c3b5e662975638643e17874ea Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Fri, 27 Jul 2012 21:22:52 -0700
Subject: NullPointerException invoking Field.getModifiers

Change-Id: I56c5908d16458d36098ffa7e2dc8c3518280f2e3
---
 luni/src/main/java/java/io/ObjectInputStream.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/luni/src/main/java/java/io/ObjectInputStream.java b/luni/src/main/java/java/io/ObjectInputStream.java
index acf00af..449204f 100644
--- a/luni/src/main/java/java/io/ObjectInputStream.java
+++ b/luni/src/main/java/java/io/ObjectInputStream.java
@@ -1090,7 +1090,7 @@ public class ObjectInputStream extends InputStream implements ObjectInput, Objec
 
         for (ObjectStreamField fieldDesc : fields) {
             Field field = classDesc.getReflectionField(fieldDesc);
-            if (Modifier.isTransient(field.getModifiers())) {
+            if (field != null && Modifier.isTransient(field.getModifiers())) {
                 field = null; // No setting transient fields! (http://b/4471249)
             }
             // We may not have been able to find the field, or it may be transient, but we still
-- 
cgit v1.1


From 86f5f3e0e2bd808e4c85b0563ae50f17b7d48309 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Mon, 30 Jul 2012 08:26:45 -0700
Subject: Repair the damage I did removing "useless" checkIndex calls from the
 asXBuffer adapter classes.

The checkIndex calls were unnecessary as far as throwing the right Exception
subclass goes, but they're necessary if you want the detail message to use
the units of the wrapping buffer rather than the wrapped buffer. And we want
that. An IndexOutOfBoundsException that says "offset=0, limit=1" is only
going to confuse developers.

(Fixes bug introduced by 26841c0bb838d54fea2e1a06390e413fab561e27.)

Bug: 6085292
Change-Id: I9a1a5991ad383b7712642e40bced9af91440bed2
---
 luni/src/main/java/java/nio/CharToByteBufferAdapter.java   | 1 +
 luni/src/main/java/java/nio/DoubleToByteBufferAdapter.java | 1 +
 luni/src/main/java/java/nio/FloatToByteBufferAdapter.java  | 1 +
 luni/src/main/java/java/nio/IntToByteBufferAdapter.java    | 1 +
 luni/src/main/java/java/nio/LongToByteBufferAdapter.java   | 1 +
 luni/src/main/java/java/nio/ShortToByteBufferAdapter.java  | 1 +
 luni/src/test/java/libcore/java/nio/BufferTest.java        | 6 ++++++
 7 files changed, 12 insertions(+)

diff --git a/luni/src/main/java/java/nio/CharToByteBufferAdapter.java b/luni/src/main/java/java/nio/CharToByteBufferAdapter.java
index 86c7186..b9100a2 100644
--- a/luni/src/main/java/java/nio/CharToByteBufferAdapter.java
+++ b/luni/src/main/java/java/nio/CharToByteBufferAdapter.java
@@ -93,6 +93,7 @@ final class CharToByteBufferAdapter extends CharBuffer {
 
     @Override
     public char get(int index) {
+        checkIndex(index);
         return byteBuffer.getChar(index * SizeOf.CHAR);
     }
 
diff --git a/luni/src/main/java/java/nio/DoubleToByteBufferAdapter.java b/luni/src/main/java/java/nio/DoubleToByteBufferAdapter.java
index ead4ef0..8b1e084 100644
--- a/luni/src/main/java/java/nio/DoubleToByteBufferAdapter.java
+++ b/luni/src/main/java/java/nio/DoubleToByteBufferAdapter.java
@@ -93,6 +93,7 @@ final class DoubleToByteBufferAdapter extends DoubleBuffer {
 
     @Override
     public double get(int index) {
+        checkIndex(index);
         return byteBuffer.getDouble(index * SizeOf.DOUBLE);
     }
 
diff --git a/luni/src/main/java/java/nio/FloatToByteBufferAdapter.java b/luni/src/main/java/java/nio/FloatToByteBufferAdapter.java
index f7733c1..0ed944b 100644
--- a/luni/src/main/java/java/nio/FloatToByteBufferAdapter.java
+++ b/luni/src/main/java/java/nio/FloatToByteBufferAdapter.java
@@ -92,6 +92,7 @@ final class FloatToByteBufferAdapter extends FloatBuffer {
 
     @Override
     public float get(int index) {
+        checkIndex(index);
         return byteBuffer.getFloat(index * SizeOf.FLOAT);
     }
 
diff --git a/luni/src/main/java/java/nio/IntToByteBufferAdapter.java b/luni/src/main/java/java/nio/IntToByteBufferAdapter.java
index 29aff41..1af5f86 100644
--- a/luni/src/main/java/java/nio/IntToByteBufferAdapter.java
+++ b/luni/src/main/java/java/nio/IntToByteBufferAdapter.java
@@ -93,6 +93,7 @@ final class IntToByteBufferAdapter extends IntBuffer {
 
     @Override
     public int get(int index) {
+        checkIndex(index);
         return byteBuffer.getInt(index * SizeOf.INT);
     }
 
diff --git a/luni/src/main/java/java/nio/LongToByteBufferAdapter.java b/luni/src/main/java/java/nio/LongToByteBufferAdapter.java
index 7fb033b..e8bf8df 100644
--- a/luni/src/main/java/java/nio/LongToByteBufferAdapter.java
+++ b/luni/src/main/java/java/nio/LongToByteBufferAdapter.java
@@ -93,6 +93,7 @@ final class LongToByteBufferAdapter extends LongBuffer {
 
     @Override
     public long get(int index) {
+        checkIndex(index);
         return byteBuffer.getLong(index * SizeOf.LONG);
     }
 
diff --git a/luni/src/main/java/java/nio/ShortToByteBufferAdapter.java b/luni/src/main/java/java/nio/ShortToByteBufferAdapter.java
index e53e355..ee36709 100644
--- a/luni/src/main/java/java/nio/ShortToByteBufferAdapter.java
+++ b/luni/src/main/java/java/nio/ShortToByteBufferAdapter.java
@@ -92,6 +92,7 @@ final class ShortToByteBufferAdapter extends ShortBuffer {
 
     @Override
     public short get(int index) {
+        checkIndex(index);
         return byteBuffer.getShort(index * SizeOf.SHORT);
     }
 
diff --git a/luni/src/test/java/libcore/java/nio/BufferTest.java b/luni/src/test/java/libcore/java/nio/BufferTest.java
index 41ee3f7..2a895fc 100644
--- a/luni/src/test/java/libcore/java/nio/BufferTest.java
+++ b/luni/src/test/java/libcore/java/nio/BufferTest.java
@@ -688,6 +688,7 @@ public class BufferTest extends TestCase {
             b.asCharBuffer().get(0);
             fail();
         } catch (IndexOutOfBoundsException expected) {
+            assertTrue(expected.getMessage().contains("limit=0"));
         }
 
         try {
@@ -699,6 +700,7 @@ public class BufferTest extends TestCase {
             b.asDoubleBuffer().get(0);
             fail();
         } catch (IndexOutOfBoundsException expected) {
+            assertTrue(expected.getMessage().contains("limit=0"));
         }
 
         try {
@@ -710,6 +712,7 @@ public class BufferTest extends TestCase {
             b.asFloatBuffer().get(0);
             fail();
         } catch (IndexOutOfBoundsException expected) {
+            assertTrue(expected.getMessage().contains("limit=0"));
         }
 
         try {
@@ -721,6 +724,7 @@ public class BufferTest extends TestCase {
             b.asIntBuffer().get(0);
             fail();
         } catch (IndexOutOfBoundsException expected) {
+            assertTrue(expected.getMessage().contains("limit=0"));
         }
 
         try {
@@ -732,6 +736,7 @@ public class BufferTest extends TestCase {
             b.asLongBuffer().get(0);
             fail();
         } catch (IndexOutOfBoundsException expected) {
+            assertTrue(expected.getMessage().contains("limit=0"));
         }
 
         try {
@@ -743,6 +748,7 @@ public class BufferTest extends TestCase {
             b.asShortBuffer().get(0);
             fail();
         } catch (IndexOutOfBoundsException expected) {
+            assertTrue(expected.getMessage().contains("limit=0"));
         }
     }
 }
-- 
cgit v1.1


From bbe3e7f1f8c312fcfbd7af2ecbfa98c48f502c61 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Mon, 30 Jul 2012 11:18:43 -0700
Subject: De-pessimize the String(byte[], int, int) constructor.
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Also add a few tests.

Before:
     0% Scenario{vm=app_process, trial=0, benchmark=_new_String_BII, length=1, name=UTF-8} 155838.96 ns; σ=1179.42 ns @ 3 trials
    10% Scenario{vm=app_process, trial=0, benchmark=_new_String_BII, length=10, name=UTF-8} 170741.68 ns; σ=10178.36 ns @ 10 trials
    40% Scenario{vm=app_process, trial=0, benchmark=_new_String_BII, length=10000, name=UTF-8} 3867968.18 ns; σ=347173.32 ns @ 10 trials

Change-Id: Ic1a8a46a81faf1afc807cfff132565e87944994b
After:
     0% Scenario{vm=app_process, trial=0, benchmark=_new_String_BII, length=1, name=UTF-8} 4563.80 ns; σ=7.13 ns @ 3 trials
    10% Scenario{vm=app_process, trial=0, benchmark=_new_String_BII, length=10, name=UTF-8} 6667.55 ns; σ=862.26 ns @ 10 trials
    40% Scenario{vm=app_process, trial=0, benchmark=_new_String_BII, length=10000, name=UTF-8} 1836705.08 ns; σ=71293.06 ns @ 10 trials
---
 luni/src/main/java/java/lang/String.java           | 12 +-----------
 .../test/java/libcore/java/lang/StringTest.java    | 22 ++++++++++++++++++----
 2 files changed, 19 insertions(+), 15 deletions(-)

diff --git a/luni/src/main/java/java/lang/String.java b/luni/src/main/java/java/lang/String.java
index efd4210..224a268 100644
--- a/luni/src/main/java/java/lang/String.java
+++ b/luni/src/main/java/java/lang/String.java
@@ -168,17 +168,7 @@ public final class String implements Serializable, Comparable<String>, CharSeque
      *             if {@code byteCount < 0 || offset < 0 || offset + byteCount > data.length}.
      */
     public String(byte[] data, int offset, int byteCount) {
-        if ((offset | byteCount) < 0 || byteCount > data.length - offset) {
-            throw failedBoundsCheck(data.length, offset, byteCount);
-        }
-        CharBuffer cb = Charset.defaultCharset().decode(ByteBuffer.wrap(data, offset, byteCount));
-        this.count = cb.length();
-        this.offset = 0;
-        if (count > 0) {
-            value = cb.array();
-        } else {
-            value = EmptyArray.CHAR;
-        }
+        this(data, offset, byteCount, Charset.defaultCharset());
     }
 
     /**
diff --git a/luni/src/test/java/libcore/java/lang/StringTest.java b/luni/src/test/java/libcore/java/lang/StringTest.java
index 42a7aad..99dba49 100644
--- a/luni/src/test/java/libcore/java/lang/StringTest.java
+++ b/luni/src/test/java/libcore/java/lang/StringTest.java
@@ -91,10 +91,24 @@ public class StringTest extends TestCase {
         }
     }
 
-    public void testStringFromCharset() {
-        Charset cs = Charset.forName("UTF-8");
-        byte[] bytes = new byte[] {(byte) 'h', (byte) 'i'};
-        assertEquals("hi", new String(bytes, cs));
+    public void testString_BII() throws Exception {
+        byte[] bytes = "xa\u0666bx".getBytes("UTF-8");
+        assertEquals("a\u0666b", new String(bytes, 1, bytes.length - 2));
+    }
+
+    public void testString_BIIString() throws Exception {
+        byte[] bytes = "xa\u0666bx".getBytes("UTF-8");
+        assertEquals("a\u0666b", new String(bytes, 1, bytes.length - 2, "UTF-8"));
+    }
+
+    public void testString_BIICharset() throws Exception {
+        byte[] bytes = "xa\u0666bx".getBytes("UTF-8");
+        assertEquals("a\u0666b", new String(bytes, 1, bytes.length - 2, Charset.forName("UTF-8")));
+    }
+
+    public void testString_BCharset() throws Exception {
+        byte[] bytes = "a\u0666b".getBytes("UTF-8");
+        assertEquals("a\u0666b", new String(bytes, Charset.forName("UTF-8")));
     }
 
     public void testStringFromCharset_MaliciousCharset() {
-- 
cgit v1.1


From 78c3de051d68b703af480778c100ca335690b250 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Mon, 30 Jul 2012 14:50:14 -0700
Subject: Fix TimeZone's handling of Australia/Lord_Howe.

Australia/Lord_Howe has a half hour difference between standard and daylight
time, rather than the usual hour. Our ZoneInfo implementation ignored this.
Fix that oversight, make SimpleDateFormat actually use this information, and
prevent TimeZone.getTimeZone("GMT") and TimeZone.getTimeZone("UTC") from
being quite as expensive as they accidentally were.

Longer term I think we should probably remove all uses of getDSTSavings from
libcore in favor of TimeZone.getOffset, but this is probably a useful step
forwards anyway. It fixes Australia/Lord_Howe in the meantime and it means
that anyone else who's using getDSTSavings won't be bitten (even if they too
really ought to be using TimeZone.getOffset).

Bug: 4723412
Bug: http://code.google.com/p/android/issues/detail?id=24684
Change-Id: I5d50afecbe1453157e9c8f0b88305a258a3ba2e0
---
 luni/src/main/java/java/text/SimpleDateFormat.java | 20 ++++----
 .../src/main/java/java/util/GregorianCalendar.java |  2 +-
 luni/src/main/java/java/util/TimeZone.java         | 56 ++++++++++++++++------
 luni/src/main/java/libcore/util/ZoneInfo.java      | 44 ++++++++++++-----
 luni/src/main/java/libcore/util/ZoneInfoDB.java    | 13 +----
 .../test/java/libcore/java/util/TimeZoneTest.java  |  6 +++
 6 files changed, 95 insertions(+), 46 deletions(-)

diff --git a/luni/src/main/java/java/text/SimpleDateFormat.java b/luni/src/main/java/java/text/SimpleDateFormat.java
index 1f9b694..5ed51a1 100644
--- a/luni/src/main/java/java/text/SimpleDateFormat.java
+++ b/luni/src/main/java/java/text/SimpleDateFormat.java
@@ -1174,14 +1174,18 @@ public class SimpleDateFormat extends DateFormat {
                     }
                     int raw = zone.getRawOffset();
                     if (j == TimeZones.LONG_NAME_DST || j == TimeZones.SHORT_NAME_DST) {
-                        /*
-                         * TODO, http://b/4723412
-                         * We can't use TimeZone#getDSTSavings here because that
-                         * will return 0 if the zone no longer uses DST. We
-                         * should change this to use TimeZone.getOffset(long),
-                         * which requires the complete date to be parsed first.
-                         */
-                        raw += 3600000;
+                        // Not all time zones use a one-hour difference, so we need to query
+                        // the TimeZone. (Australia/Lord_Howe is the usual example of this.)
+                        int dstSavings = zone.getDSTSavings();
+                        // One problem with TimeZone.getDSTSavings is that it will return 0 if the
+                        // time zone has stopped using DST, even if we're parsing a date from
+                        // the past. In that case, assume the default.
+                        if (dstSavings == 0) {
+                            // TODO: we should change this to use TimeZone.getOffset(long),
+                            // but that requires the complete date to be parsed first.
+                            dstSavings = 3600000;
+                        }
+                        raw += dstSavings;
                     }
                     calendar.setTimeZone(new SimpleTimeZone(raw, ""));
                     return offset + element[j].length();
diff --git a/luni/src/main/java/java/util/GregorianCalendar.java b/luni/src/main/java/java/util/GregorianCalendar.java
index c0fd521..4d93aef 100644
--- a/luni/src/main/java/java/util/GregorianCalendar.java
+++ b/luni/src/main/java/java/util/GregorianCalendar.java
@@ -1416,7 +1416,7 @@ public class GregorianCalendar extends Calendar {
      */
     public void setGregorianChange(Date date) {
         gregorianCutover = date.getTime();
-        GregorianCalendar cal = new GregorianCalendar(TimeZone.GMT);
+        GregorianCalendar cal = new GregorianCalendar(TimeZone.getTimeZone("GMT"));
         cal.setTime(date);
         changeYear = cal.get(YEAR);
         if (cal.get(ERA) == BC) {
diff --git a/luni/src/main/java/java/util/TimeZone.java b/luni/src/main/java/java/util/TimeZone.java
index 969e164..b7d7da1 100644
--- a/luni/src/main/java/java/util/TimeZone.java
+++ b/luni/src/main/java/java/util/TimeZone.java
@@ -17,6 +17,7 @@
 
 package java.util;
 
+import java.io.IOException;
 import java.io.Serializable;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
@@ -80,7 +81,8 @@ public abstract class TimeZone implements Serializable, Cloneable {
      */
     public static final int LONG = 1;
 
-    static final TimeZone GMT = new SimpleTimeZone(0, "GMT"); // Greenwich Mean Time
+    private static final TimeZone GMT = new SimpleTimeZone(0, "GMT");
+    private static final TimeZone UTC = new SimpleTimeZone(0, "UTC");
 
     private static TimeZone defaultTimeZone;
 
@@ -218,16 +220,27 @@ public abstract class TimeZone implements Serializable, Cloneable {
     }
 
     /**
-     * Returns the daylight savings offset in milliseconds for this time zone.
-     * The base implementation returns {@code 3600000} (1 hour) for time zones
-     * that use daylight savings time and {@code 0} for timezones that do not.
-     * Subclasses should override this method for other daylight savings
-     * offsets.
+     * Returns the latest daylight savings in milliseconds for this time zone, relative
+     * to this time zone's regular UTC offset (as returned by {@link #getRawOffset}).
      *
-     * <p>Note that this method doesn't tell you whether or not to apply the
+     * <p>This class returns {@code 3600000} (1 hour) for time zones
+     * that use daylight savings time and {@code 0} for timezones that do not,
+     * leaving it to subclasses to override this method for other daylight savings
+     * offsets. (There are time zones, such as {@code Australia/Lord_Howe},
+     * that use other values.)
+     *
+     * <p>Note that this method doesn't tell you whether or not to <i>apply</i> the
      * offset: you need to call {@code inDaylightTime} for the specific time
      * you're interested in. If this method returns a non-zero offset, that only
      * tells you that this {@code TimeZone} sometimes observes daylight savings.
+     *
+     * <p>Note also that this method doesn't necessarily return the value you need
+     * to apply to the time you're working with. This value can and does change over
+     * time for a given time zone.
+     *
+     * <p>It's highly unlikely that you should ever call this method. You
+     * probably want {@link #getOffset} instead, which tells you the offset
+     * for a specific point in time, and takes daylight savings into account for you.
      */
     public int getDSTSavings() {
         return useDaylightTime() ? 3600000 : 0;
@@ -291,17 +304,32 @@ public abstract class TimeZone implements Serializable, Cloneable {
         if (id == null) {
             throw new NullPointerException("id == null");
         }
-        TimeZone zone = ZoneInfoDB.getTimeZone(id);
-        if (zone != null) {
-            return zone;
+
+        // Special cases? These can clone an existing instance.
+        // TODO: should we just add a cache to ZoneInfoDB instead?
+        if (id.length() == 3) {
+            if (id.equals("GMT")) {
+                return (TimeZone) GMT.clone();
+            }
+            if (id.equals("UTC")) {
+                return (TimeZone) UTC.clone();
+            }
+        }
+
+        // In the database?
+        TimeZone zone = null;
+        try {
+            zone = ZoneInfoDB.makeTimeZone(id);
+        } catch (IOException ignored) {
         }
+
+        // Custom time zone?
         if (zone == null && id.length() > 3 && id.startsWith("GMT")) {
             zone = getCustomTimeZone(id);
         }
-        if (zone == null) {
-            zone = (TimeZone) GMT.clone();
-        }
-        return zone;
+
+        // We never return null; on failure we return the equivalent of "GMT".
+        return (zone != null) ? zone : (TimeZone) GMT.clone();
     }
 
     /**
diff --git a/luni/src/main/java/libcore/util/ZoneInfo.java b/luni/src/main/java/libcore/util/ZoneInfo.java
index 5a8caf2..ac48b23 100644
--- a/luni/src/main/java/libcore/util/ZoneInfo.java
+++ b/luni/src/main/java/libcore/util/ZoneInfo.java
@@ -51,29 +51,46 @@ public final class ZoneInfo extends TimeZone {
     private final byte[] mTypes;
     private final byte[] mIsDsts;
     private final boolean mUseDst;
+    private final int mDstSavings; // Implements TimeZone.getDSTSavings.
 
-    ZoneInfo(String name, int[] transitions, byte[] type, int[] gmtOffsets, byte[] isDsts) {
+    ZoneInfo(String name, int[] transitions, byte[] types, int[] gmtOffsets, byte[] isDsts) {
         mTransitions = transitions;
-        mTypes = type;
+        mTypes = types;
         mIsDsts = isDsts;
         setID(name);
 
-        // Use the latest non-daylight offset (if any) as the raw offset.
-        int lastStd;
-        for (lastStd = mTransitions.length - 1; lastStd >= 0; lastStd--) {
-            if (mIsDsts[mTypes[lastStd] & 0xff] == 0) {
-                break;
+        // Find the latest daylight and standard offsets (if any).
+        int lastStd = 0;
+        boolean haveStd = false;
+        int lastDst = 0;
+        boolean haveDst = false;
+        for (int i = mTransitions.length - 1; (!haveStd || !haveDst) && i >= 0; --i) {
+            int type = mTypes[i] & 0xff;
+            if (!haveStd && mIsDsts[type] == 0) {
+                haveStd = true;
+                lastStd = i;
+            }
+            if (!haveDst && mIsDsts[type] != 0) {
+                haveDst = true;
+                lastDst = i;
             }
         }
-        if (lastStd < 0) {
-            lastStd = 0;
-        }
+
+        // Use the latest non-daylight offset (if any) as the raw offset.
         if (lastStd >= mTypes.length) {
             mRawOffset = gmtOffsets[0];
         } else {
             mRawOffset = gmtOffsets[mTypes[lastStd] & 0xff];
         }
 
+        // Use the latest transition's pair of offsets to compute the DST savings.
+        // This isn't generally useful, but it's exposed by TimeZone.getDSTSavings.
+        if (lastDst >= mTypes.length) {
+            mDstSavings = 0;
+        } else {
+            mDstSavings = Math.abs(gmtOffsets[mTypes[lastStd] & 0xff] - gmtOffsets[mTypes[lastDst] & 0xff]) * 1000;
+        }
+
         // Cache the oldest known raw offset, in case we're asked about times that predate our
         // transition data.
         int firstStd = -1;
@@ -111,6 +128,7 @@ public final class ZoneInfo extends TimeZone {
         }
         mUseDst = usesDst;
 
+        // tzdata uses seconds, but Java uses milliseconds.
         mRawOffset *= 1000;
         mEarliestRawOffset = earliestRawOffset * 1000;
     }
@@ -185,6 +203,10 @@ public final class ZoneInfo extends TimeZone {
         mRawOffset = off;
     }
 
+    @Override public int getDSTSavings() {
+        return mUseDst ? mDstSavings: 0;
+    }
+
     @Override public boolean useDaylightTime() {
         return mUseDst;
     }
@@ -235,7 +257,7 @@ public final class ZoneInfo extends TimeZone {
         StringBuilder sb = new StringBuilder();
         // First the basics...
         sb.append(getClass().getName() + "[" + getID() + ",mRawOffset=" + mRawOffset +
-                ",mUseDst=" + mUseDst + "]");
+                ",mUseDst=" + mUseDst + ",mDstSavings=" + mDstSavings + "]");
         // ...followed by a zdump(1)-like description of all our transition data.
         sb.append("\n");
         Formatter f = new Formatter(sb);
diff --git a/luni/src/main/java/libcore/util/ZoneInfoDB.java b/luni/src/main/java/libcore/util/ZoneInfoDB.java
index 69b6784..cc7cc4f 100644
--- a/luni/src/main/java/libcore/util/ZoneInfoDB.java
+++ b/luni/src/main/java/libcore/util/ZoneInfoDB.java
@@ -180,7 +180,7 @@ public final class ZoneInfoDB {
         }
     }
 
-    private static TimeZone makeTimeZone(String id) throws IOException {
+    public static TimeZone makeTimeZone(String id) throws IOException {
         // Work out where in the big data file this time zone is.
         int index = Arrays.binarySearch(ids, id);
         if (index < 0) {
@@ -259,17 +259,6 @@ public final class ZoneInfoDB {
         }
     }
 
-    public static TimeZone getTimeZone(String id) {
-        if (id == null) {
-            return null;
-        }
-        try {
-            return makeTimeZone(id);
-        } catch (IOException ignored) {
-            return null;
-        }
-    }
-
     public static String getVersion() {
         return VERSION;
     }
diff --git a/luni/src/test/java/libcore/java/util/TimeZoneTest.java b/luni/src/test/java/libcore/java/util/TimeZoneTest.java
index 484668b..d5fa558 100644
--- a/luni/src/test/java/libcore/java/util/TimeZoneTest.java
+++ b/luni/src/test/java/libcore/java/util/TimeZoneTest.java
@@ -186,4 +186,10 @@ public class TimeZoneTest extends junit.framework.TestCase {
         assertEquals("GMT", TimeZone.getTimeZone("junk").getID());
         assertEquals("GMT", TimeZone.getTimeZone("gmt+5:00").getID());
     }
+
+    public void test_getDSTSavings() throws Exception {
+      assertEquals(0, TimeZone.getTimeZone("UTC").getDSTSavings());
+      assertEquals(3600000, TimeZone.getTimeZone("America/Los_Angeles").getDSTSavings());
+      assertEquals(1800000, TimeZone.getTimeZone("Australia/Lord_Howe").getDSTSavings());
+    }
 }
-- 
cgit v1.1


From fddea0213028dd6d467f316584fac0f6e0745ce9 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Mon, 30 Jul 2012 16:49:55 -0700
Subject: HttpResponseCache should return 504, not 502.

The RFC seems pretty clear on this issue.

Bug: http://code.google.com/p/android/issues/detail?id=28294
Change-Id: Ia9a979e1fbbd8b38b1607059c042e0fc9ca44270
---
 luni/src/main/java/libcore/net/http/HttpEngine.java            |  9 +++++----
 luni/src/test/java/libcore/net/http/HttpResponseCacheTest.java | 10 +++++-----
 2 files changed, 10 insertions(+), 9 deletions(-)

diff --git a/luni/src/main/java/libcore/net/http/HttpEngine.java b/luni/src/main/java/libcore/net/http/HttpEngine.java
index 3e4b9d3..a370956 100644
--- a/luni/src/main/java/libcore/net/http/HttpEngine.java
+++ b/luni/src/main/java/libcore/net/http/HttpEngine.java
@@ -69,10 +69,10 @@ import libcore.util.EmptyArray;
  * required, use {@link #automaticallyReleaseConnectionToPool()}.
  */
 public class HttpEngine {
-    private static final CacheResponse BAD_GATEWAY_RESPONSE = new CacheResponse() {
+    private static final CacheResponse GATEWAY_TIMEOUT_RESPONSE = new CacheResponse() {
         @Override public Map<String, List<String>> getHeaders() throws IOException {
             Map<String, List<String>> result = new HashMap<String, List<String>>();
-            result.put(null, Collections.singletonList("HTTP/1.1 502 Bad Gateway"));
+            result.put(null, Collections.singletonList("HTTP/1.1 504 Gateway Timeout"));
             return result;
         }
         @Override public InputStream getBody() throws IOException {
@@ -223,14 +223,15 @@ public class HttpEngine {
         /*
          * The raw response source may require the network, but the request
          * headers may forbid network use. In that case, dispose of the network
-         * response and use a BAD_GATEWAY response instead.
+         * response and use a GATEWAY_TIMEOUT response instead, as specified
+         * by http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.9.4.
          */
         if (requestHeaders.isOnlyIfCached() && responseSource.requiresConnection()) {
             if (responseSource == ResponseSource.CONDITIONAL_CACHE) {
                 IoUtils.closeQuietly(cachedResponseBody);
             }
             this.responseSource = ResponseSource.CACHE;
-            this.cacheResponse = BAD_GATEWAY_RESPONSE;
+            this.cacheResponse = GATEWAY_TIMEOUT_RESPONSE;
             RawHeaders rawResponseHeaders = RawHeaders.fromMultimap(cacheResponse.getHeaders());
             setResponse(new ResponseHeaders(uri, rawResponseHeaders), cacheResponse.getBody());
         }
diff --git a/luni/src/test/java/libcore/net/http/HttpResponseCacheTest.java b/luni/src/test/java/libcore/net/http/HttpResponseCacheTest.java
index 360ca44..133924e 100644
--- a/luni/src/test/java/libcore/net/http/HttpResponseCacheTest.java
+++ b/luni/src/test/java/libcore/net/http/HttpResponseCacheTest.java
@@ -959,7 +959,7 @@ public final class HttpResponseCacheTest extends TestCase {
 
         HttpURLConnection connection = (HttpURLConnection) server.getUrl("/").openConnection();
         connection.addRequestProperty("Cache-Control", "only-if-cached");
-        assertBadGateway(connection);
+        assertGatewayTimeout(connection);
     }
 
     public void testRequestOnlyIfCachedWithFullResponseCached() throws IOException {
@@ -983,7 +983,7 @@ public final class HttpResponseCacheTest extends TestCase {
         assertEquals("A", readAscii(server.getUrl("/").openConnection()));
         HttpURLConnection connection = (HttpURLConnection) server.getUrl("/").openConnection();
         connection.addRequestProperty("Cache-Control", "only-if-cached");
-        assertBadGateway(connection);
+        assertGatewayTimeout(connection);
     }
 
     public void testRequestOnlyIfCachedWithUnhelpfulResponseCached() throws IOException {
@@ -993,7 +993,7 @@ public final class HttpResponseCacheTest extends TestCase {
         assertEquals("A", readAscii(server.getUrl("/").openConnection()));
         HttpURLConnection connection = (HttpURLConnection) server.getUrl("/").openConnection();
         connection.addRequestProperty("Cache-Control", "only-if-cached");
-        assertBadGateway(connection);
+        assertGatewayTimeout(connection);
     }
 
     public void testRequestCacheControlNoCache() throws Exception {
@@ -1804,13 +1804,13 @@ public final class HttpResponseCacheTest extends TestCase {
         }
     }
 
-    private void assertBadGateway(HttpURLConnection connection) throws IOException {
+    private void assertGatewayTimeout(HttpURLConnection connection) throws IOException {
         try {
             connection.getInputStream();
             fail();
         } catch (FileNotFoundException expected) {
         }
-        assertEquals(HttpURLConnection.HTTP_BAD_GATEWAY, connection.getResponseCode());
+        assertEquals(504, connection.getResponseCode());
         assertEquals(-1, connection.getErrorStream().read());
     }
 
-- 
cgit v1.1


From f4439e56aa3c88da66d2c6c969f9cb6b73cfa0ec Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Tue, 31 Jul 2012 18:35:41 -0700
Subject: Increment OpenSSLKey EVP_PKEY reference when it is selected for use
 with SSL_use_PrivateKey

Bug: 6866852
Bug: http://code.google.com/p/android/issues/detail?id=35326

(cherry-picked from 1f9fe21b93f1d1ee44a325629a05ee4f476e5f6a)

Change-Id: I4e995de38414a7841bca0e0bba7d15b01c3bffd9
---
 .../native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp     | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp b/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
index 7dabc5d..ba2a040 100644
--- a/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
+++ b/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
@@ -2698,6 +2698,10 @@ static void NativeCrypto_SSL_use_OpenSSL_PrivateKey(JNIEnv* env, jclass, jint ss
         JNI_TRACE("ssl=%p SSL_use_OpenSSL_PrivateKey => error", ssl);
         return;
     }
+    // SSL_use_PrivateKey expects to take ownership of the EVP_PKEY,
+    // but we have an external reference from the caller such as an
+    // OpenSSLKey, so we manually increment the reference count here.
+    CRYPTO_add(&pkey->references,+1,CRYPTO_LOCK_EVP_PKEY);
 
     JNI_TRACE("ssl=%p SSL_use_OpenSSL_PrivateKey => ok", ssl);
 }
-- 
cgit v1.1


From 3edd28a92fc86a1260347d0995e65a815d73bbbe Mon Sep 17 00:00:00 2001
From: Mattias Petersson <mattias.petersson@sonymobile.com>
Date: Mon, 16 Apr 2012 12:49:24 +0200
Subject: Fix problem with Runtime.runFinalization()

This is a fix for a problem with runFinalization(). The
problem was that all FinalizerReferences to objects that had
not yet been garbage collected were lost when calling this
function. When a FinalizerReference was lost, it is was not
possible to call the finalize() method when the object
was garbage collected.

The result was that finalizers was sometimes never
called, which typically lead to memory leaks.

Also stop synchronizing on the class itself; use a private
lock instead.

Bug: 6907299
Bug: 5462944 # Synchronization on FinalizerReference.class
Change-Id: Ief515edbb5a1823c06d7371415d131165baef7f2
---
 .../java/java/lang/ref/FinalizerReference.java     | 57 ++++++++++++++++------
 .../java/libcore/java/lang/ref/FinalizeTest.java   | 30 ++++++++++--
 .../java/libcore/java/net/URLConnectionTest.java   |  2 +-
 3 files changed, 69 insertions(+), 20 deletions(-)

diff --git a/luni/src/main/java/java/lang/ref/FinalizerReference.java b/luni/src/main/java/java/lang/ref/FinalizerReference.java
index aadf1f6..7a6d871 100644
--- a/luni/src/main/java/java/lang/ref/FinalizerReference.java
+++ b/luni/src/main/java/java/lang/ref/FinalizerReference.java
@@ -20,33 +20,39 @@ package java.lang.ref;
  * @hide
  */
 public final class FinalizerReference<T> extends Reference<T> {
+    // This queue contains those objects eligible for finalization.
     public static final ReferenceQueue<Object> queue = new ReferenceQueue<Object>();
 
-    private static FinalizerReference head = null;
+    // Guards the list (not the queue).
+    private static final Object LIST_LOCK = new Object();
 
-    private T zombie;
+    // This list contains a FinalizerReference for every finalizable object in the heap.
+    // Objects in this list may or may not be eligible for finalization yet.
+    private static FinalizerReference head = null;
 
+    // The links used to construct the list.
     private FinalizerReference prev;
-
     private FinalizerReference next;
 
+    // When the GC wants something finalized, it moves it from the 'referent' field to
+    // the 'zombie' field instead.
+    private T zombie;
+
     public FinalizerReference(T r, ReferenceQueue<? super T> q) {
         super(r, q);
     }
 
-    @Override
-    public T get() {
+    @Override public T get() {
         return zombie;
     }
 
-    @Override
-    public void clear() {
+    @Override public void clear() {
         zombie = null;
     }
 
     static void add(Object referent) {
         FinalizerReference<?> reference = new FinalizerReference<Object>(referent, queue);
-        synchronized (FinalizerReference.class) {
+        synchronized (LIST_LOCK) {
             reference.prev = null;
             reference.next = head;
             if (head != null) {
@@ -57,7 +63,7 @@ public final class FinalizerReference<T> extends Reference<T> {
     }
 
     public static void remove(FinalizerReference reference) {
-        synchronized (FinalizerReference.class) {
+        synchronized (LIST_LOCK) {
             FinalizerReference next = reference.next;
             FinalizerReference prev = reference.prev;
             reference.next = null;
@@ -74,30 +80,49 @@ public final class FinalizerReference<T> extends Reference<T> {
     }
 
     /**
-     * Returns once all currently-enqueued references have been finalized.
+     * Waits for all currently-enqueued references to be finalized.
      */
     public static void finalizeAllEnqueued() throws InterruptedException {
         Sentinel sentinel = new Sentinel();
-        FinalizerReference<Object> reference = new FinalizerReference<Object>(null, queue);
-        reference.zombie = sentinel;
-        reference.enqueueInternal();
+        enqueueSentinelReference(sentinel);
         sentinel.awaitFinalization();
     }
 
+    private static void enqueueSentinelReference(Sentinel sentinel) {
+        synchronized (LIST_LOCK) {
+            // When a finalizable object is allocated, a FinalizerReference is added to the list.
+            // We search the list for that FinalizerReference (it should be at or near the head),
+            // and then put it on the queue so that it can be finalized.
+            for (FinalizerReference r = head; r != null; r = r.next) {
+                if (r.referent == sentinel) {
+                    r.referent = null;
+                    r.zombie = sentinel;
+                    r.enqueueInternal();
+                    return;
+                }
+            }
+        }
+        // We just created a finalizable object and still hold a reference to it.
+        // It must be on the list.
+        throw new AssertionError("newly-created live Sentinel not on list!");
+    }
+
     /**
      * A marker object that we can immediately enqueue. When this object's
      * finalize() method is called, we know all previously-enqueued finalizable
      * references have been finalized.
-     *
-     * <p>Each instance of this class will be finalized twice as it is enqueued
-     * directly and by the garbage collector.
      */
     private static class Sentinel {
         boolean finalized = false;
+
         @Override protected synchronized void finalize() throws Throwable {
+            if (finalized) {
+                throw new AssertionError();
+            }
             finalized = true;
             notifyAll();
         }
+
         synchronized void awaitFinalization() throws InterruptedException {
             while (!finalized) {
                 wait();
diff --git a/luni/src/test/java/libcore/java/lang/ref/FinalizeTest.java b/luni/src/test/java/libcore/java/lang/ref/FinalizeTest.java
index 10a26fe..ef303bd 100644
--- a/luni/src/test/java/libcore/java/lang/ref/FinalizeTest.java
+++ b/luni/src/test/java/libcore/java/lang/ref/FinalizeTest.java
@@ -29,18 +29,42 @@ public final class FinalizeTest extends TestCase {
 
         FinalizationTester.induceFinalization();
         if (!finalized.get()) {
-            fail();
+            fail("object not yet finalized");
+        }
+    }
+
+    /**
+     * Test verifies that runFinalization() does not mess up objects
+     * that should be finalized later on. http://b/6907299
+     */
+    public void testInducedFinalization() throws Exception {
+        AtomicBoolean finalized1 = new AtomicBoolean();
+        AtomicBoolean finalized2 = new AtomicBoolean();
+        createFinalizableObject(finalized1);
+        createFinalizableObject(finalized2);
+        FinalizationTester.induceFinalization();
+        if (!finalized1.get() || !finalized2.get()) {
+            fail("not yet finalized: " + finalized1.get() + " " + finalized2.get());
         }
     }
 
     /** Do not inline this method; that could break non-precise GCs. See FinalizationTester. */
-    private void createFinalizableObject(final AtomicBoolean finalized) {
-        new X() {
+    private X createFinalizableObject(final AtomicBoolean finalized) {
+        X result = new X() {
             @Override protected void finalize() throws Throwable {
                 super.finalize();
                 finalized.set(true);
             }
         };
+        FinalizationTester.induceFinalization();
+        // Dance around a bit to discourage dx from realizing that 'result' is no longer live.
+        boolean wasFinalized = finalized.get();
+        if (wasFinalized) {
+            fail("finalizer called early"); // ...because 'result' is still live until we return.
+        }
+        // But we don't actually want to return 'result' because then we'd have to worry about
+        // the caller accidentally keeping it live.
+        return wasFinalized ? result : null;
     }
 
     static class X {}
diff --git a/luni/src/test/java/libcore/java/net/URLConnectionTest.java b/luni/src/test/java/libcore/java/net/URLConnectionTest.java
index a1747fa..762bac4 100644
--- a/luni/src/test/java/libcore/java/net/URLConnectionTest.java
+++ b/luni/src/test/java/libcore/java/net/URLConnectionTest.java
@@ -854,7 +854,7 @@ public final class URLConnectionTest extends TestCase {
         }
 
         public boolean wasCloseGuardCalled() {
-            // FinalizationTester.induceFinalization();
+            FinalizationTester.induceFinalization();
             close();
             return closeGuardCalled.get();
         }
-- 
cgit v1.1


From 3b0d46bf84c613653a87bd1f3ecfaaf236c35437 Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Wed, 13 Jun 2012 09:19:08 -0700
Subject: CA certificate update: T-TeleSec GlobalRoot Class 3

Added    SHA1      : 55:A6:72:3E:CB:F2:EC:CD:C3:23:74:70:19:9D:2A:BE:11:E3:81:D1
         Subject   : C=DE, O=T-Systems Enterprise Services GmbH, OU=T-Systems Trust Center, CN=T-TeleSec GlobalRoot Class 3

(cherry-pick of 32c5676df786e29990b7fff9886b48b11555e004.)

Bug: http://code.google.com/p/android/issues/detail?id=33063
Change-Id: Ia8cd625739548a6299e3f3c384e9545388ea07ab
---
 luni/src/main/files/cacerts/1e1eab7c.0 | 80 ++++++++++++++++++++++++++++++++++
 1 file changed, 80 insertions(+)
 create mode 100644 luni/src/main/files/cacerts/1e1eab7c.0

diff --git a/luni/src/main/files/cacerts/1e1eab7c.0 b/luni/src/main/files/cacerts/1e1eab7c.0
new file mode 100644
index 0000000..a7cf5f9
--- /dev/null
+++ b/luni/src/main/files/cacerts/1e1eab7c.0
@@ -0,0 +1,80 @@
+-----BEGIN CERTIFICATE-----
+MIIDwzCCAqugAwIBAgIBATANBgkqhkiG9w0BAQsFADCBgjELMAkGA1UEBhMCREUx
+KzApBgNVBAoMIlQtU3lzdGVtcyBFbnRlcnByaXNlIFNlcnZpY2VzIEdtYkgxHzAd
+BgNVBAsMFlQtU3lzdGVtcyBUcnVzdCBDZW50ZXIxJTAjBgNVBAMMHFQtVGVsZVNl
+YyBHbG9iYWxSb290IENsYXNzIDMwHhcNMDgxMDAxMTAyOTU2WhcNMzMxMDAxMjM1
+OTU5WjCBgjELMAkGA1UEBhMCREUxKzApBgNVBAoMIlQtU3lzdGVtcyBFbnRlcnBy
+aXNlIFNlcnZpY2VzIEdtYkgxHzAdBgNVBAsMFlQtU3lzdGVtcyBUcnVzdCBDZW50
+ZXIxJTAjBgNVBAMMHFQtVGVsZVNlYyBHbG9iYWxSb290IENsYXNzIDMwggEiMA0G
+CSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC9dZPwYiJvJK7genasfb3ZJNW4t/zN
+8ELg63iIVl6bmlQdTQyK9tPPcPRStdiTBONGhnFBSivwKixVA9ZIw+A5OO3yXDw/
+RLyTPWGrTs0NvvAgJ1gORH8EGoel15YUNpDQSXuhdfsaa3Ox+M6pCSzyU9XDFES4
+hqX2iys52qMzVNn6chr3IhUciJFrf2blw2qAsCTz34ZFiP0Zf3WHHx+xGwpzJFu5
+ZeAsVMhg02YXP+HMVDNzkQI6pn97djmiH5a2OK61yJN0HZ65tOVgnS9W0eDrXltM
+EnAMbEQgqxHY9Bn20pxSN+f6tsIxO0rUFJmtxxr1XV/6B7h8DR/Wgx6zAgMBAAGj
+QjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBS1
+A/d2O2GCahKqGFPrAyGUv/7OyjANBgkqhkiG9w0BAQsFAAOCAQEAVj3vlNW92nOy
+WL6ukK2YJ5f+AbGwUgC4TeQbIXQbfsDuXmkqJa9c1h3a0nnJ85cp4IaH3gRZD/FZ
+1GSFS5mvJQQeyUapl96Cshtwn5z2r3Ex3XsFpSzTucpH9sry9uetuUg/vBa3wW30
+6gmv7PO15wWeph6KU1HWk4HMdJP2udqmJQV0eVp+QD6CSyYRMG7hP0HHRwA11fXT
+91Q+gT3aSWqas+8QPebrb9HIIkfLzM8BMZLZGOMivgkeGj5asuRrDFR6fUNOuIml
+e9eiPZaGzPImNC1qkp2aGtAw4l1OBLBfiyB+d8E9lYLRRpo7PHi4b6HQDWSieB4p
+TpPDpFQUWw==
+-----END CERTIFICATE-----
+Certificate:
+    Data:
+        Version: 3 (0x2)
+        Serial Number: 1 (0x1)
+        Signature Algorithm: sha256WithRSAEncryption
+        Issuer: C=DE, O=T-Systems Enterprise Services GmbH, OU=T-Systems Trust Center, CN=T-TeleSec GlobalRoot Class 3
+        Validity
+            Not Before: Oct  1 10:29:56 2008 GMT
+            Not After : Oct  1 23:59:59 2033 GMT
+        Subject: C=DE, O=T-Systems Enterprise Services GmbH, OU=T-Systems Trust Center, CN=T-TeleSec GlobalRoot Class 3
+        Subject Public Key Info:
+            Public Key Algorithm: rsaEncryption
+            RSA Public Key: (2048 bit)
+                Modulus (2048 bit):
+                    00:bd:75:93:f0:62:22:6f:24:ae:e0:7a:76:ac:7d:
+                    bd:d9:24:d5:b8:b7:fc:cd:f0:42:e0:eb:78:88:56:
+                    5e:9b:9a:54:1d:4d:0c:8a:f6:d3:cf:70:f4:52:b5:
+                    d8:93:04:e3:46:86:71:41:4a:2b:f0:2a:2c:55:03:
+                    d6:48:c3:e0:39:38:ed:f2:5c:3c:3f:44:bc:93:3d:
+                    61:ab:4e:cd:0d:be:f0:20:27:58:0e:44:7f:04:1a:
+                    87:a5:d7:96:14:36:90:d0:49:7b:a1:75:fb:1a:6b:
+                    73:b1:f8:ce:a9:09:2c:f2:53:d5:c3:14:44:b8:86:
+                    a5:f6:8b:2b:39:da:a3:33:54:d9:fa:72:1a:f7:22:
+                    15:1c:88:91:6b:7f:66:e5:c3:6a:80:b0:24:f3:df:
+                    86:45:88:fd:19:7f:75:87:1f:1f:b1:1b:0a:73:24:
+                    5b:b9:65:e0:2c:54:c8:60:d3:66:17:3f:e1:cc:54:
+                    33:73:91:02:3a:a6:7f:7b:76:39:a2:1f:96:b6:38:
+                    ae:b5:c8:93:74:1d:9e:b9:b4:e5:60:9d:2f:56:d1:
+                    e0:eb:5e:5b:4c:12:70:0c:6c:44:20:ab:11:d8:f4:
+                    19:f6:d2:9c:52:37:e7:fa:b6:c2:31:3b:4a:d4:14:
+                    99:ad:c7:1a:f5:5d:5f:fa:07:b8:7c:0d:1f:d6:83:
+                    1e:b3
+                Exponent: 65537 (0x10001)
+        X509v3 extensions:
+            X509v3 Basic Constraints: critical
+                CA:TRUE
+            X509v3 Key Usage: critical
+                Certificate Sign, CRL Sign
+            X509v3 Subject Key Identifier: 
+                B5:03:F7:76:3B:61:82:6A:12:AA:18:53:EB:03:21:94:BF:FE:CE:CA
+    Signature Algorithm: sha256WithRSAEncryption
+        56:3d:ef:94:d5:bd:da:73:b2:58:be:ae:90:ad:98:27:97:fe:
+        01:b1:b0:52:00:b8:4d:e4:1b:21:74:1b:7e:c0:ee:5e:69:2a:
+        25:af:5c:d6:1d:da:d2:79:c9:f3:97:29:e0:86:87:de:04:59:
+        0f:f1:59:d4:64:85:4b:99:af:25:04:1e:c9:46:a9:97:de:82:
+        b2:1b:70:9f:9c:f6:af:71:31:dd:7b:05:a5:2c:d3:b9:ca:47:
+        f6:ca:f2:f6:e7:ad:b9:48:3f:bc:16:b7:c1:6d:f4:ea:09:af:
+        ec:f3:b5:e7:05:9e:a6:1e:8a:53:51:d6:93:81:cc:74:93:f6:
+        b9:da:a6:25:05:74:79:5a:7e:40:3e:82:4b:26:11:30:6e:e1:
+        3f:41:c7:47:00:35:d5:f5:d3:f7:54:3e:81:3d:da:49:6a:9a:
+        b3:ef:10:3d:e6:eb:6f:d1:c8:22:47:cb:cc:cf:01:31:92:d9:
+        18:e3:22:be:09:1e:1a:3e:5a:b2:e4:6b:0c:54:7a:7d:43:4e:
+        b8:89:a5:7b:d7:a2:3d:96:86:cc:f2:26:34:2d:6a:92:9d:9a:
+        1a:d0:30:e2:5d:4e:04:b0:5f:8b:20:7e:77:c1:3d:95:82:d1:
+        46:9a:3b:3c:78:b8:6f:a1:d0:0d:64:a2:78:1e:29:4e:93:c3:
+        a4:54:14:5b
+SHA1 Fingerprint=55:A6:72:3E:CB:F2:EC:CD:C3:23:74:70:19:9D:2A:BE:11:E3:81:D1
-- 
cgit v1.1


From 63ac769acae3e1fa23aed3a6059325a9b9d91352 Mon Sep 17 00:00:00 2001
From: Ian Rogers <irogers@google.com>
Date: Tue, 20 Mar 2012 10:51:03 -0700
Subject: Use float comparison for setTargetHeapUtilization constants.

(cherry-pick of f655188036ceab8968a510ae67455a27917546cf.)

Change-Id: I587ad497ee9ac38f4052cdfdd861e8b24dd80712
---
 dalvik/src/main/java/dalvik/system/VMRuntime.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/dalvik/src/main/java/dalvik/system/VMRuntime.java b/dalvik/src/main/java/dalvik/system/VMRuntime.java
index c37290d..71098be 100644
--- a/dalvik/src/main/java/dalvik/system/VMRuntime.java
+++ b/dalvik/src/main/java/dalvik/system/VMRuntime.java
@@ -91,7 +91,7 @@ public final class VMRuntime {
      * @throws IllegalArgumentException if newTarget is &lt;= 0.0 or &gt;= 1.0
      */
     public float setTargetHeapUtilization(float newTarget) {
-        if (newTarget <= 0.0 || newTarget >= 1.0) {
+        if (newTarget <= 0.0f || newTarget >= 1.0f) {
             throw new IllegalArgumentException(newTarget +
                     " out of range (0,1)");
         }
-- 
cgit v1.1


From 3bbe5318c343b1b7c945be717cc55b4ab15874f2 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Tue, 24 Jan 2012 17:13:54 -0800
Subject: Improve the BaseDexClassLoader detail message, and make
 ScopedLocalRef more unique_ptr-like.

(cherry-pick of 1c459db4ea31c1f284353bc71bfd2dbc97ca53d7.)

Conflicts:

	include/ScopedLocalRef.h

Change-Id: Id01cb907406cc93f6b0f6ddaa8e7fb3714d18c53
---
 .../main/java/dalvik/system/BaseDexClassLoader.java  |  2 +-
 include/ScopedLocalRef.h                             | 20 +++++++++++++-------
 2 files changed, 14 insertions(+), 8 deletions(-)

diff --git a/dalvik/src/main/java/dalvik/system/BaseDexClassLoader.java b/dalvik/src/main/java/dalvik/system/BaseDexClassLoader.java
index ab24f0b..5782fd9 100644
--- a/dalvik/src/main/java/dalvik/system/BaseDexClassLoader.java
+++ b/dalvik/src/main/java/dalvik/system/BaseDexClassLoader.java
@@ -58,7 +58,7 @@ public class BaseDexClassLoader extends ClassLoader {
         Class clazz = pathList.findClass(name);
 
         if (clazz == null) {
-            throw new ClassNotFoundException(name);
+            throw new ClassNotFoundException("Didn't find class \"" + name + "\" on path: " + originalPath);
         }
 
         return clazz;
diff --git a/include/ScopedLocalRef.h b/include/ScopedLocalRef.h
index 84ee11a..e239b9e 100644
--- a/include/ScopedLocalRef.h
+++ b/include/ScopedLocalRef.h
@@ -23,22 +23,28 @@
 template<typename T>
 class ScopedLocalRef {
 public:
-    ScopedLocalRef(JNIEnv* env, T localRef)
-    : mEnv(env), mLocalRef(localRef)
-    {
+    ScopedLocalRef(JNIEnv* env, T localRef) : mEnv(env), mLocalRef(localRef) {
     }
 
     ~ScopedLocalRef() {
         reset();
     }
 
-    void reset() {
-        if (mLocalRef != NULL) {
-            mEnv->DeleteLocalRef(mLocalRef);
-            mLocalRef = NULL;
+    void reset(T ptr = NULL) {
+        if (ptr != mLocalRef) {
+            if (mLocalRef != NULL) {
+                mEnv->DeleteLocalRef(mLocalRef);
+            }
+            mLocalRef = ptr;
         }
     }
 
+    T release() __attribute__((warn_unused_result)) {
+        T localRef = mLocalRef;
+        mLocalRef = NULL;
+        return localRef;
+    }
+
     T get() const {
         return mLocalRef;
     }
-- 
cgit v1.1


From 4e0af08342cdb9c29b6039ba61ff6bd0bcbf125d Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Wed, 1 Aug 2012 12:55:14 -0700
Subject: Clean up #includes in ScopedLocalRef.h.

Change-Id: I755dc2feb90d767a1e16e98bd39f1de7681eb60c
---
 include/ScopedLocalRef.h | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/include/ScopedLocalRef.h b/include/ScopedLocalRef.h
index e239b9e..71d5776 100644
--- a/include/ScopedLocalRef.h
+++ b/include/ScopedLocalRef.h
@@ -17,7 +17,9 @@
 #ifndef SCOPED_LOCAL_REF_H_included
 #define SCOPED_LOCAL_REF_H_included
 
-#include "JNIHelp.h"
+#include "jni.h"
+
+#include <stddef.h>
 
 // A smart pointer that deletes a JNI local reference when it goes out of scope.
 template<typename T>
-- 
cgit v1.1


From 834ce234b54466ba230b3c7199d4363a837c5628 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Wed, 7 Sep 2011 10:23:09 -0700
Subject: Improve detail messages for throwers of NegativeArraySizeException.

(cherry-pick of e1766a71541cbc592c6ceb6fe703258bebd9c15e.)

Change-Id: Ib208ac64d26f2969299667d3312eb0fd1fdda3d1
---
 .../main/java/java/lang/AbstractStringBuilder.java   |  2 +-
 luni/src/main/java/java/util/Arrays.java             | 20 ++++++++++----------
 luni/src/main/java/java/util/BitSet.java             |  2 +-
 3 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/luni/src/main/java/java/lang/AbstractStringBuilder.java b/luni/src/main/java/java/lang/AbstractStringBuilder.java
index baab47d..6e46d26 100644
--- a/luni/src/main/java/java/lang/AbstractStringBuilder.java
+++ b/luni/src/main/java/java/lang/AbstractStringBuilder.java
@@ -77,7 +77,7 @@ abstract class AbstractStringBuilder {
 
     AbstractStringBuilder(int capacity) {
         if (capacity < 0) {
-            throw new NegativeArraySizeException();
+            throw new NegativeArraySizeException(Integer.toString(capacity));
         }
         value = new char[capacity];
     }
diff --git a/luni/src/main/java/java/util/Arrays.java b/luni/src/main/java/java/util/Arrays.java
index 9d0f4a4..588410f 100644
--- a/luni/src/main/java/java/util/Arrays.java
+++ b/luni/src/main/java/java/util/Arrays.java
@@ -2459,7 +2459,7 @@ public class Arrays {
      */
     public static boolean[] copyOf(boolean[] original, int newLength) {
         if (newLength < 0) {
-            throw new NegativeArraySizeException();
+            throw new NegativeArraySizeException(Integer.toString(newLength));
         }
         return copyOfRange(original, 0, newLength);
     }
@@ -2478,7 +2478,7 @@ public class Arrays {
      */
     public static byte[] copyOf(byte[] original, int newLength) {
         if (newLength < 0) {
-            throw new NegativeArraySizeException();
+            throw new NegativeArraySizeException(Integer.toString(newLength));
         }
         return copyOfRange(original, 0, newLength);
     }
@@ -2497,7 +2497,7 @@ public class Arrays {
      */
     public static char[] copyOf(char[] original, int newLength) {
         if (newLength < 0) {
-            throw new NegativeArraySizeException();
+            throw new NegativeArraySizeException(Integer.toString(newLength));
         }
         return copyOfRange(original, 0, newLength);
     }
@@ -2516,7 +2516,7 @@ public class Arrays {
      */
     public static double[] copyOf(double[] original, int newLength) {
         if (newLength < 0) {
-            throw new NegativeArraySizeException();
+            throw new NegativeArraySizeException(Integer.toString(newLength));
         }
         return copyOfRange(original, 0, newLength);
     }
@@ -2535,7 +2535,7 @@ public class Arrays {
      */
     public static float[] copyOf(float[] original, int newLength) {
         if (newLength < 0) {
-            throw new NegativeArraySizeException();
+            throw new NegativeArraySizeException(Integer.toString(newLength));
         }
         return copyOfRange(original, 0, newLength);
     }
@@ -2554,7 +2554,7 @@ public class Arrays {
      */
     public static int[] copyOf(int[] original, int newLength) {
         if (newLength < 0) {
-            throw new NegativeArraySizeException();
+            throw new NegativeArraySizeException(Integer.toString(newLength));
         }
         return copyOfRange(original, 0, newLength);
     }
@@ -2573,7 +2573,7 @@ public class Arrays {
      */
     public static long[] copyOf(long[] original, int newLength) {
         if (newLength < 0) {
-            throw new NegativeArraySizeException();
+            throw new NegativeArraySizeException(Integer.toString(newLength));
         }
         return copyOfRange(original, 0, newLength);
     }
@@ -2592,7 +2592,7 @@ public class Arrays {
      */
     public static short[] copyOf(short[] original, int newLength) {
         if (newLength < 0) {
-            throw new NegativeArraySizeException();
+            throw new NegativeArraySizeException(Integer.toString(newLength));
         }
         return copyOfRange(original, 0, newLength);
     }
@@ -2614,7 +2614,7 @@ public class Arrays {
             throw new NullPointerException();
         }
         if (newLength < 0) {
-            throw new NegativeArraySizeException();
+            throw new NegativeArraySizeException(Integer.toString(newLength));
         }
         return copyOfRange(original, 0, newLength);
     }
@@ -2636,7 +2636,7 @@ public class Arrays {
     public static <T, U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
         // We use the null pointer check in copyOfRange for exception priority compatibility.
         if (newLength < 0) {
-            throw new NegativeArraySizeException();
+            throw new NegativeArraySizeException(Integer.toString(newLength));
         }
         return copyOfRange(original, 0, newLength, newType);
     }
diff --git a/luni/src/main/java/java/util/BitSet.java b/luni/src/main/java/java/util/BitSet.java
index a4ee4c1..9dfe35e 100644
--- a/luni/src/main/java/java/util/BitSet.java
+++ b/luni/src/main/java/java/util/BitSet.java
@@ -85,7 +85,7 @@ public class BitSet implements Serializable, Cloneable {
      */
     public BitSet(int bitCount) {
         if (bitCount < 0) {
-            throw new NegativeArraySizeException();
+            throw new NegativeArraySizeException(Integer.toString(bitCount));
         }
         this.bits = arrayForBits(bitCount);
         this.longCount = 0;
-- 
cgit v1.1


From 9634b569a92841f32268907c88c408f22cb00486 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Fri, 18 May 2012 09:37:47 -0700
Subject: Stop using -fvisibility=hidden.

It breaks backtraces, and backtraces are useful. (The debugger uses
the ELF debug info, so it doesn't care, but backtracing just uses the
symbols.)

(cherry-pick of da2fb9754a9ccfa954c1b554982f06e7cf7d680a.)

Bug: 6447213
Change-Id: I957df0e935b61bcf5fefc0e506ecdaa862bc7d07
---
 NativeCode.mk                                  | 3 ---
 luni/src/main/native/libcore_io_Posix.cpp      | 2 +-
 luni/src/main/native/libcore_net_RawSocket.cpp | 6 ++++--
 3 files changed, 5 insertions(+), 6 deletions(-)

diff --git a/NativeCode.mk b/NativeCode.mk
index 2a222b1..fae0fce 100644
--- a/NativeCode.mk
+++ b/NativeCode.mk
@@ -65,9 +65,6 @@ $(foreach dir, \
 core_c_includes := $(sort libcore/include $(LOCAL_C_INCLUDES) $(JNI_H_INCLUDE))
 core_shared_libraries := $(sort $(LOCAL_SHARED_LIBRARIES))
 core_static_libraries := $(sort $(LOCAL_STATIC_LIBRARIES))
-core_cflags := -fvisibility=hidden
-core_cflags += '-DGCC_HIDDEN=__attribute__((visibility("hidden")))'
-core_cppflags := -fvisibility-inlines-hidden
 
 
 #
diff --git a/luni/src/main/native/libcore_io_Posix.cpp b/luni/src/main/native/libcore_io_Posix.cpp
index 30ca145..5a3382a 100644
--- a/luni/src/main/native/libcore_io_Posix.cpp
+++ b/luni/src/main/native/libcore_io_Posix.cpp
@@ -1102,7 +1102,7 @@ static void Posix_setsockoptGroupReq(JNIEnv* env, jobject, jobject javaFd, jint
     if (rc == -1 && errno == EINVAL) {
         // Maybe we're a 32-bit binary talking to a 64-bit kernel?
         // glibc doesn't automatically handle this.
-        struct GCC_HIDDEN group_req64 {
+        struct group_req64 {
             uint32_t gr_interface;
             uint32_t my_padding;
             sockaddr_storage gr_group;
diff --git a/luni/src/main/native/libcore_net_RawSocket.cpp b/luni/src/main/native/libcore_net_RawSocket.cpp
index 4e5059f..2e493ac 100644
--- a/luni/src/main/native/libcore_net_RawSocket.cpp
+++ b/luni/src/main/native/libcore_net_RawSocket.cpp
@@ -38,10 +38,10 @@
 #include <netinet/ip.h>
 #include <linux/udp.h>
 
-union GCC_HIDDEN sockunion {
+union sockunion {
     sockaddr sa;
     sockaddr_ll sll;
-} su;
+};
 
 /*
  * Creates a socket suitable for raw socket operations.  The socket is
@@ -61,6 +61,7 @@ static void RawSocket_create(JNIEnv* env, jclass, jobject fileDescriptor,
     return;
   }
 
+  sockunion su;
   memset(&su, 0, sizeof(su));
   su.sll.sll_family = PF_PACKET;
   su.sll.sll_protocol = htons(protocolType);
@@ -119,6 +120,7 @@ static int RawSocket_sendPacket(JNIEnv* env, jclass, jobject fileDescriptor,
     return 0;
   }
 
+  sockunion su;
   memset(&su, 0, sizeof(su));
   su.sll.sll_hatype = htons(1); // ARPHRD_ETHER
   su.sll.sll_halen = mac.size();
-- 
cgit v1.1


From 695b2a12fb5420680ab7da33c5ebd683853f4050 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Fri, 16 Dec 2011 15:26:23 -0800
Subject: Amortize the cost of Class.isEnum in Enum.valueOf.

(cherry-pick of 1f6a7be67187fa6553f6466c0ec311294149f754.)

Conflicts:

	luni/src/main/java/java/lang/Enum.java

Change-Id: Ic4905650dfd8c2b8359ab723955d228771ea27c7
---
 luni/src/main/java/java/lang/Enum.java | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/luni/src/main/java/java/lang/Enum.java b/luni/src/main/java/java/lang/Enum.java
index 391670c..3d9e68b 100644
--- a/luni/src/main/java/java/lang/Enum.java
+++ b/luni/src/main/java/java/lang/Enum.java
@@ -34,6 +34,9 @@ public abstract class Enum<E extends Enum<E>> implements Serializable, Comparabl
     private static final BasicLruCache<Class<? extends Enum>, Object[]> sharedConstantsCache
             = new BasicLruCache<Class<? extends Enum>, Object[]>(64) {
         @Override protected Object[] create(Class<? extends Enum> enumType) {
+            if (!enumType.isEnum()) {
+                return null;
+            }
             Method method = (Method) Class.getDeclaredConstructorOrMethod(
                     enumType, "values", EmptyArray.CLASS);
             try {
@@ -181,10 +184,11 @@ public abstract class Enum<E extends Enum<E>> implements Serializable, Comparabl
         if (enumType == null || name == null) {
             throw new NullPointerException("enumType == null || name == null");
         }
-        if (!enumType.isEnum()) {
+        T[] values = getSharedConstants(enumType);
+        if (values == null) {
             throw new IllegalArgumentException(enumType + " is not an enum type");
         }
-        for (T value : getSharedConstants(enumType)) {
+        for (T value : values) {
             if (name.equals(value.name())) {
                 return value;
             }
-- 
cgit v1.1


From 2680db46e43b69cc1c49429d371cd1c7512d6f2c Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Wed, 1 Aug 2012 13:56:26 -0700
Subject: Clean up lint in java.lang.ref.

Change-Id: Ie54af5965f07e8f0261eaeb5803d718658da2a23
---
 .../java/java/lang/ref/FinalizerReference.java     | 23 +++++++++++-----------
 luni/src/main/java/java/lang/ref/Reference.java    |  5 ++---
 .../main/java/java/lang/ref/ReferenceQueue.java    |  4 +---
 3 files changed, 15 insertions(+), 17 deletions(-)

diff --git a/luni/src/main/java/java/lang/ref/FinalizerReference.java b/luni/src/main/java/java/lang/ref/FinalizerReference.java
index 7a6d871..14eaae4 100644
--- a/luni/src/main/java/java/lang/ref/FinalizerReference.java
+++ b/luni/src/main/java/java/lang/ref/FinalizerReference.java
@@ -28,11 +28,11 @@ public final class FinalizerReference<T> extends Reference<T> {
 
     // This list contains a FinalizerReference for every finalizable object in the heap.
     // Objects in this list may or may not be eligible for finalization yet.
-    private static FinalizerReference head = null;
+    private static FinalizerReference<?> head = null;
 
     // The links used to construct the list.
-    private FinalizerReference prev;
-    private FinalizerReference next;
+    private FinalizerReference<?> prev;
+    private FinalizerReference<?> next;
 
     // When the GC wants something finalized, it moves it from the 'referent' field to
     // the 'zombie' field instead.
@@ -50,7 +50,7 @@ public final class FinalizerReference<T> extends Reference<T> {
         zombie = null;
     }
 
-    static void add(Object referent) {
+    public static void add(Object referent) {
         FinalizerReference<?> reference = new FinalizerReference<Object>(referent, queue);
         synchronized (LIST_LOCK) {
             reference.prev = null;
@@ -62,10 +62,10 @@ public final class FinalizerReference<T> extends Reference<T> {
         }
     }
 
-    public static void remove(FinalizerReference reference) {
+    public static void remove(FinalizerReference<?> reference) {
         synchronized (LIST_LOCK) {
-            FinalizerReference next = reference.next;
-            FinalizerReference prev = reference.prev;
+            FinalizerReference<?> next = reference.next;
+            FinalizerReference<?> prev = reference.prev;
             reference.next = null;
             reference.prev = null;
             if (prev != null) {
@@ -93,11 +93,12 @@ public final class FinalizerReference<T> extends Reference<T> {
             // When a finalizable object is allocated, a FinalizerReference is added to the list.
             // We search the list for that FinalizerReference (it should be at or near the head),
             // and then put it on the queue so that it can be finalized.
-            for (FinalizerReference r = head; r != null; r = r.next) {
+            for (FinalizerReference<?> r = head; r != null; r = r.next) {
                 if (r.referent == sentinel) {
-                    r.referent = null;
-                    r.zombie = sentinel;
-                    r.enqueueInternal();
+                    FinalizerReference<Sentinel> sentinelReference = (FinalizerReference<Sentinel>) r;
+                    sentinelReference.referent = null;
+                    sentinelReference.zombie = sentinel;
+                    sentinelReference.enqueueInternal();
                     return;
                 }
             }
diff --git a/luni/src/main/java/java/lang/ref/Reference.java b/luni/src/main/java/java/lang/ref/Reference.java
index 85fbb04..9cf49a7 100644
--- a/luni/src/main/java/java/lang/ref/Reference.java
+++ b/luni/src/main/java/java/lang/ref/Reference.java
@@ -55,8 +55,7 @@ public abstract class Reference<T> {
      * VM requirement: this field <em>must</em> be called "queue"
      * and be a java.lang.ref.ReferenceQueue.
      */
-    @SuppressWarnings("unchecked")
-    volatile ReferenceQueue queue;
+    volatile ReferenceQueue<? super T> queue;
 
     /**
      * Used internally by java.lang.ref.ReferenceQueue.
@@ -82,7 +81,7 @@ public abstract class Reference<T> {
     Reference() {
     }
 
-    Reference(T r, ReferenceQueue q) {
+    Reference(T r, ReferenceQueue<? super T> q) {
         referent = r;
         queue = q;
     }
diff --git a/luni/src/main/java/java/lang/ref/ReferenceQueue.java b/luni/src/main/java/java/lang/ref/ReferenceQueue.java
index 6c9b4d5..2b8089c 100644
--- a/luni/src/main/java/java/lang/ref/ReferenceQueue.java
+++ b/luni/src/main/java/java/lang/ref/ReferenceQueue.java
@@ -131,8 +131,6 @@ public class ReferenceQueue<T> {
      *
      * @param reference
      *            reference object to be enqueued.
-     * @return boolean true if reference is enqueued. false if reference failed
-     *         to enqueue.
      */
     synchronized void enqueue(Reference<? extends T> reference) {
         if (head == null) {
@@ -145,7 +143,7 @@ public class ReferenceQueue<T> {
     }
 
     /** @hide */
-    public static Reference unenqueued = null;
+    public static Reference<?> unenqueued = null;
 
     static void add(Reference<?> list) {
         synchronized (ReferenceQueue.class) {
-- 
cgit v1.1


From 75245fcfe3555e4dd06939b9bae366fd3e43b658 Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Sun, 1 Apr 2012 19:55:38 -0700
Subject: Include library path information in BaseDexClassLoader for better
 error reporting in Runtime.loadLibrary

(cherry-pick of b6a576f43f1c23bb92493590a04bf9c72f092438.)

Change-Id: I6f34862327cf99d8c6f9a7e9aa3aeab47985969b
---
 dalvik/src/main/java/dalvik/system/BaseDexClassLoader.java | 7 ++++++-
 luni/src/main/java/java/lang/Runtime.java                  | 5 +++--
 2 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/dalvik/src/main/java/dalvik/system/BaseDexClassLoader.java b/dalvik/src/main/java/dalvik/system/BaseDexClassLoader.java
index 5782fd9..62ec5e3 100644
--- a/dalvik/src/main/java/dalvik/system/BaseDexClassLoader.java
+++ b/dalvik/src/main/java/dalvik/system/BaseDexClassLoader.java
@@ -28,6 +28,9 @@ public class BaseDexClassLoader extends ClassLoader {
     /** originally specified path (just used for {@code toString()}) */
     private final String originalPath;
 
+    /** originally specified library path (just used for {@code toString()}) */
+    private final String originalLibraryPath;
+
     /** structured lists of path elements */
     private final DexPathList pathList;
 
@@ -49,6 +52,7 @@ public class BaseDexClassLoader extends ClassLoader {
         super(parent);
 
         this.originalPath = dexPath;
+        this.originalLibraryPath = libraryPath;
         this.pathList =
             new DexPathList(this, dexPath, libraryPath, optimizedDirectory);
     }
@@ -123,6 +127,7 @@ public class BaseDexClassLoader extends ClassLoader {
 
     @Override
     public String toString() {
-        return getClass().getName() + "[" + originalPath + "]";
+        return getClass().getName()
+                + "[dexPath=" + originalPath + ",libraryPath=" + originalLibraryPath + "]";
     }
 }
diff --git a/luni/src/main/java/java/lang/Runtime.java b/luni/src/main/java/java/lang/Runtime.java
index 320f157..efe2303 100644
--- a/luni/src/main/java/java/lang/Runtime.java
+++ b/luni/src/main/java/java/lang/Runtime.java
@@ -362,8 +362,9 @@ public class Runtime {
         if (loader != null) {
             String filename = loader.findLibrary(libraryName);
             if (filename == null) {
-                throw new UnsatisfiedLinkError("Couldn't load " + libraryName + ": " +
-                        "findLibrary returned null");
+                throw new UnsatisfiedLinkError("Couldn't load " + libraryName
+                                               + " from loader " + loader
+                                               + ": findLibrary returned null");
             }
             String error = nativeLoad(filename, loader);
             if (error != null) {
-- 
cgit v1.1


From a8b15bcac1bd17987118da06f4c63afd8799910d Mon Sep 17 00:00:00 2001
From: Ian Rogers <irogers@google.com>
Date: Tue, 31 Jan 2012 14:45:35 -0800
Subject: Avoid creating suppressedExceptions ArrayList for all Throwables

Suppressed exceptions are a Java 7 feature and therefore unlikely to be
being used. Throwable is the parent of all exceptions, so allocating
memory here is expensive. Make Throwable use Collections empty list when
no suppressed exceptions are present and then create a list when asked
to add a suppressed exception.

(cherry-pick of 24d2b0060b13d953cb5a9f10d7d2198ec3385f85.)

Change-Id: I66e4a755be66493b33c9562a8275c006b601b28e
---
 luni/src/main/java/java/lang/Throwable.java | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/luni/src/main/java/java/lang/Throwable.java b/luni/src/main/java/java/lang/Throwable.java
index b561832..e88d6ce 100644
--- a/luni/src/main/java/java/lang/Throwable.java
+++ b/luni/src/main/java/java/lang/Throwable.java
@@ -23,6 +23,7 @@ import java.io.ObjectOutputStream;
 import java.io.PrintStream;
 import java.io.PrintWriter;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 import libcore.util.EmptyArray;
 
@@ -63,7 +64,7 @@ public class Throwable implements java.io.Serializable {
      * Throwables suppressed by this throwable. Null when suppressed exceptions
      * are disabled.
      */
-    private List<Throwable> suppressedExceptions = new ArrayList<Throwable>();
+    private List<Throwable> suppressedExceptions = Collections.emptyList();
 
     /**
      * An intermediate representation of the stack trace.  This field may
@@ -418,6 +419,11 @@ public class Throwable implements java.io.Serializable {
             throw new NullPointerException("suppressed == null");
         }
         if (suppressedExceptions != null) {
+            // suppressed exceptions are enabled
+            if (suppressedExceptions.isEmpty()) {
+                // ensure we have somewhere to place suppressed exceptions
+                suppressedExceptions = new ArrayList<Throwable>(1);
+            }
             suppressedExceptions.add(throwable);
         }
     }
@@ -429,7 +435,7 @@ public class Throwable implements java.io.Serializable {
      * @hide 1.7
      */
     public final Throwable[] getSuppressed() {
-        return (suppressedExceptions != null)
+        return (suppressedExceptions != null && !suppressedExceptions.isEmpty())
                 ? suppressedExceptions.toArray(new Throwable[suppressedExceptions.size()])
                 : EmptyArray.THROWABLE;
     }
-- 
cgit v1.1


From 254fed99854bd8ce9d5d9f6f9e16d746af3f8f7c Mon Sep 17 00:00:00 2001
From: Romain Guy <romainguy@google.com>
Date: Tue, 12 Jun 2012 12:46:47 -0700
Subject: Take the Buffer's position into account when accessing the array

Prior to this patch, our APIs would take into account a Buffer's position
if it was backed by native memory. The position would not be taken into
account for buffers backed by a Dalvik array.

(cherry-pick of 177714f960fc0c586930e23b4c98341b9b4eef56.)

Bug: http://code.google.com/p/android/issues/detail?id=32588
Change-Id: Id27bc73e4cf44caa4e304fc17a52c4732d2cd97c
---
 luni/src/main/java/java/nio/NIOAccess.java | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/luni/src/main/java/java/nio/NIOAccess.java b/luni/src/main/java/java/nio/NIOAccess.java
index 361a37f..36c41cf 100644
--- a/luni/src/main/java/java/nio/NIOAccess.java
+++ b/luni/src/main/java/java/nio/NIOAccess.java
@@ -28,7 +28,7 @@ final class NIOAccess {
      * different than what the Harmony implementation calls a "base
      * address."
      *
-     * @param Buffer b the Buffer to be queried
+     * @param b the Buffer to be queried
      * @return the native pointer to the Buffer's data at its current
      * position, or 0 if there is none
      */
@@ -44,7 +44,7 @@ final class NIOAccess {
      * Returns the underlying Java array containing the data of the
      * given Buffer, or null if the Buffer is not backed by a Java array.
      *
-     * @param Buffer b the Buffer to be queried
+     * @param b the Buffer to be queried
      * @return the Java array containing the Buffer's data, or null if
      * there is none
      */
@@ -55,13 +55,14 @@ final class NIOAccess {
     /**
      * Returns the offset in bytes from the start of the underlying
      * Java array object containing the data of the given Buffer to
-     * the actual start of the data. This method is only meaningful if
-     * getBaseArray() returns non-null.
+     * the actual start of the data. The start of the data takes into
+     * account the Buffer's current position. This method is only
+     * meaningful if getBaseArray() returns non-null.
      *
-     * @param Buffer b the Buffer to be queried
+     * @param b the Buffer to be queried
      * @return the data offset in bytes to the start of this Buffer's data
      */
     static int getBaseArrayOffset(Buffer b) {
-        return b.hasArray() ? (b.arrayOffset() << b._elementSizeShift) : 0;
+        return b.hasArray() ? ((b.arrayOffset() + b.position) << b._elementSizeShift) : 0;
     }
 }
-- 
cgit v1.1


From a807b4d808d2591894daf13aab179b2e9c46a2f5 Mon Sep 17 00:00:00 2001
From: Jesse Wilson <jessewilson@google.com>
Date: Tue, 1 Nov 2011 16:46:37 -0400
Subject: Update java.util.concurrent to 2011-nov-1.

The most recent change to the upstream CVS tree was on Tue Oct 25 20:29:12 2011 UTC.

This removes references to security managers.

(cherry-pick of d206d1f85f051ec85bc1b00d576a67fa9be13228.)

Bug: 3289698
Change-Id: Id89c909407f268fdc828ebe2bebcb1c12dbb93aa
---
 luni/src/main/java/java/util/AbstractQueue.java    |    2 +-
 luni/src/main/java/java/util/ArrayDeque.java       |   66 +-
 luni/src/main/java/java/util/Deque.java            |    5 +-
 luni/src/main/java/java/util/NavigableMap.java     |    9 +-
 luni/src/main/java/java/util/NavigableSet.java     |    9 +-
 luni/src/main/java/java/util/Queue.java            |    2 +-
 .../util/concurrent/AbstractExecutorService.java   |    2 +-
 .../java/util/concurrent/ArrayBlockingQueue.java   |  849 ++++++--
 .../java/java/util/concurrent/BlockingDeque.java   |   72 +-
 .../java/java/util/concurrent/BlockingQueue.java   |   23 +-
 .../util/concurrent/BrokenBarrierException.java    |    2 +-
 .../main/java/java/util/concurrent/Callable.java   |    2 +-
 .../util/concurrent/CancellationException.java     |    2 +-
 .../java/util/concurrent/CompletionService.java    |    2 +-
 .../java/util/concurrent/ConcurrentHashMap.java    | 1149 ++++++-----
 .../util/concurrent/ConcurrentLinkedDeque.java     |   89 +-
 .../util/concurrent/ConcurrentLinkedQueue.java     |   66 +-
 .../java/java/util/concurrent/ConcurrentMap.java   |   53 +-
 .../util/concurrent/ConcurrentNavigableMap.java    |   10 +-
 .../util/concurrent/ConcurrentSkipListMap.java     |  213 +-
 .../util/concurrent/ConcurrentSkipListSet.java     |   61 +-
 .../java/util/concurrent/CopyOnWriteArraySet.java  |    7 +-
 .../java/java/util/concurrent/CountDownLatch.java  |   15 +-
 .../java/java/util/concurrent/CyclicBarrier.java   |   48 +-
 .../main/java/java/util/concurrent/DelayQueue.java |   81 +-
 .../main/java/java/util/concurrent/Delayed.java    |    4 +-
 .../main/java/java/util/concurrent/Exchanger.java  |   15 +-
 .../java/util/concurrent/ExecutionException.java   |   10 +-
 .../main/java/java/util/concurrent/Executor.java   |   22 +-
 .../util/concurrent/ExecutorCompletionService.java |    2 +-
 .../java/java/util/concurrent/ExecutorService.java |   18 +-
 .../main/java/java/util/concurrent/Executors.java  |  114 +-
 .../java/java/util/concurrent/ForkJoinPool.java    | 2127 ++++++++++++++++++++
 .../java/java/util/concurrent/ForkJoinTask.java    | 1357 +++++++++++++
 .../java/util/concurrent/ForkJoinWorkerThread.java |  970 +++++++++
 .../src/main/java/java/util/concurrent/Future.java |    2 +-
 .../main/java/java/util/concurrent/FutureTask.java |  532 +++--
 .../java/util/concurrent/LinkedBlockingDeque.java  |   25 +-
 .../java/util/concurrent/LinkedBlockingQueue.java  |   22 +-
 .../java/util/concurrent/LinkedTransferQueue.java  | 1323 ++++++++++++
 .../src/main/java/java/util/concurrent/Phaser.java | 1135 +++++++++++
 .../util/concurrent/PriorityBlockingQueue.java     |  112 +-
 .../java/java/util/concurrent/RecursiveAction.java |  165 ++
 .../java/java/util/concurrent/RecursiveTask.java   |   69 +
 .../concurrent/RejectedExecutionException.java     |    6 +-
 .../util/concurrent/RejectedExecutionHandler.java  |    2 +-
 .../java/java/util/concurrent/RunnableFuture.java  |    2 +-
 .../util/concurrent/RunnableScheduledFuture.java   |    2 +-
 .../util/concurrent/ScheduledExecutorService.java  |    4 +-
 .../java/java/util/concurrent/ScheduledFuture.java |    2 +-
 .../concurrent/ScheduledThreadPoolExecutor.java    |  125 +-
 .../main/java/java/util/concurrent/Semaphore.java  |    9 +-
 .../java/util/concurrent/SynchronousQueue.java     |  113 +-
 .../java/java/util/concurrent/ThreadFactory.java   |    7 +-
 .../java/util/concurrent/ThreadLocalRandom.java    |  198 ++
 .../java/util/concurrent/ThreadPoolExecutor.java   |   22 +-
 .../main/java/java/util/concurrent/TimeUnit.java   |   16 +-
 .../java/util/concurrent/TimeoutException.java     |    2 +-
 .../java/java/util/concurrent/TransferQueue.java   |  133 ++
 .../java/util/concurrent/atomic/AtomicBoolean.java |   12 +-
 .../java/util/concurrent/atomic/AtomicInteger.java |   27 +-
 .../util/concurrent/atomic/AtomicIntegerArray.java |    5 +-
 .../atomic/AtomicIntegerFieldUpdater.java          |   15 +-
 .../java/util/concurrent/atomic/AtomicLong.java    |   27 +-
 .../util/concurrent/atomic/AtomicLongArray.java    |    5 +-
 .../concurrent/atomic/AtomicLongFieldUpdater.java  |   18 +-
 .../concurrent/atomic/AtomicMarkableReference.java |    6 +-
 .../util/concurrent/atomic/AtomicReference.java    |   12 +-
 .../concurrent/atomic/AtomicReferenceArray.java    |   48 +-
 .../atomic/AtomicReferenceFieldUpdater.java        |   10 +-
 .../concurrent/atomic/AtomicStampedReference.java  |    4 +-
 .../java/java/util/concurrent/atomic/Fences.java   |  540 +++++
 .../java/util/concurrent/atomic/UnsafeAccess.java  |   34 -
 .../java/util/concurrent/atomic/package-info.java  |   31 +-
 .../locks/AbstractOwnableSynchronizer.java         |    2 +-
 .../locks/AbstractQueuedLongSynchronizer.java      |    7 +-
 .../locks/AbstractQueuedSynchronizer.java          |   19 +-
 .../java/java/util/concurrent/locks/Condition.java |    9 +-
 .../main/java/java/util/concurrent/locks/Lock.java |   42 +-
 .../java/util/concurrent/locks/LockSupport.java    |   16 +-
 .../java/util/concurrent/locks/ReadWriteLock.java  |    2 +-
 .../java/util/concurrent/locks/ReentrantLock.java  |   30 +-
 .../concurrent/locks/ReentrantReadWriteLock.java   |  107 +-
 .../java/util/concurrent/locks/UnsafeAccess.java   |   34 -
 .../java/util/concurrent/locks/package-info.java   |    2 +-
 .../java/java/util/concurrent/package-info.java    |    9 +-
 86 files changed, 10769 insertions(+), 1810 deletions(-)
 create mode 100644 luni/src/main/java/java/util/concurrent/ForkJoinPool.java
 create mode 100644 luni/src/main/java/java/util/concurrent/ForkJoinTask.java
 create mode 100644 luni/src/main/java/java/util/concurrent/ForkJoinWorkerThread.java
 create mode 100644 luni/src/main/java/java/util/concurrent/LinkedTransferQueue.java
 create mode 100644 luni/src/main/java/java/util/concurrent/Phaser.java
 create mode 100644 luni/src/main/java/java/util/concurrent/RecursiveAction.java
 create mode 100644 luni/src/main/java/java/util/concurrent/RecursiveTask.java
 create mode 100644 luni/src/main/java/java/util/concurrent/ThreadLocalRandom.java
 create mode 100644 luni/src/main/java/java/util/concurrent/TransferQueue.java
 create mode 100644 luni/src/main/java/java/util/concurrent/atomic/Fences.java
 delete mode 100644 luni/src/main/java/java/util/concurrent/atomic/UnsafeAccess.java
 delete mode 100644 luni/src/main/java/java/util/concurrent/locks/UnsafeAccess.java

diff --git a/luni/src/main/java/java/util/AbstractQueue.java b/luni/src/main/java/java/util/AbstractQueue.java
index d368ac9..b046559 100644
--- a/luni/src/main/java/java/util/AbstractQueue.java
+++ b/luni/src/main/java/java/util/AbstractQueue.java
@@ -1,7 +1,7 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util;
diff --git a/luni/src/main/java/java/util/ArrayDeque.java b/luni/src/main/java/java/util/ArrayDeque.java
index fafcdb4..c4d67b8 100644
--- a/luni/src/main/java/java/util/ArrayDeque.java
+++ b/luni/src/main/java/java/util/ArrayDeque.java
@@ -1,6 +1,6 @@
 /*
  * Written by Josh Bloch of Google Inc. and released to the public domain,
- * as explained at http://creativecommons.org/licenses/publicdomain.
+ * as explained at http://creativecommons.org/publicdomain/zero/1.0/.
  */
 
 package java.util;
@@ -9,8 +9,6 @@ package java.util;
 // removed link to collections framework docs
 // END android-note
 
-import java.io.*;
-
 /**
  * Resizable-array implementation of the {@link Deque} interface.  Array
  * deques have no capacity restrictions; they grow as necessary to support
@@ -53,7 +51,7 @@ import java.io.*;
  * @param <E> the type of elements held in this collection
  */
 public class ArrayDeque<E> extends AbstractCollection<E>
-                           implements Deque<E>, Cloneable, Serializable
+                           implements Deque<E>, Cloneable, java.io.Serializable
 {
     /**
      * The array in which the elements of the deque are stored.
@@ -65,7 +63,7 @@ public class ArrayDeque<E> extends AbstractCollection<E>
      * other.  We also guarantee that all array cells not holding
      * deque elements are always null.
      */
-    private transient E[] elements;
+    private transient Object[] elements;
 
     /**
      * The index of the element at the head of the deque (which is the
@@ -109,7 +107,7 @@ public class ArrayDeque<E> extends AbstractCollection<E>
             if (initialCapacity < 0)   // Too many elements, must back off
                 initialCapacity >>>= 1;// Good luck allocating 2 ^ 30 elements
         }
-        elements = (E[]) new Object[initialCapacity];
+        elements = new Object[initialCapacity];
     }
 
     /**
@@ -127,7 +125,7 @@ public class ArrayDeque<E> extends AbstractCollection<E>
         Object[] a = new Object[newCapacity];
         System.arraycopy(elements, p, a, 0, r);
         System.arraycopy(elements, 0, a, r, p);
-        elements = (E[])a;
+        elements = a;
         head = 0;
         tail = n;
     }
@@ -155,7 +153,7 @@ public class ArrayDeque<E> extends AbstractCollection<E>
      * sufficient to hold 16 elements.
      */
     public ArrayDeque() {
-        elements = (E[]) new Object[16];
+        elements = new Object[16];
     }
 
     /**
@@ -263,7 +261,8 @@ public class ArrayDeque<E> extends AbstractCollection<E>
 
     public E pollFirst() {
         int h = head;
-        E result = elements[h]; // Element is null if deque empty
+        @SuppressWarnings("unchecked") E result = (E) elements[h];
+        // Element is null if deque empty
         if (result == null)
             return null;
         elements[h] = null;     // Must null out slot
@@ -273,7 +272,7 @@ public class ArrayDeque<E> extends AbstractCollection<E>
 
     public E pollLast() {
         int t = (tail - 1) & (elements.length - 1);
-        E result = elements[t];
+        @SuppressWarnings("unchecked") E result = (E) elements[t];
         if (result == null)
             return null;
         elements[t] = null;
@@ -285,28 +284,33 @@ public class ArrayDeque<E> extends AbstractCollection<E>
      * @throws NoSuchElementException {@inheritDoc}
      */
     public E getFirst() {
-        E x = elements[head];
-        if (x == null)
+        @SuppressWarnings("unchecked") E result = (E) elements[head];
+        if (result == null)
             throw new NoSuchElementException();
-        return x;
+        return result;
     }
 
     /**
      * @throws NoSuchElementException {@inheritDoc}
      */
     public E getLast() {
-        E x = elements[(tail - 1) & (elements.length - 1)];
-        if (x == null)
+        @SuppressWarnings("unchecked")
+        E result = (E) elements[(tail - 1) & (elements.length - 1)];
+        if (result == null)
             throw new NoSuchElementException();
-        return x;
+        return result;
     }
 
     public E peekFirst() {
-        return elements[head]; // elements[head] is null if deque empty
+        @SuppressWarnings("unchecked") E result = (E) elements[head];
+        // elements[head] is null if deque empty
+        return result;
     }
 
     public E peekLast() {
-        return elements[(tail - 1) & (elements.length - 1)];
+        @SuppressWarnings("unchecked")
+        E result = (E) elements[(tail - 1) & (elements.length - 1)];
+        return result;
     }
 
     /**
@@ -326,7 +330,7 @@ public class ArrayDeque<E> extends AbstractCollection<E>
             return false;
         int mask = elements.length - 1;
         int i = head;
-        E x;
+        Object x;
         while ( (x = elements[i]) != null) {
             if (o.equals(x)) {
                 delete(i);
@@ -354,7 +358,7 @@ public class ArrayDeque<E> extends AbstractCollection<E>
             return false;
         int mask = elements.length - 1;
         int i = (tail - 1) & mask;
-        E x;
+        Object x;
         while ( (x = elements[i]) != null) {
             if (o.equals(x)) {
                 delete(i);
@@ -499,7 +503,7 @@ public class ArrayDeque<E> extends AbstractCollection<E>
      */
     private boolean delete(int i) {
         checkInvariants();
-        final E[] elements = this.elements;
+        final Object[] elements = this.elements;
         final int mask = elements.length - 1;
         final int h = head;
         final int t = tail;
@@ -597,7 +601,7 @@ public class ArrayDeque<E> extends AbstractCollection<E>
         public E next() {
             if (cursor == fence)
                 throw new NoSuchElementException();
-            E result = elements[cursor];
+            @SuppressWarnings("unchecked") E result = (E) elements[cursor];
             // This check doesn't catch all possible comodifications,
             // but does catch the ones that corrupt traversal
             if (tail != fence || result == null)
@@ -636,7 +640,7 @@ public class ArrayDeque<E> extends AbstractCollection<E>
             if (cursor == fence)
                 throw new NoSuchElementException();
             cursor = (cursor - 1) & (elements.length - 1);
-            E result = elements[cursor];
+            @SuppressWarnings("unchecked") E result = (E) elements[cursor];
             if (head != fence || result == null)
                 throw new ConcurrentModificationException();
             lastRet = cursor;
@@ -667,7 +671,7 @@ public class ArrayDeque<E> extends AbstractCollection<E>
             return false;
         int mask = elements.length - 1;
         int i = head;
-        E x;
+        Object x;
         while ( (x = elements[i]) != null) {
             if (o.equals(x))
                 return true;
@@ -750,8 +754,7 @@ public class ArrayDeque<E> extends AbstractCollection<E>
      * The following code can be used to dump the deque into a newly
      * allocated array of <tt>String</tt>:
      *
-     * <pre>
-     *     String[] y = x.toArray(new String[0]);</pre>
+     *  <pre> {@code String[] y = x.toArray(new String[0]);}</pre>
      *
      * Note that <tt>toArray(new Object[0])</tt> is identical in function to
      * <tt>toArray()</tt>.
@@ -765,6 +768,7 @@ public class ArrayDeque<E> extends AbstractCollection<E>
      *         this deque
      * @throws NullPointerException if the specified array is null
      */
+    @SuppressWarnings("unchecked")
     public <T> T[] toArray(T[] a) {
         int size = size();
         if (a.length < size)
@@ -785,6 +789,7 @@ public class ArrayDeque<E> extends AbstractCollection<E>
      */
     public ArrayDeque<E> clone() {
         try {
+            @SuppressWarnings("unchecked")
             ArrayDeque<E> result = (ArrayDeque<E>) super.clone();
             result.elements = Arrays.copyOf(elements, elements.length);
             return result;
@@ -806,7 +811,8 @@ public class ArrayDeque<E> extends AbstractCollection<E>
      * followed by all of its elements (each an object reference) in
      * first-to-last order.
      */
-    private void writeObject(ObjectOutputStream s) throws IOException {
+    private void writeObject(java.io.ObjectOutputStream s)
+            throws java.io.IOException {
         s.defaultWriteObject();
 
         // Write out size
@@ -821,8 +827,8 @@ public class ArrayDeque<E> extends AbstractCollection<E>
     /**
      * Deserialize this deque.
      */
-    private void readObject(ObjectInputStream s)
-            throws IOException, ClassNotFoundException {
+    private void readObject(java.io.ObjectInputStream s)
+            throws java.io.IOException, ClassNotFoundException {
         s.defaultReadObject();
 
         // Read in size and allocate array
@@ -833,6 +839,6 @@ public class ArrayDeque<E> extends AbstractCollection<E>
 
         // Read in all elements in the proper order.
         for (int i = 0; i < size; i++)
-            elements[i] = (E)s.readObject();
+            elements[i] = s.readObject();
     }
 }
diff --git a/luni/src/main/java/java/util/Deque.java b/luni/src/main/java/java/util/Deque.java
index cb6bd90..f74a6b4 100644
--- a/luni/src/main/java/java/util/Deque.java
+++ b/luni/src/main/java/java/util/Deque.java
@@ -1,14 +1,13 @@
 /*
  * Written by Doug Lea and Josh Bloch with assistance from members of
  * JCP JSR-166 Expert Group and released to the public domain, as explained
- * at http://creativecommons.org/licenses/publicdomain
+ * at http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util;
 
 // BEGIN android-note
 // removed link to collections framework docs
-// changed {@link #offer(Object)} to {@link #offer} to satisfy DroidDoc
 // END android-note
 
 /**
@@ -356,7 +355,7 @@ public interface Deque<E> extends Queue<E> {
      * <tt>true</tt> upon success and throwing an
      * <tt>IllegalStateException</tt> if no space is currently available.
      * When using a capacity-restricted deque, it is generally preferable to
-     * use {@link #offer offer}.
+     * use {@link #offer(Object) offer}.
      *
      * <p>This method is equivalent to {@link #addLast}.
      *
diff --git a/luni/src/main/java/java/util/NavigableMap.java b/luni/src/main/java/java/util/NavigableMap.java
index 29961c8..beeb651 100644
--- a/luni/src/main/java/java/util/NavigableMap.java
+++ b/luni/src/main/java/java/util/NavigableMap.java
@@ -1,14 +1,13 @@
 /*
  * Written by Doug Lea and Josh Bloch with assistance from members of JCP
  * JSR-166 Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util;
 
 // BEGIN android-note
 // removed link to collections framework docs
-// changed {@link #subMap(Object)} to {@link #subMap} to satisfy DroidDoc
 // END android-note
 
 /**
@@ -48,9 +47,9 @@ package java.util;
  * method {@code put}.
  *
  * <p>Methods
- * {@link #subMap subMap(K, K)},
- * {@link #headMap headMap(K)}, and
- * {@link #tailMap tailMap(K)}
+ * {@link #subMap(Object, Object) subMap(K, K)},
+ * {@link #headMap(Object) headMap(K)}, and
+ * {@link #tailMap(Object) tailMap(K)}
  * are specified to return {@code SortedMap} to allow existing
  * implementations of {@code SortedMap} to be compatibly retrofitted to
  * implement {@code NavigableMap}, but extensions and implementations
diff --git a/luni/src/main/java/java/util/NavigableSet.java b/luni/src/main/java/java/util/NavigableSet.java
index cff0800..f410313 100644
--- a/luni/src/main/java/java/util/NavigableSet.java
+++ b/luni/src/main/java/java/util/NavigableSet.java
@@ -1,14 +1,13 @@
 /*
  * Written by Doug Lea and Josh Bloch with assistance from members of JCP
  * JSR-166 Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util;
 
 // BEGIN android-note
 // removed link to collections framework docs
-// changed {@link #subSet(Object)} to {@link #subSet} to satisfy DroidDoc
 // END android-note
 
 /**
@@ -41,9 +40,9 @@ package java.util;
  * Comparable} elements intrinsically do not permit {@code null}.)
  *
  * <p>Methods
- * {@link #subSet subSet(E, E)},
- * {@link #headSet headSet(E)}, and
- * {@link #tailSet tailSet(E)}
+ * {@link #subSet(Object, Object) subSet(E, E)},
+ * {@link #headSet(Object) headSet(E)}, and
+ * {@link #tailSet(Object) tailSet(E)}
  * are specified to return {@code SortedSet} to allow existing
  * implementations of {@code SortedSet} to be compatibly retrofitted to
  * implement {@code NavigableSet}, but extensions and implementations
diff --git a/luni/src/main/java/java/util/Queue.java b/luni/src/main/java/java/util/Queue.java
index 5aef944..8b465e6 100644
--- a/luni/src/main/java/java/util/Queue.java
+++ b/luni/src/main/java/java/util/Queue.java
@@ -1,7 +1,7 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util;
diff --git a/luni/src/main/java/java/util/concurrent/AbstractExecutorService.java b/luni/src/main/java/java/util/concurrent/AbstractExecutorService.java
index 36fcecc..a7f7745 100644
--- a/luni/src/main/java/java/util/concurrent/AbstractExecutorService.java
+++ b/luni/src/main/java/java/util/concurrent/AbstractExecutorService.java
@@ -1,7 +1,7 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent;
diff --git a/luni/src/main/java/java/util/concurrent/ArrayBlockingQueue.java b/luni/src/main/java/java/util/concurrent/ArrayBlockingQueue.java
index a622832..e30ab67 100644
--- a/luni/src/main/java/java/util/concurrent/ArrayBlockingQueue.java
+++ b/luni/src/main/java/java/util/concurrent/ArrayBlockingQueue.java
@@ -1,12 +1,17 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent;
-import java.util.concurrent.locks.*;
-import java.util.*;
+import java.util.concurrent.locks.Condition;
+import java.util.concurrent.locks.ReentrantLock;
+import java.util.AbstractQueue;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+import java.lang.ref.WeakReference;
 
 // BEGIN android-note
 // removed link to collections framework docs
@@ -73,11 +78,20 @@ public class ArrayBlockingQueue<E> extends AbstractQueue<E>
 
     /** Main lock guarding all access */
     final ReentrantLock lock;
+
     /** Condition for waiting takes */
     private final Condition notEmpty;
+
     /** Condition for waiting puts */
     private final Condition notFull;
 
+    /**
+     * Shared state for currently active iterators, or null if there
+     * are known not to be any.  Allows queue operations to update
+     * iterator state.
+     */
+    transient Itrs itrs = null;
+
     // Internal helper methods
 
     /**
@@ -94,16 +108,12 @@ public class ArrayBlockingQueue<E> extends AbstractQueue<E>
         return ((i == 0) ? items.length : i) - 1;
     }
 
-    @SuppressWarnings("unchecked")
-    static <E> E cast(Object item) {
-        return (E) item;
-    }
-
     /**
      * Returns item at index i.
      */
     final E itemAt(int i) {
-        return this.<E>cast(items[i]);
+        @SuppressWarnings("unchecked") E x = (E) items[i];
+        return x;
     }
 
     /**
@@ -120,10 +130,12 @@ public class ArrayBlockingQueue<E> extends AbstractQueue<E>
      * Inserts element at current put position, advances, and signals.
      * Call only when holding lock.
      */
-    private void insert(E x) {
+    private void enqueue(E x) {
+        // assert lock.getHoldCount() == 1;
+        // assert items[putIndex] == null;
         items[putIndex] = x;
         putIndex = inc(putIndex);
-        ++count;
+        count++;
         notEmpty.signal();
     }
 
@@ -131,42 +143,57 @@ public class ArrayBlockingQueue<E> extends AbstractQueue<E>
      * Extracts element at current take position, advances, and signals.
      * Call only when holding lock.
      */
-    private E extract() {
+    private E dequeue() {
+        // assert lock.getHoldCount() == 1;
+        // assert items[takeIndex] != null;
         final Object[] items = this.items;
-        E x = this.<E>cast(items[takeIndex]);
+        @SuppressWarnings("unchecked") E x = (E) items[takeIndex];
         items[takeIndex] = null;
         takeIndex = inc(takeIndex);
-        --count;
+        count--;
+        if (itrs != null)
+            itrs.elementDequeued();
         notFull.signal();
         return x;
     }
 
     /**
-     * Deletes item at position i.
-     * Utility for remove and iterator.remove.
+     * Deletes item at array index removeIndex.
+     * Utility for remove(Object) and iterator.remove.
      * Call only when holding lock.
      */
-    void removeAt(int i) {
+    void removeAt(final int removeIndex) {
+        // assert lock.getHoldCount() == 1;
+        // assert items[removeIndex] != null;
+        // assert removeIndex >= 0 && removeIndex < items.length;
         final Object[] items = this.items;
-        // if removing front item, just advance
-        if (i == takeIndex) {
+        if (removeIndex == takeIndex) {
+            // removing front item; just advance
             items[takeIndex] = null;
             takeIndex = inc(takeIndex);
+            count--;
+            if (itrs != null)
+                itrs.elementDequeued();
         } else {
+            // an "interior" remove
+
             // slide over all others up through putIndex.
-            for (;;) {
-                int nexti = inc(i);
-                if (nexti != putIndex) {
-                    items[i] = items[nexti];
-                    i = nexti;
+            final int putIndex = this.putIndex;
+            for (int i = removeIndex;;) {
+                int next = inc(i);
+                if (next != putIndex) {
+                    items[i] = items[next];
+                    i = next;
                 } else {
                     items[i] = null;
-                    putIndex = i;
+                    this.putIndex = i;
                     break;
                 }
             }
+            count--;
+            if (itrs != null)
+                itrs.removedAt(removeIndex);
         }
-        --count;
         notFull.signal();
     }
 
@@ -271,7 +298,7 @@ public class ArrayBlockingQueue<E> extends AbstractQueue<E>
             if (count == items.length)
                 return false;
             else {
-                insert(e);
+                enqueue(e);
                 return true;
             }
         } finally {
@@ -293,7 +320,7 @@ public class ArrayBlockingQueue<E> extends AbstractQueue<E>
         try {
             while (count == items.length)
                 notFull.await();
-            insert(e);
+            enqueue(e);
         } finally {
             lock.unlock();
         }
@@ -320,7 +347,7 @@ public class ArrayBlockingQueue<E> extends AbstractQueue<E>
                     return false;
                 nanos = notFull.awaitNanos(nanos);
             }
-            insert(e);
+            enqueue(e);
             return true;
         } finally {
             lock.unlock();
@@ -331,7 +358,7 @@ public class ArrayBlockingQueue<E> extends AbstractQueue<E>
         final ReentrantLock lock = this.lock;
         lock.lock();
         try {
-            return (count == 0) ? null : extract();
+            return (count == 0) ? null : dequeue();
         } finally {
             lock.unlock();
         }
@@ -343,7 +370,7 @@ public class ArrayBlockingQueue<E> extends AbstractQueue<E>
         try {
             while (count == 0)
                 notEmpty.await();
-            return extract();
+            return dequeue();
         } finally {
             lock.unlock();
         }
@@ -359,7 +386,7 @@ public class ArrayBlockingQueue<E> extends AbstractQueue<E>
                     return null;
                 nanos = notEmpty.awaitNanos(nanos);
             }
-            return extract();
+            return dequeue();
         } finally {
             lock.unlock();
         }
@@ -438,11 +465,15 @@ public class ArrayBlockingQueue<E> extends AbstractQueue<E>
         final ReentrantLock lock = this.lock;
         lock.lock();
         try {
-            for (int i = takeIndex, k = count; k > 0; i = inc(i), k--) {
-                if (o.equals(items[i])) {
-                    removeAt(i);
-                    return true;
-                }
+            if (count > 0) {
+                final int putIndex = this.putIndex;
+                int i = takeIndex;
+                do {
+                    if (o.equals(items[i])) {
+                        removeAt(i);
+                        return true;
+                    }
+                } while ((i = inc(i)) != putIndex);
             }
             return false;
         } finally {
@@ -464,9 +495,14 @@ public class ArrayBlockingQueue<E> extends AbstractQueue<E>
         final ReentrantLock lock = this.lock;
         lock.lock();
         try {
-            for (int i = takeIndex, k = count; k > 0; i = inc(i), k--)
-                if (o.equals(items[i]))
-                    return true;
+            if (count > 0) {
+                final int putIndex = this.putIndex;
+                int i = takeIndex;
+                do {
+                    if (o.equals(items[i]))
+                        return true;
+                } while ((i = inc(i)) != putIndex);
+            }
             return false;
         } finally {
             lock.unlock();
@@ -522,8 +558,7 @@ public class ArrayBlockingQueue<E> extends AbstractQueue<E>
      * The following code can be used to dump the queue into a newly
      * allocated array of {@code String}:
      *
-     * <pre>
-     *     String[] y = x.toArray(new String[0]);</pre>
+     *  <pre> {@code String[] y = x.toArray(new String[0]);}</pre>
      *
      * Note that {@code toArray(new Object[0])} is identical in function to
      * {@code toArray()}.
@@ -589,12 +624,20 @@ public class ArrayBlockingQueue<E> extends AbstractQueue<E>
         final ReentrantLock lock = this.lock;
         lock.lock();
         try {
-            for (int i = takeIndex, k = count; k > 0; i = inc(i), k--)
-                items[i] = null;
-            count = 0;
-            putIndex = 0;
-            takeIndex = 0;
-            notFull.signalAll();
+            int k = count;
+            if (k > 0) {
+                final int putIndex = this.putIndex;
+                int i = takeIndex;
+                do {
+                    items[i] = null;
+                } while ((i = inc(i)) != putIndex);
+                takeIndex = putIndex;
+                count = 0;
+                if (itrs != null)
+                    itrs.queueIsEmpty();
+                for (; k > 0 && lock.hasWaiters(notFull); k--)
+                    notFull.signal();
+            }
         } finally {
             lock.unlock();
         }
@@ -607,32 +650,7 @@ public class ArrayBlockingQueue<E> extends AbstractQueue<E>
      * @throws IllegalArgumentException      {@inheritDoc}
      */
     public int drainTo(Collection<? super E> c) {
-        checkNotNull(c);
-        if (c == this)
-            throw new IllegalArgumentException();
-        final Object[] items = this.items;
-        final ReentrantLock lock = this.lock;
-        lock.lock();
-        try {
-            int i = takeIndex;
-            int n = 0;
-            int max = count;
-            while (n < max) {
-                c.add(this.<E>cast(items[i]));
-                items[i] = null;
-                i = inc(i);
-                ++n;
-            }
-            if (n > 0) {
-                count = 0;
-                putIndex = 0;
-                takeIndex = 0;
-                notFull.signalAll();
-            }
-            return n;
-        } finally {
-            lock.unlock();
-        }
+        return drainTo(c, Integer.MAX_VALUE);
     }
 
     /**
@@ -651,21 +669,33 @@ public class ArrayBlockingQueue<E> extends AbstractQueue<E>
         final ReentrantLock lock = this.lock;
         lock.lock();
         try {
-            int i = takeIndex;
-            int n = 0;
-            int max = (maxElements < count) ? maxElements : count;
-            while (n < max) {
-                c.add(this.<E>cast(items[i]));
-                items[i] = null;
-                i = inc(i);
-                ++n;
-            }
-            if (n > 0) {
-                count -= n;
-                takeIndex = i;
-                notFull.signalAll();
+            int n = Math.min(maxElements, count);
+            int take = takeIndex;
+            int i = 0;
+            try {
+                while (i < n) {
+                    @SuppressWarnings("unchecked") E x = (E) items[take];
+                    c.add(x);
+                    items[take] = null;
+                    take = inc(take);
+                    i++;
+                }
+                return n;
+            } finally {
+                // Restore invariants even if c.add() threw
+                if (i > 0) {
+                    count -= i;
+                    takeIndex = take;
+                    if (itrs != null) {
+                        if (count == 0)
+                            itrs.queueIsEmpty();
+                        else if (i > take)
+                            itrs.takeIndexWrapped();
+                    }
+                    for (; i > 0 && lock.hasWaiters(notFull); i--)
+                        notFull.signal();
+                }
             }
-            return n;
         } finally {
             lock.unlock();
         }
@@ -675,12 +705,12 @@ public class ArrayBlockingQueue<E> extends AbstractQueue<E>
      * Returns an iterator over the elements in this queue in proper sequence.
      * The elements will be returned in order from first (head) to last (tail).
      *
-     * <p>The returned {@code Iterator} is a "weakly consistent" iterator that
+     * <p>The returned iterator is a "weakly consistent" iterator that
      * will never throw {@link java.util.ConcurrentModificationException
-     * ConcurrentModificationException},
-     * and guarantees to traverse elements as they existed upon
-     * construction of the iterator, and may (but is not guaranteed to)
-     * reflect any modifications subsequent to construction.
+     * ConcurrentModificationException}, and guarantees to traverse
+     * elements as they existed upon construction of the iterator, and
+     * may (but is not guaranteed to) reflect any modifications
+     * subsequent to construction.
      *
      * @return an iterator over the elements in this queue in proper sequence
      */
@@ -689,88 +719,627 @@ public class ArrayBlockingQueue<E> extends AbstractQueue<E>
     }
 
     /**
-     * Iterator for ArrayBlockingQueue. To maintain weak consistency
-     * with respect to puts and takes, we (1) read ahead one slot, so
-     * as to not report hasNext true but then not have an element to
-     * return -- however we later recheck this slot to use the most
-     * current value; (2) ensure that each array slot is traversed at
-     * most once (by tracking "remaining" elements); (3) skip over
-     * null slots, which can occur if takes race ahead of iterators.
-     * However, for circular array-based queues, we cannot rely on any
-     * well established definition of what it means to be weakly
-     * consistent with respect to interior removes since these may
-     * require slot overwrites in the process of sliding elements to
-     * cover gaps. So we settle for resiliency, operating on
-     * established apparent nexts, which may miss some elements that
-     * have moved between calls to next.
+     * Shared data between iterators and their queue, allowing queue
+     * modifications to update iterators when elements are removed.
+     *
+     * This adds a lot of complexity for the sake of correctly
+     * handling some uncommon operations, but the combination of
+     * circular-arrays and supporting interior removes (i.e., those
+     * not at head) would cause iterators to sometimes lose their
+     * places and/or (re)report elements they shouldn't.  To avoid
+     * this, when a queue has one or more iterators, it keeps iterator
+     * state consistent by:
+     *
+     * (1) keeping track of the number of "cycles", that is, the
+     *     number of times takeIndex has wrapped around to 0.
+     * (2) notifying all iterators via the callback removedAt whenever
+     *     an interior element is removed (and thus other elements may
+     *     be shifted).
+     *
+     * These suffice to eliminate iterator inconsistencies, but
+     * unfortunately add the secondary responsibility of maintaining
+     * the list of iterators.  We track all active iterators in a
+     * simple linked list (accessed only when the queue's lock is
+     * held) of weak references to Itr.  The list is cleaned up using
+     * 3 different mechanisms:
+     *
+     * (1) Whenever a new iterator is created, do some O(1) checking for
+     *     stale list elements.
+     *
+     * (2) Whenever takeIndex wraps around to 0, check for iterators
+     *     that have been unused for more than one wrap-around cycle.
+     *
+     * (3) Whenever the queue becomes empty, all iterators are notified
+     *     and this entire data structure is discarded.
+     *
+     * So in addition to the removedAt callback that is necessary for
+     * correctness, iterators have the shutdown and takeIndexWrapped
+     * callbacks that help remove stale iterators from the list.
+     *
+     * Whenever a list element is examined, it is expunged if either
+     * the GC has determined that the iterator is discarded, or if the
+     * iterator reports that it is "detached" (does not need any
+     * further state updates).  Overhead is maximal when takeIndex
+     * never advances, iterators are discarded before they are
+     * exhausted, and all removals are interior removes, in which case
+     * all stale iterators are discovered by the GC.  But even in this
+     * case we don't increase the amortized complexity.
+     *
+     * Care must be taken to keep list sweeping methods from
+     * reentrantly invoking another such method, causing subtle
+     * corruption bugs.
+     */
+    class Itrs {
+
+        /**
+         * Node in a linked list of weak iterator references.
+         */
+        private class Node extends WeakReference<Itr> {
+            Node next;
+
+            Node(Itr iterator, Node next) {
+                super(iterator);
+                this.next = next;
+            }
+        }
+
+        /** Incremented whenever takeIndex wraps around to 0 */
+        int cycles = 0;
+
+        /** Linked list of weak iterator references */
+        private Node head;
+
+        /** Used to expunge stale iterators */
+        private Node sweeper = null;
+
+        private static final int SHORT_SWEEP_PROBES = 4;
+        private static final int LONG_SWEEP_PROBES = 16;
+
+        Itrs(Itr initial) {
+            register(initial);
+        }
+
+        /**
+         * Sweeps itrs, looking for and expunging stale iterators.
+         * If at least one was found, tries harder to find more.
+         * Called only from iterating thread.
+         *
+         * @param tryHarder whether to start in try-harder mode, because
+         * there is known to be at least one iterator to collect
+         */
+        void doSomeSweeping(boolean tryHarder) {
+            // assert lock.getHoldCount() == 1;
+            // assert head != null;
+            int probes = tryHarder ? LONG_SWEEP_PROBES : SHORT_SWEEP_PROBES;
+            Node o, p;
+            final Node sweeper = this.sweeper;
+            boolean passedGo;   // to limit search to one full sweep
+
+            if (sweeper == null) {
+                o = null;
+                p = head;
+                passedGo = true;
+            } else {
+                o = sweeper;
+                p = o.next;
+                passedGo = false;
+            }
+
+            for (; probes > 0; probes--) {
+                if (p == null) {
+                    if (passedGo)
+                        break;
+                    o = null;
+                    p = head;
+                    passedGo = true;
+                }
+                final Itr it = p.get();
+                final Node next = p.next;
+                if (it == null || it.isDetached()) {
+                    // found a discarded/exhausted iterator
+                    probes = LONG_SWEEP_PROBES; // "try harder"
+                    // unlink p
+                    p.clear();
+                    p.next = null;
+                    if (o == null) {
+                        head = next;
+                        if (next == null) {
+                            // We've run out of iterators to track; retire
+                            itrs = null;
+                            return;
+                        }
+                    }
+                    else
+                        o.next = next;
+                } else {
+                    o = p;
+                }
+                p = next;
+            }
+
+            this.sweeper = (p == null) ? null : o;
+        }
+
+        /**
+         * Adds a new iterator to the linked list of tracked iterators.
+         */
+        void register(Itr itr) {
+            // assert lock.getHoldCount() == 1;
+            head = new Node(itr, head);
+        }
+
+        /**
+         * Called whenever takeIndex wraps around to 0.
+         *
+         * Notifies all iterators, and expunges any that are now stale.
+         */
+        void takeIndexWrapped() {
+            // assert lock.getHoldCount() == 1;
+            cycles++;
+            for (Node o = null, p = head; p != null;) {
+                final Itr it = p.get();
+                final Node next = p.next;
+                if (it == null || it.takeIndexWrapped()) {
+                    // unlink p
+                    // assert it == null || it.isDetached();
+                    p.clear();
+                    p.next = null;
+                    if (o == null)
+                        head = next;
+                    else
+                        o.next = next;
+                } else {
+                    o = p;
+                }
+                p = next;
+            }
+            if (head == null)   // no more iterators to track
+                itrs = null;
+        }
+
+        /**
+         * Called whenever an interior remove (not at takeIndex) occured.
+         *
+         * Notifies all iterators, and expunges any that are now stale.
+         */
+        void removedAt(int removedIndex) {
+            for (Node o = null, p = head; p != null;) {
+                final Itr it = p.get();
+                final Node next = p.next;
+                if (it == null || it.removedAt(removedIndex)) {
+                    // unlink p
+                    // assert it == null || it.isDetached();
+                    p.clear();
+                    p.next = null;
+                    if (o == null)
+                        head = next;
+                    else
+                        o.next = next;
+                } else {
+                    o = p;
+                }
+                p = next;
+            }
+            if (head == null)   // no more iterators to track
+                itrs = null;
+        }
+
+        /**
+         * Called whenever the queue becomes empty.
+         *
+         * Notifies all active iterators that the queue is empty,
+         * clears all weak refs, and unlinks the itrs datastructure.
+         */
+        void queueIsEmpty() {
+            // assert lock.getHoldCount() == 1;
+            for (Node p = head; p != null; p = p.next) {
+                Itr it = p.get();
+                if (it != null) {
+                    p.clear();
+                    it.shutdown();
+                }
+            }
+            head = null;
+            itrs = null;
+        }
+
+        /**
+         * Called whenever an element has been dequeued (at takeIndex).
+         */
+        void elementDequeued() {
+            // assert lock.getHoldCount() == 1;
+            if (count == 0)
+                queueIsEmpty();
+            else if (takeIndex == 0)
+                takeIndexWrapped();
+        }
+    }
+
+    /**
+     * Iterator for ArrayBlockingQueue.
+     *
+     * To maintain weak consistency with respect to puts and takes, we
+     * read ahead one slot, so as to not report hasNext true but then
+     * not have an element to return.
+     *
+     * We switch into "detached" mode (allowing prompt unlinking from
+     * itrs without help from the GC) when all indices are negative, or
+     * when hasNext returns false for the first time.  This allows the
+     * iterator to track concurrent updates completely accurately,
+     * except for the corner case of the user calling Iterator.remove()
+     * after hasNext() returned false.  Even in this case, we ensure
+     * that we don't remove the wrong element by keeping track of the
+     * expected element to remove, in lastItem.  Yes, we may fail to
+     * remove lastItem from the queue if it moved due to an interleaved
+     * interior remove while in detached mode.
      */
     private class Itr implements Iterator<E> {
-        private int remaining; // Number of elements yet to be returned
-        private int nextIndex; // Index of element to be returned by next
-        private E nextItem;    // Element to be returned by next call to next
-        private E lastItem;    // Element returned by last call to next
-        private int lastRet;   // Index of last element returned, or -1 if none
+        /** Index to look for new nextItem; NONE at end */
+        private int cursor;
+
+        /** Element to be returned by next call to next(); null if none */
+        private E nextItem;
+
+        /** Index of nextItem; NONE if none, REMOVED if removed elsewhere */
+        private int nextIndex;
+
+        /** Last element returned; null if none or not detached. */
+        private E lastItem;
+
+        /** Index of lastItem, NONE if none, REMOVED if removed elsewhere */
+        private int lastRet;
+
+        /** Previous value of takeIndex, or DETACHED when detached */
+        private int prevTakeIndex;
+
+        /** Previous value of iters.cycles */
+        private int prevCycles;
+
+        /** Special index value indicating "not available" or "undefined" */
+        private static final int NONE = -1;
+
+        /**
+         * Special index value indicating "removed elsewhere", that is,
+         * removed by some operation other than a call to this.remove().
+         */
+        private static final int REMOVED = -2;
+
+        /** Special value for prevTakeIndex indicating "detached mode" */
+        private static final int DETACHED = -3;
 
         Itr() {
+            // assert lock.getHoldCount() == 0;
+            lastRet = NONE;
             final ReentrantLock lock = ArrayBlockingQueue.this.lock;
             lock.lock();
             try {
-                lastRet = -1;
-                if ((remaining = count) > 0)
+                if (count == 0) {
+                    // assert itrs == null;
+                    cursor = NONE;
+                    nextIndex = NONE;
+                    prevTakeIndex = DETACHED;
+                } else {
+                    final int takeIndex = ArrayBlockingQueue.this.takeIndex;
+                    prevTakeIndex = takeIndex;
                     nextItem = itemAt(nextIndex = takeIndex);
+                    cursor = incCursor(takeIndex);
+                    if (itrs == null) {
+                        itrs = new Itrs(this);
+                    } else {
+                        itrs.register(this); // in this order
+                        itrs.doSomeSweeping(false);
+                    }
+                    prevCycles = itrs.cycles;
+                    // assert takeIndex >= 0;
+                    // assert prevTakeIndex == takeIndex;
+                    // assert nextIndex >= 0;
+                    // assert nextItem != null;
+                }
             } finally {
                 lock.unlock();
             }
         }
 
+        boolean isDetached() {
+            // assert lock.getHoldCount() == 1;
+            return prevTakeIndex < 0;
+        }
+
+        private int incCursor(int index) {
+            // assert lock.getHoldCount() == 1;
+            index = inc(index);
+            if (index == putIndex)
+                index = NONE;
+            return index;
+        }
+
+        /**
+         * Returns true if index is invalidated by the given number of
+         * dequeues, starting from prevTakeIndex.
+         */
+        private boolean invalidated(int index, int prevTakeIndex,
+                                    long dequeues, int length) {
+            if (index < 0)
+                return false;
+            int distance = index - prevTakeIndex;
+            if (distance < 0)
+                distance += length;
+            return dequeues > distance;
+        }
+
+        /**
+         * Adjusts indices to incorporate all dequeues since the last
+         * operation on this iterator.  Call only from iterating thread.
+         */
+        private void incorporateDequeues() {
+            // assert lock.getHoldCount() == 1;
+            // assert itrs != null;
+            // assert !isDetached();
+            // assert count > 0;
+
+            final int cycles = itrs.cycles;
+            final int takeIndex = ArrayBlockingQueue.this.takeIndex;
+            final int prevCycles = this.prevCycles;
+            final int prevTakeIndex = this.prevTakeIndex;
+
+            if (cycles != prevCycles || takeIndex != prevTakeIndex) {
+                final int len = items.length;
+                // how far takeIndex has advanced since the previous
+                // operation of this iterator
+                long dequeues = (cycles - prevCycles) * len
+                    + (takeIndex - prevTakeIndex);
+
+                // Check indices for invalidation
+                if (invalidated(lastRet, prevTakeIndex, dequeues, len))
+                    lastRet = REMOVED;
+                if (invalidated(nextIndex, prevTakeIndex, dequeues, len))
+                    nextIndex = REMOVED;
+                if (invalidated(cursor, prevTakeIndex, dequeues, len))
+                    cursor = takeIndex;
+
+                if (cursor < 0 && nextIndex < 0 && lastRet < 0)
+                    detach();
+                else {
+                    this.prevCycles = cycles;
+                    this.prevTakeIndex = takeIndex;
+                }
+            }
+        }
+
+        /**
+         * Called when itrs should stop tracking this iterator, either
+         * because there are no more indices to update (cursor < 0 &&
+         * nextIndex < 0 && lastRet < 0) or as a special exception, when
+         * lastRet >= 0, because hasNext() is about to return false for the
+         * first time.  Call only from iterating thread.
+         */
+        private void detach() {
+            // Switch to detached mode
+            // assert lock.getHoldCount() == 1;
+            // assert cursor == NONE;
+            // assert nextIndex < 0;
+            // assert lastRet < 0 || nextItem == null;
+            // assert lastRet < 0 ^ lastItem != null;
+            if (prevTakeIndex >= 0) {
+                // assert itrs != null;
+                prevTakeIndex = DETACHED;
+                // try to unlink from itrs (but not too hard)
+                itrs.doSomeSweeping(true);
+            }
+        }
+
+        /**
+         * For performance reasons, we would like not to acquire a lock in
+         * hasNext in the common case.  To allow for this, we only access
+         * fields (i.e. nextItem) that are not modified by update operations
+         * triggered by queue modifications.
+         */
         public boolean hasNext() {
-            return remaining > 0;
+            // assert lock.getHoldCount() == 0;
+            if (nextItem != null)
+                return true;
+            noNext();
+            return false;
+        }
+
+        private void noNext() {
+            final ReentrantLock lock = ArrayBlockingQueue.this.lock;
+            lock.lock();
+            try {
+                // assert cursor == NONE;
+                // assert nextIndex == NONE;
+                if (!isDetached()) {
+                    // assert lastRet >= 0;
+                    incorporateDequeues(); // might update lastRet
+                    if (lastRet >= 0) {
+                        lastItem = itemAt(lastRet);
+                        // assert lastItem != null;
+                        detach();
+                    }
+                }
+                // assert isDetached();
+                // assert lastRet < 0 ^ lastItem != null;
+            } finally {
+                lock.unlock();
+            }
         }
 
         public E next() {
+            // assert lock.getHoldCount() == 0;
+            final E x = nextItem;
+            if (x == null)
+                throw new NoSuchElementException();
             final ReentrantLock lock = ArrayBlockingQueue.this.lock;
             lock.lock();
             try {
-                if (remaining <= 0)
-                    throw new NoSuchElementException();
+                if (!isDetached())
+                    incorporateDequeues();
+                // assert nextIndex != NONE;
+                // assert lastItem == null;
                 lastRet = nextIndex;
-                E x = itemAt(nextIndex);  // check for fresher value
-                if (x == null) {
-                    x = nextItem;         // we are forced to report old value
-                    lastItem = null;      // but ensure remove fails
+                final int cursor = this.cursor;
+                if (cursor >= 0) {
+                    nextItem = itemAt(nextIndex = cursor);
+                    // assert nextItem != null;
+                    this.cursor = incCursor(cursor);
+                } else {
+                    nextIndex = NONE;
+                    nextItem = null;
                 }
-                else
-                    lastItem = x;
-                while (--remaining > 0 && // skip over nulls
-                       (nextItem = itemAt(nextIndex = inc(nextIndex))) == null)
-                    ;
-                return x;
             } finally {
                 lock.unlock();
             }
+            return x;
         }
 
         public void remove() {
+            // assert lock.getHoldCount() == 0;
             final ReentrantLock lock = ArrayBlockingQueue.this.lock;
             lock.lock();
             try {
-                int i = lastRet;
-                if (i == -1)
+                if (!isDetached())
+                    incorporateDequeues(); // might update lastRet or detach
+                final int lastRet = this.lastRet;
+                this.lastRet = NONE;
+                if (lastRet >= 0) {
+                    if (!isDetached())
+                        removeAt(lastRet);
+                    else {
+                        final E lastItem = this.lastItem;
+                        // assert lastItem != null;
+                        this.lastItem = null;
+                        if (itemAt(lastRet) == lastItem)
+                            removeAt(lastRet);
+                    }
+                } else if (lastRet == NONE)
                     throw new IllegalStateException();
-                lastRet = -1;
-                E x = lastItem;
-                lastItem = null;
-                // only remove if item still at index
-                if (x != null && x == items[i]) {
-                    boolean removingHead = (i == takeIndex);
-                    removeAt(i);
-                    if (!removingHead)
-                        nextIndex = dec(nextIndex);
-                }
+                // else lastRet == REMOVED and the last returned element was
+                // previously asynchronously removed via an operation other
+                // than this.remove(), so nothing to do.
+
+                if (cursor < 0 && nextIndex < 0)
+                    detach();
             } finally {
                 lock.unlock();
+                // assert lastRet == NONE;
+                // assert lastItem == null;
             }
         }
-    }
 
+        /**
+         * Called to notify the iterator that the queue is empty, or that it
+         * has fallen hopelessly behind, so that it should abandon any
+         * further iteration, except possibly to return one more element
+         * from next(), as promised by returning true from hasNext().
+         */
+        void shutdown() {
+            // assert lock.getHoldCount() == 1;
+            cursor = NONE;
+            if (nextIndex >= 0)
+                nextIndex = REMOVED;
+            if (lastRet >= 0) {
+                lastRet = REMOVED;
+                lastItem = null;
+            }
+            prevTakeIndex = DETACHED;
+            // Don't set nextItem to null because we must continue to be
+            // able to return it on next().
+            //
+            // Caller will unlink from itrs when convenient.
+        }
+
+        private int distance(int index, int prevTakeIndex, int length) {
+            int distance = index - prevTakeIndex;
+            if (distance < 0)
+                distance += length;
+            return distance;
+        }
+
+        /**
+         * Called whenever an interior remove (not at takeIndex) occured.
+         *
+         * @return true if this iterator should be unlinked from itrs
+         */
+        boolean removedAt(int removedIndex) {
+            // assert lock.getHoldCount() == 1;
+            if (isDetached())
+                return true;
+
+            final int cycles = itrs.cycles;
+            final int takeIndex = ArrayBlockingQueue.this.takeIndex;
+            final int prevCycles = this.prevCycles;
+            final int prevTakeIndex = this.prevTakeIndex;
+            final int len = items.length;
+            int cycleDiff = cycles - prevCycles;
+            if (removedIndex < takeIndex)
+                cycleDiff++;
+            final int removedDistance =
+                (cycleDiff * len) + (removedIndex - prevTakeIndex);
+            // assert removedDistance >= 0;
+            int cursor = this.cursor;
+            if (cursor >= 0) {
+                int x = distance(cursor, prevTakeIndex, len);
+                if (x == removedDistance) {
+                    if (cursor == putIndex)
+                        this.cursor = cursor = NONE;
+                }
+                else if (x > removedDistance) {
+                    // assert cursor != prevTakeIndex;
+                    this.cursor = cursor = dec(cursor);
+                }
+            }
+            int lastRet = this.lastRet;
+            if (lastRet >= 0) {
+                int x = distance(lastRet, prevTakeIndex, len);
+                if (x == removedDistance)
+                    this.lastRet = lastRet = REMOVED;
+                else if (x > removedDistance)
+                    this.lastRet = lastRet = dec(lastRet);
+            }
+            int nextIndex = this.nextIndex;
+            if (nextIndex >= 0) {
+                int x = distance(nextIndex, prevTakeIndex, len);
+                if (x == removedDistance)
+                    this.nextIndex = nextIndex = REMOVED;
+                else if (x > removedDistance)
+                    this.nextIndex = nextIndex = dec(nextIndex);
+            }
+            else if (cursor < 0 && nextIndex < 0 && lastRet < 0) {
+                this.prevTakeIndex = DETACHED;
+                return true;
+            }
+            return false;
+        }
+
+        /**
+         * Called whenever takeIndex wraps around to zero.
+         *
+         * @return true if this iterator should be unlinked from itrs
+         */
+        boolean takeIndexWrapped() {
+            // assert lock.getHoldCount() == 1;
+            if (isDetached())
+                return true;
+            if (itrs.cycles - prevCycles > 1) {
+                // All the elements that existed at the time of the last
+                // operation are gone, so abandon further iteration.
+                shutdown();
+                return true;
+            }
+            return false;
+        }
+
+//         /** Uncomment for debugging. */
+//         public String toString() {
+//             return ("cursor=" + cursor + " " +
+//                     "nextIndex=" + nextIndex + " " +
+//                     "lastRet=" + lastRet + " " +
+//                     "nextItem=" + nextItem + " " +
+//                     "lastItem=" + lastItem + " " +
+//                     "prevCycles=" + prevCycles + " " +
+//                     "prevTakeIndex=" + prevTakeIndex + " " +
+//                     "size()=" + size() + " " +
+//                     "remainingCapacity()=" + remainingCapacity());
+//         }
+    }
 }
diff --git a/luni/src/main/java/java/util/concurrent/BlockingDeque.java b/luni/src/main/java/java/util/concurrent/BlockingDeque.java
index 136df9c..34f103d 100644
--- a/luni/src/main/java/java/util/concurrent/BlockingDeque.java
+++ b/luni/src/main/java/java/util/concurrent/BlockingDeque.java
@@ -1,7 +1,7 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent;
@@ -36,9 +36,9 @@ import java.util.*;
  *  <tr>
  *    <td><b>Insert</b></td>
  *    <td>{@link #addFirst addFirst(e)}</td>
- *    <td>{@link #offerFirst offerFirst(e)}</td>
+ *    <td>{@link #offerFirst(Object) offerFirst(e)}</td>
  *    <td>{@link #putFirst putFirst(e)}</td>
- *    <td>{@link #offerFirst offerFirst(e, time, unit)}</td>
+ *    <td>{@link #offerFirst(Object, long, TimeUnit) offerFirst(e, time, unit)}</td>
  *  </tr>
  *  <tr>
  *    <td><b>Remove</b></td>
@@ -67,9 +67,9 @@ import java.util.*;
  *  <tr>
  *    <td><b>Insert</b></td>
  *    <td>{@link #addLast addLast(e)}</td>
- *    <td>{@link #offerLast offerLast(e)}</td>
+ *    <td>{@link #offerLast(Object) offerLast(e)}</td>
  *    <td>{@link #putLast putLast(e)}</td>
- *    <td>{@link #offerLast offerLast(e, time, unit)}</td>
+ *    <td>{@link #offerLast(Object, long, TimeUnit) offerLast(e, time, unit)}</td>
  *  </tr>
  *  <tr>
  *    <td><b>Remove</b></td>
@@ -106,20 +106,20 @@ import java.util.*;
  *    <td ALIGN=CENTER COLSPAN = 2> <b>Insert</b></td>
  *  </tr>
  *  <tr>
- *    <td>{@link #add add(e)}</td>
- *    <td>{@link #addLast addLast(e)}</td>
+ *    <td>{@link #add(Object) add(e)}</td>
+ *    <td>{@link #addLast(Object) addLast(e)}</td>
  *  </tr>
  *  <tr>
- *    <td>{@link #offer offer(e)}</td>
- *    <td>{@link #offerLast offerLast(e)}</td>
+ *    <td>{@link #offer(Object) offer(e)}</td>
+ *    <td>{@link #offerLast(Object) offerLast(e)}</td>
  *  </tr>
  *  <tr>
- *    <td>{@link #put put(e)}</td>
- *    <td>{@link #putLast putLast(e)}</td>
+ *    <td>{@link #put(Object) put(e)}</td>
+ *    <td>{@link #putLast(Object) putLast(e)}</td>
  *  </tr>
  *  <tr>
- *    <td>{@link #offer offer(e, time, unit)}</td>
- *    <td>{@link #offerLast offerLast(e, time, unit)}</td>
+ *    <td>{@link #offer(Object, long, TimeUnit) offer(e, time, unit)}</td>
+ *    <td>{@link #offerLast(Object, long, TimeUnit) offerLast(e, time, unit)}</td>
  *  </tr>
  *  <tr>
  *    <td ALIGN=CENTER COLSPAN = 2> <b>Remove</b></td>
@@ -181,7 +181,7 @@ public interface BlockingDeque<E> extends BlockingQueue<E>, Deque<E> {
      * possible to do so immediately without violating capacity restrictions,
      * throwing an <tt>IllegalStateException</tt> if no space is currently
      * available.  When using a capacity-restricted deque, it is generally
-     * preferable to use {@link #offerFirst offerFirst}.
+     * preferable to use {@link #offerFirst(Object) offerFirst}.
      *
      * @param e the element to add
      * @throws IllegalStateException {@inheritDoc}
@@ -196,7 +196,7 @@ public interface BlockingDeque<E> extends BlockingQueue<E>, Deque<E> {
      * possible to do so immediately without violating capacity restrictions,
      * throwing an <tt>IllegalStateException</tt> if no space is currently
      * available.  When using a capacity-restricted deque, it is generally
-     * preferable to use {@link #offerLast offerLast}.
+     * preferable to use {@link #offerLast(Object) offerLast}.
      *
      * @param e the element to add
      * @throws IllegalStateException {@inheritDoc}
@@ -212,7 +212,7 @@ public interface BlockingDeque<E> extends BlockingQueue<E>, Deque<E> {
      * returning <tt>true</tt> upon success and <tt>false</tt> if no space is
      * currently available.
      * When using a capacity-restricted deque, this method is generally
-     * preferable to the {@link #addFirst addFirst} method, which can
+     * preferable to the {@link #addFirst(Object) addFirst} method, which can
      * fail to insert an element only by throwing an exception.
      *
      * @param e the element to add
@@ -228,7 +228,7 @@ public interface BlockingDeque<E> extends BlockingQueue<E>, Deque<E> {
      * returning <tt>true</tt> upon success and <tt>false</tt> if no space is
      * currently available.
      * When using a capacity-restricted deque, this method is generally
-     * preferable to the {@link #addLast addLast} method, which can
+     * preferable to the {@link #addLast(Object) addLast} method, which can
      * fail to insert an element only by throwing an exception.
      *
      * @param e the element to add
@@ -371,8 +371,10 @@ public interface BlockingDeque<E> extends BlockingQueue<E>, Deque<E> {
      * @param o element to be removed from this deque, if present
      * @return <tt>true</tt> if an element was removed as a result of this call
      * @throws ClassCastException if the class of the specified element
-     *         is incompatible with this deque (optional)
-     * @throws NullPointerException if the specified element is null (optional)
+     *         is incompatible with this deque
+     *         (<a href="../Collection.html#optional-restrictions">optional</a>)
+     * @throws NullPointerException if the specified element is null
+     *         (<a href="../Collection.html#optional-restrictions">optional</a>)
      */
     boolean removeFirstOccurrence(Object o);
 
@@ -387,8 +389,10 @@ public interface BlockingDeque<E> extends BlockingQueue<E>, Deque<E> {
      * @param o element to be removed from this deque, if present
      * @return <tt>true</tt> if an element was removed as a result of this call
      * @throws ClassCastException if the class of the specified element
-     *         is incompatible with this deque (optional)
-     * @throws NullPointerException if the specified element is null (optional)
+     *         is incompatible with this deque
+     *         (<a href="../Collection.html#optional-restrictions">optional</a>)
+     * @throws NullPointerException if the specified element is null
+     *         (<a href="../Collection.html#optional-restrictions">optional</a>)
      */
     boolean removeLastOccurrence(Object o);
 
@@ -401,9 +405,9 @@ public interface BlockingDeque<E> extends BlockingQueue<E>, Deque<E> {
      * <tt>true</tt> upon success and throwing an
      * <tt>IllegalStateException</tt> if no space is currently available.
      * When using a capacity-restricted deque, it is generally preferable to
-     * use {@link #offer offer}.
+     * use {@link #offer(Object) offer}.
      *
-     * <p>This method is equivalent to {@link #addLast addLast}.
+     * <p>This method is equivalent to {@link #addLast(Object) addLast}.
      *
      * @param e the element to add
      * @throws IllegalStateException {@inheritDoc}
@@ -424,7 +428,7 @@ public interface BlockingDeque<E> extends BlockingQueue<E>, Deque<E> {
      * generally preferable to the {@link #add} method, which can fail to
      * insert an element only by throwing an exception.
      *
-     * <p>This method is equivalent to {@link #offerLast offerLast}.
+     * <p>This method is equivalent to {@link #offerLast(Object) offerLast}.
      *
      * @param e the element to add
      * @throws ClassCastException if the class of the specified element
@@ -440,7 +444,7 @@ public interface BlockingDeque<E> extends BlockingQueue<E>, Deque<E> {
      * (in other words, at the tail of this deque), waiting if necessary for
      * space to become available.
      *
-     * <p>This method is equivalent to {@link #putLast putLast}.
+     * <p>This method is equivalent to {@link #putLast(Object) putLast}.
      *
      * @param e the element to add
      * @throws InterruptedException {@inheritDoc}
@@ -458,7 +462,7 @@ public interface BlockingDeque<E> extends BlockingQueue<E>, Deque<E> {
      * specified wait time if necessary for space to become available.
      *
      * <p>This method is equivalent to
-     * {@link #offerLast offerLast}.
+     * {@link #offerLast(Object,long,TimeUnit) offerLast}.
      *
      * @param e the element to add
      * @return <tt>true</tt> if the element was added to this deque, else
@@ -557,13 +561,15 @@ public interface BlockingDeque<E> extends BlockingQueue<E>, Deque<E> {
      * (or equivalently, if this deque changed as a result of the call).
      *
      * <p>This method is equivalent to
-     * {@link #removeFirstOccurrence removeFirstOccurrence}.
+     * {@link #removeFirstOccurrence(Object) removeFirstOccurrence}.
      *
      * @param o element to be removed from this deque, if present
      * @return <tt>true</tt> if this deque changed as a result of the call
      * @throws ClassCastException if the class of the specified element
-     *         is incompatible with this deque (optional)
-     * @throws NullPointerException if the specified element is null (optional)
+     *         is incompatible with this deque
+     *         (<a href="../Collection.html#optional-restrictions">optional</a>)
+     * @throws NullPointerException if the specified element is null
+     *         (<a href="../Collection.html#optional-restrictions">optional</a>)
      */
     boolean remove(Object o);
 
@@ -575,8 +581,10 @@ public interface BlockingDeque<E> extends BlockingQueue<E>, Deque<E> {
      * @param o object to be checked for containment in this deque
      * @return <tt>true</tt> if this deque contains the specified element
      * @throws ClassCastException if the class of the specified element
-     *         is incompatible with this deque (optional)
-     * @throws NullPointerException if the specified element is null (optional)
+     *         is incompatible with this deque
+     *         (<a href="../Collection.html#optional-restrictions">optional</a>)
+     * @throws NullPointerException if the specified element is null
+     *         (<a href="../Collection.html#optional-restrictions">optional</a>)
      */
     public boolean contains(Object o);
 
@@ -602,7 +610,7 @@ public interface BlockingDeque<E> extends BlockingQueue<E>, Deque<E> {
      * words, inserts the element at the front of this deque unless it would
      * violate capacity restrictions.
      *
-     * <p>This method is equivalent to {@link #addFirst addFirst}.
+     * <p>This method is equivalent to {@link #addFirst(Object) addFirst}.
      *
      * @throws IllegalStateException {@inheritDoc}
      * @throws ClassCastException {@inheritDoc}
diff --git a/luni/src/main/java/java/util/concurrent/BlockingQueue.java b/luni/src/main/java/java/util/concurrent/BlockingQueue.java
index d01c097..6cfe52b 100644
--- a/luni/src/main/java/java/util/concurrent/BlockingQueue.java
+++ b/luni/src/main/java/java/util/concurrent/BlockingQueue.java
@@ -1,7 +1,7 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent;
@@ -42,7 +42,7 @@ import java.util.Queue;
  *    <td>{@link #add add(e)}</td>
  *    <td>{@link #offer offer(e)}</td>
  *    <td>{@link #put put(e)}</td>
- *    <td>{@link #offer offer(e, time, unit)}</td>
+ *    <td>{@link #offer(Object, long, TimeUnit) offer(e, time, unit)}</td>
  *  </tr>
  *  <tr>
  *    <td><b>Remove</b></td>
@@ -102,7 +102,7 @@ import java.util.Queue;
  * Usage example, based on a typical producer-consumer scenario.
  * Note that a <tt>BlockingQueue</tt> can safely be used with multiple
  * producers and multiple consumers.
- * <pre>
+ *  <pre> {@code
  * class Producer implements Runnable {
  *   private final BlockingQueue queue;
  *   Producer(BlockingQueue q) { queue = q; }
@@ -135,8 +135,7 @@ import java.util.Queue;
  *     new Thread(c1).start();
  *     new Thread(c2).start();
  *   }
- * }
- * </pre>
+ * }}</pre>
  *
  * <p>Memory consistency effects: As with other concurrent
  * collections, actions in a thread prior to placing an object into a
@@ -156,7 +155,7 @@ public interface BlockingQueue<E> extends Queue<E> {
      * <tt>true</tt> upon success and throwing an
      * <tt>IllegalStateException</tt> if no space is currently available.
      * When using a capacity-restricted queue, it is generally preferable to
-     * use {@link #offer offer}.
+     * use {@link #offer(Object) offer}.
      *
      * @param e the element to add
      * @return <tt>true</tt> (as specified by {@link Collection#add})
@@ -274,8 +273,10 @@ public interface BlockingQueue<E> extends Queue<E> {
      * @param o element to be removed from this queue, if present
      * @return <tt>true</tt> if this queue changed as a result of the call
      * @throws ClassCastException if the class of the specified element
-     *         is incompatible with this queue (optional)
-     * @throws NullPointerException if the specified element is null (optional)
+     *         is incompatible with this queue
+     *         (<a href="../Collection.html#optional-restrictions">optional</a>)
+     * @throws NullPointerException if the specified element is null
+     *         (<a href="../Collection.html#optional-restrictions">optional</a>)
      */
     boolean remove(Object o);
 
@@ -287,8 +288,10 @@ public interface BlockingQueue<E> extends Queue<E> {
      * @param o object to be checked for containment in this queue
      * @return <tt>true</tt> if this queue contains the specified element
      * @throws ClassCastException if the class of the specified element
-     *         is incompatible with this queue (optional)
-     * @throws NullPointerException if the specified element is null (optional)
+     *         is incompatible with this queue
+     *         (<a href="../Collection.html#optional-restrictions">optional</a>)
+     * @throws NullPointerException if the specified element is null
+     *         (<a href="../Collection.html#optional-restrictions">optional</a>)
      */
     public boolean contains(Object o);
 
diff --git a/luni/src/main/java/java/util/concurrent/BrokenBarrierException.java b/luni/src/main/java/java/util/concurrent/BrokenBarrierException.java
index 3f93fbb..76fae13 100644
--- a/luni/src/main/java/java/util/concurrent/BrokenBarrierException.java
+++ b/luni/src/main/java/java/util/concurrent/BrokenBarrierException.java
@@ -1,7 +1,7 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent;
diff --git a/luni/src/main/java/java/util/concurrent/Callable.java b/luni/src/main/java/java/util/concurrent/Callable.java
index abc4d04..293544b 100644
--- a/luni/src/main/java/java/util/concurrent/Callable.java
+++ b/luni/src/main/java/java/util/concurrent/Callable.java
@@ -1,7 +1,7 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent;
diff --git a/luni/src/main/java/java/util/concurrent/CancellationException.java b/luni/src/main/java/java/util/concurrent/CancellationException.java
index 2c29544..dc452e4 100644
--- a/luni/src/main/java/java/util/concurrent/CancellationException.java
+++ b/luni/src/main/java/java/util/concurrent/CancellationException.java
@@ -1,7 +1,7 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent;
diff --git a/luni/src/main/java/java/util/concurrent/CompletionService.java b/luni/src/main/java/java/util/concurrent/CompletionService.java
index df9f719..7b0931c 100644
--- a/luni/src/main/java/java/util/concurrent/CompletionService.java
+++ b/luni/src/main/java/java/util/concurrent/CompletionService.java
@@ -1,7 +1,7 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent;
diff --git a/luni/src/main/java/java/util/concurrent/ConcurrentHashMap.java b/luni/src/main/java/java/util/concurrent/ConcurrentHashMap.java
index c142e2a..c85a5cc 100644
--- a/luni/src/main/java/java/util/concurrent/ConcurrentHashMap.java
+++ b/luni/src/main/java/java/util/concurrent/ConcurrentHashMap.java
@@ -1,16 +1,13 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent;
 import java.util.concurrent.locks.*;
 import java.util.*;
 import java.io.Serializable;
-import java.io.IOException;
-import java.io.ObjectInputStream;
-import java.io.ObjectOutputStream;
 
 // BEGIN android-note
 // removed link to collections framework docs
@@ -76,7 +73,25 @@ public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
 
     /*
      * The basic strategy is to subdivide the table among Segments,
-     * each of which itself is a concurrently readable hash table.
+     * each of which itself is a concurrently readable hash table.  To
+     * reduce footprint, all but one segments are constructed only
+     * when first needed (see ensureSegment). To maintain visibility
+     * in the presence of lazy construction, accesses to segments as
+     * well as elements of segment's table must use volatile access,
+     * which is done via Unsafe within methods segmentAt etc
+     * below. These provide the functionality of AtomicReferenceArrays
+     * but reduce the levels of indirection. Additionally,
+     * volatile-writes of table elements and entry "next" fields
+     * within locked operations use the cheaper "lazySet" forms of
+     * writes (via putOrderedObject) because these writes are always
+     * followed by lock releases that maintain sequential consistency
+     * of table updates.
+     *
+     * Historical note: The previous version of this class relied
+     * heavily on "final" fields, which avoided some volatile reads at
+     * the expense of a large initial footprint.  Some remnants of
+     * that design (including forced construction of segment 0) exist
+     * to ensure serialization compatibility.
      */
 
     /* ---------------- Constants -------------- */
@@ -108,8 +123,15 @@ public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
     static final int MAXIMUM_CAPACITY = 1 << 30;
 
     /**
+     * The minimum capacity for per-segment tables.  Must be a power
+     * of two, at least two to avoid immediate resizing on next use
+     * after lazy construction.
+     */
+    static final int MIN_SEGMENT_TABLE_CAPACITY = 2;
+
+    /**
      * The maximum number of segments to allow; used to bound
-     * constructor arguments.
+     * constructor arguments. Must be power of two less than 1 << 24.
      */
     static final int MAX_SEGMENTS = 1 << 16; // slightly conservative
 
@@ -135,7 +157,7 @@ public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
     final int segmentShift;
 
     /**
-     * The segments, each of which is a specialized hash table
+     * The segments, each of which is a specialized hash table.
      */
     final Segment<K,V>[] segments;
 
@@ -143,7 +165,66 @@ public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
     transient Set<Map.Entry<K,V>> entrySet;
     transient Collection<V> values;
 
-    /* ---------------- Small Utilities -------------- */
+    /**
+     * ConcurrentHashMap list entry. Note that this is never exported
+     * out as a user-visible Map.Entry.
+     */
+    static final class HashEntry<K,V> {
+        final int hash;
+        final K key;
+        volatile V value;
+        volatile HashEntry<K,V> next;
+
+        HashEntry(int hash, K key, V value, HashEntry<K,V> next) {
+            this.hash = hash;
+            this.key = key;
+            this.value = value;
+            this.next = next;
+        }
+
+        /**
+         * Sets next field with volatile write semantics.  (See above
+         * about use of putOrderedObject.)
+         */
+        final void setNext(HashEntry<K,V> n) {
+            UNSAFE.putOrderedObject(this, nextOffset, n);
+        }
+
+        // Unsafe mechanics
+        static final sun.misc.Unsafe UNSAFE;
+        static final long nextOffset;
+        static {
+            try {
+                UNSAFE = sun.misc.Unsafe.getUnsafe();
+                Class<?> k = HashEntry.class;
+                nextOffset = UNSAFE.objectFieldOffset
+                    (k.getDeclaredField("next"));
+            } catch (Exception e) {
+                throw new Error(e);
+            }
+        }
+    }
+
+    /**
+     * Gets the ith element of given table (if nonnull) with volatile
+     * read semantics. Note: This is manually integrated into a few
+     * performance-sensitive methods to reduce call overhead.
+     */
+    @SuppressWarnings("unchecked")
+    static final <K,V> HashEntry<K,V> entryAt(HashEntry<K,V>[] tab, int i) {
+        return (tab == null) ? null :
+            (HashEntry<K,V>) UNSAFE.getObjectVolatile
+            (tab, ((long)i << TSHIFT) + TBASE);
+    }
+
+    /**
+     * Sets the ith element of given table, with volatile write
+     * semantics. (See above about use of putOrderedObject.)
+     */
+    static final <K,V> void setEntryAt(HashEntry<K,V>[] tab, int i,
+                                       HashEntry<K,V> e) {
+        UNSAFE.putOrderedObject(tab, ((long)i << TSHIFT) + TBASE, e);
+    }
 
     /**
      * Applies a supplemental hash function to a given hashCode, which
@@ -164,104 +245,67 @@ public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
     }
 
     /**
-     * Returns the segment that should be used for key with given hash
-     * @param hash the hash code for the key
-     * @return the segment
-     */
-    final Segment<K,V> segmentFor(int hash) {
-        return segments[(hash >>> segmentShift) & segmentMask];
-    }
-
-    /* ---------------- Inner Classes -------------- */
-
-    /**
-     * ConcurrentHashMap list entry. Note that this is never exported
-     * out as a user-visible Map.Entry.
-     *
-     * Because the value field is volatile, not final, it is legal wrt
-     * the Java Memory Model for an unsynchronized reader to see null
-     * instead of initial value when read via a data race.  Although a
-     * reordering leading to this is not likely to ever actually
-     * occur, the Segment.readValueUnderLock method is used as a
-     * backup in case a null (pre-initialized) value is ever seen in
-     * an unsynchronized access method.
-     */
-    static final class HashEntry<K,V> {
-        final K key;
-        final int hash;
-        volatile V value;
-        final HashEntry<K,V> next;
-
-        HashEntry(K key, int hash, HashEntry<K,V> next, V value) {
-            this.key = key;
-            this.hash = hash;
-            this.next = next;
-            this.value = value;
-        }
-
-        @SuppressWarnings("unchecked")
-        static final <K,V> HashEntry<K,V>[] newArray(int i) {
-            return new HashEntry[i];
-        }
-    }
-
-    /**
      * Segments are specialized versions of hash tables.  This
      * subclasses from ReentrantLock opportunistically, just to
      * simplify some locking and avoid separate construction.
      */
     static final class Segment<K,V> extends ReentrantLock implements Serializable {
         /*
-         * Segments maintain a table of entry lists that are ALWAYS
-         * kept in a consistent state, so can be read without locking.
-         * Next fields of nodes are immutable (final).  All list
-         * additions are performed at the front of each bin. This
-         * makes it easy to check changes, and also fast to traverse.
-         * When nodes would otherwise be changed, new nodes are
-         * created to replace them. This works well for hash tables
-         * since the bin lists tend to be short. (The average length
-         * is less than two for the default load factor threshold.)
-         *
-         * Read operations can thus proceed without locking, but rely
-         * on selected uses of volatiles to ensure that completed
-         * write operations performed by other threads are
-         * noticed. For most purposes, the "count" field, tracking the
-         * number of elements, serves as that volatile variable
-         * ensuring visibility.  This is convenient because this field
-         * needs to be read in many read operations anyway:
-         *
-         *   - All (unsynchronized) read operations must first read the
-         *     "count" field, and should not look at table entries if
-         *     it is 0.
+         * Segments maintain a table of entry lists that are always
+         * kept in a consistent state, so can be read (via volatile
+         * reads of segments and tables) without locking.  This
+         * requires replicating nodes when necessary during table
+         * resizing, so the old lists can be traversed by readers
+         * still using old version of table.
          *
-         *   - All (synchronized) write operations should write to
-         *     the "count" field after structurally changing any bin.
-         *     The operations must not take any action that could even
-         *     momentarily cause a concurrent read operation to see
-         *     inconsistent data. This is made easier by the nature of
-         *     the read operations in Map. For example, no operation
-         *     can reveal that the table has grown but the threshold
-         *     has not yet been updated, so there are no atomicity
-         *     requirements for this with respect to reads.
-         *
-         * As a guide, all critical volatile reads and writes to the
-         * count field are marked in code comments.
+         * This class defines only mutative methods requiring locking.
+         * Except as noted, the methods of this class perform the
+         * per-segment versions of ConcurrentHashMap methods.  (Other
+         * methods are integrated directly into ConcurrentHashMap
+         * methods.) These mutative methods use a form of controlled
+         * spinning on contention via methods scanAndLock and
+         * scanAndLockForPut. These intersperse tryLocks with
+         * traversals to locate nodes.  The main benefit is to absorb
+         * cache misses (which are very common for hash tables) while
+         * obtaining locks so that traversal is faster once
+         * acquired. We do not actually use the found nodes since they
+         * must be re-acquired under lock anyway to ensure sequential
+         * consistency of updates (and in any case may be undetectably
+         * stale), but they will normally be much faster to re-locate.
+         * Also, scanAndLockForPut speculatively creates a fresh node
+         * to use in put if no node is found.
          */
 
         private static final long serialVersionUID = 2249069246763182397L;
 
         /**
-         * The number of elements in this segment's region.
+         * The maximum number of times to tryLock in a prescan before
+         * possibly blocking on acquire in preparation for a locked
+         * segment operation. On multiprocessors, using a bounded
+         * number of retries maintains cache acquired while locating
+         * nodes.
          */
-        transient volatile int count;
+        static final int MAX_SCAN_RETRIES =
+            Runtime.getRuntime().availableProcessors() > 1 ? 64 : 1;
+
+        /**
+         * The per-segment table. Elements are accessed via
+         * entryAt/setEntryAt providing volatile semantics.
+         */
+        transient volatile HashEntry<K,V>[] table;
 
         /**
-         * Number of updates that alter the size of the table. This is
-         * used during bulk-read methods to make sure they see a
-         * consistent snapshot: If modCounts change during a traversal
-         * of segments computing size or checking containsValue, then
-         * we might have an inconsistent view of state so (usually)
-         * must retry.
+         * The number of elements. Accessed only either within locks
+         * or among other volatile reads that maintain visibility.
+         */
+        transient int count;
+
+        /**
+         * The total number of mutative operations in this segment.
+         * Even though this may overflows 32 bits, it provides
+         * sufficient accuracy for stability checks in CHM isEmpty()
+         * and size() methods.  Accessed only either within locks or
+         * among other volatile reads that maintain visibility.
          */
         transient int modCount;
 
@@ -273,11 +317,6 @@ public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
         transient int threshold;
 
         /**
-         * The per-segment table.
-         */
-        transient volatile HashEntry<K,V>[] table;
-
-        /**
          * The load factor for the hash table.  Even though this value
          * is same for all segments, it is replicated to avoid needing
          * links to outer object.
@@ -285,202 +324,93 @@ public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
          */
         final float loadFactor;
 
-        Segment(int initialCapacity, float lf) {
-            loadFactor = lf;
-            setTable(HashEntry.<K,V>newArray(initialCapacity));
-        }
-
-        @SuppressWarnings("unchecked")
-        static final <K,V> Segment<K,V>[] newArray(int i) {
-            return new Segment[i];
-        }
-
-        /**
-         * Sets table to new HashEntry array.
-         * Call only while holding lock or in constructor.
-         */
-        void setTable(HashEntry<K,V>[] newTable) {
-            threshold = (int)(newTable.length * loadFactor);
-            table = newTable;
-        }
-
-        /**
-         * Returns properly casted first entry of bin for given hash.
-         */
-        HashEntry<K,V> getFirst(int hash) {
-            HashEntry<K,V>[] tab = table;
-            return tab[hash & (tab.length - 1)];
+        Segment(float lf, int threshold, HashEntry<K,V>[] tab) {
+            this.loadFactor = lf;
+            this.threshold = threshold;
+            this.table = tab;
         }
 
-        /**
-         * Reads value field of an entry under lock. Called if value
-         * field ever appears to be null. This is possible only if a
-         * compiler happens to reorder a HashEntry initialization with
-         * its table assignment, which is legal under memory model
-         * but is not known to ever occur.
-         */
-        V readValueUnderLock(HashEntry<K,V> e) {
-            lock();
+        final V put(K key, int hash, V value, boolean onlyIfAbsent) {
+            HashEntry<K,V> node = tryLock() ? null :
+                scanAndLockForPut(key, hash, value);
+            V oldValue;
             try {
-                return e.value;
-            } finally {
-                unlock();
-            }
-        }
-
-        /* Specialized implementations of map methods */
-
-        V get(Object key, int hash) {
-            if (count != 0) { // read-volatile
-                HashEntry<K,V> e = getFirst(hash);
-                while (e != null) {
-                    if (e.hash == hash && key.equals(e.key)) {
-                        V v = e.value;
-                        if (v != null)
-                            return v;
-                        return readValueUnderLock(e); // recheck
-                    }
-                    e = e.next;
-                }
-            }
-            return null;
-        }
-
-        boolean containsKey(Object key, int hash) {
-            if (count != 0) { // read-volatile
-                HashEntry<K,V> e = getFirst(hash);
-                while (e != null) {
-                    if (e.hash == hash && key.equals(e.key))
-                        return true;
-                    e = e.next;
-                }
-            }
-            return false;
-        }
-
-        boolean containsValue(Object value) {
-            if (count != 0) { // read-volatile
                 HashEntry<K,V>[] tab = table;
-                int len = tab.length;
-                for (int i = 0 ; i < len; i++) {
-                    for (HashEntry<K,V> e = tab[i]; e != null; e = e.next) {
-                        V v = e.value;
-                        if (v == null) // recheck
-                            v = readValueUnderLock(e);
-                        if (value.equals(v))
-                            return true;
+                int index = (tab.length - 1) & hash;
+                HashEntry<K,V> first = entryAt(tab, index);
+                for (HashEntry<K,V> e = first;;) {
+                    if (e != null) {
+                        K k;
+                        if ((k = e.key) == key ||
+                            (e.hash == hash && key.equals(k))) {
+                            oldValue = e.value;
+                            if (!onlyIfAbsent) {
+                                e.value = value;
+                                ++modCount;
+                            }
+                            break;
+                        }
+                        e = e.next;
+                    }
+                    else {
+                        if (node != null)
+                            node.setNext(first);
+                        else
+                            node = new HashEntry<K,V>(hash, key, value, first);
+                        int c = count + 1;
+                        if (c > threshold && tab.length < MAXIMUM_CAPACITY)
+                            rehash(node);
+                        else
+                            setEntryAt(tab, index, node);
+                        ++modCount;
+                        count = c;
+                        oldValue = null;
+                        break;
                     }
                 }
-            }
-            return false;
-        }
-
-        boolean replace(K key, int hash, V oldValue, V newValue) {
-            lock();
-            try {
-                HashEntry<K,V> e = getFirst(hash);
-                while (e != null && (e.hash != hash || !key.equals(e.key)))
-                    e = e.next;
-
-                boolean replaced = false;
-                if (e != null && oldValue.equals(e.value)) {
-                    replaced = true;
-                    e.value = newValue;
-                }
-                return replaced;
-            } finally {
-                unlock();
-            }
-        }
-
-        V replace(K key, int hash, V newValue) {
-            lock();
-            try {
-                HashEntry<K,V> e = getFirst(hash);
-                while (e != null && (e.hash != hash || !key.equals(e.key)))
-                    e = e.next;
-
-                V oldValue = null;
-                if (e != null) {
-                    oldValue = e.value;
-                    e.value = newValue;
-                }
-                return oldValue;
-            } finally {
-                unlock();
-            }
-        }
-
-
-        V put(K key, int hash, V value, boolean onlyIfAbsent) {
-            lock();
-            try {
-                int c = count;
-                if (c++ > threshold) // ensure capacity
-                    rehash();
-                HashEntry<K,V>[] tab = table;
-                int index = hash & (tab.length - 1);
-                HashEntry<K,V> first = tab[index];
-                HashEntry<K,V> e = first;
-                while (e != null && (e.hash != hash || !key.equals(e.key)))
-                    e = e.next;
-
-                V oldValue;
-                if (e != null) {
-                    oldValue = e.value;
-                    if (!onlyIfAbsent)
-                        e.value = value;
-                }
-                else {
-                    oldValue = null;
-                    ++modCount;
-                    tab[index] = new HashEntry<K,V>(key, hash, first, value);
-                    count = c; // write-volatile
-                }
-                return oldValue;
             } finally {
                 unlock();
             }
+            return oldValue;
         }
 
-        void rehash() {
-            HashEntry<K,V>[] oldTable = table;
-            int oldCapacity = oldTable.length;
-            if (oldCapacity >= MAXIMUM_CAPACITY)
-                return;
-
+        /**
+         * Doubles size of table and repacks entries, also adding the
+         * given node to new table
+         */
+        @SuppressWarnings("unchecked")
+        private void rehash(HashEntry<K,V> node) {
             /*
-             * Reclassify nodes in each list to new Map.  Because we are
-             * using power-of-two expansion, the elements from each bin
-             * must either stay at same index, or move with a power of two
-             * offset. We eliminate unnecessary node creation by catching
-             * cases where old nodes can be reused because their next
-             * fields won't change. Statistically, at the default
-             * threshold, only about one-sixth of them need cloning when
-             * a table doubles. The nodes they replace will be garbage
-             * collectable as soon as they are no longer referenced by any
-             * reader thread that may be in the midst of traversing table
-             * right now.
+             * Reclassify nodes in each list to new table.  Because we
+             * are using power-of-two expansion, the elements from
+             * each bin must either stay at same index, or move with a
+             * power of two offset. We eliminate unnecessary node
+             * creation by catching cases where old nodes can be
+             * reused because their next fields won't change.
+             * Statistically, at the default threshold, only about
+             * one-sixth of them need cloning when a table
+             * doubles. The nodes they replace will be garbage
+             * collectable as soon as they are no longer referenced by
+             * any reader thread that may be in the midst of
+             * concurrently traversing table. Entry accesses use plain
+             * array indexing because they are followed by volatile
+             * table write.
              */
-
-            HashEntry<K,V>[] newTable = HashEntry.newArray(oldCapacity<<1);
-            threshold = (int)(newTable.length * loadFactor);
-            int sizeMask = newTable.length - 1;
+            HashEntry<K,V>[] oldTable = table;
+            int oldCapacity = oldTable.length;
+            int newCapacity = oldCapacity << 1;
+            threshold = (int)(newCapacity * loadFactor);
+            HashEntry<K,V>[] newTable =
+                (HashEntry<K,V>[]) new HashEntry<?,?>[newCapacity];
+            int sizeMask = newCapacity - 1;
             for (int i = 0; i < oldCapacity ; i++) {
-                // We need to guarantee that any existing reads of old Map can
-                //  proceed. So we cannot yet null out each bin.
                 HashEntry<K,V> e = oldTable[i];
-
                 if (e != null) {
                     HashEntry<K,V> next = e.next;
                     int idx = e.hash & sizeMask;
-
-                    //  Single node on list
-                    if (next == null)
+                    if (next == null)   //  Single node on list
                         newTable[idx] = e;
-
-                    else {
-                        // Reuse trailing consecutive sequence at same slot
+                    else { // Reuse consecutive sequence at same slot
                         HashEntry<K,V> lastRun = e;
                         int lastIdx = idx;
                         for (HashEntry<K,V> last = next;
@@ -493,74 +423,263 @@ public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
                             }
                         }
                         newTable[lastIdx] = lastRun;
-
-                        // Clone all remaining nodes
+                        // Clone remaining nodes
                         for (HashEntry<K,V> p = e; p != lastRun; p = p.next) {
-                            int k = p.hash & sizeMask;
+                            V v = p.value;
+                            int h = p.hash;
+                            int k = h & sizeMask;
                             HashEntry<K,V> n = newTable[k];
-                            newTable[k] = new HashEntry<K,V>(p.key, p.hash,
-                                                             n, p.value);
+                            newTable[k] = new HashEntry<K,V>(h, p.key, v, n);
                         }
                     }
                 }
             }
+            int nodeIndex = node.hash & sizeMask; // add the new node
+            node.setNext(newTable[nodeIndex]);
+            newTable[nodeIndex] = node;
             table = newTable;
         }
 
         /**
+         * Scans for a node containing given key while trying to
+         * acquire lock, creating and returning one if not found. Upon
+         * return, guarantees that lock is held. Unlike in most
+         * methods, calls to method equals are not screened: Since
+         * traversal speed doesn't matter, we might as well help warm
+         * up the associated code and accesses as well.
+         *
+         * @return a new node if key not found, else null
+         */
+        private HashEntry<K,V> scanAndLockForPut(K key, int hash, V value) {
+            HashEntry<K,V> first = entryForHash(this, hash);
+            HashEntry<K,V> e = first;
+            HashEntry<K,V> node = null;
+            int retries = -1; // negative while locating node
+            while (!tryLock()) {
+                HashEntry<K,V> f; // to recheck first below
+                if (retries < 0) {
+                    if (e == null) {
+                        if (node == null) // speculatively create node
+                            node = new HashEntry<K,V>(hash, key, value, null);
+                        retries = 0;
+                    }
+                    else if (key.equals(e.key))
+                        retries = 0;
+                    else
+                        e = e.next;
+                }
+                else if (++retries > MAX_SCAN_RETRIES) {
+                    lock();
+                    break;
+                }
+                else if ((retries & 1) == 0 &&
+                         (f = entryForHash(this, hash)) != first) {
+                    e = first = f; // re-traverse if entry changed
+                    retries = -1;
+                }
+            }
+            return node;
+        }
+
+        /**
+         * Scans for a node containing the given key while trying to
+         * acquire lock for a remove or replace operation. Upon
+         * return, guarantees that lock is held.  Note that we must
+         * lock even if the key is not found, to ensure sequential
+         * consistency of updates.
+         */
+        private void scanAndLock(Object key, int hash) {
+            // similar to but simpler than scanAndLockForPut
+            HashEntry<K,V> first = entryForHash(this, hash);
+            HashEntry<K,V> e = first;
+            int retries = -1;
+            while (!tryLock()) {
+                HashEntry<K,V> f;
+                if (retries < 0) {
+                    if (e == null || key.equals(e.key))
+                        retries = 0;
+                    else
+                        e = e.next;
+                }
+                else if (++retries > MAX_SCAN_RETRIES) {
+                    lock();
+                    break;
+                }
+                else if ((retries & 1) == 0 &&
+                         (f = entryForHash(this, hash)) != first) {
+                    e = first = f;
+                    retries = -1;
+                }
+            }
+        }
+
+        /**
          * Remove; match on key only if value null, else match both.
          */
-        V remove(Object key, int hash, Object value) {
-            lock();
+        final V remove(Object key, int hash, Object value) {
+            if (!tryLock())
+                scanAndLock(key, hash);
+            V oldValue = null;
             try {
-                int c = count - 1;
                 HashEntry<K,V>[] tab = table;
-                int index = hash & (tab.length - 1);
-                HashEntry<K,V> first = tab[index];
-                HashEntry<K,V> e = first;
-                while (e != null && (e.hash != hash || !key.equals(e.key)))
-                    e = e.next;
+                int index = (tab.length - 1) & hash;
+                HashEntry<K,V> e = entryAt(tab, index);
+                HashEntry<K,V> pred = null;
+                while (e != null) {
+                    K k;
+                    HashEntry<K,V> next = e.next;
+                    if ((k = e.key) == key ||
+                        (e.hash == hash && key.equals(k))) {
+                        V v = e.value;
+                        if (value == null || value == v || value.equals(v)) {
+                            if (pred == null)
+                                setEntryAt(tab, index, next);
+                            else
+                                pred.setNext(next);
+                            ++modCount;
+                            --count;
+                            oldValue = v;
+                        }
+                        break;
+                    }
+                    pred = e;
+                    e = next;
+                }
+            } finally {
+                unlock();
+            }
+            return oldValue;
+        }
 
-                V oldValue = null;
-                if (e != null) {
-                    V v = e.value;
-                    if (value == null || value.equals(v)) {
-                        oldValue = v;
-                        // All entries following removed node can stay
-                        // in list, but all preceding ones need to be
-                        // cloned.
+        final boolean replace(K key, int hash, V oldValue, V newValue) {
+            if (!tryLock())
+                scanAndLock(key, hash);
+            boolean replaced = false;
+            try {
+                HashEntry<K,V> e;
+                for (e = entryForHash(this, hash); e != null; e = e.next) {
+                    K k;
+                    if ((k = e.key) == key ||
+                        (e.hash == hash && key.equals(k))) {
+                        if (oldValue.equals(e.value)) {
+                            e.value = newValue;
+                            ++modCount;
+                            replaced = true;
+                        }
+                        break;
+                    }
+                }
+            } finally {
+                unlock();
+            }
+            return replaced;
+        }
+
+        final V replace(K key, int hash, V value) {
+            if (!tryLock())
+                scanAndLock(key, hash);
+            V oldValue = null;
+            try {
+                HashEntry<K,V> e;
+                for (e = entryForHash(this, hash); e != null; e = e.next) {
+                    K k;
+                    if ((k = e.key) == key ||
+                        (e.hash == hash && key.equals(k))) {
+                        oldValue = e.value;
+                        e.value = value;
                         ++modCount;
-                        HashEntry<K,V> newFirst = e.next;
-                        for (HashEntry<K,V> p = first; p != e; p = p.next)
-                            newFirst = new HashEntry<K,V>(p.key, p.hash,
-                                                          newFirst, p.value);
-                        tab[index] = newFirst;
-                        count = c; // write-volatile
+                        break;
                     }
                 }
-                return oldValue;
+            } finally {
+                unlock();
+            }
+            return oldValue;
+        }
+
+        final void clear() {
+            lock();
+            try {
+                HashEntry<K,V>[] tab = table;
+                for (int i = 0; i < tab.length ; i++)
+                    setEntryAt(tab, i, null);
+                ++modCount;
+                count = 0;
             } finally {
                 unlock();
             }
         }
+    }
+
+    // Accessing segments
+
+    /**
+     * Gets the jth element of given segment array (if nonnull) with
+     * volatile element access semantics via Unsafe. (The null check
+     * can trigger harmlessly only during deserialization.) Note:
+     * because each element of segments array is set only once (using
+     * fully ordered writes), some performance-sensitive methods rely
+     * on this method only as a recheck upon null reads.
+     */
+    @SuppressWarnings("unchecked")
+    static final <K,V> Segment<K,V> segmentAt(Segment<K,V>[] ss, int j) {
+        long u = (j << SSHIFT) + SBASE;
+        return ss == null ? null :
+            (Segment<K,V>) UNSAFE.getObjectVolatile(ss, u);
+    }
 
-        void clear() {
-            if (count != 0) {
-                lock();
-                try {
-                    HashEntry<K,V>[] tab = table;
-                    for (int i = 0; i < tab.length ; i++)
-                        tab[i] = null;
-                    ++modCount;
-                    count = 0; // write-volatile
-                } finally {
-                    unlock();
+    /**
+     * Returns the segment for the given index, creating it and
+     * recording in segment table (via CAS) if not already present.
+     *
+     * @param k the index
+     * @return the segment
+     */
+    @SuppressWarnings("unchecked")
+    private Segment<K,V> ensureSegment(int k) {
+        final Segment<K,V>[] ss = this.segments;
+        long u = (k << SSHIFT) + SBASE; // raw offset
+        Segment<K,V> seg;
+        if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u)) == null) {
+            Segment<K,V> proto = ss[0]; // use segment 0 as prototype
+            int cap = proto.table.length;
+            float lf = proto.loadFactor;
+            int threshold = (int)(cap * lf);
+            HashEntry<K,V>[] tab = (HashEntry<K,V>[])new HashEntry<?,?>[cap];
+            if ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))
+                == null) { // recheck
+                Segment<K,V> s = new Segment<K,V>(lf, threshold, tab);
+                while ((seg = (Segment<K,V>)UNSAFE.getObjectVolatile(ss, u))
+                       == null) {
+                    if (UNSAFE.compareAndSwapObject(ss, u, null, seg = s))
+                        break;
                 }
             }
         }
+        return seg;
     }
 
+    // Hash-based segment and entry accesses
 
+    /**
+     * Gets the segment for the given hash code.
+     */
+    @SuppressWarnings("unchecked")
+    private Segment<K,V> segmentForHash(int h) {
+        long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
+        return (Segment<K,V>) UNSAFE.getObjectVolatile(segments, u);
+    }
+
+    /**
+     * Gets the table entry for the given segment and hash code.
+     */
+    @SuppressWarnings("unchecked")
+    static final <K,V> HashEntry<K,V> entryForHash(Segment<K,V> seg, int h) {
+        HashEntry<K,V>[] tab;
+        return (seg == null || (tab = seg.table) == null) ? null :
+            (HashEntry<K,V>) UNSAFE.getObjectVolatile
+            (tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE);
+    }
 
     /* ---------------- Public operations -------------- */
 
@@ -580,14 +699,13 @@ public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
      * negative or the load factor or concurrencyLevel are
      * nonpositive.
      */
+    @SuppressWarnings("unchecked")
     public ConcurrentHashMap(int initialCapacity,
                              float loadFactor, int concurrencyLevel) {
         if (!(loadFactor > 0) || initialCapacity < 0 || concurrencyLevel <= 0)
             throw new IllegalArgumentException();
-
         if (concurrencyLevel > MAX_SEGMENTS)
             concurrencyLevel = MAX_SEGMENTS;
-
         // Find power-of-two sizes best matching arguments
         int sshift = 0;
         int ssize = 1;
@@ -595,21 +713,23 @@ public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
             ++sshift;
             ssize <<= 1;
         }
-        segmentShift = 32 - sshift;
-        segmentMask = ssize - 1;
-        this.segments = Segment.newArray(ssize);
-
+        this.segmentShift = 32 - sshift;
+        this.segmentMask = ssize - 1;
         if (initialCapacity > MAXIMUM_CAPACITY)
             initialCapacity = MAXIMUM_CAPACITY;
         int c = initialCapacity / ssize;
         if (c * ssize < initialCapacity)
             ++c;
-        int cap = 1;
+        int cap = MIN_SEGMENT_TABLE_CAPACITY;
         while (cap < c)
             cap <<= 1;
-
-        for (int i = 0; i < this.segments.length; ++i)
-            this.segments[i] = new Segment<K,V>(cap, loadFactor);
+        // create segments and segments[0]
+        Segment<K,V> s0 =
+            new Segment<K,V>(loadFactor, (int)(cap * loadFactor),
+                             (HashEntry<K,V>[])new HashEntry<?,?>[cap]);
+        Segment<K,V>[] ss = (Segment<K,V>[])new Segment<?,?>[ssize];
+        UNSAFE.putOrderedObject(ss, SBASE, s0); // ordered write of segments[0]
+        this.segments = ss;
     }
 
     /**
@@ -672,33 +792,36 @@ public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
      * @return <tt>true</tt> if this map contains no key-value mappings
      */
     public boolean isEmpty() {
-        final Segment<K,V>[] segments = this.segments;
         /*
-         * We keep track of per-segment modCounts to avoid ABA
-         * problems in which an element in one segment was added and
-         * in another removed during traversal, in which case the
-         * table was never actually empty at any point. Note the
-         * similar use of modCounts in the size() and containsValue()
-         * methods, which are the only other methods also susceptible
-         * to ABA problems.
+         * Sum per-segment modCounts to avoid mis-reporting when
+         * elements are concurrently added and removed in one segment
+         * while checking another, in which case the table was never
+         * actually empty at any point. (The sum ensures accuracy up
+         * through at least 1<<31 per-segment modifications before
+         * recheck.)  Methods size() and containsValue() use similar
+         * constructions for stability checks.
          */
-        int[] mc = new int[segments.length];
-        int mcsum = 0;
-        for (int i = 0; i < segments.length; ++i) {
-            if (segments[i].count != 0)
-                return false;
-            else
-                mcsum += mc[i] = segments[i].modCount;
-        }
-        // If mcsum happens to be zero, then we know we got a snapshot
-        // before any modifications at all were made.  This is
-        // probably common enough to bother tracking.
-        if (mcsum != 0) {
-            for (int i = 0; i < segments.length; ++i) {
-                if (segments[i].count != 0 ||
-                    mc[i] != segments[i].modCount)
+        long sum = 0L;
+        final Segment<K,V>[] segments = this.segments;
+        for (int j = 0; j < segments.length; ++j) {
+            Segment<K,V> seg = segmentAt(segments, j);
+            if (seg != null) {
+                if (seg.count != 0)
                     return false;
+                sum += seg.modCount;
+            }
+        }
+        if (sum != 0L) { // recheck unless no modifications
+            for (int j = 0; j < segments.length; ++j) {
+                Segment<K,V> seg = segmentAt(segments, j);
+                if (seg != null) {
+                    if (seg.count != 0)
+                        return false;
+                    sum -= seg.modCount;
+                }
             }
+            if (sum != 0L)
+                return false;
         }
         return true;
     }
@@ -711,45 +834,36 @@ public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
      * @return the number of key-value mappings in this map
      */
     public int size() {
-        final Segment<K,V>[] segments = this.segments;
-        long sum = 0;
-        long check = 0;
-        int[] mc = new int[segments.length];
         // Try a few times to get accurate count. On failure due to
         // continuous async changes in table, resort to locking.
-        for (int k = 0; k < RETRIES_BEFORE_LOCK; ++k) {
-            check = 0;
-            sum = 0;
-            int mcsum = 0;
-            for (int i = 0; i < segments.length; ++i) {
-                sum += segments[i].count;
-                mcsum += mc[i] = segments[i].modCount;
-            }
-            if (mcsum != 0) {
-                for (int i = 0; i < segments.length; ++i) {
-                    check += segments[i].count;
-                    if (mc[i] != segments[i].modCount) {
-                        check = -1; // force retry
-                        break;
-                    }
+        final Segment<K,V>[] segments = this.segments;
+        final int segmentCount = segments.length;
+
+        long previousSum = 0L;
+        for (int retries = -1; retries < RETRIES_BEFORE_LOCK; retries++) {
+            long sum = 0L;    // sum of modCounts
+            long size = 0L;
+            for (int i = 0; i < segmentCount; i++) {
+                Segment<K,V> segment = segmentAt(segments, i);
+                if (segment != null) {
+                    sum += segment.modCount;
+                    size += segment.count;
                 }
             }
-            if (check == sum)
-                break;
+            if (sum == previousSum)
+                return ((size >>> 31) == 0) ? (int) size : Integer.MAX_VALUE;
+            previousSum = sum;
         }
-        if (check != sum) { // Resort to locking all segments
-            sum = 0;
-            for (int i = 0; i < segments.length; ++i)
-                segments[i].lock();
-            for (int i = 0; i < segments.length; ++i)
-                sum += segments[i].count;
-            for (int i = 0; i < segments.length; ++i)
-                segments[i].unlock();
+
+        long size = 0L;
+        for (int i = 0; i < segmentCount; i++) {
+            Segment<K,V> segment = ensureSegment(i);
+            segment.lock();
+            size += segment.count;
         }
-        if (sum > Integer.MAX_VALUE)
-            return Integer.MAX_VALUE;
-        else
-            return (int)sum;
+        for (int i = 0; i < segmentCount; i++)
+            segments[i].unlock();
+        return ((size >>> 31) == 0) ? (int) size : Integer.MAX_VALUE;
     }
 
     /**
@@ -764,8 +878,21 @@ public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
      * @throws NullPointerException if the specified key is null
      */
     public V get(Object key) {
-        int hash = hash(key.hashCode());
-        return segmentFor(hash).get(key, hash);
+        Segment<K,V> s; // manually integrate access methods to reduce overhead
+        HashEntry<K,V>[] tab;
+        int h = hash(key.hashCode());
+        long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
+        if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null &&
+            (tab = s.table) != null) {
+            for (HashEntry<K,V> e = (HashEntry<K,V>) UNSAFE.getObjectVolatile
+                     (tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE);
+                 e != null; e = e.next) {
+                K k;
+                if ((k = e.key) == key || (e.hash == h && key.equals(k)))
+                    return e.value;
+            }
+        }
+        return null;
     }
 
     /**
@@ -777,9 +904,23 @@ public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
      *         <tt>equals</tt> method; <tt>false</tt> otherwise.
      * @throws NullPointerException if the specified key is null
      */
+    @SuppressWarnings("unchecked")
     public boolean containsKey(Object key) {
-        int hash = hash(key.hashCode());
-        return segmentFor(hash).containsKey(key, hash);
+        Segment<K,V> s; // same as get() except no need for volatile value read
+        HashEntry<K,V>[] tab;
+        int h = hash(key.hashCode());
+        long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
+        if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null &&
+            (tab = s.table) != null) {
+            for (HashEntry<K,V> e = (HashEntry<K,V>) UNSAFE.getObjectVolatile
+                     (tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE);
+                 e != null; e = e.next) {
+                K k;
+                if ((k = e.key) == key || (e.hash == h && key.equals(k)))
+                    return true;
+            }
+        }
+        return false;
     }
 
     /**
@@ -794,53 +935,47 @@ public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
      * @throws NullPointerException if the specified value is null
      */
     public boolean containsValue(Object value) {
+        // Same idea as size()
         if (value == null)
             throw new NullPointerException();
-
-        // See explanation of modCount use above
-
         final Segment<K,V>[] segments = this.segments;
-        int[] mc = new int[segments.length];
-
-        // Try a few times without locking
-        for (int k = 0; k < RETRIES_BEFORE_LOCK; ++k) {
-            int sum = 0;
-            int mcsum = 0;
-            for (int i = 0; i < segments.length; ++i) {
-                int c = segments[i].count;
-                mcsum += mc[i] = segments[i].modCount;
-                if (segments[i].containsValue(value))
-                    return true;
-            }
-            boolean cleanSweep = true;
-            if (mcsum != 0) {
-                for (int i = 0; i < segments.length; ++i) {
-                    int c = segments[i].count;
-                    if (mc[i] != segments[i].modCount) {
-                        cleanSweep = false;
-                        break;
-                    }
-                }
-            }
-            if (cleanSweep)
-                return false;
-        }
-        // Resort to locking all segments
-        for (int i = 0; i < segments.length; ++i)
-            segments[i].lock();
-        boolean found = false;
+        long previousSum = 0L;
+        int lockCount = 0;
         try {
-            for (int i = 0; i < segments.length; ++i) {
-                if (segments[i].containsValue(value)) {
-                    found = true;
-                    break;
+            for (int retries = -1; ; retries++) {
+                long sum = 0L;    // sum of modCounts
+                for (int j = 0; j < segments.length; j++) {
+                    Segment<K,V> segment;
+                    if (retries == RETRIES_BEFORE_LOCK) {
+                        segment = ensureSegment(j);
+                        segment.lock();
+                        lockCount++;
+                    } else {
+                        segment = segmentAt(segments, j);
+                        if (segment == null)
+                            continue;
+                    }
+                    HashEntry<K,V>[] tab = segment.table;
+                    if (tab != null) {
+                        for (int i = 0 ; i < tab.length; i++) {
+                            HashEntry<K,V> e;
+                            for (e = entryAt(tab, i); e != null; e = e.next) {
+                                V v = e.value;
+                                if (v != null && value.equals(v))
+                                    return true;
+                            }
+                        }
+                        sum += segment.modCount;
+                    }
                 }
+                if ((retries >= 0 && sum == previousSum) || lockCount > 0)
+                    return false;
+                previousSum = sum;
             }
         } finally {
-            for (int i = 0; i < segments.length; ++i)
-                segments[i].unlock();
+            for (int j = 0; j < lockCount; j++)
+                segments[j].unlock();
         }
-        return found;
     }
 
     /**
@@ -850,7 +985,7 @@ public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
      * full compatibility with class {@link java.util.Hashtable},
      * which supported this method prior to introduction of the
      * Java Collections framework.
-
+     *
      * @param  value a value to search for
      * @return <tt>true</tt> if and only if some key maps to the
      *         <tt>value</tt> argument in this table as
@@ -875,11 +1010,17 @@ public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
      *         <tt>null</tt> if there was no mapping for <tt>key</tt>
      * @throws NullPointerException if the specified key or value is null
      */
+    @SuppressWarnings("unchecked")
     public V put(K key, V value) {
+        Segment<K,V> s;
         if (value == null)
             throw new NullPointerException();
         int hash = hash(key.hashCode());
-        return segmentFor(hash).put(key, hash, value, false);
+        int j = (hash >>> segmentShift) & segmentMask;
+        if ((s = (Segment<K,V>)UNSAFE.getObject          // nonvolatile; recheck
+             (segments, (j << SSHIFT) + SBASE)) == null) //  in ensureSegment
+            s = ensureSegment(j);
+        return s.put(key, hash, value, false);
     }
 
     /**
@@ -889,11 +1030,17 @@ public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
      *         or <tt>null</tt> if there was no mapping for the key
      * @throws NullPointerException if the specified key or value is null
      */
+    @SuppressWarnings("unchecked")
     public V putIfAbsent(K key, V value) {
+        Segment<K,V> s;
         if (value == null)
             throw new NullPointerException();
         int hash = hash(key.hashCode());
-        return segmentFor(hash).put(key, hash, value, true);
+        int j = (hash >>> segmentShift) & segmentMask;
+        if ((s = (Segment<K,V>)UNSAFE.getObject
+             (segments, (j << SSHIFT) + SBASE)) == null)
+            s = ensureSegment(j);
+        return s.put(key, hash, value, true);
     }
 
     /**
@@ -919,7 +1066,8 @@ public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
      */
     public V remove(Object key) {
         int hash = hash(key.hashCode());
-        return segmentFor(hash).remove(key, hash, null);
+        Segment<K,V> s = segmentForHash(hash);
+        return s == null ? null : s.remove(key, hash, null);
     }
 
     /**
@@ -929,9 +1077,9 @@ public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
      */
     public boolean remove(Object key, Object value) {
         int hash = hash(key.hashCode());
-        if (value == null)
-            return false;
-        return segmentFor(hash).remove(key, hash, value) != null;
+        Segment<K,V> s;
+        return value != null && (s = segmentForHash(hash)) != null &&
+            s.remove(key, hash, value) != null;
     }
 
     /**
@@ -940,10 +1088,11 @@ public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
      * @throws NullPointerException if any of the arguments are null
      */
     public boolean replace(K key, V oldValue, V newValue) {
+        int hash = hash(key.hashCode());
         if (oldValue == null || newValue == null)
             throw new NullPointerException();
-        int hash = hash(key.hashCode());
-        return segmentFor(hash).replace(key, hash, oldValue, newValue);
+        Segment<K,V> s = segmentForHash(hash);
+        return s != null && s.replace(key, hash, oldValue, newValue);
     }
 
     /**
@@ -954,18 +1103,23 @@ public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
      * @throws NullPointerException if the specified key or value is null
      */
     public V replace(K key, V value) {
+        int hash = hash(key.hashCode());
         if (value == null)
             throw new NullPointerException();
-        int hash = hash(key.hashCode());
-        return segmentFor(hash).replace(key, hash, value);
+        Segment<K,V> s = segmentForHash(hash);
+        return s == null ? null : s.replace(key, hash, value);
     }
 
     /**
      * Removes all of the mappings from this map.
      */
     public void clear() {
-        for (int i = 0; i < segments.length; ++i)
-            segments[i].clear();
+        final Segment<K,V>[] segments = this.segments;
+        for (int j = 0; j < segments.length; ++j) {
+            Segment<K,V> s = segmentAt(segments, j);
+            if (s != null)
+                s.clear();
+        }
     }
 
     /**
@@ -1066,42 +1220,41 @@ public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
             advance();
         }
 
-        public boolean hasMoreElements() { return hasNext(); }
-
+        /**
+         * Sets nextEntry to first node of next non-empty table
+         * (in backwards order, to simplify checks).
+         */
         final void advance() {
-            if (nextEntry != null && (nextEntry = nextEntry.next) != null)
-                return;
-
-            while (nextTableIndex >= 0) {
-                if ( (nextEntry = currentTable[nextTableIndex--]) != null)
-                    return;
-            }
-
-            while (nextSegmentIndex >= 0) {
-                Segment<K,V> seg = segments[nextSegmentIndex--];
-                if (seg.count != 0) {
-                    currentTable = seg.table;
-                    for (int j = currentTable.length - 1; j >= 0; --j) {
-                        if ( (nextEntry = currentTable[j]) != null) {
-                            nextTableIndex = j - 1;
-                            return;
-                        }
-                    }
+            for (;;) {
+                if (nextTableIndex >= 0) {
+                    if ((nextEntry = entryAt(currentTable,
+                                             nextTableIndex--)) != null)
+                        break;
+                }
+                else if (nextSegmentIndex >= 0) {
+                    Segment<K,V> seg = segmentAt(segments, nextSegmentIndex--);
+                    if (seg != null && (currentTable = seg.table) != null)
+                        nextTableIndex = currentTable.length - 1;
                 }
+                else
+                    break;
             }
         }
 
-        public boolean hasNext() { return nextEntry != null; }
-
-        HashEntry<K,V> nextEntry() {
-            if (nextEntry == null)
+        final HashEntry<K,V> nextEntry() {
+            HashEntry<K,V> e = nextEntry;
+            if (e == null)
                 throw new NoSuchElementException();
-            lastReturned = nextEntry;
-            advance();
-            return lastReturned;
+            lastReturned = e; // cannot assign until after null check
+            if ((nextEntry = e.next) == null)
+                advance();
+            return e;
         }
 
-        public void remove() {
+        public final boolean hasNext() { return nextEntry != null; }
+        public final boolean hasMoreElements() { return nextEntry != null; }
+
+        public final void remove() {
             if (lastReturned == null)
                 throw new IllegalStateException();
             ConcurrentHashMap.this.remove(lastReturned.key);
@@ -1113,16 +1266,16 @@ public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
         extends HashIterator
         implements Iterator<K>, Enumeration<K>
     {
-        public K next()        { return super.nextEntry().key; }
-        public K nextElement() { return super.nextEntry().key; }
+        public final K next()        { return super.nextEntry().key; }
+        public final K nextElement() { return super.nextEntry().key; }
     }
 
     final class ValueIterator
         extends HashIterator
         implements Iterator<V>, Enumeration<V>
     {
-        public V next()        { return super.nextEntry().value; }
-        public V nextElement() { return super.nextEntry().value; }
+        public final V next()        { return super.nextEntry().value; }
+        public final V nextElement() { return super.nextEntry().value; }
     }
 
     /**
@@ -1137,7 +1290,7 @@ public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
         }
 
         /**
-         * Set our entry's value and write through to the map. The
+         * Sets our entry's value and writes through to the map. The
          * value to return is somewhat arbitrary here. Since a
          * WriteThroughEntry does not necessarily track asynchronous
          * changes, the most recent "previous" value could be
@@ -1233,24 +1386,30 @@ public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
     /* ---------------- Serialization Support -------------- */
 
     /**
-     * Save the state of the <tt>ConcurrentHashMap</tt> instance to a
-     * stream (i.e., serialize it).
+     * Saves the state of the <tt>ConcurrentHashMap</tt> instance to a
+     * stream (i.e., serializes it).
      * @param s the stream
      * @serialData
      * the key (Object) and value (Object)
      * for each key-value mapping, followed by a null pair.
      * The key-value mappings are emitted in no particular order.
      */
-    private void writeObject(java.io.ObjectOutputStream s) throws IOException {
+    private void writeObject(java.io.ObjectOutputStream s)
+            throws java.io.IOException {
+        // force all segments for serialization compatibility
+        for (int k = 0; k < segments.length; ++k)
+            ensureSegment(k);
         s.defaultWriteObject();
 
+        final Segment<K,V>[] segments = this.segments;
         for (int k = 0; k < segments.length; ++k) {
-            Segment<K,V> seg = segments[k];
+            Segment<K,V> seg = segmentAt(segments, k);
             seg.lock();
             try {
                 HashEntry<K,V>[] tab = seg.table;
                 for (int i = 0; i < tab.length; ++i) {
-                    for (HashEntry<K,V> e = tab[i]; e != null; e = e.next) {
+                    HashEntry<K,V> e;
+                    for (e = entryAt(tab, i); e != null; e = e.next) {
                         s.writeObject(e.key);
                         s.writeObject(e.value);
                     }
@@ -1264,17 +1423,24 @@ public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
     }
 
     /**
-     * Reconstitute the <tt>ConcurrentHashMap</tt> instance from a
-     * stream (i.e., deserialize it).
+     * Reconstitutes the <tt>ConcurrentHashMap</tt> instance from a
+     * stream (i.e., deserializes it).
      * @param s the stream
      */
+    @SuppressWarnings("unchecked")
     private void readObject(java.io.ObjectInputStream s)
-        throws IOException, ClassNotFoundException {
+            throws java.io.IOException, ClassNotFoundException {
         s.defaultReadObject();
 
-        // Initialize each segment to be minimally sized, and let grow.
-        for (int i = 0; i < segments.length; ++i) {
-            segments[i].setTable(new HashEntry[1]);
+        // Re-initialize segments to be minimally sized, and let grow.
+        int cap = MIN_SEGMENT_TABLE_CAPACITY;
+        final Segment<K,V>[] segments = this.segments;
+        for (int k = 0; k < segments.length; ++k) {
+            Segment<K,V> seg = segments[k];
+            if (seg != null) {
+                seg.threshold = (int)(cap * seg.loadFactor);
+                seg.table = (HashEntry<K,V>[]) new HashEntry<?,?>[cap];
+            }
         }
 
         // Read the keys and values, and put the mappings in the table
@@ -1286,4 +1452,31 @@ public class ConcurrentHashMap<K, V> extends AbstractMap<K, V>
             put(key, value);
         }
     }
+
+    // Unsafe mechanics
+    private static final sun.misc.Unsafe UNSAFE;
+    private static final long SBASE;
+    private static final int SSHIFT;
+    private static final long TBASE;
+    private static final int TSHIFT;
+
+    static {
+        int ss, ts;
+        try {
+            UNSAFE = sun.misc.Unsafe.getUnsafe();
+            Class<?> tc = HashEntry[].class;
+            Class<?> sc = Segment[].class;
+            TBASE = UNSAFE.arrayBaseOffset(tc);
+            SBASE = UNSAFE.arrayBaseOffset(sc);
+            ts = UNSAFE.arrayIndexScale(tc);
+            ss = UNSAFE.arrayIndexScale(sc);
+        } catch (Exception e) {
+            throw new Error(e);
+        }
+        if ((ss & (ss-1)) != 0 || (ts & (ts-1)) != 0)
+            throw new Error("data type scale not a power of two");
+        SSHIFT = 31 - Integer.numberOfLeadingZeros(ss);
+        TSHIFT = 31 - Integer.numberOfLeadingZeros(ts);
+    }
+
 }
diff --git a/luni/src/main/java/java/util/concurrent/ConcurrentLinkedDeque.java b/luni/src/main/java/java/util/concurrent/ConcurrentLinkedDeque.java
index 72c2e08..30adb36 100644
--- a/luni/src/main/java/java/util/concurrent/ConcurrentLinkedDeque.java
+++ b/luni/src/main/java/java/util/concurrent/ConcurrentLinkedDeque.java
@@ -1,7 +1,7 @@
 /*
  * Written by Doug Lea and Martin Buchholz with assistance from members of
  * JCP JSR-166 Expert Group and released to the public domain, as explained
- * at http://creativecommons.org/licenses/publicdomain
+ * at http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent;
@@ -34,10 +34,17 @@ import java.util.Queue;
  * ConcurrentModificationException}, and may proceed concurrently with
  * other operations.
  *
- * <p>Beware that, unlike in most collections, the {@code size}
- * method is <em>NOT</em> a constant-time operation. Because of the
+ * <p>Beware that, unlike in most collections, the {@code size} method
+ * is <em>NOT</em> a constant-time operation. Because of the
  * asynchronous nature of these deques, determining the current number
- * of elements requires a traversal of the elements.
+ * of elements requires a traversal of the elements, and so may report
+ * inaccurate results if this collection is modified during traversal.
+ * Additionally, the bulk operations {@code addAll},
+ * {@code removeAll}, {@code retainAll}, {@code containsAll},
+ * {@code equals}, and {@code toArray} are <em>not</em> guaranteed
+ * to be performed atomically. For example, an iterator operating
+ * concurrently with an {@code addAll} operation might view only some
+ * of the added elements.
  *
  * <p>This class and its iterator implement all of the <em>optional</em>
  * methods of the {@link Deque} and {@link Iterator} interfaces.
@@ -245,13 +252,6 @@ public class ConcurrentLinkedDeque<E>
 
     private static final Node<Object> PREV_TERMINATOR, NEXT_TERMINATOR;
 
-    static {
-        PREV_TERMINATOR = new Node<Object>(null);
-        PREV_TERMINATOR.next = PREV_TERMINATOR;
-        NEXT_TERMINATOR = new Node<Object>(null);
-        NEXT_TERMINATOR.prev = NEXT_TERMINATOR;
-    }
-
     @SuppressWarnings("unchecked")
     Node<E> prevTerminator() {
         return (Node<E>) PREV_TERMINATOR;
@@ -267,6 +267,9 @@ public class ConcurrentLinkedDeque<E>
         volatile E item;
         volatile Node<E> next;
 
+        Node() {  // default constructor for NEXT_TERMINATOR, PREV_TERMINATOR
+        }
+
         /**
          * Constructs a new node.  Uses relaxed write because item can
          * only be seen after publication via casNext or casPrev.
@@ -297,14 +300,25 @@ public class ConcurrentLinkedDeque<E>
 
         // Unsafe mechanics
 
-        private static final sun.misc.Unsafe UNSAFE =
-            sun.misc.Unsafe.getUnsafe();
-        private static final long prevOffset =
-            objectFieldOffset(UNSAFE, "prev", Node.class);
-        private static final long itemOffset =
-            objectFieldOffset(UNSAFE, "item", Node.class);
-        private static final long nextOffset =
-            objectFieldOffset(UNSAFE, "next", Node.class);
+        private static final sun.misc.Unsafe UNSAFE;
+        private static final long prevOffset;
+        private static final long itemOffset;
+        private static final long nextOffset;
+
+        static {
+            try {
+                UNSAFE = sun.misc.Unsafe.getUnsafe();
+                Class<?> k = Node.class;
+                prevOffset = UNSAFE.objectFieldOffset
+                    (k.getDeclaredField("prev"));
+                itemOffset = UNSAFE.objectFieldOffset
+                    (k.getDeclaredField("item"));
+                nextOffset = UNSAFE.objectFieldOffset
+                    (k.getDeclaredField("next"));
+            } catch (Exception e) {
+                throw new Error(e);
+            }
+        }
     }
 
     /**
@@ -1209,8 +1223,7 @@ public class ConcurrentLinkedDeque<E>
      * The following code can be used to dump the deque into a newly
      * allocated array of {@code String}:
      *
-     * <pre>
-     *     String[] y = x.toArray(new String[0]);</pre>
+     *  <pre> {@code String[] y = x.toArray(new String[0]);}</pre>
      *
      * Note that {@code toArray(new Object[0])} is identical in function to
      * {@code toArray()}.
@@ -1395,14 +1408,6 @@ public class ConcurrentLinkedDeque<E>
         initHeadTail(h, t);
     }
 
-    // Unsafe mechanics
-
-    private static final sun.misc.Unsafe UNSAFE =
-        sun.misc.Unsafe.getUnsafe();
-    private static final long headOffset =
-        objectFieldOffset(UNSAFE, "head", ConcurrentLinkedDeque.class);
-    private static final long tailOffset =
-        objectFieldOffset(UNSAFE, "tail", ConcurrentLinkedDeque.class);
 
     private boolean casHead(Node<E> cmp, Node<E> val) {
         return UNSAFE.compareAndSwapObject(this, headOffset, cmp, val);
@@ -1412,15 +1417,25 @@ public class ConcurrentLinkedDeque<E>
         return UNSAFE.compareAndSwapObject(this, tailOffset, cmp, val);
     }
 
-    static long objectFieldOffset(sun.misc.Unsafe UNSAFE,
-                                  String field, Class<?> klazz) {
+    // Unsafe mechanics
+
+    private static final sun.misc.Unsafe UNSAFE;
+    private static final long headOffset;
+    private static final long tailOffset;
+    static {
+        PREV_TERMINATOR = new Node<Object>();
+        PREV_TERMINATOR.next = PREV_TERMINATOR;
+        NEXT_TERMINATOR = new Node<Object>();
+        NEXT_TERMINATOR.prev = NEXT_TERMINATOR;
         try {
-            return UNSAFE.objectFieldOffset(klazz.getDeclaredField(field));
-        } catch (NoSuchFieldException e) {
-            // Convert Exception to corresponding Error
-            NoSuchFieldError error = new NoSuchFieldError(field);
-            error.initCause(e);
-            throw error;
+            UNSAFE = sun.misc.Unsafe.getUnsafe();
+            Class<?> k = ConcurrentLinkedDeque.class;
+            headOffset = UNSAFE.objectFieldOffset
+                (k.getDeclaredField("head"));
+            tailOffset = UNSAFE.objectFieldOffset
+                (k.getDeclaredField("tail"));
+        } catch (Exception e) {
+            throw new Error(e);
         }
     }
 }
diff --git a/luni/src/main/java/java/util/concurrent/ConcurrentLinkedQueue.java b/luni/src/main/java/java/util/concurrent/ConcurrentLinkedQueue.java
index 3ed0a7c..a0a26fd 100644
--- a/luni/src/main/java/java/util/concurrent/ConcurrentLinkedQueue.java
+++ b/luni/src/main/java/java/util/concurrent/ConcurrentLinkedQueue.java
@@ -1,7 +1,7 @@
 /*
  * Written by Doug Lea and Martin Buchholz with assistance from members of
  * JCP JSR-166 Expert Group and released to the public domain, as explained
- * at http://creativecommons.org/licenses/publicdomain
+ * at http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent;
@@ -47,7 +47,14 @@ import java.util.Queue;
  * <p>Beware that, unlike in most collections, the {@code size} method
  * is <em>NOT</em> a constant-time operation. Because of the
  * asynchronous nature of these queues, determining the current number
- * of elements requires a traversal of the elements.
+ * of elements requires a traversal of the elements, and so may report
+ * inaccurate results if this collection is modified during traversal.
+ * Additionally, the bulk operations {@code addAll},
+ * {@code removeAll}, {@code retainAll}, {@code containsAll},
+ * {@code equals}, and {@code toArray} are <em>not</em> guaranteed
+ * to be performed atomically. For example, an iterator operating
+ * concurrently with an {@code addAll} operation might view only some
+ * of the added elements.
  *
  * <p>This class and its iterator implement all of the <em>optional</em>
  * methods of the {@link Queue} and {@link Iterator} interfaces.
@@ -165,12 +172,22 @@ public class ConcurrentLinkedQueue<E> extends AbstractQueue<E>
 
         // Unsafe mechanics
 
-        private static final sun.misc.Unsafe UNSAFE =
-            sun.misc.Unsafe.getUnsafe();
-        private static final long nextOffset =
-            objectFieldOffset(UNSAFE, "next", Node.class);
-        private static final long itemOffset =
-            objectFieldOffset(UNSAFE, "item", Node.class);
+        private static final sun.misc.Unsafe UNSAFE;
+        private static final long itemOffset;
+        private static final long nextOffset;
+
+        static {
+            try {
+                UNSAFE = sun.misc.Unsafe.getUnsafe();
+                Class<?> k = Node.class;
+                itemOffset = UNSAFE.objectFieldOffset
+                    (k.getDeclaredField("item"));
+                nextOffset = UNSAFE.objectFieldOffset
+                    (k.getDeclaredField("next"));
+            } catch (Exception e) {
+                throw new Error(e);
+            }
+        }
     }
 
     /**
@@ -563,8 +580,7 @@ public class ConcurrentLinkedQueue<E> extends AbstractQueue<E>
      * The following code can be used to dump the queue into a newly
      * allocated array of {@code String}:
      *
-     * <pre>
-     *     String[] y = x.toArray(new String[0]);</pre>
+     *  <pre> {@code String[] y = x.toArray(new String[0]);}</pre>
      *
      * Note that {@code toArray(new Object[0])} is identical in function to
      * {@code toArray()}.
@@ -761,14 +777,6 @@ public class ConcurrentLinkedQueue<E> extends AbstractQueue<E>
             throw new NullPointerException();
     }
 
-    // Unsafe mechanics
-
-    private static final sun.misc.Unsafe UNSAFE = sun.misc.Unsafe.getUnsafe();
-    private static final long headOffset =
-        objectFieldOffset(UNSAFE, "head", ConcurrentLinkedQueue.class);
-    private static final long tailOffset =
-        objectFieldOffset(UNSAFE, "tail", ConcurrentLinkedQueue.class);
-
     private boolean casTail(Node<E> cmp, Node<E> val) {
         return UNSAFE.compareAndSwapObject(this, tailOffset, cmp, val);
     }
@@ -777,15 +785,21 @@ public class ConcurrentLinkedQueue<E> extends AbstractQueue<E>
         return UNSAFE.compareAndSwapObject(this, headOffset, cmp, val);
     }
 
-    static long objectFieldOffset(sun.misc.Unsafe UNSAFE,
-                                  String field, Class<?> klazz) {
+    // Unsafe mechanics
+
+    private static final sun.misc.Unsafe UNSAFE;
+    private static final long headOffset;
+    private static final long tailOffset;
+    static {
         try {
-            return UNSAFE.objectFieldOffset(klazz.getDeclaredField(field));
-        } catch (NoSuchFieldException e) {
-            // Convert Exception to corresponding Error
-            NoSuchFieldError error = new NoSuchFieldError(field);
-            error.initCause(e);
-            throw error;
+            UNSAFE = sun.misc.Unsafe.getUnsafe();
+            Class<?> k = ConcurrentLinkedQueue.class;
+            headOffset = UNSAFE.objectFieldOffset
+                (k.getDeclaredField("head"));
+            tailOffset = UNSAFE.objectFieldOffset
+                (k.getDeclaredField("tail"));
+        } catch (Exception e) {
+            throw new Error(e);
         }
     }
 }
diff --git a/luni/src/main/java/java/util/concurrent/ConcurrentMap.java b/luni/src/main/java/java/util/concurrent/ConcurrentMap.java
index 2daebc5..3405acf 100644
--- a/luni/src/main/java/java/util/concurrent/ConcurrentMap.java
+++ b/luni/src/main/java/java/util/concurrent/ConcurrentMap.java
@@ -1,7 +1,7 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent;
@@ -32,11 +32,12 @@ public interface ConcurrentMap<K, V> extends Map<K, V> {
      * If the specified key is not already associated
      * with a value, associate it with the given value.
      * This is equivalent to
-     * <pre>
-     *   if (!map.containsKey(key))
-     *       return map.put(key, value);
-     *   else
-     *       return map.get(key);</pre>
+     *  <pre> {@code
+     * if (!map.containsKey(key))
+     *   return map.put(key, value);
+     * else
+     *   return map.get(key);}</pre>
+     *
      * except that the action is performed atomically.
      *
      * @param key key with which the specified value is to be associated
@@ -61,11 +62,13 @@ public interface ConcurrentMap<K, V> extends Map<K, V> {
     /**
      * Removes the entry for a key only if currently mapped to a given value.
      * This is equivalent to
-     * <pre>
-     *   if (map.containsKey(key) &amp;&amp; map.get(key).equals(value)) {
-     *       map.remove(key);
-     *       return true;
-     *   } else return false;</pre>
+     *  <pre> {@code
+     * if (map.containsKey(key) && map.get(key).equals(value)) {
+     *   map.remove(key);
+     *   return true;
+     * } else
+     *   return false;}</pre>
+     *
      * except that the action is performed atomically.
      *
      * @param key key with which the specified value is associated
@@ -74,20 +77,24 @@ public interface ConcurrentMap<K, V> extends Map<K, V> {
      * @throws UnsupportedOperationException if the <tt>remove</tt> operation
      *         is not supported by this map
      * @throws ClassCastException if the key or value is of an inappropriate
-     *         type for this map (optional)
+     *         type for this map
+     *         (<a href="../Collection.html#optional-restrictions">optional</a>)
      * @throws NullPointerException if the specified key or value is null,
-     *         and this map does not permit null keys or values (optional)
+     *         and this map does not permit null keys or values
+     *         (<a href="../Collection.html#optional-restrictions">optional</a>)
      */
     boolean remove(Object key, Object value);
 
     /**
      * Replaces the entry for a key only if currently mapped to a given value.
      * This is equivalent to
-     * <pre>
-     *   if (map.containsKey(key) &amp;&amp; map.get(key).equals(oldValue)) {
-     *       map.put(key, newValue);
-     *       return true;
-     *   } else return false;</pre>
+     *  <pre> {@code
+     * if (map.containsKey(key) && map.get(key).equals(oldValue)) {
+     *   map.put(key, newValue);
+     *   return true;
+     * } else
+     *   return false;}</pre>
+     *
      * except that the action is performed atomically.
      *
      * @param key key with which the specified value is associated
@@ -108,10 +115,12 @@ public interface ConcurrentMap<K, V> extends Map<K, V> {
     /**
      * Replaces the entry for a key only if currently mapped to some value.
      * This is equivalent to
-     * <pre>
-     *   if (map.containsKey(key)) {
-     *       return map.put(key, value);
-     *   } else return null;</pre>
+     *  <pre> {@code
+     * if (map.containsKey(key)) {
+     *   return map.put(key, value);
+     * } else
+     *   return null;}</pre>
+     *
      * except that the action is performed atomically.
      *
      * @param key key with which the specified value is associated
diff --git a/luni/src/main/java/java/util/concurrent/ConcurrentNavigableMap.java b/luni/src/main/java/java/util/concurrent/ConcurrentNavigableMap.java
index 7d86afb..ea99886 100644
--- a/luni/src/main/java/java/util/concurrent/ConcurrentNavigableMap.java
+++ b/luni/src/main/java/java/util/concurrent/ConcurrentNavigableMap.java
@@ -1,20 +1,20 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent;
 import java.util.*;
 
+// BEGIN android-note
+// removed link to collections framework docs
+// END android-note
+
 /**
  * A {@link ConcurrentMap} supporting {@link NavigableMap} operations,
  * and recursively so for its navigable sub-maps.
  *
- * <p>This interface is a member of the
- * <a href="{@docRoot}/../technotes/guides/collections/index.html">
- * Java Collections Framework</a>.
- *
  * @author Doug Lea
  * @param <K> the type of keys maintained by this map
  * @param <V> the type of mapped values
diff --git a/luni/src/main/java/java/util/concurrent/ConcurrentSkipListMap.java b/luni/src/main/java/java/util/concurrent/ConcurrentSkipListMap.java
index fbd1083..d0d6f14 100644
--- a/luni/src/main/java/java/util/concurrent/ConcurrentSkipListMap.java
+++ b/luni/src/main/java/java/util/concurrent/ConcurrentSkipListMap.java
@@ -1,12 +1,15 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent;
 import java.util.*;
-import java.util.concurrent.atomic.*;
+
+// BEGIN android-note
+// removed link to collections framework docs
+// END android-note
 
 /**
  * A scalable concurrent {@link ConcurrentNavigableMap} implementation.
@@ -15,8 +18,8 @@ import java.util.concurrent.atomic.*;
  * creation time, depending on which constructor is used.
  *
  * <p>This class implements a concurrent variant of <a
- * href="http://www.cs.umd.edu/~pugh/">SkipLists</a> providing
- * expected average <i>log(n)</i> time cost for the
+ * href="http://en.wikipedia.org/wiki/Skip_list" target="_top">SkipLists</a>
+ * providing expected average <i>log(n)</i> time cost for the
  * <tt>containsKey</tt>, <tt>get</tt>, <tt>put</tt> and
  * <tt>remove</tt> operations and their variants.  Insertion, removal,
  * update, and access operations safely execute concurrently by
@@ -37,12 +40,13 @@ import java.util.concurrent.atomic.*;
  * <p>Beware that, unlike in most collections, the <tt>size</tt>
  * method is <em>not</em> a constant-time operation. Because of the
  * asynchronous nature of these maps, determining the current number
- * of elements requires a traversal of the elements.  Additionally,
- * the bulk operations <tt>putAll</tt>, <tt>equals</tt>, and
- * <tt>clear</tt> are <em>not</em> guaranteed to be performed
- * atomically. For example, an iterator operating concurrently with a
- * <tt>putAll</tt> operation might view only some of the added
- * elements.
+ * of elements requires a traversal of the elements, and so may report
+ * inaccurate results if this collection is modified during traversal.
+ * Additionally, the bulk operations <tt>putAll</tt>, <tt>equals</tt>,
+ * <tt>toArray</tt>, <tt>containsValue</tt>, and <tt>clear</tt> are
+ * <em>not</em> guaranteed to be performed atomically. For example, an
+ * iterator operating concurrently with a <tt>putAll</tt> operation
+ * might view only some of the added elements.
  *
  * <p>This class and its views and iterators implement all of the
  * <em>optional</em> methods of the {@link Map} and {@link Iterator}
@@ -51,10 +55,6 @@ import java.util.concurrent.atomic.*;
  * null return values cannot be reliably distinguished from the absence of
  * elements.
  *
- * <p>This class is a member of the
- * <a href="{@docRoot}/../technotes/guides/collections/index.html">
- * Java Collections Framework</a>.
- *
  * @author Doug Lea
  * @param <K> the type of keys maintained by this map
  * @param <V> the type of mapped values
@@ -322,11 +322,11 @@ public class ConcurrentSkipListMap<K,V> extends AbstractMap<K,V>
     private transient int randomSeed;
 
     /** Lazily initialized key set */
-    private transient KeySet keySet;
+    private transient KeySet<K> keySet;
     /** Lazily initialized entry set */
-    private transient EntrySet entrySet;
+    private transient EntrySet<K,V> entrySet;
     /** Lazily initialized values collection */
-    private transient Values values;
+    private transient Values<V> values;
     /** Lazily initialized descending key set */
     private transient ConcurrentNavigableMap<K,V> descendingMap;
 
@@ -478,13 +478,24 @@ public class ConcurrentSkipListMap<K,V> extends AbstractMap<K,V>
             return new AbstractMap.SimpleImmutableEntry<K,V>(key, v);
         }
 
-        // Unsafe mechanics
-        private static final sun.misc.Unsafe UNSAFE = sun.misc.Unsafe.getUnsafe();
-        private static final long valueOffset =
-            objectFieldOffset(UNSAFE, "value", Node.class);
-        private static final long nextOffset =
-            objectFieldOffset(UNSAFE, "next", Node.class);
+        // UNSAFE mechanics
 
+        private static final sun.misc.Unsafe UNSAFE;
+        private static final long valueOffset;
+        private static final long nextOffset;
+
+        static {
+            try {
+                UNSAFE = sun.misc.Unsafe.getUnsafe();
+                Class<?> k = Node.class;
+                valueOffset = UNSAFE.objectFieldOffset
+                    (k.getDeclaredField("value"));
+                nextOffset = UNSAFE.objectFieldOffset
+                    (k.getDeclaredField("next"));
+            } catch (Exception e) {
+                throw new Error(e);
+            }
+        }
     }
 
     /* ---------------- Indexing -------------- */
@@ -551,10 +562,18 @@ public class ConcurrentSkipListMap<K,V> extends AbstractMap<K,V>
         }
 
         // Unsafe mechanics
-        private static final sun.misc.Unsafe UNSAFE = sun.misc.Unsafe.getUnsafe();
-        private static final long rightOffset =
-            objectFieldOffset(UNSAFE, "right", Index.class);
-
+        private static final sun.misc.Unsafe UNSAFE;
+        private static final long rightOffset;
+        static {
+            try {
+                UNSAFE = sun.misc.Unsafe.getUnsafe();
+                Class<?> k = Index.class;
+                rightOffset = UNSAFE.objectFieldOffset
+                    (k.getDeclaredField("right"));
+            } catch (Exception e) {
+                throw new Error(e);
+            }
+        }
     }
 
     /* ---------------- Head nodes -------------- */
@@ -884,7 +903,7 @@ public class ConcurrentSkipListMap<K,V> extends AbstractMap<K,V>
              * direction.
              */
             level = max + 1;
-            Index<K,V>[] idxs = (Index<K,V>[])new Index[level+1];
+            Index<K,V>[] idxs = (Index<K,V>[])new Index<?,?>[level+1];
             Index<K,V> idx = null;
             for (int i = 1; i <= level; ++i)
                 idxs[i] = idx = new Index<K,V>(z, idx, null);
@@ -1387,16 +1406,16 @@ public class ConcurrentSkipListMap<K,V> extends AbstractMap<K,V>
      * @return a shallow copy of this map
      */
     public ConcurrentSkipListMap<K,V> clone() {
-        ConcurrentSkipListMap<K,V> clone = null;
         try {
-            clone = (ConcurrentSkipListMap<K,V>) super.clone();
+            @SuppressWarnings("unchecked")
+            ConcurrentSkipListMap<K,V> clone =
+                (ConcurrentSkipListMap<K,V>) super.clone();
+            clone.initialize();
+            clone.buildFromSorted(this);
+            return clone;
         } catch (CloneNotSupportedException e) {
             throw new InternalError();
         }
-
-        clone.initialize();
-        clone.buildFromSorted(this);
-        return clone;
     }
 
     /**
@@ -1458,7 +1477,7 @@ public class ConcurrentSkipListMap<K,V> extends AbstractMap<K,V>
     /* ---------------- Serialization -------------- */
 
     /**
-     * Save the state of this map to a stream.
+     * Saves the state of this map to a stream (that is, serializes it).
      *
      * @serialData The key (Object) and value (Object) for each
      * key-value mapping represented by the map, followed by
@@ -1483,7 +1502,9 @@ public class ConcurrentSkipListMap<K,V> extends AbstractMap<K,V>
     }
 
     /**
-     * Reconstitute the map from a stream.
+     * Reconstitutes the map from a stream (that is, deserializes it).
+     *
+     * @param s the stream
      */
     private void readObject(final java.io.ObjectInputStream s)
         throws java.io.IOException, ClassNotFoundException {
@@ -1613,7 +1634,9 @@ public class ConcurrentSkipListMap<K,V> extends AbstractMap<K,V>
     /**
      * Returns <tt>true</tt> if this map maps one or more keys to the
      * specified value.  This operation requires time linear in the
-     * map size.
+     * map size. Additionally, it is possible for the map to change
+     * during execution of this method, in which case the returned
+     * result may be inaccurate.
      *
      * @param value value whose presence in this map is to be tested
      * @return <tt>true</tt> if a mapping to <tt>value</tt> exists;
@@ -1703,14 +1726,14 @@ public class ConcurrentSkipListMap<K,V> extends AbstractMap<K,V>
      *
      * @return a navigable set view of the keys in this map
      */
-     public NavigableSet<K> keySet() {
-        KeySet ks = keySet;
-        return (ks != null) ? ks : (keySet = new KeySet(this));
+    public NavigableSet<K> keySet() {
+        KeySet<K> ks = keySet;
+        return (ks != null) ? ks : (keySet = new KeySet<K>(this));
     }
 
     public NavigableSet<K> navigableKeySet() {
-        KeySet ks = keySet;
-        return (ks != null) ? ks : (keySet = new KeySet(this));
+        KeySet<K> ks = keySet;
+        return (ks != null) ? ks : (keySet = new KeySet<K>(this));
     }
 
     /**
@@ -1732,8 +1755,8 @@ public class ConcurrentSkipListMap<K,V> extends AbstractMap<K,V>
      * reflect any modifications subsequent to construction.
      */
     public Collection<V> values() {
-        Values vs = values;
-        return (vs != null) ? vs : (values = new Values(this));
+        Values<V> vs = values;
+        return (vs != null) ? vs : (values = new Values<V>(this));
     }
 
     /**
@@ -1761,8 +1784,8 @@ public class ConcurrentSkipListMap<K,V> extends AbstractMap<K,V>
      *         sorted in ascending key order
      */
     public Set<Map.Entry<K,V>> entrySet() {
-        EntrySet es = entrySet;
-        return (es != null) ? es : (entrySet = new EntrySet(this));
+        EntrySet<K,V> es = entrySet;
+        return (es != null) ? es : (entrySet = new EntrySet<K,V>(this));
     }
 
     public ConcurrentNavigableMap<K,V> descendingMap() {
@@ -2253,8 +2276,8 @@ public class ConcurrentSkipListMap<K,V> extends AbstractMap<K,V>
 
     static final class KeySet<E>
             extends AbstractSet<E> implements NavigableSet<E> {
-        private final ConcurrentNavigableMap<E,Object> m;
-        KeySet(ConcurrentNavigableMap<E,Object> map) { m = map; }
+        private final ConcurrentNavigableMap<E,?> m;
+        KeySet(ConcurrentNavigableMap<E,?> map) { m = map; }
         public int size() { return m.size(); }
         public boolean isEmpty() { return m.isEmpty(); }
         public boolean contains(Object o) { return m.containsKey(o); }
@@ -2268,11 +2291,11 @@ public class ConcurrentSkipListMap<K,V> extends AbstractMap<K,V>
         public E first() { return m.firstKey(); }
         public E last() { return m.lastKey(); }
         public E pollFirst() {
-            Map.Entry<E,Object> e = m.pollFirstEntry();
+            Map.Entry<E,?> e = m.pollFirstEntry();
             return (e == null) ? null : e.getKey();
         }
         public E pollLast() {
-            Map.Entry<E,Object> e = m.pollLastEntry();
+            Map.Entry<E,?> e = m.pollLastEntry();
             return (e == null) ? null : e.getKey();
         }
         public Iterator<E> iterator() {
@@ -2323,20 +2346,20 @@ public class ConcurrentSkipListMap<K,V> extends AbstractMap<K,V>
             return tailSet(fromElement, true);
         }
         public NavigableSet<E> descendingSet() {
-            return new KeySet(m.descendingMap());
+            return new KeySet<E>(m.descendingMap());
         }
     }
 
     static final class Values<E> extends AbstractCollection<E> {
-        private final ConcurrentNavigableMap<Object, E> m;
-        Values(ConcurrentNavigableMap<Object, E> map) {
+        private final ConcurrentNavigableMap<?, E> m;
+        Values(ConcurrentNavigableMap<?, E> map) {
             m = map;
         }
         public Iterator<E> iterator() {
             if (m instanceof ConcurrentSkipListMap)
-                return ((ConcurrentSkipListMap<Object,E>)m).valueIterator();
+                return ((ConcurrentSkipListMap<?,E>)m).valueIterator();
             else
-                return ((SubMap<Object,E>)m).valueIterator();
+                return ((SubMap<?,E>)m).valueIterator();
         }
         public boolean isEmpty() {
             return m.isEmpty();
@@ -2370,14 +2393,14 @@ public class ConcurrentSkipListMap<K,V> extends AbstractMap<K,V>
         public boolean contains(Object o) {
             if (!(o instanceof Map.Entry))
                 return false;
-            Map.Entry<K1,V1> e = (Map.Entry<K1,V1>)o;
+            Map.Entry<?,?> e = (Map.Entry<?,?>)o;
             V1 v = m.get(e.getKey());
             return v != null && v.equals(e.getValue());
         }
         public boolean remove(Object o) {
             if (!(o instanceof Map.Entry))
                 return false;
-            Map.Entry<K1,V1> e = (Map.Entry<K1,V1>)o;
+            Map.Entry<?,?> e = (Map.Entry<?,?>)o;
             return m.remove(e.getKey(),
                             e.getValue());
         }
@@ -2517,9 +2540,9 @@ public class ConcurrentSkipListMap<K,V> extends AbstractMap<K,V>
             if (lo == null)
                 return m.findFirst();
             else if (loInclusive)
-                return m.findNear(lo, m.GT|m.EQ);
+                return m.findNear(lo, GT|EQ);
             else
-                return m.findNear(lo, m.GT);
+                return m.findNear(lo, GT);
         }
 
         /**
@@ -2530,9 +2553,9 @@ public class ConcurrentSkipListMap<K,V> extends AbstractMap<K,V>
             if (hi == null)
                 return m.findLast();
             else if (hiInclusive)
-                return m.findNear(hi, m.LT|m.EQ);
+                return m.findNear(hi, LT|EQ);
             else
-                return m.findNear(hi, m.LT);
+                return m.findNear(hi, LT);
         }
 
         /**
@@ -2614,15 +2637,15 @@ public class ConcurrentSkipListMap<K,V> extends AbstractMap<K,V>
          */
         private Map.Entry<K,V> getNearEntry(K key, int rel) {
             if (isDescending) { // adjust relation for direction
-                if ((rel & m.LT) == 0)
-                    rel |= m.LT;
+                if ((rel & LT) == 0)
+                    rel |= LT;
                 else
-                    rel &= ~m.LT;
+                    rel &= ~LT;
             }
             if (tooLow(key))
-                return ((rel & m.LT) != 0) ? null : lowestEntry();
+                return ((rel & LT) != 0) ? null : lowestEntry();
             if (tooHigh(key))
-                return ((rel & m.LT) != 0) ? highestEntry() : null;
+                return ((rel & LT) != 0) ? highestEntry() : null;
             for (;;) {
                 Node<K,V> n = m.findNear(key, rel);
                 if (n == null || !inBounds(n.key))
@@ -2637,13 +2660,13 @@ public class ConcurrentSkipListMap<K,V> extends AbstractMap<K,V>
         // Almost the same as getNearEntry, except for keys
         private K getNearKey(K key, int rel) {
             if (isDescending) { // adjust relation for direction
-                if ((rel & m.LT) == 0)
-                    rel |= m.LT;
+                if ((rel & LT) == 0)
+                    rel |= LT;
                 else
-                    rel &= ~m.LT;
+                    rel &= ~LT;
             }
             if (tooLow(key)) {
-                if ((rel & m.LT) == 0) {
+                if ((rel & LT) == 0) {
                     ConcurrentSkipListMap.Node<K,V> n = loNode();
                     if (isBeforeEnd(n))
                         return n.key;
@@ -2651,7 +2674,7 @@ public class ConcurrentSkipListMap<K,V> extends AbstractMap<K,V>
                 return null;
             }
             if (tooHigh(key)) {
-                if ((rel & m.LT) != 0) {
+                if ((rel & LT) != 0) {
                     ConcurrentSkipListMap.Node<K,V> n = hiNode();
                     if (n != null) {
                         K last = n.key;
@@ -2683,7 +2706,7 @@ public class ConcurrentSkipListMap<K,V> extends AbstractMap<K,V>
         public V get(Object key) {
             if (key == null) throw new NullPointerException();
             K k = (K)key;
-            return ((!inBounds(k)) ? null : m.get(k));
+            return (!inBounds(k)) ? null : m.get(k);
         }
 
         public V put(K key, V value) {
@@ -2850,35 +2873,35 @@ public class ConcurrentSkipListMap<K,V> extends AbstractMap<K,V>
         /* ----------------  Relational methods -------------- */
 
         public Map.Entry<K,V> ceilingEntry(K key) {
-            return getNearEntry(key, (m.GT|m.EQ));
+            return getNearEntry(key, GT|EQ);
         }
 
         public K ceilingKey(K key) {
-            return getNearKey(key, (m.GT|m.EQ));
+            return getNearKey(key, GT|EQ);
         }
 
         public Map.Entry<K,V> lowerEntry(K key) {
-            return getNearEntry(key, (m.LT));
+            return getNearEntry(key, LT);
         }
 
         public K lowerKey(K key) {
-            return getNearKey(key, (m.LT));
+            return getNearKey(key, LT);
         }
 
         public Map.Entry<K,V> floorEntry(K key) {
-            return getNearEntry(key, (m.LT|m.EQ));
+            return getNearEntry(key, LT|EQ);
         }
 
         public K floorKey(K key) {
-            return getNearKey(key, (m.LT|m.EQ));
+            return getNearKey(key, LT|EQ);
         }
 
         public Map.Entry<K,V> higherEntry(K key) {
-            return getNearEntry(key, (m.GT));
+            return getNearEntry(key, GT);
         }
 
         public K higherKey(K key) {
-            return getNearKey(key, (m.GT));
+            return getNearKey(key, GT);
         }
 
         public K firstKey() {
@@ -2909,22 +2932,22 @@ public class ConcurrentSkipListMap<K,V> extends AbstractMap<K,V>
 
         public NavigableSet<K> keySet() {
             KeySet<K> ks = keySetView;
-            return (ks != null) ? ks : (keySetView = new KeySet(this));
+            return (ks != null) ? ks : (keySetView = new KeySet<K>(this));
         }
 
         public NavigableSet<K> navigableKeySet() {
             KeySet<K> ks = keySetView;
-            return (ks != null) ? ks : (keySetView = new KeySet(this));
+            return (ks != null) ? ks : (keySetView = new KeySet<K>(this));
         }
 
         public Collection<V> values() {
             Collection<V> vs = valuesView;
-            return (vs != null) ? vs : (valuesView = new Values(this));
+            return (vs != null) ? vs : (valuesView = new Values<V>(this));
         }
 
         public Set<Map.Entry<K,V>> entrySet() {
             Set<Map.Entry<K,V>> es = entrySetView;
-            return (es != null) ? es : (entrySetView = new EntrySet(this));
+            return (es != null) ? es : (entrySetView = new EntrySet<K,V>(this));
         }
 
         public NavigableSet<K> descendingKeySet() {
@@ -3053,20 +3076,16 @@ public class ConcurrentSkipListMap<K,V> extends AbstractMap<K,V>
     }
 
     // Unsafe mechanics
-    private static final sun.misc.Unsafe UNSAFE = sun.misc.Unsafe.getUnsafe();
-    private static final long headOffset =
-        objectFieldOffset(UNSAFE, "head", ConcurrentSkipListMap.class);
-
-    static long objectFieldOffset(sun.misc.Unsafe UNSAFE,
-                                  String field, Class<?> klazz) {
+    private static final sun.misc.Unsafe UNSAFE;
+    private static final long headOffset;
+    static {
         try {
-            return UNSAFE.objectFieldOffset(klazz.getDeclaredField(field));
-        } catch (NoSuchFieldException e) {
-            // Convert Exception to corresponding Error
-            NoSuchFieldError error = new NoSuchFieldError(field);
-            error.initCause(e);
-            throw error;
+            UNSAFE = sun.misc.Unsafe.getUnsafe();
+            Class<?> k = ConcurrentSkipListMap.class;
+            headOffset = UNSAFE.objectFieldOffset
+                (k.getDeclaredField("head"));
+        } catch (Exception e) {
+            throw new Error(e);
         }
     }
-
 }
diff --git a/luni/src/main/java/java/util/concurrent/ConcurrentSkipListSet.java b/luni/src/main/java/java/util/concurrent/ConcurrentSkipListSet.java
index d24876f..71431a9 100644
--- a/luni/src/main/java/java/util/concurrent/ConcurrentSkipListSet.java
+++ b/luni/src/main/java/java/util/concurrent/ConcurrentSkipListSet.java
@@ -1,12 +1,15 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent;
 import java.util.*;
-import sun.misc.Unsafe;
+
+// BEGIN android-note
+// removed link to collections framework docs
+// END android-note
 
 /**
  * A scalable concurrent {@link NavigableSet} implementation based on
@@ -29,12 +32,14 @@ import sun.misc.Unsafe;
  * <p>Beware that, unlike in most collections, the <tt>size</tt>
  * method is <em>not</em> a constant-time operation. Because of the
  * asynchronous nature of these sets, determining the current number
- * of elements requires a traversal of the elements. Additionally, the
- * bulk operations <tt>addAll</tt>, <tt>removeAll</tt>,
- * <tt>retainAll</tt>, and <tt>containsAll</tt> are <em>not</em>
- * guaranteed to be performed atomically. For example, an iterator
- * operating concurrently with an <tt>addAll</tt> operation might view
- * only some of the added elements.
+ * of elements requires a traversal of the elements, and so may report
+ * inaccurate results if this collection is modified during traversal.
+ * Additionally, the bulk operations <tt>addAll</tt>,
+ * <tt>removeAll</tt>, <tt>retainAll</tt>, <tt>containsAll</tt>,
+ * <tt>equals</tt>, and <tt>toArray</tt> are <em>not</em> guaranteed
+ * to be performed atomically. For example, an iterator operating
+ * concurrently with an <tt>addAll</tt> operation might view only some
+ * of the added elements.
  *
  * <p>This class and its iterators implement all of the
  * <em>optional</em> methods of the {@link Set} and {@link Iterator}
@@ -43,10 +48,6 @@ import sun.misc.Unsafe;
  * because <tt>null</tt> arguments and return values cannot be reliably
  * distinguished from the absence of elements.
  *
- * <p>This class is a member of the
- * <a href="{@docRoot}/../technotes/guides/collections/index.html">
- * Java Collections Framework</a>.
- *
  * @author Doug Lea
  * @param <E> the type of elements maintained by this set
  * @since 1.6
@@ -127,15 +128,15 @@ public class ConcurrentSkipListSet<E>
      * @return a shallow copy of this set
      */
     public ConcurrentSkipListSet<E> clone() {
-        ConcurrentSkipListSet<E> clone = null;
         try {
-            clone = (ConcurrentSkipListSet<E>) super.clone();
-            clone.setMap(new ConcurrentSkipListMap(m));
+            @SuppressWarnings("unchecked")
+            ConcurrentSkipListSet<E> clone =
+                (ConcurrentSkipListSet<E>) super.clone();
+            clone.setMap(new ConcurrentSkipListMap<E,Object>(m));
+            return clone;
         } catch (CloneNotSupportedException e) {
             throw new InternalError();
         }
-
-        return clone;
     }
 
     /* ---------------- Set operations -------------- */
@@ -291,8 +292,8 @@ public class ConcurrentSkipListSet<E>
     public boolean removeAll(Collection<?> c) {
         // Override AbstractSet version to avoid unnecessary call to size()
         boolean modified = false;
-        for (Iterator<?> i = c.iterator(); i.hasNext(); )
-            if (remove(i.next()))
+        for (Object e : c)
+            if (remove(e))
                 modified = true;
         return modified;
     }
@@ -437,20 +438,24 @@ public class ConcurrentSkipListSet<E>
      * @return a reverse order view of this set
      */
     public NavigableSet<E> descendingSet() {
-        return new ConcurrentSkipListSet(m.descendingMap());
+        return new ConcurrentSkipListSet<E>(m.descendingMap());
     }
 
     // Support for resetting map in clone
-    private static final Unsafe unsafe = Unsafe.getUnsafe();
+    private void setMap(ConcurrentNavigableMap<E,Object> map) {
+        UNSAFE.putObjectVolatile(this, mapOffset, map);
+    }
+
+    private static final sun.misc.Unsafe UNSAFE;
     private static final long mapOffset;
     static {
         try {
-            mapOffset = unsafe.objectFieldOffset
-                (ConcurrentSkipListSet.class.getDeclaredField("m"));
-        } catch (Exception ex) { throw new Error(ex); }
-    }
-    private void setMap(ConcurrentNavigableMap<E,Object> map) {
-        unsafe.putObjectVolatile(this, mapOffset, map);
+            UNSAFE = sun.misc.Unsafe.getUnsafe();
+            Class<?> k = ConcurrentSkipListSet.class;
+            mapOffset = UNSAFE.objectFieldOffset
+                (k.getDeclaredField("m"));
+        } catch (Exception e) {
+            throw new Error(e);
+        }
     }
-
 }
diff --git a/luni/src/main/java/java/util/concurrent/CopyOnWriteArraySet.java b/luni/src/main/java/java/util/concurrent/CopyOnWriteArraySet.java
index 87419fc..1f37bc9 100644
--- a/luni/src/main/java/java/util/concurrent/CopyOnWriteArraySet.java
+++ b/luni/src/main/java/java/util/concurrent/CopyOnWriteArraySet.java
@@ -1,7 +1,7 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent;
@@ -160,8 +160,7 @@ public class CopyOnWriteArraySet<E> extends AbstractSet<E>
      * The following code can be used to dump the set into a newly allocated
      * array of <tt>String</tt>:
      *
-     * <pre>
-     *     String[] y = x.toArray(new String[0]);</pre>
+     *  <pre> {@code String[] y = x.toArray(new String[0]);}</pre>
      *
      * Note that <tt>toArray(new Object[0])</tt> is identical in function to
      * <tt>toArray()</tt>.
@@ -358,6 +357,6 @@ public class CopyOnWriteArraySet<E> extends AbstractSet<E>
      * Test for equality, coping with nulls.
      */
     private static boolean eq(Object o1, Object o2) {
-        return (o1 == null ? o2 == null : o1.equals(o2));
+        return (o1 == null) ? o2 == null : o1.equals(o2);
     }
 }
diff --git a/luni/src/main/java/java/util/concurrent/CountDownLatch.java b/luni/src/main/java/java/util/concurrent/CountDownLatch.java
index 1888279..e90badf 100644
--- a/luni/src/main/java/java/util/concurrent/CountDownLatch.java
+++ b/luni/src/main/java/java/util/concurrent/CountDownLatch.java
@@ -1,12 +1,11 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent;
 import java.util.concurrent.locks.*;
-import java.util.concurrent.atomic.*;
 
 /**
  * A synchronization aid that allows one or more threads to wait until
@@ -44,7 +43,7 @@ import java.util.concurrent.atomic.*;
  * until all workers have completed.
  * </ul>
  *
- * <pre>
+ *  <pre> {@code
  * class Driver { // ...
  *   void main() throws InterruptedException {
  *     CountDownLatch startSignal = new CountDownLatch(1);
@@ -76,9 +75,7 @@ import java.util.concurrent.atomic.*;
  *   }
  *
  *   void doWork() { ... }
- * }
- *
- * </pre>
+ * }}</pre>
  *
  * <p>Another typical usage would be to divide a problem into N parts,
  * describe each part with a Runnable that executes that portion and
@@ -87,7 +84,7 @@ import java.util.concurrent.atomic.*;
  * will be able to pass through await. (When threads must repeatedly
  * count down in this way, instead use a {@link CyclicBarrier}.)
  *
- * <pre>
+ *  <pre> {@code
  * class Driver2 { // ...
  *   void main() throws InterruptedException {
  *     CountDownLatch doneSignal = new CountDownLatch(N);
@@ -115,9 +112,7 @@ import java.util.concurrent.atomic.*;
  *   }
  *
  *   void doWork() { ... }
- * }
- *
- * </pre>
+ * }}</pre>
  *
  * <p>Memory consistency effects: Until the count reaches
  * zero, actions in a thread prior to calling
diff --git a/luni/src/main/java/java/util/concurrent/CyclicBarrier.java b/luni/src/main/java/java/util/concurrent/CyclicBarrier.java
index d5738c5..cf0b46e 100644
--- a/luni/src/main/java/java/util/concurrent/CyclicBarrier.java
+++ b/luni/src/main/java/java/util/concurrent/CyclicBarrier.java
@@ -1,7 +1,7 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent;
@@ -23,7 +23,8 @@ import java.util.concurrent.locks.*;
  *
  * <p><b>Sample usage:</b> Here is an example of
  *  using a barrier in a parallel decomposition design:
- * <pre>
+ *
+ *  <pre> {@code
  * class Solver {
  *   final int N;
  *   final float[][] data;
@@ -61,8 +62,8 @@ import java.util.concurrent.locks.*;
  *
  *     waitUntilDone();
  *   }
- * }
- * </pre>
+ * }}</pre>
+ *
  * Here, each worker thread processes a row of the matrix then waits at the
  * barrier until all rows have been processed. When all rows are processed
  * the supplied {@link Runnable} barrier action is executed and merges the
@@ -76,9 +77,10 @@ import java.util.concurrent.locks.*;
  * {@link #await} returns the arrival index of that thread at the barrier.
  * You can then choose which thread should execute the barrier action, for
  * example:
- * <pre>  if (barrier.await() == 0) {
- *     // log the completion of this iteration
- *   }</pre>
+ *  <pre> {@code
+ * if (barrier.await() == 0) {
+ *   // log the completion of this iteration
+ * }}</pre>
  *
  * <p>The <tt>CyclicBarrier</tt> uses an all-or-none breakage model
  * for failed synchronization attempts: If a thread leaves a barrier
@@ -175,21 +177,21 @@ public class CyclicBarrier {
                 throw new InterruptedException();
             }
 
-           int index = --count;
-           if (index == 0) {  // tripped
-               boolean ranAction = false;
-               try {
-                   final Runnable command = barrierCommand;
-                   if (command != null)
-                       command.run();
-                   ranAction = true;
-                   nextGeneration();
-                   return 0;
-               } finally {
-                   if (!ranAction)
-                       breakBarrier();
-               }
-           }
+            int index = --count;
+            if (index == 0) {  // tripped
+                boolean ranAction = false;
+                try {
+                    final Runnable command = barrierCommand;
+                    if (command != null)
+                        command.run();
+                    ranAction = true;
+                    nextGeneration();
+                    return 0;
+                } finally {
+                    if (!ranAction)
+                        breakBarrier();
+                }
+            }
 
             // loop until tripped, broken, interrupted, or timed out
             for (;;) {
@@ -325,7 +327,7 @@ public class CyclicBarrier {
         try {
             return dowait(false, 0L);
         } catch (TimeoutException toe) {
-            throw new Error(toe); // cannot happen;
+            throw new Error(toe); // cannot happen
         }
     }
 
diff --git a/luni/src/main/java/java/util/concurrent/DelayQueue.java b/luni/src/main/java/java/util/concurrent/DelayQueue.java
index 8c44e82..52028cb 100644
--- a/luni/src/main/java/java/util/concurrent/DelayQueue.java
+++ b/luni/src/main/java/java/util/concurrent/DelayQueue.java
@@ -1,12 +1,14 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 
 package java.util.concurrent;
-import java.util.concurrent.locks.*;
+import static java.util.concurrent.TimeUnit.NANOSECONDS;
+import java.util.concurrent.locks.Condition;
+import java.util.concurrent.locks.ReentrantLock;
 import java.util.*;
 
 // BEGIN android-note
@@ -29,7 +31,9 @@ import java.util.*;
  *
  * <p>This class and its iterator implement all of the
  * <em>optional</em> methods of the {@link Collection} and {@link
- * Iterator} interfaces.
+ * Iterator} interfaces.  The Iterator provided in method {@link
+ * #iterator()} is <em>not</em> guaranteed to traverse the elements of
+ * the DelayQueue in any particular order.
  *
  * @since 1.5
  * @author Doug Lea
@@ -154,7 +158,7 @@ public class DelayQueue<E extends Delayed> extends AbstractQueue<E>
         lock.lock();
         try {
             E first = q.peek();
-            if (first == null || first.getDelay(TimeUnit.NANOSECONDS) > 0)
+            if (first == null || first.getDelay(NANOSECONDS) > 0)
                 return null;
             else
                 return q.poll();
@@ -179,7 +183,7 @@ public class DelayQueue<E extends Delayed> extends AbstractQueue<E>
                 if (first == null)
                     available.await();
                 else {
-                    long delay = first.getDelay(TimeUnit.NANOSECONDS);
+                    long delay = first.getDelay(NANOSECONDS);
                     if (delay <= 0)
                         return q.poll();
                     else if (leader != null)
@@ -226,7 +230,7 @@ public class DelayQueue<E extends Delayed> extends AbstractQueue<E>
                     else
                         nanos = available.awaitNanos(nanos);
                 } else {
-                    long delay = first.getDelay(TimeUnit.NANOSECONDS);
+                    long delay = first.getDelay(NANOSECONDS);
                     if (delay <= 0)
                         return q.poll();
                     if (nanos <= 0)
@@ -284,6 +288,17 @@ public class DelayQueue<E extends Delayed> extends AbstractQueue<E>
     }
 
     /**
+     * Return first element only if it is expired.
+     * Used only by drainTo.  Call only when holding lock.
+     */
+    private E peekExpired() {
+        // assert lock.isHeldByCurrentThread();
+        E first = q.peek();
+        return (first == null || first.getDelay(NANOSECONDS) > 0) ?
+            null : first;
+    }
+
+    /**
      * @throws UnsupportedOperationException {@inheritDoc}
      * @throws ClassCastException            {@inheritDoc}
      * @throws NullPointerException          {@inheritDoc}
@@ -298,11 +313,9 @@ public class DelayQueue<E extends Delayed> extends AbstractQueue<E>
         lock.lock();
         try {
             int n = 0;
-            for (;;) {
-                E first = q.peek();
-                if (first == null || first.getDelay(TimeUnit.NANOSECONDS) > 0)
-                    break;
-                c.add(q.poll());
+            for (E e; (e = peekExpired()) != null;) {
+                c.add(e);       // In this order, in case add() throws.
+                q.poll();
                 ++n;
             }
             return n;
@@ -328,11 +341,9 @@ public class DelayQueue<E extends Delayed> extends AbstractQueue<E>
         lock.lock();
         try {
             int n = 0;
-            while (n < maxElements) {
-                E first = q.peek();
-                if (first == null || first.getDelay(TimeUnit.NANOSECONDS) > 0)
-                    break;
-                c.add(q.poll());
+            for (E e; n < maxElements && (e = peekExpired()) != null;) {
+                c.add(e);       // In this order, in case add() throws.
+                q.poll();
                 ++n;
             }
             return n;
@@ -411,8 +422,7 @@ public class DelayQueue<E extends Delayed> extends AbstractQueue<E>
      * <p>The following code can be used to dump a delay queue into a newly
      * allocated array of <tt>Delayed</tt>:
      *
-     * <pre>
-     *     Delayed[] a = q.toArray(new Delayed[0]);</pre>
+     * <pre> {@code Delayed[] a = q.toArray(new Delayed[0]);}</pre>
      *
      * Note that <tt>toArray(new Object[0])</tt> is identical in function to
      * <tt>toArray()</tt>.
@@ -451,6 +461,24 @@ public class DelayQueue<E extends Delayed> extends AbstractQueue<E>
     }
 
     /**
+     * Identity-based version for use in Itr.remove
+     */
+    void removeEQ(Object o) {
+        final ReentrantLock lock = this.lock;
+        lock.lock();
+        try {
+            for (Iterator<E> it = q.iterator(); it.hasNext(); ) {
+                if (o == it.next()) {
+                    it.remove();
+                    break;
+                }
+            }
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    /**
      * Returns an iterator over all the elements (both expired and
      * unexpired) in this queue. The iterator does not return the
      * elements in any particular order.
@@ -473,7 +501,7 @@ public class DelayQueue<E extends Delayed> extends AbstractQueue<E>
      */
     private class Itr implements Iterator<E> {
         final Object[] array; // Array of all elements
-        int cursor;           // index of next element to return;
+        int cursor;           // index of next element to return
         int lastRet;          // index of last element, or -1 if no such
 
         Itr(Object[] array) {
@@ -496,21 +524,8 @@ public class DelayQueue<E extends Delayed> extends AbstractQueue<E>
         public void remove() {
             if (lastRet < 0)
                 throw new IllegalStateException();
-            Object x = array[lastRet];
+            removeEQ(array[lastRet]);
             lastRet = -1;
-            // Traverse underlying queue to find == element,
-            // not just a .equals element.
-            lock.lock();
-            try {
-                for (Iterator it = q.iterator(); it.hasNext(); ) {
-                    if (it.next() == x) {
-                        it.remove();
-                        return;
-                    }
-                }
-            } finally {
-                lock.unlock();
-            }
         }
     }
 
diff --git a/luni/src/main/java/java/util/concurrent/Delayed.java b/luni/src/main/java/java/util/concurrent/Delayed.java
index b1ff4ee..39d927c 100644
--- a/luni/src/main/java/java/util/concurrent/Delayed.java
+++ b/luni/src/main/java/java/util/concurrent/Delayed.java
@@ -1,13 +1,11 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent;
 
-import java.util.*;
-
 /**
  * A mix-in style interface for marking objects that should be
  * acted upon after a given delay.
diff --git a/luni/src/main/java/java/util/concurrent/Exchanger.java b/luni/src/main/java/java/util/concurrent/Exchanger.java
index 3c230be..6069dce 100644
--- a/luni/src/main/java/java/util/concurrent/Exchanger.java
+++ b/luni/src/main/java/java/util/concurrent/Exchanger.java
@@ -2,7 +2,7 @@
  * Written by Doug Lea, Bill Scherer, and Michael Scott with
  * assistance from members of JCP JSR-166 Expert Group and released to
  * the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent;
@@ -23,7 +23,7 @@ import java.util.concurrent.locks.LockSupport;
  * to swap buffers between threads so that the thread filling the
  * buffer gets a freshly emptied one when it needs it, handing off the
  * filled one to the thread emptying the buffer.
- * <pre>{@code
+ *  <pre> {@code
  * class FillAndEmpty {
  *   Exchanger<DataBuffer> exchanger = new Exchanger<DataBuffer>();
  *   DataBuffer initialEmptyBuffer = ... a made-up type
@@ -59,8 +59,7 @@ import java.util.concurrent.locks.LockSupport;
  *     new Thread(new FillingLoop()).start();
  *     new Thread(new EmptyingLoop()).start();
  *   }
- * }
- * }</pre>
+ * }}</pre>
  *
  * <p>Memory consistency effects: For each pair of threads that
  * successfully exchange objects via an {@code Exchanger}, actions
@@ -135,8 +134,8 @@ public class Exchanger<V> {
      * races between two threads or thread pre-emptions occurring
      * between reading and CASing.  Also, very transient peak
      * contention can be much higher than the average sustainable
-     * levels.  The max limit is decreased on average 50% of the times
-     * that a non-slot-zero wait elapses without being fulfilled.
+     * levels.  An attempt to decrease the max limit is usually made
+     * when a non-slot-zero wait elapses without being fulfilled.
      * Threads experiencing elapsed waits move closer to zero, so
      * eventually find existing (or future) threads even if the table
      * has been shrunk due to inactivity.  The chosen mechanics and
@@ -275,7 +274,9 @@ public class Exchanger<V> {
      * extra space.
      */
     private static final class Slot extends AtomicReference<Object> {
-        // Improve likelihood of isolation on <= 64 byte cache lines
+        // Improve likelihood of isolation on <= 128 byte cache lines.
+        // We used to target 64 byte cache lines, but some x86s (including
+        // i7 under some BIOSes) actually use 128 byte cache lines.
         long q0, q1, q2, q3, q4, q5, q6, q7, q8, q9, qa, qb, qc, qd, qe;
     }
 
diff --git a/luni/src/main/java/java/util/concurrent/ExecutionException.java b/luni/src/main/java/java/util/concurrent/ExecutionException.java
index bc561e5..9bb8dee 100644
--- a/luni/src/main/java/java/util/concurrent/ExecutionException.java
+++ b/luni/src/main/java/java/util/concurrent/ExecutionException.java
@@ -1,7 +1,7 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent;
@@ -50,11 +50,9 @@ public class ExecutionException extends Exception {
 
     /**
      * Constructs an <tt>ExecutionException</tt> with the specified cause.
-     * The detail message is set to:
-     * <pre>
-     *  (cause == null ? null : cause.toString())</pre>
-     * (which typically contains the class and detail message of
-     * <tt>cause</tt>).
+     * The detail message is set to {@code (cause == null ? null :
+     * cause.toString())} (which typically contains the class and
+     * detail message of <tt>cause</tt>).
      *
      * @param  cause the cause (which is saved for later retrieval by the
      *         {@link #getCause()} method)
diff --git a/luni/src/main/java/java/util/concurrent/Executor.java b/luni/src/main/java/java/util/concurrent/Executor.java
index fbc4e6f..831bf46 100644
--- a/luni/src/main/java/java/util/concurrent/Executor.java
+++ b/luni/src/main/java/java/util/concurrent/Executor.java
@@ -1,7 +1,7 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent;
@@ -27,23 +27,23 @@ package java.util.concurrent;
  * executor can run the submitted task immediately in the caller's
  * thread:
  *
- * <pre>
+ *  <pre> {@code
  * class DirectExecutor implements Executor {
- *     public void execute(Runnable r) {
- *         r.run();
- *     }
- * }</pre>
+ *   public void execute(Runnable r) {
+ *     r.run();
+ *   }
+ * }}</pre>
  *
  * More typically, tasks are executed in some thread other
  * than the caller's thread.  The executor below spawns a new thread
  * for each task.
  *
- * <pre>
+ *  <pre> {@code
  * class ThreadPerTaskExecutor implements Executor {
- *     public void execute(Runnable r) {
- *         new Thread(r).start();
- *     }
- * }</pre>
+ *   public void execute(Runnable r) {
+ *     new Thread(r).start();
+ *   }
+ * }}</pre>
  *
  * Many <tt>Executor</tt> implementations impose some sort of
  * limitation on how and when tasks are scheduled.  The executor below
diff --git a/luni/src/main/java/java/util/concurrent/ExecutorCompletionService.java b/luni/src/main/java/java/util/concurrent/ExecutorCompletionService.java
index b41955d..c0d6006 100644
--- a/luni/src/main/java/java/util/concurrent/ExecutorCompletionService.java
+++ b/luni/src/main/java/java/util/concurrent/ExecutorCompletionService.java
@@ -1,7 +1,7 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent;
diff --git a/luni/src/main/java/java/util/concurrent/ExecutorService.java b/luni/src/main/java/java/util/concurrent/ExecutorService.java
index 89688e4..a33ceec 100644
--- a/luni/src/main/java/java/util/concurrent/ExecutorService.java
+++ b/luni/src/main/java/java/util/concurrent/ExecutorService.java
@@ -1,14 +1,16 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent;
 import java.util.List;
 import java.util.Collection;
-import java.security.PrivilegedAction;
-import java.security.PrivilegedExceptionAction;
+
+// BEGIN android-note
+// removed security manager docs
+// END android-note
 
 /**
  * An {@link Executor} that provides methods to manage termination and
@@ -44,7 +46,7 @@ import java.security.PrivilegedExceptionAction;
  * pool service incoming requests. It uses the preconfigured {@link
  * Executors#newFixedThreadPool} factory method:
  *
- * <pre>
+ *  <pre> {@code
  * class NetworkService implements Runnable {
  *   private final ServerSocket serverSocket;
  *   private final ExecutorService pool;
@@ -72,14 +74,13 @@ import java.security.PrivilegedExceptionAction;
  *   public void run() {
  *     // read and service request on socket
  *   }
- * }
- * </pre>
+ * }}</pre>
  *
  * The following method shuts down an <tt>ExecutorService</tt> in two phases,
  * first by calling <tt>shutdown</tt> to reject incoming tasks, and then
  * calling <tt>shutdownNow</tt>, if necessary, to cancel any lingering tasks:
  *
- * <pre>
+ *  <pre> {@code
  * void shutdownAndAwaitTermination(ExecutorService pool) {
  *   pool.shutdown(); // Disable new tasks from being submitted
  *   try {
@@ -96,8 +97,7 @@ import java.security.PrivilegedExceptionAction;
  *     // Preserve interrupt status
  *     Thread.currentThread().interrupt();
  *   }
- * }
- * </pre>
+ * }}</pre>
  *
  * <p>Memory consistency effects: Actions in a thread prior to the
  * submission of a {@code Runnable} or {@code Callable} task to an
diff --git a/luni/src/main/java/java/util/concurrent/Executors.java b/luni/src/main/java/java/util/concurrent/Executors.java
index e42b0cc..b4f03ba 100644
--- a/luni/src/main/java/java/util/concurrent/Executors.java
+++ b/luni/src/main/java/java/util/concurrent/Executors.java
@@ -1,7 +1,7 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent;
@@ -12,9 +12,10 @@ import java.security.AccessController;
 import java.security.PrivilegedAction;
 import java.security.PrivilegedExceptionAction;
 import java.security.PrivilegedActionException;
-import java.security.AccessControlException;
-// import sun.security.util.SecurityConstants; // android-removed
 
+// BEGIN android-note
+// removed security manager docs
+// END android-note
 /**
  * Factory and utility methods for {@link Executor}, {@link
  * ExecutorService}, {@link ScheduledExecutorService}, {@link
@@ -271,10 +272,7 @@ public class Executors {
     /**
      * Returns a default thread factory used to create new threads.
      * This factory creates all new threads used by an Executor in the
-     * same {@link ThreadGroup}. If there is a {@link
-     * java.lang.SecurityManager}, it uses the group of {@link
-     * System#getSecurityManager}, else the group of the thread
-     * invoking this <tt>defaultThreadFactory</tt> method. Each new
+     * same {@link ThreadGroup}. Each new
      * thread is created as a non-daemon thread with priority set to
      * the smaller of <tt>Thread.NORM_PRIORITY</tt> and the maximum
      * priority permitted in the thread group.  New threads have names
@@ -289,36 +287,7 @@ public class Executors {
     }
 
     /**
-     * Returns a thread factory used to create new threads that
-     * have the same permissions as the current thread.
-     * This factory creates threads with the same settings as {@link
-     * Executors#defaultThreadFactory}, additionally setting the
-     * AccessControlContext and contextClassLoader of new threads to
-     * be the same as the thread invoking this
-     * <tt>privilegedThreadFactory</tt> method.  A new
-     * <tt>privilegedThreadFactory</tt> can be created within an
-     * {@link AccessController#doPrivileged} action setting the
-     * current thread's access control context to create threads with
-     * the selected permission settings holding within that action.
-     *
-     * <p> Note that while tasks running within such threads will have
-     * the same access control and class loader settings as the
-     * current thread, they need not have the same {@link
-     * java.lang.ThreadLocal} or {@link
-     * java.lang.InheritableThreadLocal} values. If necessary,
-     * particular values of thread locals can be set or reset before
-     * any task runs in {@link ThreadPoolExecutor} subclasses using
-     * {@link ThreadPoolExecutor#beforeExecute}. Also, if it is
-     * necessary to initialize worker threads to have the same
-     * InheritableThreadLocal settings as some other designated
-     * thread, you can create a custom ThreadFactory in which that
-     * thread waits for and services requests to create others that
-     * will inherit its values.
-     *
-     * @return a thread factory
-     * @throws AccessControlException if the current access control
-     * context does not have permission to both get and set context
-     * class loader.
+     * Legacy security code; do not use.
      */
     public static ThreadFactory privilegedThreadFactory() {
         return new PrivilegedThreadFactory();
@@ -383,18 +352,7 @@ public class Executors {
     }
 
     /**
-     * Returns a {@link Callable} object that will, when
-     * called, execute the given <tt>callable</tt> under the current
-     * access control context. This method should normally be
-     * invoked within an {@link AccessController#doPrivileged} action
-     * to create callables that will, if possible, execute under the
-     * selected permission settings holding within that action; or if
-     * not possible, throw an associated {@link
-     * AccessControlException}.
-     * @param callable the underlying task
-     * @return a callable object
-     * @throws NullPointerException if callable null
-     *
+     * Legacy security code; do not use.
      */
     public static <T> Callable<T> privilegedCallable(Callable<T> callable) {
         if (callable == null)
@@ -405,20 +363,10 @@ public class Executors {
     /**
      * Returns a {@link Callable} object that will, when
      * called, execute the given <tt>callable</tt> under the current
-     * access control context, with the current context class loader
-     * as the context class loader. This method should normally be
-     * invoked within an {@link AccessController#doPrivileged} action
-     * to create callables that will, if possible, execute under the
-     * selected permission settings holding within that action; or if
-     * not possible, throw an associated {@link
-     * AccessControlException}.
-     * @param callable the underlying task
+     * with the current context class loader as the context class loader.
      *
      * @return a callable object
      * @throws NullPointerException if callable null
-     * @throws AccessControlException if the current access control
-     * context does not have permission to both set and get context
-     * class loader.
      */
     public static <T> Callable<T> privilegedCallableUsingCurrentClassLoader(Callable<T> callable) {
         if (callable == null)
@@ -480,17 +428,19 @@ public class Executors {
         private final ClassLoader ccl;
 
         PrivilegedCallableUsingCurrentClassLoader(Callable<T> task) {
-            SecurityManager sm = System.getSecurityManager();
-            if (sm != null) {
-                // Calls to getContextClassLoader from this class
-                // never trigger a security check, but we check
-                // whether our callers have this permission anyways.
-                sm.checkPermission(new RuntimePermission("getContextClassLoader")); // android-changed
-
-                // Whether setContextClassLoader turns out to be necessary
-                // or not, we fail fast if permission is not available.
-                sm.checkPermission(new RuntimePermission("setContextClassLoader"));
-            }
+            // BEGIN android-removed
+            // SecurityManager sm = System.getSecurityManager();
+            // if (sm != null) {
+            //     // Calls to getContextClassLoader from this class
+            //     // never trigger a security check, but we check
+            //     // whether our callers have this permission anyways.
+            //     sm.checkPermission(SecurityConstants.GET_CLASSLOADER_PERMISSION);
+            //
+            //     // Whether setContextClassLoader turns out to be necessary
+            //     // or not, we fail fast if permission is not available.
+            //     sm.checkPermission(new RuntimePermission("setContextClassLoader"));
+            // }
+            // END android-removed
             this.task = task;
             this.acc = AccessController.getContext();
             this.ccl = Thread.currentThread().getContextClassLoader();
@@ -561,16 +511,18 @@ public class Executors {
 
         PrivilegedThreadFactory() {
             super();
-            SecurityManager sm = System.getSecurityManager();
-            if (sm != null) {
-                // Calls to getContextClassLoader from this class
-                // never trigger a security check, but we check
-                // whether our callers have this permission anyways.
-                sm.checkPermission(new RuntimePermission("getContextClassLoader")); // android-changed
-
-                // Fail fast
-                sm.checkPermission(new RuntimePermission("setContextClassLoader"));
-            }
+            // BEGIN android-removed
+            // SecurityManager sm = System.getSecurityManager();
+            // if (sm != null) {
+            //     // Calls to getContextClassLoader from this class
+            //     // never trigger a security check, but we check
+            //     // whether our callers have this permission anyways.
+            //     sm.checkPermission(SecurityConstants.GET_CLASSLOADER_PERMISSION);
+            //
+            //     // Fail fast
+            //     sm.checkPermission(new RuntimePermission("setContextClassLoader"));
+            // }
+            // END android-removed
             this.acc = AccessController.getContext();
             this.ccl = Thread.currentThread().getContextClassLoader();
         }
diff --git a/luni/src/main/java/java/util/concurrent/ForkJoinPool.java b/luni/src/main/java/java/util/concurrent/ForkJoinPool.java
new file mode 100644
index 0000000..ee15ac8
--- /dev/null
+++ b/luni/src/main/java/java/util/concurrent/ForkJoinPool.java
@@ -0,0 +1,2127 @@
+/*
+ * Written by Doug Lea with assistance from members of JCP JSR-166
+ * Expert Group and released to the public domain, as explained at
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+package java.util.concurrent;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.AbstractExecutorService;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Future;
+import java.util.concurrent.RejectedExecutionException;
+import java.util.concurrent.RunnableFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.locks.LockSupport;
+import java.util.concurrent.locks.ReentrantLock;
+import java.util.concurrent.locks.Condition;
+import libcore.util.SneakyThrow;
+
+// BEGIN android-note
+// removed security manager docs
+// END android-note
+
+/**
+ * An {@link ExecutorService} for running {@link ForkJoinTask}s.
+ * A {@code ForkJoinPool} provides the entry point for submissions
+ * from non-{@code ForkJoinTask} clients, as well as management and
+ * monitoring operations.
+ *
+ * <p>A {@code ForkJoinPool} differs from other kinds of {@link
+ * ExecutorService} mainly by virtue of employing
+ * <em>work-stealing</em>: all threads in the pool attempt to find and
+ * execute subtasks created by other active tasks (eventually blocking
+ * waiting for work if none exist). This enables efficient processing
+ * when most tasks spawn other subtasks (as do most {@code
+ * ForkJoinTask}s). When setting <em>asyncMode</em> to true in
+ * constructors, {@code ForkJoinPool}s may also be appropriate for use
+ * with event-style tasks that are never joined.
+ *
+ * <p>A {@code ForkJoinPool} is constructed with a given target
+ * parallelism level; by default, equal to the number of available
+ * processors. The pool attempts to maintain enough active (or
+ * available) threads by dynamically adding, suspending, or resuming
+ * internal worker threads, even if some tasks are stalled waiting to
+ * join others. However, no such adjustments are guaranteed in the
+ * face of blocked IO or other unmanaged synchronization. The nested
+ * {@link ManagedBlocker} interface enables extension of the kinds of
+ * synchronization accommodated.
+ *
+ * <p>In addition to execution and lifecycle control methods, this
+ * class provides status check methods (for example
+ * {@link #getStealCount}) that are intended to aid in developing,
+ * tuning, and monitoring fork/join applications. Also, method
+ * {@link #toString} returns indications of pool state in a
+ * convenient form for informal monitoring.
+ *
+ * <p> As is the case with other ExecutorServices, there are three
+ * main task execution methods summarized in the following
+ * table. These are designed to be used by clients not already engaged
+ * in fork/join computations in the current pool.  The main forms of
+ * these methods accept instances of {@code ForkJoinTask}, but
+ * overloaded forms also allow mixed execution of plain {@code
+ * Runnable}- or {@code Callable}- based activities as well.  However,
+ * tasks that are already executing in a pool should normally
+ * <em>NOT</em> use these pool execution methods, but instead use the
+ * within-computation forms listed in the table.
+ *
+ * <table BORDER CELLPADDING=3 CELLSPACING=1>
+ *  <tr>
+ *    <td></td>
+ *    <td ALIGN=CENTER> <b>Call from non-fork/join clients</b></td>
+ *    <td ALIGN=CENTER> <b>Call from within fork/join computations</b></td>
+ *  </tr>
+ *  <tr>
+ *    <td> <b>Arrange async execution</td>
+ *    <td> {@link #execute(ForkJoinTask)}</td>
+ *    <td> {@link ForkJoinTask#fork}</td>
+ *  </tr>
+ *  <tr>
+ *    <td> <b>Await and obtain result</td>
+ *    <td> {@link #invoke(ForkJoinTask)}</td>
+ *    <td> {@link ForkJoinTask#invoke}</td>
+ *  </tr>
+ *  <tr>
+ *    <td> <b>Arrange exec and obtain Future</td>
+ *    <td> {@link #submit(ForkJoinTask)}</td>
+ *    <td> {@link ForkJoinTask#fork} (ForkJoinTasks <em>are</em> Futures)</td>
+ *  </tr>
+ * </table>
+ *
+ * <p><b>Sample Usage.</b> Normally a single {@code ForkJoinPool} is
+ * used for all parallel task execution in a program or subsystem.
+ * Otherwise, use would not usually outweigh the construction and
+ * bookkeeping overhead of creating a large set of threads. For
+ * example, a common pool could be used for the {@code SortTasks}
+ * illustrated in {@link RecursiveAction}. Because {@code
+ * ForkJoinPool} uses threads in {@linkplain java.lang.Thread#isDaemon
+ * daemon} mode, there is typically no need to explicitly {@link
+ * #shutdown} such a pool upon program exit.
+ *
+ *  <pre> {@code
+ * static final ForkJoinPool mainPool = new ForkJoinPool();
+ * ...
+ * public void sort(long[] array) {
+ *   mainPool.invoke(new SortTask(array, 0, array.length));
+ * }}</pre>
+ *
+ * <p><b>Implementation notes</b>: This implementation restricts the
+ * maximum number of running threads to 32767. Attempts to create
+ * pools with greater than the maximum number result in
+ * {@code IllegalArgumentException}.
+ *
+ * <p>This implementation rejects submitted tasks (that is, by throwing
+ * {@link RejectedExecutionException}) only when the pool is shut down
+ * or internal resources have been exhausted.
+ *
+ * @since 1.7
+ * @hide
+ * @author Doug Lea
+ */
+public class ForkJoinPool extends AbstractExecutorService {
+
+    /*
+     * Implementation Overview
+     *
+     * This class provides the central bookkeeping and control for a
+     * set of worker threads: Submissions from non-FJ threads enter
+     * into a submission queue. Workers take these tasks and typically
+     * split them into subtasks that may be stolen by other workers.
+     * Preference rules give first priority to processing tasks from
+     * their own queues (LIFO or FIFO, depending on mode), then to
+     * randomized FIFO steals of tasks in other worker queues, and
+     * lastly to new submissions.
+     *
+     * The main throughput advantages of work-stealing stem from
+     * decentralized control -- workers mostly take tasks from
+     * themselves or each other. We cannot negate this in the
+     * implementation of other management responsibilities. The main
+     * tactic for avoiding bottlenecks is packing nearly all
+     * essentially atomic control state into a single 64bit volatile
+     * variable ("ctl"). This variable is read on the order of 10-100
+     * times as often as it is modified (always via CAS). (There is
+     * some additional control state, for example variable "shutdown"
+     * for which we can cope with uncoordinated updates.)  This
+     * streamlines synchronization and control at the expense of messy
+     * constructions needed to repack status bits upon updates.
+     * Updates tend not to contend with each other except during
+     * bursts while submitted tasks begin or end.  In some cases when
+     * they do contend, threads can instead do something else
+     * (usually, scan for tasks) until contention subsides.
+     *
+     * To enable packing, we restrict maximum parallelism to (1<<15)-1
+     * (which is far in excess of normal operating range) to allow
+     * ids, counts, and their negations (used for thresholding) to fit
+     * into 16bit fields.
+     *
+     * Recording Workers.  Workers are recorded in the "workers" array
+     * that is created upon pool construction and expanded if (rarely)
+     * necessary.  This is an array as opposed to some other data
+     * structure to support index-based random steals by workers.
+     * Updates to the array recording new workers and unrecording
+     * terminated ones are protected from each other by a seqLock
+     * (scanGuard) but the array is otherwise concurrently readable,
+     * and accessed directly by workers. To simplify index-based
+     * operations, the array size is always a power of two, and all
+     * readers must tolerate null slots. To avoid flailing during
+     * start-up, the array is presized to hold twice #parallelism
+     * workers (which is unlikely to need further resizing during
+     * execution). But to avoid dealing with so many null slots,
+     * variable scanGuard includes a mask for the nearest power of two
+     * that contains all current workers.  All worker thread creation
+     * is on-demand, triggered by task submissions, replacement of
+     * terminated workers, and/or compensation for blocked
+     * workers. However, all other support code is set up to work with
+     * other policies.  To ensure that we do not hold on to worker
+     * references that would prevent GC, ALL accesses to workers are
+     * via indices into the workers array (which is one source of some
+     * of the messy code constructions here). In essence, the workers
+     * array serves as a weak reference mechanism. Thus for example
+     * the wait queue field of ctl stores worker indices, not worker
+     * references.  Access to the workers in associated methods (for
+     * example signalWork) must both index-check and null-check the
+     * IDs. All such accesses ignore bad IDs by returning out early
+     * from what they are doing, since this can only be associated
+     * with termination, in which case it is OK to give up.
+     *
+     * All uses of the workers array, as well as queue arrays, check
+     * that the array is non-null (even if previously non-null). This
+     * allows nulling during termination, which is currently not
+     * necessary, but remains an option for resource-revocation-based
+     * shutdown schemes.
+     *
+     * Wait Queuing. Unlike HPC work-stealing frameworks, we cannot
+     * let workers spin indefinitely scanning for tasks when none can
+     * be found immediately, and we cannot start/resume workers unless
+     * there appear to be tasks available.  On the other hand, we must
+     * quickly prod them into action when new tasks are submitted or
+     * generated.  We park/unpark workers after placing in an event
+     * wait queue when they cannot find work. This "queue" is actually
+     * a simple Treiber stack, headed by the "id" field of ctl, plus a
+     * 15bit counter value to both wake up waiters (by advancing their
+     * count) and avoid ABA effects. Successors are held in worker
+     * field "nextWait".  Queuing deals with several intrinsic races,
+     * mainly that a task-producing thread can miss seeing (and
+     * signalling) another thread that gave up looking for work but
+     * has not yet entered the wait queue. We solve this by requiring
+     * a full sweep of all workers both before (in scan()) and after
+     * (in tryAwaitWork()) a newly waiting worker is added to the wait
+     * queue. During a rescan, the worker might release some other
+     * queued worker rather than itself, which has the same net
+     * effect. Because enqueued workers may actually be rescanning
+     * rather than waiting, we set and clear the "parked" field of
+     * ForkJoinWorkerThread to reduce unnecessary calls to unpark.
+     * (Use of the parked field requires a secondary recheck to avoid
+     * missed signals.)
+     *
+     * Signalling.  We create or wake up workers only when there
+     * appears to be at least one task they might be able to find and
+     * execute.  When a submission is added or another worker adds a
+     * task to a queue that previously had two or fewer tasks, they
+     * signal waiting workers (or trigger creation of new ones if
+     * fewer than the given parallelism level -- see signalWork).
+     * These primary signals are buttressed by signals during rescans
+     * as well as those performed when a worker steals a task and
+     * notices that there are more tasks too; together these cover the
+     * signals needed in cases when more than two tasks are pushed
+     * but untaken.
+     *
+     * Trimming workers. To release resources after periods of lack of
+     * use, a worker starting to wait when the pool is quiescent will
+     * time out and terminate if the pool has remained quiescent for
+     * SHRINK_RATE nanosecs. This will slowly propagate, eventually
+     * terminating all workers after long periods of non-use.
+     *
+     * Submissions. External submissions are maintained in an
+     * array-based queue that is structured identically to
+     * ForkJoinWorkerThread queues except for the use of
+     * submissionLock in method addSubmission. Unlike the case for
+     * worker queues, multiple external threads can add new
+     * submissions, so adding requires a lock.
+     *
+     * Compensation. Beyond work-stealing support and lifecycle
+     * control, the main responsibility of this framework is to take
+     * actions when one worker is waiting to join a task stolen (or
+     * always held by) another.  Because we are multiplexing many
+     * tasks on to a pool of workers, we can't just let them block (as
+     * in Thread.join).  We also cannot just reassign the joiner's
+     * run-time stack with another and replace it later, which would
+     * be a form of "continuation", that even if possible is not
+     * necessarily a good idea since we sometimes need both an
+     * unblocked task and its continuation to progress. Instead we
+     * combine two tactics:
+     *
+     *   Helping: Arranging for the joiner to execute some task that it
+     *      would be running if the steal had not occurred.  Method
+     *      ForkJoinWorkerThread.joinTask tracks joining->stealing
+     *      links to try to find such a task.
+     *
+     *   Compensating: Unless there are already enough live threads,
+     *      method tryPreBlock() may create or re-activate a spare
+     *      thread to compensate for blocked joiners until they
+     *      unblock.
+     *
+     * The ManagedBlocker extension API can't use helping so relies
+     * only on compensation in method awaitBlocker.
+     *
+     * It is impossible to keep exactly the target parallelism number
+     * of threads running at any given time.  Determining the
+     * existence of conservatively safe helping targets, the
+     * availability of already-created spares, and the apparent need
+     * to create new spares are all racy and require heuristic
+     * guidance, so we rely on multiple retries of each.  Currently,
+     * in keeping with on-demand signalling policy, we compensate only
+     * if blocking would leave less than one active (non-waiting,
+     * non-blocked) worker. Additionally, to avoid some false alarms
+     * due to GC, lagging counters, system activity, etc, compensated
+     * blocking for joins is only attempted after rechecks stabilize
+     * (retries are interspersed with Thread.yield, for good
+     * citizenship).  The variable blockedCount, incremented before
+     * blocking and decremented after, is sometimes needed to
+     * distinguish cases of waiting for work vs blocking on joins or
+     * other managed sync. Both cases are equivalent for most pool
+     * control, so we can update non-atomically. (Additionally,
+     * contention on blockedCount alleviates some contention on ctl).
+     *
+     * Shutdown and Termination. A call to shutdownNow atomically sets
+     * the ctl stop bit and then (non-atomically) sets each workers
+     * "terminate" status, cancels all unprocessed tasks, and wakes up
+     * all waiting workers.  Detecting whether termination should
+     * commence after a non-abrupt shutdown() call requires more work
+     * and bookkeeping. We need consensus about quiescence (i.e., that
+     * there is no more work) which is reflected in active counts so
+     * long as there are no current blockers, as well as possible
+     * re-evaluations during independent changes in blocking or
+     * quiescing workers.
+     *
+     * Style notes: There is a lot of representation-level coupling
+     * among classes ForkJoinPool, ForkJoinWorkerThread, and
+     * ForkJoinTask.  Most fields of ForkJoinWorkerThread maintain
+     * data structures managed by ForkJoinPool, so are directly
+     * accessed.  Conversely we allow access to "workers" array by
+     * workers, and direct access to ForkJoinTask.status by both
+     * ForkJoinPool and ForkJoinWorkerThread.  There is little point
+     * trying to reduce this, since any associated future changes in
+     * representations will need to be accompanied by algorithmic
+     * changes anyway. All together, these low-level implementation
+     * choices produce as much as a factor of 4 performance
+     * improvement compared to naive implementations, and enable the
+     * processing of billions of tasks per second, at the expense of
+     * some ugliness.
+     *
+     * Methods signalWork() and scan() are the main bottlenecks so are
+     * especially heavily micro-optimized/mangled.  There are lots of
+     * inline assignments (of form "while ((local = field) != 0)")
+     * which are usually the simplest way to ensure the required read
+     * orderings (which are sometimes critical). This leads to a
+     * "C"-like style of listing declarations of these locals at the
+     * heads of methods or blocks.  There are several occurrences of
+     * the unusual "do {} while (!cas...)"  which is the simplest way
+     * to force an update of a CAS'ed variable. There are also other
+     * coding oddities that help some methods perform reasonably even
+     * when interpreted (not compiled).
+     *
+     * The order of declarations in this file is: (1) declarations of
+     * statics (2) fields (along with constants used when unpacking
+     * some of them), listed in an order that tends to reduce
+     * contention among them a bit under most JVMs.  (3) internal
+     * control methods (4) callbacks and other support for
+     * ForkJoinTask and ForkJoinWorkerThread classes, (5) exported
+     * methods (plus a few little helpers). (6) static block
+     * initializing all statics in a minimally dependent order.
+     */
+
+    /**
+     * Factory for creating new {@link ForkJoinWorkerThread}s.
+     * A {@code ForkJoinWorkerThreadFactory} must be defined and used
+     * for {@code ForkJoinWorkerThread} subclasses that extend base
+     * functionality or initialize threads with different contexts.
+     */
+    public static interface ForkJoinWorkerThreadFactory {
+        /**
+         * Returns a new worker thread operating in the given pool.
+         *
+         * @param pool the pool this thread works in
+         * @throws NullPointerException if the pool is null
+         */
+        public ForkJoinWorkerThread newThread(ForkJoinPool pool);
+    }
+
+    /**
+     * Default ForkJoinWorkerThreadFactory implementation; creates a
+     * new ForkJoinWorkerThread.
+     */
+    static class DefaultForkJoinWorkerThreadFactory
+        implements ForkJoinWorkerThreadFactory {
+        public ForkJoinWorkerThread newThread(ForkJoinPool pool) {
+            return new ForkJoinWorkerThread(pool);
+        }
+    }
+
+    /**
+     * Creates a new ForkJoinWorkerThread. This factory is used unless
+     * overridden in ForkJoinPool constructors.
+     */
+    public static final ForkJoinWorkerThreadFactory
+        defaultForkJoinWorkerThreadFactory;
+
+    /**
+     * Permission required for callers of methods that may start or
+     * kill threads.
+     */
+    private static final RuntimePermission modifyThreadPermission;
+
+    /**
+     * If there is a security manager, makes sure caller has
+     * permission to modify threads.
+     */
+    private static void checkPermission() {
+        SecurityManager security = System.getSecurityManager();
+        if (security != null)
+            security.checkPermission(modifyThreadPermission);
+    }
+
+    /**
+     * Generator for assigning sequence numbers as pool names.
+     */
+    private static final AtomicInteger poolNumberGenerator;
+
+    /**
+     * Generator for initial random seeds for worker victim
+     * selection. This is used only to create initial seeds. Random
+     * steals use a cheaper xorshift generator per steal attempt. We
+     * don't expect much contention on seedGenerator, so just use a
+     * plain Random.
+     */
+    static final Random workerSeedGenerator;
+
+    /**
+     * Array holding all worker threads in the pool.  Initialized upon
+     * construction. Array size must be a power of two.  Updates and
+     * replacements are protected by scanGuard, but the array is
+     * always kept in a consistent enough state to be randomly
+     * accessed without locking by workers performing work-stealing,
+     * as well as other traversal-based methods in this class, so long
+     * as reads memory-acquire by first reading ctl. All readers must
+     * tolerate that some array slots may be null.
+     */
+    ForkJoinWorkerThread[] workers;
+
+    /**
+     * Initial size for submission queue array. Must be a power of
+     * two.  In many applications, these always stay small so we use a
+     * small initial cap.
+     */
+    private static final int INITIAL_QUEUE_CAPACITY = 8;
+
+    /**
+     * Maximum size for submission queue array. Must be a power of two
+     * less than or equal to 1 << (31 - width of array entry) to
+     * ensure lack of index wraparound, but is capped at a lower
+     * value to help users trap runaway computations.
+     */
+    private static final int MAXIMUM_QUEUE_CAPACITY = 1 << 24; // 16M
+
+    /**
+     * Array serving as submission queue. Initialized upon construction.
+     */
+    private ForkJoinTask<?>[] submissionQueue;
+
+    /**
+     * Lock protecting submissions array for addSubmission
+     */
+    private final ReentrantLock submissionLock;
+
+    /**
+     * Condition for awaitTermination, using submissionLock for
+     * convenience.
+     */
+    private final Condition termination;
+
+    /**
+     * Creation factory for worker threads.
+     */
+    private final ForkJoinWorkerThreadFactory factory;
+
+    /**
+     * The uncaught exception handler used when any worker abruptly
+     * terminates.
+     */
+    final Thread.UncaughtExceptionHandler ueh;
+
+    /**
+     * Prefix for assigning names to worker threads
+     */
+    private final String workerNamePrefix;
+
+    /**
+     * Sum of per-thread steal counts, updated only when threads are
+     * idle or terminating.
+     */
+    private volatile long stealCount;
+
+    /**
+     * Main pool control -- a long packed with:
+     * AC: Number of active running workers minus target parallelism (16 bits)
+     * TC: Number of total workers minus target parallelism (16 bits)
+     * ST: true if pool is terminating (1 bit)
+     * EC: the wait count of top waiting thread (15 bits)
+     * ID: ~poolIndex of top of Treiber stack of waiting threads (16 bits)
+     *
+     * When convenient, we can extract the upper 32 bits of counts and
+     * the lower 32 bits of queue state, u = (int)(ctl >>> 32) and e =
+     * (int)ctl.  The ec field is never accessed alone, but always
+     * together with id and st. The offsets of counts by the target
+     * parallelism and the positionings of fields makes it possible to
+     * perform the most common checks via sign tests of fields: When
+     * ac is negative, there are not enough active workers, when tc is
+     * negative, there are not enough total workers, when id is
+     * negative, there is at least one waiting worker, and when e is
+     * negative, the pool is terminating.  To deal with these possibly
+     * negative fields, we use casts in and out of "short" and/or
+     * signed shifts to maintain signedness.
+     */
+    volatile long ctl;
+
+    // bit positions/shifts for fields
+    private static final int  AC_SHIFT   = 48;
+    private static final int  TC_SHIFT   = 32;
+    private static final int  ST_SHIFT   = 31;
+    private static final int  EC_SHIFT   = 16;
+
+    // bounds
+    private static final int  MAX_ID     = 0x7fff;  // max poolIndex
+    private static final int  SMASK      = 0xffff;  // mask short bits
+    private static final int  SHORT_SIGN = 1 << 15;
+    private static final int  INT_SIGN   = 1 << 31;
+
+    // masks
+    private static final long STOP_BIT   = 0x0001L << ST_SHIFT;
+    private static final long AC_MASK    = ((long)SMASK) << AC_SHIFT;
+    private static final long TC_MASK    = ((long)SMASK) << TC_SHIFT;
+
+    // units for incrementing and decrementing
+    private static final long TC_UNIT    = 1L << TC_SHIFT;
+    private static final long AC_UNIT    = 1L << AC_SHIFT;
+
+    // masks and units for dealing with u = (int)(ctl >>> 32)
+    private static final int  UAC_SHIFT  = AC_SHIFT - 32;
+    private static final int  UTC_SHIFT  = TC_SHIFT - 32;
+    private static final int  UAC_MASK   = SMASK << UAC_SHIFT;
+    private static final int  UTC_MASK   = SMASK << UTC_SHIFT;
+    private static final int  UAC_UNIT   = 1 << UAC_SHIFT;
+    private static final int  UTC_UNIT   = 1 << UTC_SHIFT;
+
+    // masks and units for dealing with e = (int)ctl
+    private static final int  E_MASK     = 0x7fffffff; // no STOP_BIT
+    private static final int  EC_UNIT    = 1 << EC_SHIFT;
+
+    /**
+     * The target parallelism level.
+     */
+    final int parallelism;
+
+    /**
+     * Index (mod submission queue length) of next element to take
+     * from submission queue. Usage is identical to that for
+     * per-worker queues -- see ForkJoinWorkerThread internal
+     * documentation.
+     */
+    volatile int queueBase;
+
+    /**
+     * Index (mod submission queue length) of next element to add
+     * in submission queue. Usage is identical to that for
+     * per-worker queues -- see ForkJoinWorkerThread internal
+     * documentation.
+     */
+    int queueTop;
+
+    /**
+     * True when shutdown() has been called.
+     */
+    volatile boolean shutdown;
+
+    /**
+     * True if use local fifo, not default lifo, for local polling.
+     * Read by, and replicated by ForkJoinWorkerThreads.
+     */
+    final boolean locallyFifo;
+
+    /**
+     * The number of threads in ForkJoinWorkerThreads.helpQuiescePool.
+     * When non-zero, suppresses automatic shutdown when active
+     * counts become zero.
+     */
+    volatile int quiescerCount;
+
+    /**
+     * The number of threads blocked in join.
+     */
+    volatile int blockedCount;
+
+    /**
+     * Counter for worker Thread names (unrelated to their poolIndex)
+     */
+    private volatile int nextWorkerNumber;
+
+    /**
+     * The index for the next created worker. Accessed under scanGuard.
+     */
+    private int nextWorkerIndex;
+
+    /**
+     * SeqLock and index masking for updates to workers array.  Locked
+     * when SG_UNIT is set. Unlocking clears bit by adding
+     * SG_UNIT. Staleness of read-only operations can be checked by
+     * comparing scanGuard to value before the reads. The low 16 bits
+     * (i.e, anding with SMASK) hold (the smallest power of two
+     * covering all worker indices, minus one, and is used to avoid
+     * dealing with large numbers of null slots when the workers array
+     * is overallocated.
+     */
+    volatile int scanGuard;
+
+    private static final int SG_UNIT = 1 << 16;
+
+    /**
+     * The wakeup interval (in nanoseconds) for a worker waiting for a
+     * task when the pool is quiescent to instead try to shrink the
+     * number of workers.  The exact value does not matter too
+     * much. It must be short enough to release resources during
+     * sustained periods of idleness, but not so short that threads
+     * are continually re-created.
+     */
+    private static final long SHRINK_RATE =
+        4L * 1000L * 1000L * 1000L; // 4 seconds
+
+    /**
+     * Top-level loop for worker threads: On each step: if the
+     * previous step swept through all queues and found no tasks, or
+     * there are excess threads, then possibly blocks. Otherwise,
+     * scans for and, if found, executes a task. Returns when pool
+     * and/or worker terminate.
+     *
+     * @param w the worker
+     */
+    final void work(ForkJoinWorkerThread w) {
+        boolean swept = false;                // true on empty scans
+        long c;
+        while (!w.terminate && (int)(c = ctl) >= 0) {
+            int a;                            // active count
+            if (!swept && (a = (int)(c >> AC_SHIFT)) <= 0)
+                swept = scan(w, a);
+            else if (tryAwaitWork(w, c))
+                swept = false;
+        }
+    }
+
+    // Signalling
+
+    /**
+     * Wakes up or creates a worker.
+     */
+    final void signalWork() {
+        /*
+         * The while condition is true if: (there is are too few total
+         * workers OR there is at least one waiter) AND (there are too
+         * few active workers OR the pool is terminating).  The value
+         * of e distinguishes the remaining cases: zero (no waiters)
+         * for create, negative if terminating (in which case do
+         * nothing), else release a waiter. The secondary checks for
+         * release (non-null array etc) can fail if the pool begins
+         * terminating after the test, and don't impose any added cost
+         * because JVMs must perform null and bounds checks anyway.
+         */
+        long c; int e, u;
+        while ((((e = (int)(c = ctl)) | (u = (int)(c >>> 32))) &
+                (INT_SIGN|SHORT_SIGN)) == (INT_SIGN|SHORT_SIGN) && e >= 0) {
+            if (e > 0) {                         // release a waiting worker
+                int i; ForkJoinWorkerThread w; ForkJoinWorkerThread[] ws;
+                if ((ws = workers) == null ||
+                    (i = ~e & SMASK) >= ws.length ||
+                    (w = ws[i]) == null)
+                    break;
+                long nc = (((long)(w.nextWait & E_MASK)) |
+                           ((long)(u + UAC_UNIT) << 32));
+                if (w.eventCount == e &&
+                    UNSAFE.compareAndSwapLong(this, ctlOffset, c, nc)) {
+                    w.eventCount = (e + EC_UNIT) & E_MASK;
+                    if (w.parked)
+                        UNSAFE.unpark(w);
+                    break;
+                }
+            }
+            else if (UNSAFE.compareAndSwapLong
+                     (this, ctlOffset, c,
+                      (long)(((u + UTC_UNIT) & UTC_MASK) |
+                             ((u + UAC_UNIT) & UAC_MASK)) << 32)) {
+                addWorker();
+                break;
+            }
+        }
+    }
+
+    /**
+     * Variant of signalWork to help release waiters on rescans.
+     * Tries once to release a waiter if active count < 0.
+     *
+     * @return false if failed due to contention, else true
+     */
+    private boolean tryReleaseWaiter() {
+        long c; int e, i; ForkJoinWorkerThread w; ForkJoinWorkerThread[] ws;
+        if ((e = (int)(c = ctl)) > 0 &&
+            (int)(c >> AC_SHIFT) < 0 &&
+            (ws = workers) != null &&
+            (i = ~e & SMASK) < ws.length &&
+            (w = ws[i]) != null) {
+            long nc = ((long)(w.nextWait & E_MASK) |
+                       ((c + AC_UNIT) & (AC_MASK|TC_MASK)));
+            if (w.eventCount != e ||
+                !UNSAFE.compareAndSwapLong(this, ctlOffset, c, nc))
+                return false;
+            w.eventCount = (e + EC_UNIT) & E_MASK;
+            if (w.parked)
+                UNSAFE.unpark(w);
+        }
+        return true;
+    }
+
+    // Scanning for tasks
+
+    /**
+     * Scans for and, if found, executes one task. Scans start at a
+     * random index of workers array, and randomly select the first
+     * (2*#workers)-1 probes, and then, if all empty, resort to 2
+     * circular sweeps, which is necessary to check quiescence. and
+     * taking a submission only if no stealable tasks were found.  The
+     * steal code inside the loop is a specialized form of
+     * ForkJoinWorkerThread.deqTask, followed bookkeeping to support
+     * helpJoinTask and signal propagation. The code for submission
+     * queues is almost identical. On each steal, the worker completes
+     * not only the task, but also all local tasks that this task may
+     * have generated. On detecting staleness or contention when
+     * trying to take a task, this method returns without finishing
+     * sweep, which allows global state rechecks before retry.
+     *
+     * @param w the worker
+     * @param a the number of active workers
+     * @return true if swept all queues without finding a task
+     */
+    private boolean scan(ForkJoinWorkerThread w, int a) {
+        int g = scanGuard; // mask 0 avoids useless scans if only one active
+        int m = (parallelism == 1 - a && blockedCount == 0) ? 0 : g & SMASK;
+        ForkJoinWorkerThread[] ws = workers;
+        if (ws == null || ws.length <= m)         // staleness check
+            return false;
+        for (int r = w.seed, k = r, j = -(m + m); j <= m + m; ++j) {
+            ForkJoinTask<?> t; ForkJoinTask<?>[] q; int b, i;
+            ForkJoinWorkerThread v = ws[k & m];
+            if (v != null && (b = v.queueBase) != v.queueTop &&
+                (q = v.queue) != null && (i = (q.length - 1) & b) >= 0) {
+                long u = (i << ASHIFT) + ABASE;
+                if ((t = q[i]) != null && v.queueBase == b &&
+                    UNSAFE.compareAndSwapObject(q, u, t, null)) {
+                    int d = (v.queueBase = b + 1) - v.queueTop;
+                    v.stealHint = w.poolIndex;
+                    if (d != 0)
+                        signalWork();             // propagate if nonempty
+                    w.execTask(t);
+                }
+                r ^= r << 13; r ^= r >>> 17; w.seed = r ^ (r << 5);
+                return false;                     // store next seed
+            }
+            else if (j < 0) {                     // xorshift
+                r ^= r << 13; r ^= r >>> 17; k = r ^= r << 5;
+            }
+            else
+                ++k;
+        }
+        if (scanGuard != g)                       // staleness check
+            return false;
+        else {                                    // try to take submission
+            ForkJoinTask<?> t; ForkJoinTask<?>[] q; int b, i;
+            if ((b = queueBase) != queueTop &&
+                (q = submissionQueue) != null &&
+                (i = (q.length - 1) & b) >= 0) {
+                long u = (i << ASHIFT) + ABASE;
+                if ((t = q[i]) != null && queueBase == b &&
+                    UNSAFE.compareAndSwapObject(q, u, t, null)) {
+                    queueBase = b + 1;
+                    w.execTask(t);
+                }
+                return false;
+            }
+            return true;                         // all queues empty
+        }
+    }
+
+    /**
+     * Tries to enqueue worker w in wait queue and await change in
+     * worker's eventCount.  If the pool is quiescent and there is
+     * more than one worker, possibly terminates worker upon exit.
+     * Otherwise, before blocking, rescans queues to avoid missed
+     * signals.  Upon finding work, releases at least one worker
+     * (which may be the current worker). Rescans restart upon
+     * detected staleness or failure to release due to
+     * contention. Note the unusual conventions about Thread.interrupt
+     * here and elsewhere: Because interrupts are used solely to alert
+     * threads to check termination, which is checked here anyway, we
+     * clear status (using Thread.interrupted) before any call to
+     * park, so that park does not immediately return due to status
+     * being set via some other unrelated call to interrupt in user
+     * code.
+     *
+     * @param w the calling worker
+     * @param c the ctl value on entry
+     * @return true if waited or another thread was released upon enq
+     */
+    private boolean tryAwaitWork(ForkJoinWorkerThread w, long c) {
+        int v = w.eventCount;
+        w.nextWait = (int)c;                      // w's successor record
+        long nc = (long)(v & E_MASK) | ((c - AC_UNIT) & (AC_MASK|TC_MASK));
+        if (ctl != c || !UNSAFE.compareAndSwapLong(this, ctlOffset, c, nc)) {
+            long d = ctl; // return true if lost to a deq, to force scan
+            return (int)d != (int)c && (d & AC_MASK) >= (c & AC_MASK);
+        }
+        for (int sc = w.stealCount; sc != 0;) {   // accumulate stealCount
+            long s = stealCount;
+            if (UNSAFE.compareAndSwapLong(this, stealCountOffset, s, s + sc))
+                sc = w.stealCount = 0;
+            else if (w.eventCount != v)
+                return true;                      // update next time
+        }
+        if ((!shutdown || !tryTerminate(false)) &&
+            (int)c != 0 && parallelism + (int)(nc >> AC_SHIFT) == 0 &&
+            blockedCount == 0 && quiescerCount == 0)
+            idleAwaitWork(w, nc, c, v);           // quiescent
+        for (boolean rescanned = false;;) {
+            if (w.eventCount != v)
+                return true;
+            if (!rescanned) {
+                int g = scanGuard, m = g & SMASK;
+                ForkJoinWorkerThread[] ws = workers;
+                if (ws != null && m < ws.length) {
+                    rescanned = true;
+                    for (int i = 0; i <= m; ++i) {
+                        ForkJoinWorkerThread u = ws[i];
+                        if (u != null) {
+                            if (u.queueBase != u.queueTop &&
+                                !tryReleaseWaiter())
+                                rescanned = false; // contended
+                            if (w.eventCount != v)
+                                return true;
+                        }
+                    }
+                }
+                if (scanGuard != g ||              // stale
+                    (queueBase != queueTop && !tryReleaseWaiter()))
+                    rescanned = false;
+                if (!rescanned)
+                    Thread.yield();                // reduce contention
+                else
+                    Thread.interrupted();          // clear before park
+            }
+            else {
+                w.parked = true;                   // must recheck
+                if (w.eventCount != v) {
+                    w.parked = false;
+                    return true;
+                }
+                LockSupport.park(this);
+                rescanned = w.parked = false;
+            }
+        }
+    }
+
+    /**
+     * If inactivating worker w has caused pool to become
+     * quiescent, check for pool termination, and wait for event
+     * for up to SHRINK_RATE nanosecs (rescans are unnecessary in
+     * this case because quiescence reflects consensus about lack
+     * of work). On timeout, if ctl has not changed, terminate the
+     * worker. Upon its termination (see deregisterWorker), it may
+     * wake up another worker to possibly repeat this process.
+     *
+     * @param w the calling worker
+     * @param currentCtl the ctl value after enqueuing w
+     * @param prevCtl the ctl value if w terminated
+     * @param v the eventCount w awaits change
+     */
+    private void idleAwaitWork(ForkJoinWorkerThread w, long currentCtl,
+                               long prevCtl, int v) {
+        if (w.eventCount == v) {
+            if (shutdown)
+                tryTerminate(false);
+            ForkJoinTask.helpExpungeStaleExceptions(); // help clean weak refs
+            while (ctl == currentCtl) {
+                long startTime = System.nanoTime();
+                w.parked = true;
+                if (w.eventCount == v)             // must recheck
+                    LockSupport.parkNanos(this, SHRINK_RATE);
+                w.parked = false;
+                if (w.eventCount != v)
+                    break;
+                else if (System.nanoTime() - startTime <
+                         SHRINK_RATE - (SHRINK_RATE / 10)) // timing slop
+                    Thread.interrupted();          // spurious wakeup
+                else if (UNSAFE.compareAndSwapLong(this, ctlOffset,
+                                                   currentCtl, prevCtl)) {
+                    w.terminate = true;            // restore previous
+                    w.eventCount = ((int)currentCtl + EC_UNIT) & E_MASK;
+                    break;
+                }
+            }
+        }
+    }
+
+    // Submissions
+
+    /**
+     * Enqueues the given task in the submissionQueue.  Same idea as
+     * ForkJoinWorkerThread.pushTask except for use of submissionLock.
+     *
+     * @param t the task
+     */
+    private void addSubmission(ForkJoinTask<?> t) {
+        final ReentrantLock lock = this.submissionLock;
+        lock.lock();
+        try {
+            ForkJoinTask<?>[] q; int s, m;
+            if ((q = submissionQueue) != null) {    // ignore if queue removed
+                long u = (((s = queueTop) & (m = q.length-1)) << ASHIFT)+ABASE;
+                UNSAFE.putOrderedObject(q, u, t);
+                queueTop = s + 1;
+                if (s - queueBase == m)
+                    growSubmissionQueue();
+            }
+        } finally {
+            lock.unlock();
+        }
+        signalWork();
+    }
+
+    //  (pollSubmission is defined below with exported methods)
+
+    /**
+     * Creates or doubles submissionQueue array.
+     * Basically identical to ForkJoinWorkerThread version.
+     */
+    private void growSubmissionQueue() {
+        ForkJoinTask<?>[] oldQ = submissionQueue;
+        int size = oldQ != null ? oldQ.length << 1 : INITIAL_QUEUE_CAPACITY;
+        if (size > MAXIMUM_QUEUE_CAPACITY)
+            throw new RejectedExecutionException("Queue capacity exceeded");
+        if (size < INITIAL_QUEUE_CAPACITY)
+            size = INITIAL_QUEUE_CAPACITY;
+        ForkJoinTask<?>[] q = submissionQueue = new ForkJoinTask<?>[size];
+        int mask = size - 1;
+        int top = queueTop;
+        int oldMask;
+        if (oldQ != null && (oldMask = oldQ.length - 1) >= 0) {
+            for (int b = queueBase; b != top; ++b) {
+                long u = ((b & oldMask) << ASHIFT) + ABASE;
+                Object x = UNSAFE.getObjectVolatile(oldQ, u);
+                if (x != null && UNSAFE.compareAndSwapObject(oldQ, u, x, null))
+                    UNSAFE.putObjectVolatile
+                        (q, ((b & mask) << ASHIFT) + ABASE, x);
+            }
+        }
+    }
+
+    // Blocking support
+
+    /**
+     * Tries to increment blockedCount, decrement active count
+     * (sometimes implicitly) and possibly release or create a
+     * compensating worker in preparation for blocking. Fails
+     * on contention or termination.
+     *
+     * @return true if the caller can block, else should recheck and retry
+     */
+    private boolean tryPreBlock() {
+        int b = blockedCount;
+        if (UNSAFE.compareAndSwapInt(this, blockedCountOffset, b, b + 1)) {
+            int pc = parallelism;
+            do {
+                ForkJoinWorkerThread[] ws; ForkJoinWorkerThread w;
+                int e, ac, tc, i;
+                long c = ctl;
+                int u = (int)(c >>> 32);
+                if ((e = (int)c) < 0) {
+                                                 // skip -- terminating
+                }
+                else if ((ac = (u >> UAC_SHIFT)) <= 0 && e != 0 &&
+                         (ws = workers) != null &&
+                         (i = ~e & SMASK) < ws.length &&
+                         (w = ws[i]) != null) {
+                    long nc = ((long)(w.nextWait & E_MASK) |
+                               (c & (AC_MASK|TC_MASK)));
+                    if (w.eventCount == e &&
+                        UNSAFE.compareAndSwapLong(this, ctlOffset, c, nc)) {
+                        w.eventCount = (e + EC_UNIT) & E_MASK;
+                        if (w.parked)
+                            UNSAFE.unpark(w);
+                        return true;             // release an idle worker
+                    }
+                }
+                else if ((tc = (short)(u >>> UTC_SHIFT)) >= 0 && ac + pc > 1) {
+                    long nc = ((c - AC_UNIT) & AC_MASK) | (c & ~AC_MASK);
+                    if (UNSAFE.compareAndSwapLong(this, ctlOffset, c, nc))
+                        return true;             // no compensation needed
+                }
+                else if (tc + pc < MAX_ID) {
+                    long nc = ((c + TC_UNIT) & TC_MASK) | (c & ~TC_MASK);
+                    if (UNSAFE.compareAndSwapLong(this, ctlOffset, c, nc)) {
+                        addWorker();
+                        return true;            // create a replacement
+                    }
+                }
+                // try to back out on any failure and let caller retry
+            } while (!UNSAFE.compareAndSwapInt(this, blockedCountOffset,
+                                               b = blockedCount, b - 1));
+        }
+        return false;
+    }
+
+    /**
+     * Decrements blockedCount and increments active count.
+     */
+    private void postBlock() {
+        long c;
+        do {} while (!UNSAFE.compareAndSwapLong(this, ctlOffset,  // no mask
+                                                c = ctl, c + AC_UNIT));
+        int b;
+        do {} while (!UNSAFE.compareAndSwapInt(this, blockedCountOffset,
+                                               b = blockedCount, b - 1));
+    }
+
+    /**
+     * Possibly blocks waiting for the given task to complete, or
+     * cancels the task if terminating.  Fails to wait if contended.
+     *
+     * @param joinMe the task
+     */
+    final void tryAwaitJoin(ForkJoinTask<?> joinMe) {
+        Thread.interrupted(); // clear interrupts before checking termination
+        if (joinMe.status >= 0) {
+            if (tryPreBlock()) {
+                joinMe.tryAwaitDone(0L);
+                postBlock();
+            }
+            else if ((ctl & STOP_BIT) != 0L)
+                joinMe.cancelIgnoringExceptions();
+        }
+    }
+
+    /**
+     * Possibly blocks the given worker waiting for joinMe to
+     * complete or timeout.
+     *
+     * @param joinMe the task
+     * @param nanos the wait time for underlying Object.wait
+     */
+    final void timedAwaitJoin(ForkJoinTask<?> joinMe, long nanos) {
+        while (joinMe.status >= 0) {
+            Thread.interrupted();
+            if ((ctl & STOP_BIT) != 0L) {
+                joinMe.cancelIgnoringExceptions();
+                break;
+            }
+            if (tryPreBlock()) {
+                long last = System.nanoTime();
+                while (joinMe.status >= 0) {
+                    long millis = TimeUnit.NANOSECONDS.toMillis(nanos);
+                    if (millis <= 0)
+                        break;
+                    joinMe.tryAwaitDone(millis);
+                    if (joinMe.status < 0)
+                        break;
+                    if ((ctl & STOP_BIT) != 0L) {
+                        joinMe.cancelIgnoringExceptions();
+                        break;
+                    }
+                    long now = System.nanoTime();
+                    nanos -= now - last;
+                    last = now;
+                }
+                postBlock();
+                break;
+            }
+        }
+    }
+
+    /**
+     * If necessary, compensates for blocker, and blocks.
+     */
+    private void awaitBlocker(ManagedBlocker blocker)
+        throws InterruptedException {
+        while (!blocker.isReleasable()) {
+            if (tryPreBlock()) {
+                try {
+                    do {} while (!blocker.isReleasable() && !blocker.block());
+                } finally {
+                    postBlock();
+                }
+                break;
+            }
+        }
+    }
+
+    // Creating, registering and deregistring workers
+
+    /**
+     * Tries to create and start a worker; minimally rolls back counts
+     * on failure.
+     */
+    private void addWorker() {
+        Throwable ex = null;
+        ForkJoinWorkerThread t = null;
+        try {
+            t = factory.newThread(this);
+        } catch (Throwable e) {
+            ex = e;
+        }
+        if (t == null) {  // null or exceptional factory return
+            long c;       // adjust counts
+            do {} while (!UNSAFE.compareAndSwapLong
+                         (this, ctlOffset, c = ctl,
+                          (((c - AC_UNIT) & AC_MASK) |
+                           ((c - TC_UNIT) & TC_MASK) |
+                           (c & ~(AC_MASK|TC_MASK)))));
+            // Propagate exception if originating from an external caller
+            if (!tryTerminate(false) && ex != null &&
+                !(Thread.currentThread() instanceof ForkJoinWorkerThread))
+                SneakyThrow.sneakyThrow(ex); // android-changed
+        }
+        else
+            t.start();
+    }
+
+    /**
+     * Callback from ForkJoinWorkerThread constructor to assign a
+     * public name
+     */
+    final String nextWorkerName() {
+        for (int n;;) {
+            if (UNSAFE.compareAndSwapInt(this, nextWorkerNumberOffset,
+                                         n = nextWorkerNumber, ++n))
+                return workerNamePrefix + n;
+        }
+    }
+
+    /**
+     * Callback from ForkJoinWorkerThread constructor to
+     * determine its poolIndex and record in workers array.
+     *
+     * @param w the worker
+     * @return the worker's pool index
+     */
+    final int registerWorker(ForkJoinWorkerThread w) {
+        /*
+         * In the typical case, a new worker acquires the lock, uses
+         * next available index and returns quickly.  Since we should
+         * not block callers (ultimately from signalWork or
+         * tryPreBlock) waiting for the lock needed to do this, we
+         * instead help release other workers while waiting for the
+         * lock.
+         */
+        for (int g;;) {
+            ForkJoinWorkerThread[] ws;
+            if (((g = scanGuard) & SG_UNIT) == 0 &&
+                UNSAFE.compareAndSwapInt(this, scanGuardOffset,
+                                         g, g | SG_UNIT)) {
+                int k = nextWorkerIndex;
+                try {
+                    if ((ws = workers) != null) { // ignore on shutdown
+                        int n = ws.length;
+                        if (k < 0 || k >= n || ws[k] != null) {
+                            for (k = 0; k < n && ws[k] != null; ++k)
+                                ;
+                            if (k == n)
+                                ws = workers = Arrays.copyOf(ws, n << 1);
+                        }
+                        ws[k] = w;
+                        nextWorkerIndex = k + 1;
+                        int m = g & SMASK;
+                        g = (k > m) ? ((m << 1) + 1) & SMASK : g + (SG_UNIT<<1);
+                    }
+                } finally {
+                    scanGuard = g;
+                }
+                return k;
+            }
+            else if ((ws = workers) != null) { // help release others
+                for (ForkJoinWorkerThread u : ws) {
+                    if (u != null && u.queueBase != u.queueTop) {
+                        if (tryReleaseWaiter())
+                            break;
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Final callback from terminating worker.  Removes record of
+     * worker from array, and adjusts counts. If pool is shutting
+     * down, tries to complete termination.
+     *
+     * @param w the worker
+     */
+    final void deregisterWorker(ForkJoinWorkerThread w, Throwable ex) {
+        int idx = w.poolIndex;
+        int sc = w.stealCount;
+        int steps = 0;
+        // Remove from array, adjust worker counts and collect steal count.
+        // We can intermix failed removes or adjusts with steal updates
+        do {
+            long s, c;
+            int g;
+            if (steps == 0 && ((g = scanGuard) & SG_UNIT) == 0 &&
+                UNSAFE.compareAndSwapInt(this, scanGuardOffset,
+                                         g, g |= SG_UNIT)) {
+                ForkJoinWorkerThread[] ws = workers;
+                if (ws != null && idx >= 0 &&
+                    idx < ws.length && ws[idx] == w)
+                    ws[idx] = null;    // verify
+                nextWorkerIndex = idx;
+                scanGuard = g + SG_UNIT;
+                steps = 1;
+            }
+            if (steps == 1 &&
+                UNSAFE.compareAndSwapLong(this, ctlOffset, c = ctl,
+                                          (((c - AC_UNIT) & AC_MASK) |
+                                           ((c - TC_UNIT) & TC_MASK) |
+                                           (c & ~(AC_MASK|TC_MASK)))))
+                steps = 2;
+            if (sc != 0 &&
+                UNSAFE.compareAndSwapLong(this, stealCountOffset,
+                                          s = stealCount, s + sc))
+                sc = 0;
+        } while (steps != 2 || sc != 0);
+        if (!tryTerminate(false)) {
+            if (ex != null)   // possibly replace if died abnormally
+                signalWork();
+            else
+                tryReleaseWaiter();
+        }
+    }
+
+    // Shutdown and termination
+
+    /**
+     * Possibly initiates and/or completes termination.
+     *
+     * @param now if true, unconditionally terminate, else only
+     * if shutdown and empty queue and no active workers
+     * @return true if now terminating or terminated
+     */
+    private boolean tryTerminate(boolean now) {
+        long c;
+        while (((c = ctl) & STOP_BIT) == 0) {
+            if (!now) {
+                if ((int)(c >> AC_SHIFT) != -parallelism)
+                    return false;
+                if (!shutdown || blockedCount != 0 || quiescerCount != 0 ||
+                    queueBase != queueTop) {
+                    if (ctl == c) // staleness check
+                        return false;
+                    continue;
+                }
+            }
+            if (UNSAFE.compareAndSwapLong(this, ctlOffset, c, c | STOP_BIT))
+                startTerminating();
+        }
+        if ((short)(c >>> TC_SHIFT) == -parallelism) { // signal when 0 workers
+            final ReentrantLock lock = this.submissionLock;
+            lock.lock();
+            try {
+                termination.signalAll();
+            } finally {
+                lock.unlock();
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Runs up to three passes through workers: (0) Setting
+     * termination status for each worker, followed by wakeups up to
+     * queued workers; (1) helping cancel tasks; (2) interrupting
+     * lagging threads (likely in external tasks, but possibly also
+     * blocked in joins).  Each pass repeats previous steps because of
+     * potential lagging thread creation.
+     */
+    private void startTerminating() {
+        cancelSubmissions();
+        for (int pass = 0; pass < 3; ++pass) {
+            ForkJoinWorkerThread[] ws = workers;
+            if (ws != null) {
+                for (ForkJoinWorkerThread w : ws) {
+                    if (w != null) {
+                        w.terminate = true;
+                        if (pass > 0) {
+                            w.cancelTasks();
+                            if (pass > 1 && !w.isInterrupted()) {
+                                try {
+                                    w.interrupt();
+                                } catch (SecurityException ignore) {
+                                }
+                            }
+                        }
+                    }
+                }
+                terminateWaiters();
+            }
+        }
+    }
+
+    /**
+     * Polls and cancels all submissions. Called only during termination.
+     */
+    private void cancelSubmissions() {
+        while (queueBase != queueTop) {
+            ForkJoinTask<?> task = pollSubmission();
+            if (task != null) {
+                try {
+                    task.cancel(false);
+                } catch (Throwable ignore) {
+                }
+            }
+        }
+    }
+
+    /**
+     * Tries to set the termination status of waiting workers, and
+     * then wakes them up (after which they will terminate).
+     */
+    private void terminateWaiters() {
+        ForkJoinWorkerThread[] ws = workers;
+        if (ws != null) {
+            ForkJoinWorkerThread w; long c; int i, e;
+            int n = ws.length;
+            while ((i = ~(e = (int)(c = ctl)) & SMASK) < n &&
+                   (w = ws[i]) != null && w.eventCount == (e & E_MASK)) {
+                if (UNSAFE.compareAndSwapLong(this, ctlOffset, c,
+                                              (long)(w.nextWait & E_MASK) |
+                                              ((c + AC_UNIT) & AC_MASK) |
+                                              (c & (TC_MASK|STOP_BIT)))) {
+                    w.terminate = true;
+                    w.eventCount = e + EC_UNIT;
+                    if (w.parked)
+                        UNSAFE.unpark(w);
+                }
+            }
+        }
+    }
+
+    // misc ForkJoinWorkerThread support
+
+    /**
+     * Increments or decrements quiescerCount. Needed only to prevent
+     * triggering shutdown if a worker is transiently inactive while
+     * checking quiescence.
+     *
+     * @param delta 1 for increment, -1 for decrement
+     */
+    final void addQuiescerCount(int delta) {
+        int c;
+        do {} while (!UNSAFE.compareAndSwapInt(this, quiescerCountOffset,
+                                               c = quiescerCount, c + delta));
+    }
+
+    /**
+     * Directly increments or decrements active count without queuing.
+     * This method is used to transiently assert inactivation while
+     * checking quiescence.
+     *
+     * @param delta 1 for increment, -1 for decrement
+     */
+    final void addActiveCount(int delta) {
+        long d = (long)delta << AC_SHIFT;
+        long c;
+        do {} while (!UNSAFE.compareAndSwapLong(this, ctlOffset,
+                                                c = ctl, c + d));
+    }
+
+    /**
+     * Returns the approximate (non-atomic) number of idle threads per
+     * active thread.
+     */
+    final int idlePerActive() {
+        // Approximate at powers of two for small values, saturate past 4
+        int p = parallelism;
+        int a = p + (int)(ctl >> AC_SHIFT);
+        return (a > (p >>>= 1) ? 0 :
+                a > (p >>>= 1) ? 1 :
+                a > (p >>>= 1) ? 2 :
+                a > (p >>>= 1) ? 4 :
+                8);
+    }
+
+    // Exported methods
+
+    // Constructors
+
+    /**
+     * Creates a {@code ForkJoinPool} with parallelism equal to {@link
+     * java.lang.Runtime#availableProcessors}, using the {@linkplain
+     * #defaultForkJoinWorkerThreadFactory default thread factory},
+     * no UncaughtExceptionHandler, and non-async LIFO processing mode.
+     */
+    public ForkJoinPool() {
+        this(Runtime.getRuntime().availableProcessors(),
+             defaultForkJoinWorkerThreadFactory, null, false);
+    }
+
+    /**
+     * Creates a {@code ForkJoinPool} with the indicated parallelism
+     * level, the {@linkplain
+     * #defaultForkJoinWorkerThreadFactory default thread factory},
+     * no UncaughtExceptionHandler, and non-async LIFO processing mode.
+     *
+     * @param parallelism the parallelism level
+     * @throws IllegalArgumentException if parallelism less than or
+     *         equal to zero, or greater than implementation limit
+     */
+    public ForkJoinPool(int parallelism) {
+        this(parallelism, defaultForkJoinWorkerThreadFactory, null, false);
+    }
+
+    /**
+     * Creates a {@code ForkJoinPool} with the given parameters.
+     *
+     * @param parallelism the parallelism level. For default value,
+     * use {@link java.lang.Runtime#availableProcessors}.
+     * @param factory the factory for creating new threads. For default value,
+     * use {@link #defaultForkJoinWorkerThreadFactory}.
+     * @param handler the handler for internal worker threads that
+     * terminate due to unrecoverable errors encountered while executing
+     * tasks. For default value, use {@code null}.
+     * @param asyncMode if true,
+     * establishes local first-in-first-out scheduling mode for forked
+     * tasks that are never joined. This mode may be more appropriate
+     * than default locally stack-based mode in applications in which
+     * worker threads only process event-style asynchronous tasks.
+     * For default value, use {@code false}.
+     * @throws IllegalArgumentException if parallelism less than or
+     *         equal to zero, or greater than implementation limit
+     * @throws NullPointerException if the factory is null
+     */
+    public ForkJoinPool(int parallelism,
+                        ForkJoinWorkerThreadFactory factory,
+                        Thread.UncaughtExceptionHandler handler,
+                        boolean asyncMode) {
+        checkPermission();
+        if (factory == null)
+            throw new NullPointerException();
+        if (parallelism <= 0 || parallelism > MAX_ID)
+            throw new IllegalArgumentException();
+        this.parallelism = parallelism;
+        this.factory = factory;
+        this.ueh = handler;
+        this.locallyFifo = asyncMode;
+        long np = (long)(-parallelism); // offset ctl counts
+        this.ctl = ((np << AC_SHIFT) & AC_MASK) | ((np << TC_SHIFT) & TC_MASK);
+        this.submissionQueue = new ForkJoinTask<?>[INITIAL_QUEUE_CAPACITY];
+        // initialize workers array with room for 2*parallelism if possible
+        int n = parallelism << 1;
+        if (n >= MAX_ID)
+            n = MAX_ID;
+        else { // See Hackers Delight, sec 3.2, where n < (1 << 16)
+            n |= n >>> 1; n |= n >>> 2; n |= n >>> 4; n |= n >>> 8;
+        }
+        workers = new ForkJoinWorkerThread[n + 1];
+        this.submissionLock = new ReentrantLock();
+        this.termination = submissionLock.newCondition();
+        StringBuilder sb = new StringBuilder("ForkJoinPool-");
+        sb.append(poolNumberGenerator.incrementAndGet());
+        sb.append("-worker-");
+        this.workerNamePrefix = sb.toString();
+    }
+
+    // Execution methods
+
+    /**
+     * Performs the given task, returning its result upon completion.
+     * If the computation encounters an unchecked Exception or Error,
+     * it is rethrown as the outcome of this invocation.  Rethrown
+     * exceptions behave in the same way as regular exceptions, but,
+     * when possible, contain stack traces (as displayed for example
+     * using {@code ex.printStackTrace()}) of both the current thread
+     * as well as the thread actually encountering the exception;
+     * minimally only the latter.
+     *
+     * @param task the task
+     * @return the task's result
+     * @throws NullPointerException if the task is null
+     * @throws RejectedExecutionException if the task cannot be
+     *         scheduled for execution
+     */
+    public <T> T invoke(ForkJoinTask<T> task) {
+        Thread t = Thread.currentThread();
+        if (task == null)
+            throw new NullPointerException();
+        if (shutdown)
+            throw new RejectedExecutionException();
+        if ((t instanceof ForkJoinWorkerThread) &&
+            ((ForkJoinWorkerThread)t).pool == this)
+            return task.invoke();  // bypass submit if in same pool
+        else {
+            addSubmission(task);
+            return task.join();
+        }
+    }
+
+    /**
+     * Unless terminating, forks task if within an ongoing FJ
+     * computation in the current pool, else submits as external task.
+     */
+    private <T> void forkOrSubmit(ForkJoinTask<T> task) {
+        ForkJoinWorkerThread w;
+        Thread t = Thread.currentThread();
+        if (shutdown)
+            throw new RejectedExecutionException();
+        if ((t instanceof ForkJoinWorkerThread) &&
+            (w = (ForkJoinWorkerThread)t).pool == this)
+            w.pushTask(task);
+        else
+            addSubmission(task);
+    }
+
+    /**
+     * Arranges for (asynchronous) execution of the given task.
+     *
+     * @param task the task
+     * @throws NullPointerException if the task is null
+     * @throws RejectedExecutionException if the task cannot be
+     *         scheduled for execution
+     */
+    public void execute(ForkJoinTask<?> task) {
+        if (task == null)
+            throw new NullPointerException();
+        forkOrSubmit(task);
+    }
+
+    // AbstractExecutorService methods
+
+    /**
+     * @throws NullPointerException if the task is null
+     * @throws RejectedExecutionException if the task cannot be
+     *         scheduled for execution
+     */
+    public void execute(Runnable task) {
+        if (task == null)
+            throw new NullPointerException();
+        ForkJoinTask<?> job;
+        if (task instanceof ForkJoinTask<?>) // avoid re-wrap
+            job = (ForkJoinTask<?>) task;
+        else
+            job = ForkJoinTask.adapt(task, null);
+        forkOrSubmit(job);
+    }
+
+    /**
+     * Submits a ForkJoinTask for execution.
+     *
+     * @param task the task to submit
+     * @return the task
+     * @throws NullPointerException if the task is null
+     * @throws RejectedExecutionException if the task cannot be
+     *         scheduled for execution
+     */
+    public <T> ForkJoinTask<T> submit(ForkJoinTask<T> task) {
+        if (task == null)
+            throw new NullPointerException();
+        forkOrSubmit(task);
+        return task;
+    }
+
+    /**
+     * @throws NullPointerException if the task is null
+     * @throws RejectedExecutionException if the task cannot be
+     *         scheduled for execution
+     */
+    public <T> ForkJoinTask<T> submit(Callable<T> task) {
+        if (task == null)
+            throw new NullPointerException();
+        ForkJoinTask<T> job = ForkJoinTask.adapt(task);
+        forkOrSubmit(job);
+        return job;
+    }
+
+    /**
+     * @throws NullPointerException if the task is null
+     * @throws RejectedExecutionException if the task cannot be
+     *         scheduled for execution
+     */
+    public <T> ForkJoinTask<T> submit(Runnable task, T result) {
+        if (task == null)
+            throw new NullPointerException();
+        ForkJoinTask<T> job = ForkJoinTask.adapt(task, result);
+        forkOrSubmit(job);
+        return job;
+    }
+
+    /**
+     * @throws NullPointerException if the task is null
+     * @throws RejectedExecutionException if the task cannot be
+     *         scheduled for execution
+     */
+    public ForkJoinTask<?> submit(Runnable task) {
+        if (task == null)
+            throw new NullPointerException();
+        ForkJoinTask<?> job;
+        if (task instanceof ForkJoinTask<?>) // avoid re-wrap
+            job = (ForkJoinTask<?>) task;
+        else
+            job = ForkJoinTask.adapt(task, null);
+        forkOrSubmit(job);
+        return job;
+    }
+
+    /**
+     * @throws NullPointerException       {@inheritDoc}
+     * @throws RejectedExecutionException {@inheritDoc}
+     */
+    public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> tasks) {
+        ArrayList<ForkJoinTask<T>> forkJoinTasks =
+            new ArrayList<ForkJoinTask<T>>(tasks.size());
+        for (Callable<T> task : tasks)
+            forkJoinTasks.add(ForkJoinTask.adapt(task));
+        invoke(new InvokeAll<T>(forkJoinTasks));
+
+        @SuppressWarnings({"unchecked", "rawtypes"})
+            List<Future<T>> futures = (List<Future<T>>) (List) forkJoinTasks;
+        return futures;
+    }
+
+    static final class InvokeAll<T> extends RecursiveAction {
+        final ArrayList<ForkJoinTask<T>> tasks;
+        InvokeAll(ArrayList<ForkJoinTask<T>> tasks) { this.tasks = tasks; }
+        public void compute() {
+            try { invokeAll(tasks); }
+            catch (Exception ignore) {}
+        }
+        private static final long serialVersionUID = -7914297376763021607L;
+    }
+
+    /**
+     * Returns the factory used for constructing new workers.
+     *
+     * @return the factory used for constructing new workers
+     */
+    public ForkJoinWorkerThreadFactory getFactory() {
+        return factory;
+    }
+
+    /**
+     * Returns the handler for internal worker threads that terminate
+     * due to unrecoverable errors encountered while executing tasks.
+     *
+     * @return the handler, or {@code null} if none
+     */
+    public Thread.UncaughtExceptionHandler getUncaughtExceptionHandler() {
+        return ueh;
+    }
+
+    /**
+     * Returns the targeted parallelism level of this pool.
+     *
+     * @return the targeted parallelism level of this pool
+     */
+    public int getParallelism() {
+        return parallelism;
+    }
+
+    /**
+     * Returns the number of worker threads that have started but not
+     * yet terminated.  The result returned by this method may differ
+     * from {@link #getParallelism} when threads are created to
+     * maintain parallelism when others are cooperatively blocked.
+     *
+     * @return the number of worker threads
+     */
+    public int getPoolSize() {
+        return parallelism + (short)(ctl >>> TC_SHIFT);
+    }
+
+    /**
+     * Returns {@code true} if this pool uses local first-in-first-out
+     * scheduling mode for forked tasks that are never joined.
+     *
+     * @return {@code true} if this pool uses async mode
+     */
+    public boolean getAsyncMode() {
+        return locallyFifo;
+    }
+
+    /**
+     * Returns an estimate of the number of worker threads that are
+     * not blocked waiting to join tasks or for other managed
+     * synchronization. This method may overestimate the
+     * number of running threads.
+     *
+     * @return the number of worker threads
+     */
+    public int getRunningThreadCount() {
+        int r = parallelism + (int)(ctl >> AC_SHIFT);
+        return (r <= 0) ? 0 : r; // suppress momentarily negative values
+    }
+
+    /**
+     * Returns an estimate of the number of threads that are currently
+     * stealing or executing tasks. This method may overestimate the
+     * number of active threads.
+     *
+     * @return the number of active threads
+     */
+    public int getActiveThreadCount() {
+        int r = parallelism + (int)(ctl >> AC_SHIFT) + blockedCount;
+        return (r <= 0) ? 0 : r; // suppress momentarily negative values
+    }
+
+    /**
+     * Returns {@code true} if all worker threads are currently idle.
+     * An idle worker is one that cannot obtain a task to execute
+     * because none are available to steal from other threads, and
+     * there are no pending submissions to the pool. This method is
+     * conservative; it might not return {@code true} immediately upon
+     * idleness of all threads, but will eventually become true if
+     * threads remain inactive.
+     *
+     * @return {@code true} if all threads are currently idle
+     */
+    public boolean isQuiescent() {
+        return parallelism + (int)(ctl >> AC_SHIFT) + blockedCount == 0;
+    }
+
+    /**
+     * Returns an estimate of the total number of tasks stolen from
+     * one thread's work queue by another. The reported value
+     * underestimates the actual total number of steals when the pool
+     * is not quiescent. This value may be useful for monitoring and
+     * tuning fork/join programs: in general, steal counts should be
+     * high enough to keep threads busy, but low enough to avoid
+     * overhead and contention across threads.
+     *
+     * @return the number of steals
+     */
+    public long getStealCount() {
+        return stealCount;
+    }
+
+    /**
+     * Returns an estimate of the total number of tasks currently held
+     * in queues by worker threads (but not including tasks submitted
+     * to the pool that have not begun executing). This value is only
+     * an approximation, obtained by iterating across all threads in
+     * the pool. This method may be useful for tuning task
+     * granularities.
+     *
+     * @return the number of queued tasks
+     */
+    public long getQueuedTaskCount() {
+        long count = 0;
+        ForkJoinWorkerThread[] ws;
+        if ((short)(ctl >>> TC_SHIFT) > -parallelism &&
+            (ws = workers) != null) {
+            for (ForkJoinWorkerThread w : ws)
+                if (w != null)
+                    count -= w.queueBase - w.queueTop; // must read base first
+        }
+        return count;
+    }
+
+    /**
+     * Returns an estimate of the number of tasks submitted to this
+     * pool that have not yet begun executing.  This method may take
+     * time proportional to the number of submissions.
+     *
+     * @return the number of queued submissions
+     */
+    public int getQueuedSubmissionCount() {
+        return -queueBase + queueTop;
+    }
+
+    /**
+     * Returns {@code true} if there are any tasks submitted to this
+     * pool that have not yet begun executing.
+     *
+     * @return {@code true} if there are any queued submissions
+     */
+    public boolean hasQueuedSubmissions() {
+        return queueBase != queueTop;
+    }
+
+    /**
+     * Removes and returns the next unexecuted submission if one is
+     * available.  This method may be useful in extensions to this
+     * class that re-assign work in systems with multiple pools.
+     *
+     * @return the next submission, or {@code null} if none
+     */
+    protected ForkJoinTask<?> pollSubmission() {
+        ForkJoinTask<?> t; ForkJoinTask<?>[] q; int b, i;
+        while ((b = queueBase) != queueTop &&
+               (q = submissionQueue) != null &&
+               (i = (q.length - 1) & b) >= 0) {
+            long u = (i << ASHIFT) + ABASE;
+            if ((t = q[i]) != null &&
+                queueBase == b &&
+                UNSAFE.compareAndSwapObject(q, u, t, null)) {
+                queueBase = b + 1;
+                return t;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Removes all available unexecuted submitted and forked tasks
+     * from scheduling queues and adds them to the given collection,
+     * without altering their execution status. These may include
+     * artificially generated or wrapped tasks. This method is
+     * designed to be invoked only when the pool is known to be
+     * quiescent. Invocations at other times may not remove all
+     * tasks. A failure encountered while attempting to add elements
+     * to collection {@code c} may result in elements being in
+     * neither, either or both collections when the associated
+     * exception is thrown.  The behavior of this operation is
+     * undefined if the specified collection is modified while the
+     * operation is in progress.
+     *
+     * @param c the collection to transfer elements into
+     * @return the number of elements transferred
+     */
+    protected int drainTasksTo(Collection<? super ForkJoinTask<?>> c) {
+        int count = 0;
+        while (queueBase != queueTop) {
+            ForkJoinTask<?> t = pollSubmission();
+            if (t != null) {
+                c.add(t);
+                ++count;
+            }
+        }
+        ForkJoinWorkerThread[] ws;
+        if ((short)(ctl >>> TC_SHIFT) > -parallelism &&
+            (ws = workers) != null) {
+            for (ForkJoinWorkerThread w : ws)
+                if (w != null)
+                    count += w.drainTasksTo(c);
+        }
+        return count;
+    }
+
+    /**
+     * Returns a string identifying this pool, as well as its state,
+     * including indications of run state, parallelism level, and
+     * worker and task counts.
+     *
+     * @return a string identifying this pool, as well as its state
+     */
+    public String toString() {
+        long st = getStealCount();
+        long qt = getQueuedTaskCount();
+        long qs = getQueuedSubmissionCount();
+        int pc = parallelism;
+        long c = ctl;
+        int tc = pc + (short)(c >>> TC_SHIFT);
+        int rc = pc + (int)(c >> AC_SHIFT);
+        if (rc < 0) // ignore transient negative
+            rc = 0;
+        int ac = rc + blockedCount;
+        String level;
+        if ((c & STOP_BIT) != 0)
+            level = (tc == 0) ? "Terminated" : "Terminating";
+        else
+            level = shutdown ? "Shutting down" : "Running";
+        return super.toString() +
+            "[" + level +
+            ", parallelism = " + pc +
+            ", size = " + tc +
+            ", active = " + ac +
+            ", running = " + rc +
+            ", steals = " + st +
+            ", tasks = " + qt +
+            ", submissions = " + qs +
+            "]";
+    }
+
+    /**
+     * Initiates an orderly shutdown in which previously submitted
+     * tasks are executed, but no new tasks will be accepted.
+     * Invocation has no additional effect if already shut down.
+     * Tasks that are in the process of being submitted concurrently
+     * during the course of this method may or may not be rejected.
+     */
+    public void shutdown() {
+        checkPermission();
+        shutdown = true;
+        tryTerminate(false);
+    }
+
+    /**
+     * Attempts to cancel and/or stop all tasks, and reject all
+     * subsequently submitted tasks.  Tasks that are in the process of
+     * being submitted or executed concurrently during the course of
+     * this method may or may not be rejected. This method cancels
+     * both existing and unexecuted tasks, in order to permit
+     * termination in the presence of task dependencies. So the method
+     * always returns an empty list (unlike the case for some other
+     * Executors).
+     *
+     * @return an empty list
+     */
+    public List<Runnable> shutdownNow() {
+        checkPermission();
+        shutdown = true;
+        tryTerminate(true);
+        return Collections.emptyList();
+    }
+
+    /**
+     * Returns {@code true} if all tasks have completed following shut down.
+     *
+     * @return {@code true} if all tasks have completed following shut down
+     */
+    public boolean isTerminated() {
+        long c = ctl;
+        return ((c & STOP_BIT) != 0L &&
+                (short)(c >>> TC_SHIFT) == -parallelism);
+    }
+
+    /**
+     * Returns {@code true} if the process of termination has
+     * commenced but not yet completed.  This method may be useful for
+     * debugging. A return of {@code true} reported a sufficient
+     * period after shutdown may indicate that submitted tasks have
+     * ignored or suppressed interruption, or are waiting for IO,
+     * causing this executor not to properly terminate. (See the
+     * advisory notes for class {@link ForkJoinTask} stating that
+     * tasks should not normally entail blocking operations.  But if
+     * they do, they must abort them on interrupt.)
+     *
+     * @return {@code true} if terminating but not yet terminated
+     */
+    public boolean isTerminating() {
+        long c = ctl;
+        return ((c & STOP_BIT) != 0L &&
+                (short)(c >>> TC_SHIFT) != -parallelism);
+    }
+
+    /**
+     * Returns true if terminating or terminated. Used by ForkJoinWorkerThread.
+     */
+    final boolean isAtLeastTerminating() {
+        return (ctl & STOP_BIT) != 0L;
+    }
+
+    /**
+     * Returns {@code true} if this pool has been shut down.
+     *
+     * @return {@code true} if this pool has been shut down
+     */
+    public boolean isShutdown() {
+        return shutdown;
+    }
+
+    /**
+     * Blocks until all tasks have completed execution after a shutdown
+     * request, or the timeout occurs, or the current thread is
+     * interrupted, whichever happens first.
+     *
+     * @param timeout the maximum time to wait
+     * @param unit the time unit of the timeout argument
+     * @return {@code true} if this executor terminated and
+     *         {@code false} if the timeout elapsed before termination
+     * @throws InterruptedException if interrupted while waiting
+     */
+    public boolean awaitTermination(long timeout, TimeUnit unit)
+        throws InterruptedException {
+        long nanos = unit.toNanos(timeout);
+        final ReentrantLock lock = this.submissionLock;
+        lock.lock();
+        try {
+            for (;;) {
+                if (isTerminated())
+                    return true;
+                if (nanos <= 0)
+                    return false;
+                nanos = termination.awaitNanos(nanos);
+            }
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    /**
+     * Interface for extending managed parallelism for tasks running
+     * in {@link ForkJoinPool}s.
+     *
+     * <p>A {@code ManagedBlocker} provides two methods.  Method
+     * {@code isReleasable} must return {@code true} if blocking is
+     * not necessary. Method {@code block} blocks the current thread
+     * if necessary (perhaps internally invoking {@code isReleasable}
+     * before actually blocking). These actions are performed by any
+     * thread invoking {@link ForkJoinPool#managedBlock}.  The
+     * unusual methods in this API accommodate synchronizers that may,
+     * but don't usually, block for long periods. Similarly, they
+     * allow more efficient internal handling of cases in which
+     * additional workers may be, but usually are not, needed to
+     * ensure sufficient parallelism.  Toward this end,
+     * implementations of method {@code isReleasable} must be amenable
+     * to repeated invocation.
+     *
+     * <p>For example, here is a ManagedBlocker based on a
+     * ReentrantLock:
+     *  <pre> {@code
+     * class ManagedLocker implements ManagedBlocker {
+     *   final ReentrantLock lock;
+     *   boolean hasLock = false;
+     *   ManagedLocker(ReentrantLock lock) { this.lock = lock; }
+     *   public boolean block() {
+     *     if (!hasLock)
+     *       lock.lock();
+     *     return true;
+     *   }
+     *   public boolean isReleasable() {
+     *     return hasLock || (hasLock = lock.tryLock());
+     *   }
+     * }}</pre>
+     *
+     * <p>Here is a class that possibly blocks waiting for an
+     * item on a given queue:
+     *  <pre> {@code
+     * class QueueTaker<E> implements ManagedBlocker {
+     *   final BlockingQueue<E> queue;
+     *   volatile E item = null;
+     *   QueueTaker(BlockingQueue<E> q) { this.queue = q; }
+     *   public boolean block() throws InterruptedException {
+     *     if (item == null)
+     *       item = queue.take();
+     *     return true;
+     *   }
+     *   public boolean isReleasable() {
+     *     return item != null || (item = queue.poll()) != null;
+     *   }
+     *   public E getItem() { // call after pool.managedBlock completes
+     *     return item;
+     *   }
+     * }}</pre>
+     */
+    public static interface ManagedBlocker {
+        /**
+         * Possibly blocks the current thread, for example waiting for
+         * a lock or condition.
+         *
+         * @return {@code true} if no additional blocking is necessary
+         * (i.e., if isReleasable would return true)
+         * @throws InterruptedException if interrupted while waiting
+         * (the method is not required to do so, but is allowed to)
+         */
+        boolean block() throws InterruptedException;
+
+        /**
+         * Returns {@code true} if blocking is unnecessary.
+         */
+        boolean isReleasable();
+    }
+
+    /**
+     * Blocks in accord with the given blocker.  If the current thread
+     * is a {@link ForkJoinWorkerThread}, this method possibly
+     * arranges for a spare thread to be activated if necessary to
+     * ensure sufficient parallelism while the current thread is blocked.
+     *
+     * <p>If the caller is not a {@link ForkJoinTask}, this method is
+     * behaviorally equivalent to
+     *  <pre> {@code
+     * while (!blocker.isReleasable())
+     *   if (blocker.block())
+     *     return;
+     * }</pre>
+     *
+     * If the caller is a {@code ForkJoinTask}, then the pool may
+     * first be expanded to ensure parallelism, and later adjusted.
+     *
+     * @param blocker the blocker
+     * @throws InterruptedException if blocker.block did so
+     */
+    public static void managedBlock(ManagedBlocker blocker)
+        throws InterruptedException {
+        Thread t = Thread.currentThread();
+        if (t instanceof ForkJoinWorkerThread) {
+            ForkJoinWorkerThread w = (ForkJoinWorkerThread) t;
+            w.pool.awaitBlocker(blocker);
+        }
+        else {
+            do {} while (!blocker.isReleasable() && !blocker.block());
+        }
+    }
+
+    // AbstractExecutorService overrides.  These rely on undocumented
+    // fact that ForkJoinTask.adapt returns ForkJoinTasks that also
+    // implement RunnableFuture.
+
+    protected <T> RunnableFuture<T> newTaskFor(Runnable runnable, T value) {
+        return (RunnableFuture<T>) ForkJoinTask.adapt(runnable, value);
+    }
+
+    protected <T> RunnableFuture<T> newTaskFor(Callable<T> callable) {
+        return (RunnableFuture<T>) ForkJoinTask.adapt(callable);
+    }
+
+    // Unsafe mechanics
+    private static final sun.misc.Unsafe UNSAFE;
+    private static final long ctlOffset;
+    private static final long stealCountOffset;
+    private static final long blockedCountOffset;
+    private static final long quiescerCountOffset;
+    private static final long scanGuardOffset;
+    private static final long nextWorkerNumberOffset;
+    private static final long ABASE;
+    private static final int ASHIFT;
+
+    static {
+        poolNumberGenerator = new AtomicInteger();
+        workerSeedGenerator = new Random();
+        modifyThreadPermission = new RuntimePermission("modifyThread");
+        defaultForkJoinWorkerThreadFactory =
+            new DefaultForkJoinWorkerThreadFactory();
+        try {
+            UNSAFE = sun.misc.Unsafe.getUnsafe();
+            Class<?> k = ForkJoinPool.class;
+            ctlOffset = UNSAFE.objectFieldOffset
+                (k.getDeclaredField("ctl"));
+            stealCountOffset = UNSAFE.objectFieldOffset
+                (k.getDeclaredField("stealCount"));
+            blockedCountOffset = UNSAFE.objectFieldOffset
+                (k.getDeclaredField("blockedCount"));
+            quiescerCountOffset = UNSAFE.objectFieldOffset
+                (k.getDeclaredField("quiescerCount"));
+            scanGuardOffset = UNSAFE.objectFieldOffset
+                (k.getDeclaredField("scanGuard"));
+            nextWorkerNumberOffset = UNSAFE.objectFieldOffset
+                (k.getDeclaredField("nextWorkerNumber"));
+        } catch (Exception e) {
+            throw new Error(e);
+        }
+        Class<?> a = ForkJoinTask[].class;
+        ABASE = UNSAFE.arrayBaseOffset(a);
+        int s = UNSAFE.arrayIndexScale(a);
+        if ((s & (s-1)) != 0)
+            throw new Error("data type scale not a power of two");
+        ASHIFT = 31 - Integer.numberOfLeadingZeros(s);
+    }
+
+}
diff --git a/luni/src/main/java/java/util/concurrent/ForkJoinTask.java b/luni/src/main/java/java/util/concurrent/ForkJoinTask.java
new file mode 100644
index 0000000..86a29d7
--- /dev/null
+++ b/luni/src/main/java/java/util/concurrent/ForkJoinTask.java
@@ -0,0 +1,1357 @@
+/*
+ * Written by Doug Lea with assistance from members of JCP JSR-166
+ * Expert Group and released to the public domain, as explained at
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+package java.util.concurrent;
+
+import java.io.Serializable;
+import java.util.Collection;
+import java.util.List;
+import java.util.RandomAccess;
+import java.lang.ref.WeakReference;
+import java.lang.ref.ReferenceQueue;
+import java.util.concurrent.Callable;
+import java.util.concurrent.CancellationException;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import java.util.concurrent.RejectedExecutionException;
+import java.util.concurrent.RunnableFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.locks.ReentrantLock;
+import java.lang.reflect.Constructor;
+import libcore.util.SneakyThrow;
+
+/**
+ * Abstract base class for tasks that run within a {@link ForkJoinPool}.
+ * A {@code ForkJoinTask} is a thread-like entity that is much
+ * lighter weight than a normal thread.  Huge numbers of tasks and
+ * subtasks may be hosted by a small number of actual threads in a
+ * ForkJoinPool, at the price of some usage limitations.
+ *
+ * <p>A "main" {@code ForkJoinTask} begins execution when submitted
+ * to a {@link ForkJoinPool}.  Once started, it will usually in turn
+ * start other subtasks.  As indicated by the name of this class,
+ * many programs using {@code ForkJoinTask} employ only methods
+ * {@link #fork} and {@link #join}, or derivatives such as {@link
+ * #invokeAll(ForkJoinTask...) invokeAll}.  However, this class also
+ * provides a number of other methods that can come into play in
+ * advanced usages, as well as extension mechanics that allow
+ * support of new forms of fork/join processing.
+ *
+ * <p>A {@code ForkJoinTask} is a lightweight form of {@link Future}.
+ * The efficiency of {@code ForkJoinTask}s stems from a set of
+ * restrictions (that are only partially statically enforceable)
+ * reflecting their intended use as computational tasks calculating
+ * pure functions or operating on purely isolated objects.  The
+ * primary coordination mechanisms are {@link #fork}, that arranges
+ * asynchronous execution, and {@link #join}, that doesn't proceed
+ * until the task's result has been computed.  Computations should
+ * avoid {@code synchronized} methods or blocks, and should minimize
+ * other blocking synchronization apart from joining other tasks or
+ * using synchronizers such as Phasers that are advertised to
+ * cooperate with fork/join scheduling. Tasks should also not perform
+ * blocking IO, and should ideally access variables that are
+ * completely independent of those accessed by other running
+ * tasks. Minor breaches of these restrictions, for example using
+ * shared output streams, may be tolerable in practice, but frequent
+ * use may result in poor performance, and the potential to
+ * indefinitely stall if the number of threads not waiting for IO or
+ * other external synchronization becomes exhausted. This usage
+ * restriction is in part enforced by not permitting checked
+ * exceptions such as {@code IOExceptions} to be thrown. However,
+ * computations may still encounter unchecked exceptions, that are
+ * rethrown to callers attempting to join them. These exceptions may
+ * additionally include {@link RejectedExecutionException} stemming
+ * from internal resource exhaustion, such as failure to allocate
+ * internal task queues. Rethrown exceptions behave in the same way as
+ * regular exceptions, but, when possible, contain stack traces (as
+ * displayed for example using {@code ex.printStackTrace()}) of both
+ * the thread that initiated the computation as well as the thread
+ * actually encountering the exception; minimally only the latter.
+ *
+ * <p>The primary method for awaiting completion and extracting
+ * results of a task is {@link #join}, but there are several variants:
+ * The {@link Future#get} methods support interruptible and/or timed
+ * waits for completion and report results using {@code Future}
+ * conventions. Method {@link #invoke} is semantically
+ * equivalent to {@code fork(); join()} but always attempts to begin
+ * execution in the current thread. The "<em>quiet</em>" forms of
+ * these methods do not extract results or report exceptions. These
+ * may be useful when a set of tasks are being executed, and you need
+ * to delay processing of results or exceptions until all complete.
+ * Method {@code invokeAll} (available in multiple versions)
+ * performs the most common form of parallel invocation: forking a set
+ * of tasks and joining them all.
+ *
+ * <p>The execution status of tasks may be queried at several levels
+ * of detail: {@link #isDone} is true if a task completed in any way
+ * (including the case where a task was cancelled without executing);
+ * {@link #isCompletedNormally} is true if a task completed without
+ * cancellation or encountering an exception; {@link #isCancelled} is
+ * true if the task was cancelled (in which case {@link #getException}
+ * returns a {@link java.util.concurrent.CancellationException}); and
+ * {@link #isCompletedAbnormally} is true if a task was either
+ * cancelled or encountered an exception, in which case {@link
+ * #getException} will return either the encountered exception or
+ * {@link java.util.concurrent.CancellationException}.
+ *
+ * <p>The ForkJoinTask class is not usually directly subclassed.
+ * Instead, you subclass one of the abstract classes that support a
+ * particular style of fork/join processing, typically {@link
+ * RecursiveAction} for computations that do not return results, or
+ * {@link RecursiveTask} for those that do.  Normally, a concrete
+ * ForkJoinTask subclass declares fields comprising its parameters,
+ * established in a constructor, and then defines a {@code compute}
+ * method that somehow uses the control methods supplied by this base
+ * class. While these methods have {@code public} access (to allow
+ * instances of different task subclasses to call each other's
+ * methods), some of them may only be called from within other
+ * ForkJoinTasks (as may be determined using method {@link
+ * #inForkJoinPool}).  Attempts to invoke them in other contexts
+ * result in exceptions or errors, possibly including
+ * {@code ClassCastException}.
+ *
+ * <p>Method {@link #join} and its variants are appropriate for use
+ * only when completion dependencies are acyclic; that is, the
+ * parallel computation can be described as a directed acyclic graph
+ * (DAG). Otherwise, executions may encounter a form of deadlock as
+ * tasks cyclically wait for each other.  However, this framework
+ * supports other methods and techniques (for example the use of
+ * {@link Phaser}, {@link #helpQuiesce}, and {@link #complete}) that
+ * may be of use in constructing custom subclasses for problems that
+ * are not statically structured as DAGs.
+ *
+ * <p>Most base support methods are {@code final}, to prevent
+ * overriding of implementations that are intrinsically tied to the
+ * underlying lightweight task scheduling framework.  Developers
+ * creating new basic styles of fork/join processing should minimally
+ * implement {@code protected} methods {@link #exec}, {@link
+ * #setRawResult}, and {@link #getRawResult}, while also introducing
+ * an abstract computational method that can be implemented in its
+ * subclasses, possibly relying on other {@code protected} methods
+ * provided by this class.
+ *
+ * <p>ForkJoinTasks should perform relatively small amounts of
+ * computation. Large tasks should be split into smaller subtasks,
+ * usually via recursive decomposition. As a very rough rule of thumb,
+ * a task should perform more than 100 and less than 10000 basic
+ * computational steps, and should avoid indefinite looping. If tasks
+ * are too big, then parallelism cannot improve throughput. If too
+ * small, then memory and internal task maintenance overhead may
+ * overwhelm processing.
+ *
+ * <p>This class provides {@code adapt} methods for {@link Runnable}
+ * and {@link Callable}, that may be of use when mixing execution of
+ * {@code ForkJoinTasks} with other kinds of tasks. When all tasks are
+ * of this form, consider using a pool constructed in <em>asyncMode</em>.
+ *
+ * <p>ForkJoinTasks are {@code Serializable}, which enables them to be
+ * used in extensions such as remote execution frameworks. It is
+ * sensible to serialize tasks only before or after, but not during,
+ * execution. Serialization is not relied on during execution itself.
+ *
+ * @since 1.7
+ * @hide
+ * @author Doug Lea
+ */
+public abstract class ForkJoinTask<V> implements Future<V>, Serializable {
+
+    /*
+     * See the internal documentation of class ForkJoinPool for a
+     * general implementation overview.  ForkJoinTasks are mainly
+     * responsible for maintaining their "status" field amidst relays
+     * to methods in ForkJoinWorkerThread and ForkJoinPool.
+     *
+     * The methods of this class are more-or-less layered into
+     * (1) basic status maintenance
+     * (2) execution and awaiting completion
+     * (3) user-level methods that additionally report results.
+     * This is sometimes hard to see because this file orders exported
+     * methods in a way that flows well in javadocs.
+     */
+
+    /*
+     * The status field holds run control status bits packed into a
+     * single int to minimize footprint and to ensure atomicity (via
+     * CAS).  Status is initially zero, and takes on nonnegative
+     * values until completed, upon which status holds value
+     * NORMAL, CANCELLED, or EXCEPTIONAL. Tasks undergoing blocking
+     * waits by other threads have the SIGNAL bit set.  Completion of
+     * a stolen task with SIGNAL set awakens any waiters via
+     * notifyAll. Even though suboptimal for some purposes, we use
+     * basic builtin wait/notify to take advantage of "monitor
+     * inflation" in JVMs that we would otherwise need to emulate to
+     * avoid adding further per-task bookkeeping overhead.  We want
+     * these monitors to be "fat", i.e., not use biasing or thin-lock
+     * techniques, so use some odd coding idioms that tend to avoid
+     * them.
+     */
+
+    /** The run status of this task */
+    volatile int status; // accessed directly by pool and workers
+    private static final int NORMAL      = -1;
+    private static final int CANCELLED   = -2;
+    private static final int EXCEPTIONAL = -3;
+    private static final int SIGNAL      =  1;
+
+    /**
+     * Marks completion and wakes up threads waiting to join this task,
+     * also clearing signal request bits.
+     *
+     * @param completion one of NORMAL, CANCELLED, EXCEPTIONAL
+     * @return completion status on exit
+     */
+    private int setCompletion(int completion) {
+        for (int s;;) {
+            if ((s = status) < 0)
+                return s;
+            if (UNSAFE.compareAndSwapInt(this, statusOffset, s, completion)) {
+                if (s != 0)
+                    synchronized (this) { notifyAll(); }
+                return completion;
+            }
+        }
+    }
+
+    /**
+     * Tries to block a worker thread until completed or timed out.
+     * Uses Object.wait time argument conventions.
+     * May fail on contention or interrupt.
+     *
+     * @param millis if > 0, wait time.
+     */
+    final void tryAwaitDone(long millis) {
+        int s;
+        try {
+            if (((s = status) > 0 ||
+                 (s == 0 &&
+                  UNSAFE.compareAndSwapInt(this, statusOffset, 0, SIGNAL))) &&
+                status > 0) {
+                synchronized (this) {
+                    if (status > 0)
+                        wait(millis);
+                }
+            }
+        } catch (InterruptedException ie) {
+            // caller must check termination
+        }
+    }
+
+    /**
+     * Blocks a non-worker-thread until completion.
+     * @return status upon completion
+     */
+    private int externalAwaitDone() {
+        int s;
+        if ((s = status) >= 0) {
+            boolean interrupted = false;
+            synchronized (this) {
+                while ((s = status) >= 0) {
+                    if (s == 0)
+                        UNSAFE.compareAndSwapInt(this, statusOffset,
+                                                 0, SIGNAL);
+                    else {
+                        try {
+                            wait();
+                        } catch (InterruptedException ie) {
+                            interrupted = true;
+                        }
+                    }
+                }
+            }
+            if (interrupted)
+                Thread.currentThread().interrupt();
+        }
+        return s;
+    }
+
+    /**
+     * Blocks a non-worker-thread until completion or interruption or timeout.
+     */
+    private int externalInterruptibleAwaitDone(long millis)
+        throws InterruptedException {
+        int s;
+        if (Thread.interrupted())
+            throw new InterruptedException();
+        if ((s = status) >= 0) {
+            synchronized (this) {
+                while ((s = status) >= 0) {
+                    if (s == 0)
+                        UNSAFE.compareAndSwapInt(this, statusOffset,
+                                                 0, SIGNAL);
+                    else {
+                        wait(millis);
+                        if (millis > 0L)
+                            break;
+                    }
+                }
+            }
+        }
+        return s;
+    }
+
+    /**
+     * Primary execution method for stolen tasks. Unless done, calls
+     * exec and records status if completed, but doesn't wait for
+     * completion otherwise.
+     */
+    final void doExec() {
+        if (status >= 0) {
+            boolean completed;
+            try {
+                completed = exec();
+            } catch (Throwable rex) {
+                setExceptionalCompletion(rex);
+                return;
+            }
+            if (completed)
+                setCompletion(NORMAL); // must be outside try block
+        }
+    }
+
+    /**
+     * Primary mechanics for join, get, quietlyJoin.
+     * @return status upon completion
+     */
+    private int doJoin() {
+        Thread t; ForkJoinWorkerThread w; int s; boolean completed;
+        if ((t = Thread.currentThread()) instanceof ForkJoinWorkerThread) {
+            if ((s = status) < 0)
+                return s;
+            if ((w = (ForkJoinWorkerThread)t).unpushTask(this)) {
+                try {
+                    completed = exec();
+                } catch (Throwable rex) {
+                    return setExceptionalCompletion(rex);
+                }
+                if (completed)
+                    return setCompletion(NORMAL);
+            }
+            return w.joinTask(this);
+        }
+        else
+            return externalAwaitDone();
+    }
+
+    /**
+     * Primary mechanics for invoke, quietlyInvoke.
+     * @return status upon completion
+     */
+    private int doInvoke() {
+        int s; boolean completed;
+        if ((s = status) < 0)
+            return s;
+        try {
+            completed = exec();
+        } catch (Throwable rex) {
+            return setExceptionalCompletion(rex);
+        }
+        if (completed)
+            return setCompletion(NORMAL);
+        else
+            return doJoin();
+    }
+
+    // Exception table support
+
+    /**
+     * Table of exceptions thrown by tasks, to enable reporting by
+     * callers. Because exceptions are rare, we don't directly keep
+     * them with task objects, but instead use a weak ref table.  Note
+     * that cancellation exceptions don't appear in the table, but are
+     * instead recorded as status values.
+     *
+     * Note: These statics are initialized below in static block.
+     */
+    private static final ExceptionNode[] exceptionTable;
+    private static final ReentrantLock exceptionTableLock;
+    private static final ReferenceQueue<Object> exceptionTableRefQueue;
+
+    /**
+     * Fixed capacity for exceptionTable.
+     */
+    private static final int EXCEPTION_MAP_CAPACITY = 32;
+
+    /**
+     * Key-value nodes for exception table.  The chained hash table
+     * uses identity comparisons, full locking, and weak references
+     * for keys. The table has a fixed capacity because it only
+     * maintains task exceptions long enough for joiners to access
+     * them, so should never become very large for sustained
+     * periods. However, since we do not know when the last joiner
+     * completes, we must use weak references and expunge them. We do
+     * so on each operation (hence full locking). Also, some thread in
+     * any ForkJoinPool will call helpExpungeStaleExceptions when its
+     * pool becomes isQuiescent.
+     */
+    static final class ExceptionNode extends WeakReference<ForkJoinTask<?>>{
+        final Throwable ex;
+        ExceptionNode next;
+        final long thrower;  // use id not ref to avoid weak cycles
+        ExceptionNode(ForkJoinTask<?> task, Throwable ex, ExceptionNode next) {
+            super(task, exceptionTableRefQueue);
+            this.ex = ex;
+            this.next = next;
+            this.thrower = Thread.currentThread().getId();
+        }
+    }
+
+    /**
+     * Records exception and sets exceptional completion.
+     *
+     * @return status on exit
+     */
+    private int setExceptionalCompletion(Throwable ex) {
+        int h = System.identityHashCode(this);
+        final ReentrantLock lock = exceptionTableLock;
+        lock.lock();
+        try {
+            expungeStaleExceptions();
+            ExceptionNode[] t = exceptionTable;
+            int i = h & (t.length - 1);
+            for (ExceptionNode e = t[i]; ; e = e.next) {
+                if (e == null) {
+                    t[i] = new ExceptionNode(this, ex, t[i]);
+                    break;
+                }
+                if (e.get() == this) // already present
+                    break;
+            }
+        } finally {
+            lock.unlock();
+        }
+        return setCompletion(EXCEPTIONAL);
+    }
+
+    /**
+     * Removes exception node and clears status
+     */
+    private void clearExceptionalCompletion() {
+        int h = System.identityHashCode(this);
+        final ReentrantLock lock = exceptionTableLock;
+        lock.lock();
+        try {
+            ExceptionNode[] t = exceptionTable;
+            int i = h & (t.length - 1);
+            ExceptionNode e = t[i];
+            ExceptionNode pred = null;
+            while (e != null) {
+                ExceptionNode next = e.next;
+                if (e.get() == this) {
+                    if (pred == null)
+                        t[i] = next;
+                    else
+                        pred.next = next;
+                    break;
+                }
+                pred = e;
+                e = next;
+            }
+            expungeStaleExceptions();
+            status = 0;
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    /**
+     * Returns a rethrowable exception for the given task, if
+     * available. To provide accurate stack traces, if the exception
+     * was not thrown by the current thread, we try to create a new
+     * exception of the same type as the one thrown, but with the
+     * recorded exception as its cause. If there is no such
+     * constructor, we instead try to use a no-arg constructor,
+     * followed by initCause, to the same effect. If none of these
+     * apply, or any fail due to other exceptions, we return the
+     * recorded exception, which is still correct, although it may
+     * contain a misleading stack trace.
+     *
+     * @return the exception, or null if none
+     */
+    private Throwable getThrowableException() {
+        if (status != EXCEPTIONAL)
+            return null;
+        int h = System.identityHashCode(this);
+        ExceptionNode e;
+        final ReentrantLock lock = exceptionTableLock;
+        lock.lock();
+        try {
+            expungeStaleExceptions();
+            ExceptionNode[] t = exceptionTable;
+            e = t[h & (t.length - 1)];
+            while (e != null && e.get() != this)
+                e = e.next;
+        } finally {
+            lock.unlock();
+        }
+        Throwable ex;
+        if (e == null || (ex = e.ex) == null)
+            return null;
+        if (e.thrower != Thread.currentThread().getId()) {
+            Class<? extends Throwable> ec = ex.getClass();
+            try {
+                Constructor<?> noArgCtor = null;
+                Constructor<?>[] cs = ec.getConstructors();// public ctors only
+                for (int i = 0; i < cs.length; ++i) {
+                    Constructor<?> c = cs[i];
+                    Class<?>[] ps = c.getParameterTypes();
+                    if (ps.length == 0)
+                        noArgCtor = c;
+                    else if (ps.length == 1 && ps[0] == Throwable.class)
+                        return (Throwable)(c.newInstance(ex));
+                }
+                if (noArgCtor != null) {
+                    Throwable wx = (Throwable)(noArgCtor.newInstance());
+                    wx.initCause(ex);
+                    return wx;
+                }
+            } catch (Exception ignore) {
+            }
+        }
+        return ex;
+    }
+
+    /**
+     * Poll stale refs and remove them. Call only while holding lock.
+     */
+    private static void expungeStaleExceptions() {
+        for (Object x; (x = exceptionTableRefQueue.poll()) != null;) {
+            if (x instanceof ExceptionNode) {
+                ForkJoinTask<?> key = ((ExceptionNode)x).get();
+                ExceptionNode[] t = exceptionTable;
+                int i = System.identityHashCode(key) & (t.length - 1);
+                ExceptionNode e = t[i];
+                ExceptionNode pred = null;
+                while (e != null) {
+                    ExceptionNode next = e.next;
+                    if (e == x) {
+                        if (pred == null)
+                            t[i] = next;
+                        else
+                            pred.next = next;
+                        break;
+                    }
+                    pred = e;
+                    e = next;
+                }
+            }
+        }
+    }
+
+    /**
+     * If lock is available, poll stale refs and remove them.
+     * Called from ForkJoinPool when pools become quiescent.
+     */
+    static final void helpExpungeStaleExceptions() {
+        final ReentrantLock lock = exceptionTableLock;
+        if (lock.tryLock()) {
+            try {
+                expungeStaleExceptions();
+            } finally {
+                lock.unlock();
+            }
+        }
+    }
+
+    /**
+     * Report the result of invoke or join; called only upon
+     * non-normal return of internal versions.
+     */
+    private V reportResult() {
+        int s; Throwable ex;
+        if ((s = status) == CANCELLED)
+            throw new CancellationException();
+        if (s == EXCEPTIONAL && (ex = getThrowableException()) != null)
+            SneakyThrow.sneakyThrow(ex); // android-changed
+        return getRawResult();
+    }
+
+    // public methods
+
+    /**
+     * Arranges to asynchronously execute this task.  While it is not
+     * necessarily enforced, it is a usage error to fork a task more
+     * than once unless it has completed and been reinitialized.
+     * Subsequent modifications to the state of this task or any data
+     * it operates on are not necessarily consistently observable by
+     * any thread other than the one executing it unless preceded by a
+     * call to {@link #join} or related methods, or a call to {@link
+     * #isDone} returning {@code true}.
+     *
+     * <p>This method may be invoked only from within {@code
+     * ForkJoinPool} computations (as may be determined using method
+     * {@link #inForkJoinPool}).  Attempts to invoke in other contexts
+     * result in exceptions or errors, possibly including {@code
+     * ClassCastException}.
+     *
+     * @return {@code this}, to simplify usage
+     */
+    public final ForkJoinTask<V> fork() {
+        ((ForkJoinWorkerThread) Thread.currentThread())
+            .pushTask(this);
+        return this;
+    }
+
+    /**
+     * Returns the result of the computation when it {@link #isDone is
+     * done}.  This method differs from {@link #get()} in that
+     * abnormal completion results in {@code RuntimeException} or
+     * {@code Error}, not {@code ExecutionException}, and that
+     * interrupts of the calling thread do <em>not</em> cause the
+     * method to abruptly return by throwing {@code
+     * InterruptedException}.
+     *
+     * @return the computed result
+     */
+    public final V join() {
+        if (doJoin() != NORMAL)
+            return reportResult();
+        else
+            return getRawResult();
+    }
+
+    /**
+     * Commences performing this task, awaits its completion if
+     * necessary, and returns its result, or throws an (unchecked)
+     * {@code RuntimeException} or {@code Error} if the underlying
+     * computation did so.
+     *
+     * @return the computed result
+     */
+    public final V invoke() {
+        if (doInvoke() != NORMAL)
+            return reportResult();
+        else
+            return getRawResult();
+    }
+
+    /**
+     * Forks the given tasks, returning when {@code isDone} holds for
+     * each task or an (unchecked) exception is encountered, in which
+     * case the exception is rethrown. If more than one task
+     * encounters an exception, then this method throws any one of
+     * these exceptions. If any task encounters an exception, the
+     * other may be cancelled. However, the execution status of
+     * individual tasks is not guaranteed upon exceptional return. The
+     * status of each task may be obtained using {@link
+     * #getException()} and related methods to check if they have been
+     * cancelled, completed normally or exceptionally, or left
+     * unprocessed.
+     *
+     * <p>This method may be invoked only from within {@code
+     * ForkJoinPool} computations (as may be determined using method
+     * {@link #inForkJoinPool}).  Attempts to invoke in other contexts
+     * result in exceptions or errors, possibly including {@code
+     * ClassCastException}.
+     *
+     * @param t1 the first task
+     * @param t2 the second task
+     * @throws NullPointerException if any task is null
+     */
+    public static void invokeAll(ForkJoinTask<?> t1, ForkJoinTask<?> t2) {
+        t2.fork();
+        t1.invoke();
+        t2.join();
+    }
+
+    /**
+     * Forks the given tasks, returning when {@code isDone} holds for
+     * each task or an (unchecked) exception is encountered, in which
+     * case the exception is rethrown. If more than one task
+     * encounters an exception, then this method throws any one of
+     * these exceptions. If any task encounters an exception, others
+     * may be cancelled. However, the execution status of individual
+     * tasks is not guaranteed upon exceptional return. The status of
+     * each task may be obtained using {@link #getException()} and
+     * related methods to check if they have been cancelled, completed
+     * normally or exceptionally, or left unprocessed.
+     *
+     * <p>This method may be invoked only from within {@code
+     * ForkJoinPool} computations (as may be determined using method
+     * {@link #inForkJoinPool}).  Attempts to invoke in other contexts
+     * result in exceptions or errors, possibly including {@code
+     * ClassCastException}.
+     *
+     * @param tasks the tasks
+     * @throws NullPointerException if any task is null
+     */
+    public static void invokeAll(ForkJoinTask<?>... tasks) {
+        Throwable ex = null;
+        int last = tasks.length - 1;
+        for (int i = last; i >= 0; --i) {
+            ForkJoinTask<?> t = tasks[i];
+            if (t == null) {
+                if (ex == null)
+                    ex = new NullPointerException();
+            }
+            else if (i != 0)
+                t.fork();
+            else if (t.doInvoke() < NORMAL && ex == null)
+                ex = t.getException();
+        }
+        for (int i = 1; i <= last; ++i) {
+            ForkJoinTask<?> t = tasks[i];
+            if (t != null) {
+                if (ex != null)
+                    t.cancel(false);
+                else if (t.doJoin() < NORMAL)
+                    ex = t.getException();
+            }
+        }
+        if (ex != null)
+            SneakyThrow.sneakyThrow(ex); // android-changed
+    }
+
+    /**
+     * Forks all tasks in the specified collection, returning when
+     * {@code isDone} holds for each task or an (unchecked) exception
+     * is encountered, in which case the exception is rethrown. If
+     * more than one task encounters an exception, then this method
+     * throws any one of these exceptions. If any task encounters an
+     * exception, others may be cancelled. However, the execution
+     * status of individual tasks is not guaranteed upon exceptional
+     * return. The status of each task may be obtained using {@link
+     * #getException()} and related methods to check if they have been
+     * cancelled, completed normally or exceptionally, or left
+     * unprocessed.
+     *
+     * <p>This method may be invoked only from within {@code
+     * ForkJoinPool} computations (as may be determined using method
+     * {@link #inForkJoinPool}).  Attempts to invoke in other contexts
+     * result in exceptions or errors, possibly including {@code
+     * ClassCastException}.
+     *
+     * @param tasks the collection of tasks
+     * @return the tasks argument, to simplify usage
+     * @throws NullPointerException if tasks or any element are null
+     */
+    public static <T extends ForkJoinTask<?>> Collection<T> invokeAll(Collection<T> tasks) {
+        if (!(tasks instanceof RandomAccess) || !(tasks instanceof List<?>)) {
+            invokeAll(tasks.toArray(new ForkJoinTask<?>[tasks.size()]));
+            return tasks;
+        }
+        @SuppressWarnings("unchecked")
+        List<? extends ForkJoinTask<?>> ts =
+            (List<? extends ForkJoinTask<?>>) tasks;
+        Throwable ex = null;
+        int last = ts.size() - 1;
+        for (int i = last; i >= 0; --i) {
+            ForkJoinTask<?> t = ts.get(i);
+            if (t == null) {
+                if (ex == null)
+                    ex = new NullPointerException();
+            }
+            else if (i != 0)
+                t.fork();
+            else if (t.doInvoke() < NORMAL && ex == null)
+                ex = t.getException();
+        }
+        for (int i = 1; i <= last; ++i) {
+            ForkJoinTask<?> t = ts.get(i);
+            if (t != null) {
+                if (ex != null)
+                    t.cancel(false);
+                else if (t.doJoin() < NORMAL)
+                    ex = t.getException();
+            }
+        }
+        if (ex != null)
+            SneakyThrow.sneakyThrow(ex); // android-changed
+        return tasks;
+    }
+
+    /**
+     * Attempts to cancel execution of this task. This attempt will
+     * fail if the task has already completed or could not be
+     * cancelled for some other reason. If successful, and this task
+     * has not started when {@code cancel} is called, execution of
+     * this task is suppressed. After this method returns
+     * successfully, unless there is an intervening call to {@link
+     * #reinitialize}, subsequent calls to {@link #isCancelled},
+     * {@link #isDone}, and {@code cancel} will return {@code true}
+     * and calls to {@link #join} and related methods will result in
+     * {@code CancellationException}.
+     *
+     * <p>This method may be overridden in subclasses, but if so, must
+     * still ensure that these properties hold. In particular, the
+     * {@code cancel} method itself must not throw exceptions.
+     *
+     * <p>This method is designed to be invoked by <em>other</em>
+     * tasks. To terminate the current task, you can just return or
+     * throw an unchecked exception from its computation method, or
+     * invoke {@link #completeExceptionally}.
+     *
+     * @param mayInterruptIfRunning this value has no effect in the
+     * default implementation because interrupts are not used to
+     * control cancellation.
+     *
+     * @return {@code true} if this task is now cancelled
+     */
+    public boolean cancel(boolean mayInterruptIfRunning) {
+        return setCompletion(CANCELLED) == CANCELLED;
+    }
+
+    /**
+     * Cancels, ignoring any exceptions thrown by cancel. Used during
+     * worker and pool shutdown. Cancel is spec'ed not to throw any
+     * exceptions, but if it does anyway, we have no recourse during
+     * shutdown, so guard against this case.
+     */
+    final void cancelIgnoringExceptions() {
+        try {
+            cancel(false);
+        } catch (Throwable ignore) {
+        }
+    }
+
+    public final boolean isDone() {
+        return status < 0;
+    }
+
+    public final boolean isCancelled() {
+        return status == CANCELLED;
+    }
+
+    /**
+     * Returns {@code true} if this task threw an exception or was cancelled.
+     *
+     * @return {@code true} if this task threw an exception or was cancelled
+     */
+    public final boolean isCompletedAbnormally() {
+        return status < NORMAL;
+    }
+
+    /**
+     * Returns {@code true} if this task completed without throwing an
+     * exception and was not cancelled.
+     *
+     * @return {@code true} if this task completed without throwing an
+     * exception and was not cancelled
+     */
+    public final boolean isCompletedNormally() {
+        return status == NORMAL;
+    }
+
+    /**
+     * Returns the exception thrown by the base computation, or a
+     * {@code CancellationException} if cancelled, or {@code null} if
+     * none or if the method has not yet completed.
+     *
+     * @return the exception, or {@code null} if none
+     */
+    public final Throwable getException() {
+        int s = status;
+        return ((s >= NORMAL)    ? null :
+                (s == CANCELLED) ? new CancellationException() :
+                getThrowableException());
+    }
+
+    /**
+     * Completes this task abnormally, and if not already aborted or
+     * cancelled, causes it to throw the given exception upon
+     * {@code join} and related operations. This method may be used
+     * to induce exceptions in asynchronous tasks, or to force
+     * completion of tasks that would not otherwise complete.  Its use
+     * in other situations is discouraged.  This method is
+     * overridable, but overridden versions must invoke {@code super}
+     * implementation to maintain guarantees.
+     *
+     * @param ex the exception to throw. If this exception is not a
+     * {@code RuntimeException} or {@code Error}, the actual exception
+     * thrown will be a {@code RuntimeException} with cause {@code ex}.
+     */
+    public void completeExceptionally(Throwable ex) {
+        setExceptionalCompletion((ex instanceof RuntimeException) ||
+                                 (ex instanceof Error) ? ex :
+                                 new RuntimeException(ex));
+    }
+
+    /**
+     * Completes this task, and if not already aborted or cancelled,
+     * returning the given value as the result of subsequent
+     * invocations of {@code join} and related operations. This method
+     * may be used to provide results for asynchronous tasks, or to
+     * provide alternative handling for tasks that would not otherwise
+     * complete normally. Its use in other situations is
+     * discouraged. This method is overridable, but overridden
+     * versions must invoke {@code super} implementation to maintain
+     * guarantees.
+     *
+     * @param value the result value for this task
+     */
+    public void complete(V value) {
+        try {
+            setRawResult(value);
+        } catch (Throwable rex) {
+            setExceptionalCompletion(rex);
+            return;
+        }
+        setCompletion(NORMAL);
+    }
+
+    /**
+     * Waits if necessary for the computation to complete, and then
+     * retrieves its result.
+     *
+     * @return the computed result
+     * @throws CancellationException if the computation was cancelled
+     * @throws ExecutionException if the computation threw an
+     * exception
+     * @throws InterruptedException if the current thread is not a
+     * member of a ForkJoinPool and was interrupted while waiting
+     */
+    public final V get() throws InterruptedException, ExecutionException {
+        int s = (Thread.currentThread() instanceof ForkJoinWorkerThread) ?
+            doJoin() : externalInterruptibleAwaitDone(0L);
+        Throwable ex;
+        if (s == CANCELLED)
+            throw new CancellationException();
+        if (s == EXCEPTIONAL && (ex = getThrowableException()) != null)
+            throw new ExecutionException(ex);
+        return getRawResult();
+    }
+
+    /**
+     * Waits if necessary for at most the given time for the computation
+     * to complete, and then retrieves its result, if available.
+     *
+     * @param timeout the maximum time to wait
+     * @param unit the time unit of the timeout argument
+     * @return the computed result
+     * @throws CancellationException if the computation was cancelled
+     * @throws ExecutionException if the computation threw an
+     * exception
+     * @throws InterruptedException if the current thread is not a
+     * member of a ForkJoinPool and was interrupted while waiting
+     * @throws TimeoutException if the wait timed out
+     */
+    public final V get(long timeout, TimeUnit unit)
+        throws InterruptedException, ExecutionException, TimeoutException {
+        Thread t = Thread.currentThread();
+        if (t instanceof ForkJoinWorkerThread) {
+            ForkJoinWorkerThread w = (ForkJoinWorkerThread) t;
+            long nanos = unit.toNanos(timeout);
+            if (status >= 0) {
+                boolean completed = false;
+                if (w.unpushTask(this)) {
+                    try {
+                        completed = exec();
+                    } catch (Throwable rex) {
+                        setExceptionalCompletion(rex);
+                    }
+                }
+                if (completed)
+                    setCompletion(NORMAL);
+                else if (status >= 0 && nanos > 0)
+                    w.pool.timedAwaitJoin(this, nanos);
+            }
+        }
+        else {
+            long millis = unit.toMillis(timeout);
+            if (millis > 0)
+                externalInterruptibleAwaitDone(millis);
+        }
+        int s = status;
+        if (s != NORMAL) {
+            Throwable ex;
+            if (s == CANCELLED)
+                throw new CancellationException();
+            if (s != EXCEPTIONAL)
+                throw new TimeoutException();
+            if ((ex = getThrowableException()) != null)
+                throw new ExecutionException(ex);
+        }
+        return getRawResult();
+    }
+
+    /**
+     * Joins this task, without returning its result or throwing its
+     * exception. This method may be useful when processing
+     * collections of tasks when some have been cancelled or otherwise
+     * known to have aborted.
+     */
+    public final void quietlyJoin() {
+        doJoin();
+    }
+
+    /**
+     * Commences performing this task and awaits its completion if
+     * necessary, without returning its result or throwing its
+     * exception.
+     */
+    public final void quietlyInvoke() {
+        doInvoke();
+    }
+
+    /**
+     * Possibly executes tasks until the pool hosting the current task
+     * {@link ForkJoinPool#isQuiescent is quiescent}. This method may
+     * be of use in designs in which many tasks are forked, but none
+     * are explicitly joined, instead executing them until all are
+     * processed.
+     *
+     * <p>This method may be invoked only from within {@code
+     * ForkJoinPool} computations (as may be determined using method
+     * {@link #inForkJoinPool}).  Attempts to invoke in other contexts
+     * result in exceptions or errors, possibly including {@code
+     * ClassCastException}.
+     */
+    public static void helpQuiesce() {
+        ((ForkJoinWorkerThread) Thread.currentThread())
+            .helpQuiescePool();
+    }
+
+    /**
+     * Resets the internal bookkeeping state of this task, allowing a
+     * subsequent {@code fork}. This method allows repeated reuse of
+     * this task, but only if reuse occurs when this task has either
+     * never been forked, or has been forked, then completed and all
+     * outstanding joins of this task have also completed. Effects
+     * under any other usage conditions are not guaranteed.
+     * This method may be useful when executing
+     * pre-constructed trees of subtasks in loops.
+     *
+     * <p>Upon completion of this method, {@code isDone()} reports
+     * {@code false}, and {@code getException()} reports {@code
+     * null}. However, the value returned by {@code getRawResult} is
+     * unaffected. To clear this value, you can invoke {@code
+     * setRawResult(null)}.
+     */
+    public void reinitialize() {
+        if (status == EXCEPTIONAL)
+            clearExceptionalCompletion();
+        else
+            status = 0;
+    }
+
+    /**
+     * Returns the pool hosting the current task execution, or null
+     * if this task is executing outside of any ForkJoinPool.
+     *
+     * @see #inForkJoinPool
+     * @return the pool, or {@code null} if none
+     */
+    public static ForkJoinPool getPool() {
+        Thread t = Thread.currentThread();
+        return (t instanceof ForkJoinWorkerThread) ?
+            ((ForkJoinWorkerThread) t).pool : null;
+    }
+
+    /**
+     * Returns {@code true} if the current thread is a {@link
+     * ForkJoinWorkerThread} executing as a ForkJoinPool computation.
+     *
+     * @return {@code true} if the current thread is a {@link
+     * ForkJoinWorkerThread} executing as a ForkJoinPool computation,
+     * or {@code false} otherwise
+     */
+    public static boolean inForkJoinPool() {
+        return Thread.currentThread() instanceof ForkJoinWorkerThread;
+    }
+
+    /**
+     * Tries to unschedule this task for execution. This method will
+     * typically succeed if this task is the most recently forked task
+     * by the current thread, and has not commenced executing in
+     * another thread.  This method may be useful when arranging
+     * alternative local processing of tasks that could have been, but
+     * were not, stolen.
+     *
+     * <p>This method may be invoked only from within {@code
+     * ForkJoinPool} computations (as may be determined using method
+     * {@link #inForkJoinPool}).  Attempts to invoke in other contexts
+     * result in exceptions or errors, possibly including {@code
+     * ClassCastException}.
+     *
+     * @return {@code true} if unforked
+     */
+    public boolean tryUnfork() {
+        return ((ForkJoinWorkerThread) Thread.currentThread())
+            .unpushTask(this);
+    }
+
+    /**
+     * Returns an estimate of the number of tasks that have been
+     * forked by the current worker thread but not yet executed. This
+     * value may be useful for heuristic decisions about whether to
+     * fork other tasks.
+     *
+     * <p>This method may be invoked only from within {@code
+     * ForkJoinPool} computations (as may be determined using method
+     * {@link #inForkJoinPool}).  Attempts to invoke in other contexts
+     * result in exceptions or errors, possibly including {@code
+     * ClassCastException}.
+     *
+     * @return the number of tasks
+     */
+    public static int getQueuedTaskCount() {
+        return ((ForkJoinWorkerThread) Thread.currentThread())
+            .getQueueSize();
+    }
+
+    /**
+     * Returns an estimate of how many more locally queued tasks are
+     * held by the current worker thread than there are other worker
+     * threads that might steal them.  This value may be useful for
+     * heuristic decisions about whether to fork other tasks. In many
+     * usages of ForkJoinTasks, at steady state, each worker should
+     * aim to maintain a small constant surplus (for example, 3) of
+     * tasks, and to process computations locally if this threshold is
+     * exceeded.
+     *
+     * <p>This method may be invoked only from within {@code
+     * ForkJoinPool} computations (as may be determined using method
+     * {@link #inForkJoinPool}).  Attempts to invoke in other contexts
+     * result in exceptions or errors, possibly including {@code
+     * ClassCastException}.
+     *
+     * @return the surplus number of tasks, which may be negative
+     */
+    public static int getSurplusQueuedTaskCount() {
+        return ((ForkJoinWorkerThread) Thread.currentThread())
+            .getEstimatedSurplusTaskCount();
+    }
+
+    // Extension methods
+
+    /**
+     * Returns the result that would be returned by {@link #join}, even
+     * if this task completed abnormally, or {@code null} if this task
+     * is not known to have been completed.  This method is designed
+     * to aid debugging, as well as to support extensions. Its use in
+     * any other context is discouraged.
+     *
+     * @return the result, or {@code null} if not completed
+     */
+    public abstract V getRawResult();
+
+    /**
+     * Forces the given value to be returned as a result.  This method
+     * is designed to support extensions, and should not in general be
+     * called otherwise.
+     *
+     * @param value the value
+     */
+    protected abstract void setRawResult(V value);
+
+    /**
+     * Immediately performs the base action of this task.  This method
+     * is designed to support extensions, and should not in general be
+     * called otherwise. The return value controls whether this task
+     * is considered to be done normally. It may return false in
+     * asynchronous actions that require explicit invocations of
+     * {@link #complete} to become joinable. It may also throw an
+     * (unchecked) exception to indicate abnormal exit.
+     *
+     * @return {@code true} if completed normally
+     */
+    protected abstract boolean exec();
+
+    /**
+     * Returns, but does not unschedule or execute, a task queued by
+     * the current thread but not yet executed, if one is immediately
+     * available. There is no guarantee that this task will actually
+     * be polled or executed next. Conversely, this method may return
+     * null even if a task exists but cannot be accessed without
+     * contention with other threads.  This method is designed
+     * primarily to support extensions, and is unlikely to be useful
+     * otherwise.
+     *
+     * <p>This method may be invoked only from within {@code
+     * ForkJoinPool} computations (as may be determined using method
+     * {@link #inForkJoinPool}).  Attempts to invoke in other contexts
+     * result in exceptions or errors, possibly including {@code
+     * ClassCastException}.
+     *
+     * @return the next task, or {@code null} if none are available
+     */
+    protected static ForkJoinTask<?> peekNextLocalTask() {
+        return ((ForkJoinWorkerThread) Thread.currentThread())
+            .peekTask();
+    }
+
+    /**
+     * Unschedules and returns, without executing, the next task
+     * queued by the current thread but not yet executed.  This method
+     * is designed primarily to support extensions, and is unlikely to
+     * be useful otherwise.
+     *
+     * <p>This method may be invoked only from within {@code
+     * ForkJoinPool} computations (as may be determined using method
+     * {@link #inForkJoinPool}).  Attempts to invoke in other contexts
+     * result in exceptions or errors, possibly including {@code
+     * ClassCastException}.
+     *
+     * @return the next task, or {@code null} if none are available
+     */
+    protected static ForkJoinTask<?> pollNextLocalTask() {
+        return ((ForkJoinWorkerThread) Thread.currentThread())
+            .pollLocalTask();
+    }
+
+    /**
+     * Unschedules and returns, without executing, the next task
+     * queued by the current thread but not yet executed, if one is
+     * available, or if not available, a task that was forked by some
+     * other thread, if available. Availability may be transient, so a
+     * {@code null} result does not necessarily imply quiescence
+     * of the pool this task is operating in.  This method is designed
+     * primarily to support extensions, and is unlikely to be useful
+     * otherwise.
+     *
+     * <p>This method may be invoked only from within {@code
+     * ForkJoinPool} computations (as may be determined using method
+     * {@link #inForkJoinPool}).  Attempts to invoke in other contexts
+     * result in exceptions or errors, possibly including {@code
+     * ClassCastException}.
+     *
+     * @return a task, or {@code null} if none are available
+     */
+    protected static ForkJoinTask<?> pollTask() {
+        return ((ForkJoinWorkerThread) Thread.currentThread())
+            .pollTask();
+    }
+
+    /**
+     * Adaptor for Runnables. This implements RunnableFuture
+     * to be compliant with AbstractExecutorService constraints
+     * when used in ForkJoinPool.
+     */
+    static final class AdaptedRunnable<T> extends ForkJoinTask<T>
+        implements RunnableFuture<T> {
+        final Runnable runnable;
+        final T resultOnCompletion;
+        T result;
+        AdaptedRunnable(Runnable runnable, T result) {
+            if (runnable == null) throw new NullPointerException();
+            this.runnable = runnable;
+            this.resultOnCompletion = result;
+        }
+        public T getRawResult() { return result; }
+        public void setRawResult(T v) { result = v; }
+        public boolean exec() {
+            runnable.run();
+            result = resultOnCompletion;
+            return true;
+        }
+        public void run() { invoke(); }
+        private static final long serialVersionUID = 5232453952276885070L;
+    }
+
+    /**
+     * Adaptor for Callables
+     */
+    static final class AdaptedCallable<T> extends ForkJoinTask<T>
+        implements RunnableFuture<T> {
+        final Callable<? extends T> callable;
+        T result;
+        AdaptedCallable(Callable<? extends T> callable) {
+            if (callable == null) throw new NullPointerException();
+            this.callable = callable;
+        }
+        public T getRawResult() { return result; }
+        public void setRawResult(T v) { result = v; }
+        public boolean exec() {
+            try {
+                result = callable.call();
+                return true;
+            } catch (Error err) {
+                throw err;
+            } catch (RuntimeException rex) {
+                throw rex;
+            } catch (Exception ex) {
+                throw new RuntimeException(ex);
+            }
+        }
+        public void run() { invoke(); }
+        private static final long serialVersionUID = 2838392045355241008L;
+    }
+
+    /**
+     * Returns a new {@code ForkJoinTask} that performs the {@code run}
+     * method of the given {@code Runnable} as its action, and returns
+     * a null result upon {@link #join}.
+     *
+     * @param runnable the runnable action
+     * @return the task
+     */
+    public static ForkJoinTask<?> adapt(Runnable runnable) {
+        return new AdaptedRunnable<Void>(runnable, null);
+    }
+
+    /**
+     * Returns a new {@code ForkJoinTask} that performs the {@code run}
+     * method of the given {@code Runnable} as its action, and returns
+     * the given result upon {@link #join}.
+     *
+     * @param runnable the runnable action
+     * @param result the result upon completion
+     * @return the task
+     */
+    public static <T> ForkJoinTask<T> adapt(Runnable runnable, T result) {
+        return new AdaptedRunnable<T>(runnable, result);
+    }
+
+    /**
+     * Returns a new {@code ForkJoinTask} that performs the {@code call}
+     * method of the given {@code Callable} as its action, and returns
+     * its result upon {@link #join}, translating any checked exceptions
+     * encountered into {@code RuntimeException}.
+     *
+     * @param callable the callable action
+     * @return the task
+     */
+    public static <T> ForkJoinTask<T> adapt(Callable<? extends T> callable) {
+        return new AdaptedCallable<T>(callable);
+    }
+
+    // Serialization support
+
+    private static final long serialVersionUID = -7721805057305804111L;
+
+    /**
+     * Saves the state to a stream (that is, serializes it).
+     *
+     * @serialData the current run status and the exception thrown
+     * during execution, or {@code null} if none
+     * @param s the stream
+     */
+    private void writeObject(java.io.ObjectOutputStream s)
+        throws java.io.IOException {
+        s.defaultWriteObject();
+        s.writeObject(getException());
+    }
+
+    /**
+     * Reconstitutes the instance from a stream (that is, deserializes it).
+     *
+     * @param s the stream
+     */
+    private void readObject(java.io.ObjectInputStream s)
+        throws java.io.IOException, ClassNotFoundException {
+        s.defaultReadObject();
+        Object ex = s.readObject();
+        if (ex != null)
+            setExceptionalCompletion((Throwable)ex);
+    }
+
+    // Unsafe mechanics
+    private static final sun.misc.Unsafe UNSAFE;
+    private static final long statusOffset;
+    static {
+        exceptionTableLock = new ReentrantLock();
+        exceptionTableRefQueue = new ReferenceQueue<Object>();
+        exceptionTable = new ExceptionNode[EXCEPTION_MAP_CAPACITY];
+        try {
+            UNSAFE = sun.misc.Unsafe.getUnsafe();
+            statusOffset = UNSAFE.objectFieldOffset
+                (ForkJoinTask.class.getDeclaredField("status"));
+        } catch (Exception e) {
+            throw new Error(e);
+        }
+    }
+
+}
diff --git a/luni/src/main/java/java/util/concurrent/ForkJoinWorkerThread.java b/luni/src/main/java/java/util/concurrent/ForkJoinWorkerThread.java
new file mode 100644
index 0000000..d99ffe9
--- /dev/null
+++ b/luni/src/main/java/java/util/concurrent/ForkJoinWorkerThread.java
@@ -0,0 +1,970 @@
+/*
+ * Written by Doug Lea with assistance from members of JCP JSR-166
+ * Expert Group and released to the public domain, as explained at
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+package java.util.concurrent;
+
+import java.util.Collection;
+import java.util.concurrent.RejectedExecutionException;
+import libcore.util.SneakyThrow;
+
+/**
+ * A thread managed by a {@link ForkJoinPool}, which executes
+ * {@link ForkJoinTask}s.
+ * This class is subclassable solely for the sake of adding
+ * functionality -- there are no overridable methods dealing with
+ * scheduling or execution.  However, you can override initialization
+ * and termination methods surrounding the main task processing loop.
+ * If you do create such a subclass, you will also need to supply a
+ * custom {@link ForkJoinPool.ForkJoinWorkerThreadFactory} to use it
+ * in a {@code ForkJoinPool}.
+ *
+ * @since 1.7
+ * @hide
+ * @author Doug Lea
+ */
+public class ForkJoinWorkerThread extends Thread {
+    /*
+     * Overview:
+     *
+     * ForkJoinWorkerThreads are managed by ForkJoinPools and perform
+     * ForkJoinTasks. This class includes bookkeeping in support of
+     * worker activation, suspension, and lifecycle control described
+     * in more detail in the internal documentation of class
+     * ForkJoinPool. And as described further below, this class also
+     * includes special-cased support for some ForkJoinTask
+     * methods. But the main mechanics involve work-stealing:
+     *
+     * Work-stealing queues are special forms of Deques that support
+     * only three of the four possible end-operations -- push, pop,
+     * and deq (aka steal), under the further constraints that push
+     * and pop are called only from the owning thread, while deq may
+     * be called from other threads.  (If you are unfamiliar with
+     * them, you probably want to read Herlihy and Shavit's book "The
+     * Art of Multiprocessor programming", chapter 16 describing these
+     * in more detail before proceeding.)  The main work-stealing
+     * queue design is roughly similar to those in the papers "Dynamic
+     * Circular Work-Stealing Deque" by Chase and Lev, SPAA 2005
+     * (http://research.sun.com/scalable/pubs/index.html) and
+     * "Idempotent work stealing" by Michael, Saraswat, and Vechev,
+     * PPoPP 2009 (http://portal.acm.org/citation.cfm?id=1504186).
+     * The main differences ultimately stem from gc requirements that
+     * we null out taken slots as soon as we can, to maintain as small
+     * a footprint as possible even in programs generating huge
+     * numbers of tasks. To accomplish this, we shift the CAS
+     * arbitrating pop vs deq (steal) from being on the indices
+     * ("queueBase" and "queueTop") to the slots themselves (mainly
+     * via method "casSlotNull()"). So, both a successful pop and deq
+     * mainly entail a CAS of a slot from non-null to null.  Because
+     * we rely on CASes of references, we do not need tag bits on
+     * queueBase or queueTop.  They are simple ints as used in any
+     * circular array-based queue (see for example ArrayDeque).
+     * Updates to the indices must still be ordered in a way that
+     * guarantees that queueTop == queueBase means the queue is empty,
+     * but otherwise may err on the side of possibly making the queue
+     * appear nonempty when a push, pop, or deq have not fully
+     * committed. Note that this means that the deq operation,
+     * considered individually, is not wait-free. One thief cannot
+     * successfully continue until another in-progress one (or, if
+     * previously empty, a push) completes.  However, in the
+     * aggregate, we ensure at least probabilistic non-blockingness.
+     * If an attempted steal fails, a thief always chooses a different
+     * random victim target to try next. So, in order for one thief to
+     * progress, it suffices for any in-progress deq or new push on
+     * any empty queue to complete.
+     *
+     * This approach also enables support for "async mode" where local
+     * task processing is in FIFO, not LIFO order; simply by using a
+     * version of deq rather than pop when locallyFifo is true (as set
+     * by the ForkJoinPool).  This allows use in message-passing
+     * frameworks in which tasks are never joined.  However neither
+     * mode considers affinities, loads, cache localities, etc, so
+     * rarely provide the best possible performance on a given
+     * machine, but portably provide good throughput by averaging over
+     * these factors.  (Further, even if we did try to use such
+     * information, we do not usually have a basis for exploiting
+     * it. For example, some sets of tasks profit from cache
+     * affinities, but others are harmed by cache pollution effects.)
+     *
+     * When a worker would otherwise be blocked waiting to join a
+     * task, it first tries a form of linear helping: Each worker
+     * records (in field currentSteal) the most recent task it stole
+     * from some other worker. Plus, it records (in field currentJoin)
+     * the task it is currently actively joining. Method joinTask uses
+     * these markers to try to find a worker to help (i.e., steal back
+     * a task from and execute it) that could hasten completion of the
+     * actively joined task. In essence, the joiner executes a task
+     * that would be on its own local deque had the to-be-joined task
+     * not been stolen. This may be seen as a conservative variant of
+     * the approach in Wagner & Calder "Leapfrogging: a portable
+     * technique for implementing efficient futures" SIGPLAN Notices,
+     * 1993 (http://portal.acm.org/citation.cfm?id=155354). It differs
+     * in that: (1) We only maintain dependency links across workers
+     * upon steals, rather than use per-task bookkeeping.  This may
+     * require a linear scan of workers array to locate stealers, but
+     * usually doesn't because stealers leave hints (that may become
+     * stale/wrong) of where to locate them. This isolates cost to
+     * when it is needed, rather than adding to per-task overhead.
+     * (2) It is "shallow", ignoring nesting and potentially cyclic
+     * mutual steals.  (3) It is intentionally racy: field currentJoin
+     * is updated only while actively joining, which means that we
+     * miss links in the chain during long-lived tasks, GC stalls etc
+     * (which is OK since blocking in such cases is usually a good
+     * idea).  (4) We bound the number of attempts to find work (see
+     * MAX_HELP) and fall back to suspending the worker and if
+     * necessary replacing it with another.
+     *
+     * Efficient implementation of these algorithms currently relies
+     * on an uncomfortable amount of "Unsafe" mechanics. To maintain
+     * correct orderings, reads and writes of variable queueBase
+     * require volatile ordering.  Variable queueTop need not be
+     * volatile because non-local reads always follow those of
+     * queueBase.  Similarly, because they are protected by volatile
+     * queueBase reads, reads of the queue array and its slots by
+     * other threads do not need volatile load semantics, but writes
+     * (in push) require store order and CASes (in pop and deq)
+     * require (volatile) CAS semantics.  (Michael, Saraswat, and
+     * Vechev's algorithm has similar properties, but without support
+     * for nulling slots.)  Since these combinations aren't supported
+     * using ordinary volatiles, the only way to accomplish these
+     * efficiently is to use direct Unsafe calls. (Using external
+     * AtomicIntegers and AtomicReferenceArrays for the indices and
+     * array is significantly slower because of memory locality and
+     * indirection effects.)
+     *
+     * Further, performance on most platforms is very sensitive to
+     * placement and sizing of the (resizable) queue array.  Even
+     * though these queues don't usually become all that big, the
+     * initial size must be large enough to counteract cache
+     * contention effects across multiple queues (especially in the
+     * presence of GC cardmarking). Also, to improve thread-locality,
+     * queues are initialized after starting.
+     */
+
+    /**
+     * Mask for pool indices encoded as shorts
+     */
+    private static final int  SMASK  = 0xffff;
+
+    /**
+     * Capacity of work-stealing queue array upon initialization.
+     * Must be a power of two. Initial size must be at least 4, but is
+     * padded to minimize cache effects.
+     */
+    private static final int INITIAL_QUEUE_CAPACITY = 1 << 13;
+
+    /**
+     * Maximum size for queue array. Must be a power of two
+     * less than or equal to 1 << (31 - width of array entry) to
+     * ensure lack of index wraparound, but is capped at a lower
+     * value to help users trap runaway computations.
+     */
+    private static final int MAXIMUM_QUEUE_CAPACITY = 1 << 24; // 16M
+
+    /**
+     * The work-stealing queue array. Size must be a power of two.
+     * Initialized when started (as opposed to when constructed), to
+     * improve memory locality.
+     */
+    ForkJoinTask<?>[] queue;
+
+    /**
+     * The pool this thread works in. Accessed directly by ForkJoinTask.
+     */
+    final ForkJoinPool pool;
+
+    /**
+     * Index (mod queue.length) of next queue slot to push to or pop
+     * from. It is written only by owner thread, and accessed by other
+     * threads only after reading (volatile) queueBase.  Both queueTop
+     * and queueBase are allowed to wrap around on overflow, but
+     * (queueTop - queueBase) still estimates size.
+     */
+    int queueTop;
+
+    /**
+     * Index (mod queue.length) of least valid queue slot, which is
+     * always the next position to steal from if nonempty.
+     */
+    volatile int queueBase;
+
+    /**
+     * The index of most recent stealer, used as a hint to avoid
+     * traversal in method helpJoinTask. This is only a hint because a
+     * worker might have had multiple steals and this only holds one
+     * of them (usually the most current). Declared non-volatile,
+     * relying on other prevailing sync to keep reasonably current.
+     */
+    int stealHint;
+
+    /**
+     * Index of this worker in pool array. Set once by pool before
+     * running, and accessed directly by pool to locate this worker in
+     * its workers array.
+     */
+    final int poolIndex;
+
+    /**
+     * Encoded record for pool task waits. Usages are always
+     * surrounded by volatile reads/writes
+     */
+    int nextWait;
+
+    /**
+     * Complement of poolIndex, offset by count of entries of task
+     * waits. Accessed by ForkJoinPool to manage event waiters.
+     */
+    volatile int eventCount;
+
+    /**
+     * Seed for random number generator for choosing steal victims.
+     * Uses Marsaglia xorshift. Must be initialized as nonzero.
+     */
+    int seed;
+
+    /**
+     * Number of steals. Directly accessed (and reset) by pool when
+     * idle.
+     */
+    int stealCount;
+
+    /**
+     * True if this worker should or did terminate
+     */
+    volatile boolean terminate;
+
+    /**
+     * Set to true before LockSupport.park; false on return
+     */
+    volatile boolean parked;
+
+    /**
+     * True if use local fifo, not default lifo, for local polling.
+     * Shadows value from ForkJoinPool.
+     */
+    final boolean locallyFifo;
+
+    /**
+     * The task most recently stolen from another worker (or
+     * submission queue).  All uses are surrounded by enough volatile
+     * reads/writes to maintain as non-volatile.
+     */
+    ForkJoinTask<?> currentSteal;
+
+    /**
+     * The task currently being joined, set only when actively trying
+     * to help other stealers in helpJoinTask. All uses are surrounded
+     * by enough volatile reads/writes to maintain as non-volatile.
+     */
+    ForkJoinTask<?> currentJoin;
+
+    /**
+     * Creates a ForkJoinWorkerThread operating in the given pool.
+     *
+     * @param pool the pool this thread works in
+     * @throws NullPointerException if pool is null
+     */
+    protected ForkJoinWorkerThread(ForkJoinPool pool) {
+        super(pool.nextWorkerName());
+        this.pool = pool;
+        int k = pool.registerWorker(this);
+        poolIndex = k;
+        eventCount = ~k & SMASK; // clear wait count
+        locallyFifo = pool.locallyFifo;
+        Thread.UncaughtExceptionHandler ueh = pool.ueh;
+        if (ueh != null)
+            setUncaughtExceptionHandler(ueh);
+        setDaemon(true);
+    }
+
+    // Public methods
+
+    /**
+     * Returns the pool hosting this thread.
+     *
+     * @return the pool
+     */
+    public ForkJoinPool getPool() {
+        return pool;
+    }
+
+    /**
+     * Returns the index number of this thread in its pool.  The
+     * returned value ranges from zero to the maximum number of
+     * threads (minus one) that have ever been created in the pool.
+     * This method may be useful for applications that track status or
+     * collect results per-worker rather than per-task.
+     *
+     * @return the index number
+     */
+    public int getPoolIndex() {
+        return poolIndex;
+    }
+
+    // Randomization
+
+    /**
+     * Computes next value for random victim probes and backoffs.
+     * Scans don't require a very high quality generator, but also not
+     * a crummy one.  Marsaglia xor-shift is cheap and works well
+     * enough.  Note: This is manually inlined in FJP.scan() to avoid
+     * writes inside busy loops.
+     */
+    private int nextSeed() {
+        int r = seed;
+        r ^= r << 13;
+        r ^= r >>> 17;
+        r ^= r << 5;
+        return seed = r;
+    }
+
+    // Run State management
+
+    /**
+     * Initializes internal state after construction but before
+     * processing any tasks. If you override this method, you must
+     * invoke {@code super.onStart()} at the beginning of the method.
+     * Initialization requires care: Most fields must have legal
+     * default values, to ensure that attempted accesses from other
+     * threads work correctly even before this thread starts
+     * processing tasks.
+     */
+    protected void onStart() {
+        queue = new ForkJoinTask<?>[INITIAL_QUEUE_CAPACITY];
+        int r = ForkJoinPool.workerSeedGenerator.nextInt();
+        seed = (r == 0) ? 1 : r; //  must be nonzero
+    }
+
+    /**
+     * Performs cleanup associated with termination of this worker
+     * thread.  If you override this method, you must invoke
+     * {@code super.onTermination} at the end of the overridden method.
+     *
+     * @param exception the exception causing this thread to abort due
+     * to an unrecoverable error, or {@code null} if completed normally
+     */
+    protected void onTermination(Throwable exception) {
+        try {
+            terminate = true;
+            cancelTasks();
+            pool.deregisterWorker(this, exception);
+        } catch (Throwable ex) {        // Shouldn't ever happen
+            if (exception == null)      // but if so, at least rethrown
+                exception = ex;
+        } finally {
+            if (exception != null)
+                SneakyThrow.sneakyThrow(exception); // android-changed
+        }
+    }
+
+    /**
+     * This method is required to be public, but should never be
+     * called explicitly. It performs the main run loop to execute
+     * {@link ForkJoinTask}s.
+     */
+    public void run() {
+        Throwable exception = null;
+        try {
+            onStart();
+            pool.work(this);
+        } catch (Throwable ex) {
+            exception = ex;
+        } finally {
+            onTermination(exception);
+        }
+    }
+
+    /*
+     * Intrinsics-based atomic writes for queue slots. These are
+     * basically the same as methods in AtomicReferenceArray, but
+     * specialized for (1) ForkJoinTask elements (2) requirement that
+     * nullness and bounds checks have already been performed by
+     * callers and (3) effective offsets are known not to overflow
+     * from int to long (because of MAXIMUM_QUEUE_CAPACITY). We don't
+     * need corresponding version for reads: plain array reads are OK
+     * because they are protected by other volatile reads and are
+     * confirmed by CASes.
+     *
+     * Most uses don't actually call these methods, but instead
+     * contain inlined forms that enable more predictable
+     * optimization.  We don't define the version of write used in
+     * pushTask at all, but instead inline there a store-fenced array
+     * slot write.
+     *
+     * Also in most methods, as a performance (not correctness) issue,
+     * we'd like to encourage compilers not to arbitrarily postpone
+     * setting queueTop after writing slot.  Currently there is no
+     * intrinsic for arranging this, but using Unsafe putOrderedInt
+     * may be a preferable strategy on some compilers even though its
+     * main effect is a pre-, not post- fence. To simplify possible
+     * changes, the option is left in comments next to the associated
+     * assignments.
+     */
+
+    /**
+     * CASes slot i of array q from t to null. Caller must ensure q is
+     * non-null and index is in range.
+     */
+    private static final boolean casSlotNull(ForkJoinTask<?>[] q, int i,
+                                             ForkJoinTask<?> t) {
+        return UNSAFE.compareAndSwapObject(q, (i << ASHIFT) + ABASE, t, null);
+    }
+
+    /**
+     * Performs a volatile write of the given task at given slot of
+     * array q.  Caller must ensure q is non-null and index is in
+     * range. This method is used only during resets and backouts.
+     */
+    private static final void writeSlot(ForkJoinTask<?>[] q, int i,
+                                        ForkJoinTask<?> t) {
+        UNSAFE.putObjectVolatile(q, (i << ASHIFT) + ABASE, t);
+    }
+
+    // queue methods
+
+    /**
+     * Pushes a task. Call only from this thread.
+     *
+     * @param t the task. Caller must ensure non-null.
+     */
+    final void pushTask(ForkJoinTask<?> t) {
+        ForkJoinTask<?>[] q; int s, m;
+        if ((q = queue) != null) {    // ignore if queue removed
+            long u = (((s = queueTop) & (m = q.length - 1)) << ASHIFT) + ABASE;
+            UNSAFE.putOrderedObject(q, u, t);
+            queueTop = s + 1;         // or use putOrderedInt
+            if ((s -= queueBase) <= 2)
+                pool.signalWork();
+            else if (s == m)
+                growQueue();
+        }
+    }
+
+    /**
+     * Creates or doubles queue array.  Transfers elements by
+     * emulating steals (deqs) from old array and placing, oldest
+     * first, into new array.
+     */
+    private void growQueue() {
+        ForkJoinTask<?>[] oldQ = queue;
+        int size = oldQ != null ? oldQ.length << 1 : INITIAL_QUEUE_CAPACITY;
+        if (size > MAXIMUM_QUEUE_CAPACITY)
+            throw new RejectedExecutionException("Queue capacity exceeded");
+        if (size < INITIAL_QUEUE_CAPACITY)
+            size = INITIAL_QUEUE_CAPACITY;
+        ForkJoinTask<?>[] q = queue = new ForkJoinTask<?>[size];
+        int mask = size - 1;
+        int top = queueTop;
+        int oldMask;
+        if (oldQ != null && (oldMask = oldQ.length - 1) >= 0) {
+            for (int b = queueBase; b != top; ++b) {
+                long u = ((b & oldMask) << ASHIFT) + ABASE;
+                Object x = UNSAFE.getObjectVolatile(oldQ, u);
+                if (x != null && UNSAFE.compareAndSwapObject(oldQ, u, x, null))
+                    UNSAFE.putObjectVolatile
+                        (q, ((b & mask) << ASHIFT) + ABASE, x);
+            }
+        }
+    }
+
+    /**
+     * Tries to take a task from the base of the queue, failing if
+     * empty or contended. Note: Specializations of this code appear
+     * in locallyDeqTask and elsewhere.
+     *
+     * @return a task, or null if none or contended
+     */
+    final ForkJoinTask<?> deqTask() {
+        ForkJoinTask<?> t; ForkJoinTask<?>[] q; int b, i;
+        if (queueTop != (b = queueBase) &&
+            (q = queue) != null && // must read q after b
+            (i = (q.length - 1) & b) >= 0 &&
+            (t = q[i]) != null && queueBase == b &&
+            UNSAFE.compareAndSwapObject(q, (i << ASHIFT) + ABASE, t, null)) {
+            queueBase = b + 1;
+            return t;
+        }
+        return null;
+    }
+
+    /**
+     * Tries to take a task from the base of own queue.  Called only
+     * by this thread.
+     *
+     * @return a task, or null if none
+     */
+    final ForkJoinTask<?> locallyDeqTask() {
+        ForkJoinTask<?> t; int m, b, i;
+        ForkJoinTask<?>[] q = queue;
+        if (q != null && (m = q.length - 1) >= 0) {
+            while (queueTop != (b = queueBase)) {
+                if ((t = q[i = m & b]) != null &&
+                    queueBase == b &&
+                    UNSAFE.compareAndSwapObject(q, (i << ASHIFT) + ABASE,
+                                                t, null)) {
+                    queueBase = b + 1;
+                    return t;
+                }
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Returns a popped task, or null if empty.
+     * Called only by this thread.
+     */
+    private ForkJoinTask<?> popTask() {
+        int m;
+        ForkJoinTask<?>[] q = queue;
+        if (q != null && (m = q.length - 1) >= 0) {
+            for (int s; (s = queueTop) != queueBase;) {
+                int i = m & --s;
+                long u = (i << ASHIFT) + ABASE; // raw offset
+                ForkJoinTask<?> t = q[i];
+                if (t == null)   // lost to stealer
+                    break;
+                if (UNSAFE.compareAndSwapObject(q, u, t, null)) {
+                    queueTop = s; // or putOrderedInt
+                    return t;
+                }
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Specialized version of popTask to pop only if topmost element
+     * is the given task. Called only by this thread.
+     *
+     * @param t the task. Caller must ensure non-null.
+     */
+    final boolean unpushTask(ForkJoinTask<?> t) {
+        ForkJoinTask<?>[] q;
+        int s;
+        if ((q = queue) != null && (s = queueTop) != queueBase &&
+            UNSAFE.compareAndSwapObject
+            (q, (((q.length - 1) & --s) << ASHIFT) + ABASE, t, null)) {
+            queueTop = s; // or putOrderedInt
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Returns next task, or null if empty or contended.
+     */
+    final ForkJoinTask<?> peekTask() {
+        int m;
+        ForkJoinTask<?>[] q = queue;
+        if (q == null || (m = q.length - 1) < 0)
+            return null;
+        int i = locallyFifo ? queueBase : (queueTop - 1);
+        return q[i & m];
+    }
+
+    // Support methods for ForkJoinPool
+
+    /**
+     * Runs the given task, plus any local tasks until queue is empty
+     */
+    final void execTask(ForkJoinTask<?> t) {
+        currentSteal = t;
+        for (;;) {
+            if (t != null)
+                t.doExec();
+            if (queueTop == queueBase)
+                break;
+            t = locallyFifo ? locallyDeqTask() : popTask();
+        }
+        ++stealCount;
+        currentSteal = null;
+    }
+
+    /**
+     * Removes and cancels all tasks in queue.  Can be called from any
+     * thread.
+     */
+    final void cancelTasks() {
+        ForkJoinTask<?> cj = currentJoin; // try to cancel ongoing tasks
+        if (cj != null && cj.status >= 0)
+            cj.cancelIgnoringExceptions();
+        ForkJoinTask<?> cs = currentSteal;
+        if (cs != null && cs.status >= 0)
+            cs.cancelIgnoringExceptions();
+        while (queueBase != queueTop) {
+            ForkJoinTask<?> t = deqTask();
+            if (t != null)
+                t.cancelIgnoringExceptions();
+        }
+    }
+
+    /**
+     * Drains tasks to given collection c.
+     *
+     * @return the number of tasks drained
+     */
+    final int drainTasksTo(Collection<? super ForkJoinTask<?>> c) {
+        int n = 0;
+        while (queueBase != queueTop) {
+            ForkJoinTask<?> t = deqTask();
+            if (t != null) {
+                c.add(t);
+                ++n;
+            }
+        }
+        return n;
+    }
+
+    // Support methods for ForkJoinTask
+
+    /**
+     * Returns an estimate of the number of tasks in the queue.
+     */
+    final int getQueueSize() {
+        return queueTop - queueBase;
+    }
+
+    /**
+     * Gets and removes a local task.
+     *
+     * @return a task, if available
+     */
+    final ForkJoinTask<?> pollLocalTask() {
+        return locallyFifo ? locallyDeqTask() : popTask();
+    }
+
+    /**
+     * Gets and removes a local or stolen task.
+     *
+     * @return a task, if available
+     */
+    final ForkJoinTask<?> pollTask() {
+        ForkJoinWorkerThread[] ws;
+        ForkJoinTask<?> t = pollLocalTask();
+        if (t != null || (ws = pool.workers) == null)
+            return t;
+        int n = ws.length; // cheap version of FJP.scan
+        int steps = n << 1;
+        int r = nextSeed();
+        int i = 0;
+        while (i < steps) {
+            ForkJoinWorkerThread w = ws[(i++ + r) & (n - 1)];
+            if (w != null && w.queueBase != w.queueTop && w.queue != null) {
+                if ((t = w.deqTask()) != null)
+                    return t;
+                i = 0;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * The maximum stolen->joining link depth allowed in helpJoinTask,
+     * as well as the maximum number of retries (allowing on average
+     * one staleness retry per level) per attempt to instead try
+     * compensation.  Depths for legitimate chains are unbounded, but
+     * we use a fixed constant to avoid (otherwise unchecked) cycles
+     * and bound staleness of traversal parameters at the expense of
+     * sometimes blocking when we could be helping.
+     */
+    private static final int MAX_HELP = 16;
+
+    /**
+     * Possibly runs some tasks and/or blocks, until joinMe is done.
+     *
+     * @param joinMe the task to join
+     * @return completion status on exit
+     */
+    final int joinTask(ForkJoinTask<?> joinMe) {
+        ForkJoinTask<?> prevJoin = currentJoin;
+        currentJoin = joinMe;
+        for (int s, retries = MAX_HELP;;) {
+            if ((s = joinMe.status) < 0) {
+                currentJoin = prevJoin;
+                return s;
+            }
+            if (retries > 0) {
+                if (queueTop != queueBase) {
+                    if (!localHelpJoinTask(joinMe))
+                        retries = 0;           // cannot help
+                }
+                else if (retries == MAX_HELP >>> 1) {
+                    --retries;                 // check uncommon case
+                    if (tryDeqAndExec(joinMe) >= 0)
+                        Thread.yield();        // for politeness
+                }
+                else
+                    retries = helpJoinTask(joinMe) ? MAX_HELP : retries - 1;
+            }
+            else {
+                retries = MAX_HELP;           // restart if not done
+                pool.tryAwaitJoin(joinMe);
+            }
+        }
+    }
+
+    /**
+     * If present, pops and executes the given task, or any other
+     * cancelled task
+     *
+     * @return false if any other non-cancelled task exists in local queue
+     */
+    private boolean localHelpJoinTask(ForkJoinTask<?> joinMe) {
+        int s, i; ForkJoinTask<?>[] q; ForkJoinTask<?> t;
+        if ((s = queueTop) != queueBase && (q = queue) != null &&
+            (i = (q.length - 1) & --s) >= 0 &&
+            (t = q[i]) != null) {
+            if (t != joinMe && t.status >= 0)
+                return false;
+            if (UNSAFE.compareAndSwapObject
+                (q, (i << ASHIFT) + ABASE, t, null)) {
+                queueTop = s;           // or putOrderedInt
+                t.doExec();
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Tries to locate and execute tasks for a stealer of the given
+     * task, or in turn one of its stealers, Traces
+     * currentSteal->currentJoin links looking for a thread working on
+     * a descendant of the given task and with a non-empty queue to
+     * steal back and execute tasks from.  The implementation is very
+     * branchy to cope with potential inconsistencies or loops
+     * encountering chains that are stale, unknown, or of length
+     * greater than MAX_HELP links.  All of these cases are dealt with
+     * by just retrying by caller.
+     *
+     * @param joinMe the task to join
+     * @return true if ran a task
+     */
+    private boolean helpJoinTask(ForkJoinTask<?> joinMe) {
+        boolean helped = false;
+        int m = pool.scanGuard & SMASK;
+        ForkJoinWorkerThread[] ws = pool.workers;
+        if (ws != null && ws.length > m && joinMe.status >= 0) {
+            int levels = MAX_HELP;              // remaining chain length
+            ForkJoinTask<?> task = joinMe;      // base of chain
+            outer:for (ForkJoinWorkerThread thread = this;;) {
+                // Try to find v, the stealer of task, by first using hint
+                ForkJoinWorkerThread v = ws[thread.stealHint & m];
+                if (v == null || v.currentSteal != task) {
+                    for (int j = 0; ;) {        // search array
+                        if ((v = ws[j]) != null && v.currentSteal == task) {
+                            thread.stealHint = j;
+                            break;              // save hint for next time
+                        }
+                        if (++j > m)
+                            break outer;        // can't find stealer
+                    }
+                }
+                // Try to help v, using specialized form of deqTask
+                for (;;) {
+                    ForkJoinTask<?>[] q; int b, i;
+                    if (joinMe.status < 0)
+                        break outer;
+                    if ((b = v.queueBase) == v.queueTop ||
+                        (q = v.queue) == null ||
+                        (i = (q.length-1) & b) < 0)
+                        break;                  // empty
+                    long u = (i << ASHIFT) + ABASE;
+                    ForkJoinTask<?> t = q[i];
+                    if (task.status < 0)
+                        break outer;            // stale
+                    if (t != null && v.queueBase == b &&
+                        UNSAFE.compareAndSwapObject(q, u, t, null)) {
+                        v.queueBase = b + 1;
+                        v.stealHint = poolIndex;
+                        ForkJoinTask<?> ps = currentSteal;
+                        currentSteal = t;
+                        t.doExec();
+                        currentSteal = ps;
+                        helped = true;
+                    }
+                }
+                // Try to descend to find v's stealer
+                ForkJoinTask<?> next = v.currentJoin;
+                if (--levels > 0 && task.status >= 0 &&
+                    next != null && next != task) {
+                    task = next;
+                    thread = v;
+                }
+                else
+                    break;  // max levels, stale, dead-end, or cyclic
+            }
+        }
+        return helped;
+    }
+
+    /**
+     * Performs an uncommon case for joinTask: If task t is at base of
+     * some workers queue, steals and executes it.
+     *
+     * @param t the task
+     * @return t's status
+     */
+    private int tryDeqAndExec(ForkJoinTask<?> t) {
+        int m = pool.scanGuard & SMASK;
+        ForkJoinWorkerThread[] ws = pool.workers;
+        if (ws != null && ws.length > m && t.status >= 0) {
+            for (int j = 0; j <= m; ++j) {
+                ForkJoinTask<?>[] q; int b, i;
+                ForkJoinWorkerThread v = ws[j];
+                if (v != null &&
+                    (b = v.queueBase) != v.queueTop &&
+                    (q = v.queue) != null &&
+                    (i = (q.length - 1) & b) >= 0 &&
+                    q[i] ==  t) {
+                    long u = (i << ASHIFT) + ABASE;
+                    if (v.queueBase == b &&
+                        UNSAFE.compareAndSwapObject(q, u, t, null)) {
+                        v.queueBase = b + 1;
+                        v.stealHint = poolIndex;
+                        ForkJoinTask<?> ps = currentSteal;
+                        currentSteal = t;
+                        t.doExec();
+                        currentSteal = ps;
+                    }
+                    break;
+                }
+            }
+        }
+        return t.status;
+    }
+
+    /**
+     * Implements ForkJoinTask.getSurplusQueuedTaskCount().  Returns
+     * an estimate of the number of tasks, offset by a function of
+     * number of idle workers.
+     *
+     * This method provides a cheap heuristic guide for task
+     * partitioning when programmers, frameworks, tools, or languages
+     * have little or no idea about task granularity.  In essence by
+     * offering this method, we ask users only about tradeoffs in
+     * overhead vs expected throughput and its variance, rather than
+     * how finely to partition tasks.
+     *
+     * In a steady state strict (tree-structured) computation, each
+     * thread makes available for stealing enough tasks for other
+     * threads to remain active. Inductively, if all threads play by
+     * the same rules, each thread should make available only a
+     * constant number of tasks.
+     *
+     * The minimum useful constant is just 1. But using a value of 1
+     * would require immediate replenishment upon each steal to
+     * maintain enough tasks, which is infeasible.  Further,
+     * partitionings/granularities of offered tasks should minimize
+     * steal rates, which in general means that threads nearer the top
+     * of computation tree should generate more than those nearer the
+     * bottom. In perfect steady state, each thread is at
+     * approximately the same level of computation tree. However,
+     * producing extra tasks amortizes the uncertainty of progress and
+     * diffusion assumptions.
+     *
+     * So, users will want to use values larger, but not much larger
+     * than 1 to both smooth over transient shortages and hedge
+     * against uneven progress; as traded off against the cost of
+     * extra task overhead. We leave the user to pick a threshold
+     * value to compare with the results of this call to guide
+     * decisions, but recommend values such as 3.
+     *
+     * When all threads are active, it is on average OK to estimate
+     * surplus strictly locally. In steady-state, if one thread is
+     * maintaining say 2 surplus tasks, then so are others. So we can
+     * just use estimated queue length (although note that (queueTop -
+     * queueBase) can be an overestimate because of stealers lagging
+     * increments of queueBase).  However, this strategy alone leads
+     * to serious mis-estimates in some non-steady-state conditions
+     * (ramp-up, ramp-down, other stalls). We can detect many of these
+     * by further considering the number of "idle" threads, that are
+     * known to have zero queued tasks, so compensate by a factor of
+     * (#idle/#active) threads.
+     */
+    final int getEstimatedSurplusTaskCount() {
+        return queueTop - queueBase - pool.idlePerActive();
+    }
+
+    /**
+     * Runs tasks until {@code pool.isQuiescent()}. We piggyback on
+     * pool's active count ctl maintenance, but rather than blocking
+     * when tasks cannot be found, we rescan until all others cannot
+     * find tasks either. The bracketing by pool quiescerCounts
+     * updates suppresses pool auto-shutdown mechanics that could
+     * otherwise prematurely terminate the pool because all threads
+     * appear to be inactive.
+     */
+    final void helpQuiescePool() {
+        boolean active = true;
+        ForkJoinTask<?> ps = currentSteal; // to restore below
+        ForkJoinPool p = pool;
+        p.addQuiescerCount(1);
+        for (;;) {
+            ForkJoinWorkerThread[] ws = p.workers;
+            ForkJoinWorkerThread v = null;
+            int n;
+            if (queueTop != queueBase)
+                v = this;
+            else if (ws != null && (n = ws.length) > 1) {
+                ForkJoinWorkerThread w;
+                int r = nextSeed(); // cheap version of FJP.scan
+                int steps = n << 1;
+                for (int i = 0; i < steps; ++i) {
+                    if ((w = ws[(i + r) & (n - 1)]) != null &&
+                        w.queueBase != w.queueTop) {
+                        v = w;
+                        break;
+                    }
+                }
+            }
+            if (v != null) {
+                ForkJoinTask<?> t;
+                if (!active) {
+                    active = true;
+                    p.addActiveCount(1);
+                }
+                if ((t = (v != this) ? v.deqTask() :
+                     locallyFifo ? locallyDeqTask() : popTask()) != null) {
+                    currentSteal = t;
+                    t.doExec();
+                    currentSteal = ps;
+                }
+            }
+            else {
+                if (active) {
+                    active = false;
+                    p.addActiveCount(-1);
+                }
+                if (p.isQuiescent()) {
+                    p.addActiveCount(1);
+                    p.addQuiescerCount(-1);
+                    break;
+                }
+            }
+        }
+    }
+
+    // Unsafe mechanics
+    private static final sun.misc.Unsafe UNSAFE;
+    private static final long ABASE;
+    private static final int ASHIFT;
+
+    static {
+        int s;
+        try {
+            UNSAFE = sun.misc.Unsafe.getUnsafe();
+            Class<?> a = ForkJoinTask[].class;
+            ABASE = UNSAFE.arrayBaseOffset(a);
+            s = UNSAFE.arrayIndexScale(a);
+        } catch (Exception e) {
+            throw new Error(e);
+        }
+        if ((s & (s-1)) != 0)
+            throw new Error("data type scale not a power of two");
+        ASHIFT = 31 - Integer.numberOfLeadingZeros(s);
+    }
+
+}
diff --git a/luni/src/main/java/java/util/concurrent/Future.java b/luni/src/main/java/java/util/concurrent/Future.java
index eb84796..6a37729 100644
--- a/luni/src/main/java/java/util/concurrent/Future.java
+++ b/luni/src/main/java/java/util/concurrent/Future.java
@@ -1,7 +1,7 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent;
diff --git a/luni/src/main/java/java/util/concurrent/FutureTask.java b/luni/src/main/java/java/util/concurrent/FutureTask.java
index 2f2335e..d51881d 100644
--- a/luni/src/main/java/java/util/concurrent/FutureTask.java
+++ b/luni/src/main/java/java/util/concurrent/FutureTask.java
@@ -1,55 +1,116 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent;
-import java.util.concurrent.locks.*;
+import java.util.concurrent.locks.LockSupport;
 
 /**
  * A cancellable asynchronous computation.  This class provides a base
  * implementation of {@link Future}, with methods to start and cancel
  * a computation, query to see if the computation is complete, and
  * retrieve the result of the computation.  The result can only be
- * retrieved when the computation has completed; the <tt>get</tt>
- * method will block if the computation has not yet completed.  Once
+ * retrieved when the computation has completed; the {@code get}
+ * methods will block if the computation has not yet completed.  Once
  * the computation has completed, the computation cannot be restarted
- * or cancelled.
+ * or cancelled (unless the computation is invoked using
+ * {@link #runAndReset}).
  *
- * <p>A <tt>FutureTask</tt> can be used to wrap a {@link Callable} or
- * {@link java.lang.Runnable} object.  Because <tt>FutureTask</tt>
- * implements <tt>Runnable</tt>, a <tt>FutureTask</tt> can be
- * submitted to an {@link Executor} for execution.
+ * <p>A {@code FutureTask} can be used to wrap a {@link Callable} or
+ * {@link Runnable} object.  Because {@code FutureTask} implements
+ * {@code Runnable}, a {@code FutureTask} can be submitted to an
+ * {@link Executor} for execution.
  *
  * <p>In addition to serving as a standalone class, this class provides
- * <tt>protected</tt> functionality that may be useful when creating
+ * {@code protected} functionality that may be useful when creating
  * customized task classes.
  *
  * @since 1.5
  * @author Doug Lea
- * @param <V> The result type returned by this FutureTask's <tt>get</tt> method
+ * @param <V> The result type returned by this FutureTask's {@code get} methods
  */
 public class FutureTask<V> implements RunnableFuture<V> {
-    /** Synchronization control for FutureTask */
-    private final Sync sync;
+    /*
+     * Revision notes: This differs from previous versions of this
+     * class that relied on AbstractQueuedSynchronizer, mainly to
+     * avoid surprising users about retaining interrupt status during
+     * cancellation races. Sync control in the current design relies
+     * on a "state" field updated via CAS to track completion, along
+     * with a simple Treiber stack to hold waiting threads.
+     *
+     * Style note: As usual, we bypass overhead of using
+     * AtomicXFieldUpdaters and instead directly use Unsafe intrinsics.
+     */
+
+    /**
+     * The run state of this task, initially NEW.  The run state
+     * transitions to a terminal state only in methods set,
+     * setException, and cancel.  During completion, state may take on
+     * transient values of COMPLETING (while outcome is being set) or
+     * INTERRUPTING (only while interrupting the runner to satisfy a
+     * cancel(true)). Transitions from these intermediate to final
+     * states use cheaper ordered/lazy writes because values are unique
+     * and cannot be further modified.
+     *
+     * Possible state transitions:
+     * NEW -> COMPLETING -> NORMAL
+     * NEW -> COMPLETING -> EXCEPTIONAL
+     * NEW -> CANCELLED
+     * NEW -> INTERRUPTING -> INTERRUPTED
+     */
+    private volatile int state;
+    private static final int NEW          = 0;
+    private static final int COMPLETING   = 1;
+    private static final int NORMAL       = 2;
+    private static final int EXCEPTIONAL  = 3;
+    private static final int CANCELLED    = 4;
+    private static final int INTERRUPTING = 5;
+    private static final int INTERRUPTED  = 6;
+
+    /** The underlying callable; nulled out after running */
+    private Callable<V> callable;
+    /** The result to return or exception to throw from get() */
+    private Object outcome; // non-volatile, protected by state reads/writes
+    /** The thread running the callable; CASed during run() */
+    private volatile Thread runner;
+    /** Treiber stack of waiting threads */
+    private volatile WaitNode waiters;
+
+    /**
+     * Returns result or throws exception for completed task.
+     *
+     * @param s completed state value
+     */
+    private V report(int s) throws ExecutionException {
+        Object x = outcome;
+        if (s == NORMAL) {
+            @SuppressWarnings("unchecked") V v = (V)x;
+            return v;
+        }
+        if (s >= CANCELLED)
+            throw new CancellationException();
+        throw new ExecutionException((Throwable)x);
+    }
 
     /**
-     * Creates a <tt>FutureTask</tt> that will, upon running, execute the
-     * given <tt>Callable</tt>.
+     * Creates a {@code FutureTask} that will, upon running, execute the
+     * given {@code Callable}.
      *
      * @param  callable the callable task
-     * @throws NullPointerException if callable is null
+     * @throws NullPointerException if the callable is null
      */
     public FutureTask(Callable<V> callable) {
         if (callable == null)
             throw new NullPointerException();
-        sync = new Sync(callable);
+        this.callable = callable;
+        this.state = NEW;       // ensure visibility of callable
     }
 
     /**
-     * Creates a <tt>FutureTask</tt> that will, upon running, execute the
-     * given <tt>Runnable</tt>, and arrange that <tt>get</tt> will return the
+     * Creates a {@code FutureTask} that will, upon running, execute the
+     * given {@code Runnable}, and arrange that {@code get} will return the
      * given result on successful completion.
      *
      * @param runnable the runnable task
@@ -57,29 +118,46 @@ public class FutureTask<V> implements RunnableFuture<V> {
      * you don't need a particular result, consider using
      * constructions of the form:
      * {@code Future<?> f = new FutureTask<Void>(runnable, null)}
-     * @throws NullPointerException if runnable is null
+     * @throws NullPointerException if the runnable is null
      */
     public FutureTask(Runnable runnable, V result) {
-        sync = new Sync(Executors.callable(runnable, result));
+        this.callable = Executors.callable(runnable, result);
+        this.state = NEW;       // ensure visibility of callable
     }
 
     public boolean isCancelled() {
-        return sync.innerIsCancelled();
+        return state >= CANCELLED;
     }
 
     public boolean isDone() {
-        return sync.innerIsDone();
+        return state != NEW;
     }
 
     public boolean cancel(boolean mayInterruptIfRunning) {
-        return sync.innerCancel(mayInterruptIfRunning);
+        if (state != NEW)
+            return false;
+        if (mayInterruptIfRunning) {
+            if (!UNSAFE.compareAndSwapInt(this, stateOffset, NEW, INTERRUPTING))
+                return false;
+            Thread t = runner;
+            if (t != null)
+                t.interrupt();
+            UNSAFE.putOrderedInt(this, stateOffset, INTERRUPTED); // final state
+        }
+        else if (!UNSAFE.compareAndSwapInt(this, stateOffset, NEW, CANCELLED))
+            return false;
+        finishCompletion();
+        return true;
     }
 
     /**
      * @throws CancellationException {@inheritDoc}
      */
     public V get() throws InterruptedException, ExecutionException {
-        return sync.innerGet();
+        int s = state;
+        if (s <= COMPLETING)
+            s = awaitDone(false, 0L);
+        return report(s);
     }
 
     /**
@@ -87,12 +165,18 @@ public class FutureTask<V> implements RunnableFuture<V> {
      */
     public V get(long timeout, TimeUnit unit)
         throws InterruptedException, ExecutionException, TimeoutException {
-        return sync.innerGet(unit.toNanos(timeout));
+        if (unit == null)
+            throw new NullPointerException();
+        int s = state;
+        if (s <= COMPLETING &&
+            (s = awaitDone(true, unit.toNanos(timeout))) <= COMPLETING)
+            throw new TimeoutException();
+        return report(s);
     }
 
     /**
      * Protected method invoked when this task transitions to state
-     * <tt>isDone</tt> (whether normally or via cancellation). The
+     * {@code isDone} (whether normally or via cancellation). The
      * default implementation does nothing.  Subclasses may override
      * this method to invoke completion callbacks or perform
      * bookkeeping. Note that you can query status inside the
@@ -102,230 +186,268 @@ public class FutureTask<V> implements RunnableFuture<V> {
     protected void done() { }
 
     /**
-     * Sets the result of this Future to the given value unless
+     * Sets the result of this future to the given value unless
      * this future has already been set or has been cancelled.
-     * This method is invoked internally by the <tt>run</tt> method
+     *
+     * <p>This method is invoked internally by the {@link #run} method
      * upon successful completion of the computation.
+     *
      * @param v the value
      */
     protected void set(V v) {
-        sync.innerSet(v);
+        if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
+            outcome = v;
+            UNSAFE.putOrderedInt(this, stateOffset, NORMAL); // final state
+            finishCompletion();
+        }
     }
 
     /**
-     * Causes this future to report an <tt>ExecutionException</tt>
-     * with the given throwable as its cause, unless this Future has
+     * Causes this future to report an {@link ExecutionException}
+     * with the given throwable as its cause, unless this future has
      * already been set or has been cancelled.
-     * This method is invoked internally by the <tt>run</tt> method
+     *
+     * <p>This method is invoked internally by the {@link #run} method
      * upon failure of the computation.
+     *
      * @param t the cause of failure
      */
     protected void setException(Throwable t) {
-        sync.innerSetException(t);
+        if (UNSAFE.compareAndSwapInt(this, stateOffset, NEW, COMPLETING)) {
+            outcome = t;
+            UNSAFE.putOrderedInt(this, stateOffset, EXCEPTIONAL); // final state
+            finishCompletion();
+        }
     }
 
-    // The following (duplicated) doc comment can be removed once
-    //
-    // 6270645: Javadoc comments should be inherited from most derived
-    //          superinterface or superclass
-    // is fixed.
-    /**
-     * Sets this Future to the result of its computation
-     * unless it has been cancelled.
-     */
     public void run() {
-        sync.innerRun();
+        if (state != NEW ||
+            !UNSAFE.compareAndSwapObject(this, runnerOffset,
+                                         null, Thread.currentThread()))
+            return;
+        try {
+            Callable<V> c = callable;
+            if (c != null && state == NEW) {
+                V result;
+                boolean ran;
+                try {
+                    result = c.call();
+                    ran = true;
+                } catch (Throwable ex) {
+                    result = null;
+                    ran = false;
+                    setException(ex);
+                }
+                if (ran)
+                    set(result);
+            }
+        } finally {
+            // runner must be non-null until state is settled to
+            // prevent concurrent calls to run()
+            runner = null;
+            // state must be re-read after nulling runner to prevent
+            // leaked interrupts
+            int s = state;
+            if (s >= INTERRUPTING)
+                handlePossibleCancellationInterrupt(s);
+        }
     }
 
     /**
      * Executes the computation without setting its result, and then
-     * resets this Future to initial state, failing to do so if the
+     * resets this future to initial state, failing to do so if the
      * computation encounters an exception or is cancelled.  This is
      * designed for use with tasks that intrinsically execute more
      * than once.
+     *
      * @return true if successfully run and reset
      */
     protected boolean runAndReset() {
-        return sync.innerRunAndReset();
+        if (state != NEW ||
+            !UNSAFE.compareAndSwapObject(this, runnerOffset,
+                                         null, Thread.currentThread()))
+            return false;
+        boolean ran = false;
+        int s = state;
+        try {
+            Callable<V> c = callable;
+            if (c != null && s == NEW) {
+                try {
+                    c.call(); // don't set result
+                    ran = true;
+                } catch (Throwable ex) {
+                    setException(ex);
+                }
+            }
+        } finally {
+            // runner must be non-null until state is settled to
+            // prevent concurrent calls to run()
+            runner = null;
+            // state must be re-read after nulling runner to prevent
+            // leaked interrupts
+            s = state;
+            if (s >= INTERRUPTING)
+                handlePossibleCancellationInterrupt(s);
+        }
+        return ran && s == NEW;
     }
 
     /**
-     * Synchronization control for FutureTask. Note that this must be
-     * a non-static inner class in order to invoke the protected
-     * <tt>done</tt> method. For clarity, all inner class support
-     * methods are same as outer, prefixed with "inner".
-     *
-     * Uses AQS sync state to represent run status
+     * Ensures that any interrupt from a possible cancel(true) is only
+     * delivered to a task while in run or runAndReset.
      */
-    private final class Sync extends AbstractQueuedSynchronizer {
-        private static final long serialVersionUID = -7828117401763700385L;
-
-        /** State value representing that task is ready to run */
-        private static final int READY     = 0;
-        /** State value representing that task is running */
-        private static final int RUNNING   = 1;
-        /** State value representing that task ran */
-        private static final int RAN       = 2;
-        /** State value representing that task was cancelled */
-        private static final int CANCELLED = 4;
-
-        /** The underlying callable */
-        private final Callable<V> callable;
-        /** The result to return from get() */
-        private V result;
-        /** The exception to throw from get() */
-        private Throwable exception;
-
-        /**
-         * The thread running task. When nulled after set/cancel, this
-         * indicates that the results are accessible.  Must be
-         * volatile, to ensure visibility upon completion.
-         */
-        private volatile Thread runner;
-
-        Sync(Callable<V> callable) {
-            this.callable = callable;
-        }
-
-        private boolean ranOrCancelled(int state) {
-            return (state & (RAN | CANCELLED)) != 0;
-        }
-
-        /**
-         * Implements AQS base acquire to succeed if ran or cancelled
-         */
-        protected int tryAcquireShared(int ignore) {
-            return innerIsDone() ? 1 : -1;
-        }
-
-        /**
-         * Implements AQS base release to always signal after setting
-         * final done status by nulling runner thread.
-         */
-        protected boolean tryReleaseShared(int ignore) {
-            runner = null;
-            return true;
-        }
-
-        boolean innerIsCancelled() {
-            return getState() == CANCELLED;
-        }
-
-        boolean innerIsDone() {
-            return ranOrCancelled(getState()) && runner == null;
-        }
-
-        V innerGet() throws InterruptedException, ExecutionException {
-            acquireSharedInterruptibly(0);
-            if (getState() == CANCELLED)
-                throw new CancellationException();
-            if (exception != null)
-                throw new ExecutionException(exception);
-            return result;
-        }
+    private void handlePossibleCancellationInterrupt(int s) {
+        // It is possible for our interrupter to stall before getting a
+        // chance to interrupt us.  Let's spin-wait patiently.
+        if (s == INTERRUPTING)
+            while (state == INTERRUPTING)
+                Thread.yield(); // wait out pending interrupt
+
+        // assert state == INTERRUPTED;
+
+        // We want to clear any interrupt we may have received from
+        // cancel(true).  However, it is permissible to use interrupts
+        // as an independent mechanism for a task to communicate with
+        // its caller, and there is no way to clear only the
+        // cancellation interrupt.
+        //
+        // Thread.interrupted();
+    }
 
-        V innerGet(long nanosTimeout) throws InterruptedException, ExecutionException, TimeoutException {
-            if (!tryAcquireSharedNanos(0, nanosTimeout))
-                throw new TimeoutException();
-            if (getState() == CANCELLED)
-                throw new CancellationException();
-            if (exception != null)
-                throw new ExecutionException(exception);
-            return result;
-        }
+    /**
+     * Simple linked list nodes to record waiting threads in a Treiber
+     * stack.  See other classes such as Phaser and SynchronousQueue
+     * for more detailed explanation.
+     */
+    static final class WaitNode {
+        volatile Thread thread;
+        volatile WaitNode next;
+        WaitNode() { thread = Thread.currentThread(); }
+    }
 
-        void innerSet(V v) {
-            for (;;) {
-                int s = getState();
-                if (s == RAN)
-                    return;
-                if (s == CANCELLED) {
-                    // aggressively release to set runner to null,
-                    // in case we are racing with a cancel request
-                    // that will try to interrupt runner
-                    releaseShared(0);
-                    return;
-                }
-                if (compareAndSetState(s, RAN)) {
-                    result = v;
-                    releaseShared(0);
-                    done();
-                    return;
+    /**
+     * Removes and signals all waiting threads, invokes done(), and
+     * nulls out callable.
+     */
+    private void finishCompletion() {
+        // assert state > COMPLETING;
+        for (WaitNode q; (q = waiters) != null;) {
+            if (UNSAFE.compareAndSwapObject(this, waitersOffset, q, null)) {
+                for (;;) {
+                    Thread t = q.thread;
+                    if (t != null) {
+                        q.thread = null;
+                        LockSupport.unpark(t);
+                    }
+                    WaitNode next = q.next;
+                    if (next == null)
+                        break;
+                    q.next = null; // unlink to help gc
+                    q = next;
                 }
+                break;
             }
         }
 
-        void innerSetException(Throwable t) {
-            for (;;) {
-                int s = getState();
-                if (s == RAN)
-                    return;
-                if (s == CANCELLED) {
-                    // aggressively release to set runner to null,
-                    // in case we are racing with a cancel request
-                    // that will try to interrupt runner
-                    releaseShared(0);
-                    return;
-                }
-                if (compareAndSetState(s, RAN)) {
-                    exception = t;
-                    releaseShared(0);
-                    done();
-                    return;
-                }
+        done();
+
+        callable = null;        // to reduce footprint
+    }
+
+    /**
+     * Awaits completion or aborts on interrupt or timeout.
+     *
+     * @param timed true if use timed waits
+     * @param nanos time to wait, if timed
+     * @return state upon completion
+     */
+    private int awaitDone(boolean timed, long nanos)
+        throws InterruptedException {
+        long last = timed ? System.nanoTime() : 0L;
+        WaitNode q = null;
+        boolean queued = false;
+        for (;;) {
+            if (Thread.interrupted()) {
+                removeWaiter(q);
+                throw new InterruptedException();
             }
-        }
 
-        boolean innerCancel(boolean mayInterruptIfRunning) {
-            for (;;) {
-                int s = getState();
-                if (ranOrCancelled(s))
-                    return false;
-                if (compareAndSetState(s, CANCELLED))
-                    break;
+            int s = state;
+            if (s > COMPLETING) {
+                if (q != null)
+                    q.thread = null;
+                return s;
             }
-            if (mayInterruptIfRunning) {
-                Thread r = runner;
-                if (r != null)
-                    r.interrupt();
+            else if (q == null)
+                q = new WaitNode();
+            else if (!queued)
+                queued = UNSAFE.compareAndSwapObject(this, waitersOffset,
+                                                     q.next = waiters, q);
+            else if (timed) {
+                long now = System.nanoTime();
+                if ((nanos -= (now - last)) <= 0L) {
+                    removeWaiter(q);
+                    return state;
+                }
+                last = now;
+                LockSupport.parkNanos(this, nanos);
             }
-            releaseShared(0);
-            done();
-            return true;
+            else
+                LockSupport.park(this);
         }
+    }
 
-        void innerRun() {
-            if (!compareAndSetState(READY, RUNNING))
-                return;
-
-            runner = Thread.currentThread();
-            if (getState() == RUNNING) { // recheck after setting thread
-                V result;
-                try {
-                    result = callable.call();
-                } catch (Throwable ex) {
-                    setException(ex);
-                    return;
+    /**
+     * Tries to unlink a timed-out or interrupted wait node to avoid
+     * accumulating garbage.  Internal nodes are simply unspliced
+     * without CAS since it is harmless if they are traversed anyway
+     * by releasers.  To avoid effects of unsplicing from already
+     * removed nodes, the list is retraversed in case of an apparent
+     * race.  This is slow when there are a lot of nodes, but we don't
+     * expect lists to be long enough to outweigh higher-overhead
+     * schemes.
+     */
+    private void removeWaiter(WaitNode node) {
+        if (node != null) {
+            node.thread = null;
+            retry:
+            for (;;) {          // restart on removeWaiter race
+                for (WaitNode pred = null, q = waiters, s; q != null; q = s) {
+                    s = q.next;
+                    if (q.thread != null)
+                        pred = q;
+                    else if (pred != null) {
+                        pred.next = s;
+                        if (pred.thread == null) // check for race
+                            continue retry;
+                    }
+                    else if (!UNSAFE.compareAndSwapObject(this, waitersOffset,
+                                                          q, s))
+                        continue retry;
                 }
-                set(result);
-            } else {
-                releaseShared(0); // cancel
+                break;
             }
         }
+    }
 
-        boolean innerRunAndReset() {
-            if (!compareAndSetState(READY, RUNNING))
-                return false;
-            try {
-                runner = Thread.currentThread();
-                if (getState() == RUNNING)
-                    callable.call(); // don't set result
-                runner = null;
-                return compareAndSetState(RUNNING, READY);
-            } catch (Throwable ex) {
-                setException(ex);
-                return false;
-            }
+    // Unsafe mechanics
+    private static final sun.misc.Unsafe UNSAFE;
+    private static final long stateOffset;
+    private static final long runnerOffset;
+    private static final long waitersOffset;
+    static {
+        try {
+            UNSAFE = sun.misc.Unsafe.getUnsafe();
+            Class<?> k = FutureTask.class;
+            stateOffset = UNSAFE.objectFieldOffset
+                (k.getDeclaredField("state"));
+            runnerOffset = UNSAFE.objectFieldOffset
+                (k.getDeclaredField("runner"));
+            waitersOffset = UNSAFE.objectFieldOffset
+                (k.getDeclaredField("waiters"));
+        } catch (Exception e) {
+            throw new Error(e);
         }
     }
+
 }
diff --git a/luni/src/main/java/java/util/concurrent/LinkedBlockingDeque.java b/luni/src/main/java/java/util/concurrent/LinkedBlockingDeque.java
index 8c01e71..6f32c47 100644
--- a/luni/src/main/java/java/util/concurrent/LinkedBlockingDeque.java
+++ b/luni/src/main/java/java/util/concurrent/LinkedBlockingDeque.java
@@ -1,7 +1,7 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent;
@@ -13,6 +13,10 @@ import java.util.NoSuchElementException;
 import java.util.concurrent.locks.Condition;
 import java.util.concurrent.locks.ReentrantLock;
 
+// BEGIN android-note
+// removed link to collections framework docs
+// END android-note
+
 /**
  * An optionally-bounded {@linkplain BlockingDeque blocking deque} based on
  * linked nodes.
@@ -34,10 +38,6 @@ import java.util.concurrent.locks.ReentrantLock;
  * <em>optional</em> methods of the {@link Collection} and {@link
  * Iterator} interfaces.
  *
- * <p>This class is a member of the
- * <a href="{@docRoot}/../technotes/guides/collections/index.html">
- * Java Collections Framework</a>.
- *
  * @since 1.6
  * @author  Doug Lea
  * @param <E> the type of elements held in this collection
@@ -590,7 +590,7 @@ public class LinkedBlockingDeque<E>
     /**
      * Inserts the specified element at the end of this deque unless it would
      * violate capacity restrictions.  When using a capacity-restricted deque,
-     * it is generally preferable to use method {@link #offer offer}.
+     * it is generally preferable to use method {@link #offer(Object) offer}.
      *
      * <p>This method is equivalent to {@link #addLast}.
      *
@@ -713,6 +713,8 @@ public class LinkedBlockingDeque<E>
             throw new NullPointerException();
         if (c == this)
             throw new IllegalArgumentException();
+        if (maxElements <= 0)
+            return 0;
         final ReentrantLock lock = this.lock;
         lock.lock();
         try {
@@ -891,8 +893,7 @@ public class LinkedBlockingDeque<E>
      * The following code can be used to dump the deque into a newly
      * allocated array of {@code String}:
      *
-     * <pre>
-     *     String[] y = x.toArray(new String[0]);</pre>
+     *  <pre> {@code String[] y = x.toArray(new String[0]);}</pre>
      *
      * Note that {@code toArray(new Object[0])} is identical in function to
      * {@code toArray()}.
@@ -1014,7 +1015,7 @@ public class LinkedBlockingDeque<E>
         /**
          * The next node to return in next()
          */
-         Node<E> next;
+        Node<E> next;
 
         /**
          * nextItem holds on to item fields because once we claim that
@@ -1122,7 +1123,7 @@ public class LinkedBlockingDeque<E>
     }
 
     /**
-     * Save the state of this deque to a stream (that is, serialize it).
+     * Saves the state of this deque to a stream (that is, serializes it).
      *
      * @serialData The capacity (int), followed by elements (each an
      * {@code Object}) in the proper order, followed by a null
@@ -1146,8 +1147,8 @@ public class LinkedBlockingDeque<E>
     }
 
     /**
-     * Reconstitute this deque from a stream (that is,
-     * deserialize it).
+     * Reconstitutes this deque from a stream (that is, deserializes it).
+     *
      * @param s the stream
      */
     private void readObject(java.io.ObjectInputStream s)
diff --git a/luni/src/main/java/java/util/concurrent/LinkedBlockingQueue.java b/luni/src/main/java/java/util/concurrent/LinkedBlockingQueue.java
index d06c737..e8c9edb 100644
--- a/luni/src/main/java/java/util/concurrent/LinkedBlockingQueue.java
+++ b/luni/src/main/java/java/util/concurrent/LinkedBlockingQueue.java
@@ -1,7 +1,7 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent;
@@ -106,13 +106,13 @@ public class LinkedBlockingQueue<E> extends AbstractQueue<E>
     private final int capacity;
 
     /** Current number of elements */
-    private final AtomicInteger count = new AtomicInteger(0);
+    private final AtomicInteger count = new AtomicInteger();
 
     /**
      * Head of linked list.
      * Invariant: head.item == null
      */
-    private transient Node<E> head;
+    transient Node<E> head;
 
     /**
      * Tail of linked list.
@@ -303,7 +303,7 @@ public class LinkedBlockingQueue<E> extends AbstractQueue<E>
         // Note: convention in all put/take/etc is to preset local var
         // holding count negative to indicate failure unless set.
         int c = -1;
-        Node<E> node = new Node(e);
+        Node<E> node = new Node<E>(e);
         final ReentrantLock putLock = this.putLock;
         final AtomicInteger count = this.count;
         putLock.lockInterruptibly();
@@ -383,7 +383,7 @@ public class LinkedBlockingQueue<E> extends AbstractQueue<E>
         if (count.get() == capacity)
             return false;
         int c = -1;
-        Node<E> node = new Node(e);
+        Node<E> node = new Node<E>(e);
         final ReentrantLock putLock = this.putLock;
         putLock.lock();
         try {
@@ -601,8 +601,7 @@ public class LinkedBlockingQueue<E> extends AbstractQueue<E>
      * The following code can be used to dump the queue into a newly
      * allocated array of {@code String}:
      *
-     * <pre>
-     *     String[] y = x.toArray(new String[0]);</pre>
+     *  <pre> {@code String[] y = x.toArray(new String[0]);}</pre>
      *
      * Note that {@code toArray(new Object[0])} is identical in function to
      * {@code toArray()}.
@@ -699,6 +698,8 @@ public class LinkedBlockingQueue<E> extends AbstractQueue<E>
             throw new NullPointerException();
         if (c == this)
             throw new IllegalArgumentException();
+        if (maxElements <= 0)
+            return 0;
         boolean signalNotFull = false;
         final ReentrantLock takeLock = this.takeLock;
         takeLock.lock();
@@ -746,7 +747,7 @@ public class LinkedBlockingQueue<E> extends AbstractQueue<E>
      * @return an iterator over the elements in this queue in proper sequence
      */
     public Iterator<E> iterator() {
-      return new Itr();
+        return new Itr();
     }
 
     private class Itr implements Iterator<E> {
@@ -829,7 +830,7 @@ public class LinkedBlockingQueue<E> extends AbstractQueue<E>
     }
 
     /**
-     * Save the state to a stream (that is, serialize it).
+     * Saves the state to a stream (that is, serializes it).
      *
      * @serialData The capacity is emitted (int), followed by all of
      * its elements (each an {@code Object}) in the proper order,
@@ -856,8 +857,7 @@ public class LinkedBlockingQueue<E> extends AbstractQueue<E>
     }
 
     /**
-     * Reconstitute this queue instance from a stream (that is,
-     * deserialize it).
+     * Reconstitutes this queue from a stream (that is, deserializes it).
      *
      * @param s the stream
      */
diff --git a/luni/src/main/java/java/util/concurrent/LinkedTransferQueue.java b/luni/src/main/java/java/util/concurrent/LinkedTransferQueue.java
new file mode 100644
index 0000000..2a3446e
--- /dev/null
+++ b/luni/src/main/java/java/util/concurrent/LinkedTransferQueue.java
@@ -0,0 +1,1323 @@
+/*
+ * Written by Doug Lea with assistance from members of JCP JSR-166
+ * Expert Group and released to the public domain, as explained at
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+package java.util.concurrent;
+
+import java.util.AbstractQueue;
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+import java.util.Queue;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.locks.LockSupport;
+
+// BEGIN android-note
+// removed link to collections framework docs
+// END android-note
+
+/**
+ * An unbounded {@link TransferQueue} based on linked nodes.
+ * This queue orders elements FIFO (first-in-first-out) with respect
+ * to any given producer.  The <em>head</em> of the queue is that
+ * element that has been on the queue the longest time for some
+ * producer.  The <em>tail</em> of the queue is that element that has
+ * been on the queue the shortest time for some producer.
+ *
+ * <p>Beware that, unlike in most collections, the {@code size} method
+ * is <em>NOT</em> a constant-time operation. Because of the
+ * asynchronous nature of these queues, determining the current number
+ * of elements requires a traversal of the elements, and so may report
+ * inaccurate results if this collection is modified during traversal.
+ * Additionally, the bulk operations {@code addAll},
+ * {@code removeAll}, {@code retainAll}, {@code containsAll},
+ * {@code equals}, and {@code toArray} are <em>not</em> guaranteed
+ * to be performed atomically. For example, an iterator operating
+ * concurrently with an {@code addAll} operation might view only some
+ * of the added elements.
+ *
+ * <p>This class and its iterator implement all of the
+ * <em>optional</em> methods of the {@link Collection} and {@link
+ * Iterator} interfaces.
+ *
+ * <p>Memory consistency effects: As with other concurrent
+ * collections, actions in a thread prior to placing an object into a
+ * {@code LinkedTransferQueue}
+ * <a href="package-summary.html#MemoryVisibility"><i>happen-before</i></a>
+ * actions subsequent to the access or removal of that element from
+ * the {@code LinkedTransferQueue} in another thread.
+ *
+ * @since 1.7
+ * @hide
+ * @author Doug Lea
+ * @param <E> the type of elements held in this collection
+ */
+public class LinkedTransferQueue<E> extends AbstractQueue<E>
+    implements TransferQueue<E>, java.io.Serializable {
+    private static final long serialVersionUID = -3223113410248163686L;
+
+    /*
+     * *** Overview of Dual Queues with Slack ***
+     *
+     * Dual Queues, introduced by Scherer and Scott
+     * (http://www.cs.rice.edu/~wns1/papers/2004-DISC-DDS.pdf) are
+     * (linked) queues in which nodes may represent either data or
+     * requests.  When a thread tries to enqueue a data node, but
+     * encounters a request node, it instead "matches" and removes it;
+     * and vice versa for enqueuing requests. Blocking Dual Queues
+     * arrange that threads enqueuing unmatched requests block until
+     * other threads provide the match. Dual Synchronous Queues (see
+     * Scherer, Lea, & Scott
+     * http://www.cs.rochester.edu/u/scott/papers/2009_Scherer_CACM_SSQ.pdf)
+     * additionally arrange that threads enqueuing unmatched data also
+     * block.  Dual Transfer Queues support all of these modes, as
+     * dictated by callers.
+     *
+     * A FIFO dual queue may be implemented using a variation of the
+     * Michael & Scott (M&S) lock-free queue algorithm
+     * (http://www.cs.rochester.edu/u/scott/papers/1996_PODC_queues.pdf).
+     * It maintains two pointer fields, "head", pointing to a
+     * (matched) node that in turn points to the first actual
+     * (unmatched) queue node (or null if empty); and "tail" that
+     * points to the last node on the queue (or again null if
+     * empty). For example, here is a possible queue with four data
+     * elements:
+     *
+     *  head                tail
+     *    |                   |
+     *    v                   v
+     *    M -> U -> U -> U -> U
+     *
+     * The M&S queue algorithm is known to be prone to scalability and
+     * overhead limitations when maintaining (via CAS) these head and
+     * tail pointers. This has led to the development of
+     * contention-reducing variants such as elimination arrays (see
+     * Moir et al http://portal.acm.org/citation.cfm?id=1074013) and
+     * optimistic back pointers (see Ladan-Mozes & Shavit
+     * http://people.csail.mit.edu/edya/publications/OptimisticFIFOQueue-journal.pdf).
+     * However, the nature of dual queues enables a simpler tactic for
+     * improving M&S-style implementations when dual-ness is needed.
+     *
+     * In a dual queue, each node must atomically maintain its match
+     * status. While there are other possible variants, we implement
+     * this here as: for a data-mode node, matching entails CASing an
+     * "item" field from a non-null data value to null upon match, and
+     * vice-versa for request nodes, CASing from null to a data
+     * value. (Note that the linearization properties of this style of
+     * queue are easy to verify -- elements are made available by
+     * linking, and unavailable by matching.) Compared to plain M&S
+     * queues, this property of dual queues requires one additional
+     * successful atomic operation per enq/deq pair. But it also
+     * enables lower cost variants of queue maintenance mechanics. (A
+     * variation of this idea applies even for non-dual queues that
+     * support deletion of interior elements, such as
+     * j.u.c.ConcurrentLinkedQueue.)
+     *
+     * Once a node is matched, its match status can never again
+     * change.  We may thus arrange that the linked list of them
+     * contain a prefix of zero or more matched nodes, followed by a
+     * suffix of zero or more unmatched nodes. (Note that we allow
+     * both the prefix and suffix to be zero length, which in turn
+     * means that we do not use a dummy header.)  If we were not
+     * concerned with either time or space efficiency, we could
+     * correctly perform enqueue and dequeue operations by traversing
+     * from a pointer to the initial node; CASing the item of the
+     * first unmatched node on match and CASing the next field of the
+     * trailing node on appends. (Plus some special-casing when
+     * initially empty).  While this would be a terrible idea in
+     * itself, it does have the benefit of not requiring ANY atomic
+     * updates on head/tail fields.
+     *
+     * We introduce here an approach that lies between the extremes of
+     * never versus always updating queue (head and tail) pointers.
+     * This offers a tradeoff between sometimes requiring extra
+     * traversal steps to locate the first and/or last unmatched
+     * nodes, versus the reduced overhead and contention of fewer
+     * updates to queue pointers. For example, a possible snapshot of
+     * a queue is:
+     *
+     *  head           tail
+     *    |              |
+     *    v              v
+     *    M -> M -> U -> U -> U -> U
+     *
+     * The best value for this "slack" (the targeted maximum distance
+     * between the value of "head" and the first unmatched node, and
+     * similarly for "tail") is an empirical matter. We have found
+     * that using very small constants in the range of 1-3 work best
+     * over a range of platforms. Larger values introduce increasing
+     * costs of cache misses and risks of long traversal chains, while
+     * smaller values increase CAS contention and overhead.
+     *
+     * Dual queues with slack differ from plain M&S dual queues by
+     * virtue of only sometimes updating head or tail pointers when
+     * matching, appending, or even traversing nodes; in order to
+     * maintain a targeted slack.  The idea of "sometimes" may be
+     * operationalized in several ways. The simplest is to use a
+     * per-operation counter incremented on each traversal step, and
+     * to try (via CAS) to update the associated queue pointer
+     * whenever the count exceeds a threshold. Another, that requires
+     * more overhead, is to use random number generators to update
+     * with a given probability per traversal step.
+     *
+     * In any strategy along these lines, because CASes updating
+     * fields may fail, the actual slack may exceed targeted
+     * slack. However, they may be retried at any time to maintain
+     * targets.  Even when using very small slack values, this
+     * approach works well for dual queues because it allows all
+     * operations up to the point of matching or appending an item
+     * (hence potentially allowing progress by another thread) to be
+     * read-only, thus not introducing any further contention. As
+     * described below, we implement this by performing slack
+     * maintenance retries only after these points.
+     *
+     * As an accompaniment to such techniques, traversal overhead can
+     * be further reduced without increasing contention of head
+     * pointer updates: Threads may sometimes shortcut the "next" link
+     * path from the current "head" node to be closer to the currently
+     * known first unmatched node, and similarly for tail. Again, this
+     * may be triggered with using thresholds or randomization.
+     *
+     * These ideas must be further extended to avoid unbounded amounts
+     * of costly-to-reclaim garbage caused by the sequential "next"
+     * links of nodes starting at old forgotten head nodes: As first
+     * described in detail by Boehm
+     * (http://portal.acm.org/citation.cfm?doid=503272.503282) if a GC
+     * delays noticing that any arbitrarily old node has become
+     * garbage, all newer dead nodes will also be unreclaimed.
+     * (Similar issues arise in non-GC environments.)  To cope with
+     * this in our implementation, upon CASing to advance the head
+     * pointer, we set the "next" link of the previous head to point
+     * only to itself; thus limiting the length of connected dead lists.
+     * (We also take similar care to wipe out possibly garbage
+     * retaining values held in other Node fields.)  However, doing so
+     * adds some further complexity to traversal: If any "next"
+     * pointer links to itself, it indicates that the current thread
+     * has lagged behind a head-update, and so the traversal must
+     * continue from the "head".  Traversals trying to find the
+     * current tail starting from "tail" may also encounter
+     * self-links, in which case they also continue at "head".
+     *
+     * It is tempting in slack-based scheme to not even use CAS for
+     * updates (similarly to Ladan-Mozes & Shavit). However, this
+     * cannot be done for head updates under the above link-forgetting
+     * mechanics because an update may leave head at a detached node.
+     * And while direct writes are possible for tail updates, they
+     * increase the risk of long retraversals, and hence long garbage
+     * chains, which can be much more costly than is worthwhile
+     * considering that the cost difference of performing a CAS vs
+     * write is smaller when they are not triggered on each operation
+     * (especially considering that writes and CASes equally require
+     * additional GC bookkeeping ("write barriers") that are sometimes
+     * more costly than the writes themselves because of contention).
+     *
+     * *** Overview of implementation ***
+     *
+     * We use a threshold-based approach to updates, with a slack
+     * threshold of two -- that is, we update head/tail when the
+     * current pointer appears to be two or more steps away from the
+     * first/last node. The slack value is hard-wired: a path greater
+     * than one is naturally implemented by checking equality of
+     * traversal pointers except when the list has only one element,
+     * in which case we keep slack threshold at one. Avoiding tracking
+     * explicit counts across method calls slightly simplifies an
+     * already-messy implementation. Using randomization would
+     * probably work better if there were a low-quality dirt-cheap
+     * per-thread one available, but even ThreadLocalRandom is too
+     * heavy for these purposes.
+     *
+     * With such a small slack threshold value, it is not worthwhile
+     * to augment this with path short-circuiting (i.e., unsplicing
+     * interior nodes) except in the case of cancellation/removal (see
+     * below).
+     *
+     * We allow both the head and tail fields to be null before any
+     * nodes are enqueued; initializing upon first append.  This
+     * simplifies some other logic, as well as providing more
+     * efficient explicit control paths instead of letting JVMs insert
+     * implicit NullPointerExceptions when they are null.  While not
+     * currently fully implemented, we also leave open the possibility
+     * of re-nulling these fields when empty (which is complicated to
+     * arrange, for little benefit.)
+     *
+     * All enqueue/dequeue operations are handled by the single method
+     * "xfer" with parameters indicating whether to act as some form
+     * of offer, put, poll, take, or transfer (each possibly with
+     * timeout). The relative complexity of using one monolithic
+     * method outweighs the code bulk and maintenance problems of
+     * using separate methods for each case.
+     *
+     * Operation consists of up to three phases. The first is
+     * implemented within method xfer, the second in tryAppend, and
+     * the third in method awaitMatch.
+     *
+     * 1. Try to match an existing node
+     *
+     *    Starting at head, skip already-matched nodes until finding
+     *    an unmatched node of opposite mode, if one exists, in which
+     *    case matching it and returning, also if necessary updating
+     *    head to one past the matched node (or the node itself if the
+     *    list has no other unmatched nodes). If the CAS misses, then
+     *    a loop retries advancing head by two steps until either
+     *    success or the slack is at most two. By requiring that each
+     *    attempt advances head by two (if applicable), we ensure that
+     *    the slack does not grow without bound. Traversals also check
+     *    if the initial head is now off-list, in which case they
+     *    start at the new head.
+     *
+     *    If no candidates are found and the call was untimed
+     *    poll/offer, (argument "how" is NOW) return.
+     *
+     * 2. Try to append a new node (method tryAppend)
+     *
+     *    Starting at current tail pointer, find the actual last node
+     *    and try to append a new node (or if head was null, establish
+     *    the first node). Nodes can be appended only if their
+     *    predecessors are either already matched or are of the same
+     *    mode. If we detect otherwise, then a new node with opposite
+     *    mode must have been appended during traversal, so we must
+     *    restart at phase 1. The traversal and update steps are
+     *    otherwise similar to phase 1: Retrying upon CAS misses and
+     *    checking for staleness.  In particular, if a self-link is
+     *    encountered, then we can safely jump to a node on the list
+     *    by continuing the traversal at current head.
+     *
+     *    On successful append, if the call was ASYNC, return.
+     *
+     * 3. Await match or cancellation (method awaitMatch)
+     *
+     *    Wait for another thread to match node; instead cancelling if
+     *    the current thread was interrupted or the wait timed out. On
+     *    multiprocessors, we use front-of-queue spinning: If a node
+     *    appears to be the first unmatched node in the queue, it
+     *    spins a bit before blocking. In either case, before blocking
+     *    it tries to unsplice any nodes between the current "head"
+     *    and the first unmatched node.
+     *
+     *    Front-of-queue spinning vastly improves performance of
+     *    heavily contended queues. And so long as it is relatively
+     *    brief and "quiet", spinning does not much impact performance
+     *    of less-contended queues.  During spins threads check their
+     *    interrupt status and generate a thread-local random number
+     *    to decide to occasionally perform a Thread.yield. While
+     *    yield has underdefined specs, we assume that it might help,
+     *    and will not hurt, in limiting impact of spinning on busy
+     *    systems.  We also use smaller (1/2) spins for nodes that are
+     *    not known to be front but whose predecessors have not
+     *    blocked -- these "chained" spins avoid artifacts of
+     *    front-of-queue rules which otherwise lead to alternating
+     *    nodes spinning vs blocking. Further, front threads that
+     *    represent phase changes (from data to request node or vice
+     *    versa) compared to their predecessors receive additional
+     *    chained spins, reflecting longer paths typically required to
+     *    unblock threads during phase changes.
+     *
+     *
+     * ** Unlinking removed interior nodes **
+     *
+     * In addition to minimizing garbage retention via self-linking
+     * described above, we also unlink removed interior nodes. These
+     * may arise due to timed out or interrupted waits, or calls to
+     * remove(x) or Iterator.remove.  Normally, given a node that was
+     * at one time known to be the predecessor of some node s that is
+     * to be removed, we can unsplice s by CASing the next field of
+     * its predecessor if it still points to s (otherwise s must
+     * already have been removed or is now offlist). But there are two
+     * situations in which we cannot guarantee to make node s
+     * unreachable in this way: (1) If s is the trailing node of list
+     * (i.e., with null next), then it is pinned as the target node
+     * for appends, so can only be removed later after other nodes are
+     * appended. (2) We cannot necessarily unlink s given a
+     * predecessor node that is matched (including the case of being
+     * cancelled): the predecessor may already be unspliced, in which
+     * case some previous reachable node may still point to s.
+     * (For further explanation see Herlihy & Shavit "The Art of
+     * Multiprocessor Programming" chapter 9).  Although, in both
+     * cases, we can rule out the need for further action if either s
+     * or its predecessor are (or can be made to be) at, or fall off
+     * from, the head of list.
+     *
+     * Without taking these into account, it would be possible for an
+     * unbounded number of supposedly removed nodes to remain
+     * reachable.  Situations leading to such buildup are uncommon but
+     * can occur in practice; for example when a series of short timed
+     * calls to poll repeatedly time out but never otherwise fall off
+     * the list because of an untimed call to take at the front of the
+     * queue.
+     *
+     * When these cases arise, rather than always retraversing the
+     * entire list to find an actual predecessor to unlink (which
+     * won't help for case (1) anyway), we record a conservative
+     * estimate of possible unsplice failures (in "sweepVotes").
+     * We trigger a full sweep when the estimate exceeds a threshold
+     * ("SWEEP_THRESHOLD") indicating the maximum number of estimated
+     * removal failures to tolerate before sweeping through, unlinking
+     * cancelled nodes that were not unlinked upon initial removal.
+     * We perform sweeps by the thread hitting threshold (rather than
+     * background threads or by spreading work to other threads)
+     * because in the main contexts in which removal occurs, the
+     * caller is already timed-out, cancelled, or performing a
+     * potentially O(n) operation (e.g. remove(x)), none of which are
+     * time-critical enough to warrant the overhead that alternatives
+     * would impose on other threads.
+     *
+     * Because the sweepVotes estimate is conservative, and because
+     * nodes become unlinked "naturally" as they fall off the head of
+     * the queue, and because we allow votes to accumulate even while
+     * sweeps are in progress, there are typically significantly fewer
+     * such nodes than estimated.  Choice of a threshold value
+     * balances the likelihood of wasted effort and contention, versus
+     * providing a worst-case bound on retention of interior nodes in
+     * quiescent queues. The value defined below was chosen
+     * empirically to balance these under various timeout scenarios.
+     *
+     * Note that we cannot self-link unlinked interior nodes during
+     * sweeps. However, the associated garbage chains terminate when
+     * some successor ultimately falls off the head of the list and is
+     * self-linked.
+     */
+
+    /** True if on multiprocessor */
+    private static final boolean MP =
+        Runtime.getRuntime().availableProcessors() > 1;
+
+    /**
+     * The number of times to spin (with randomly interspersed calls
+     * to Thread.yield) on multiprocessor before blocking when a node
+     * is apparently the first waiter in the queue.  See above for
+     * explanation. Must be a power of two. The value is empirically
+     * derived -- it works pretty well across a variety of processors,
+     * numbers of CPUs, and OSes.
+     */
+    private static final int FRONT_SPINS   = 1 << 7;
+
+    /**
+     * The number of times to spin before blocking when a node is
+     * preceded by another node that is apparently spinning.  Also
+     * serves as an increment to FRONT_SPINS on phase changes, and as
+     * base average frequency for yielding during spins. Must be a
+     * power of two.
+     */
+    private static final int CHAINED_SPINS = FRONT_SPINS >>> 1;
+
+    /**
+     * The maximum number of estimated removal failures (sweepVotes)
+     * to tolerate before sweeping through the queue unlinking
+     * cancelled nodes that were not unlinked upon initial
+     * removal. See above for explanation. The value must be at least
+     * two to avoid useless sweeps when removing trailing nodes.
+     */
+    static final int SWEEP_THRESHOLD = 32;
+
+    /**
+     * Queue nodes. Uses Object, not E, for items to allow forgetting
+     * them after use.  Relies heavily on Unsafe mechanics to minimize
+     * unnecessary ordering constraints: Writes that are intrinsically
+     * ordered wrt other accesses or CASes use simple relaxed forms.
+     */
+    static final class Node {
+        final boolean isData;   // false if this is a request node
+        volatile Object item;   // initially non-null if isData; CASed to match
+        volatile Node next;
+        volatile Thread waiter; // null until waiting
+
+        // CAS methods for fields
+        final boolean casNext(Node cmp, Node val) {
+            return UNSAFE.compareAndSwapObject(this, nextOffset, cmp, val);
+        }
+
+        final boolean casItem(Object cmp, Object val) {
+            // assert cmp == null || cmp.getClass() != Node.class;
+            return UNSAFE.compareAndSwapObject(this, itemOffset, cmp, val);
+        }
+
+        /**
+         * Constructs a new node.  Uses relaxed write because item can
+         * only be seen after publication via casNext.
+         */
+        Node(Object item, boolean isData) {
+            UNSAFE.putObject(this, itemOffset, item); // relaxed write
+            this.isData = isData;
+        }
+
+        /**
+         * Links node to itself to avoid garbage retention.  Called
+         * only after CASing head field, so uses relaxed write.
+         */
+        final void forgetNext() {
+            UNSAFE.putObject(this, nextOffset, this);
+        }
+
+        /**
+         * Sets item to self and waiter to null, to avoid garbage
+         * retention after matching or cancelling. Uses relaxed writes
+         * because order is already constrained in the only calling
+         * contexts: item is forgotten only after volatile/atomic
+         * mechanics that extract items.  Similarly, clearing waiter
+         * follows either CAS or return from park (if ever parked;
+         * else we don't care).
+         */
+        final void forgetContents() {
+            UNSAFE.putObject(this, itemOffset, this);
+            UNSAFE.putObject(this, waiterOffset, null);
+        }
+
+        /**
+         * Returns true if this node has been matched, including the
+         * case of artificial matches due to cancellation.
+         */
+        final boolean isMatched() {
+            Object x = item;
+            return (x == this) || ((x == null) == isData);
+        }
+
+        /**
+         * Returns true if this is an unmatched request node.
+         */
+        final boolean isUnmatchedRequest() {
+            return !isData && item == null;
+        }
+
+        /**
+         * Returns true if a node with the given mode cannot be
+         * appended to this node because this node is unmatched and
+         * has opposite data mode.
+         */
+        final boolean cannotPrecede(boolean haveData) {
+            boolean d = isData;
+            Object x;
+            return d != haveData && (x = item) != this && (x != null) == d;
+        }
+
+        /**
+         * Tries to artificially match a data node -- used by remove.
+         */
+        final boolean tryMatchData() {
+            // assert isData;
+            Object x = item;
+            if (x != null && x != this && casItem(x, null)) {
+                LockSupport.unpark(waiter);
+                return true;
+            }
+            return false;
+        }
+
+        private static final long serialVersionUID = -3375979862319811754L;
+
+        // Unsafe mechanics
+        private static final sun.misc.Unsafe UNSAFE;
+        private static final long itemOffset;
+        private static final long nextOffset;
+        private static final long waiterOffset;
+        static {
+            try {
+                UNSAFE = sun.misc.Unsafe.getUnsafe();
+                Class<?> k = Node.class;
+                itemOffset = UNSAFE.objectFieldOffset
+                    (k.getDeclaredField("item"));
+                nextOffset = UNSAFE.objectFieldOffset
+                    (k.getDeclaredField("next"));
+                waiterOffset = UNSAFE.objectFieldOffset
+                    (k.getDeclaredField("waiter"));
+            } catch (Exception e) {
+                throw new Error(e);
+            }
+        }
+    }
+
+    /** head of the queue; null until first enqueue */
+    transient volatile Node head;
+
+    /** tail of the queue; null until first append */
+    private transient volatile Node tail;
+
+    /** The number of apparent failures to unsplice removed nodes */
+    private transient volatile int sweepVotes;
+
+    // CAS methods for fields
+    private boolean casTail(Node cmp, Node val) {
+        return UNSAFE.compareAndSwapObject(this, tailOffset, cmp, val);
+    }
+
+    private boolean casHead(Node cmp, Node val) {
+        return UNSAFE.compareAndSwapObject(this, headOffset, cmp, val);
+    }
+
+    private boolean casSweepVotes(int cmp, int val) {
+        return UNSAFE.compareAndSwapInt(this, sweepVotesOffset, cmp, val);
+    }
+
+    /*
+     * Possible values for "how" argument in xfer method.
+     */
+    private static final int NOW   = 0; // for untimed poll, tryTransfer
+    private static final int ASYNC = 1; // for offer, put, add
+    private static final int SYNC  = 2; // for transfer, take
+    private static final int TIMED = 3; // for timed poll, tryTransfer
+
+    @SuppressWarnings("unchecked")
+    static <E> E cast(Object item) {
+        // assert item == null || item.getClass() != Node.class;
+        return (E) item;
+    }
+
+    /**
+     * Implements all queuing methods. See above for explanation.
+     *
+     * @param e the item or null for take
+     * @param haveData true if this is a put, else a take
+     * @param how NOW, ASYNC, SYNC, or TIMED
+     * @param nanos timeout in nanosecs, used only if mode is TIMED
+     * @return an item if matched, else e
+     * @throws NullPointerException if haveData mode but e is null
+     */
+    private E xfer(E e, boolean haveData, int how, long nanos) {
+        if (haveData && (e == null))
+            throw new NullPointerException();
+        Node s = null;                        // the node to append, if needed
+
+        retry:
+        for (;;) {                            // restart on append race
+
+            for (Node h = head, p = h; p != null;) { // find & match first node
+                boolean isData = p.isData;
+                Object item = p.item;
+                if (item != p && (item != null) == isData) { // unmatched
+                    if (isData == haveData)   // can't match
+                        break;
+                    if (p.casItem(item, e)) { // match
+                        for (Node q = p; q != h;) {
+                            Node n = q.next;  // update by 2 unless singleton
+                            if (head == h && casHead(h, n == null ? q : n)) {
+                                h.forgetNext();
+                                break;
+                            }                 // advance and retry
+                            if ((h = head)   == null ||
+                                (q = h.next) == null || !q.isMatched())
+                                break;        // unless slack < 2
+                        }
+                        LockSupport.unpark(p.waiter);
+                        return LinkedTransferQueue.<E>cast(item);
+                    }
+                }
+                Node n = p.next;
+                p = (p != n) ? n : (h = head); // Use head if p offlist
+            }
+
+            if (how != NOW) {                 // No matches available
+                if (s == null)
+                    s = new Node(e, haveData);
+                Node pred = tryAppend(s, haveData);
+                if (pred == null)
+                    continue retry;           // lost race vs opposite mode
+                if (how != ASYNC)
+                    return awaitMatch(s, pred, e, (how == TIMED), nanos);
+            }
+            return e; // not waiting
+        }
+    }
+
+    /**
+     * Tries to append node s as tail.
+     *
+     * @param s the node to append
+     * @param haveData true if appending in data mode
+     * @return null on failure due to losing race with append in
+     * different mode, else s's predecessor, or s itself if no
+     * predecessor
+     */
+    private Node tryAppend(Node s, boolean haveData) {
+        for (Node t = tail, p = t;;) {        // move p to last node and append
+            Node n, u;                        // temps for reads of next & tail
+            if (p == null && (p = head) == null) {
+                if (casHead(null, s))
+                    return s;                 // initialize
+            }
+            else if (p.cannotPrecede(haveData))
+                return null;                  // lost race vs opposite mode
+            else if ((n = p.next) != null)    // not last; keep traversing
+                p = p != t && t != (u = tail) ? (t = u) : // stale tail
+                    (p != n) ? n : null;      // restart if off list
+            else if (!p.casNext(null, s))
+                p = p.next;                   // re-read on CAS failure
+            else {
+                if (p != t) {                 // update if slack now >= 2
+                    while ((tail != t || !casTail(t, s)) &&
+                           (t = tail)   != null &&
+                           (s = t.next) != null && // advance and retry
+                           (s = s.next) != null && s != t);
+                }
+                return p;
+            }
+        }
+    }
+
+    /**
+     * Spins/yields/blocks until node s is matched or caller gives up.
+     *
+     * @param s the waiting node
+     * @param pred the predecessor of s, or s itself if it has no
+     * predecessor, or null if unknown (the null case does not occur
+     * in any current calls but may in possible future extensions)
+     * @param e the comparison value for checking match
+     * @param timed if true, wait only until timeout elapses
+     * @param nanos timeout in nanosecs, used only if timed is true
+     * @return matched item, or e if unmatched on interrupt or timeout
+     */
+    private E awaitMatch(Node s, Node pred, E e, boolean timed, long nanos) {
+        long lastTime = timed ? System.nanoTime() : 0L;
+        Thread w = Thread.currentThread();
+        int spins = -1; // initialized after first item and cancel checks
+        ThreadLocalRandom randomYields = null; // bound if needed
+
+        for (;;) {
+            Object item = s.item;
+            if (item != e) {                  // matched
+                // assert item != s;
+                s.forgetContents();           // avoid garbage
+                return LinkedTransferQueue.<E>cast(item);
+            }
+            if ((w.isInterrupted() || (timed && nanos <= 0)) &&
+                    s.casItem(e, s)) {        // cancel
+                unsplice(pred, s);
+                return e;
+            }
+
+            if (spins < 0) {                  // establish spins at/near front
+                if ((spins = spinsFor(pred, s.isData)) > 0)
+                    randomYields = ThreadLocalRandom.current();
+            }
+            else if (spins > 0) {             // spin
+                --spins;
+                if (randomYields.nextInt(CHAINED_SPINS) == 0)
+                    Thread.yield();           // occasionally yield
+            }
+            else if (s.waiter == null) {
+                s.waiter = w;                 // request unpark then recheck
+            }
+            else if (timed) {
+                long now = System.nanoTime();
+                if ((nanos -= now - lastTime) > 0)
+                    LockSupport.parkNanos(this, nanos);
+                lastTime = now;
+            }
+            else {
+                LockSupport.park(this);
+            }
+        }
+    }
+
+    /**
+     * Returns spin/yield value for a node with given predecessor and
+     * data mode. See above for explanation.
+     */
+    private static int spinsFor(Node pred, boolean haveData) {
+        if (MP && pred != null) {
+            if (pred.isData != haveData)      // phase change
+                return FRONT_SPINS + CHAINED_SPINS;
+            if (pred.isMatched())             // probably at front
+                return FRONT_SPINS;
+            if (pred.waiter == null)          // pred apparently spinning
+                return CHAINED_SPINS;
+        }
+        return 0;
+    }
+
+    /* -------------- Traversal methods -------------- */
+
+    /**
+     * Returns the successor of p, or the head node if p.next has been
+     * linked to self, which will only be true if traversing with a
+     * stale pointer that is now off the list.
+     */
+    final Node succ(Node p) {
+        Node next = p.next;
+        return (p == next) ? head : next;
+    }
+
+    /**
+     * Returns the first unmatched node of the given mode, or null if
+     * none.  Used by methods isEmpty, hasWaitingConsumer.
+     */
+    private Node firstOfMode(boolean isData) {
+        for (Node p = head; p != null; p = succ(p)) {
+            if (!p.isMatched())
+                return (p.isData == isData) ? p : null;
+        }
+        return null;
+    }
+
+    /**
+     * Returns the item in the first unmatched node with isData; or
+     * null if none.  Used by peek.
+     */
+    private E firstDataItem() {
+        for (Node p = head; p != null; p = succ(p)) {
+            Object item = p.item;
+            if (p.isData) {
+                if (item != null && item != p)
+                    return LinkedTransferQueue.<E>cast(item);
+            }
+            else if (item == null)
+                return null;
+        }
+        return null;
+    }
+
+    /**
+     * Traverses and counts unmatched nodes of the given mode.
+     * Used by methods size and getWaitingConsumerCount.
+     */
+    private int countOfMode(boolean data) {
+        int count = 0;
+        for (Node p = head; p != null; ) {
+            if (!p.isMatched()) {
+                if (p.isData != data)
+                    return 0;
+                if (++count == Integer.MAX_VALUE) // saturated
+                    break;
+            }
+            Node n = p.next;
+            if (n != p)
+                p = n;
+            else {
+                count = 0;
+                p = head;
+            }
+        }
+        return count;
+    }
+
+    final class Itr implements Iterator<E> {
+        private Node nextNode;   // next node to return item for
+        private E nextItem;      // the corresponding item
+        private Node lastRet;    // last returned node, to support remove
+        private Node lastPred;   // predecessor to unlink lastRet
+
+        /**
+         * Moves to next node after prev, or first node if prev null.
+         */
+        private void advance(Node prev) {
+            /*
+             * To track and avoid buildup of deleted nodes in the face
+             * of calls to both Queue.remove and Itr.remove, we must
+             * include variants of unsplice and sweep upon each
+             * advance: Upon Itr.remove, we may need to catch up links
+             * from lastPred, and upon other removes, we might need to
+             * skip ahead from stale nodes and unsplice deleted ones
+             * found while advancing.
+             */
+
+            Node r, b; // reset lastPred upon possible deletion of lastRet
+            if ((r = lastRet) != null && !r.isMatched())
+                lastPred = r;    // next lastPred is old lastRet
+            else if ((b = lastPred) == null || b.isMatched())
+                lastPred = null; // at start of list
+            else {
+                Node s, n;       // help with removal of lastPred.next
+                while ((s = b.next) != null &&
+                       s != b && s.isMatched() &&
+                       (n = s.next) != null && n != s)
+                    b.casNext(s, n);
+            }
+
+            this.lastRet = prev;
+
+            for (Node p = prev, s, n;;) {
+                s = (p == null) ? head : p.next;
+                if (s == null)
+                    break;
+                else if (s == p) {
+                    p = null;
+                    continue;
+                }
+                Object item = s.item;
+                if (s.isData) {
+                    if (item != null && item != s) {
+                        nextItem = LinkedTransferQueue.<E>cast(item);
+                        nextNode = s;
+                        return;
+                    }
+                }
+                else if (item == null)
+                    break;
+                // assert s.isMatched();
+                if (p == null)
+                    p = s;
+                else if ((n = s.next) == null)
+                    break;
+                else if (s == n)
+                    p = null;
+                else
+                    p.casNext(s, n);
+            }
+            nextNode = null;
+            nextItem = null;
+        }
+
+        Itr() {
+            advance(null);
+        }
+
+        public final boolean hasNext() {
+            return nextNode != null;
+        }
+
+        public final E next() {
+            Node p = nextNode;
+            if (p == null) throw new NoSuchElementException();
+            E e = nextItem;
+            advance(p);
+            return e;
+        }
+
+        public final void remove() {
+            final Node lastRet = this.lastRet;
+            if (lastRet == null)
+                throw new IllegalStateException();
+            this.lastRet = null;
+            if (lastRet.tryMatchData())
+                unsplice(lastPred, lastRet);
+        }
+    }
+
+    /* -------------- Removal methods -------------- */
+
+    /**
+     * Unsplices (now or later) the given deleted/cancelled node with
+     * the given predecessor.
+     *
+     * @param pred a node that was at one time known to be the
+     * predecessor of s, or null or s itself if s is/was at head
+     * @param s the node to be unspliced
+     */
+    final void unsplice(Node pred, Node s) {
+        s.forgetContents(); // forget unneeded fields
+        /*
+         * See above for rationale. Briefly: if pred still points to
+         * s, try to unlink s.  If s cannot be unlinked, because it is
+         * trailing node or pred might be unlinked, and neither pred
+         * nor s are head or offlist, add to sweepVotes, and if enough
+         * votes have accumulated, sweep.
+         */
+        if (pred != null && pred != s && pred.next == s) {
+            Node n = s.next;
+            if (n == null ||
+                (n != s && pred.casNext(s, n) && pred.isMatched())) {
+                for (;;) {               // check if at, or could be, head
+                    Node h = head;
+                    if (h == pred || h == s || h == null)
+                        return;          // at head or list empty
+                    if (!h.isMatched())
+                        break;
+                    Node hn = h.next;
+                    if (hn == null)
+                        return;          // now empty
+                    if (hn != h && casHead(h, hn))
+                        h.forgetNext();  // advance head
+                }
+                if (pred.next != pred && s.next != s) { // recheck if offlist
+                    for (;;) {           // sweep now if enough votes
+                        int v = sweepVotes;
+                        if (v < SWEEP_THRESHOLD) {
+                            if (casSweepVotes(v, v + 1))
+                                break;
+                        }
+                        else if (casSweepVotes(v, 0)) {
+                            sweep();
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Unlinks matched (typically cancelled) nodes encountered in a
+     * traversal from head.
+     */
+    private void sweep() {
+        for (Node p = head, s, n; p != null && (s = p.next) != null; ) {
+            if (!s.isMatched())
+                // Unmatched nodes are never self-linked
+                p = s;
+            else if ((n = s.next) == null) // trailing node is pinned
+                break;
+            else if (s == n)    // stale
+                // No need to also check for p == s, since that implies s == n
+                p = head;
+            else
+                p.casNext(s, n);
+        }
+    }
+
+    /**
+     * Main implementation of remove(Object)
+     */
+    private boolean findAndRemove(Object e) {
+        if (e != null) {
+            for (Node pred = null, p = head; p != null; ) {
+                Object item = p.item;
+                if (p.isData) {
+                    if (item != null && item != p && e.equals(item) &&
+                        p.tryMatchData()) {
+                        unsplice(pred, p);
+                        return true;
+                    }
+                }
+                else if (item == null)
+                    break;
+                pred = p;
+                if ((p = p.next) == pred) { // stale
+                    pred = null;
+                    p = head;
+                }
+            }
+        }
+        return false;
+    }
+
+
+    /**
+     * Creates an initially empty {@code LinkedTransferQueue}.
+     */
+    public LinkedTransferQueue() {
+    }
+
+    /**
+     * Creates a {@code LinkedTransferQueue}
+     * initially containing the elements of the given collection,
+     * added in traversal order of the collection's iterator.
+     *
+     * @param c the collection of elements to initially contain
+     * @throws NullPointerException if the specified collection or any
+     *         of its elements are null
+     */
+    public LinkedTransferQueue(Collection<? extends E> c) {
+        this();
+        addAll(c);
+    }
+
+    /**
+     * Inserts the specified element at the tail of this queue.
+     * As the queue is unbounded, this method will never block.
+     *
+     * @throws NullPointerException if the specified element is null
+     */
+    public void put(E e) {
+        xfer(e, true, ASYNC, 0);
+    }
+
+    /**
+     * Inserts the specified element at the tail of this queue.
+     * As the queue is unbounded, this method will never block or
+     * return {@code false}.
+     *
+     * @return {@code true} (as specified by
+     *  {@link java.util.concurrent.BlockingQueue#offer(Object,long,TimeUnit)
+     *  BlockingQueue.offer})
+     * @throws NullPointerException if the specified element is null
+     */
+    public boolean offer(E e, long timeout, TimeUnit unit) {
+        xfer(e, true, ASYNC, 0);
+        return true;
+    }
+
+    /**
+     * Inserts the specified element at the tail of this queue.
+     * As the queue is unbounded, this method will never return {@code false}.
+     *
+     * @return {@code true} (as specified by {@link Queue#offer})
+     * @throws NullPointerException if the specified element is null
+     */
+    public boolean offer(E e) {
+        xfer(e, true, ASYNC, 0);
+        return true;
+    }
+
+    /**
+     * Inserts the specified element at the tail of this queue.
+     * As the queue is unbounded, this method will never throw
+     * {@link IllegalStateException} or return {@code false}.
+     *
+     * @return {@code true} (as specified by {@link Collection#add})
+     * @throws NullPointerException if the specified element is null
+     */
+    public boolean add(E e) {
+        xfer(e, true, ASYNC, 0);
+        return true;
+    }
+
+    /**
+     * Transfers the element to a waiting consumer immediately, if possible.
+     *
+     * <p>More precisely, transfers the specified element immediately
+     * if there exists a consumer already waiting to receive it (in
+     * {@link #take} or timed {@link #poll(long,TimeUnit) poll}),
+     * otherwise returning {@code false} without enqueuing the element.
+     *
+     * @throws NullPointerException if the specified element is null
+     */
+    public boolean tryTransfer(E e) {
+        return xfer(e, true, NOW, 0) == null;
+    }
+
+    /**
+     * Transfers the element to a consumer, waiting if necessary to do so.
+     *
+     * <p>More precisely, transfers the specified element immediately
+     * if there exists a consumer already waiting to receive it (in
+     * {@link #take} or timed {@link #poll(long,TimeUnit) poll}),
+     * else inserts the specified element at the tail of this queue
+     * and waits until the element is received by a consumer.
+     *
+     * @throws NullPointerException if the specified element is null
+     */
+    public void transfer(E e) throws InterruptedException {
+        if (xfer(e, true, SYNC, 0) != null) {
+            Thread.interrupted(); // failure possible only due to interrupt
+            throw new InterruptedException();
+        }
+    }
+
+    /**
+     * Transfers the element to a consumer if it is possible to do so
+     * before the timeout elapses.
+     *
+     * <p>More precisely, transfers the specified element immediately
+     * if there exists a consumer already waiting to receive it (in
+     * {@link #take} or timed {@link #poll(long,TimeUnit) poll}),
+     * else inserts the specified element at the tail of this queue
+     * and waits until the element is received by a consumer,
+     * returning {@code false} if the specified wait time elapses
+     * before the element can be transferred.
+     *
+     * @throws NullPointerException if the specified element is null
+     */
+    public boolean tryTransfer(E e, long timeout, TimeUnit unit)
+        throws InterruptedException {
+        if (xfer(e, true, TIMED, unit.toNanos(timeout)) == null)
+            return true;
+        if (!Thread.interrupted())
+            return false;
+        throw new InterruptedException();
+    }
+
+    public E take() throws InterruptedException {
+        E e = xfer(null, false, SYNC, 0);
+        if (e != null)
+            return e;
+        Thread.interrupted();
+        throw new InterruptedException();
+    }
+
+    public E poll(long timeout, TimeUnit unit) throws InterruptedException {
+        E e = xfer(null, false, TIMED, unit.toNanos(timeout));
+        if (e != null || !Thread.interrupted())
+            return e;
+        throw new InterruptedException();
+    }
+
+    public E poll() {
+        return xfer(null, false, NOW, 0);
+    }
+
+    /**
+     * @throws NullPointerException     {@inheritDoc}
+     * @throws IllegalArgumentException {@inheritDoc}
+     */
+    public int drainTo(Collection<? super E> c) {
+        if (c == null)
+            throw new NullPointerException();
+        if (c == this)
+            throw new IllegalArgumentException();
+        int n = 0;
+        for (E e; (e = poll()) != null;) {
+            c.add(e);
+            ++n;
+        }
+        return n;
+    }
+
+    /**
+     * @throws NullPointerException     {@inheritDoc}
+     * @throws IllegalArgumentException {@inheritDoc}
+     */
+    public int drainTo(Collection<? super E> c, int maxElements) {
+        if (c == null)
+            throw new NullPointerException();
+        if (c == this)
+            throw new IllegalArgumentException();
+        int n = 0;
+        for (E e; n < maxElements && (e = poll()) != null;) {
+            c.add(e);
+            ++n;
+        }
+        return n;
+    }
+
+    /**
+     * Returns an iterator over the elements in this queue in proper sequence.
+     * The elements will be returned in order from first (head) to last (tail).
+     *
+     * <p>The returned iterator is a "weakly consistent" iterator that
+     * will never throw {@link java.util.ConcurrentModificationException
+     * ConcurrentModificationException}, and guarantees to traverse
+     * elements as they existed upon construction of the iterator, and
+     * may (but is not guaranteed to) reflect any modifications
+     * subsequent to construction.
+     *
+     * @return an iterator over the elements in this queue in proper sequence
+     */
+    public Iterator<E> iterator() {
+        return new Itr();
+    }
+
+    public E peek() {
+        return firstDataItem();
+    }
+
+    /**
+     * Returns {@code true} if this queue contains no elements.
+     *
+     * @return {@code true} if this queue contains no elements
+     */
+    public boolean isEmpty() {
+        for (Node p = head; p != null; p = succ(p)) {
+            if (!p.isMatched())
+                return !p.isData;
+        }
+        return true;
+    }
+
+    public boolean hasWaitingConsumer() {
+        return firstOfMode(false) != null;
+    }
+
+    /**
+     * Returns the number of elements in this queue.  If this queue
+     * contains more than {@code Integer.MAX_VALUE} elements, returns
+     * {@code Integer.MAX_VALUE}.
+     *
+     * <p>Beware that, unlike in most collections, this method is
+     * <em>NOT</em> a constant-time operation. Because of the
+     * asynchronous nature of these queues, determining the current
+     * number of elements requires an O(n) traversal.
+     *
+     * @return the number of elements in this queue
+     */
+    public int size() {
+        return countOfMode(true);
+    }
+
+    public int getWaitingConsumerCount() {
+        return countOfMode(false);
+    }
+
+    /**
+     * Removes a single instance of the specified element from this queue,
+     * if it is present.  More formally, removes an element {@code e} such
+     * that {@code o.equals(e)}, if this queue contains one or more such
+     * elements.
+     * Returns {@code true} if this queue contained the specified element
+     * (or equivalently, if this queue changed as a result of the call).
+     *
+     * @param o element to be removed from this queue, if present
+     * @return {@code true} if this queue changed as a result of the call
+     */
+    public boolean remove(Object o) {
+        return findAndRemove(o);
+    }
+
+    /**
+     * Returns {@code true} if this queue contains the specified element.
+     * More formally, returns {@code true} if and only if this queue contains
+     * at least one element {@code e} such that {@code o.equals(e)}.
+     *
+     * @param o object to be checked for containment in this queue
+     * @return {@code true} if this queue contains the specified element
+     */
+    public boolean contains(Object o) {
+        if (o == null) return false;
+        for (Node p = head; p != null; p = succ(p)) {
+            Object item = p.item;
+            if (p.isData) {
+                if (item != null && item != p && o.equals(item))
+                    return true;
+            }
+            else if (item == null)
+                break;
+        }
+        return false;
+    }
+
+    /**
+     * Always returns {@code Integer.MAX_VALUE} because a
+     * {@code LinkedTransferQueue} is not capacity constrained.
+     *
+     * @return {@code Integer.MAX_VALUE} (as specified by
+     *         {@link java.util.concurrent.BlockingQueue#remainingCapacity()
+     *         BlockingQueue.remainingCapacity})
+     */
+    public int remainingCapacity() {
+        return Integer.MAX_VALUE;
+    }
+
+    /**
+     * Saves the state to a stream (that is, serializes it).
+     *
+     * @serialData All of the elements (each an {@code E}) in
+     * the proper order, followed by a null
+     * @param s the stream
+     */
+    private void writeObject(java.io.ObjectOutputStream s)
+        throws java.io.IOException {
+        s.defaultWriteObject();
+        for (E e : this)
+            s.writeObject(e);
+        // Use trailing null as sentinel
+        s.writeObject(null);
+    }
+
+    /**
+     * Reconstitutes the Queue instance from a stream (that is,
+     * deserializes it).
+     *
+     * @param s the stream
+     */
+    private void readObject(java.io.ObjectInputStream s)
+        throws java.io.IOException, ClassNotFoundException {
+        s.defaultReadObject();
+        for (;;) {
+            @SuppressWarnings("unchecked") E item = (E) s.readObject();
+            if (item == null)
+                break;
+            else
+                offer(item);
+        }
+    }
+
+    // Unsafe mechanics
+
+    private static final sun.misc.Unsafe UNSAFE;
+    private static final long headOffset;
+    private static final long tailOffset;
+    private static final long sweepVotesOffset;
+    static {
+        try {
+            UNSAFE = sun.misc.Unsafe.getUnsafe();
+            Class<?> k = LinkedTransferQueue.class;
+            headOffset = UNSAFE.objectFieldOffset
+                (k.getDeclaredField("head"));
+            tailOffset = UNSAFE.objectFieldOffset
+                (k.getDeclaredField("tail"));
+            sweepVotesOffset = UNSAFE.objectFieldOffset
+                (k.getDeclaredField("sweepVotes"));
+        } catch (Exception e) {
+            throw new Error(e);
+        }
+    }
+}
diff --git a/luni/src/main/java/java/util/concurrent/Phaser.java b/luni/src/main/java/java/util/concurrent/Phaser.java
new file mode 100644
index 0000000..25ff743
--- /dev/null
+++ b/luni/src/main/java/java/util/concurrent/Phaser.java
@@ -0,0 +1,1135 @@
+/*
+ * Written by Doug Lea with assistance from members of JCP JSR-166
+ * Expert Group and released to the public domain, as explained at
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+package java.util.concurrent;
+
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.concurrent.locks.LockSupport;
+
+/**
+ * A reusable synchronization barrier, similar in functionality to
+ * {@link java.util.concurrent.CyclicBarrier CyclicBarrier} and
+ * {@link java.util.concurrent.CountDownLatch CountDownLatch}
+ * but supporting more flexible usage.
+ *
+ * <p> <b>Registration.</b> Unlike the case for other barriers, the
+ * number of parties <em>registered</em> to synchronize on a phaser
+ * may vary over time.  Tasks may be registered at any time (using
+ * methods {@link #register}, {@link #bulkRegister}, or forms of
+ * constructors establishing initial numbers of parties), and
+ * optionally deregistered upon any arrival (using {@link
+ * #arriveAndDeregister}).  As is the case with most basic
+ * synchronization constructs, registration and deregistration affect
+ * only internal counts; they do not establish any further internal
+ * bookkeeping, so tasks cannot query whether they are registered.
+ * (However, you can introduce such bookkeeping by subclassing this
+ * class.)
+ *
+ * <p> <b>Synchronization.</b> Like a {@code CyclicBarrier}, a {@code
+ * Phaser} may be repeatedly awaited.  Method {@link
+ * #arriveAndAwaitAdvance} has effect analogous to {@link
+ * java.util.concurrent.CyclicBarrier#await CyclicBarrier.await}. Each
+ * generation of a phaser has an associated phase number. The phase
+ * number starts at zero, and advances when all parties arrive at the
+ * phaser, wrapping around to zero after reaching {@code
+ * Integer.MAX_VALUE}. The use of phase numbers enables independent
+ * control of actions upon arrival at a phaser and upon awaiting
+ * others, via two kinds of methods that may be invoked by any
+ * registered party:
+ *
+ * <ul>
+ *
+ *   <li> <b>Arrival.</b> Methods {@link #arrive} and
+ *       {@link #arriveAndDeregister} record arrival.  These methods
+ *       do not block, but return an associated <em>arrival phase
+ *       number</em>; that is, the phase number of the phaser to which
+ *       the arrival applied. When the final party for a given phase
+ *       arrives, an optional action is performed and the phase
+ *       advances.  These actions are performed by the party
+ *       triggering a phase advance, and are arranged by overriding
+ *       method {@link #onAdvance(int, int)}, which also controls
+ *       termination. Overriding this method is similar to, but more
+ *       flexible than, providing a barrier action to a {@code
+ *       CyclicBarrier}.
+ *
+ *   <li> <b>Waiting.</b> Method {@link #awaitAdvance} requires an
+ *       argument indicating an arrival phase number, and returns when
+ *       the phaser advances to (or is already at) a different phase.
+ *       Unlike similar constructions using {@code CyclicBarrier},
+ *       method {@code awaitAdvance} continues to wait even if the
+ *       waiting thread is interrupted. Interruptible and timeout
+ *       versions are also available, but exceptions encountered while
+ *       tasks wait interruptibly or with timeout do not change the
+ *       state of the phaser. If necessary, you can perform any
+ *       associated recovery within handlers of those exceptions,
+ *       often after invoking {@code forceTermination}.  Phasers may
+ *       also be used by tasks executing in a {@link ForkJoinPool},
+ *       which will ensure sufficient parallelism to execute tasks
+ *       when others are blocked waiting for a phase to advance.
+ *
+ * </ul>
+ *
+ * <p> <b>Termination.</b> A phaser may enter a <em>termination</em>
+ * state, that may be checked using method {@link #isTerminated}. Upon
+ * termination, all synchronization methods immediately return without
+ * waiting for advance, as indicated by a negative return value.
+ * Similarly, attempts to register upon termination have no effect.
+ * Termination is triggered when an invocation of {@code onAdvance}
+ * returns {@code true}. The default implementation returns {@code
+ * true} if a deregistration has caused the number of registered
+ * parties to become zero.  As illustrated below, when phasers control
+ * actions with a fixed number of iterations, it is often convenient
+ * to override this method to cause termination when the current phase
+ * number reaches a threshold. Method {@link #forceTermination} is
+ * also available to abruptly release waiting threads and allow them
+ * to terminate.
+ *
+ * <p> <b>Tiering.</b> Phasers may be <em>tiered</em> (i.e.,
+ * constructed in tree structures) to reduce contention. Phasers with
+ * large numbers of parties that would otherwise experience heavy
+ * synchronization contention costs may instead be set up so that
+ * groups of sub-phasers share a common parent.  This may greatly
+ * increase throughput even though it incurs greater per-operation
+ * overhead.
+ *
+ * <p>In a tree of tiered phasers, registration and deregistration of
+ * child phasers with their parent are managed automatically.
+ * Whenever the number of registered parties of a child phaser becomes
+ * non-zero (as established in the {@link #Phaser(Phaser,int)}
+ * constructor, {@link #register}, or {@link #bulkRegister}), the
+ * child phaser is registered with its parent.  Whenever the number of
+ * registered parties becomes zero as the result of an invocation of
+ * {@link #arriveAndDeregister}, the child phaser is deregistered
+ * from its parent.
+ *
+ * <p><b>Monitoring.</b> While synchronization methods may be invoked
+ * only by registered parties, the current state of a phaser may be
+ * monitored by any caller.  At any given moment there are {@link
+ * #getRegisteredParties} parties in total, of which {@link
+ * #getArrivedParties} have arrived at the current phase ({@link
+ * #getPhase}).  When the remaining ({@link #getUnarrivedParties})
+ * parties arrive, the phase advances.  The values returned by these
+ * methods may reflect transient states and so are not in general
+ * useful for synchronization control.  Method {@link #toString}
+ * returns snapshots of these state queries in a form convenient for
+ * informal monitoring.
+ *
+ * <p><b>Sample usages:</b>
+ *
+ * <p>A {@code Phaser} may be used instead of a {@code CountDownLatch}
+ * to control a one-shot action serving a variable number of parties.
+ * The typical idiom is for the method setting this up to first
+ * register, then start the actions, then deregister, as in:
+ *
+ *  <pre> {@code
+ * void runTasks(List<Runnable> tasks) {
+ *   final Phaser phaser = new Phaser(1); // "1" to register self
+ *   // create and start threads
+ *   for (final Runnable task : tasks) {
+ *     phaser.register();
+ *     new Thread() {
+ *       public void run() {
+ *         phaser.arriveAndAwaitAdvance(); // await all creation
+ *         task.run();
+ *       }
+ *     }.start();
+ *   }
+ *
+ *   // allow threads to start and deregister self
+ *   phaser.arriveAndDeregister();
+ * }}</pre>
+ *
+ * <p>One way to cause a set of threads to repeatedly perform actions
+ * for a given number of iterations is to override {@code onAdvance}:
+ *
+ *  <pre> {@code
+ * void startTasks(List<Runnable> tasks, final int iterations) {
+ *   final Phaser phaser = new Phaser() {
+ *     protected boolean onAdvance(int phase, int registeredParties) {
+ *       return phase >= iterations || registeredParties == 0;
+ *     }
+ *   };
+ *   phaser.register();
+ *   for (final Runnable task : tasks) {
+ *     phaser.register();
+ *     new Thread() {
+ *       public void run() {
+ *         do {
+ *           task.run();
+ *           phaser.arriveAndAwaitAdvance();
+ *         } while (!phaser.isTerminated());
+ *       }
+ *     }.start();
+ *   }
+ *   phaser.arriveAndDeregister(); // deregister self, don't wait
+ * }}</pre>
+ *
+ * If the main task must later await termination, it
+ * may re-register and then execute a similar loop:
+ *  <pre> {@code
+ *   // ...
+ *   phaser.register();
+ *   while (!phaser.isTerminated())
+ *     phaser.arriveAndAwaitAdvance();}</pre>
+ *
+ * <p>Related constructions may be used to await particular phase numbers
+ * in contexts where you are sure that the phase will never wrap around
+ * {@code Integer.MAX_VALUE}. For example:
+ *
+ *  <pre> {@code
+ * void awaitPhase(Phaser phaser, int phase) {
+ *   int p = phaser.register(); // assumes caller not already registered
+ *   while (p < phase) {
+ *     if (phaser.isTerminated())
+ *       // ... deal with unexpected termination
+ *     else
+ *       p = phaser.arriveAndAwaitAdvance();
+ *   }
+ *   phaser.arriveAndDeregister();
+ * }}</pre>
+ *
+ *
+ * <p>To create a set of {@code n} tasks using a tree of phasers, you
+ * could use code of the following form, assuming a Task class with a
+ * constructor accepting a {@code Phaser} that it registers with upon
+ * construction. After invocation of {@code build(new Task[n], 0, n,
+ * new Phaser())}, these tasks could then be started, for example by
+ * submitting to a pool:
+ *
+ *  <pre> {@code
+ * void build(Task[] tasks, int lo, int hi, Phaser ph) {
+ *   if (hi - lo > TASKS_PER_PHASER) {
+ *     for (int i = lo; i < hi; i += TASKS_PER_PHASER) {
+ *       int j = Math.min(i + TASKS_PER_PHASER, hi);
+ *       build(tasks, i, j, new Phaser(ph));
+ *     }
+ *   } else {
+ *     for (int i = lo; i < hi; ++i)
+ *       tasks[i] = new Task(ph);
+ *       // assumes new Task(ph) performs ph.register()
+ *   }
+ * }}</pre>
+ *
+ * The best value of {@code TASKS_PER_PHASER} depends mainly on
+ * expected synchronization rates. A value as low as four may
+ * be appropriate for extremely small per-phase task bodies (thus
+ * high rates), or up to hundreds for extremely large ones.
+ *
+ * <p><b>Implementation notes</b>: This implementation restricts the
+ * maximum number of parties to 65535. Attempts to register additional
+ * parties result in {@code IllegalStateException}. However, you can and
+ * should create tiered phasers to accommodate arbitrarily large sets
+ * of participants.
+ *
+ * @since 1.7
+ * @hide
+ * @author Doug Lea
+ */
+public class Phaser {
+    /*
+     * This class implements an extension of X10 "clocks".  Thanks to
+     * Vijay Saraswat for the idea, and to Vivek Sarkar for
+     * enhancements to extend functionality.
+     */
+
+    /**
+     * Primary state representation, holding four bit-fields:
+     *
+     * unarrived  -- the number of parties yet to hit barrier (bits  0-15)
+     * parties    -- the number of parties to wait            (bits 16-31)
+     * phase      -- the generation of the barrier            (bits 32-62)
+     * terminated -- set if barrier is terminated             (bit  63 / sign)
+     *
+     * Except that a phaser with no registered parties is
+     * distinguished by the otherwise illegal state of having zero
+     * parties and one unarrived parties (encoded as EMPTY below).
+     *
+     * To efficiently maintain atomicity, these values are packed into
+     * a single (atomic) long. Good performance relies on keeping
+     * state decoding and encoding simple, and keeping race windows
+     * short.
+     *
+     * All state updates are performed via CAS except initial
+     * registration of a sub-phaser (i.e., one with a non-null
+     * parent).  In this (relatively rare) case, we use built-in
+     * synchronization to lock while first registering with its
+     * parent.
+     *
+     * The phase of a subphaser is allowed to lag that of its
+     * ancestors until it is actually accessed -- see method
+     * reconcileState.
+     */
+    private volatile long state;
+
+    private static final int  MAX_PARTIES     = 0xffff;
+    private static final int  MAX_PHASE       = Integer.MAX_VALUE;
+    private static final int  PARTIES_SHIFT   = 16;
+    private static final int  PHASE_SHIFT     = 32;
+    private static final int  UNARRIVED_MASK  = 0xffff;      // to mask ints
+    private static final long PARTIES_MASK    = 0xffff0000L; // to mask longs
+    private static final long COUNTS_MASK     = 0xffffffffL;
+    private static final long TERMINATION_BIT = 1L << 63;
+
+    // some special values
+    private static final int  ONE_ARRIVAL     = 1;
+    private static final int  ONE_PARTY       = 1 << PARTIES_SHIFT;
+    private static final int  ONE_DEREGISTER  = ONE_ARRIVAL|ONE_PARTY;
+    private static final int  EMPTY           = 1;
+
+    // The following unpacking methods are usually manually inlined
+
+    private static int unarrivedOf(long s) {
+        int counts = (int)s;
+        return (counts == EMPTY) ? 0 : (counts & UNARRIVED_MASK);
+    }
+
+    private static int partiesOf(long s) {
+        return (int)s >>> PARTIES_SHIFT;
+    }
+
+    private static int phaseOf(long s) {
+        return (int)(s >>> PHASE_SHIFT);
+    }
+
+    private static int arrivedOf(long s) {
+        int counts = (int)s;
+        return (counts == EMPTY) ? 0 :
+            (counts >>> PARTIES_SHIFT) - (counts & UNARRIVED_MASK);
+    }
+
+    /**
+     * The parent of this phaser, or null if none
+     */
+    private final Phaser parent;
+
+    /**
+     * The root of phaser tree. Equals this if not in a tree.
+     */
+    private final Phaser root;
+
+    /**
+     * Heads of Treiber stacks for waiting threads. To eliminate
+     * contention when releasing some threads while adding others, we
+     * use two of them, alternating across even and odd phases.
+     * Subphasers share queues with root to speed up releases.
+     */
+    private final AtomicReference<QNode> evenQ;
+    private final AtomicReference<QNode> oddQ;
+
+    private AtomicReference<QNode> queueFor(int phase) {
+        return ((phase & 1) == 0) ? evenQ : oddQ;
+    }
+
+    /**
+     * Returns message string for bounds exceptions on arrival.
+     */
+    private String badArrive(long s) {
+        return "Attempted arrival of unregistered party for " +
+            stateToString(s);
+    }
+
+    /**
+     * Returns message string for bounds exceptions on registration.
+     */
+    private String badRegister(long s) {
+        return "Attempt to register more than " +
+            MAX_PARTIES + " parties for " + stateToString(s);
+    }
+
+    /**
+     * Main implementation for methods arrive and arriveAndDeregister.
+     * Manually tuned to speed up and minimize race windows for the
+     * common case of just decrementing unarrived field.
+     *
+     * @param adjust value to subtract from state;
+     *               ONE_ARRIVAL for arrive,
+     *               ONE_DEREGISTER for arriveAndDeregister
+     */
+    private int doArrive(int adjust) {
+        final Phaser root = this.root;
+        for (;;) {
+            long s = (root == this) ? state : reconcileState();
+            int phase = (int)(s >>> PHASE_SHIFT);
+            if (phase < 0)
+                return phase;
+            int counts = (int)s;
+            int unarrived = (counts == EMPTY) ? 0 : (counts & UNARRIVED_MASK);
+            if (unarrived <= 0)
+                throw new IllegalStateException(badArrive(s));
+            if (UNSAFE.compareAndSwapLong(this, stateOffset, s, s-=adjust)) {
+                if (unarrived == 1) {
+                    long n = s & PARTIES_MASK;  // base of next state
+                    int nextUnarrived = (int)n >>> PARTIES_SHIFT;
+                    if (root == this) {
+                        if (onAdvance(phase, nextUnarrived))
+                            n |= TERMINATION_BIT;
+                        else if (nextUnarrived == 0)
+                            n |= EMPTY;
+                        else
+                            n |= nextUnarrived;
+                        int nextPhase = (phase + 1) & MAX_PHASE;
+                        n |= (long)nextPhase << PHASE_SHIFT;
+                        UNSAFE.compareAndSwapLong(this, stateOffset, s, n);
+                        releaseWaiters(phase);
+                    }
+                    else if (nextUnarrived == 0) { // propagate deregistration
+                        phase = parent.doArrive(ONE_DEREGISTER);
+                        UNSAFE.compareAndSwapLong(this, stateOffset,
+                                                  s, s | EMPTY);
+                    }
+                    else
+                        phase = parent.doArrive(ONE_ARRIVAL);
+                }
+                return phase;
+            }
+        }
+    }
+
+    /**
+     * Implementation of register, bulkRegister
+     *
+     * @param registrations number to add to both parties and
+     * unarrived fields. Must be greater than zero.
+     */
+    private int doRegister(int registrations) {
+        // adjustment to state
+        long adjust = ((long)registrations << PARTIES_SHIFT) | registrations;
+        final Phaser parent = this.parent;
+        int phase;
+        for (;;) {
+            long s = (parent == null) ? state : reconcileState();
+            int counts = (int)s;
+            int parties = counts >>> PARTIES_SHIFT;
+            int unarrived = counts & UNARRIVED_MASK;
+            if (registrations > MAX_PARTIES - parties)
+                throw new IllegalStateException(badRegister(s));
+            phase = (int)(s >>> PHASE_SHIFT);
+            if (phase < 0)
+                break;
+            if (counts != EMPTY) {                  // not 1st registration
+                if (parent == null || reconcileState() == s) {
+                    if (unarrived == 0)             // wait out advance
+                        root.internalAwaitAdvance(phase, null);
+                    else if (UNSAFE.compareAndSwapLong(this, stateOffset,
+                                                       s, s + adjust))
+                        break;
+                }
+            }
+            else if (parent == null) {              // 1st root registration
+                long next = ((long)phase << PHASE_SHIFT) | adjust;
+                if (UNSAFE.compareAndSwapLong(this, stateOffset, s, next))
+                    break;
+            }
+            else {
+                synchronized (this) {               // 1st sub registration
+                    if (state == s) {               // recheck under lock
+                        phase = parent.doRegister(1);
+                        if (phase < 0)
+                            break;
+                        // finish registration whenever parent registration
+                        // succeeded, even when racing with termination,
+                        // since these are part of the same "transaction".
+                        while (!UNSAFE.compareAndSwapLong
+                               (this, stateOffset, s,
+                                ((long)phase << PHASE_SHIFT) | adjust)) {
+                            s = state;
+                            phase = (int)(root.state >>> PHASE_SHIFT);
+                            // assert (int)s == EMPTY;
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+        return phase;
+    }
+
+    /**
+     * Resolves lagged phase propagation from root if necessary.
+     * Reconciliation normally occurs when root has advanced but
+     * subphasers have not yet done so, in which case they must finish
+     * their own advance by setting unarrived to parties (or if
+     * parties is zero, resetting to unregistered EMPTY state).
+     *
+     * @return reconciled state
+     */
+    private long reconcileState() {
+        final Phaser root = this.root;
+        long s = state;
+        if (root != this) {
+            int phase, p;
+            // CAS to root phase with current parties, tripping unarrived
+            while ((phase = (int)(root.state >>> PHASE_SHIFT)) !=
+                   (int)(s >>> PHASE_SHIFT) &&
+                   !UNSAFE.compareAndSwapLong
+                   (this, stateOffset, s,
+                    s = (((long)phase << PHASE_SHIFT) |
+                         ((phase < 0) ? (s & COUNTS_MASK) :
+                          (((p = (int)s >>> PARTIES_SHIFT) == 0) ? EMPTY :
+                           ((s & PARTIES_MASK) | p))))))
+                s = state;
+        }
+        return s;
+    }
+
+    /**
+     * Creates a new phaser with no initially registered parties, no
+     * parent, and initial phase number 0. Any thread using this
+     * phaser will need to first register for it.
+     */
+    public Phaser() {
+        this(null, 0);
+    }
+
+    /**
+     * Creates a new phaser with the given number of registered
+     * unarrived parties, no parent, and initial phase number 0.
+     *
+     * @param parties the number of parties required to advance to the
+     * next phase
+     * @throws IllegalArgumentException if parties less than zero
+     * or greater than the maximum number of parties supported
+     */
+    public Phaser(int parties) {
+        this(null, parties);
+    }
+
+    /**
+     * Equivalent to {@link #Phaser(Phaser, int) Phaser(parent, 0)}.
+     *
+     * @param parent the parent phaser
+     */
+    public Phaser(Phaser parent) {
+        this(parent, 0);
+    }
+
+    /**
+     * Creates a new phaser with the given parent and number of
+     * registered unarrived parties.  When the given parent is non-null
+     * and the given number of parties is greater than zero, this
+     * child phaser is registered with its parent.
+     *
+     * @param parent the parent phaser
+     * @param parties the number of parties required to advance to the
+     * next phase
+     * @throws IllegalArgumentException if parties less than zero
+     * or greater than the maximum number of parties supported
+     */
+    public Phaser(Phaser parent, int parties) {
+        if (parties >>> PARTIES_SHIFT != 0)
+            throw new IllegalArgumentException("Illegal number of parties");
+        int phase = 0;
+        this.parent = parent;
+        if (parent != null) {
+            final Phaser root = parent.root;
+            this.root = root;
+            this.evenQ = root.evenQ;
+            this.oddQ = root.oddQ;
+            if (parties != 0)
+                phase = parent.doRegister(1);
+        }
+        else {
+            this.root = this;
+            this.evenQ = new AtomicReference<QNode>();
+            this.oddQ = new AtomicReference<QNode>();
+        }
+        this.state = (parties == 0) ? (long)EMPTY :
+            ((long)phase << PHASE_SHIFT) |
+            ((long)parties << PARTIES_SHIFT) |
+            ((long)parties);
+    }
+
+    /**
+     * Adds a new unarrived party to this phaser.  If an ongoing
+     * invocation of {@link #onAdvance} is in progress, this method
+     * may await its completion before returning.  If this phaser has
+     * a parent, and this phaser previously had no registered parties,
+     * this child phaser is also registered with its parent. If
+     * this phaser is terminated, the attempt to register has
+     * no effect, and a negative value is returned.
+     *
+     * @return the arrival phase number to which this registration
+     * applied.  If this value is negative, then this phaser has
+     * terminated, in which case registration has no effect.
+     * @throws IllegalStateException if attempting to register more
+     * than the maximum supported number of parties
+     */
+    public int register() {
+        return doRegister(1);
+    }
+
+    /**
+     * Adds the given number of new unarrived parties to this phaser.
+     * If an ongoing invocation of {@link #onAdvance} is in progress,
+     * this method may await its completion before returning.  If this
+     * phaser has a parent, and the given number of parties is greater
+     * than zero, and this phaser previously had no registered
+     * parties, this child phaser is also registered with its parent.
+     * If this phaser is terminated, the attempt to register has no
+     * effect, and a negative value is returned.
+     *
+     * @param parties the number of additional parties required to
+     * advance to the next phase
+     * @return the arrival phase number to which this registration
+     * applied.  If this value is negative, then this phaser has
+     * terminated, in which case registration has no effect.
+     * @throws IllegalStateException if attempting to register more
+     * than the maximum supported number of parties
+     * @throws IllegalArgumentException if {@code parties < 0}
+     */
+    public int bulkRegister(int parties) {
+        if (parties < 0)
+            throw new IllegalArgumentException();
+        if (parties == 0)
+            return getPhase();
+        return doRegister(parties);
+    }
+
+    /**
+     * Arrives at this phaser, without waiting for others to arrive.
+     *
+     * <p>It is a usage error for an unregistered party to invoke this
+     * method.  However, this error may result in an {@code
+     * IllegalStateException} only upon some subsequent operation on
+     * this phaser, if ever.
+     *
+     * @return the arrival phase number, or a negative value if terminated
+     * @throws IllegalStateException if not terminated and the number
+     * of unarrived parties would become negative
+     */
+    public int arrive() {
+        return doArrive(ONE_ARRIVAL);
+    }
+
+    /**
+     * Arrives at this phaser and deregisters from it without waiting
+     * for others to arrive. Deregistration reduces the number of
+     * parties required to advance in future phases.  If this phaser
+     * has a parent, and deregistration causes this phaser to have
+     * zero parties, this phaser is also deregistered from its parent.
+     *
+     * <p>It is a usage error for an unregistered party to invoke this
+     * method.  However, this error may result in an {@code
+     * IllegalStateException} only upon some subsequent operation on
+     * this phaser, if ever.
+     *
+     * @return the arrival phase number, or a negative value if terminated
+     * @throws IllegalStateException if not terminated and the number
+     * of registered or unarrived parties would become negative
+     */
+    public int arriveAndDeregister() {
+        return doArrive(ONE_DEREGISTER);
+    }
+
+    /**
+     * Arrives at this phaser and awaits others. Equivalent in effect
+     * to {@code awaitAdvance(arrive())}.  If you need to await with
+     * interruption or timeout, you can arrange this with an analogous
+     * construction using one of the other forms of the {@code
+     * awaitAdvance} method.  If instead you need to deregister upon
+     * arrival, use {@code awaitAdvance(arriveAndDeregister())}.
+     *
+     * <p>It is a usage error for an unregistered party to invoke this
+     * method.  However, this error may result in an {@code
+     * IllegalStateException} only upon some subsequent operation on
+     * this phaser, if ever.
+     *
+     * @return the arrival phase number, or the (negative)
+     * {@linkplain #getPhase() current phase} if terminated
+     * @throws IllegalStateException if not terminated and the number
+     * of unarrived parties would become negative
+     */
+    public int arriveAndAwaitAdvance() {
+        // Specialization of doArrive+awaitAdvance eliminating some reads/paths
+        final Phaser root = this.root;
+        for (;;) {
+            long s = (root == this) ? state : reconcileState();
+            int phase = (int)(s >>> PHASE_SHIFT);
+            if (phase < 0)
+                return phase;
+            int counts = (int)s;
+            int unarrived = (counts == EMPTY) ? 0 : (counts & UNARRIVED_MASK);
+            if (unarrived <= 0)
+                throw new IllegalStateException(badArrive(s));
+            if (UNSAFE.compareAndSwapLong(this, stateOffset, s,
+                                          s -= ONE_ARRIVAL)) {
+                if (unarrived > 1)
+                    return root.internalAwaitAdvance(phase, null);
+                if (root != this)
+                    return parent.arriveAndAwaitAdvance();
+                long n = s & PARTIES_MASK;  // base of next state
+                int nextUnarrived = (int)n >>> PARTIES_SHIFT;
+                if (onAdvance(phase, nextUnarrived))
+                    n |= TERMINATION_BIT;
+                else if (nextUnarrived == 0)
+                    n |= EMPTY;
+                else
+                    n |= nextUnarrived;
+                int nextPhase = (phase + 1) & MAX_PHASE;
+                n |= (long)nextPhase << PHASE_SHIFT;
+                if (!UNSAFE.compareAndSwapLong(this, stateOffset, s, n))
+                    return (int)(state >>> PHASE_SHIFT); // terminated
+                releaseWaiters(phase);
+                return nextPhase;
+            }
+        }
+    }
+
+    /**
+     * Awaits the phase of this phaser to advance from the given phase
+     * value, returning immediately if the current phase is not equal
+     * to the given phase value or this phaser is terminated.
+     *
+     * @param phase an arrival phase number, or negative value if
+     * terminated; this argument is normally the value returned by a
+     * previous call to {@code arrive} or {@code arriveAndDeregister}.
+     * @return the next arrival phase number, or the argument if it is
+     * negative, or the (negative) {@linkplain #getPhase() current phase}
+     * if terminated
+     */
+    public int awaitAdvance(int phase) {
+        final Phaser root = this.root;
+        long s = (root == this) ? state : reconcileState();
+        int p = (int)(s >>> PHASE_SHIFT);
+        if (phase < 0)
+            return phase;
+        if (p == phase)
+            return root.internalAwaitAdvance(phase, null);
+        return p;
+    }
+
+    /**
+     * Awaits the phase of this phaser to advance from the given phase
+     * value, throwing {@code InterruptedException} if interrupted
+     * while waiting, or returning immediately if the current phase is
+     * not equal to the given phase value or this phaser is
+     * terminated.
+     *
+     * @param phase an arrival phase number, or negative value if
+     * terminated; this argument is normally the value returned by a
+     * previous call to {@code arrive} or {@code arriveAndDeregister}.
+     * @return the next arrival phase number, or the argument if it is
+     * negative, or the (negative) {@linkplain #getPhase() current phase}
+     * if terminated
+     * @throws InterruptedException if thread interrupted while waiting
+     */
+    public int awaitAdvanceInterruptibly(int phase)
+        throws InterruptedException {
+        final Phaser root = this.root;
+        long s = (root == this) ? state : reconcileState();
+        int p = (int)(s >>> PHASE_SHIFT);
+        if (phase < 0)
+            return phase;
+        if (p == phase) {
+            QNode node = new QNode(this, phase, true, false, 0L);
+            p = root.internalAwaitAdvance(phase, node);
+            if (node.wasInterrupted)
+                throw new InterruptedException();
+        }
+        return p;
+    }
+
+    /**
+     * Awaits the phase of this phaser to advance from the given phase
+     * value or the given timeout to elapse, throwing {@code
+     * InterruptedException} if interrupted while waiting, or
+     * returning immediately if the current phase is not equal to the
+     * given phase value or this phaser is terminated.
+     *
+     * @param phase an arrival phase number, or negative value if
+     * terminated; this argument is normally the value returned by a
+     * previous call to {@code arrive} or {@code arriveAndDeregister}.
+     * @param timeout how long to wait before giving up, in units of
+     *        {@code unit}
+     * @param unit a {@code TimeUnit} determining how to interpret the
+     *        {@code timeout} parameter
+     * @return the next arrival phase number, or the argument if it is
+     * negative, or the (negative) {@linkplain #getPhase() current phase}
+     * if terminated
+     * @throws InterruptedException if thread interrupted while waiting
+     * @throws TimeoutException if timed out while waiting
+     */
+    public int awaitAdvanceInterruptibly(int phase,
+                                         long timeout, TimeUnit unit)
+        throws InterruptedException, TimeoutException {
+        long nanos = unit.toNanos(timeout);
+        final Phaser root = this.root;
+        long s = (root == this) ? state : reconcileState();
+        int p = (int)(s >>> PHASE_SHIFT);
+        if (phase < 0)
+            return phase;
+        if (p == phase) {
+            QNode node = new QNode(this, phase, true, true, nanos);
+            p = root.internalAwaitAdvance(phase, node);
+            if (node.wasInterrupted)
+                throw new InterruptedException();
+            else if (p == phase)
+                throw new TimeoutException();
+        }
+        return p;
+    }
+
+    /**
+     * Forces this phaser to enter termination state.  Counts of
+     * registered parties are unaffected.  If this phaser is a member
+     * of a tiered set of phasers, then all of the phasers in the set
+     * are terminated.  If this phaser is already terminated, this
+     * method has no effect.  This method may be useful for
+     * coordinating recovery after one or more tasks encounter
+     * unexpected exceptions.
+     */
+    public void forceTermination() {
+        // Only need to change root state
+        final Phaser root = this.root;
+        long s;
+        while ((s = root.state) >= 0) {
+            if (UNSAFE.compareAndSwapLong(root, stateOffset,
+                                          s, s | TERMINATION_BIT)) {
+                // signal all threads
+                releaseWaiters(0); // Waiters on evenQ
+                releaseWaiters(1); // Waiters on oddQ
+                return;
+            }
+        }
+    }
+
+    /**
+     * Returns the current phase number. The maximum phase number is
+     * {@code Integer.MAX_VALUE}, after which it restarts at
+     * zero. Upon termination, the phase number is negative,
+     * in which case the prevailing phase prior to termination
+     * may be obtained via {@code getPhase() + Integer.MIN_VALUE}.
+     *
+     * @return the phase number, or a negative value if terminated
+     */
+    public final int getPhase() {
+        return (int)(root.state >>> PHASE_SHIFT);
+    }
+
+    /**
+     * Returns the number of parties registered at this phaser.
+     *
+     * @return the number of parties
+     */
+    public int getRegisteredParties() {
+        return partiesOf(state);
+    }
+
+    /**
+     * Returns the number of registered parties that have arrived at
+     * the current phase of this phaser. If this phaser has terminated,
+     * the returned value is meaningless and arbitrary.
+     *
+     * @return the number of arrived parties
+     */
+    public int getArrivedParties() {
+        return arrivedOf(reconcileState());
+    }
+
+    /**
+     * Returns the number of registered parties that have not yet
+     * arrived at the current phase of this phaser. If this phaser has
+     * terminated, the returned value is meaningless and arbitrary.
+     *
+     * @return the number of unarrived parties
+     */
+    public int getUnarrivedParties() {
+        return unarrivedOf(reconcileState());
+    }
+
+    /**
+     * Returns the parent of this phaser, or {@code null} if none.
+     *
+     * @return the parent of this phaser, or {@code null} if none
+     */
+    public Phaser getParent() {
+        return parent;
+    }
+
+    /**
+     * Returns the root ancestor of this phaser, which is the same as
+     * this phaser if it has no parent.
+     *
+     * @return the root ancestor of this phaser
+     */
+    public Phaser getRoot() {
+        return root;
+    }
+
+    /**
+     * Returns {@code true} if this phaser has been terminated.
+     *
+     * @return {@code true} if this phaser has been terminated
+     */
+    public boolean isTerminated() {
+        return root.state < 0L;
+    }
+
+    /**
+     * Overridable method to perform an action upon impending phase
+     * advance, and to control termination. This method is invoked
+     * upon arrival of the party advancing this phaser (when all other
+     * waiting parties are dormant).  If this method returns {@code
+     * true}, this phaser will be set to a final termination state
+     * upon advance, and subsequent calls to {@link #isTerminated}
+     * will return true. Any (unchecked) Exception or Error thrown by
+     * an invocation of this method is propagated to the party
+     * attempting to advance this phaser, in which case no advance
+     * occurs.
+     *
+     * <p>The arguments to this method provide the state of the phaser
+     * prevailing for the current transition.  The effects of invoking
+     * arrival, registration, and waiting methods on this phaser from
+     * within {@code onAdvance} are unspecified and should not be
+     * relied on.
+     *
+     * <p>If this phaser is a member of a tiered set of phasers, then
+     * {@code onAdvance} is invoked only for its root phaser on each
+     * advance.
+     *
+     * <p>To support the most common use cases, the default
+     * implementation of this method returns {@code true} when the
+     * number of registered parties has become zero as the result of a
+     * party invoking {@code arriveAndDeregister}.  You can disable
+     * this behavior, thus enabling continuation upon future
+     * registrations, by overriding this method to always return
+     * {@code false}:
+     *
+     * <pre> {@code
+     * Phaser phaser = new Phaser() {
+     *   protected boolean onAdvance(int phase, int parties) { return false; }
+     * }}</pre>
+     *
+     * @param phase the current phase number on entry to this method,
+     * before this phaser is advanced
+     * @param registeredParties the current number of registered parties
+     * @return {@code true} if this phaser should terminate
+     */
+    protected boolean onAdvance(int phase, int registeredParties) {
+        return registeredParties == 0;
+    }
+
+    /**
+     * Returns a string identifying this phaser, as well as its
+     * state.  The state, in brackets, includes the String {@code
+     * "phase = "} followed by the phase number, {@code "parties = "}
+     * followed by the number of registered parties, and {@code
+     * "arrived = "} followed by the number of arrived parties.
+     *
+     * @return a string identifying this phaser, as well as its state
+     */
+    public String toString() {
+        return stateToString(reconcileState());
+    }
+
+    /**
+     * Implementation of toString and string-based error messages
+     */
+    private String stateToString(long s) {
+        return super.toString() +
+            "[phase = " + phaseOf(s) +
+            " parties = " + partiesOf(s) +
+            " arrived = " + arrivedOf(s) + "]";
+    }
+
+    // Waiting mechanics
+
+    /**
+     * Removes and signals threads from queue for phase.
+     */
+    private void releaseWaiters(int phase) {
+        QNode q;   // first element of queue
+        Thread t;  // its thread
+        AtomicReference<QNode> head = (phase & 1) == 0 ? evenQ : oddQ;
+        while ((q = head.get()) != null &&
+               q.phase != (int)(root.state >>> PHASE_SHIFT)) {
+            if (head.compareAndSet(q, q.next) &&
+                (t = q.thread) != null) {
+                q.thread = null;
+                LockSupport.unpark(t);
+            }
+        }
+    }
+
+    /**
+     * Variant of releaseWaiters that additionally tries to remove any
+     * nodes no longer waiting for advance due to timeout or
+     * interrupt. Currently, nodes are removed only if they are at
+     * head of queue, which suffices to reduce memory footprint in
+     * most usages.
+     *
+     * @return current phase on exit
+     */
+    private int abortWait(int phase) {
+        AtomicReference<QNode> head = (phase & 1) == 0 ? evenQ : oddQ;
+        for (;;) {
+            Thread t;
+            QNode q = head.get();
+            int p = (int)(root.state >>> PHASE_SHIFT);
+            if (q == null || ((t = q.thread) != null && q.phase == p))
+                return p;
+            if (head.compareAndSet(q, q.next) && t != null) {
+                q.thread = null;
+                LockSupport.unpark(t);
+            }
+        }
+    }
+
+    /** The number of CPUs, for spin control */
+    private static final int NCPU = Runtime.getRuntime().availableProcessors();
+
+    /**
+     * The number of times to spin before blocking while waiting for
+     * advance, per arrival while waiting. On multiprocessors, fully
+     * blocking and waking up a large number of threads all at once is
+     * usually a very slow process, so we use rechargeable spins to
+     * avoid it when threads regularly arrive: When a thread in
+     * internalAwaitAdvance notices another arrival before blocking,
+     * and there appear to be enough CPUs available, it spins
+     * SPINS_PER_ARRIVAL more times before blocking. The value trades
+     * off good-citizenship vs big unnecessary slowdowns.
+     */
+    static final int SPINS_PER_ARRIVAL = (NCPU < 2) ? 1 : 1 << 8;
+
+    /**
+     * Possibly blocks and waits for phase to advance unless aborted.
+     * Call only on root phaser.
+     *
+     * @param phase current phase
+     * @param node if non-null, the wait node to track interrupt and timeout;
+     * if null, denotes noninterruptible wait
+     * @return current phase
+     */
+    private int internalAwaitAdvance(int phase, QNode node) {
+        // assert root == this;
+        releaseWaiters(phase-1);          // ensure old queue clean
+        boolean queued = false;           // true when node is enqueued
+        int lastUnarrived = 0;            // to increase spins upon change
+        int spins = SPINS_PER_ARRIVAL;
+        long s;
+        int p;
+        while ((p = (int)((s = state) >>> PHASE_SHIFT)) == phase) {
+            if (node == null) {           // spinning in noninterruptible mode
+                int unarrived = (int)s & UNARRIVED_MASK;
+                if (unarrived != lastUnarrived &&
+                    (lastUnarrived = unarrived) < NCPU)
+                    spins += SPINS_PER_ARRIVAL;
+                boolean interrupted = Thread.interrupted();
+                if (interrupted || --spins < 0) { // need node to record intr
+                    node = new QNode(this, phase, false, false, 0L);
+                    node.wasInterrupted = interrupted;
+                }
+            }
+            else if (node.isReleasable()) // done or aborted
+                break;
+            else if (!queued) {           // push onto queue
+                AtomicReference<QNode> head = (phase & 1) == 0 ? evenQ : oddQ;
+                QNode q = node.next = head.get();
+                if ((q == null || q.phase == phase) &&
+                    (int)(state >>> PHASE_SHIFT) == phase) // avoid stale enq
+                    queued = head.compareAndSet(q, node);
+            }
+            else {
+                try {
+                    ForkJoinPool.managedBlock(node);
+                } catch (InterruptedException ie) {
+                    node.wasInterrupted = true;
+                }
+            }
+        }
+
+        if (node != null) {
+            if (node.thread != null)
+                node.thread = null;       // avoid need for unpark()
+            if (node.wasInterrupted && !node.interruptible)
+                Thread.currentThread().interrupt();
+            if (p == phase && (p = (int)(state >>> PHASE_SHIFT)) == phase)
+                return abortWait(phase); // possibly clean up on abort
+        }
+        releaseWaiters(phase);
+        return p;
+    }
+
+    /**
+     * Wait nodes for Treiber stack representing wait queue
+     */
+    static final class QNode implements ForkJoinPool.ManagedBlocker {
+        final Phaser phaser;
+        final int phase;
+        final boolean interruptible;
+        final boolean timed;
+        boolean wasInterrupted;
+        long nanos;
+        long lastTime;
+        volatile Thread thread; // nulled to cancel wait
+        QNode next;
+
+        QNode(Phaser phaser, int phase, boolean interruptible,
+              boolean timed, long nanos) {
+            this.phaser = phaser;
+            this.phase = phase;
+            this.interruptible = interruptible;
+            this.nanos = nanos;
+            this.timed = timed;
+            this.lastTime = timed ? System.nanoTime() : 0L;
+            thread = Thread.currentThread();
+        }
+
+        public boolean isReleasable() {
+            if (thread == null)
+                return true;
+            if (phaser.getPhase() != phase) {
+                thread = null;
+                return true;
+            }
+            if (Thread.interrupted())
+                wasInterrupted = true;
+            if (wasInterrupted && interruptible) {
+                thread = null;
+                return true;
+            }
+            if (timed) {
+                if (nanos > 0L) {
+                    long now = System.nanoTime();
+                    nanos -= now - lastTime;
+                    lastTime = now;
+                }
+                if (nanos <= 0L) {
+                    thread = null;
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        public boolean block() {
+            if (isReleasable())
+                return true;
+            else if (!timed)
+                LockSupport.park(this);
+            else if (nanos > 0)
+                LockSupport.parkNanos(this, nanos);
+            return isReleasable();
+        }
+    }
+
+    // Unsafe mechanics
+
+    private static final sun.misc.Unsafe UNSAFE;
+    private static final long stateOffset;
+    static {
+        try {
+            UNSAFE = sun.misc.Unsafe.getUnsafe();
+            Class<?> k = Phaser.class;
+            stateOffset = UNSAFE.objectFieldOffset
+                (k.getDeclaredField("state"));
+        } catch (Exception e) {
+            throw new Error(e);
+        }
+    }
+}
diff --git a/luni/src/main/java/java/util/concurrent/PriorityBlockingQueue.java b/luni/src/main/java/java/util/concurrent/PriorityBlockingQueue.java
index cffbe64..26c72eb 100644
--- a/luni/src/main/java/java/util/concurrent/PriorityBlockingQueue.java
+++ b/luni/src/main/java/java/util/concurrent/PriorityBlockingQueue.java
@@ -1,7 +1,7 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent;
@@ -81,7 +81,7 @@ public class PriorityBlockingQueue<E> extends AbstractQueue<E>
      * java.util.PriorityQueue operations within a lock, as was done
      * in a previous version of this class. To maintain
      * interoperability, a plain PriorityQueue is still used during
-     * serialization, which maintains compatibility at the espense of
+     * serialization, which maintains compatibility at the expense of
      * transiently doubling overhead.
      */
 
@@ -139,7 +139,7 @@ public class PriorityBlockingQueue<E> extends AbstractQueue<E>
      * to maintain compatibility with previous versions
      * of this class. Non-null only during serialization/deserialization.
      */
-    private PriorityQueue q;
+    private PriorityQueue<E> q;
 
     /**
      * Creates a {@code PriorityBlockingQueue} with the default
@@ -278,14 +278,13 @@ public class PriorityBlockingQueue<E> extends AbstractQueue<E>
     /**
      * Mechanics for poll().  Call only while holding lock.
      */
-    private E extract() {
-        E result;
+    private E dequeue() {
         int n = size - 1;
         if (n < 0)
-            result = null;
+            return null;
         else {
             Object[] array = queue;
-            result = (E) array[0];
+            E result = (E) array[0];
             E x = (E) array[n];
             array[n] = null;
             Comparator<? super E> cmp = comparator;
@@ -294,8 +293,8 @@ public class PriorityBlockingQueue<E> extends AbstractQueue<E>
             else
                 siftDownUsingComparator(0, x, array, n, cmp);
             size = n;
+            return result;
         }
-        return result;
     }
 
     /**
@@ -312,6 +311,7 @@ public class PriorityBlockingQueue<E> extends AbstractQueue<E>
      * @param k the position to fill
      * @param x the item to insert
      * @param array the heap array
+     * @param n heap size
      */
     private static <T> void siftUpComparable(int k, T x, Object[] array) {
         Comparable<? super T> key = (Comparable<? super T>) x;
@@ -476,7 +476,7 @@ public class PriorityBlockingQueue<E> extends AbstractQueue<E>
      * @param timeout This parameter is ignored as the method never blocks
      * @param unit This parameter is ignored as the method never blocks
      * @return {@code true} (as specified by
-     *  {@link BlockingQueue#offer BlockingQueue.offer})
+     *  {@link BlockingQueue#offer(Object,long,TimeUnit) BlockingQueue.offer})
      * @throws ClassCastException if the specified element cannot be compared
      *         with elements currently in the priority queue according to the
      *         priority queue's ordering
@@ -489,13 +489,11 @@ public class PriorityBlockingQueue<E> extends AbstractQueue<E>
     public E poll() {
         final ReentrantLock lock = this.lock;
         lock.lock();
-        E result;
         try {
-            result = extract();
+            return dequeue();
         } finally {
             lock.unlock();
         }
-        return result;
     }
 
     public E take() throws InterruptedException {
@@ -503,7 +501,7 @@ public class PriorityBlockingQueue<E> extends AbstractQueue<E>
         lock.lockInterruptibly();
         E result;
         try {
-            while ( (result = extract()) == null)
+            while ( (result = dequeue()) == null)
                 notEmpty.await();
         } finally {
             lock.unlock();
@@ -517,7 +515,7 @@ public class PriorityBlockingQueue<E> extends AbstractQueue<E>
         lock.lockInterruptibly();
         E result;
         try {
-            while ( (result = extract()) == null && nanos > 0)
+            while ( (result = dequeue()) == null && nanos > 0)
                 nanos = notEmpty.awaitNanos(nanos);
         } finally {
             lock.unlock();
@@ -528,13 +526,11 @@ public class PriorityBlockingQueue<E> extends AbstractQueue<E>
     public E peek() {
         final ReentrantLock lock = this.lock;
         lock.lock();
-        E result;
         try {
-            result = size > 0 ? (E) queue[0] : null;
+            return (size == 0) ? null : (E) queue[0];
         } finally {
             lock.unlock();
         }
-        return result;
     }
 
     /**
@@ -618,32 +614,28 @@ public class PriorityBlockingQueue<E> extends AbstractQueue<E>
      * @return {@code true} if this queue changed as a result of the call
      */
     public boolean remove(Object o) {
-        boolean removed = false;
         final ReentrantLock lock = this.lock;
         lock.lock();
         try {
             int i = indexOf(o);
-            if (i != -1) {
-                removeAt(i);
-                removed = true;
-            }
+            if (i == -1)
+                return false;
+            removeAt(i);
+            return true;
         } finally {
             lock.unlock();
         }
-        return removed;
     }
 
-
     /**
      * Identity-based version for use in Itr.remove
      */
-    private void removeEQ(Object o) {
+    void removeEQ(Object o) {
         final ReentrantLock lock = this.lock;
         lock.lock();
         try {
             Object[] array = queue;
-            int n = size;
-            for (int i = 0; i < n; i++) {
+            for (int i = 0, n = size; i < n; i++) {
                 if (o == array[i]) {
                     removeAt(i);
                     break;
@@ -663,15 +655,13 @@ public class PriorityBlockingQueue<E> extends AbstractQueue<E>
      * @return {@code true} if this queue contains the specified element
      */
     public boolean contains(Object o) {
-        int index;
         final ReentrantLock lock = this.lock;
         lock.lock();
         try {
-            index = indexOf(o);
+            return indexOf(o) != -1;
         } finally {
             lock.unlock();
         }
-        return index != -1;
     }
 
     /**
@@ -697,7 +687,6 @@ public class PriorityBlockingQueue<E> extends AbstractQueue<E>
         }
     }
 
-
     public String toString() {
         final ReentrantLock lock = this.lock;
         lock.lock();
@@ -708,7 +697,7 @@ public class PriorityBlockingQueue<E> extends AbstractQueue<E>
             StringBuilder sb = new StringBuilder();
             sb.append('[');
             for (int i = 0; i < n; ++i) {
-                E e = (E)queue[i];
+                Object e = queue[i];
                 sb.append(e == this ? "(this Collection)" : e);
                 if (i != n - 1)
                     sb.append(',').append(' ');
@@ -726,23 +715,7 @@ public class PriorityBlockingQueue<E> extends AbstractQueue<E>
      * @throws IllegalArgumentException      {@inheritDoc}
      */
     public int drainTo(Collection<? super E> c) {
-        if (c == null)
-            throw new NullPointerException();
-        if (c == this)
-            throw new IllegalArgumentException();
-        final ReentrantLock lock = this.lock;
-        lock.lock();
-        try {
-            int n = 0;
-            E e;
-            while ( (e = extract()) != null) {
-                c.add(e);
-                ++n;
-            }
-            return n;
-        } finally {
-            lock.unlock();
-        }
+        return drainTo(c, Integer.MAX_VALUE);
     }
 
     /**
@@ -761,11 +734,10 @@ public class PriorityBlockingQueue<E> extends AbstractQueue<E>
         final ReentrantLock lock = this.lock;
         lock.lock();
         try {
-            int n = 0;
-            E e;
-            while (n < maxElements && (e = extract()) != null) {
-                c.add(e);
-                ++n;
+            int n = Math.min(size, maxElements);
+            for (int i = 0; i < n; i++) {
+                c.add((E) queue[0]); // In this order, in case add() throws.
+                dequeue();
             }
             return n;
         } finally {
@@ -813,8 +785,7 @@ public class PriorityBlockingQueue<E> extends AbstractQueue<E>
      * The following code can be used to dump the queue into a newly
      * allocated array of {@code String}:
      *
-     * <pre>
-     *     String[] y = x.toArray(new String[0]);</pre>
+     *  <pre> {@code String[] y = x.toArray(new String[0]);}</pre>
      *
      * Note that {@code toArray(new Object[0])} is identical in function to
      * {@code toArray()}.
@@ -867,7 +838,7 @@ public class PriorityBlockingQueue<E> extends AbstractQueue<E>
      */
     final class Itr implements Iterator<E> {
         final Object[] array; // Array of all elements
-        int cursor;           // index of next element to return;
+        int cursor;           // index of next element to return
         int lastRet;          // index of last element, or -1 if no such
 
         Itr(Object[] array) {
@@ -904,8 +875,8 @@ public class PriorityBlockingQueue<E> extends AbstractQueue<E>
         throws java.io.IOException {
         lock.lock();
         try {
-            int n = size; // avoid zero capacity argument
-            q = new PriorityQueue<E>(n == 0 ? 1 : n, comparator);
+            // avoid zero capacity argument
+            q = new PriorityQueue<E>(Math.max(size, 1), comparator);
             q.addAll(this);
             s.defaultWriteObject();
         } finally {
@@ -933,21 +904,16 @@ public class PriorityBlockingQueue<E> extends AbstractQueue<E>
     }
 
     // Unsafe mechanics
-    private static final sun.misc.Unsafe UNSAFE = sun.misc.Unsafe.getUnsafe();
-    private static final long allocationSpinLockOffset =
-        objectFieldOffset(UNSAFE, "allocationSpinLock",
-                          PriorityBlockingQueue.class);
-
-    static long objectFieldOffset(sun.misc.Unsafe UNSAFE,
-                                  String field, Class<?> klazz) {
+    private static final sun.misc.Unsafe UNSAFE;
+    private static final long allocationSpinLockOffset;
+    static {
         try {
-            return UNSAFE.objectFieldOffset(klazz.getDeclaredField(field));
-        } catch (NoSuchFieldException e) {
-            // Convert Exception to corresponding Error
-            NoSuchFieldError error = new NoSuchFieldError(field);
-            error.initCause(e);
-            throw error;
+            UNSAFE = sun.misc.Unsafe.getUnsafe();
+            Class<?> k = PriorityBlockingQueue.class;
+            allocationSpinLockOffset = UNSAFE.objectFieldOffset
+                (k.getDeclaredField("allocationSpinLock"));
+        } catch (Exception e) {
+            throw new Error(e);
         }
     }
-
 }
diff --git a/luni/src/main/java/java/util/concurrent/RecursiveAction.java b/luni/src/main/java/java/util/concurrent/RecursiveAction.java
new file mode 100644
index 0000000..48066c9
--- /dev/null
+++ b/luni/src/main/java/java/util/concurrent/RecursiveAction.java
@@ -0,0 +1,165 @@
+/*
+ * Written by Doug Lea with assistance from members of JCP JSR-166
+ * Expert Group and released to the public domain, as explained at
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+package java.util.concurrent;
+
+/**
+ * A recursive resultless {@link ForkJoinTask}.  This class
+ * establishes conventions to parameterize resultless actions as
+ * {@code Void} {@code ForkJoinTask}s. Because {@code null} is the
+ * only valid value of type {@code Void}, methods such as {@code join}
+ * always return {@code null} upon completion.
+ *
+ * <p><b>Sample Usages.</b> Here is a simple but complete ForkJoin
+ * sort that sorts a given {@code long[]} array:
+ *
+ *  <pre> {@code
+ * static class SortTask extends RecursiveAction {
+ *   final long[] array; final int lo, hi;
+ *   SortTask(long[] array, int lo, int hi) {
+ *     this.array = array; this.lo = lo; this.hi = hi;
+ *   }
+ *   SortTask(long[] array) { this(array, 0, array.length); }
+ *   protected void compute() {
+ *     if (hi - lo < THRESHOLD)
+ *       sortSequentially(lo, hi);
+ *     else {
+ *       int mid = (lo + hi) >>> 1;
+ *       invokeAll(new SortTask(array, lo, mid),
+ *                 new SortTask(array, mid, hi));
+ *       merge(lo, mid, hi);
+ *     }
+ *   }
+ *   // implementation details follow:
+ *   final static int THRESHOLD = 1000;
+ *   void sortSequentially(int lo, int hi) {
+ *     Arrays.sort(array, lo, hi);
+ *   }
+ *   void merge(int lo, int mid, int hi) {
+ *     long[] buf = Arrays.copyOfRange(array, lo, mid);
+ *     for (int i = 0, j = lo, k = mid; i < buf.length; j++)
+ *       array[j] = (k == hi || buf[i] < array[k]) ?
+ *         buf[i++] : array[k++];
+ *   }
+ * }}</pre>
+ *
+ * You could then sort {@code anArray} by creating {@code new
+ * SortTask(anArray)} and invoking it in a ForkJoinPool.  As a more
+ * concrete simple example, the following task increments each element
+ * of an array:
+ *  <pre> {@code
+ * class IncrementTask extends RecursiveAction {
+ *   final long[] array; final int lo, hi;
+ *   IncrementTask(long[] array, int lo, int hi) {
+ *     this.array = array; this.lo = lo; this.hi = hi;
+ *   }
+ *   protected void compute() {
+ *     if (hi - lo < THRESHOLD) {
+ *       for (int i = lo; i < hi; ++i)
+ *         array[i]++;
+ *     }
+ *     else {
+ *       int mid = (lo + hi) >>> 1;
+ *       invokeAll(new IncrementTask(array, lo, mid),
+ *                 new IncrementTask(array, mid, hi));
+ *     }
+ *   }
+ * }}</pre>
+ *
+ * <p>The following example illustrates some refinements and idioms
+ * that may lead to better performance: RecursiveActions need not be
+ * fully recursive, so long as they maintain the basic
+ * divide-and-conquer approach. Here is a class that sums the squares
+ * of each element of a double array, by subdividing out only the
+ * right-hand-sides of repeated divisions by two, and keeping track of
+ * them with a chain of {@code next} references. It uses a dynamic
+ * threshold based on method {@code getSurplusQueuedTaskCount}, but
+ * counterbalances potential excess partitioning by directly
+ * performing leaf actions on unstolen tasks rather than further
+ * subdividing.
+ *
+ *  <pre> {@code
+ * double sumOfSquares(ForkJoinPool pool, double[] array) {
+ *   int n = array.length;
+ *   Applyer a = new Applyer(array, 0, n, null);
+ *   pool.invoke(a);
+ *   return a.result;
+ * }
+ *
+ * class Applyer extends RecursiveAction {
+ *   final double[] array;
+ *   final int lo, hi;
+ *   double result;
+ *   Applyer next; // keeps track of right-hand-side tasks
+ *   Applyer(double[] array, int lo, int hi, Applyer next) {
+ *     this.array = array; this.lo = lo; this.hi = hi;
+ *     this.next = next;
+ *   }
+ *
+ *   double atLeaf(int l, int h) {
+ *     double sum = 0;
+ *     for (int i = l; i < h; ++i) // perform leftmost base step
+ *       sum += array[i] * array[i];
+ *     return sum;
+ *   }
+ *
+ *   protected void compute() {
+ *     int l = lo;
+ *     int h = hi;
+ *     Applyer right = null;
+ *     while (h - l > 1 && getSurplusQueuedTaskCount() <= 3) {
+ *        int mid = (l + h) >>> 1;
+ *        right = new Applyer(array, mid, h, right);
+ *        right.fork();
+ *        h = mid;
+ *     }
+ *     double sum = atLeaf(l, h);
+ *     while (right != null) {
+ *        if (right.tryUnfork()) // directly calculate if not stolen
+ *          sum += right.atLeaf(right.lo, right.hi);
+ *       else {
+ *          right.join();
+ *          sum += right.result;
+ *        }
+ *        right = right.next;
+ *      }
+ *     result = sum;
+ *   }
+ * }}</pre>
+ *
+ * @since 1.7
+ * @hide
+ * @author Doug Lea
+ */
+public abstract class RecursiveAction extends ForkJoinTask<Void> {
+    private static final long serialVersionUID = 5232453952276485070L;
+
+    /**
+     * The main computation performed by this task.
+     */
+    protected abstract void compute();
+
+    /**
+     * Always returns {@code null}.
+     *
+     * @return {@code null} always
+     */
+    public final Void getRawResult() { return null; }
+
+    /**
+     * Requires null completion value.
+     */
+    protected final void setRawResult(Void mustBeNull) { }
+
+    /**
+     * Implements execution conventions for RecursiveActions.
+     */
+    protected final boolean exec() {
+        compute();
+        return true;
+    }
+
+}
diff --git a/luni/src/main/java/java/util/concurrent/RecursiveTask.java b/luni/src/main/java/java/util/concurrent/RecursiveTask.java
new file mode 100644
index 0000000..5e17280
--- /dev/null
+++ b/luni/src/main/java/java/util/concurrent/RecursiveTask.java
@@ -0,0 +1,69 @@
+/*
+ * Written by Doug Lea with assistance from members of JCP JSR-166
+ * Expert Group and released to the public domain, as explained at
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+package java.util.concurrent;
+
+/**
+ * A recursive result-bearing {@link ForkJoinTask}.
+ *
+ * <p>For a classic example, here is a task computing Fibonacci numbers:
+ *
+ *  <pre> {@code
+ * class Fibonacci extends RecursiveTask<Integer> {
+ *   final int n;
+ *   Fibonacci(int n) { this.n = n; }
+ *   Integer compute() {
+ *     if (n <= 1)
+ *        return n;
+ *     Fibonacci f1 = new Fibonacci(n - 1);
+ *     f1.fork();
+ *     Fibonacci f2 = new Fibonacci(n - 2);
+ *     return f2.compute() + f1.join();
+ *   }
+ * }}</pre>
+ *
+ * However, besides being a dumb way to compute Fibonacci functions
+ * (there is a simple fast linear algorithm that you'd use in
+ * practice), this is likely to perform poorly because the smallest
+ * subtasks are too small to be worthwhile splitting up. Instead, as
+ * is the case for nearly all fork/join applications, you'd pick some
+ * minimum granularity size (for example 10 here) for which you always
+ * sequentially solve rather than subdividing.
+ *
+ * @since 1.7
+ * @hide
+ * @author Doug Lea
+ */
+public abstract class RecursiveTask<V> extends ForkJoinTask<V> {
+    private static final long serialVersionUID = 5232453952276485270L;
+
+    /**
+     * The result of the computation.
+     */
+    V result;
+
+    /**
+     * The main computation performed by this task.
+     */
+    protected abstract V compute();
+
+    public final V getRawResult() {
+        return result;
+    }
+
+    protected final void setRawResult(V value) {
+        result = value;
+    }
+
+    /**
+     * Implements execution conventions for RecursiveTask.
+     */
+    protected final boolean exec() {
+        result = compute();
+        return true;
+    }
+
+}
diff --git a/luni/src/main/java/java/util/concurrent/RejectedExecutionException.java b/luni/src/main/java/java/util/concurrent/RejectedExecutionException.java
index 30b043d..f0005d1 100644
--- a/luni/src/main/java/java/util/concurrent/RejectedExecutionException.java
+++ b/luni/src/main/java/java/util/concurrent/RejectedExecutionException.java
@@ -1,7 +1,7 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent;
@@ -49,8 +49,8 @@ public class RejectedExecutionException extends RuntimeException {
 
     /**
      * Constructs a <tt>RejectedExecutionException</tt> with the
-     * specified cause.  The detail message is set to: <pre> (cause ==
-     * null ? null : cause.toString())</pre> (which typically contains
+     * specified cause.  The detail message is set to {@code (cause ==
+     * null ? null : cause.toString())} (which typically contains
      * the class and detail message of <tt>cause</tt>).
      *
      * @param  cause the cause (which is saved for later retrieval by the
diff --git a/luni/src/main/java/java/util/concurrent/RejectedExecutionHandler.java b/luni/src/main/java/java/util/concurrent/RejectedExecutionHandler.java
index 417a27c..8c000ea 100644
--- a/luni/src/main/java/java/util/concurrent/RejectedExecutionHandler.java
+++ b/luni/src/main/java/java/util/concurrent/RejectedExecutionHandler.java
@@ -1,7 +1,7 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent;
diff --git a/luni/src/main/java/java/util/concurrent/RunnableFuture.java b/luni/src/main/java/java/util/concurrent/RunnableFuture.java
index d74211d..2d6d52c 100644
--- a/luni/src/main/java/java/util/concurrent/RunnableFuture.java
+++ b/luni/src/main/java/java/util/concurrent/RunnableFuture.java
@@ -1,7 +1,7 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent;
diff --git a/luni/src/main/java/java/util/concurrent/RunnableScheduledFuture.java b/luni/src/main/java/java/util/concurrent/RunnableScheduledFuture.java
index 0e8cc32..fbb995c 100644
--- a/luni/src/main/java/java/util/concurrent/RunnableScheduledFuture.java
+++ b/luni/src/main/java/java/util/concurrent/RunnableScheduledFuture.java
@@ -1,7 +1,7 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent;
diff --git a/luni/src/main/java/java/util/concurrent/ScheduledExecutorService.java b/luni/src/main/java/java/util/concurrent/ScheduledExecutorService.java
index 6cb4e27..71e57ed 100644
--- a/luni/src/main/java/java/util/concurrent/ScheduledExecutorService.java
+++ b/luni/src/main/java/java/util/concurrent/ScheduledExecutorService.java
@@ -1,12 +1,10 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent;
-import java.util.concurrent.atomic.*;
-import java.util.*;
 
 /**
  * An {@link ExecutorService} that can schedule commands to run after a given
diff --git a/luni/src/main/java/java/util/concurrent/ScheduledFuture.java b/luni/src/main/java/java/util/concurrent/ScheduledFuture.java
index 239d681..3745cb0 100644
--- a/luni/src/main/java/java/util/concurrent/ScheduledFuture.java
+++ b/luni/src/main/java/java/util/concurrent/ScheduledFuture.java
@@ -1,7 +1,7 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent;
diff --git a/luni/src/main/java/java/util/concurrent/ScheduledThreadPoolExecutor.java b/luni/src/main/java/java/util/concurrent/ScheduledThreadPoolExecutor.java
index c2eaedf..e41f0c3 100644
--- a/luni/src/main/java/java/util/concurrent/ScheduledThreadPoolExecutor.java
+++ b/luni/src/main/java/java/util/concurrent/ScheduledThreadPoolExecutor.java
@@ -1,16 +1,19 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent;
-import java.util.concurrent.atomic.*;
-import java.util.concurrent.locks.*;
+import static java.util.concurrent.TimeUnit.NANOSECONDS;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.locks.Condition;
+import java.util.concurrent.locks.ReentrantLock;
 import java.util.*;
 
 // BEGIN android-note
-// Omit class-level docs on setRemoveOnCancelPolicy()
+// omit class-level docs on setRemoveOnCancelPolicy()
+// removed security manager docs
 // END android-note
 
 /**
@@ -138,7 +141,7 @@ public class ScheduledThreadPoolExecutor
      * Sequence number to break scheduling ties, and in turn to
      * guarantee FIFO order among tied entries.
      */
-    private static final AtomicLong sequencer = new AtomicLong(0);
+    private static final AtomicLong sequencer = new AtomicLong();
 
     /**
      * Returns current nanosecond time.
@@ -203,11 +206,11 @@ public class ScheduledThreadPoolExecutor
         }
 
         public long getDelay(TimeUnit unit) {
-            return unit.convert(time - now(), TimeUnit.NANOSECONDS);
+            return unit.convert(time - now(), NANOSECONDS);
         }
 
         public int compareTo(Delayed other) {
-            if (other == this) // compare zero ONLY if same object
+            if (other == this) // compare zero if same object
                 return 0;
             if (other instanceof ScheduledFutureTask) {
                 ScheduledFutureTask<?> x = (ScheduledFutureTask<?>)other;
@@ -221,9 +224,9 @@ public class ScheduledThreadPoolExecutor
                 else
                     return 1;
             }
-            long d = (getDelay(TimeUnit.NANOSECONDS) -
-                      other.getDelay(TimeUnit.NANOSECONDS));
-            return (d == 0) ? 0 : ((d < 0) ? -1 : 1);
+            long diff = (getDelay(NANOSECONDS) -
+                         other.getDelay(NANOSECONDS));
+            return (diff < 0) ? -1 : (diff > 0) ? 1 : 0;
         }
 
         /**
@@ -302,7 +305,7 @@ public class ScheduledThreadPoolExecutor
                 remove(task))
                 task.cancel(false);
             else
-                prestartCoreThread();
+                ensurePrestart();
         }
     }
 
@@ -318,7 +321,7 @@ public class ScheduledThreadPoolExecutor
             if (!canRunInCurrentRunState(true) && remove(task))
                 task.cancel(false);
             else
-                prestartCoreThread();
+                ensurePrestart();
         }
     }
 
@@ -396,7 +399,7 @@ public class ScheduledThreadPoolExecutor
      * @throws IllegalArgumentException if {@code corePoolSize < 0}
      */
     public ScheduledThreadPoolExecutor(int corePoolSize) {
-        super(corePoolSize, Integer.MAX_VALUE, 0, TimeUnit.NANOSECONDS,
+        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
               new DelayedWorkQueue());
     }
 
@@ -413,7 +416,7 @@ public class ScheduledThreadPoolExecutor
      */
     public ScheduledThreadPoolExecutor(int corePoolSize,
                                        ThreadFactory threadFactory) {
-        super(corePoolSize, Integer.MAX_VALUE, 0, TimeUnit.NANOSECONDS,
+        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
               new DelayedWorkQueue(), threadFactory);
     }
 
@@ -430,7 +433,7 @@ public class ScheduledThreadPoolExecutor
      */
     public ScheduledThreadPoolExecutor(int corePoolSize,
                                        RejectedExecutionHandler handler) {
-        super(corePoolSize, Integer.MAX_VALUE, 0, TimeUnit.NANOSECONDS,
+        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
               new DelayedWorkQueue(), handler);
     }
 
@@ -451,7 +454,7 @@ public class ScheduledThreadPoolExecutor
     public ScheduledThreadPoolExecutor(int corePoolSize,
                                        ThreadFactory threadFactory,
                                        RejectedExecutionHandler handler) {
-        super(corePoolSize, Integer.MAX_VALUE, 0, TimeUnit.NANOSECONDS,
+        super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,
               new DelayedWorkQueue(), threadFactory, handler);
     }
 
@@ -480,7 +483,7 @@ public class ScheduledThreadPoolExecutor
     private long overflowFree(long delay) {
         Delayed head = (Delayed) super.getQueue().peek();
         if (head != null) {
-            long headDelay = head.getDelay(TimeUnit.NANOSECONDS);
+            long headDelay = head.getDelay(NANOSECONDS);
             if (headDelay < 0 && (delay - headDelay < 0))
                 delay = Long.MAX_VALUE + headDelay;
         }
@@ -588,7 +591,7 @@ public class ScheduledThreadPoolExecutor
      * @throws NullPointerException {@inheritDoc}
      */
     public void execute(Runnable command) {
-        schedule(command, 0, TimeUnit.NANOSECONDS);
+        schedule(command, 0, NANOSECONDS);
     }
 
     // Override AbstractExecutorService methods
@@ -598,7 +601,7 @@ public class ScheduledThreadPoolExecutor
      * @throws NullPointerException       {@inheritDoc}
      */
     public Future<?> submit(Runnable task) {
-        return schedule(task, 0, TimeUnit.NANOSECONDS);
+        return schedule(task, 0, NANOSECONDS);
     }
 
     /**
@@ -606,8 +609,7 @@ public class ScheduledThreadPoolExecutor
      * @throws NullPointerException       {@inheritDoc}
      */
     public <T> Future<T> submit(Runnable task, T result) {
-        return schedule(Executors.callable(task, result),
-                        0, TimeUnit.NANOSECONDS);
+        return schedule(Executors.callable(task, result), 0, NANOSECONDS);
     }
 
     /**
@@ -615,7 +617,7 @@ public class ScheduledThreadPoolExecutor
      * @throws NullPointerException       {@inheritDoc}
      */
     public <T> Future<T> submit(Callable<T> task) {
-        return schedule(task, 0, TimeUnit.NANOSECONDS);
+        return schedule(task, 0, NANOSECONDS);
     }
 
     /**
@@ -690,8 +692,9 @@ public class ScheduledThreadPoolExecutor
      * @param value if {@code true}, remove on cancellation, else don't
      * @see #getRemoveOnCancelPolicy
      * @since 1.7
+     * @hide
      */
-    /*public*/ void setRemoveOnCancelPolicy(boolean value) { // android-changed
+    public void setRemoveOnCancelPolicy(boolean value) {
         removeOnCancel = value;
     }
 
@@ -704,8 +707,9 @@ public class ScheduledThreadPoolExecutor
      *         from the queue
      * @see #setRemoveOnCancelPolicy
      * @since 1.7
+     * @hide
      */
-    /*public*/ boolean getRemoveOnCancelPolicy() { // android-changed
+    public boolean getRemoveOnCancelPolicy() {
         return removeOnCancel;
     }
 
@@ -724,8 +728,6 @@ public class ScheduledThreadPoolExecutor
      * ContinueExistingPeriodicTasksAfterShutdownPolicy} has been set
      * {@code true}, future executions of existing periodic tasks will
      * be cancelled.
-     *
-     * @throws SecurityException {@inheritDoc}
      */
     public void shutdown() {
         super.shutdown();
@@ -750,7 +752,6 @@ public class ScheduledThreadPoolExecutor
      *         including those tasks submitted using {@code execute},
      *         which are for scheduling purposes used as the basis of a
      *         zero-delay {@code ScheduledFuture}.
-     * @throws SecurityException {@inheritDoc}
      */
     public List<Runnable> shutdownNow() {
         return super.shutdownNow();
@@ -803,8 +804,8 @@ public class ScheduledThreadPoolExecutor
          */
 
         private static final int INITIAL_CAPACITY = 16;
-        private RunnableScheduledFuture[] queue =
-            new RunnableScheduledFuture[INITIAL_CAPACITY];
+        private RunnableScheduledFuture<?>[] queue =
+            new RunnableScheduledFuture<?>[INITIAL_CAPACITY];
         private final ReentrantLock lock = new ReentrantLock();
         private int size = 0;
 
@@ -835,7 +836,7 @@ public class ScheduledThreadPoolExecutor
         /**
          * Set f's heapIndex if it is a ScheduledFutureTask.
          */
-        private void setIndex(RunnableScheduledFuture f, int idx) {
+        private void setIndex(RunnableScheduledFuture<?> f, int idx) {
             if (f instanceof ScheduledFutureTask)
                 ((ScheduledFutureTask)f).heapIndex = idx;
         }
@@ -844,10 +845,10 @@ public class ScheduledThreadPoolExecutor
          * Sift element added at bottom up to its heap-ordered spot.
          * Call only when holding lock.
          */
-        private void siftUp(int k, RunnableScheduledFuture key) {
+        private void siftUp(int k, RunnableScheduledFuture<?> key) {
             while (k > 0) {
                 int parent = (k - 1) >>> 1;
-                RunnableScheduledFuture e = queue[parent];
+                RunnableScheduledFuture<?> e = queue[parent];
                 if (key.compareTo(e) >= 0)
                     break;
                 queue[k] = e;
@@ -862,11 +863,11 @@ public class ScheduledThreadPoolExecutor
          * Sift element added at top down to its heap-ordered spot.
          * Call only when holding lock.
          */
-        private void siftDown(int k, RunnableScheduledFuture key) {
+        private void siftDown(int k, RunnableScheduledFuture<?> key) {
             int half = size >>> 1;
             while (k < half) {
                 int child = (k << 1) + 1;
-                RunnableScheduledFuture c = queue[child];
+                RunnableScheduledFuture<?> c = queue[child];
                 int right = child + 1;
                 if (right < size && c.compareTo(queue[right]) > 0)
                     c = queue[child = right];
@@ -931,7 +932,7 @@ public class ScheduledThreadPoolExecutor
 
                 setIndex(queue[i], -1);
                 int s = --size;
-                RunnableScheduledFuture replacement = queue[s];
+                RunnableScheduledFuture<?> replacement = queue[s];
                 queue[s] = null;
                 if (s != i) {
                     siftDown(i, replacement);
@@ -962,7 +963,7 @@ public class ScheduledThreadPoolExecutor
             return Integer.MAX_VALUE;
         }
 
-        public RunnableScheduledFuture peek() {
+        public RunnableScheduledFuture<?> peek() {
             final ReentrantLock lock = this.lock;
             lock.lock();
             try {
@@ -975,7 +976,7 @@ public class ScheduledThreadPoolExecutor
         public boolean offer(Runnable x) {
             if (x == null)
                 throw new NullPointerException();
-            RunnableScheduledFuture e = (RunnableScheduledFuture)x;
+            RunnableScheduledFuture<?> e = (RunnableScheduledFuture<?>)x;
             final ReentrantLock lock = this.lock;
             lock.lock();
             try {
@@ -1017,9 +1018,9 @@ public class ScheduledThreadPoolExecutor
          * holding lock.
          * @param f the task to remove and return
          */
-        private RunnableScheduledFuture finishPoll(RunnableScheduledFuture f) {
+        private RunnableScheduledFuture<?> finishPoll(RunnableScheduledFuture<?> f) {
             int s = --size;
-            RunnableScheduledFuture x = queue[s];
+            RunnableScheduledFuture<?> x = queue[s];
             queue[s] = null;
             if (s != 0)
                 siftDown(0, x);
@@ -1027,12 +1028,12 @@ public class ScheduledThreadPoolExecutor
             return f;
         }
 
-        public RunnableScheduledFuture poll() {
+        public RunnableScheduledFuture<?> poll() {
             final ReentrantLock lock = this.lock;
             lock.lock();
             try {
-                RunnableScheduledFuture first = queue[0];
-                if (first == null || first.getDelay(TimeUnit.NANOSECONDS) > 0)
+                RunnableScheduledFuture<?> first = queue[0];
+                if (first == null || first.getDelay(NANOSECONDS) > 0)
                     return null;
                 else
                     return finishPoll(first);
@@ -1041,16 +1042,16 @@ public class ScheduledThreadPoolExecutor
             }
         }
 
-        public RunnableScheduledFuture take() throws InterruptedException {
+        public RunnableScheduledFuture<?> take() throws InterruptedException {
             final ReentrantLock lock = this.lock;
             lock.lockInterruptibly();
             try {
                 for (;;) {
-                    RunnableScheduledFuture first = queue[0];
+                    RunnableScheduledFuture<?> first = queue[0];
                     if (first == null)
                         available.await();
                     else {
-                        long delay = first.getDelay(TimeUnit.NANOSECONDS);
+                        long delay = first.getDelay(NANOSECONDS);
                         if (delay <= 0)
                             return finishPoll(first);
                         else if (leader != null)
@@ -1074,21 +1075,21 @@ public class ScheduledThreadPoolExecutor
             }
         }
 
-        public RunnableScheduledFuture poll(long timeout, TimeUnit unit)
+        public RunnableScheduledFuture<?> poll(long timeout, TimeUnit unit)
             throws InterruptedException {
             long nanos = unit.toNanos(timeout);
             final ReentrantLock lock = this.lock;
             lock.lockInterruptibly();
             try {
                 for (;;) {
-                    RunnableScheduledFuture first = queue[0];
+                    RunnableScheduledFuture<?> first = queue[0];
                     if (first == null) {
                         if (nanos <= 0)
                             return null;
                         else
                             nanos = available.awaitNanos(nanos);
                     } else {
-                        long delay = first.getDelay(TimeUnit.NANOSECONDS);
+                        long delay = first.getDelay(NANOSECONDS);
                         if (delay <= 0)
                             return finishPoll(first);
                         if (nanos <= 0)
@@ -1120,7 +1121,7 @@ public class ScheduledThreadPoolExecutor
             lock.lock();
             try {
                 for (int i = 0; i < size; i++) {
-                    RunnableScheduledFuture t = queue[i];
+                    RunnableScheduledFuture<?> t = queue[i];
                     if (t != null) {
                         queue[i] = null;
                         setIndex(t, -1);
@@ -1133,14 +1134,14 @@ public class ScheduledThreadPoolExecutor
         }
 
         /**
-         * Return and remove first element only if it is expired.
+         * Return first element only if it is expired.
          * Used only by drainTo.  Call only when holding lock.
          */
-        private RunnableScheduledFuture pollExpired() {
-            RunnableScheduledFuture first = queue[0];
-            if (first == null || first.getDelay(TimeUnit.NANOSECONDS) > 0)
-                return null;
-            return finishPoll(first);
+        private RunnableScheduledFuture<?> peekExpired() {
+            // assert lock.isHeldByCurrentThread();
+            RunnableScheduledFuture<?> first = queue[0];
+            return (first == null || first.getDelay(NANOSECONDS) > 0) ?
+                null : first;
         }
 
         public int drainTo(Collection<? super Runnable> c) {
@@ -1151,10 +1152,11 @@ public class ScheduledThreadPoolExecutor
             final ReentrantLock lock = this.lock;
             lock.lock();
             try {
-                RunnableScheduledFuture first;
+                RunnableScheduledFuture<?> first;
                 int n = 0;
-                while ((first = pollExpired()) != null) {
-                    c.add(first);
+                while ((first = peekExpired()) != null) {
+                    c.add(first);   // In this order, in case add() throws.
+                    finishPoll(first);
                     ++n;
                 }
                 return n;
@@ -1173,10 +1175,11 @@ public class ScheduledThreadPoolExecutor
             final ReentrantLock lock = this.lock;
             lock.lock();
             try {
-                RunnableScheduledFuture first;
+                RunnableScheduledFuture<?> first;
                 int n = 0;
-                while (n < maxElements && (first = pollExpired()) != null) {
-                    c.add(first);
+                while (n < maxElements && (first = peekExpired()) != null) {
+                    c.add(first);   // In this order, in case add() throws.
+                    finishPoll(first);
                     ++n;
                 }
                 return n;
diff --git a/luni/src/main/java/java/util/concurrent/Semaphore.java b/luni/src/main/java/java/util/concurrent/Semaphore.java
index 62dea1a..bf2524c 100644
--- a/luni/src/main/java/java/util/concurrent/Semaphore.java
+++ b/luni/src/main/java/java/util/concurrent/Semaphore.java
@@ -1,13 +1,12 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent;
 import java.util.*;
 import java.util.concurrent.locks.*;
-import java.util.concurrent.atomic.*;
 
 /**
  * A counting semaphore.  Conceptually, a semaphore maintains a set of
@@ -20,7 +19,7 @@ import java.util.concurrent.atomic.*;
  * <p>Semaphores are often used to restrict the number of threads than can
  * access some (physical or logical) resource. For example, here is
  * a class that uses a semaphore to control access to a pool of items:
- * <pre>
+ *  <pre> {@code
  * class Pool {
  *   private static final int MAX_AVAILABLE = 100;
  *   private final Semaphore available = new Semaphore(MAX_AVAILABLE, true);
@@ -62,9 +61,7 @@ import java.util.concurrent.atomic.*;
  *     }
  *     return false;
  *   }
- *
- * }
- * </pre>
+ * }}</pre>
  *
  * <p>Before obtaining an item each thread must acquire a permit from
  * the semaphore, guaranteeing that an item is available for use. When
diff --git a/luni/src/main/java/java/util/concurrent/SynchronousQueue.java b/luni/src/main/java/java/util/concurrent/SynchronousQueue.java
index 51d40c0..b05ae0a 100644
--- a/luni/src/main/java/java/util/concurrent/SynchronousQueue.java
+++ b/luni/src/main/java/java/util/concurrent/SynchronousQueue.java
@@ -2,13 +2,12 @@
  * Written by Doug Lea, Bill Scherer, and Michael Scott with
  * assistance from members of JCP JSR-166 Expert Group and released to
  * the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent;
 import java.util.concurrent.locks.*;
 import java.util.*;
-import libcore.util.EmptyArray;
 
 // BEGIN android-note
 // removed link to collections framework docs
@@ -250,12 +249,22 @@ public class SynchronousQueue<E> extends AbstractQueue<E>
             }
 
             // Unsafe mechanics
-            private static final sun.misc.Unsafe UNSAFE = sun.misc.Unsafe.getUnsafe();
-            private static final long nextOffset =
-                objectFieldOffset(UNSAFE, "next", SNode.class);
-            private static final long matchOffset =
-                objectFieldOffset(UNSAFE, "match", SNode.class);
-
+            private static final sun.misc.Unsafe UNSAFE;
+            private static final long matchOffset;
+            private static final long nextOffset;
+
+            static {
+                try {
+                    UNSAFE = sun.misc.Unsafe.getUnsafe();
+                    Class<?> k = SNode.class;
+                    matchOffset = UNSAFE.objectFieldOffset
+                        (k.getDeclaredField("match"));
+                    nextOffset = UNSAFE.objectFieldOffset
+                        (k.getDeclaredField("next"));
+                } catch (Exception e) {
+                    throw new Error(e);
+                }
+            }
         }
 
         /** The head (top) of the stack */
@@ -393,7 +402,6 @@ public class SynchronousQueue<E> extends AbstractQueue<E>
              */
             long lastTime = timed ? System.nanoTime() : 0;
             Thread w = Thread.currentThread();
-            SNode h = head;
             int spins = (shouldSpin(s) ?
                          (timed ? maxTimedSpins : maxUntimedSpins) : 0);
             for (;;) {
@@ -469,10 +477,18 @@ public class SynchronousQueue<E> extends AbstractQueue<E>
         }
 
         // Unsafe mechanics
-        private static final sun.misc.Unsafe UNSAFE = sun.misc.Unsafe.getUnsafe();
-        private static final long headOffset =
-            objectFieldOffset(UNSAFE, "head", TransferStack.class);
-
+        private static final sun.misc.Unsafe UNSAFE;
+        private static final long headOffset;
+        static {
+            try {
+                UNSAFE = sun.misc.Unsafe.getUnsafe();
+                Class<?> k = TransferStack.class;
+                headOffset = UNSAFE.objectFieldOffset
+                    (k.getDeclaredField("head"));
+            } catch (Exception e) {
+                throw new Error(e);
+            }
+        }
     }
 
     /** Dual Queue */
@@ -529,11 +545,22 @@ public class SynchronousQueue<E> extends AbstractQueue<E>
             }
 
             // Unsafe mechanics
-            private static final sun.misc.Unsafe UNSAFE = sun.misc.Unsafe.getUnsafe();
-            private static final long nextOffset =
-                objectFieldOffset(UNSAFE, "next", QNode.class);
-            private static final long itemOffset =
-                objectFieldOffset(UNSAFE, "item", QNode.class);
+            private static final sun.misc.Unsafe UNSAFE;
+            private static final long itemOffset;
+            private static final long nextOffset;
+
+            static {
+                try {
+                    UNSAFE = sun.misc.Unsafe.getUnsafe();
+                    Class<?> k = QNode.class;
+                    itemOffset = UNSAFE.objectFieldOffset
+                        (k.getDeclaredField("item"));
+                    nextOffset = UNSAFE.objectFieldOffset
+                        (k.getDeclaredField("next"));
+                } catch (Exception e) {
+                    throw new Error(e);
+                }
+            }
         }
 
         /** Head of queue */
@@ -762,15 +789,24 @@ public class SynchronousQueue<E> extends AbstractQueue<E>
             }
         }
 
-        // unsafe mechanics
-        private static final sun.misc.Unsafe UNSAFE = sun.misc.Unsafe.getUnsafe();
-        private static final long headOffset =
-            objectFieldOffset(UNSAFE, "head", TransferQueue.class);
-        private static final long tailOffset =
-            objectFieldOffset(UNSAFE, "tail", TransferQueue.class);
-        private static final long cleanMeOffset =
-            objectFieldOffset(UNSAFE, "cleanMe", TransferQueue.class);
-
+        private static final sun.misc.Unsafe UNSAFE;
+        private static final long headOffset;
+        private static final long tailOffset;
+        private static final long cleanMeOffset;
+        static {
+            try {
+                UNSAFE = sun.misc.Unsafe.getUnsafe();
+                Class<?> k = TransferQueue.class;
+                headOffset = UNSAFE.objectFieldOffset
+                    (k.getDeclaredField("head"));
+                tailOffset = UNSAFE.objectFieldOffset
+                    (k.getDeclaredField("tail"));
+                cleanMeOffset = UNSAFE.objectFieldOffset
+                    (k.getDeclaredField("cleanMe"));
+            } catch (Exception e) {
+                throw new Error(e);
+            }
+        }
     }
 
     /**
@@ -998,8 +1034,19 @@ public class SynchronousQueue<E> extends AbstractQueue<E>
      *
      * @return an empty iterator
      */
+    @SuppressWarnings("unchecked")
     public Iterator<E> iterator() {
-        return Collections.<E>emptySet().iterator(); // android-changed
+        return (Iterator<E>) EmptyIterator.EMPTY_ITERATOR;
+    }
+
+    // Replicated from a previous version of Collections
+    private static class EmptyIterator<E> implements Iterator<E> {
+        static final EmptyIterator<Object> EMPTY_ITERATOR
+            = new EmptyIterator<Object>();
+
+        public boolean hasNext() { return false; }
+        public E next() { throw new NoSuchElementException(); }
+        public void remove() { throw new IllegalStateException(); }
     }
 
     /**
@@ -1007,7 +1054,7 @@ public class SynchronousQueue<E> extends AbstractQueue<E>
      * @return a zero-length array
      */
     public Object[] toArray() {
-        return EmptyArray.OBJECT; // android-changed
+        return new Object[0];
     }
 
     /**
@@ -1036,8 +1083,7 @@ public class SynchronousQueue<E> extends AbstractQueue<E>
         if (c == this)
             throw new IllegalArgumentException();
         int n = 0;
-        E e;
-        while ( (e = poll()) != null) {
+        for (E e; (e = poll()) != null;) {
             c.add(e);
             ++n;
         }
@@ -1056,8 +1102,7 @@ public class SynchronousQueue<E> extends AbstractQueue<E>
         if (c == this)
             throw new IllegalArgumentException();
         int n = 0;
-        E e;
-        while (n < maxElements && (e = poll()) != null) {
+        for (E e; n < maxElements && (e = poll()) != null;) {
             c.add(e);
             ++n;
         }
@@ -1084,7 +1129,7 @@ public class SynchronousQueue<E> extends AbstractQueue<E>
     private WaitQueue waitingConsumers;
 
     /**
-     * Save the state to a stream (that is, serialize it).
+     * Saves the state to a stream (that is, serializes it).
      *
      * @param s the stream
      */
diff --git a/luni/src/main/java/java/util/concurrent/ThreadFactory.java b/luni/src/main/java/java/util/concurrent/ThreadFactory.java
index 2f0fb1a..d1a4eb6 100644
--- a/luni/src/main/java/java/util/concurrent/ThreadFactory.java
+++ b/luni/src/main/java/java/util/concurrent/ThreadFactory.java
@@ -1,7 +1,7 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent;
@@ -13,13 +13,12 @@ package java.util.concurrent;
  *
  * <p>
  * The simplest implementation of this interface is just:
- * <pre>
+ *  <pre> {@code
  * class SimpleThreadFactory implements ThreadFactory {
  *   public Thread newThread(Runnable r) {
  *     return new Thread(r);
  *   }
- * }
- * </pre>
+ * }}</pre>
  *
  * The {@link Executors#defaultThreadFactory} method provides a more
  * useful simple implementation, that sets the created thread context
diff --git a/luni/src/main/java/java/util/concurrent/ThreadLocalRandom.java b/luni/src/main/java/java/util/concurrent/ThreadLocalRandom.java
new file mode 100644
index 0000000..a559321
--- /dev/null
+++ b/luni/src/main/java/java/util/concurrent/ThreadLocalRandom.java
@@ -0,0 +1,198 @@
+/*
+ * Written by Doug Lea with assistance from members of JCP JSR-166
+ * Expert Group and released to the public domain, as explained at
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+package java.util.concurrent;
+
+import java.util.Random;
+
+/**
+ * A random number generator isolated to the current thread.  Like the
+ * global {@link java.util.Random} generator used by the {@link
+ * java.lang.Math} class, a {@code ThreadLocalRandom} is initialized
+ * with an internally generated seed that may not otherwise be
+ * modified. When applicable, use of {@code ThreadLocalRandom} rather
+ * than shared {@code Random} objects in concurrent programs will
+ * typically encounter much less overhead and contention.  Use of
+ * {@code ThreadLocalRandom} is particularly appropriate when multiple
+ * tasks (for example, each a {@link ForkJoinTask}) use random numbers
+ * in parallel in thread pools.
+ *
+ * <p>Usages of this class should typically be of the form:
+ * {@code ThreadLocalRandom.current().nextX(...)} (where
+ * {@code X} is {@code Int}, {@code Long}, etc).
+ * When all usages are of this form, it is never possible to
+ * accidently share a {@code ThreadLocalRandom} across multiple threads.
+ *
+ * <p>This class also provides additional commonly used bounded random
+ * generation methods.
+ *
+ * @since 1.7
+ * @hide
+ * @author Doug Lea
+ */
+public class ThreadLocalRandom extends Random {
+    // same constants as Random, but must be redeclared because private
+    private static final long multiplier = 0x5DEECE66DL;
+    private static final long addend = 0xBL;
+    private static final long mask = (1L << 48) - 1;
+
+    /**
+     * The random seed. We can't use super.seed.
+     */
+    private long rnd;
+
+    /**
+     * Initialization flag to permit calls to setSeed to succeed only
+     * while executing the Random constructor.  We can't allow others
+     * since it would cause setting seed in one part of a program to
+     * unintentionally impact other usages by the thread.
+     */
+    boolean initialized;
+
+    // Padding to help avoid memory contention among seed updates in
+    // different TLRs in the common case that they are located near
+    // each other.
+    private long pad0, pad1, pad2, pad3, pad4, pad5, pad6, pad7;
+
+    /**
+     * The actual ThreadLocal
+     */
+    private static final ThreadLocal<ThreadLocalRandom> localRandom =
+        new ThreadLocal<ThreadLocalRandom>() {
+            protected ThreadLocalRandom initialValue() {
+                return new ThreadLocalRandom();
+            }
+    };
+
+
+    /**
+     * Constructor called only by localRandom.initialValue.
+     */
+    ThreadLocalRandom() {
+        super();
+        initialized = true;
+    }
+
+    /**
+     * Returns the current thread's {@code ThreadLocalRandom}.
+     *
+     * @return the current thread's {@code ThreadLocalRandom}
+     */
+    public static ThreadLocalRandom current() {
+        return localRandom.get();
+    }
+
+    /**
+     * Throws {@code UnsupportedOperationException}.  Setting seeds in
+     * this generator is not supported.
+     *
+     * @throws UnsupportedOperationException always
+     */
+    public void setSeed(long seed) {
+        if (initialized)
+            throw new UnsupportedOperationException();
+        rnd = (seed ^ multiplier) & mask;
+    }
+
+    protected int next(int bits) {
+        rnd = (rnd * multiplier + addend) & mask;
+        return (int) (rnd >>> (48-bits));
+    }
+
+    /**
+     * Returns a pseudorandom, uniformly distributed value between the
+     * given least value (inclusive) and bound (exclusive).
+     *
+     * @param least the least value returned
+     * @param bound the upper bound (exclusive)
+     * @throws IllegalArgumentException if least greater than or equal
+     * to bound
+     * @return the next value
+     */
+    public int nextInt(int least, int bound) {
+        if (least >= bound)
+            throw new IllegalArgumentException();
+        return nextInt(bound - least) + least;
+    }
+
+    /**
+     * Returns a pseudorandom, uniformly distributed value
+     * between 0 (inclusive) and the specified value (exclusive).
+     *
+     * @param n the bound on the random number to be returned.  Must be
+     *        positive.
+     * @return the next value
+     * @throws IllegalArgumentException if n is not positive
+     */
+    public long nextLong(long n) {
+        if (n <= 0)
+            throw new IllegalArgumentException("n must be positive");
+        // Divide n by two until small enough for nextInt. On each
+        // iteration (at most 31 of them but usually much less),
+        // randomly choose both whether to include high bit in result
+        // (offset) and whether to continue with the lower vs upper
+        // half (which makes a difference only if odd).
+        long offset = 0;
+        while (n >= Integer.MAX_VALUE) {
+            int bits = next(2);
+            long half = n >>> 1;
+            long nextn = ((bits & 2) == 0) ? half : n - half;
+            if ((bits & 1) == 0)
+                offset += n - nextn;
+            n = nextn;
+        }
+        return offset + nextInt((int) n);
+    }
+
+    /**
+     * Returns a pseudorandom, uniformly distributed value between the
+     * given least value (inclusive) and bound (exclusive).
+     *
+     * @param least the least value returned
+     * @param bound the upper bound (exclusive)
+     * @return the next value
+     * @throws IllegalArgumentException if least greater than or equal
+     * to bound
+     */
+    public long nextLong(long least, long bound) {
+        if (least >= bound)
+            throw new IllegalArgumentException();
+        return nextLong(bound - least) + least;
+    }
+
+    /**
+     * Returns a pseudorandom, uniformly distributed {@code double} value
+     * between 0 (inclusive) and the specified value (exclusive).
+     *
+     * @param n the bound on the random number to be returned.  Must be
+     *        positive.
+     * @return the next value
+     * @throws IllegalArgumentException if n is not positive
+     */
+    public double nextDouble(double n) {
+        if (n <= 0)
+            throw new IllegalArgumentException("n must be positive");
+        return nextDouble() * n;
+    }
+
+    /**
+     * Returns a pseudorandom, uniformly distributed value between the
+     * given least value (inclusive) and bound (exclusive).
+     *
+     * @param least the least value returned
+     * @param bound the upper bound (exclusive)
+     * @return the next value
+     * @throws IllegalArgumentException if least greater than or equal
+     * to bound
+     */
+    public double nextDouble(double least, double bound) {
+        if (least >= bound)
+            throw new IllegalArgumentException();
+        return nextDouble() * (bound - least) + least;
+    }
+
+    private static final long serialVersionUID = -5851777807851030925L;
+}
diff --git a/luni/src/main/java/java/util/concurrent/ThreadPoolExecutor.java b/luni/src/main/java/java/util/concurrent/ThreadPoolExecutor.java
index 6622af8..331e225 100644
--- a/luni/src/main/java/java/util/concurrent/ThreadPoolExecutor.java
+++ b/luni/src/main/java/java/util/concurrent/ThreadPoolExecutor.java
@@ -1,7 +1,7 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent;
@@ -9,6 +9,10 @@ import java.util.concurrent.locks.*;
 import java.util.concurrent.atomic.*;
 import java.util.*;
 
+// BEGIN android-note
+// removed security manager docs
+// END android-note
+
 /**
  * An {@link ExecutorService} that executes each submitted task using
  * one of possibly several pooled threads, normally configured
@@ -1311,8 +1315,6 @@ public class ThreadPoolExecutor extends AbstractExecutorService {
      * <p>This method does not wait for previously submitted tasks to
      * complete execution.  Use {@link #awaitTermination awaitTermination}
      * to do that.
-     *
-     * @throws SecurityException {@inheritDoc}
      */
     public void shutdown() {
         final ReentrantLock mainLock = this.mainLock;
@@ -1342,8 +1344,6 @@ public class ThreadPoolExecutor extends AbstractExecutorService {
      * processing actively executing tasks.  This implementation
      * cancels tasks via {@link Thread#interrupt}, so any task that
      * fails to respond to interrupts may never terminate.
-     *
-     * @throws SecurityException {@inheritDoc}
      */
     public List<Runnable> shutdownNow() {
         List<Runnable> tasks;
@@ -1512,6 +1512,18 @@ public class ThreadPoolExecutor extends AbstractExecutorService {
     }
 
     /**
+     * Same as prestartCoreThread except arranges that at least one
+     * thread is started even if corePoolSize is 0.
+     */
+    void ensurePrestart() {
+        int wc = workerCountOf(ctl.get());
+        if (wc < corePoolSize)
+            addWorker(null, true);
+        else if (wc == 0)
+            addWorker(null, false);
+    }
+
+    /**
      * Starts all core threads, causing them to idly wait for work. This
      * overrides the default policy of starting core threads only when
      * new tasks are executed.
diff --git a/luni/src/main/java/java/util/concurrent/TimeUnit.java b/luni/src/main/java/java/util/concurrent/TimeUnit.java
index b2e3060..50f6ce0 100644
--- a/luni/src/main/java/java/util/concurrent/TimeUnit.java
+++ b/luni/src/main/java/java/util/concurrent/TimeUnit.java
@@ -1,7 +1,7 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent;
@@ -23,14 +23,14 @@ package java.util.concurrent;
  * the following code will timeout in 50 milliseconds if the {@link
  * java.util.concurrent.locks.Lock lock} is not available:
  *
- * <pre>  Lock lock = ...;
- *  if (lock.tryLock(50L, TimeUnit.MILLISECONDS)) ...
- * </pre>
+ *  <pre> {@code
+ * Lock lock = ...;
+ * if (lock.tryLock(50L, TimeUnit.MILLISECONDS)) ...}</pre>
+ *
  * while this code will timeout in 50 seconds:
- * <pre>
- *  Lock lock = ...;
- *  if (lock.tryLock(50L, TimeUnit.SECONDS)) ...
- * </pre>
+ *  <pre> {@code
+ * Lock lock = ...;
+ * if (lock.tryLock(50L, TimeUnit.SECONDS)) ...}</pre>
  *
  * Note however, that there is no guarantee that a particular timeout
  * implementation will be able to notice the passage of time at the
diff --git a/luni/src/main/java/java/util/concurrent/TimeoutException.java b/luni/src/main/java/java/util/concurrent/TimeoutException.java
index 8b84f28..83934f0 100644
--- a/luni/src/main/java/java/util/concurrent/TimeoutException.java
+++ b/luni/src/main/java/java/util/concurrent/TimeoutException.java
@@ -1,7 +1,7 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent;
diff --git a/luni/src/main/java/java/util/concurrent/TransferQueue.java b/luni/src/main/java/java/util/concurrent/TransferQueue.java
new file mode 100644
index 0000000..9cd5773
--- /dev/null
+++ b/luni/src/main/java/java/util/concurrent/TransferQueue.java
@@ -0,0 +1,133 @@
+/*
+ * Written by Doug Lea with assistance from members of JCP JSR-166
+ * Expert Group and released to the public domain, as explained at
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+package java.util.concurrent;
+
+// BEGIN android-note
+// removed link to collections framework docs
+// END android-note
+
+/**
+ * A {@link BlockingQueue} in which producers may wait for consumers
+ * to receive elements.  A {@code TransferQueue} may be useful for
+ * example in message passing applications in which producers
+ * sometimes (using method {@link #transfer}) await receipt of
+ * elements by consumers invoking {@code take} or {@code poll}, while
+ * at other times enqueue elements (via method {@code put}) without
+ * waiting for receipt.
+ * {@linkplain #tryTransfer(Object) Non-blocking} and
+ * {@linkplain #tryTransfer(Object,long,TimeUnit) time-out} versions of
+ * {@code tryTransfer} are also available.
+ * A {@code TransferQueue} may also be queried, via {@link
+ * #hasWaitingConsumer}, whether there are any threads waiting for
+ * items, which is a converse analogy to a {@code peek} operation.
+ *
+ * <p>Like other blocking queues, a {@code TransferQueue} may be
+ * capacity bounded.  If so, an attempted transfer operation may
+ * initially block waiting for available space, and/or subsequently
+ * block waiting for reception by a consumer.  Note that in a queue
+ * with zero capacity, such as {@link SynchronousQueue}, {@code put}
+ * and {@code transfer} are effectively synonymous.
+ *
+ * @since 1.7
+ * @hide
+ * @author Doug Lea
+ * @param <E> the type of elements held in this collection
+ */
+public interface TransferQueue<E> extends BlockingQueue<E> {
+    /**
+     * Transfers the element to a waiting consumer immediately, if possible.
+     *
+     * <p>More precisely, transfers the specified element immediately
+     * if there exists a consumer already waiting to receive it (in
+     * {@link #take} or timed {@link #poll(long,TimeUnit) poll}),
+     * otherwise returning {@code false} without enqueuing the element.
+     *
+     * @param e the element to transfer
+     * @return {@code true} if the element was transferred, else
+     *         {@code false}
+     * @throws ClassCastException if the class of the specified element
+     *         prevents it from being added to this queue
+     * @throws NullPointerException if the specified element is null
+     * @throws IllegalArgumentException if some property of the specified
+     *         element prevents it from being added to this queue
+     */
+    boolean tryTransfer(E e);
+
+    /**
+     * Transfers the element to a consumer, waiting if necessary to do so.
+     *
+     * <p>More precisely, transfers the specified element immediately
+     * if there exists a consumer already waiting to receive it (in
+     * {@link #take} or timed {@link #poll(long,TimeUnit) poll}),
+     * else waits until the element is received by a consumer.
+     *
+     * @param e the element to transfer
+     * @throws InterruptedException if interrupted while waiting,
+     *         in which case the element is not left enqueued
+     * @throws ClassCastException if the class of the specified element
+     *         prevents it from being added to this queue
+     * @throws NullPointerException if the specified element is null
+     * @throws IllegalArgumentException if some property of the specified
+     *         element prevents it from being added to this queue
+     */
+    void transfer(E e) throws InterruptedException;
+
+    /**
+     * Transfers the element to a consumer if it is possible to do so
+     * before the timeout elapses.
+     *
+     * <p>More precisely, transfers the specified element immediately
+     * if there exists a consumer already waiting to receive it (in
+     * {@link #take} or timed {@link #poll(long,TimeUnit) poll}),
+     * else waits until the element is received by a consumer,
+     * returning {@code false} if the specified wait time elapses
+     * before the element can be transferred.
+     *
+     * @param e the element to transfer
+     * @param timeout how long to wait before giving up, in units of
+     *        {@code unit}
+     * @param unit a {@code TimeUnit} determining how to interpret the
+     *        {@code timeout} parameter
+     * @return {@code true} if successful, or {@code false} if
+     *         the specified waiting time elapses before completion,
+     *         in which case the element is not left enqueued
+     * @throws InterruptedException if interrupted while waiting,
+     *         in which case the element is not left enqueued
+     * @throws ClassCastException if the class of the specified element
+     *         prevents it from being added to this queue
+     * @throws NullPointerException if the specified element is null
+     * @throws IllegalArgumentException if some property of the specified
+     *         element prevents it from being added to this queue
+     */
+    boolean tryTransfer(E e, long timeout, TimeUnit unit)
+        throws InterruptedException;
+
+    /**
+     * Returns {@code true} if there is at least one consumer waiting
+     * to receive an element via {@link #take} or
+     * timed {@link #poll(long,TimeUnit) poll}.
+     * The return value represents a momentary state of affairs.
+     *
+     * @return {@code true} if there is at least one waiting consumer
+     */
+    boolean hasWaitingConsumer();
+
+    /**
+     * Returns an estimate of the number of consumers waiting to
+     * receive elements via {@link #take} or timed
+     * {@link #poll(long,TimeUnit) poll}.  The return value is an
+     * approximation of a momentary state of affairs, that may be
+     * inaccurate if consumers have completed or given up waiting.
+     * The value may be useful for monitoring and heuristics, but
+     * not for synchronization control.  Implementations of this
+     * method are likely to be noticeably slower than those for
+     * {@link #hasWaitingConsumer}.
+     *
+     * @return the number of consumers waiting to receive elements
+     */
+    int getWaitingConsumerCount();
+}
diff --git a/luni/src/main/java/java/util/concurrent/atomic/AtomicBoolean.java b/luni/src/main/java/java/util/concurrent/atomic/AtomicBoolean.java
index c774d21..d531f25 100644
--- a/luni/src/main/java/java/util/concurrent/atomic/AtomicBoolean.java
+++ b/luni/src/main/java/java/util/concurrent/atomic/AtomicBoolean.java
@@ -1,7 +1,7 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent.atomic;
@@ -21,14 +21,14 @@ import sun.misc.Unsafe;
 public class AtomicBoolean implements java.io.Serializable {
     private static final long serialVersionUID = 4654671469794556979L;
     // setup to use Unsafe.compareAndSwapInt for updates
-    private static final Unsafe unsafe = UnsafeAccess.THE_ONE; // android-changed
+    private static final Unsafe unsafe = Unsafe.getUnsafe();
     private static final long valueOffset;
 
     static {
-      try {
-        valueOffset = unsafe.objectFieldOffset
-            (AtomicBoolean.class.getDeclaredField("value"));
-      } catch (Exception ex) { throw new Error(ex); }
+        try {
+            valueOffset = unsafe.objectFieldOffset
+                (AtomicBoolean.class.getDeclaredField("value"));
+        } catch (Exception ex) { throw new Error(ex); }
     }
 
     private volatile int value;
diff --git a/luni/src/main/java/java/util/concurrent/atomic/AtomicInteger.java b/luni/src/main/java/java/util/concurrent/atomic/AtomicInteger.java
index 16dd568..e0a0018 100644
--- a/luni/src/main/java/java/util/concurrent/atomic/AtomicInteger.java
+++ b/luni/src/main/java/java/util/concurrent/atomic/AtomicInteger.java
@@ -1,7 +1,7 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent.atomic;
@@ -24,14 +24,14 @@ public class AtomicInteger extends Number implements java.io.Serializable {
     private static final long serialVersionUID = 6214790243416807050L;
 
     // setup to use Unsafe.compareAndSwapInt for updates
-    private static final Unsafe unsafe = UnsafeAccess.THE_ONE; // android-changed
+    private static final Unsafe unsafe = Unsafe.getUnsafe();
     private static final long valueOffset;
 
     static {
-      try {
-        valueOffset = unsafe.objectFieldOffset
-            (AtomicInteger.class.getDeclaredField("value"));
-      } catch (Exception ex) { throw new Error(ex); }
+        try {
+            valueOffset = unsafe.objectFieldOffset
+                (AtomicInteger.class.getDeclaredField("value"));
+        } catch (Exception ex) { throw new Error(ex); }
     }
 
     private volatile int value;
@@ -217,18 +217,33 @@ public class AtomicInteger extends Number implements java.io.Serializable {
     }
 
 
+    /**
+     * Returns the value of this {@code AtomicInteger} as an {@code int}.
+     */
     public int intValue() {
         return get();
     }
 
+    /**
+     * Returns the value of this {@code AtomicInteger} as a {@code long}
+     * after a widening primitive conversion.
+     */
     public long longValue() {
         return (long)get();
     }
 
+    /**
+     * Returns the value of this {@code AtomicInteger} as a {@code float}
+     * after a widening primitive conversion.
+     */
     public float floatValue() {
         return (float)get();
     }
 
+    /**
+     * Returns the value of this {@code AtomicInteger} as a {@code double}
+     * after a widening primitive conversion.
+     */
     public double doubleValue() {
         return (double)get();
     }
diff --git a/luni/src/main/java/java/util/concurrent/atomic/AtomicIntegerArray.java b/luni/src/main/java/java/util/concurrent/atomic/AtomicIntegerArray.java
index 6dcdfd0..804a51e 100644
--- a/luni/src/main/java/java/util/concurrent/atomic/AtomicIntegerArray.java
+++ b/luni/src/main/java/java/util/concurrent/atomic/AtomicIntegerArray.java
@@ -1,12 +1,11 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent.atomic;
 import sun.misc.Unsafe;
-import java.util.*;
 
 /**
  * An {@code int} array in which elements may be updated atomically.
@@ -19,7 +18,7 @@ import java.util.*;
 public class AtomicIntegerArray implements java.io.Serializable {
     private static final long serialVersionUID = 2862133569453604235L;
 
-    private static final Unsafe unsafe = UnsafeAccess.THE_ONE; // android-changed
+    private static final Unsafe unsafe = Unsafe.getUnsafe();
     private static final int base = unsafe.arrayBaseOffset(int[].class);
     private static final int shift;
     private final int[] array;
diff --git a/luni/src/main/java/java/util/concurrent/atomic/AtomicIntegerFieldUpdater.java b/luni/src/main/java/java/util/concurrent/atomic/AtomicIntegerFieldUpdater.java
index e8a0d57..c7ed158 100644
--- a/luni/src/main/java/java/util/concurrent/atomic/AtomicIntegerFieldUpdater.java
+++ b/luni/src/main/java/java/util/concurrent/atomic/AtomicIntegerFieldUpdater.java
@@ -1,7 +1,7 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent.atomic;
@@ -236,24 +236,21 @@ public abstract class  AtomicIntegerFieldUpdater<T> {
      * Standard hotspot implementation using intrinsics
      */
     private static class AtomicIntegerFieldUpdaterImpl<T> extends AtomicIntegerFieldUpdater<T> {
-        private static final Unsafe unsafe = UnsafeAccess.THE_ONE; // android-changed
+        private static final Unsafe unsafe = Unsafe.getUnsafe();
         private final long offset;
         private final Class<T> tclass;
-        private final Class cclass;
+        private final Class<?> cclass;
 
         AtomicIntegerFieldUpdaterImpl(Class<T> tclass, String fieldName) {
             Field field = null;
-            Class caller = null;
+            Class<?> caller = null;
             int modifiers = 0;
             try {
                 field = tclass.getDeclaredField(fieldName);
-                // BEGIN android-changed
-                caller = VMStack.getStackClass2();
-                // END android-changed
+                caller = VMStack.getStackClass2(); // android-changed
                 modifiers = field.getModifiers();
 
                 // BEGIN android-removed
-                // modifiers = field.getModifiers();
                 // sun.reflect.misc.ReflectUtil.ensureMemberAccess(
                 //     caller, tclass, null, modifiers);
                 // sun.reflect.misc.ReflectUtil.checkPackageAccess(tclass);
@@ -262,7 +259,7 @@ public abstract class  AtomicIntegerFieldUpdater<T> {
                 throw new RuntimeException(ex);
             }
 
-            Class fieldt = field.getType();
+            Class<?> fieldt = field.getType();
             if (fieldt != int.class)
                 throw new IllegalArgumentException("Must be integer type");
 
diff --git a/luni/src/main/java/java/util/concurrent/atomic/AtomicLong.java b/luni/src/main/java/java/util/concurrent/atomic/AtomicLong.java
index 12d6cd1..5e799f7 100644
--- a/luni/src/main/java/java/util/concurrent/atomic/AtomicLong.java
+++ b/luni/src/main/java/java/util/concurrent/atomic/AtomicLong.java
@@ -1,7 +1,7 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent.atomic;
@@ -24,7 +24,7 @@ public class AtomicLong extends Number implements java.io.Serializable {
     private static final long serialVersionUID = 1927816293512124184L;
 
     // setup to use Unsafe.compareAndSwapLong for updates
-    private static final Unsafe unsafe = UnsafeAccess.THE_ONE; // android-changed
+    private static final Unsafe unsafe = Unsafe.getUnsafe();
     private static final long valueOffset;
 
     /**
@@ -42,10 +42,10 @@ public class AtomicLong extends Number implements java.io.Serializable {
     private static native boolean VMSupportsCS8();
 
     static {
-      try {
-        valueOffset = unsafe.objectFieldOffset
-            (AtomicLong.class.getDeclaredField("value"));
-      } catch (Exception ex) { throw new Error(ex); }
+        try {
+            valueOffset = unsafe.objectFieldOffset
+                (AtomicLong.class.getDeclaredField("value"));
+        } catch (Exception ex) { throw new Error(ex); }
     }
 
     private volatile long value;
@@ -231,18 +231,33 @@ public class AtomicLong extends Number implements java.io.Serializable {
     }
 
 
+    /**
+     * Returns the value of this {@code AtomicLong} as an {@code int}
+     * after a narrowing primitive conversion.
+     */
     public int intValue() {
         return (int)get();
     }
 
+    /**
+     * Returns the value of this {@code AtomicLong} as a {@code long}.
+     */
     public long longValue() {
         return get();
     }
 
+    /**
+     * Returns the value of this {@code AtomicLong} as a {@code float}
+     * after a widening primitive conversion.
+     */
     public float floatValue() {
         return (float)get();
     }
 
+    /**
+     * Returns the value of this {@code AtomicLong} as a {@code double}
+     * after a widening primitive conversion.
+     */
     public double doubleValue() {
         return (double)get();
     }
diff --git a/luni/src/main/java/java/util/concurrent/atomic/AtomicLongArray.java b/luni/src/main/java/java/util/concurrent/atomic/AtomicLongArray.java
index 9e2d25f..22edb3f 100644
--- a/luni/src/main/java/java/util/concurrent/atomic/AtomicLongArray.java
+++ b/luni/src/main/java/java/util/concurrent/atomic/AtomicLongArray.java
@@ -1,12 +1,11 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent.atomic;
 import sun.misc.Unsafe;
-import java.util.*;
 
 /**
  * A {@code long} array in which elements may be updated atomically.
@@ -18,7 +17,7 @@ import java.util.*;
 public class AtomicLongArray implements java.io.Serializable {
     private static final long serialVersionUID = -2308431214976778248L;
 
-    private static final Unsafe unsafe = UnsafeAccess.THE_ONE; // android-changed
+    private static final Unsafe unsafe = Unsafe.getUnsafe();
     private static final int base = unsafe.arrayBaseOffset(long[].class);
     private static final int shift;
     private final long[] array;
diff --git a/luni/src/main/java/java/util/concurrent/atomic/AtomicLongFieldUpdater.java b/luni/src/main/java/java/util/concurrent/atomic/AtomicLongFieldUpdater.java
index 21ef748..748ae69 100644
--- a/luni/src/main/java/java/util/concurrent/atomic/AtomicLongFieldUpdater.java
+++ b/luni/src/main/java/java/util/concurrent/atomic/AtomicLongFieldUpdater.java
@@ -1,7 +1,7 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent.atomic;
@@ -235,14 +235,14 @@ public abstract class  AtomicLongFieldUpdater<T> {
     }
 
     private static class CASUpdater<T> extends AtomicLongFieldUpdater<T> {
-        private static final Unsafe unsafe = UnsafeAccess.THE_ONE; // android-changed
+        private static final Unsafe unsafe = Unsafe.getUnsafe();
         private final long offset;
         private final Class<T> tclass;
-        private final Class cclass;
+        private final Class<?> cclass;
 
         CASUpdater(Class<T> tclass, String fieldName) {
             Field field = null;
-            Class caller = null;
+            Class<?> caller = null;
             int modifiers = 0;
             try {
                 field = tclass.getDeclaredField(fieldName);
@@ -257,7 +257,7 @@ public abstract class  AtomicLongFieldUpdater<T> {
                 throw new RuntimeException(ex);
             }
 
-            Class fieldt = field.getType();
+            Class<?> fieldt = field.getType();
             if (fieldt != long.class)
                 throw new IllegalArgumentException("Must be long type");
 
@@ -320,14 +320,14 @@ public abstract class  AtomicLongFieldUpdater<T> {
 
 
     private static class LockedUpdater<T> extends AtomicLongFieldUpdater<T> {
-        private static final Unsafe unsafe = UnsafeAccess.THE_ONE; // android-changed
+        private static final Unsafe unsafe = Unsafe.getUnsafe();
         private final long offset;
         private final Class<T> tclass;
-        private final Class cclass;
+        private final Class<?> cclass;
 
         LockedUpdater(Class<T> tclass, String fieldName) {
             Field field = null;
-            Class caller = null;
+            Class<?> caller = null;
             int modifiers = 0;
             try {
                 field = tclass.getDeclaredField(fieldName);
@@ -342,7 +342,7 @@ public abstract class  AtomicLongFieldUpdater<T> {
                 throw new RuntimeException(ex);
             }
 
-            Class fieldt = field.getType();
+            Class<?> fieldt = field.getType();
             if (fieldt != long.class)
                 throw new IllegalArgumentException("Must be long type");
 
diff --git a/luni/src/main/java/java/util/concurrent/atomic/AtomicMarkableReference.java b/luni/src/main/java/java/util/concurrent/atomic/AtomicMarkableReference.java
index 63f46d6..eaf700c 100644
--- a/luni/src/main/java/java/util/concurrent/atomic/AtomicMarkableReference.java
+++ b/luni/src/main/java/java/util/concurrent/atomic/AtomicMarkableReference.java
@@ -1,13 +1,11 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent.atomic;
 
-import sun.misc.Unsafe;
-
 /**
  * An {@code AtomicMarkableReference} maintains an object reference
  * along with a mark bit, that can be updated atomically.
@@ -163,7 +161,7 @@ public class AtomicMarkableReference<V> {
 
     // Unsafe mechanics
 
-    private static final sun.misc.Unsafe UNSAFE = UnsafeAccess.THE_ONE; // android-changed
+    private static final sun.misc.Unsafe UNSAFE = sun.misc.Unsafe.getUnsafe();
     private static final long pairOffset =
         objectFieldOffset(UNSAFE, "pair", AtomicMarkableReference.class);
 
diff --git a/luni/src/main/java/java/util/concurrent/atomic/AtomicReference.java b/luni/src/main/java/java/util/concurrent/atomic/AtomicReference.java
index f041bbd..b21e9b6 100644
--- a/luni/src/main/java/java/util/concurrent/atomic/AtomicReference.java
+++ b/luni/src/main/java/java/util/concurrent/atomic/AtomicReference.java
@@ -1,7 +1,7 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent.atomic;
@@ -18,14 +18,14 @@ import sun.misc.Unsafe;
 public class AtomicReference<V>  implements java.io.Serializable {
     private static final long serialVersionUID = -1848883965231344442L;
 
-    private static final Unsafe unsafe = UnsafeAccess.THE_ONE; // android-changed
+    private static final Unsafe unsafe = Unsafe.getUnsafe();
     private static final long valueOffset;
 
     static {
-      try {
-        valueOffset = unsafe.objectFieldOffset
-            (AtomicReference.class.getDeclaredField("value"));
-      } catch (Exception ex) { throw new Error(ex); }
+        try {
+            valueOffset = unsafe.objectFieldOffset
+                (AtomicReference.class.getDeclaredField("value"));
+        } catch (Exception ex) { throw new Error(ex); }
     }
 
     private volatile V value;
diff --git a/luni/src/main/java/java/util/concurrent/atomic/AtomicReferenceArray.java b/luni/src/main/java/java/util/concurrent/atomic/AtomicReferenceArray.java
index dbc5886..c47728d 100644
--- a/luni/src/main/java/java/util/concurrent/atomic/AtomicReferenceArray.java
+++ b/luni/src/main/java/java/util/concurrent/atomic/AtomicReferenceArray.java
@@ -1,12 +1,14 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent.atomic;
+
+import java.util.Arrays;
+import java.lang.reflect.Array;
 import sun.misc.Unsafe;
-import java.util.*;
 
 /**
  * An array of object references in which elements may be updated
@@ -20,13 +22,23 @@ import java.util.*;
 public class AtomicReferenceArray<E> implements java.io.Serializable {
     private static final long serialVersionUID = -6209656149925076980L;
 
-    private static final Unsafe unsafe = UnsafeAccess.THE_ONE; // android-changed
-    private static final int base = unsafe.arrayBaseOffset(Object[].class);
+    private static final Unsafe unsafe;
+    private static final int base;
     private static final int shift;
-    private final Object[] array;
+    private static final long arrayFieldOffset;
+    private final Object[] array; // must have exact type Object[]
 
     static {
-        int scale = unsafe.arrayIndexScale(Object[].class);
+        int scale;
+        try {
+            unsafe = Unsafe.getUnsafe();
+            arrayFieldOffset = unsafe.objectFieldOffset
+                (AtomicReferenceArray.class.getDeclaredField("array"));
+            base = unsafe.arrayBaseOffset(Object[].class);
+            scale = unsafe.arrayIndexScale(Object[].class);
+        } catch (Exception e) {
+            throw new Error(e);
+        }
         if ((scale & (scale - 1)) != 0)
             throw new Error("data type scale not a power of two");
         shift = 31 - Integer.numberOfLeadingZeros(scale);
@@ -45,7 +57,7 @@ public class AtomicReferenceArray<E> implements java.io.Serializable {
 
     /**
      * Creates a new AtomicReferenceArray of the given length, with all
-     * elements initially zero.
+     * elements initially null.
      *
      * @param length the length of the array
      */
@@ -62,7 +74,7 @@ public class AtomicReferenceArray<E> implements java.io.Serializable {
      */
     public AtomicReferenceArray(E[] array) {
         // Visibility guaranteed by final field guarantees
-        this.array = array.clone();
+        this.array = Arrays.copyOf(array, array.length, Object[].class);
     }
 
     /**
@@ -121,7 +133,7 @@ public class AtomicReferenceArray<E> implements java.io.Serializable {
     public final E getAndSet(int i, E newValue) {
         long offset = checkedByteOffset(i);
         while (true) {
-            E current = (E) getRaw(offset);
+            E current = getRaw(offset);
             if (compareAndSetRaw(offset, current, newValue))
                 return current;
         }
@@ -167,7 +179,7 @@ public class AtomicReferenceArray<E> implements java.io.Serializable {
      * @return the String representation of the current values of array
      */
     public String toString() {
-           int iMax = array.length - 1;
+        int iMax = array.length - 1;
         if (iMax == -1)
             return "[]";
 
@@ -181,4 +193,20 @@ public class AtomicReferenceArray<E> implements java.io.Serializable {
         }
     }
 
+    /**
+     * Reconstitutes the instance from a stream (that is, deserializes it).
+     * @param s the stream
+     */
+    private void readObject(java.io.ObjectInputStream s)
+        throws java.io.IOException, ClassNotFoundException,
+        java.io.InvalidObjectException {
+        // Note: This must be changed if any additional fields are defined
+        Object a = s.readFields().get("array", null);
+        if (a == null || !a.getClass().isArray())
+            throw new java.io.InvalidObjectException("Not array type");
+        if (a.getClass() != Object[].class)
+            a = Arrays.copyOf((Object[])a, Array.getLength(a), Object[].class);
+        unsafe.putObjectVolatile(this, arrayFieldOffset, a);
+    }
+
 }
diff --git a/luni/src/main/java/java/util/concurrent/atomic/AtomicReferenceFieldUpdater.java b/luni/src/main/java/java/util/concurrent/atomic/AtomicReferenceFieldUpdater.java
index 8b3da0b..d23d766 100644
--- a/luni/src/main/java/java/util/concurrent/atomic/AtomicReferenceFieldUpdater.java
+++ b/luni/src/main/java/java/util/concurrent/atomic/AtomicReferenceFieldUpdater.java
@@ -1,11 +1,11 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent.atomic;
-import dalvik.system.VMStack;
+import dalvik.system.VMStack; // android-added
 import sun.misc.Unsafe;
 import java.lang.reflect.*;
 
@@ -155,7 +155,7 @@ public abstract class AtomicReferenceFieldUpdater<T, V> {
         private final long offset;
         private final Class<T> tclass;
         private final Class<V> vclass;
-        private final Class cclass;
+        private final Class<?> cclass;
 
         /*
          * Internal type checks within all update methods contain
@@ -173,8 +173,8 @@ public abstract class AtomicReferenceFieldUpdater<T, V> {
                                         Class<V> vclass,
                                         String fieldName) {
             Field field = null;
-            Class fieldClass = null;
-            Class caller = null;
+            Class<?> fieldClass = null;
+            Class<?> caller = null;
             int modifiers = 0;
             try {
                 field = tclass.getDeclaredField(fieldName);
diff --git a/luni/src/main/java/java/util/concurrent/atomic/AtomicStampedReference.java b/luni/src/main/java/java/util/concurrent/atomic/AtomicStampedReference.java
index 2e826f2..a0cb492 100644
--- a/luni/src/main/java/java/util/concurrent/atomic/AtomicStampedReference.java
+++ b/luni/src/main/java/java/util/concurrent/atomic/AtomicStampedReference.java
@@ -1,7 +1,7 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent.atomic;
@@ -162,7 +162,7 @@ public class AtomicStampedReference<V> {
 
     // Unsafe mechanics
 
-    private static final sun.misc.Unsafe UNSAFE = UnsafeAccess.THE_ONE; // android-changed
+    private static final sun.misc.Unsafe UNSAFE = sun.misc.Unsafe.getUnsafe();
     private static final long pairOffset =
         objectFieldOffset(UNSAFE, "pair", AtomicStampedReference.class);
 
diff --git a/luni/src/main/java/java/util/concurrent/atomic/Fences.java b/luni/src/main/java/java/util/concurrent/atomic/Fences.java
new file mode 100644
index 0000000..7ecf45a
--- /dev/null
+++ b/luni/src/main/java/java/util/concurrent/atomic/Fences.java
@@ -0,0 +1,540 @@
+/*
+ * Written by Doug Lea with assistance from members of JCP JSR-166
+ * Expert Group and released to the public domain, as explained at
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+package java.util.concurrent.atomic;
+
+/**
+ * A set of methods providing fine-grained control over happens-before
+ * and synchronization order relations among reads and/or writes.  The
+ * methods of this class are designed for use in uncommon situations
+ * where declaring variables {@code volatile} or {@code final}, using
+ * instances of atomic classes, using {@code synchronized} blocks or
+ * methods, or using other synchronization facilities are not possible
+ * or do not provide the desired control.
+ *
+ * <p><b>Memory Ordering.</b> There are three methods for controlling
+ * ordering relations among memory accesses (i.e., reads and
+ * writes). Method {@code orderWrites} is typically used to enforce
+ * order between two writes, and {@code orderAccesses} between a write
+ * and a read.  Method {@code orderReads} is used to enforce order
+ * between two reads with respect to other {@code orderWrites} and/or
+ * {@code orderAccesses} invocations.  The formally specified
+ * properties of these methods described below provide
+ * platform-independent guarantees that are honored by all levels of a
+ * platform (compilers, systems, processors).  The use of these
+ * methods may result in the suppression of otherwise valid compiler
+ * transformations and optimizations that could visibly violate the
+ * specified orderings, and may or may not entail the use of
+ * processor-level "memory barrier" instructions.
+ *
+ * <p>Each ordering method accepts a {@code ref} argument, and
+ * controls ordering among accesses with respect to this reference.
+ * Invocations must be placed <em>between</em> accesses performed in
+ * expression evaluations and assignment statements to control the
+ * orderings of prior versus subsequent accesses appearing in program
+ * order. These methods also return their arguments to simplify
+ * correct usage in these contexts.
+ *
+ * <p>Usages of ordering methods almost always take one of the forms
+ * illustrated in the examples below.  These idioms arrange some of
+ * the ordering properties associated with {@code volatile} and
+ * related language-based constructions, but without other
+ * compile-time and runtime benefits that make language-based
+ * constructions far better choices when they are applicable.  Usages
+ * should be restricted to the control of strictly internal
+ * implementation matters inside a class or package, and must either
+ * avoid or document any consequent violations of ordering or safety
+ * properties expected by users of a class employing them.
+ *
+ * <p><b>Reachability.</b> Method {@code reachabilityFence}
+ * establishes an ordering for strong reachability (as defined in the
+ * {@link java.lang.ref} package specification) with respect to
+ * garbage collection.  Method {@code reachabilityFence} differs from
+ * the others in that it controls relations that are otherwise only
+ * implicit in a program -- the reachability conditions triggering
+ * garbage collection.  As illustrated in the sample usages below,
+ * this method is applicable only when reclamation may have visible
+ * effects, which is possible for objects with finalizers (see Section
+ * 12.6 of the Java Language Specification) that are implemented in
+ * ways that rely on ordering control for correctness.
+ *
+ * <p><b>Sample Usages</b>
+ *
+ * <p><b>Safe publication.</b> With care, method {@code orderWrites}
+ * may be used to obtain the memory safety effects of {@code final}
+ * for a field that cannot be declared as {@code final}, because its
+ * primary initialization cannot be performed in a constructor, in
+ * turn because it is used in a framework requiring that all classes
+ * have a no-argument constructor; as in:
+ *
+ *  <pre> {@code
+ * class WidgetHolder {
+ *   private Widget widget;
+ *   public WidgetHolder() {}
+ *   public static WidgetHolder newWidgetHolder(Params params) {
+ *     WidgetHolder h = new WidgetHolder();
+ *     h.widget = new Widget(params);
+ *     return Fences.orderWrites(h);
+ *   }
+ * }}</pre>
+ *
+ * Here, the invocation of {@code orderWrites} ensures that the
+ * effects of the widget assignment are ordered before those of any
+ * (unknown) subsequent stores of {@code h} in other variables that
+ * make {@code h} available for use by other objects.  Initialization
+ * sequences using {@code orderWrites} require more care than those
+ * involving {@code final} fields.  When {@code final} is not used,
+ * compilers cannot help you to ensure that the field is set correctly
+ * across all usages.  You must fully initialize objects
+ * <em>before</em> the {@code orderWrites} invocation that makes
+ * references to them safe to assign to accessible variables. Further,
+ * initialization sequences must not internally "leak" the reference
+ * by using it as an argument to a callback method or adding it to a
+ * static data structure.  If less constrained usages were required,
+ * it may be possible to cope using more extensive sets of fences, or
+ * as a normally better choice, using synchronization (locking).
+ * Conversely, if it were possible to do so, the best option would be
+ * to rewrite class {@code WidgetHolder} to use {@code final}.
+ *
+ * <p>An alternative approach is to place similar mechanics in the
+ * (sole) method that makes such objects available for use by others.
+ * Here is a stripped-down example illustrating the essentials. In
+ * practice, among other changes, you would use access methods instead
+ * of a public field.
+ *
+ *  <pre> {@code
+ * class AnotherWidgetHolder {
+ *   public Widget widget;
+ *   void publish(Widget w) {
+ *     this.widget = Fences.orderWrites(w);
+ *   }
+ *   // ...
+ * }}</pre>
+ *
+ * In this case, the {@code orderWrites} invocation occurs before the
+ * store making the object available. Correctness again relies on
+ * ensuring that there are no leaks prior to invoking this method, and
+ * that it really is the <em>only</em> means of accessing the
+ * published object.  This approach is not often applicable --
+ * normally you would publish objects using a thread-safe collection
+ * that itself guarantees the expected ordering relations. However, it
+ * may come into play in the construction of such classes themselves.
+ *
+ * <p><b>Safely updating fields.</b> Outside of the initialization
+ * idioms illustrated above, Fence methods ordering writes must be
+ * paired with those ordering reads. To illustrate, suppose class
+ * {@code c} contains an accessible variable {@code data} that should
+ * have been declared as {@code volatile} but wasn't:
+ *
+ *  <pre> {@code
+ * class C {
+ *    Object data;  // need volatile access but not volatile
+ *    // ...
+ * }
+ *
+ * class App {
+ *   Object getData(C c) {
+ *      return Fences.orderReads(c).data;
+ *   }
+ *
+ *   void setData(C c) {
+ *      Object newValue = ...;
+ *      c.data = Fences.orderWrites(newValue);
+ *      Fences.orderAccesses(c);
+ *   }
+ *   // ...
+ * }}</pre>
+ *
+ * Method {@code getData} provides an emulation of {@code volatile}
+ * reads of (non-long/double) fields by ensuring that the read of
+ * {@code c} obtained as an argument is ordered before subsequent
+ * reads using this reference, and then performs the read of its
+ * field. Method {@code setData} provides an emulation of volatile
+ * writes, ensuring that all other relevant writes have completed,
+ * then performing the assignment, and then ensuring that the write is
+ * ordered before any other access.  These techniques may apply even
+ * when fields are not directly accessible, in which case calls to
+ * fence methods would surround calls to methods such as {@code
+ * c.getData()}.  However, these techniques cannot be applied to
+ * {@code long} or {@code double} fields because reads and writes of
+ * fields of these types are not guaranteed to be
+ * atomic. Additionally, correctness may require that all accesses of
+ * such data use these kinds of wrapper methods, which you would need
+ * to manually ensure.
+ *
+ * <p>More generally, Fence methods can be used in this way to achieve
+ * the safety properties of {@code volatile}. However their use does
+ * not necessarily guarantee the full sequential consistency
+ * properties specified in the Java Language Specification chapter 17
+ * for programs using {@code volatile}. In particular, emulation using
+ * Fence methods is not guaranteed to maintain the property that
+ * {@code volatile} operations performed by different threads are
+ * observed in the same order by all observer threads.
+ *
+ * <p><b>Acquire/Release management of threadsafe objects</b>. It may
+ * be possible to use weaker conventions for volatile-like variables
+ * when they are used to keep track of objects that fully manage their
+ * own thread-safety and synchronization.  Here, an acquiring read
+ * operation remains the same as a volatile-read, but a releasing
+ * write differs by virtue of not itself ensuring an ordering of its
+ * write with subsequent reads, because the required effects are
+ * already ensured by the referenced objects.
+ * For example:
+ *
+ *  <pre> {@code
+ * class Item {
+ *    synchronized f(); // ALL methods are synchronized
+ *    // ...
+ * }
+ *
+ * class ItemHolder {
+ *   private Item item;
+ *   Item acquireItem() {
+ *      return Fences.orderReads(item);
+ *   }
+ *
+ *   void releaseItem(Item x) {
+ *      item = Fences.orderWrites(x);
+ *   }
+ *
+ *   // ...
+ * }}</pre>
+ *
+ * Because this construction avoids use of {@code orderAccesses},
+ * which is typically more costly than the other fence methods, it may
+ * result in better performance than using {@code volatile} or its
+ * emulation. However, as is the case with most applications of fence
+ * methods, correctness relies on the usage context -- here, the
+ * thread safety of {@code Item}, as well as the lack of need for full
+ * volatile semantics inside this class itself. However, the second
+ * concern means that it can be difficult to extend the {@code
+ * ItemHolder} class in this example to be more useful.
+ *
+ * <p><b>Avoiding premature finalization.</b> Finalization may occur
+ * whenever a Java Virtual Machine detects that no reference to an
+ * object will ever be stored in the heap: A garbage collector may
+ * reclaim an object even if the fields of that object are still in
+ * use, so long as the object has otherwise become unreachable. This
+ * may have surprising and undesirable effects in cases such as the
+ * following example in which the bookkeeping associated with a class
+ * is managed through array indices. Here, method {@code action}
+ * uses a {@code reachabilityFence} to ensure that the Resource
+ * object is not reclaimed before bookkeeping on an associated
+ * ExternalResource has been performed; in particular here, to ensure
+ * that the array slot holding the ExternalResource is not nulled out
+ * in method {@link Object#finalize}, which may otherwise run
+ * concurrently.
+ *
+ *  <pre> {@code
+ * class Resource {
+ *   private static ExternalResource[] externalResourceArray = ...
+ *
+ *   int myIndex;
+ *   Resource(...) {
+ *     myIndex = ...
+ *     externalResourceArray[myIndex] = ...;
+ *     ...
+ *   }
+ *   protected void finalize() {
+ *     externalResourceArray[myIndex] = null;
+ *     ...
+ *   }
+ *   public void action() {
+ *     try {
+ *       // ...
+ *       int i = myIndex;
+ *       Resource.update(externalResourceArray[i]);
+ *     } finally {
+ *       Fences.reachabilityFence(this);
+ *     }
+ *   }
+ *   private static void update(ExternalResource ext) {
+ *     ext.status = ...;
+ *   }
+ * }}</pre>
+ *
+ * Here, the call to {@code reachabilityFence} is nonintuitively
+ * placed <em>after</em> the call to {@code update}, to ensure that
+ * the array slot is not nulled out by {@link Object#finalize} before
+ * the update, even if the call to {@code action} was the last use of
+ * this object. This might be the case if for example a usage in a
+ * user program had the form {@code new Resource().action();} which
+ * retains no other reference to this Resource.  While probably
+ * overkill here, {@code reachabilityFence} is placed in a {@code
+ * finally} block to ensure that it is invoked across all paths in the
+ * method.  In a method with more complex control paths, you might
+ * need further precautions to ensure that {@code reachabilityFence}
+ * is encountered along all of them.
+ *
+ * <p>It is sometimes possible to better encapsulate use of
+ * {@code reachabilityFence}. Continuing the above example, if it
+ * were OK for the call to method update to proceed even if the
+ * finalizer had already executed (nulling out slot), then you could
+ * localize use of {@code reachabilityFence}:
+ *
+ *  <pre> {@code
+ * public void action2() {
+ *   // ...
+ *   Resource.update(getExternalResource());
+ * }
+ * private ExternalResource getExternalResource() {
+ *   ExternalResource ext = externalResourceArray[myIndex];
+ *   Fences.reachabilityFence(this);
+ *   return ext;
+ * }}</pre>
+ *
+ * <p>Method {@code reachabilityFence} is not required in
+ * constructions that themselves ensure reachability. For example,
+ * because objects that are locked cannot in general be reclaimed, it
+ * would suffice if all accesses of the object, in all methods of
+ * class Resource (including {@code finalize}) were enclosed in {@code
+ * synchronized (this)} blocks. (Further, such blocks must not include
+ * infinite loops, or themselves be unreachable, which fall into the
+ * corner case exceptions to the "in general" disclaimer.) However,
+ * method {@code reachabilityFence} remains a better option in cases
+ * where this approach is not as efficient, desirable, or possible;
+ * for example because it would encounter deadlock.
+ *
+ * <p><b>Formal Properties.</b>
+ *
+ * <p>Using the terminology of The Java Language Specification chapter
+ * 17, the rules governing the semantics of the methods of this class
+ * are as follows:
+ *
+ * <p> The following is still under construction.
+ *
+ * <dl>
+ *
+ *   <dt><b>[Definitions]</b>
+ *   <dd>
+ *   <ul>
+ *
+ *     <li>Define <em>sequenced(a, b)</em> to be true if <em>a</em>
+ *     occurs before <em>b</em> in <em>program order</em>.
+ *
+ *     <li>Define <em>accesses(a, p)</em> to be true if
+ *     <em>a</em> is a read or write of a field (or if an array, an
+ *     element) of the object referenced by <em>p</em>.
+ *
+ *     <li>Define <em>deeplyAccesses(a, p)</em> to be true if either
+ *     <em>accesses(a, p)</em> or <em>deeplyAccesses(a, q)</em> where
+ *     <em>q</em> is the value seen by some read <em>r</em>
+ *     such that <em>accesses(r, p)</em>.
+ *
+ *   </ul>
+ *   <p>
+ *   <dt><b>[Matching]</b>
+ *   <dd> Given:
+ *
+ *   <ul>
+ *
+ *     <li><em>p</em>, a reference to an object
+ *
+ *     <li><em>wf</em>, an invocation of {@code orderWrites(p)} or
+ *       {@code orderAccesses(p)}
+ *
+ *     <li><em>w</em>, a write of value <em>p</em>
+ *
+ *     <li> <em>rf</em>, an invocation of {@code orderReads(p)} or
+ *     {@code orderAccesses(p)}
+ *
+ *     <li> <em>r</em>, a read returning value <em>p</em>
+ *
+ *   </ul>
+ *   If:
+ *   <ul>
+ *     <li>sequenced(wf, w)
+ *     <li>read <em>r</em> sees write <em>w</em>
+ *     <li>sequenced(r, rf)
+ *   </ul>
+ *   Then:
+ *   <ul>
+ *
+ *     <li> <em>wf happens-before rf</em>
+ *
+ *     <li> <em>wf</em> precedes <em>rf</em> in the
+ *          <em>synchronization order</em>
+ *
+ *     <li> If (<em>r1</em>, <em>w1</em>) and (<em>r2</em>,
+ *     <em>w2</em>) are two pairs of reads and writes, both
+ *     respectively satisfying the above conditions for <em>p</em>,
+ *     and sequenced(r1, r2) then it is not the case that <em>w2
+ *     happens-before w1</em>.
+ *
+ *   </ul>
+ *   <p>
+ *   <dt><b>[Initial Reads]</b>
+ *   <dd> Given:
+ *
+ *   <ul>
+ *
+ *     <li><em>p</em>, a reference to an object
+ *
+ *     <li> <em>a</em>, an access where deeplyAccesses(a, p)
+ *
+ *     <li><em>wf</em>, an invocation of {@code orderWrites(p)} or
+ *       {@code orderAccesses(p)}
+ *
+ *     <li><em>w</em>, a write of value <em>p</em>
+ *
+ *     <li> <em>r</em>, a read returning value <em>p</em>
+ *
+ *     <li> <em>b</em>, an access where accesses(b, p)
+ *
+ *   </ul>
+ *   If:
+ *   <ul>
+ *     <li>sequenced(a, wf);
+ *     <li>sequenced(wf, w)
+ *     <li>read <em>r</em> sees write <em>w</em>, and
+ *         <em>r</em> is the first read by some thread
+ *         <em>t</em> that sees value <em>p</em>
+ *     <li>sequenced(r, b)
+ *   </ul>
+ *   Then:
+ *   <ul>
+ *     <li> the effects of <em>b</em> are constrained
+ *          by the relation <em>a happens-before b</em>.
+ *   </ul>
+ *  <p>
+ *  <dt><b>[orderAccesses]</b>
+ *  <dd> Given:
+ *
+ *   <ul>
+ *     <li><em>p</em>, a reference to an object
+ *     <li><em>f</em>, an invocation of {@code orderAccesses(p)}
+ *   </ul>
+ *   If:
+ *   <ul>
+ *     <li>sequenced(f, w)
+ *   </ul>
+ *
+ *    Then:
+ *
+ *   <ul>
+ *
+ *     <li> <em>f</em> is an element of the <em>synchronization order</em>.
+ *
+ *   </ul>
+ *   <p>
+ *   <dt><b>[Reachability]</b>
+ *   <dd> Given:
+ *
+ *   <ul>
+ *
+ *     <li><em>p</em>, a reference to an object
+ *
+ *     <li><em>f</em>, an invocation of {@code reachabilityFence(p)}
+ *
+ *     <li><em>a</em>, an access where accesses(a, p)
+ *
+ *     <li><em>b</em>, an action (by a garbage collector) taking
+ *     the form of an invocation of {@code
+ *     p.finalize()} or of enqueing any {@link
+ *     java.lang.ref.Reference} constructed with argument <em>p</em>
+ *
+ *   </ul>
+ *
+ *   If:
+ *   <ul>
+ *     <li>sequenced(a, f)
+ *   </ul>
+ *
+ *    Then:
+ *
+ *   <ul>
+ *
+ *     <li> <em>a happens-before b</em>.
+ *
+ *   </ul>
+ *
+ * </dl>
+ *
+ * @since 1.7
+ * @hide
+ * @author Doug Lea
+ */
+public class Fences {
+    private Fences() {} // Non-instantiable
+
+    /*
+     * The methods of this class are intended to be intrinisified by a
+     * JVM. However, we provide correct but inefficient Java-level
+     * code that simply reads and writes a static volatile
+     * variable. Without JVM support, the consistency effects are
+     * stronger than necessary, and the memory contention effects can
+     * be a serious performance issue.
+     */
+    private static volatile int theVolatile;
+
+    /**
+     * Informally: Ensures that a read of the given reference prior to
+     * the invocation of this method occurs before a subsequent use of
+     * the given reference with the effect of reading or writing a
+     * field (or if an array, element) of the referenced object.  The
+     * use of this method is sensible only when paired with other
+     * invocations of {@link #orderWrites} and/or {@link
+     * #orderAccesses} for the given reference. For details, see the
+     * class documentation for this class.
+     *
+     * @param ref the reference. If null, this method has no effect.
+     * @return the given ref, to simplify usage
+     */
+    public static <T> T orderReads(T ref) {
+        int ignore = theVolatile;
+        return ref;
+    }
+
+    /**
+     * Informally: Ensures that a use of the given reference with the
+     * effect of reading or writing a field (or if an array, element)
+     * of the referenced object, prior to the invocation of this
+     * method occur before a subsequent write of the reference. For
+     * details, see the class documentation for this class.
+     *
+     * @param ref the reference. If null, this method has no effect.
+     * @return the given ref, to simplify usage
+     */
+    public static <T> T orderWrites(T ref) {
+        theVolatile = 0;
+        return ref;
+    }
+
+    /**
+     * Informally: Ensures that accesses (reads or writes) using the
+     * given reference prior to the invocation of this method occur
+     * before subsequent accesses.  For details, see the class
+     * documentation for this class.
+     *
+     * @param ref the reference. If null, this method has no effect.
+     * @return the given ref, to simplify usage
+     */
+    public static <T> T orderAccesses(T ref) {
+        theVolatile = 0;
+        return ref;
+    }
+
+    /**
+     * Ensures that the object referenced by the given reference
+     * remains <em>strongly reachable</em> (as defined in the {@link
+     * java.lang.ref} package documentation), regardless of any prior
+     * actions of the program that might otherwise cause the object to
+     * become unreachable; thus, the referenced object is not
+     * reclaimable by garbage collection at least until after the
+     * invocation of this method. Invocation of this method does not
+     * itself initiate garbage collection or finalization.
+     *
+     * <p>See the class-level documentation for further explanation
+     * and usage examples.
+     *
+     * @param ref the reference. If null, this method has no effect.
+     */
+    public static void reachabilityFence(Object ref) {
+        if (ref != null) {
+            synchronized (ref) {}
+        }
+    }
+}
diff --git a/luni/src/main/java/java/util/concurrent/atomic/UnsafeAccess.java b/luni/src/main/java/java/util/concurrent/atomic/UnsafeAccess.java
deleted file mode 100644
index 96fff17..0000000
--- a/luni/src/main/java/java/util/concurrent/atomic/UnsafeAccess.java
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
- * Copyright (C) 2008 The Android Open Source Project
- *
- * Licensed 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 java.util.concurrent.atomic;
-
-import sun.misc.Unsafe;
-
-/**
- * Easy access to {@link Unsafe} for the rest of this package.
- */
-/*package*/ final class UnsafeAccess {
-    /** non-null; unique instance of {@link Unsafe} */
-    /*package*/ static final Unsafe THE_ONE = Unsafe.getUnsafe();
-
-    /**
-     * This class is uninstantiable.
-     */
-    private UnsafeAccess() {
-        // This space intentionally left blank.
-    }
-}
diff --git a/luni/src/main/java/java/util/concurrent/atomic/package-info.java b/luni/src/main/java/java/util/concurrent/atomic/package-info.java
index 4a4375d..efbb413 100644
--- a/luni/src/main/java/java/util/concurrent/atomic/package-info.java
+++ b/luni/src/main/java/java/util/concurrent/atomic/package-info.java
@@ -1,7 +1,7 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 /**
@@ -11,9 +11,7 @@
  * array elements to those that also provide an atomic conditional update
  * operation of the form:
  *
- * <pre>
- *   boolean compareAndSet(expectedValue, updateValue);
- * </pre>
+ *  <pre> {@code boolean compareAndSet(expectedValue, updateValue);}</pre>
  *
  * <p>This method (which varies in argument types across different
  * classes) atomically sets a variable to the {@code updateValue} if it
@@ -40,15 +38,30 @@
  * {@code AtomicInteger} provide atomic increment methods.  One
  * application is to generate sequence numbers, as in:
  *
- * <pre>
+ *  <pre> {@code
  * class Sequencer {
  *   private final AtomicLong sequenceNumber
  *     = new AtomicLong(0);
  *   public long next() {
  *     return sequenceNumber.getAndIncrement();
  *   }
- * }
- * </pre>
+ * }}</pre>
+ *
+ * <p>It is straightforward to define new utility functions that, like
+ * {@code getAndIncrement}, apply a function to a value atomically.
+ * For example, given some transformation
+ * <pre> {@code long transform(long input)}</pre>
+ *
+ * write your utility method as follows:
+ *  <pre> {@code
+ * boolean getAndTransform(AtomicLong var) {
+ *   while (true) {
+ *     long current = var.get();
+ *     long next = transform(current);
+ *     if (var.compareAndSet(current, next))
+ *         return current;
+ *   }
+ * }}</pre>
  *
  * <p>The memory effects for accesses and updates of atomics generally
  * follow the rules for volatiles, as stated in
@@ -161,9 +174,9 @@
  * {@code byte} values, and cast appropriately.
  *
  * You can also hold floats using
- * {@link java.lang.Float#floatToIntBits} and
+ * {@link java.lang.Float#floatToRawIntBits} and
  * {@link java.lang.Float#intBitsToFloat} conversions, and doubles using
- * {@link java.lang.Double#doubleToLongBits} and
+ * {@link java.lang.Double#doubleToRawLongBits} and
  * {@link java.lang.Double#longBitsToDouble} conversions.
  *
  * @since 1.5
diff --git a/luni/src/main/java/java/util/concurrent/locks/AbstractOwnableSynchronizer.java b/luni/src/main/java/java/util/concurrent/locks/AbstractOwnableSynchronizer.java
index f3780e5..4bec0cf 100644
--- a/luni/src/main/java/java/util/concurrent/locks/AbstractOwnableSynchronizer.java
+++ b/luni/src/main/java/java/util/concurrent/locks/AbstractOwnableSynchronizer.java
@@ -1,7 +1,7 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent.locks;
diff --git a/luni/src/main/java/java/util/concurrent/locks/AbstractQueuedLongSynchronizer.java b/luni/src/main/java/java/util/concurrent/locks/AbstractQueuedLongSynchronizer.java
index 5c8111c..7b36460 100644
--- a/luni/src/main/java/java/util/concurrent/locks/AbstractQueuedLongSynchronizer.java
+++ b/luni/src/main/java/java/util/concurrent/locks/AbstractQueuedLongSynchronizer.java
@@ -1,13 +1,12 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent.locks;
 import java.util.*;
 import java.util.concurrent.*;
-import java.util.concurrent.atomic.*;
 import sun.misc.Unsafe;
 
 /**
@@ -569,7 +568,7 @@ public abstract class AbstractQueuedLongSynchronizer
     /**
      * Convenience method to interrupt current thread.
      */
-    private static void selfInterrupt() {
+    static void selfInterrupt() {
         Thread.currentThread().interrupt();
     }
 
@@ -1231,7 +1230,7 @@ public abstract class AbstractQueuedLongSynchronizer
      * due to the queue being empty.
      *
      * <p>This method is designed to be used by a fair synchronizer to
-     * avoid <a href="AbstractQueuedSynchronizer#barging">barging</a>.
+     * avoid <a href="AbstractQueuedSynchronizer.html#barging">barging</a>.
      * Such a synchronizer's {@link #tryAcquire} method should return
      * {@code false}, and its {@link #tryAcquireShared} method should
      * return a negative value, if this method returns {@code true}
diff --git a/luni/src/main/java/java/util/concurrent/locks/AbstractQueuedSynchronizer.java b/luni/src/main/java/java/util/concurrent/locks/AbstractQueuedSynchronizer.java
index 065f130..42029f0 100644
--- a/luni/src/main/java/java/util/concurrent/locks/AbstractQueuedSynchronizer.java
+++ b/luni/src/main/java/java/util/concurrent/locks/AbstractQueuedSynchronizer.java
@@ -1,13 +1,12 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent.locks;
 import java.util.*;
 import java.util.concurrent.*;
-import java.util.concurrent.atomic.*;
 import sun.misc.Unsafe;
 
 // BEGIN android-note
@@ -173,7 +172,7 @@ import sun.misc.Unsafe;
  * It also supports conditions and exposes
  * one of the instrumentation methods:
  *
- * <pre>
+ *  <pre> {@code
  * class Mutex implements Lock, java.io.Serializable {
  *
  *   // Our internal helper class
@@ -229,15 +228,14 @@ import sun.misc.Unsafe;
  *       throws InterruptedException {
  *     return sync.tryAcquireNanos(1, unit.toNanos(timeout));
  *   }
- * }
- * </pre>
+ * }}</pre>
  *
  * <p>Here is a latch class that is like a {@link CountDownLatch}
  * except that it only requires a single <tt>signal</tt> to
  * fire. Because a latch is non-exclusive, it uses the <tt>shared</tt>
  * acquire and release methods.
  *
- * <pre>
+ *  <pre> {@code
  * class BooleanLatch {
  *
  *   private static class Sync extends AbstractQueuedSynchronizer {
@@ -259,8 +257,7 @@ import sun.misc.Unsafe;
  *   public void await() throws InterruptedException {
  *     sync.acquireSharedInterruptibly(1);
  *   }
- * }
- * </pre>
+ * }}</pre>
  *
  * @since 1.5
  * @author Doug Lea
@@ -800,7 +797,7 @@ public abstract class AbstractQueuedSynchronizer
     /**
      * Convenience method to interrupt current thread.
      */
-    private static void selfInterrupt() {
+    static void selfInterrupt() {
         Thread.currentThread().interrupt();
     }
 
@@ -2251,9 +2248,7 @@ public abstract class AbstractQueuedSynchronizer
      * are at it, we do the same for other CASable fields (which could
      * otherwise be done with atomic field updaters).
      */
-    // BEGIN android-changed
-    private static final Unsafe unsafe = UnsafeAccess.THE_ONE;
-    // END android-changed
+    private static final Unsafe unsafe = Unsafe.getUnsafe();
     private static final long stateOffset;
     private static final long headOffset;
     private static final long tailOffset;
diff --git a/luni/src/main/java/java/util/concurrent/locks/Condition.java b/luni/src/main/java/java/util/concurrent/locks/Condition.java
index 8504e1f..7050df9 100644
--- a/luni/src/main/java/java/util/concurrent/locks/Condition.java
+++ b/luni/src/main/java/java/util/concurrent/locks/Condition.java
@@ -1,7 +1,7 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent.locks;
@@ -331,10 +331,9 @@ public interface Condition {
     /**
      * Causes the current thread to wait until it is signalled or interrupted,
      * or the specified waiting time elapses. This method is behaviorally
-     * equivalent to:<br>
-     * <pre>
-     *   awaitNanos(unit.toNanos(time)) &gt; 0
-     * </pre>
+     * equivalent to:
+     *  <pre> {@code awaitNanos(unit.toNanos(time)) > 0}</pre>
+     *
      * @param time the maximum time to wait
      * @param unit the time unit of the {@code time} argument
      * @return {@code false} if the waiting time detectably elapsed
diff --git a/luni/src/main/java/java/util/concurrent/locks/Lock.java b/luni/src/main/java/java/util/concurrent/locks/Lock.java
index 4b9abd6..d5c6294 100644
--- a/luni/src/main/java/java/util/concurrent/locks/Lock.java
+++ b/luni/src/main/java/java/util/concurrent/locks/Lock.java
@@ -1,7 +1,7 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent.locks;
@@ -48,14 +48,14 @@ import java.util.concurrent.TimeUnit;
  * methods and statements. In most cases, the following idiom
  * should be used:
  *
- * <pre><tt>     Lock l = ...;
- *     l.lock();
- *     try {
- *         // access the resource protected by this lock
- *     } finally {
- *         l.unlock();
- *     }
- * </tt></pre>
+ *  <pre> {@code
+ * Lock l = ...;
+ * l.lock();
+ * try {
+ *   // access the resource protected by this lock
+ * } finally {
+ *   l.unlock();
+ * }}</pre>
  *
  * When locking and unlocking occur in different scopes, care must be
  * taken to ensure that all code that is executed while the lock is
@@ -210,18 +210,18 @@ public interface Lock {
      * immediately with the value {@code false}.
      *
      * <p>A typical usage idiom for this method would be:
-     * <pre>
-     *      Lock lock = ...;
-     *      if (lock.tryLock()) {
-     *          try {
-     *              // manipulate protected state
-     *          } finally {
-     *              lock.unlock();
-     *          }
-     *      } else {
-     *          // perform alternative actions
-     *      }
-     * </pre>
+     *  <pre> {@code
+     * Lock lock = ...;
+     * if (lock.tryLock()) {
+     *   try {
+     *     // manipulate protected state
+     *   } finally {
+     *     lock.unlock();
+     *   }
+     * } else {
+     *   // perform alternative actions
+     * }}</pre>
+     *
      * This usage ensures that the lock is unlocked if it was acquired, and
      * doesn't try to unlock if the lock was not acquired.
      *
diff --git a/luni/src/main/java/java/util/concurrent/locks/LockSupport.java b/luni/src/main/java/java/util/concurrent/locks/LockSupport.java
index 0c0f07d..422e428 100644
--- a/luni/src/main/java/java/util/concurrent/locks/LockSupport.java
+++ b/luni/src/main/java/java/util/concurrent/locks/LockSupport.java
@@ -1,11 +1,10 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent.locks;
-import java.util.concurrent.*;
 import sun.misc.Unsafe;
 
 
@@ -49,7 +48,10 @@ import sun.misc.Unsafe;
  * higher-level synchronization utilities, and are not in themselves
  * useful for most concurrency control applications.  The {@code park}
  * method is designed for use only in constructions of the form:
- * <pre>while (!canProceed()) { ... LockSupport.park(this); }</pre>
+ *
+ *  <pre> {@code
+ * while (!canProceed()) { ... LockSupport.park(this); }}</pre>
+ *
  * where neither {@code canProceed} nor any other actions prior to the
  * call to {@code park} entail locking or blocking.  Because only one
  * permit is associated with each thread, any intermediary uses of
@@ -57,7 +59,7 @@ import sun.misc.Unsafe;
  *
  * <p><b>Sample Usage.</b> Here is a sketch of a first-in-first-out
  * non-reentrant lock class:
- * <pre>{@code
+ *  <pre> {@code
  * class FIFOMutex {
  *   private final AtomicBoolean locked = new AtomicBoolean(false);
  *   private final Queue<Thread> waiters
@@ -92,7 +94,7 @@ public class LockSupport {
     private LockSupport() {} // Cannot be instantiated.
 
     // Hotspot implementation via intrinsics API
-    private static final Unsafe unsafe = UnsafeAccess.THE_ONE; // android-changed
+    private static final Unsafe unsafe = Unsafe.getUnsafe();
     private static final long parkBlockerOffset;
 
     static {
@@ -246,10 +248,14 @@ public class LockSupport {
      * snapshot -- the thread may have since unblocked or blocked on a
      * different blocker object.
      *
+     * @param t the thread
      * @return the blocker
+     * @throws NullPointerException if argument is null
      * @since 1.6
      */
     public static Object getBlocker(Thread t) {
+        if (t == null)
+            throw new NullPointerException();
         return unsafe.getObjectVolatile(t, parkBlockerOffset);
     }
 
diff --git a/luni/src/main/java/java/util/concurrent/locks/ReadWriteLock.java b/luni/src/main/java/java/util/concurrent/locks/ReadWriteLock.java
index 484f68d..bb7b388 100644
--- a/luni/src/main/java/java/util/concurrent/locks/ReadWriteLock.java
+++ b/luni/src/main/java/java/util/concurrent/locks/ReadWriteLock.java
@@ -1,7 +1,7 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent.locks;
diff --git a/luni/src/main/java/java/util/concurrent/locks/ReentrantLock.java b/luni/src/main/java/java/util/concurrent/locks/ReentrantLock.java
index cf787ca..07baf41 100644
--- a/luni/src/main/java/java/util/concurrent/locks/ReentrantLock.java
+++ b/luni/src/main/java/java/util/concurrent/locks/ReentrantLock.java
@@ -1,13 +1,12 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent.locks;
 import java.util.*;
 import java.util.concurrent.*;
-import java.util.concurrent.atomic.*;
 
 /**
  * A reentrant mutual exclusion {@link Lock} with the same basic
@@ -44,7 +43,7 @@ import java.util.concurrent.atomic.*;
  * follow a call to {@code lock} with a {@code try} block, most
  * typically in a before/after construction such as:
  *
- * <pre>
+ *  <pre> {@code
  * class X {
  *   private final ReentrantLock lock = new ReentrantLock();
  *   // ...
@@ -57,8 +56,7 @@ import java.util.concurrent.atomic.*;
  *       lock.unlock()
  *     }
  *   }
- * }
- * </pre>
+ * }}</pre>
  *
  * <p>In addition to implementing the {@link Lock} interface, this
  * class defines methods {@code isLocked} and
@@ -354,8 +352,11 @@ public class ReentrantLock implements Lock, java.io.Serializable {
      * method. If you want a timed {@code tryLock} that does permit barging on
      * a fair lock then combine the timed and un-timed forms together:
      *
-     * <pre>if (lock.tryLock() || lock.tryLock(timeout, unit) ) { ... }
-     * </pre>
+     *  <pre> {@code
+     * if (lock.tryLock() ||
+     *     lock.tryLock(timeout, unit)) {
+     *   ...
+     * }}</pre>
      *
      * <p>If the current thread
      * already holds this lock then the hold count is incremented by one and
@@ -485,7 +486,7 @@ public class ReentrantLock implements Lock, java.io.Serializable {
      * not be entered with the lock already held then we can assert that
      * fact:
      *
-     * <pre>
+     *  <pre> {@code
      * class X {
      *   ReentrantLock lock = new ReentrantLock();
      *   // ...
@@ -498,8 +499,7 @@ public class ReentrantLock implements Lock, java.io.Serializable {
      *       lock.unlock();
      *     }
      *   }
-     * }
-     * </pre>
+     * }}</pre>
      *
      * @return the number of holds on this lock by the current thread,
      *         or zero if this lock is not held by the current thread
@@ -516,7 +516,7 @@ public class ReentrantLock implements Lock, java.io.Serializable {
      * testing. For example, a method that should only be called while
      * a lock is held can assert that this is the case:
      *
-     * <pre>
+     *  <pre> {@code
      * class X {
      *   ReentrantLock lock = new ReentrantLock();
      *   // ...
@@ -525,13 +525,12 @@ public class ReentrantLock implements Lock, java.io.Serializable {
      *       assert lock.isHeldByCurrentThread();
      *       // ... method body
      *   }
-     * }
-     * </pre>
+     * }}</pre>
      *
      * <p>It can also be used to ensure that a reentrant lock is used
      * in a non-reentrant manner, for example:
      *
-     * <pre>
+     *  <pre> {@code
      * class X {
      *   ReentrantLock lock = new ReentrantLock();
      *   // ...
@@ -545,8 +544,7 @@ public class ReentrantLock implements Lock, java.io.Serializable {
      *           lock.unlock();
      *       }
      *   }
-     * }
-     * </pre>
+     * }}</pre>
      *
      * @return {@code true} if current thread holds this lock and
      *         {@code false} otherwise
diff --git a/luni/src/main/java/java/util/concurrent/locks/ReentrantReadWriteLock.java b/luni/src/main/java/java/util/concurrent/locks/ReentrantReadWriteLock.java
index b1a1a60..244a4a7 100644
--- a/luni/src/main/java/java/util/concurrent/locks/ReentrantReadWriteLock.java
+++ b/luni/src/main/java/java/util/concurrent/locks/ReentrantReadWriteLock.java
@@ -1,12 +1,11 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 package java.util.concurrent.locks;
 import java.util.concurrent.*;
-import java.util.concurrent.atomic.*;
 import java.util.*;
 
 /**
@@ -33,7 +32,7 @@ import java.util.*;
  * <dt><b><i>Fair mode</i></b>
  * <dd> When constructed as fair, threads contend for entry using an
  * approximately arrival-order policy. When the currently held lock
- * is released either the longest-waiting single writer thread will
+ * is released, either the longest-waiting single writer thread will
  * be assigned the write lock, or if there is a group of reader threads
  * waiting longer than all waiting writer threads, that group will be
  * assigned the read lock.
@@ -51,8 +50,8 @@ import java.util.*;
  * will block unless both the read lock and write lock are free (which
  * implies there are no waiting threads).  (Note that the non-blocking
  * {@link ReadLock#tryLock()} and {@link WriteLock#tryLock()} methods
- * do not honor this fair setting and will acquire the lock if it is
- * possible, regardless of waiting threads.)
+ * do not honor this fair setting and will immediately acquire the lock
+ * if it is possible, regardless of waiting threads.)
  * <p>
  * </dl>
  *
@@ -114,21 +113,21 @@ import java.util.*;
  *   void processCachedData() {
  *     rwl.readLock().lock();
  *     if (!cacheValid) {
- *        // Must release read lock before acquiring write lock
- *        rwl.readLock().unlock();
- *        rwl.writeLock().lock();
- *        try {
- *          // Recheck state because another thread might have
- *          // acquired write lock and changed state before we did.
- *          if (!cacheValid) {
- *            data = ...
- *            cacheValid = true;
- *          }
- *          // Downgrade by acquiring read lock before releasing write lock
- *          rwl.readLock().lock();
- *        } finally {
- *          rwl.writeLock().unlock(); // Unlock write, still hold read
- *        }
+ *       // Must release read lock before acquiring write lock
+ *       rwl.readLock().unlock();
+ *       rwl.writeLock().lock();
+ *       try {
+ *         // Recheck state because another thread might have
+ *         // acquired write lock and changed state before we did.
+ *         if (!cacheValid) {
+ *           data = ...
+ *           cacheValid = true;
+ *         }
+ *         // Downgrade by acquiring read lock before releasing write lock
+ *         rwl.readLock().lock();
+ *       } finally {
+ *         rwl.writeLock().unlock(); // Unlock write, still hold read
+ *       }
  *     }
  *
  *     try {
@@ -147,33 +146,33 @@ import java.util.*;
  * is a class using a TreeMap that is expected to be large and
  * concurrently accessed.
  *
- * <pre>{@code
+ *  <pre> {@code
  * class RWDictionary {
- *    private final Map<String, Data> m = new TreeMap<String, Data>();
- *    private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
- *    private final Lock r = rwl.readLock();
- *    private final Lock w = rwl.writeLock();
+ *   private final Map<String, Data> m = new TreeMap<String, Data>();
+ *   private final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
+ *   private final Lock r = rwl.readLock();
+ *   private final Lock w = rwl.writeLock();
  *
- *    public Data get(String key) {
- *        r.lock();
- *        try { return m.get(key); }
- *        finally { r.unlock(); }
- *    }
- *    public String[] allKeys() {
- *        r.lock();
- *        try { return m.keySet().toArray(); }
- *        finally { r.unlock(); }
- *    }
- *    public Data put(String key, Data value) {
- *        w.lock();
- *        try { return m.put(key, value); }
- *        finally { w.unlock(); }
- *    }
- *    public void clear() {
- *        w.lock();
- *        try { m.clear(); }
- *        finally { w.unlock(); }
- *    }
+ *   public Data get(String key) {
+ *     r.lock();
+ *     try { return m.get(key); }
+ *     finally { r.unlock(); }
+ *   }
+ *   public String[] allKeys() {
+ *     r.lock();
+ *     try { return m.keySet().toArray(); }
+ *     finally { r.unlock(); }
+ *   }
+ *   public Data put(String key, Data value) {
+ *     w.lock();
+ *     try { return m.put(key, value); }
+ *     finally { w.unlock(); }
+ *   }
+ *   public void clear() {
+ *     w.lock();
+ *     try { m.clear(); }
+ *     finally { w.unlock(); }
+ *   }
  * }}</pre>
  *
  * <h3>Implementation Notes</h3>
@@ -625,7 +624,9 @@ public class ReentrantReadWriteLock
         }
 
         /**
-         * Reconstitute this lock instance from a stream
+         * Reconstitutes this lock instance from a stream (that is,
+         * deserializes it).
+         *
          * @param s the stream
          */
         private void readObject(java.io.ObjectInputStream s)
@@ -790,8 +791,11 @@ public class ReentrantReadWriteLock
          * permit barging on a fair lock then combine the timed and
          * un-timed forms together:
          *
-         * <pre>if (lock.tryLock() || lock.tryLock(timeout, unit) ) { ... }
-         * </pre>
+         *  <pre> {@code
+         * if (lock.tryLock() ||
+         *     lock.tryLock(timeout, unit)) {
+         *   ...
+         * }}</pre>
          *
          * <p>If the write lock is held by another thread then the
          * current thread becomes disabled for thread scheduling
@@ -1020,8 +1024,11 @@ public class ReentrantReadWriteLock
          * that does permit barging on a fair lock then combine the
          * timed and un-timed forms together:
          *
-         * <pre>if (lock.tryLock() || lock.tryLock(timeout, unit) ) { ... }
-         * </pre>
+         *  <pre> {@code
+         * if (lock.tryLock() ||
+         *     lock.tryLock(timeout, unit)) {
+         *   ...
+         * }}</pre>
          *
          * <p>If the current thread already holds this lock then the
          * hold count is incremented by one and the method returns
diff --git a/luni/src/main/java/java/util/concurrent/locks/UnsafeAccess.java b/luni/src/main/java/java/util/concurrent/locks/UnsafeAccess.java
deleted file mode 100644
index 07f64e4..0000000
--- a/luni/src/main/java/java/util/concurrent/locks/UnsafeAccess.java
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
- * Copyright (C) 2008 The Android Open Source Project
- *
- * Licensed 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 java.util.concurrent.locks;
-
-import sun.misc.Unsafe;
-
-/**
- * Easy access to {@link Unsafe} for the rest of this package.
- */
-/*package*/ final class UnsafeAccess {
-    /** non-null; unique instance of {@link Unsafe} */
-    /*package*/ static final Unsafe THE_ONE = Unsafe.getUnsafe();
-
-    /**
-     * This class is uninstantiable.
-     */
-    private UnsafeAccess() {
-        // This space intentionally left blank.
-    }
-}
diff --git a/luni/src/main/java/java/util/concurrent/locks/package-info.java b/luni/src/main/java/java/util/concurrent/locks/package-info.java
index 860acdd..433f869 100644
--- a/luni/src/main/java/java/util/concurrent/locks/package-info.java
+++ b/luni/src/main/java/java/util/concurrent/locks/package-info.java
@@ -1,7 +1,7 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 /**
diff --git a/luni/src/main/java/java/util/concurrent/package-info.java b/luni/src/main/java/java/util/concurrent/package-info.java
index 8509a41..259b845 100644
--- a/luni/src/main/java/java/util/concurrent/package-info.java
+++ b/luni/src/main/java/java/util/concurrent/package-info.java
@@ -1,11 +1,11 @@
 /*
  * Written by Doug Lea with assistance from members of JCP JSR-166
  * Expert Group and released to the public domain, as explained at
- * http://creativecommons.org/licenses/publicdomain
+ * http://creativecommons.org/publicdomain/zero/1.0/
  */
 
 // BEGIN android-note
-// Dropped references to unreleased APIs (ForkJoinPool, Phaser, etc.)
+// omit links to ForkJoinPool, ForkJoinTask, LinkedTransferQueue, PHaser, TransferQueue
 // END android-note
 
 /**
@@ -146,7 +146,7 @@
  * A {@code CopyOnWriteArrayList} is preferable to a synchronized
  * {@code ArrayList} when the expected number of reads and traversals
  * greatly outnumber the number of updates to a list.
-
+ *
  * <p>The "Concurrent" prefix used with some classes in this package
  * is a shorthand indicating several differences from similar
  * "synchronized" classes.  For example {@code java.util.Hashtable} and
@@ -243,7 +243,8 @@
  *   in each thread <i>happen-before</i> those subsequent to the
  *   corresponding {@code exchange()} in another thread.
  *
- *   <li>Actions prior to calling {@code CyclicBarrier.await}
+ *   <li>Actions prior to calling {@code CyclicBarrier.await} and
+ *   {@code Phaser.awaitAdvance} (as well as its variants)
  *   <i>happen-before</i> actions performed by the barrier action, and
  *   actions performed by the barrier action <i>happen-before</i> actions
  *   subsequent to a successful return from the corresponding {@code await}
-- 
cgit v1.1


From 56444c0884abdbd0946d4e601d534edda0bb2aac Mon Sep 17 00:00:00 2001
From: Jesse Wilson <jessewilson@google.com>
Date: Mon, 21 Nov 2011 20:04:33 -0500
Subject: Don't serialize a Throwable's stackState field.

In some situations this field may reference a non-serializable value.

(cherry-pick of 6c15570a27c2b7aad18ae2064db2eae921be27e0.)

Change-Id: I78607bbcb707fc1ab43cfbaba4647d91b9d90ad4
---
 luni/src/main/java/java/lang/Throwable.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/luni/src/main/java/java/lang/Throwable.java b/luni/src/main/java/java/lang/Throwable.java
index e88d6ce..31eb538 100644
--- a/luni/src/main/java/java/lang/Throwable.java
+++ b/luni/src/main/java/java/lang/Throwable.java
@@ -70,7 +70,7 @@ public class Throwable implements java.io.Serializable {
      * An intermediate representation of the stack trace.  This field may
      * be accessed by the VM; do not rename.
      */
-    private volatile Object stackState;
+    private transient volatile Object stackState;
 
     /**
      * A fully-expanded representation of the stack trace.
-- 
cgit v1.1


From 1baa4fcbfe3c22e5f06a4fee48f520162d23270f Mon Sep 17 00:00:00 2001
From: Jesse Wilson <jessewilson@google.com>
Date: Wed, 22 Jun 2011 09:40:11 -0700
Subject: Don't cache partial sets of date fields in Calendar.

This was only useful when modifying calendars within a single day.
Not worth the complexity, and possibly a source of bugs.

(cherry-pick of 0170a5c2cd87d90e11513a45f29ebafee6a1701c.)

Bug: 2435103
Change-Id: Ib6d68aed29f424ac464fc389e7ae26909667b9b9
---
 luni/src/main/java/java/util/Calendar.java         |  10 +-
 .../src/main/java/java/util/GregorianCalendar.java | 231 ++-------------------
 2 files changed, 18 insertions(+), 223 deletions(-)

diff --git a/luni/src/main/java/java/util/Calendar.java b/luni/src/main/java/java/util/Calendar.java
index bef6e26..4cabd4a 100644
--- a/luni/src/main/java/java/util/Calendar.java
+++ b/luni/src/main/java/java/util/Calendar.java
@@ -877,8 +877,7 @@ public abstract class Calendar implements Serializable, Cloneable, Comparable<Ca
         return getTimeInMillis() == cal.getTimeInMillis()
                 && isLenient() == cal.isLenient()
                 && getFirstDayOfWeek() == cal.getFirstDayOfWeek()
-                && getMinimalDaysInFirstWeek() == cal
-                        .getMinimalDaysInFirstWeek()
+                && getMinimalDaysInFirstWeek() == cal.getMinimalDaysInFirstWeek()
                 && getTimeZone().equals(cal.getTimeZone());
     }
 
@@ -903,11 +902,8 @@ public abstract class Calendar implements Serializable, Cloneable, Comparable<Ca
     }
 
     /**
-     * Gets the maximum value of the specified field for the current date.
-     *
-     * @param field
-     *            the field.
-     * @return the maximum value of the specified field.
+     * Returns the maximum value of the specified field for the current date.
+     * For example, the maximum number of days in the current month.
      */
     public int getActualMaximum(int field) {
         int value, next;
diff --git a/luni/src/main/java/java/util/GregorianCalendar.java b/luni/src/main/java/java/util/GregorianCalendar.java
index 4d93aef..9ff9ccc 100644
--- a/luni/src/main/java/java/util/GregorianCalendar.java
+++ b/luni/src/main/java/java/util/GregorianCalendar.java
@@ -219,14 +219,6 @@ public class GregorianCalendar extends Calendar {
     private static int[] leastMaximums = new int[] { 1, 292269054, 11, 50, 3,
             28, 355, 7, 3, 1, 11, 23, 59, 59, 999, 50400000, 1200000 };
 
-    private boolean isCached;
-
-    private int[] cachedFields = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
-
-    private long nextMidnightMillis = 0L;
-
-    private long lastMidnightMillis = 0L;
-
     private int currentYearSkew = 10;
 
     private int lastYearSkew = 0;
@@ -365,8 +357,6 @@ public class GregorianCalendar extends Calendar {
             throw new IllegalArgumentException();
         }
 
-        isCached = false;
-
         if (field == ERA) {
             complete();
             if (fields[ERA] == AD) {
@@ -468,19 +458,8 @@ public class GregorianCalendar extends Calendar {
         complete();
     }
 
-    /**
-     * Creates new instance of {@code GregorianCalendar} with the same properties.
-     *
-     * @return a shallow copy of this {@code GregorianCalendar}.
-     */
-    @Override
-    public Object clone() {
-        GregorianCalendar thisClone = (GregorianCalendar) super.clone();
-        thisClone.cachedFields = cachedFields.clone();
-        return thisClone;
-    }
-
-    private final void fullFieldsCalc(long timeVal, int millis, int zoneOffset) {
+    private void fullFieldsCalc(long timeVal, int zoneOffset) {
+        int millis = (int) (time % 86400000);
         long days = timeVal / 86400000;
 
         if (millis < 0) {
@@ -583,31 +562,6 @@ public class GregorianCalendar extends Calendar {
         }
     }
 
-    private final void cachedFieldsCheckAndGet(long timeVal,
-            long newTimeMillis, long newTimeMillisAdjusted, int millis,
-            int zoneOffset) {
-        int dstOffset = fields[DST_OFFSET];
-        if (!isCached
-                || newTimeMillis >= nextMidnightMillis
-                || newTimeMillis <= lastMidnightMillis
-                || cachedFields[4] != zoneOffset
-                || (dstOffset == 0 && (newTimeMillisAdjusted >= nextMidnightMillis))
-                || (dstOffset != 0 && (newTimeMillisAdjusted <= lastMidnightMillis))) {
-            fullFieldsCalc(timeVal, millis, zoneOffset);
-            isCached = false;
-        } else {
-            fields[YEAR] = cachedFields[0];
-            fields[MONTH] = cachedFields[1];
-            fields[DATE] = cachedFields[2];
-            fields[DAY_OF_WEEK] = cachedFields[3];
-            fields[ERA] = cachedFields[5];
-            fields[WEEK_OF_YEAR] = cachedFields[6];
-            fields[WEEK_OF_MONTH] = cachedFields[7];
-            fields[DAY_OF_YEAR] = cachedFields[8];
-            fields[DAY_OF_WEEK_IN_MONTH] = cachedFields[9];
-        }
-    }
-
     @Override
     protected void computeFields() {
         TimeZone timeZone = getTimeZone();
@@ -616,99 +570,11 @@ public class GregorianCalendar extends Calendar {
         fields[DST_OFFSET] = dstOffset;
         fields[ZONE_OFFSET] = zoneOffset;
 
-        int millis = (int) (time % 86400000);
-        int savedMillis = millis;
-        // compute without a change in daylight saving time
-        int offset = zoneOffset + dstOffset;
-        long newTime = time + offset;
-
-        if (time > 0L && newTime < 0L && offset > 0) {
-            newTime = 0x7fffffffffffffffL;
-        } else if (time < 0L && newTime > 0L && offset < 0) {
-            newTime = 0x8000000000000000L;
-        }
-
-        // FIXME: I don't think this caching ever really gets used, because it requires that the
-        // time zone doesn't use daylight savings (ever). So unless you're somewhere like Taiwan...
-        if (isCached) {
-            if (millis < 0) {
-                millis += 86400000;
-            }
-
-            // Cannot add ZONE_OFFSET to time as it might overflow
-            millis += zoneOffset;
-            millis += dstOffset;
-
-            if (millis < 0) {
-                millis += 86400000;
-            } else if (millis >= 86400000) {
-                millis -= 86400000;
-            }
-
-            fields[MILLISECOND] = (millis % 1000);
-            millis /= 1000;
-            fields[SECOND] = (millis % 60);
-            millis /= 60;
-            fields[MINUTE] = (millis % 60);
-            millis /= 60;
-            fields[HOUR_OF_DAY] = (millis % 24);
-            millis /= 24;
-            fields[AM_PM] = fields[HOUR_OF_DAY] > 11 ? 1 : 0;
-            fields[HOUR] = fields[HOUR_OF_DAY] % 12;
-
-            // FIXME: this has to be wrong; useDaylightTime doesn't mean what they think it means!
-            long newTimeAdjusted = newTime;
-            if (timeZone.useDaylightTime()) {
-                int dstSavings = timeZone.getDSTSavings();
-                newTimeAdjusted += (dstOffset == 0) ? dstSavings : -dstSavings;
-            }
-
-            if (newTime > 0L && newTimeAdjusted < 0L && dstOffset == 0) {
-                newTimeAdjusted = 0x7fffffffffffffffL;
-            } else if (newTime < 0L && newTimeAdjusted > 0L && dstOffset != 0) {
-                newTimeAdjusted = 0x8000000000000000L;
-            }
-
-            cachedFieldsCheckAndGet(time, newTime, newTimeAdjusted,
-                    savedMillis, zoneOffset);
-        } else {
-            fullFieldsCalc(time, savedMillis, zoneOffset);
-        }
+        fullFieldsCalc(time, zoneOffset);
 
         for (int i = 0; i < FIELD_COUNT; i++) {
             isSet[i] = true;
         }
-
-        // Caching
-        if (!isCached
-                && newTime != 0x7fffffffffffffffL
-                && newTime != 0x8000000000000000L
-                && (!timeZone.useDaylightTime() || timeZone instanceof SimpleTimeZone)) {
-            int cacheMillis = 0;
-
-            cachedFields[0] = fields[YEAR];
-            cachedFields[1] = fields[MONTH];
-            cachedFields[2] = fields[DATE];
-            cachedFields[3] = fields[DAY_OF_WEEK];
-            cachedFields[4] = zoneOffset;
-            cachedFields[5] = fields[ERA];
-            cachedFields[6] = fields[WEEK_OF_YEAR];
-            cachedFields[7] = fields[WEEK_OF_MONTH];
-            cachedFields[8] = fields[DAY_OF_YEAR];
-            cachedFields[9] = fields[DAY_OF_WEEK_IN_MONTH];
-
-            cacheMillis += (23 - fields[HOUR_OF_DAY]) * 60 * 60 * 1000;
-            cacheMillis += (59 - fields[MINUTE]) * 60 * 1000;
-            cacheMillis += (59 - fields[SECOND]) * 1000;
-            nextMidnightMillis = newTime + cacheMillis;
-
-            cacheMillis = fields[HOUR_OF_DAY] * 60 * 60 * 1000;
-            cacheMillis += fields[MINUTE] * 60 * 1000;
-            cacheMillis += fields[SECOND] * 1000;
-            lastMidnightMillis = newTime - cacheMillis;
-
-            isCached = true;
-        }
     }
 
     @Override
@@ -939,19 +805,17 @@ public class GregorianCalendar extends Calendar {
         return (int) days + 1;
     }
 
-    private long daysFromBaseYear(int iyear) {
-        long year = iyear;
-
+    private long daysFromBaseYear(long year) {
         if (year >= 1970) {
             long days = (year - 1970) * 365 + ((year - 1969) / 4);
             if (year > changeYear) {
                 days -= ((year - 1901) / 100) - ((year - 1601) / 400);
             } else {
-                if(year == changeYear){
+                if (year == changeYear) {
                     days += currentYearSkew;
-                }else if(year == changeYear -1){
+                } else if (year == changeYear - 1) {
                     days += lastYearSkew;
-                }else{
+                } else {
                     days += julianSkew;
                 }
             }
@@ -995,21 +859,10 @@ public class GregorianCalendar extends Calendar {
     }
 
     /**
-     * Compares the specified {@code Object} to this {@code GregorianCalendar} and returns whether
-     * they are equal. To be equal, the {@code Object} must be an instance of {@code GregorianCalendar} and
-     * have the same properties.
-     *
-     * @param object
-     *            the {@code Object} to compare with this {@code GregorianCalendar}.
-     * @return {@code true} if {@code object} is equal to this
-     *         {@code GregorianCalendar}, {@code false} otherwise.
-     * @throws IllegalArgumentException
-     *                if the time is not set and the time cannot be computed
-     *                from the current field values.
-     * @see #hashCode
+     * Returns true if {@code object} is a GregorianCalendar with the same
+     * properties.
      */
-    @Override
-    public boolean equals(Object object) {
+    @Override public boolean equals(Object object) {
         if (!(object instanceof GregorianCalendar)) {
             return false;
         }
@@ -1020,28 +873,12 @@ public class GregorianCalendar extends Calendar {
                 && gregorianCutover == ((GregorianCalendar) object).gregorianCutover;
     }
 
-    /**
-     * Gets the maximum value of the specified field for the current date. For
-     * example, the maximum number of days in the current month.
-     *
-     * @param field
-     *            the field.
-     * @return the maximum value of the specified field.
-     */
-    @Override
-    public int getActualMaximum(int field) {
+    @Override public int getActualMaximum(int field) {
         int value;
         if ((value = maximums[field]) == leastMaximums[field]) {
             return value;
         }
 
-        switch (field) {
-            case WEEK_OF_YEAR:
-            case WEEK_OF_MONTH:
-                isCached = false;
-                break;
-        }
-
         complete();
         long orgTime = time;
         int result = 0;
@@ -1216,32 +1053,16 @@ public class GregorianCalendar extends Calendar {
             month++;
         }
         int dayOfWeek = mod7(dayCount - 3) + 1;
-        int offset = timeZone.getOffset(AD, year, month, date, dayOfWeek,
-                millis);
-        return offset;
+        return timeZone.getOffset(AD, year, month, date, dayOfWeek, millis);
     }
 
-    /**
-     * Returns an integer hash code for the receiver. Objects which are equal
-     * return the same value for this method.
-     *
-     * @return the receiver's hash.
-     *
-     * @see #equals
-     */
-    @Override
-    public int hashCode() {
+    @Override public int hashCode() {
         return super.hashCode()
                 + ((int) (gregorianCutover >>> 32) ^ (int) gregorianCutover);
     }
 
     /**
-     * Returns whether the specified year is a leap year.
-     *
-     * @param year
-     *            the year.
-     * @return {@code true} if the specified year is a leap year, {@code false}
-     *         otherwise.
+     * Returns true if {@code year} is a leap year.
      */
     public boolean isLeapYear(int year) {
         if (year > changeYear) {
@@ -1294,8 +1115,6 @@ public class GregorianCalendar extends Calendar {
             throw new IllegalArgumentException();
         }
 
-        isCached = false;
-
         complete();
         int days, day, mod, maxWeeks, newWeek;
         int max = -1;
@@ -1410,9 +1229,6 @@ public class GregorianCalendar extends Calendar {
 
     /**
      * Sets the gregorian change date of this calendar.
-     *
-     * @param date
-     *            a {@code Date} which represents the gregorian change date.
      */
     public void setGregorianChange(Date date) {
         gregorianCutover = date.getTime();
@@ -1424,7 +1240,6 @@ public class GregorianCalendar extends Calendar {
         }
         julianSkew = ((changeYear - 2000) / 400) + julianError()
                 - ((changeYear - 2000) / 100);
-        isCached = false;
         int dayOfYear = cal.get(DAY_OF_YEAR);
         if (dayOfYear < julianSkew) {
             currentYearSkew = dayOfYear-1;
@@ -1433,30 +1248,14 @@ public class GregorianCalendar extends Calendar {
             lastYearSkew = 0;
             currentYearSkew = julianSkew;
         }
-        isCached = false;
     }
 
     private void writeObject(ObjectOutputStream stream) throws IOException {
         stream.defaultWriteObject();
     }
 
-    private void readObject(ObjectInputStream stream) throws IOException,
-            ClassNotFoundException {
-
+    private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException {
         stream.defaultReadObject();
         setGregorianChange(new Date(gregorianCutover));
-        isCached = false;
-    }
-
-    @Override
-    public void setFirstDayOfWeek(int value) {
-        super.setFirstDayOfWeek(value);
-        isCached = false;
-    }
-
-    @Override
-    public void setMinimalDaysInFirstWeek(int value) {
-        super.setMinimalDaysInFirstWeek(value);
-        isCached = false;
     }
 }
-- 
cgit v1.1


From bbffd0389666ee4c3a44c9f111bc87cb8781c30e Mon Sep 17 00:00:00 2001
From: Carl Shapiro <cshapiro@google.com>
Date: Fri, 15 Jul 2011 19:02:39 -0700
Subject: Avoid the implicit NaN test in {float,double}To{Int,Long}Bits.

The possibility of ak being a NaN is eliminated by the preceding
compare to 0.0.  As such, a raw conversion will produce identical
results.

(cherry-pick of c9f45b2e4dd6c5f0bd96d8419370cdbbc7031ffa.)

Change-Id: Ic87cc137030d9d9e2f3c725ed15982b313323b5d
---
 luni/src/main/java/java/util/DualPivotQuicksort.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/luni/src/main/java/java/util/DualPivotQuicksort.java b/luni/src/main/java/java/util/DualPivotQuicksort.java
index 97797d1..5d2f77f 100644
--- a/luni/src/main/java/java/util/DualPivotQuicksort.java
+++ b/luni/src/main/java/java/util/DualPivotQuicksort.java
@@ -1565,7 +1565,7 @@ final class DualPivotQuicksort {
 
         for (int k = left; k <= n; k++) {
             float ak = a[k];
-            if (ak == 0.0f && NEGATIVE_ZERO == Float.floatToIntBits(ak)) {
+            if (ak == 0.0f && NEGATIVE_ZERO == Float.floatToRawIntBits(ak)) {
                 a[k] = 0.0f;
                 numNegativeZeros++;
             } else if (ak != ak) { // i.e., ak is NaN
@@ -1938,7 +1938,7 @@ final class DualPivotQuicksort {
 
         for (int k = left; k <= n; k++) {
             double ak = a[k];
-            if (ak == 0.0d && NEGATIVE_ZERO == Double.doubleToLongBits(ak)) {
+            if (ak == 0.0d && NEGATIVE_ZERO == Double.doubleToRawLongBits(ak)) {
                 a[k] = 0.0d;
                 numNegativeZeros++;
             } else if (ak != ak) { // i.e., ak is NaN
-- 
cgit v1.1


From 421f0b0e439b5baeb6d2888cf61c7acc0516e2ec Mon Sep 17 00:00:00 2001
From: Jesse Wilson <jessewilson@google.com>
Date: Wed, 7 Dec 2011 11:43:30 -0500
Subject: Include the failed key when a Hashtable put fails.

This helped debugging a problem I was running into when
getting vogar to work when System.getenv() was returning
null; it might help other developers in similar situations.

(cherry-pick of e9f1bc2eb660107ef925b3424f472e38b74b92ac.)

Change-Id: If58c16397b70ef747736df8d5491da15fa3a450c
---
 luni/src/main/java/java/util/Hashtable.java | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/luni/src/main/java/java/util/Hashtable.java b/luni/src/main/java/java/util/Hashtable.java
index cea29da..4ea26fb 100644
--- a/luni/src/main/java/java/util/Hashtable.java
+++ b/luni/src/main/java/java/util/Hashtable.java
@@ -361,8 +361,8 @@ public class Hashtable<K, V> extends Dictionary<K, V>
      * @see java.lang.Object#equals
      */
     public synchronized V put(K key, V value) {
-        if (value == null) {
-            throw new NullPointerException();
+        if (key == null || value == null) {
+            throw new NullPointerException("key=" + key + " value=" + value);
         }
         int hash = secondaryHash(key.hashCode());
         HashtableEntry<K, V>[] tab = table;
@@ -395,8 +395,8 @@ public class Hashtable<K, V> extends Dictionary<K, V>
      * ensure that capacity is sufficient, and does not increment modCount.
      */
     private void constructorPut(K key, V value) {
-        if (value == null) {
-            throw new NullPointerException();
+        if (key == null || value == null) {
+            throw new NullPointerException("key=" + key + " value=" + value);
         }
         int hash = secondaryHash(key.hashCode());
         HashtableEntry<K, V>[] tab = table;
@@ -680,7 +680,7 @@ public class Hashtable<K, V> extends Dictionary<K, V>
 
         public final V setValue(V value) {
             if (value == null) {
-                throw new NullPointerException();
+                throw new NullPointerException("key=" + key + " value=" + value);
             }
             V oldValue = this.value;
             this.value = value;
-- 
cgit v1.1


From 687409006d21cb01c56b3a3acc180952bb4d7e3e Mon Sep 17 00:00:00 2001
From: Jesse Wilson <jessewilson@google.com>
Date: Wed, 22 Jun 2011 11:01:08 -0700
Subject: Don't call overrideable methods from a constructor.

Conflicts:

	luni/src/test/java/libcore/java/util/TimeZoneTest.java

(cherry-pick of 7dbf334facc7f43c18244150d2052ae4ec8c5e16.)

Change-Id: I0aa0f3c8776538076bdfed070da08e65aa959486
---
 luni/src/main/java/java/util/SimpleTimeZone.java   | 13 +++++++++---
 .../test/java/libcore/java/util/TimeZoneTest.java  | 23 ++++++++++++++++++++--
 2 files changed, 31 insertions(+), 5 deletions(-)

diff --git a/luni/src/main/java/java/util/SimpleTimeZone.java b/luni/src/main/java/java/util/SimpleTimeZone.java
index 6c9b443..93dc88e 100644
--- a/luni/src/main/java/java/util/SimpleTimeZone.java
+++ b/luni/src/main/java/java/util/SimpleTimeZone.java
@@ -217,10 +217,17 @@ public class SimpleTimeZone extends TimeZone {
             throw new IllegalArgumentException("Invalid daylightSavings: " + daylightSavings);
         }
         dstSavings = daylightSavings;
-        // TODO: do we need to set useDaylight is dstSavings != 0?
 
-        setStartRule(startMonth, startDay, startDayOfWeek, startTime);
-        setEndRule(endMonth, endDay, endDayOfWeek, endTime);
+        this.startMonth = startMonth;
+        this.startDay = startDay;
+        this.startDayOfWeek = startDayOfWeek;
+        this.startTime = startTime;
+        setStartMode();
+        this.endMonth = endMonth;
+        this.endDay = endDay;
+        this.endDayOfWeek = endDayOfWeek;
+        this.endTime = endTime;
+        setEndMode();
     }
 
     /**
diff --git a/luni/src/test/java/libcore/java/util/TimeZoneTest.java b/luni/src/test/java/libcore/java/util/TimeZoneTest.java
index d5fa558..6e8b8d8 100644
--- a/luni/src/test/java/libcore/java/util/TimeZoneTest.java
+++ b/luni/src/test/java/libcore/java/util/TimeZoneTest.java
@@ -17,12 +17,14 @@
 package libcore.java.util;
 
 import java.text.SimpleDateFormat;
+import java.util.Calendar;
 import java.util.Date;
 import java.util.Locale;
-import java.util.TimeZone;
 import java.util.SimpleTimeZone;
+import java.util.TimeZone;
+import junit.framework.TestCase;
 
-public class TimeZoneTest extends junit.framework.TestCase {
+public class TimeZoneTest extends TestCase {
     // http://code.google.com/p/android/issues/detail?id=877
     public void test_useDaylightTime_Taiwan() {
         TimeZone asiaTaipei = TimeZone.getTimeZone("Asia/Taipei");
@@ -192,4 +194,21 @@ public class TimeZoneTest extends junit.framework.TestCase {
       assertEquals(3600000, TimeZone.getTimeZone("America/Los_Angeles").getDSTSavings());
       assertEquals(1800000, TimeZone.getTimeZone("Australia/Lord_Howe").getDSTSavings());
     }
+
+    public void testSimpleTimeZoneDoesNotCallOverrideableMethodsFromConstructor() {
+        new SimpleTimeZone(0, "X", Calendar.MARCH, 1, 1, 1, Calendar.SEPTEMBER, 1, 1, 1) {
+            @Override public void setStartRule(int m, int d, int dow, int time) {
+                fail();
+            }
+            @Override public void setStartRule(int m, int d, int dow, int time, boolean after) {
+                fail();
+            }
+            @Override public void setEndRule(int m, int d, int dow, int time) {
+                fail();
+            }
+            @Override public void setEndRule(int m, int d, int dow, int time, boolean after) {
+                fail();
+            }
+        };
+    }
 }
-- 
cgit v1.1


From 20484654bc7c2407da40226d5188acfc37ee1c2b Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Mon, 8 Aug 2011 20:16:53 -0700
Subject: Remove more cruft.

Unused imports and bogus comments.

(cherry-pick of 9af8c0318fac8bf03ee145da01b0c38a503791fc.)

Change-Id: I2bddb32028b71964407e86c4dbef5516673c27eb
---
 luni/src/main/java/java/io/ObjectInputStream.java        |  1 -
 luni/src/main/java/javax/xml/namespace/QName.java        |  2 --
 .../harmony/xnet/provider/jsse/ClientHandshakeImpl.java  |  2 --
 .../org/apache/harmony/xnet/provider/jsse/Logger.java    |  2 --
 .../harmony/xnet/provider/jsse/OpenSSLSessionImpl.java   | 16 +++-------------
 .../harmony/xnet/provider/jsse/ServerHandshakeImpl.java  |  1 -
 6 files changed, 3 insertions(+), 21 deletions(-)

diff --git a/luni/src/main/java/java/io/ObjectInputStream.java b/luni/src/main/java/java/io/ObjectInputStream.java
index 449204f..0d75a44 100644
--- a/luni/src/main/java/java/io/ObjectInputStream.java
+++ b/luni/src/main/java/java/io/ObjectInputStream.java
@@ -25,7 +25,6 @@ import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.lang.reflect.Proxy;
-import java.security.PrivilegedAction;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
diff --git a/luni/src/main/java/javax/xml/namespace/QName.java b/luni/src/main/java/javax/xml/namespace/QName.java
index f748b64..a82487f 100644
--- a/luni/src/main/java/javax/xml/namespace/QName.java
+++ b/luni/src/main/java/javax/xml/namespace/QName.java
@@ -22,8 +22,6 @@ package javax.xml.namespace;
 import java.io.IOException;
 import java.io.ObjectInputStream;
 import java.io.Serializable;
-import java.security.AccessController;
-import java.security.PrivilegedAction;
 import javax.xml.XMLConstants;
 
 /**
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/ClientHandshakeImpl.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/ClientHandshakeImpl.java
index da8a1c3..83f86ae 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/ClientHandshakeImpl.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/ClientHandshakeImpl.java
@@ -18,14 +18,12 @@
 package org.apache.harmony.xnet.provider.jsse;
 
 import java.io.IOException;
-import java.security.AccessController;
 import java.security.Key;
 import java.security.KeyFactory;
 import java.security.KeyPair;
 import java.security.KeyPairGenerator;
 import java.security.NoSuchAlgorithmException;
 import java.security.PrivateKey;
-import java.security.PrivilegedExceptionAction;
 import java.security.PublicKey;
 import java.security.cert.CertificateException;
 import java.security.cert.X509Certificate;
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/Logger.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/Logger.java
index a2688e2..2fbbef7 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/Logger.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/Logger.java
@@ -19,8 +19,6 @@ package org.apache.harmony.xnet.provider.jsse;
 
 import java.io.PrintStream;
 import java.util.Locale;
-import java.security.AccessController;
-import java.security.PrivilegedAction;
 import libcore.util.EmptyArray;
 
 /**
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLSessionImpl.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLSessionImpl.java
index e194a38..5895eec 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLSessionImpl.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLSessionImpl.java
@@ -380,9 +380,7 @@ public class OpenSSLSessionImpl implements SSLSession {
     /**
      * Returns the object which is bound to the the input parameter name.
      * This name is a sort of link to the data of the SSL session's application
-     * layer, if any exists. The search for this link is monitored, as a matter
-     * of security, by the full machinery of the <code>AccessController</code>
-     * class.
+     * layer, if any exists.
      *
      * @param name the name of the binding to find.
      * @return the value bound to that name, or null if the binding does not
@@ -398,9 +396,7 @@ public class OpenSSLSessionImpl implements SSLSession {
 
     /**
      * Returns an array with the names (sort of links) of all the data
-     * objects of the application layer bound into the SSL session. The search
-     * for this link is monitored, as a matter of security, by the full
-     * machinery of the <code>AccessController</code> class.
+     * objects of the application layer bound into the SSL session.
      *
      * @return a non-null (possibly empty) array of names of the data objects
      *         bound to this SSL session.
@@ -413,9 +409,7 @@ public class OpenSSLSessionImpl implements SSLSession {
      * A link (name) with the specified value object of the SSL session's
      * application layer data is created or replaced. If the new (or existing)
      * value object implements the <code>SSLSessionBindingListener</code>
-     * interface, that object will be notified in due course. These links-to
-     * -data bounds are monitored, as a matter of security, by the full
-     * machinery of the <code>AccessController</code> class.
+     * interface, that object will be notified in due course.
      *
      * @param name the name of the link (no null are
      *            accepted!)
@@ -446,10 +440,6 @@ public class OpenSSLSessionImpl implements SSLSession {
      * <p>If the value object implements the <code>SSLSessionBindingListener</code>
      * interface, the object will receive a <code>valueUnbound</code> notification.
      *
-     * <p>These links-to -data bounds are
-     * monitored, as a matter of security, by the full machinery of the
-     * <code>AccessController</code> class.
-     *
      * @param name the name of the link (no null are
      *            accepted!)
      * @throws <code>IllegalArgumentException</code> if the argument is null.
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/ServerHandshakeImpl.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/ServerHandshakeImpl.java
index ff7fb3d..fa8d291 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/ServerHandshakeImpl.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/ServerHandshakeImpl.java
@@ -19,7 +19,6 @@ package org.apache.harmony.xnet.provider.jsse;
 
 import java.io.IOException;
 import java.math.BigInteger;
-import java.security.AccessController;
 import java.security.KeyFactory;
 import java.security.KeyPair;
 import java.security.KeyPairGenerator;
-- 
cgit v1.1


From 46aabcb28b0e3b807f6db8c33173962d6f2cb71f Mon Sep 17 00:00:00 2001
From: Kenny Root <kroot@google.com>
Date: Mon, 11 Jun 2012 16:54:08 -0700
Subject: Add OpenSSL provider for SHA1PRNG

(cherry-pick of 4718b07e482ccb083ce3dfff228d0615b96a8dd2 and 84fb77d814b0ad04d70addb04847797925acf805.)

Change-Id: Ib45c646a8596bf5ea0629408d6057d3828a1ac94
---
 .../harmony/xnet/provider/jsse/NativeCrypto.java   |   2 +
 .../xnet/provider/jsse/OpenSSLProvider.java        |   9 ++
 .../harmony/xnet/provider/jsse/OpenSSLRandom.java  |  41 ++++++++
 ...che_harmony_xnet_provider_jsse_NativeCrypto.cpp |  19 ++++
 .../libcore/java/security/SecureRandomTest.java    | 114 +++++++++++++++++++++
 .../tests/java/security/SecureRandom2Test.java     |  35 ++-----
 .../xnet/provider/jsse/NativeCryptoTest.java       |  21 ++++
 7 files changed, 212 insertions(+), 29 deletions(-)
 create mode 100644 luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLRandom.java
 create mode 100644 luni/src/test/java/libcore/java/security/SecureRandomTest.java

diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/NativeCrypto.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/NativeCrypto.java
index 759fc85..f3cc1ac 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/NativeCrypto.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/NativeCrypto.java
@@ -172,6 +172,8 @@ public final class NativeCrypto {
 
     public static native int RAND_load_file(String filename, long max_bytes);
 
+    public static native void RAND_bytes(byte[] output);
+
     // --- X509_NAME -----------------------------------------------------------
 
     public static int X509_NAME_hash(X500Principal principal) {
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLProvider.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLProvider.java
index 97753cf..4c88fc3 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLProvider.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLProvider.java
@@ -108,5 +108,14 @@ public final class OpenSSLProvider extends Provider {
         put("Alg.Alias.Signature.1.3.14.3.2.26with1.2.840.10040.4.3", "SHA1withDSA");
         put("Alg.Alias.Signature.DSAWithSHA1", "SHA1withDSA");
         put("Alg.Alias.Signature.1.2.840.10040.4.3", "SHA1withDSA");
+
+        // SecureRandom
+        /*
+         * We have to specify SHA1PRNG because various documentation mentions
+         * that algorithm by name instead of just recommending calling
+         * "new SecureRandom()"
+         */
+        put("SecureRandom.SHA1PRNG", OpenSSLRandom.class.getName());
+        put("SecureRandom.SHA1PRNG ImplementedIn", "Software");
     }
 }
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLRandom.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLRandom.java
new file mode 100644
index 0000000..fd011f0
--- /dev/null
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLRandom.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed 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.xnet.provider.jsse;
+
+import java.io.Serializable;
+import java.security.SecureRandomSpi;
+
+public class OpenSSLRandom extends SecureRandomSpi implements Serializable {
+    private static final long serialVersionUID = 8506210602917522860L;
+
+    @Override
+    protected void engineSetSeed(byte[] seed) {
+        NativeCrypto.RAND_seed(seed);
+    }
+
+    @Override
+    protected void engineNextBytes(byte[] bytes) {
+        NativeCrypto.RAND_bytes(bytes);
+    }
+
+    @Override
+    protected byte[] engineGenerateSeed(int numBytes) {
+        byte[] output = new byte[numBytes];
+        NativeCrypto.RAND_bytes(output);
+        return output;
+    }
+}
diff --git a/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp b/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
index ba2a040..65e76ec 100644
--- a/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
+++ b/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
@@ -1828,6 +1828,24 @@ static jint NativeCrypto_RAND_load_file(JNIEnv* env, jclass, jstring filename, j
     return result;
 }
 
+static void NativeCrypto_RAND_bytes(JNIEnv* env, jclass, jbyteArray output) {
+    JNI_TRACE("NativeCrypto_RAND_bytes(%p)", output);
+
+    ScopedByteArrayRW outputBytes(env, output);
+    if (outputBytes.get() == NULL) {
+        return;
+    }
+
+    unsigned char* tmp = reinterpret_cast<unsigned char*>(outputBytes.get());
+    if (!RAND_bytes(tmp, outputBytes.size())) {
+        throwExceptionIfNecessary(env, "NativeCrypto_RAND_bytes");
+        JNI_TRACE("ctx=%p NativeCrypto_RAND_bytes => threw error", ctx);
+        return;
+    }
+
+    JNI_TRACE("NativeCrypto_RAND_bytes(%p) => success", output);
+}
+
 #ifdef WITH_JNI_TRACE
 /**
  * Based on example logging call back from SSL_CTX_set_info_callback man page
@@ -4273,6 +4291,7 @@ static JNINativeMethod sNativeCryptoMethods[] = {
     NATIVE_METHOD(NativeCrypto, EVP_CIPHER_CTX_cleanup, "(I)V"),
     NATIVE_METHOD(NativeCrypto, RAND_seed, "([B)V"),
     NATIVE_METHOD(NativeCrypto, RAND_load_file, "(Ljava/lang/String;J)I"),
+    NATIVE_METHOD(NativeCrypto, RAND_bytes, "([B)V"),
     NATIVE_METHOD(NativeCrypto, SSL_CTX_new, "()I"),
     NATIVE_METHOD(NativeCrypto, SSL_CTX_free, "(I)V"),
     NATIVE_METHOD(NativeCrypto, SSL_CTX_set_session_id_context, "(I[B)V"),
diff --git a/luni/src/test/java/libcore/java/security/SecureRandomTest.java b/luni/src/test/java/libcore/java/security/SecureRandomTest.java
new file mode 100644
index 0000000..8199120
--- /dev/null
+++ b/luni/src/test/java/libcore/java/security/SecureRandomTest.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed 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 libcore.java.security;
+
+import org.apache.harmony.xnet.provider.jsse.OpenSSLProvider;
+
+import java.security.Provider;
+import java.security.SecureRandom;
+import java.security.Security;
+import java.util.Arrays;
+import java.util.Set;
+
+import junit.framework.TestCase;
+
+public class SecureRandomTest extends TestCase {
+    private static final Class<? extends Provider> EXPECTED_PROVIDER = OpenSSLProvider.class;
+
+    private static final byte[] STATIC_SEED_BYTES = new byte[] {
+            0x0A, (byte) 0xA0, 0x01, 0x10, (byte) 0xFF, (byte) 0xF0, 0x0F
+    };
+
+    private static final long STATIC_SEED_LONG = 8506210602917522860L;
+
+    public void test_getInstance() throws Exception {
+        Provider[] providers = Security.getProviders();
+        for (Provider provider : providers) {
+            Set<Provider.Service> services = provider.getServices();
+            for (Provider.Service service : services) {
+                String type = service.getType();
+                if (!type.equals("SecureRandom")) {
+                    continue;
+                }
+
+                String algorithm = service.getAlgorithm();
+                try {
+                    SecureRandom sr1 = SecureRandom.getInstance(algorithm);
+                    assertEquals(algorithm, sr1.getAlgorithm());
+                    test_SecureRandom(sr1);
+
+                    // SecureRandom.getInstance(String, Provider)
+                    SecureRandom sr2 = SecureRandom.getInstance(algorithm, provider);
+                    assertEquals(algorithm, sr2.getAlgorithm());
+                    assertEquals(provider, sr2.getProvider());
+                    test_SecureRandom(sr2);
+
+                    // SecureRandom.getInstance(String, String)
+                    SecureRandom sr3 = SecureRandom.getInstance(algorithm, provider.getName());
+                    assertEquals(algorithm, sr3.getAlgorithm());
+                    assertEquals(provider, sr3.getProvider());
+                    test_SecureRandom(sr3);
+
+                    System.out.println("SecureRandomTest " + algorithm + " and provider "
+                            + provider.getName());
+                } catch (Exception e) {
+                    throw new Exception("Problem testing SecureRandom." + algorithm
+                            + ", provider: " + provider.getName(), e);
+                }
+            }
+        }
+    }
+
+    private void test_SecureRandom(SecureRandom sr) throws Exception {
+        byte[] out1 = new byte[20];
+        byte[] out2 = new byte[20];
+
+        sr.nextBytes(out1);
+        sr.nextBytes(out2);
+        assertFalse(Arrays.equals(out1, out2));
+
+        byte[] seed1 = sr.generateSeed(20);
+        byte[] seed2 = sr.generateSeed(20);
+        assertFalse(Arrays.equals(seed1, seed2));
+
+        sr.setSeed(STATIC_SEED_BYTES);
+        sr.nextBytes(out1);
+        sr.nextBytes(out2);
+        assertFalse(Arrays.equals(out1, out2));
+
+        sr.setSeed(STATIC_SEED_LONG);
+        sr.nextBytes(out1);
+        sr.nextBytes(out2);
+        assertFalse(Arrays.equals(out1, out2));
+    }
+
+    public void testGetCommonInstances_Success() throws Exception {
+        SecureRandom sr = SecureRandom.getInstance("SHA1PRNG");
+        assertNotNull(sr);
+        assertEquals(EXPECTED_PROVIDER, sr.getProvider().getClass());
+    }
+
+    public void testNewConstructors_Success() throws Exception {
+        SecureRandom sr1 = new SecureRandom();
+        assertEquals(EXPECTED_PROVIDER, sr1.getProvider().getClass());
+        test_SecureRandom(sr1);
+
+        SecureRandom sr2 = new SecureRandom(STATIC_SEED_BYTES);
+        assertEquals(EXPECTED_PROVIDER, sr2.getProvider().getClass());
+        test_SecureRandom(sr2);
+    }
+}
diff --git a/luni/src/test/java/org/apache/harmony/security/tests/java/security/SecureRandom2Test.java b/luni/src/test/java/org/apache/harmony/security/tests/java/security/SecureRandom2Test.java
index cf030c7..aa0ec67 100644
--- a/luni/src/test/java/org/apache/harmony/security/tests/java/security/SecureRandom2Test.java
+++ b/luni/src/test/java/org/apache/harmony/security/tests/java/security/SecureRandom2Test.java
@@ -301,40 +301,15 @@ public class SecureRandom2Test extends TestCase {
      * as it tends to be error prone and open up security holes.
      * See {@link SecureRandom} for more details about insecure seeding.
      *
-     * @see #testSameSeedGeneratesSameResultsWhenConstructorIsUsed()
+     * Note that this only works with the Harmony "Crypto" provider.
      */
     public void testSameSeedGeneratesSameResults() throws Exception {
         byte[] seed1 = { 'a', 'b', 'c' };
-        SecureRandom sr1 = SecureRandom.getInstance("SHA1PRNG");
+        SecureRandom sr1 = SecureRandom.getInstance("SHA1PRNG", "Crypto");
         sr1.setSeed(seed1);
 
         byte[] seed2 = { 'a', 'b', 'c' };
-        SecureRandom sr2 = SecureRandom.getInstance("SHA1PRNG");
-        sr2.setSeed(seed2);
-
-        assertTrue(sr1.nextLong() == sr2.nextLong());
-    }
-
-    /**
-     * Same tests as {@link #testSameSeedGeneratesSameResults()}, except
-     * here we use the constructor, not {@link SecureRandom#getInstance(String)}.
-     *
-     * Note that Android behaves differently than the reference implementation.
-     * This test fails on the reference implementation.
-     *
-     * In the future, it may make sense to change our implementation to
-     * match the reference implementation.  It may also make sense to
-     * disallow seeding {@code SecureRandom} completely, as it tends to
-     * be error prone and open up security holes.  See {@link SecureRandom}
-     * for more details about insecure seeding.
-     */
-    public void testSameSeedGeneratesSameResultsWhenConstructorIsUsed() {
-        byte[] seed1 = { 'a', 'b', 'c' };
-        SecureRandom sr1 = new SecureRandom();
-        sr1.setSeed(seed1);
-
-        byte[] seed2 = { 'a', 'b', 'c' };
-        SecureRandom sr2 = new SecureRandom();
+        SecureRandom sr2 = SecureRandom.getInstance("SHA1PRNG", "Crypto");
         sr2.setSeed(seed2);
 
         assertTrue(sr1.nextLong() == sr2.nextLong());
@@ -348,10 +323,12 @@ public class SecureRandom2Test extends TestCase {
      * SHA1PRNG, so users of {@code SecureRandom} should not assume
      * the same seed will always produce the same value.  This test
      * is not a guarantee of future compatibility.
+     *
+     * In fact, this test only works with the Harmony "Crypto" provider.
      */
     public void testAlwaysSameValueWithSameSeed() throws Exception {
         byte[] seed1 = { 'a', 'b', 'c' };
-        SecureRandom sr1 = SecureRandom.getInstance("SHA1PRNG");
+        SecureRandom sr1 = SecureRandom.getInstance("SHA1PRNG", "Crypto");
         sr1.setSeed(seed1);
 
         // This long value has no special meaning and may change in the future.
diff --git a/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/NativeCryptoTest.java b/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/NativeCryptoTest.java
index c8df4ab..51c00fe 100644
--- a/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/NativeCryptoTest.java
+++ b/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/NativeCryptoTest.java
@@ -1771,4 +1771,25 @@ public class NativeCryptoTest extends TestCase {
             // Success
         }
     }
+
+    public void test_RAND_bytes_Success() throws Exception {
+        byte[] output = new byte[32];
+        NativeCrypto.RAND_bytes(output);
+
+        boolean isZero = true;
+        for (int i = 0; i < output.length; i++) {
+            isZero &= (output[i] == 0);
+        }
+
+        assertFalse("Random output was zero. This is a very low probability event "
+                + "and probably indicates an error.", isZero);
+    }
+
+    public void test_RAND_bytes_Null_Failure() throws Exception {
+        byte[] output = null;
+        try {
+            NativeCrypto.RAND_bytes(output);
+            fail("Should be an error on null buffer input");
+        } catch (RuntimeException success) { }
+    }
 }
-- 
cgit v1.1


From 5757d1d948906c432110f70d8281b18b4ce6824c Mon Sep 17 00:00:00 2001
From: Jesse Wilson <jessewilson@google.com>
Date: Thu, 27 Oct 2011 11:36:56 -0400
Subject: Tests to demonstrate that KxmlSerializer and DOM writing both work.

A user reported that he expected &quot; instead of " in text nodes
of the emitted document. The user is wrong, but we don't have any
tests that demonstrate either case. I wrote tests for both DOM
writing and KxmlSerializer since there's no "RI" for the KxmlSerializer
and I wanted evidence that " is commonplace. (&quot; is permitted
according to the spec.)

(cherry-pick of 75595b3b8136ac524570125d74f748f0b0424428.)

Bug: http://code.google.com/p/android/issues/detail?id=21250
Change-Id: I1b219a5c8d06551c4e7ac72a6df262df6b64209f
---
 .../java/libcore/xml/DomSerializationTest.java     | 74 ++++++++++++++++++++++
 .../test/java/libcore/xml/KxmlSerializerTest.java  | 58 +++++++++++++++++
 2 files changed, 132 insertions(+)
 create mode 100644 luni/src/test/java/libcore/xml/DomSerializationTest.java
 create mode 100644 luni/src/test/java/libcore/xml/KxmlSerializerTest.java

diff --git a/luni/src/test/java/libcore/xml/DomSerializationTest.java b/luni/src/test/java/libcore/xml/DomSerializationTest.java
new file mode 100644
index 0000000..9015f97
--- /dev/null
+++ b/luni/src/test/java/libcore/xml/DomSerializationTest.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed 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 libcore.xml;
+
+import java.io.StringWriter;
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.transform.Transformer;
+import javax.xml.transform.TransformerFactory;
+import javax.xml.transform.dom.DOMSource;
+import javax.xml.transform.stream.StreamResult;
+import junit.framework.TestCase;
+import org.w3c.dom.Attr;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+
+public final class DomSerializationTest extends TestCase {
+    private DocumentBuilder documentBuilder;
+    private Transformer transformer;
+
+    @Override protected void setUp() throws Exception {
+        DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
+        documentBuilder = builderFactory.newDocumentBuilder();
+        transformer = TransformerFactory.newInstance().newTransformer();
+    }
+
+    public void testWriteDocument() throws Exception {
+        Document document = documentBuilder.newDocument();
+        Element foo = document.createElement("foo");
+        Attr quux = document.createAttribute("quux");
+        quux.setValue("abc");
+        foo.setAttributeNode(quux);
+        foo.appendChild(document.createElement("bar"));
+        foo.appendChild(document.createElement("baz"));
+        document.appendChild(foo);
+        assertXmlEquals("<foo quux=\"abc\"><bar/><baz/></foo>", document);
+    }
+
+    public void testWriteSpecialCharactersInText() throws Exception {
+        Document document = documentBuilder.newDocument();
+        Element foo = document.createElement("foo");
+        foo.appendChild(document.createTextNode("5'8\", 5 < 6 & 7 > 3!"));
+        document.appendChild(foo);
+        assertXmlEquals("<foo>5'8\", 5 &lt; 6 &amp; 7 &gt; 3!</foo>", document);
+    }
+
+    private String toXml(Document document) throws Exception {
+        StringWriter stringWriter = new StringWriter();
+        transformer.transform(new DOMSource(document), new StreamResult(stringWriter));
+        return stringWriter.toString();
+    }
+
+    private void assertXmlEquals(String expectedXml, Document document) throws Exception {
+        String actual = toXml(document);
+        String declarationA = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>";
+        String declarationB = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>";
+        assertTrue(actual, actual.equals(declarationA + expectedXml)
+                || actual.equals(declarationB + expectedXml));
+    }
+}
diff --git a/luni/src/test/java/libcore/xml/KxmlSerializerTest.java b/luni/src/test/java/libcore/xml/KxmlSerializerTest.java
new file mode 100644
index 0000000..94d4c3b
--- /dev/null
+++ b/luni/src/test/java/libcore/xml/KxmlSerializerTest.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed 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 libcore.xml;
+
+import java.io.StringWriter;
+import junit.framework.TestCase;
+import org.kxml2.io.KXmlSerializer;
+import org.xmlpull.v1.XmlSerializer;
+
+public final class KxmlSerializerTest extends TestCase {
+    public void testWriteDocument() throws Exception {
+        StringWriter stringWriter = new StringWriter();
+        XmlSerializer serializer = new KXmlSerializer();
+        serializer.setOutput(stringWriter);
+        serializer.startDocument("UTF-8", null);
+        serializer.startTag(null, "foo");
+        serializer.attribute(null, "quux", "abc");
+        serializer.startTag(null, "bar");
+        serializer.endTag(null, "bar");
+        serializer.startTag(null, "baz");
+        serializer.endTag(null, "baz");
+        serializer.endTag(null, "foo");
+        serializer.endDocument();
+        assertXmlEquals("<foo quux=\"abc\"><bar /><baz /></foo>", stringWriter.toString());
+    }
+
+    // http://code.google.com/p/android/issues/detail?id=21250
+    public void testWriteSpecialCharactersInText() throws Exception {
+        StringWriter stringWriter = new StringWriter();
+        XmlSerializer serializer = new KXmlSerializer();
+        serializer.setOutput(stringWriter);
+        serializer.startDocument("UTF-8", null);
+        serializer.startTag(null, "foo");
+        serializer.text("5'8\", 5 < 6 & 7 > 3!");
+        serializer.endTag(null, "foo");
+        serializer.endDocument();
+        assertXmlEquals("<foo>5'8\", 5 &lt; 6 &amp; 7 &gt; 3!</foo>", stringWriter.toString());
+    }
+
+    private void assertXmlEquals(String expectedXml, String actualXml) throws Exception {
+        String declaration = "<?xml version='1.0' encoding='UTF-8' ?>";
+        assertEquals(declaration + expectedXml, actualXml);
+    }
+}
-- 
cgit v1.1


From 10be789f42863b6d3cb2991d0439dd6528288bac Mon Sep 17 00:00:00 2001
From: Jesse Wilson <jessewilson@google.com>
Date: Fri, 9 Dec 2011 11:38:53 -0500
Subject: Add a test for KxmlSerializer attributes with whitespace chars.

Delete some unused Kxml classes while I'm in the area, and
combine our two classes named KXmlSerializerTest.

(cherry-pick of 22a12704190060f74e308a5b5aa32d0b7f715183.)

Change-Id: Id8b3f72edc58547e49ad86c51a171dce3669be3f
---
 luni/src/main/java/org/xml/ThirdPartyProject.prop  |   9 +
 .../test/java/libcore/xml/KxmlSerializerTest.java  | 130 +++++++-
 xml/src/main/java/org/kxml2/kdom/Document.java     | 129 --------
 xml/src/main/java/org/kxml2/kdom/Element.java      | 335 -------------------
 xml/src/main/java/org/kxml2/kdom/Node.java         | 366 ---------------------
 xml/src/main/java/org/xml/ThirdPartyProject.prop   |   9 -
 .../test/java/org/kxml2/io/KXmlSerializerTest.java | 119 -------
 7 files changed, 129 insertions(+), 968 deletions(-)
 create mode 100644 luni/src/main/java/org/xml/ThirdPartyProject.prop
 delete mode 100644 xml/src/main/java/org/kxml2/kdom/Document.java
 delete mode 100644 xml/src/main/java/org/kxml2/kdom/Element.java
 delete mode 100644 xml/src/main/java/org/kxml2/kdom/Node.java
 delete mode 100644 xml/src/main/java/org/xml/ThirdPartyProject.prop
 delete mode 100644 xml/src/test/java/org/kxml2/io/KXmlSerializerTest.java

diff --git a/luni/src/main/java/org/xml/ThirdPartyProject.prop b/luni/src/main/java/org/xml/ThirdPartyProject.prop
new file mode 100644
index 0000000..b8ac0da
--- /dev/null
+++ b/luni/src/main/java/org/xml/ThirdPartyProject.prop
@@ -0,0 +1,9 @@
+# Copyright 2010 Google Inc. All Rights Reserved.
+#Fri Jul 16 10:03:09 PDT 2010
+currentVersion=2.0.2
+version=2.0.2
+isNative=false
+name=xml_sax_parser
+keywords=xml sax parser
+onDevice=true
+homepage=http\://www.saxproject.org
diff --git a/luni/src/test/java/libcore/xml/KxmlSerializerTest.java b/luni/src/test/java/libcore/xml/KxmlSerializerTest.java
index 94d4c3b..6a75a9b 100644
--- a/luni/src/test/java/libcore/xml/KxmlSerializerTest.java
+++ b/luni/src/test/java/libcore/xml/KxmlSerializerTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2011 The Android Open Source Project
+ * Copyright (C) 2009 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,24 +16,47 @@
 
 package libcore.xml;
 
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
 import java.io.StringWriter;
 import junit.framework.TestCase;
 import org.kxml2.io.KXmlSerializer;
+import org.w3c.dom.Document;
+import org.w3c.dom.NodeList;
 import org.xmlpull.v1.XmlSerializer;
+import static tests.support.Support_Xml.domOf;
 
 public final class KxmlSerializerTest extends TestCase {
+    private static final String NAMESPACE = null;
+
+    public void testWhitespaceInAttributeValue() throws Exception {
+        StringWriter stringWriter = new StringWriter();
+        XmlSerializer serializer = new KXmlSerializer();
+        serializer.setOutput(stringWriter);
+        serializer.startDocument("UTF-8", null);
+        serializer.startTag(NAMESPACE, "a");
+        serializer.attribute(NAMESPACE, "cr", "\r");
+        serializer.attribute(NAMESPACE, "lf", "\n");
+        serializer.attribute(NAMESPACE, "tab", "\t");
+        serializer.attribute(NAMESPACE, "space", " ");
+        serializer.endTag(NAMESPACE, "a");
+        serializer.endDocument();
+        assertXmlEquals("<a cr=\"&#13;\" lf=\"&#10;\" tab=\"&#9;\" space=\" \" />",
+                stringWriter.toString());
+    }
+
     public void testWriteDocument() throws Exception {
         StringWriter stringWriter = new StringWriter();
         XmlSerializer serializer = new KXmlSerializer();
         serializer.setOutput(stringWriter);
         serializer.startDocument("UTF-8", null);
-        serializer.startTag(null, "foo");
-        serializer.attribute(null, "quux", "abc");
-        serializer.startTag(null, "bar");
-        serializer.endTag(null, "bar");
-        serializer.startTag(null, "baz");
-        serializer.endTag(null, "baz");
-        serializer.endTag(null, "foo");
+        serializer.startTag(NAMESPACE, "foo");
+        serializer.attribute(NAMESPACE, "quux", "abc");
+        serializer.startTag(NAMESPACE, "bar");
+        serializer.endTag(NAMESPACE, "bar");
+        serializer.startTag(NAMESPACE, "baz");
+        serializer.endTag(NAMESPACE, "baz");
+        serializer.endTag(NAMESPACE, "foo");
         serializer.endDocument();
         assertXmlEquals("<foo quux=\"abc\"><bar /><baz /></foo>", stringWriter.toString());
     }
@@ -44,9 +67,9 @@ public final class KxmlSerializerTest extends TestCase {
         XmlSerializer serializer = new KXmlSerializer();
         serializer.setOutput(stringWriter);
         serializer.startDocument("UTF-8", null);
-        serializer.startTag(null, "foo");
+        serializer.startTag(NAMESPACE, "foo");
         serializer.text("5'8\", 5 < 6 & 7 > 3!");
-        serializer.endTag(null, "foo");
+        serializer.endTag(NAMESPACE, "foo");
         serializer.endDocument();
         assertXmlEquals("<foo>5'8\", 5 &lt; 6 &amp; 7 &gt; 3!</foo>", stringWriter.toString());
     }
@@ -55,4 +78,91 @@ public final class KxmlSerializerTest extends TestCase {
         String declaration = "<?xml version='1.0' encoding='UTF-8' ?>";
         assertEquals(declaration + expectedXml, actualXml);
     }
+
+    private static XmlSerializer newSerializer() throws IOException {
+        ByteArrayOutputStream bytesOut = new ByteArrayOutputStream();
+        XmlSerializer serializer = new KXmlSerializer();
+        serializer.setOutput(bytesOut, "UTF-8");
+        serializer.startDocument("UTF-8", null);
+        return serializer;
+    }
+
+    public void testInvalidCharactersInText() throws IOException {
+        XmlSerializer serializer = newSerializer();
+        serializer.startTag(NAMESPACE, "root");
+        for (int ch = 0; ch <= 0xffff; ++ch) {
+            final String s = Character.toString((char) ch);
+            if (isValidXmlCodePoint(ch)) {
+                serializer.text("a" + s + "b");
+            } else {
+                try {
+                    serializer.text("a" + s + "b");
+                    fail(s);
+                } catch (IllegalArgumentException expected) {
+                }
+            }
+        }
+        serializer.endTag(NAMESPACE, "root");
+    }
+
+    public void testInvalidCharactersInAttributeValues() throws IOException {
+        XmlSerializer serializer = newSerializer();
+        serializer.startTag(NAMESPACE, "root");
+        for (int ch = 0; ch <= 0xffff; ++ch) {
+            final String s = Character.toString((char) ch);
+            if (isValidXmlCodePoint(ch)) {
+                serializer.attribute(NAMESPACE, "a", "a" + s + "b");
+            } else {
+                try {
+                    serializer.attribute(NAMESPACE, "a", "a" + s + "b");
+                    fail(s);
+                } catch (IllegalArgumentException expected) {
+                }
+            }
+        }
+        serializer.endTag(NAMESPACE, "root");
+    }
+
+    public void testInvalidCharactersInCdataSections() throws IOException {
+        XmlSerializer serializer = newSerializer();
+        serializer.startTag(NAMESPACE, "root");
+        for (int ch = 0; ch <= 0xffff; ++ch) {
+            final String s = Character.toString((char) ch);
+            if (isValidXmlCodePoint(ch)) {
+                serializer.cdsect("a" + s + "b");
+            } else {
+                try {
+                    serializer.cdsect("a" + s + "b");
+                    fail(s);
+                } catch (IllegalArgumentException expected) {
+                }
+            }
+        }
+        serializer.endTag(NAMESPACE, "root");
+    }
+
+    public void testCdataWithTerminatorInside() throws Exception {
+        StringWriter writer = new StringWriter();
+        XmlSerializer serializer = new KXmlSerializer();
+        serializer.setOutput(writer);
+        serializer.startDocument("UTF-8", null);
+        serializer.startTag(NAMESPACE, "p");
+        serializer.cdsect("a]]>b");
+        serializer.endTag(NAMESPACE, "p");
+        serializer.endDocument();
+        // Adjacent CDATA sections aren't merged, so let's stick them together ourselves...
+        Document doc = domOf(writer.toString());
+        NodeList children = doc.getFirstChild().getChildNodes();
+        String text = "";
+        for (int i = 0; i < children.getLength(); ++i) {
+            text += children.item(i).getNodeValue();
+        }
+        assertEquals("a]]>b", text);
+    }
+
+    private static boolean isValidXmlCodePoint(int c) {
+        // http://www.w3.org/TR/REC-xml/#charsets
+        return (c >= 0x20 && c <= 0xd7ff) || (c == 0x9) || (c == 0xa) || (c == 0xd) ||
+                (c >= 0xe000 && c <= 0xfffd) || (c >= 0x10000 && c <= 0x10ffff);
+    }
 }
diff --git a/xml/src/main/java/org/kxml2/kdom/Document.java b/xml/src/main/java/org/kxml2/kdom/Document.java
deleted file mode 100644
index 9123e62..0000000
--- a/xml/src/main/java/org/kxml2/kdom/Document.java
+++ /dev/null
@@ -1,129 +0,0 @@
-/* Copyright (c) 2002,2003, Stefan Haustein, Oberhausen, Rhld., Germany
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The  above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE. */
-
-
-package org.kxml2.kdom;
-
-import java.io.*;
-
-import org.xmlpull.v1.*;
-/** The document consists of some legacy events and a single root
-    element. This class basically adds some consistency checks to
-    Node. */
-
-public class Document extends Node {
-
-    protected int rootIndex = -1;
-    String encoding;
-    Boolean standalone;
-
-    /** returns "#document" */
-
-    public String getEncoding () {
-        return encoding;
-    }
-
-    public void setEncoding(String enc) {
-        this.encoding = enc;
-    }
-
-    public void setStandalone (Boolean standalone) {
-        this.standalone = standalone;
-    }
-
-    public Boolean getStandalone() {
-        return standalone;
-    }
-
-
-    public String getName() {
-        return "#document";
-    }
-
-    /** Adds a child at the given index position. Throws
-    an exception when a second root element is added */
-
-    public void addChild(int index, int type, Object child) {
-        if (type == ELEMENT) {
-         //   if (rootIndex != -1)
-           //     throw new RuntimeException("Only one document root element allowed");
-
-            rootIndex = index;
-        }
-        else if (rootIndex >= index)
-            rootIndex++;
-
-        super.addChild(index, type, child);
-    }
-
-    /** reads the document and checks if the last event
-    is END_DOCUMENT. If not, an exception is thrown.
-    The end event is consumed. For parsing partial
-        XML structures, consider using Node.parse (). */
-
-    public void parse(XmlPullParser parser)
-        throws IOException, XmlPullParserException {
-
-        parser.require(XmlPullParser.START_DOCUMENT, null, null);
-        parser.nextToken ();
-
-        encoding = parser.getInputEncoding();
-        standalone = (Boolean)parser.getProperty ("http://xmlpull.org/v1/doc/properties.html#xmldecl-standalone");
-
-        super.parse(parser);
-
-        if (parser.getEventType() != XmlPullParser.END_DOCUMENT)
-            throw new RuntimeException("Document end expected!");
-
-    }
-
-    public void removeChild(int index) {
-        if (index == rootIndex)
-            rootIndex = -1;
-        else if (index < rootIndex)
-            rootIndex--;
-
-        super.removeChild(index);
-    }
-
-    /** returns the root element of this document. */
-
-    public Element getRootElement() {
-        if (rootIndex == -1)
-            throw new RuntimeException("Document has no root element!");
-
-        return (Element) getChild(rootIndex);
-    }
-
-
-    /** Writes this node to the given XmlWriter. For node and document,
-        this method is identical to writeChildren, except that the
-        stream is flushed automatically. */
-
-    public void write(XmlSerializer writer)
-        throws IOException {
-
-        writer.startDocument(encoding, standalone);
-        writeChildren(writer);
-        writer.endDocument();
-    }
-
-
-}
\ No newline at end of file
diff --git a/xml/src/main/java/org/kxml2/kdom/Element.java b/xml/src/main/java/org/kxml2/kdom/Element.java
deleted file mode 100644
index a9cb426..0000000
--- a/xml/src/main/java/org/kxml2/kdom/Element.java
+++ /dev/null
@@ -1,335 +0,0 @@
-/* Copyright (c) 2002,2003, Stefan Haustein, Oberhausen, Rhld., Germany
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The  above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE. */
-
-package org.kxml2.kdom;
-
-import java.io.*;
-import java.util.*;
-
-import org.xmlpull.v1.*;
-
-/**
- * In order to create an element, please use the createElement method
- * instead of invoking the constructor directly. The right place to
- * add user defined initialization code is the init method. */
-
-public class Element extends Node {
-
-    protected String namespace;
-    protected String name;
-    protected Vector attributes;
-    protected Node parent;
-    protected Vector prefixes;
-
-    public Element() {
-    }
-
-    /**
-     * called when all properties are set, but before children
-     * are parsed. Please do not use setParent for initialization
-     * code any longer. */
-
-    public void init() {
-    }
-
-
-
-
-    /**
-     * removes all children and attributes */
-
-    public void clear() {
-        attributes = null;
-        children = null;
-    }
-
-    /**
-     * Forwards creation request to parent if any, otherwise
-     * calls super.createElement. */
-
-    public Element createElement(
-        String namespace,
-        String name) {
-
-        return (this.parent == null)
-            ? super.createElement(namespace, name)
-            : this.parent.createElement(namespace, name);
-    }
-
-    /**
-     * Returns the number of attributes of this element. */
-
-    public int getAttributeCount() {
-        return attributes == null ? 0 : attributes.size();
-    }
-
-    public String getAttributeNamespace (int index) {
-        return ((String []) attributes.elementAt (index)) [0];
-    }
-
-/*    public String getAttributePrefix (int index) {
-        return ((String []) attributes.elementAt (index)) [1];
-    }*/
-
-    public String getAttributeName (int index) {
-        return ((String []) attributes.elementAt (index)) [1];
-    }
-
-
-    public String getAttributeValue (int index) {
-        return ((String []) attributes.elementAt (index)) [2];
-    }
-
-
-    public String getAttributeValue (String namespace, String name) {
-        for (int i = 0; i < getAttributeCount (); i++) {
-            if (name.equals (getAttributeName (i))
-                && (namespace == null || namespace.equals (getAttributeNamespace(i)))) {
-                return getAttributeValue (i);
-            }
-        }
-        return null;
-    }
-
-    /**
-     * Returns the root node, determined by ascending to the
-     * all parents un of the root element. */
-
-    public Node getRoot() {
-
-        Element current = this;
-
-        while (current.parent != null) {
-            if (!(current.parent instanceof Element)) return current.parent;
-            current = (Element) current.parent;
-        }
-
-        return current;
-    }
-
-    /**
-     * returns the (local) name of the element */
-
-    public String getName() {
-        return name;
-    }
-
-    /**
-     * returns the namespace of the element */
-
-    public String getNamespace() {
-        return namespace;
-    }
-
-
-    /**
-     * returns the namespace for the given prefix */
-
-    public String getNamespaceUri (String prefix) {
-        int cnt = getNamespaceCount ();
-        for (int i = 0; i < cnt; i++) {
-            if (prefix == getNamespacePrefix (i) ||
-                (prefix != null && prefix.equals (getNamespacePrefix (i))))
-                return getNamespaceUri (i);
-        }
-        return parent instanceof Element ? ((Element) parent).getNamespaceUri (prefix) : null;
-    }
-
-
-    /**
-     * returns the number of declared namespaces, NOT including
-     * parent elements */
-
-    public int getNamespaceCount () {
-        return (prefixes == null ? 0 : prefixes.size ());
-    }
-
-
-    public String getNamespacePrefix (int i) {
-        return ((String []) prefixes.elementAt (i)) [0];
-    }
-
-    public String getNamespaceUri (int i) {
-        return ((String []) prefixes.elementAt (i)) [1];
-    }
-
-
-    /**
-     * Returns the parent node of this element */
-
-    public Node getParent() {
-        return parent;
-    }
-
-    /*
-     * Returns the parent element if available, null otherwise
-
-    public Element getParentElement() {
-        return (parent instanceof Element)
-            ? ((Element) parent)
-            : null;
-    }
-*/
-
-    /**
-     * Builds the child elements from the given Parser. By overwriting
-     * parse, an element can take complete control over parsing its
-     * subtree. */
-
-    public void parse(XmlPullParser parser)
-        throws IOException, XmlPullParserException {
-
-        for (int i = parser.getNamespaceCount (parser.getDepth () - 1);
-            i < parser.getNamespaceCount (parser.getDepth ()); i++) {
-            setPrefix (parser.getNamespacePrefix (i), parser.getNamespaceUri(i));
-        }
-
-
-        for (int i = 0; i < parser.getAttributeCount (); i++)
-            setAttribute (parser.getAttributeNamespace (i),
-//                          parser.getAttributePrefix (i),
-                          parser.getAttributeName (i),
-                          parser.getAttributeValue (i));
-
-
-        //        if (prefixMap == null) throw new RuntimeException ("!!");
-
-        init();
-
-
-        if (parser.isEmptyElementTag())
-            parser.nextToken ();
-        else {
-            parser.nextToken ();
-            super.parse(parser);
-
-            if (getChildCount() == 0)
-                addChild(IGNORABLE_WHITESPACE, "");
-        }
-
-        parser.require(
-            XmlPullParser.END_TAG,
-            getNamespace(),
-            getName());
-
-        parser.nextToken ();
-    }
-
-
-    /**
-     * Sets the given attribute; a value of null removes the attribute */
-
-    public void setAttribute (String namespace, String name, String value) {
-        if (attributes == null)
-            attributes = new Vector ();
-
-        if (namespace == null)
-            namespace = "";
-
-        for (int i = attributes.size()-1; i >=0; i--){
-            String[] attribut = (String[]) attributes.elementAt(i);
-            if (attribut[0].equals(namespace) &&
-                attribut[1].equals(name)){
-
-                if (value == null) {
-                    attributes.removeElementAt(i);
-                }
-                else {
-                    attribut[2] = value;
-                }
-                return;
-            }
-        }
-
-        attributes.addElement
-            (new String [] {namespace, name, value});
-    }
-
-
-    /**
-     * Sets the given prefix; a namespace value of null removess the
-     * prefix */
-
-    public void setPrefix (String prefix, String namespace) {
-        if (prefixes == null) prefixes = new Vector ();
-        prefixes.addElement (new String [] {prefix, namespace});
-    }
-
-
-    /**
-     * sets the name of the element */
-
-    public void setName(String name) {
-        this.name = name;
-    }
-
-    /**
-     * sets the namespace of the element. Please note: For no
-     * namespace, please use Xml.NO_NAMESPACE, null is not a legal
-     * value. Currently, null is converted to Xml.NO_NAMESPACE, but
-     * future versions may throw an exception. */
-
-    public void setNamespace(String namespace) {
-        if (namespace == null)
-            throw new NullPointerException ("Use \"\" for empty namespace");
-        this.namespace = namespace;
-    }
-
-    /**
-     * Sets the Parent of this element. Automatically called from the
-     * add method.  Please use with care, you can simply
-     * create inconsitencies in the document tree structure using
-     * this method!  */
-
-    protected void setParent(Node parent) {
-        this.parent = parent;
-    }
-
-
-    /**
-     * Writes this element and all children to the given XmlWriter. */
-
-    public void write(XmlSerializer writer)
-        throws IOException {
-
-        if (prefixes != null) {
-            for (int i = 0; i < prefixes.size(); i++) {
-                writer.setPrefix (getNamespacePrefix (i), getNamespaceUri (i));
-            }
-        }
-
-        writer.startTag(
-            getNamespace(),
-            getName());
-
-        int len = getAttributeCount();
-
-        for (int i = 0; i < len; i++) {
-            writer.attribute(
-                getAttributeNamespace(i),
-                getAttributeName(i),
-                getAttributeValue(i));
-        }
-
-        writeChildren(writer);
-
-        writer.endTag(getNamespace (), getName ());
-    }
-}
diff --git a/xml/src/main/java/org/kxml2/kdom/Node.java b/xml/src/main/java/org/kxml2/kdom/Node.java
deleted file mode 100644
index 820390c..0000000
--- a/xml/src/main/java/org/kxml2/kdom/Node.java
+++ /dev/null
@@ -1,366 +0,0 @@
-/* Copyright (c) 2002,2003, Stefan Haustein, Oberhausen, Rhld., Germany
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or
- * sell copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The  above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
- * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
- * IN THE SOFTWARE. */
-
-package org.kxml2.kdom;
-
-import java.util.*;
-import java.io.*;
-import org.xmlpull.v1.*;
-/** A common base class for Document and Element, also used for
-    storing XML fragments. */
-
-public class Node { //implements XmlIO{
-
-    public static final int DOCUMENT = 0;
-    public static final int ELEMENT = 2;
-    public static final int TEXT = 4;
-    public static final int CDSECT = 5;
-    public static final int ENTITY_REF = 6;
-    public static final int IGNORABLE_WHITESPACE = 7;
-    public static final int PROCESSING_INSTRUCTION = 8;
-    public static final int COMMENT = 9;
-    public static final int DOCDECL = 10;
-
-    protected Vector children;
-    protected StringBuffer types;
-
-    /** inserts the given child object of the given type at the
-    given index. */
-
-    public void addChild(int index, int type, Object child) {
-
-        if (child == null)
-            throw new NullPointerException();
-
-        if (children == null) {
-            children = new Vector();
-            types = new StringBuffer();
-        }
-
-        if (type == ELEMENT) {
-            if (!(child instanceof Element))
-                throw new RuntimeException("Element obj expected)");
-
-            ((Element) child).setParent(this);
-        }
-        else if (!(child instanceof String))
-            throw new RuntimeException("String expected");
-
-        children.insertElementAt(child, index);
-        types.insert(index, (char) type);
-    }
-
-    /** convenience method for addChild (getChildCount (), child) */
-
-    public void addChild(int type, Object child) {
-        addChild(getChildCount(), type, child);
-    }
-
-    /** Builds a default element with the given properties. Elements
-    should always be created using this method instead of the
-    constructor in order to enable construction of specialized
-    subclasses by deriving custom Document classes. Please note:
-    For no namespace, please use Xml.NO_NAMESPACE, null is not a
-    legal value. Currently, null is converted to Xml.NO_NAMESPACE,
-    but future versions may throw an exception. */
-
-    public Element createElement(String namespace, String name) {
-
-        Element e = new Element();
-        e.namespace = namespace == null ? "" : namespace;
-        e.name = name;
-        return e;
-    }
-
-    /** Returns the child object at the given index.  For child
-        elements, an Element object is returned. For all other child
-        types, a String is returned. */
-
-    public Object getChild(int index) {
-        return children.elementAt(index);
-    }
-
-    /** Returns the number of child objects */
-
-    public int getChildCount() {
-        return children == null ? 0 : children.size();
-    }
-
-    /** returns the element at the given index. If the node at the
-    given index is a text node, null is returned */
-
-    public Element getElement(int index) {
-        Object child = getChild(index);
-        return (child instanceof Element) ? (Element) child : null;
-    }
-
-    /** Returns the element with the given namespace and name. If the
-        element is not found, or more than one matching elements are
-        found, an exception is thrown. */
-
-    public Element getElement(String namespace, String name) {
-
-        int i = indexOf(namespace, name, 0);
-        int j = indexOf(namespace, name, i + 1);
-
-        if (i == -1 || j != -1)
-            throw new RuntimeException(
-                "Element {"
-                    + namespace
-                    + "}"
-                    + name
-                    + (i == -1 ? " not found in " : " more than once in ")
-                    + this);
-
-        return getElement(i);
-    }
-
-    /* returns "#document-fragment". For elements, the element name is returned
-
-    public String getName() {
-        return "#document-fragment";
-    }
-
-    /** Returns the namespace of the current element. For Node
-        and Document, Xml.NO_NAMESPACE is returned.
-
-    public String getNamespace() {
-        return "";
-    }
-
-    public int getNamespaceCount () {
-        return 0;
-    }
-
-    /** returns the text content if the element has text-only
-    content. Throws an exception for mixed content
-
-    public String getText() {
-
-        StringBuffer buf = new StringBuffer();
-        int len = getChildCount();
-
-        for (int i = 0; i < len; i++) {
-            if (isText(i))
-                buf.append(getText(i));
-            else if (getType(i) == ELEMENT)
-                throw new RuntimeException("not text-only content!");
-        }
-
-        return buf.toString();
-    }
-    */
-
-    /** Returns the text node with the given index or null if the node
-        with the given index is not a text node. */
-
-    public String getText(int index) {
-        return (isText(index)) ? (String) getChild(index) : null;
-    }
-
-    /** Returns the type of the child at the given index. Possible
-    types are ELEMENT, TEXT, COMMENT, and PROCESSING_INSTRUCTION */
-
-    public int getType(int index) {
-        return types.charAt(index);
-    }
-
-    /** Convenience method for indexOf (getNamespace (), name,
-        startIndex).
-
-    public int indexOf(String name, int startIndex) {
-        return indexOf(getNamespace(), name, startIndex);
-    }
-    */
-
-    /** Performs search for an element with the given namespace and
-    name, starting at the given start index. A null namespace
-    matches any namespace, please use Xml.NO_NAMESPACE for no
-    namespace).  returns -1 if no matching element was found. */
-
-    public int indexOf(String namespace, String name, int startIndex) {
-
-        int len = getChildCount();
-
-        for (int i = startIndex; i < len; i++) {
-
-            Element child = getElement(i);
-
-            if (child != null
-                && name.equals(child.getName())
-                && (namespace == null || namespace.equals(child.getNamespace())))
-                return i;
-        }
-        return -1;
-    }
-
-    public boolean isText(int i) {
-        int t = getType(i);
-        return t == TEXT || t == IGNORABLE_WHITESPACE || t == CDSECT;
-    }
-
-    /** Recursively builds the child elements from the given parser
-    until an end tag or end document is found.
-        The end tag is not consumed. */
-
-    public void parse(XmlPullParser parser)
-        throws IOException, XmlPullParserException {
-
-        boolean leave = false;
-
-        do {
-            int type = parser.getEventType();
-
-   //         System.out.println(parser.getPositionDescription());
-
-            switch (type) {
-
-                case XmlPullParser.START_TAG :
-                    {
-                        Element child =
-                            createElement(
-                                parser.getNamespace(),
-                                parser.getName());
-                        //    child.setAttributes (event.getAttributes ());
-                        addChild(ELEMENT, child);
-
-                        // order is important here since
-                        // setparent may perform some init code!
-
-                        child.parse(parser);
-                        break;
-                    }
-
-                case XmlPullParser.END_DOCUMENT :
-                case XmlPullParser.END_TAG :
-                    leave = true;
-                    break;
-
-                default :
-                    if (parser.getText() != null)
-                        addChild(
-                            type == XmlPullParser.ENTITY_REF ? TEXT : type,
-                            parser.getText());
-                    else if (
-                        type == XmlPullParser.ENTITY_REF
-                            && parser.getName() != null) {
-                        addChild(ENTITY_REF, parser.getName());
-                    }
-                    parser.nextToken();
-            }
-        }
-        while (!leave);
-    }
-
-    /** Removes the child object at the given index */
-
-    public void removeChild(int idx) {
-        children.removeElementAt(idx);
-
-        /***  Modification by HHS - start ***/
-        //      types.deleteCharAt (index);
-        /***/
-        int n = types.length() - 1;
-
-        for (int i = idx; i < n; i++)
-            types.setCharAt(i, types.charAt(i + 1));
-
-        types.setLength(n);
-
-        /***  Modification by HHS - end   ***/
-    }
-
-    /* returns a valid XML representation of this Element including
-        attributes and children.
-    public String toString() {
-        try {
-            ByteArrayOutputStream bos =
-                new ByteArrayOutputStream();
-            XmlWriter xw =
-                new XmlWriter(new OutputStreamWriter(bos));
-            write(xw);
-            xw.close();
-            return new String(bos.toByteArray());
-        }
-        catch (IOException e) {
-            throw new RuntimeException(e.toString());
-        }
-    }
-    */
-
-    /** Writes this node to the given XmlWriter. For node and document,
-        this method is identical to writeChildren, except that the
-        stream is flushed automatically. */
-
-    public void write(XmlSerializer writer) throws IOException {
-        writeChildren(writer);
-        writer.flush();
-    }
-
-    /** Writes the children of this node to the given XmlWriter. */
-
-    public void writeChildren(XmlSerializer writer) throws IOException {
-        if (children == null)
-            return;
-
-        int len = children.size();
-
-        for (int i = 0; i < len; i++) {
-            int type = getType(i);
-            Object child = children.elementAt(i);
-            switch (type) {
-                case ELEMENT :
-                     ((Element) child).write(writer);
-                    break;
-
-                case TEXT :
-                    writer.text((String) child);
-                    break;
-
-                case IGNORABLE_WHITESPACE :
-                    writer.ignorableWhitespace((String) child);
-                    break;
-
-                case CDSECT :
-                    writer.cdsect((String) child);
-                    break;
-
-                case COMMENT :
-                    writer.comment((String) child);
-                    break;
-
-                case ENTITY_REF :
-                    writer.entityRef((String) child);
-                    break;
-
-                case PROCESSING_INSTRUCTION :
-                    writer.processingInstruction((String) child);
-                    break;
-
-                case DOCDECL :
-                    writer.docdecl((String) child);
-                    break;
-
-                default :
-                    throw new RuntimeException("Illegal type: " + type);
-            }
-        }
-    }
-}
diff --git a/xml/src/main/java/org/xml/ThirdPartyProject.prop b/xml/src/main/java/org/xml/ThirdPartyProject.prop
deleted file mode 100644
index b8ac0da..0000000
--- a/xml/src/main/java/org/xml/ThirdPartyProject.prop
+++ /dev/null
@@ -1,9 +0,0 @@
-# Copyright 2010 Google Inc. All Rights Reserved.
-#Fri Jul 16 10:03:09 PDT 2010
-currentVersion=2.0.2
-version=2.0.2
-isNative=false
-name=xml_sax_parser
-keywords=xml sax parser
-onDevice=true
-homepage=http\://www.saxproject.org
diff --git a/xml/src/test/java/org/kxml2/io/KXmlSerializerTest.java b/xml/src/test/java/org/kxml2/io/KXmlSerializerTest.java
deleted file mode 100644
index 7aba746..0000000
--- a/xml/src/test/java/org/kxml2/io/KXmlSerializerTest.java
+++ /dev/null
@@ -1,119 +0,0 @@
-/*
- * Copyright (C) 2009 The Android Open Source Project
- *
- * Licensed 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.kxml2.io;
-
-import junit.framework.TestCase;
-
-import java.io.ByteArrayOutputStream;
-import java.io.IOException;
-import java.io.StringWriter;
-import org.w3c.dom.Document;
-import org.w3c.dom.NodeList;
-import org.xmlpull.v1.XmlSerializer;
-
-import static tests.support.Support_Xml.*;
-
-public class KXmlSerializerTest extends TestCase {
-    private static final String NAMESPACE = null;
-
-    private static boolean isValidXmlCodePoint(int c) {
-        // http://www.w3.org/TR/REC-xml/#charsets
-        return (c >= 0x20 && c <= 0xd7ff) || (c == 0x9) || (c == 0xa) || (c == 0xd) ||
-                (c >= 0xe000 && c <= 0xfffd) || (c >= 0x10000 && c <= 0x10ffff);
-    }
-
-    private static XmlSerializer newSerializer() throws IOException {
-        ByteArrayOutputStream bytesOut = new ByteArrayOutputStream();
-        XmlSerializer serializer = new KXmlSerializer();
-        serializer.setOutput(bytesOut, "UTF-8");
-        serializer.startDocument("UTF-8", null);
-        return serializer;
-    }
-
-    public void testInvalidCharactersInText() throws IOException {
-        XmlSerializer serializer = newSerializer();
-        serializer.startTag(NAMESPACE, "root");
-        for (int ch = 0; ch <= 0xffff; ++ch) {
-            final String s = Character.toString((char) ch);
-            if (isValidXmlCodePoint(ch)) {
-                serializer.text("a" + s + "b");
-            } else {
-                try {
-                    serializer.text("a" + s + "b");
-                    fail(s);
-                } catch (IllegalArgumentException expected) {
-                }
-            }
-        }
-        serializer.endTag(NAMESPACE, "root");
-    }
-
-    public void testInvalidCharactersInAttributeValues() throws IOException {
-        XmlSerializer serializer = newSerializer();
-        serializer.startTag(NAMESPACE, "root");
-        for (int ch = 0; ch <= 0xffff; ++ch) {
-            final String s = Character.toString((char) ch);
-            if (isValidXmlCodePoint(ch)) {
-                serializer.attribute(NAMESPACE, "a", "a" + s + "b");
-            } else {
-                try {
-                    serializer.attribute(NAMESPACE, "a", "a" + s + "b");
-                    fail(s);
-                } catch (IllegalArgumentException expected) {
-                }
-            }
-        }
-        serializer.endTag(NAMESPACE, "root");
-    }
-
-    public void testInvalidCharactersInCdataSections() throws IOException {
-        XmlSerializer serializer = newSerializer();
-        serializer.startTag(NAMESPACE, "root");
-        for (int ch = 0; ch <= 0xffff; ++ch) {
-            final String s = Character.toString((char) ch);
-            if (isValidXmlCodePoint(ch)) {
-                serializer.cdsect("a" + s + "b");
-            } else {
-                try {
-                    serializer.cdsect("a" + s + "b");
-                    fail(s);
-                } catch (IllegalArgumentException expected) {
-                }
-            }
-        }
-        serializer.endTag(NAMESPACE, "root");
-    }
-
-    public void testCdataWithTerminatorInside() throws Exception {
-        StringWriter writer = new StringWriter();
-        XmlSerializer serializer = new KXmlSerializer();
-        serializer.setOutput(writer);
-        serializer.startDocument("UTF-8", null);
-        serializer.startTag(NAMESPACE, "p");
-        serializer.cdsect("a]]>b");
-        serializer.endTag(NAMESPACE, "p");
-        serializer.endDocument();
-        // Adjacent CDATA sections aren't merged, so let's stick them together ourselves...
-        Document doc = domOf(writer.toString());
-        NodeList children = doc.getFirstChild().getChildNodes();
-        String text = "";
-        for (int i = 0; i < children.getLength(); ++i) {
-            text += children.item(i).getNodeValue();
-        }
-        assertEquals("a]]>b", text);
-    }
-}
-- 
cgit v1.1


From ec9557af2760d73e6e53a2be6b025acb258e9017 Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Wed, 1 Aug 2012 17:53:03 -0700
Subject: Remove SSLContext TLSv1.1 and TLSv1.2 from expected list for RI

Change-Id: Ie506337882a878df77073c0c8117dfdc8d33b670
---
 support/src/test/java/libcore/java/security/StandardNames.java | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/support/src/test/java/libcore/java/security/StandardNames.java b/support/src/test/java/libcore/java/security/StandardNames.java
index e8b29e4..6539e2c 100644
--- a/support/src/test/java/libcore/java/security/StandardNames.java
+++ b/support/src/test/java/libcore/java/security/StandardNames.java
@@ -274,6 +274,12 @@ public final class StandardNames extends Assert {
             provide("Signature", "SHA512WITHECDSA");
         }
 
+        // Documented as Standard Names, but do not exit in RI 6
+        if (IS_RI) {
+            unprovide("SSLContext", "TLSv1.1");
+            unprovide("SSLContext", "TLSv1.2");
+        }
+
         // Fixups for dalvik
         if (!IS_RI) {
 
-- 
cgit v1.1


From c7a56c94bdea0e20123ae6fba5eca5b8d984c670 Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Wed, 1 Aug 2012 13:55:42 -0700
Subject: Avoid ConcurrentModificationException on providers

Previously concurrently adding/removing providers in one thread and
doing algorithm lookups on another thread would cause
ConcurrentModificationExceptions such as:

java.util.ConcurrentModificationException
        at java.util.ArrayList$ArrayListIterator.next(ArrayList.java:569)
        at org.apache.harmony.security.fortress.Services.updateServiceInfo(Services.java:186)
        at org.apache.harmony.security.fortress.Services.refresh(Services.java:234)
        at org.apache.harmony.security.fortress.Engine.getInstance(Engine.java:137)
        at java.security.KeyFactory.getInstance(KeyFactory.java:81)

Also do some general cleanup and add similar protection on services.

Change-Id: I706c45655924dfccc3383fca57653d0c5b461721
---
 luni/src/main/java/java/security/SecureRandom.java |   1 -
 .../apache/harmony/security/fortress/Engine.java   |  12 +-
 .../apache/harmony/security/fortress/Services.java | 242 +++++++++++----------
 3 files changed, 130 insertions(+), 125 deletions(-)

diff --git a/luni/src/main/java/java/security/SecureRandom.java b/luni/src/main/java/java/security/SecureRandom.java
index 68a2917..9091f73 100644
--- a/luni/src/main/java/java/security/SecureRandom.java
+++ b/luni/src/main/java/java/security/SecureRandom.java
@@ -88,7 +88,6 @@ public class SecureRandom extends Random {
      */
     public SecureRandom() {
         super(0);
-        Services.refresh();
         Provider.Service service = Services.getSecureRandomService();
         if (service == null) {
             this.provider = null;
diff --git a/luni/src/main/java/org/apache/harmony/security/fortress/Engine.java b/luni/src/main/java/org/apache/harmony/security/fortress/Engine.java
index 8a67ac2..f1dd43c 100644
--- a/luni/src/main/java/org/apache/harmony/security/fortress/Engine.java
+++ b/luni/src/main/java/org/apache/harmony/security/fortress/Engine.java
@@ -93,15 +93,15 @@ public class Engine {
         /** used to test for cache hit */
         private final String algorithm;
         /** used to test for cache validity */
-        private final int refreshNumber;
+        private final int cacheVersion;
         /** cached result */
         private final Provider.Service service;
 
         private ServiceCacheEntry(String algorithm,
-                                  int refreshNumber,
+                                  int cacheVersion,
                                   Provider.Service service) {
             this.algorithm = algorithm;
-            this.refreshNumber = refreshNumber;
+            this.cacheVersion = cacheVersion;
             this.service = service;
         }
     }
@@ -134,12 +134,12 @@ public class Engine {
         if (algorithm == null) {
             throw new NoSuchAlgorithmException("Null algorithm name");
         }
-        Services.refresh();
+        int newCacheVersion = Services.getCacheVersion();
         Provider.Service service;
         ServiceCacheEntry cacheEntry = this.serviceCache;
         if (cacheEntry != null
                 && cacheEntry.algorithm.equalsIgnoreCase(algorithm)
-                && Services.refreshNumber == cacheEntry.refreshNumber) {
+                && newCacheVersion == cacheEntry.cacheVersion) {
             service = cacheEntry.service;
         } else {
             if (Services.isEmpty()) {
@@ -150,7 +150,7 @@ public class Engine {
             if (service == null) {
                 throw notFound(serviceName, algorithm);
             }
-            this.serviceCache = new ServiceCacheEntry(algorithm, Services.refreshNumber, service);
+            this.serviceCache = new ServiceCacheEntry(algorithm, newCacheVersion, service);
         }
         return new SpiAndProvider(service.newInstance(param), service.getProvider());
     }
diff --git a/luni/src/main/java/org/apache/harmony/security/fortress/Services.java b/luni/src/main/java/org/apache/harmony/security/fortress/Services.java
index d97e0f4..a441290 100644
--- a/luni/src/main/java/org/apache/harmony/security/fortress/Services.java
+++ b/luni/src/main/java/org/apache/harmony/security/fortress/Services.java
@@ -15,11 +15,6 @@
  *  limitations under the License.
  */
 
-/**
-* @author Boris V. Kuznetsov
-* @version $Revision$
-*/
-
 package org.apache.harmony.security.fortress;
 
 import java.security.Provider;
@@ -34,204 +29,215 @@ import java.util.Map;
 /**
  * This class contains information about all registered providers and preferred
  * implementations for all "serviceName.algName".
- *
  */
-
 public class Services {
 
-    // The HashMap that contains information about preferred implementations for
-    // all serviceName.algName in the registered providers.
-    // Set the initial size to 600 so we don't grow to 1024 by default because
-    // initialization adds a few entries more than the growth threshold.
+    /**
+     * The HashMap that contains information about preferred implementations for
+     * all serviceName.algName in the registered providers.
+     * Set the initial size to 600 so we don't grow to 1024 by default because
+     * initialization adds a few entries more than the growth threshold.
+     */
     private static final Map<String, Provider.Service> services
             = new HashMap<String, Provider.Service>(600);
-    // Save default SecureRandom service as well.
-    // Avoids similar provider/services iteration in SecureRandom constructor
-    private static Provider.Service secureRandom;
 
-    // Need refresh flag
-    private static boolean needRefresh; // = false;
+    /**
+     * Save default SecureRandom service as well.
+     * Avoids similar provider/services iteration in SecureRandom constructor.
+     */
+    private static Provider.Service cachedSecureRandomService;
+
+    /**
+     * Need refresh flag. Protected by synchronizing on providers.
+     */
+    private static boolean needRefresh;
 
     /**
-     * Refresh number
+     * The cacheVersion is changed on every update of service
+     * information. It is used by external callers to validate their
+     * own caches of Service information.
      */
-    static int refreshNumber = 1;
+    private static int cacheVersion = 1;
 
-    // Registered providers
+    /**
+     * Registered providers.
+     */
     private static final List<Provider> providers = new ArrayList<Provider>(20);
 
-    // Hash for quick provider access by name
+    /**
+     * Hash for quick provider access by name. Protected by synchronizing on providers.
+     */
     private static final Map<String, Provider> providersNames = new HashMap<String, Provider>(20);
     static {
         loadProviders();
     }
 
-    // Load statically registered providers and init Services Info
     private static void loadProviders() {
-        String providerClassName = null;
-        int i = 1;
-        ClassLoader cl = ClassLoader.getSystemClassLoader();
-        Provider p;
-
-        while ((providerClassName = Security.getProperty("security.provider."
-                + i++)) != null) {
-            try {
-                p = (Provider) Class
-                        .forName(providerClassName.trim(), true, cl)
-                        .newInstance();
-                providers.add(p);
-                providersNames.put(p.getName(), p);
-                initServiceInfo(p);
-            } catch (ClassNotFoundException e) { // ignore Exceptions
-            } catch (IllegalAccessException e) {
-            } catch (InstantiationException e) {
+        synchronized (providers) {
+            String providerClassName = null;
+            int i = 1;
+            ClassLoader cl = ClassLoader.getSystemClassLoader();
+
+            while ((providerClassName = Security.getProperty("security.provider." + i++)) != null) {
+                try {
+                    Class providerClass = Class.forName(providerClassName.trim(), true, cl);
+                    Provider p = (Provider) providerClass.newInstance();
+                    providers.add(p);
+                    providersNames.put(p.getName(), p);
+                    initServiceInfo(p);
+                } catch (ClassNotFoundException ignored) {
+                } catch (IllegalAccessException ignored) {
+                } catch (InstantiationException ignored) {
+                }
             }
+            Engine.door.renumProviders();
         }
-        Engine.door.renumProviders();
     }
 
     /**
-     * Returns registered providers
-     *
-     * @return
+     * Returns a copy of the registered providers as an array.
      */
     public static Provider[] getProviders() {
-        return providers.toArray(new Provider[providers.size()]);
+        synchronized (providers) {
+            return providers.toArray(new Provider[providers.size()]);
+        }
     }
 
     /**
-     * Returns registered providers as List
-     *
-     * @return
+     * Returns a copy of the registered providers as a list.
      */
     public static List<Provider> getProvidersList() {
-        return new ArrayList<Provider>(providers);
+        synchronized (providers) {
+            return new ArrayList<Provider>(providers);
+        }
     }
 
     /**
-     * Returns the provider with the specified name
-     *
-     * @param name
-     * @return
+     * Returns the provider with the specified name.
      */
     public static Provider getProvider(String name) {
         if (name == null) {
             return null;
         }
-        return providersNames.get(name);
+        synchronized (providers) {
+            return providersNames.get(name);
+        }
     }
 
     /**
-     * Inserts a provider at a specified position
-     *
-     * @param provider
-     * @param position
-     * @return
+     * Inserts a provider at a specified 1-based position.
      */
     public static int insertProviderAt(Provider provider, int position) {
-        int size = providers.size();
-        if ((position < 1) || (position > size)) {
-            position = size + 1;
+        synchronized (providers) {
+            int size = providers.size();
+            if ((position < 1) || (position > size)) {
+                position = size + 1;
+            }
+            providers.add(position - 1, provider);
+            providersNames.put(provider.getName(), provider);
+            setNeedRefresh();
+            return position;
         }
-        providers.add(position - 1, provider);
-        providersNames.put(provider.getName(), provider);
-        setNeedRefresh();
-        return position;
     }
 
     /**
-     * Removes the provider
-     *
-     * @param providerNumber
+     * Removes the provider at the specified 1-based position.
      */
     public static void removeProvider(int providerNumber) {
-        Provider p = providers.remove(providerNumber - 1);
-        providersNames.remove(p.getName());
-        setNeedRefresh();
+        synchronized (providers) {
+            Provider p = providers.remove(providerNumber - 1);
+            providersNames.remove(p.getName());
+            setNeedRefresh();
+        }
     }
 
     /**
-     *
      * Adds information about provider services into HashMap.
-     *
-     * @param p
      */
     public static void initServiceInfo(Provider p) {
-        for (Provider.Service serv : p.getServices()) {
-            String type = serv.getType();
-            if (secureRandom == null && type.equals("SecureRandom")) {
-                secureRandom = serv;
-            }
-            String key = type + "." + serv.getAlgorithm().toUpperCase(Locale.US);
-            if (!services.containsKey(key)) {
-                services.put(key, serv);
-            }
-            for (String alias : Engine.door.getAliases(serv)) {
-                key = type + "." + alias.toUpperCase(Locale.US);
+        synchronized (services) {
+            for (Provider.Service service : p.getServices()) {
+                String type = service.getType();
+                if (cachedSecureRandomService == null && type.equals("SecureRandom")) {
+                    cachedSecureRandomService = service;
+                }
+                String key = type + "." + service.getAlgorithm().toUpperCase(Locale.US);
                 if (!services.containsKey(key)) {
-                    services.put(key, serv);
+                    services.put(key, service);
+                }
+                for (String alias : Engine.door.getAliases(service)) {
+                    key = type + "." + alias.toUpperCase(Locale.US);
+                    if (!services.containsKey(key)) {
+                        services.put(key, service);
+                    }
                 }
             }
         }
     }
 
     /**
-     *
-     * Updates services hashtable for all registered providers
-     *
-     */
-    public static void updateServiceInfo() {
-        services.clear();
-        secureRandom = null;
-        for (Provider p : providers) {
-            initServiceInfo(p);
-        }
-        needRefresh = false;
-    }
-
-    /**
-     * Returns true if services contain any provider information
-     * @return
+     * Returns true if services contain any provider information.
      */
     public static boolean isEmpty() {
-        return services.isEmpty();
+        synchronized (services) {
+            return services.isEmpty();
+        }
     }
 
     /**
-     * Returns service description.
-     * Call refresh() before.
+     * Looks up the requested service by type and algorithm. The
+     * service key should be provided in the same format used when
+     * registering a service with a provider, for example,
+     * "KeyFactory.RSA".
      *
-     * @param key in the format TYPE.ALGORITHM
-     * @return
+     * Callers can cache the returned service information but such
+     * caches should be validated against the result of
+     * Service.getCacheVersion() before use.
      */
     public static Provider.Service getService(String key) {
-        return services.get(key);
+        synchronized (services) {
+            return services.get(key);
+        }
     }
 
     /**
      * Returns the default SecureRandom service description.
-     * Call refresh() before.
      */
     public static Provider.Service getSecureRandomService() {
-        return secureRandom;
+        getCacheVersion();  // used for side effect of updating cache if needed
+        return cachedSecureRandomService;
     }
 
     /**
-     * Set flag needRefresh
-     *
+     * In addition to being used here when the list of providers
+     * changes, this method is also used by the Provider
+     * implementation to indicate that a provides list of services has
+     * changed.
      */
     public static void setNeedRefresh() {
-        needRefresh = true;
+        synchronized (providers) {
+            needRefresh = true;
+        }
     }
 
     /**
-     * Refresh services info
-     *
+     * Returns the current cache version. This has the possible side
+     * effect of updating the cache if needed.
      */
-    public static void refresh() {
-        if (needRefresh) {
-            refreshNumber++;
-            updateServiceInfo();
+    public static int getCacheVersion() {
+        synchronized (providers) {
+            if (needRefresh) {
+                cacheVersion++;
+                synchronized (services) {
+                    services.clear();
+                }
+                cachedSecureRandomService = null;
+                for (Provider p : providers) {
+                    initServiceInfo(p);
+                }
+                needRefresh = false;
+            }
+            return cacheVersion;
         }
     }
 }
-- 
cgit v1.1


From a40fcc07b281313cb0ad125d8a1a2d6adec8e867 Mon Sep 17 00:00:00 2001
From: Narayan Kamath <narayan@google.com>
Date: Thu, 19 Jul 2012 09:29:17 +0100
Subject: Add NPN related logging to native crypto

Also fixes a compilation error when logging macros
are expanded.

(cherry-picked from 8a545afcbad15fdd805b9b7790d3d1aa6323fd9e)

Change-Id: I1e422917cdb6fec56398344ee096eb50ab519668
---
 .../native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp     | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp b/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
index 65e76ec..615b6b3 100644
--- a/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
+++ b/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
@@ -1839,7 +1839,7 @@ static void NativeCrypto_RAND_bytes(JNIEnv* env, jclass, jbyteArray output) {
     unsigned char* tmp = reinterpret_cast<unsigned char*>(outputBytes.get());
     if (!RAND_bytes(tmp, outputBytes.size())) {
         throwExceptionIfNecessary(env, "NativeCrypto_RAND_bytes");
-        JNI_TRACE("ctx=%p NativeCrypto_RAND_bytes => threw error", ctx);
+        JNI_TRACE("tmp=%p NativeCrypto_RAND_bytes => threw error", tmp);
         return;
     }
 
@@ -3204,8 +3204,10 @@ static int next_proto_select_callback(SSL* ssl, unsigned char **out, unsigned ch
     SSL_set_mode(ssl, SSL_MODE_HANDSHAKE_CUTTHROUGH);
 
     AppData* appData = toAppData(ssl);
+    JNI_TRACE("AppData=%p", appData);
     unsigned char* npnProtocols = reinterpret_cast<unsigned char*>(appData->npnProtocolsData);
     size_t npnProtocolsLength = appData->npnProtocolsLength;
+    JNI_TRACE("npn_protocols=%p, length=%d", npnProtocols, npnProtocolsLength);
 
     int status = SSL_select_next_proto(out, outlen, in, inlen, npnProtocols, npnProtocolsLength);
     switch (status) {
-- 
cgit v1.1


From c531f5f402b4cedcc35a0b7f0b540dc84c545106 Mon Sep 17 00:00:00 2001
From: Kenny Root <kroot@google.com>
Date: Tue, 31 Jul 2012 13:00:10 -0700
Subject: Add raw RSA signature support

With the new Keystore changes, this is the only way you can get raw RSA
signatures which a lot of native code expects to be able to do.

Bug: 6787078
Change-Id: I1c5ddd5287be1ab71347eedc864a41c24e156cb4
---
 .../harmony/xnet/provider/jsse/NativeCrypto.java   |  18 ++
 .../xnet/provider/jsse/OpenSSLProvider.java        |   3 +
 .../xnet/provider/jsse/OpenSSLSignatureRawRSA.java | 208 +++++++++++++++++++
 ...che_harmony_xnet_provider_jsse_NativeCrypto.cpp | 157 ++++++++++++++
 .../java/libcore/java/security/SignatureTest.java  | 229 ++++++++++++++++++++-
 5 files changed, 612 insertions(+), 3 deletions(-)
 create mode 100644 luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLSignatureRawRSA.java

diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/NativeCrypto.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/NativeCrypto.java
index f3cc1ac..5fc4aef 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/NativeCrypto.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/NativeCrypto.java
@@ -84,6 +84,20 @@ public final class NativeCrypto {
 
     public static native int RSA_generate_key_ex(int modulusBits, byte[] publicExponent);
 
+    public static native int RSA_size(int pkey);
+
+    public static native int RSA_private_encrypt(int flen, byte[] from, byte[] to, int pkey,
+            int padding);
+
+    public static native int RSA_public_decrypt(int flen, byte[] from, byte[] to, int pkey,
+            int padding);
+
+    public static native void RSA_padding_add_PKCS1_type_1(byte[] to, int tlen, byte[] from,
+            int flen);
+
+    public static native int RSA_padding_check_PKCS1_type_1(byte[] to, int tlen, byte[] from,
+            int flen, int rsa_len);
+
     /**
      * @return array of {n, e}
      */
@@ -335,6 +349,10 @@ public final class NativeCrypto {
     public static final int EVP_PKEY_DH  = 28;  // NID_dhKeyAgreement
     public static final int EVP_PKEY_EC  = 408; // NID_X9_62_id_ecPublicKey
 
+    // RSA padding modes from rsa.h
+    public static final int RSA_PKCS1_PADDING = 1;
+    public static final int RSA_NO_PADDING    = 3;
+
     // SSL mode from ssl.h
     public static final long SSL_MODE_HANDSHAKE_CUTTHROUGH = 0x00000040L;
 
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLProvider.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLProvider.java
index 4c88fc3..efb9387 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLProvider.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLProvider.java
@@ -109,6 +109,9 @@ public final class OpenSSLProvider extends Provider {
         put("Alg.Alias.Signature.DSAWithSHA1", "SHA1withDSA");
         put("Alg.Alias.Signature.1.2.840.10040.4.3", "SHA1withDSA");
 
+        put("Signature.RAWRSA", OpenSSLSignatureRawRSA.class.getName());
+        put("Alg.Alias.Signature.NONEwithRSA", "RAWRSA");
+
         // SecureRandom
         /*
          * We have to specify SHA1PRNG because various documentation mentions
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLSignatureRawRSA.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLSignatureRawRSA.java
new file mode 100644
index 0000000..70d2532
--- /dev/null
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLSignatureRawRSA.java
@@ -0,0 +1,208 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed 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.xnet.provider.jsse;
+
+import java.security.InvalidKeyException;
+import java.security.InvalidParameterException;
+import java.security.NoSuchAlgorithmException;
+import java.security.PrivateKey;
+import java.security.PublicKey;
+import java.security.Signature;
+import java.security.SignatureException;
+import java.security.interfaces.RSAPrivateCrtKey;
+import java.security.interfaces.RSAPrivateKey;
+import java.security.interfaces.RSAPublicKey;
+
+/**
+ * Implements the JDK Signature interface needed for RAW RSA signature
+ * generation and verification using OpenSSL.
+ */
+public class OpenSSLSignatureRawRSA extends Signature {
+    /**
+     * The current OpenSSL key we're operating on.
+     */
+    private OpenSSLKey key;
+
+    /**
+     * Buffer to hold value to be signed or verified.
+     */
+    private byte[] inputBuffer;
+
+    /**
+     * Current offset in input buffer.
+     */
+    private int inputOffset;
+
+    /**
+     * Provides a flag to specify when the input is too long.
+     */
+    private boolean inputIsTooLong;
+
+    /**
+     * Creates a new OpenSSLSignature instance for the given algorithm name.
+     */
+    public OpenSSLSignatureRawRSA() throws NoSuchAlgorithmException {
+        super("NONEwithRSA");
+    }
+
+    @Override
+    protected void engineUpdate(byte input) {
+        final int oldOffset = inputOffset++;
+
+        if (inputOffset > inputBuffer.length) {
+            inputIsTooLong = true;
+            return;
+        }
+
+        inputBuffer[oldOffset] = input;
+    }
+
+    @Override
+    protected void engineUpdate(byte[] input, int offset, int len) {
+        final int oldOffset = inputOffset;
+        inputOffset += len;
+
+        if (inputOffset > inputBuffer.length) {
+            inputIsTooLong = true;
+            return;
+        }
+
+        System.arraycopy(input, offset, inputBuffer, oldOffset, len);
+    }
+
+    @Override
+    protected Object engineGetParameter(String param) throws InvalidParameterException {
+        return null;
+    }
+
+    @Override
+    protected void engineInitSign(PrivateKey privateKey) throws InvalidKeyException {
+        if (privateKey instanceof OpenSSLRSAPrivateKey) {
+            OpenSSLRSAPrivateKey rsaPrivateKey = (OpenSSLRSAPrivateKey) privateKey;
+            key = rsaPrivateKey.getOpenSSLKey();
+        } else if (privateKey instanceof RSAPrivateCrtKey) {
+            RSAPrivateCrtKey rsaPrivateKey = (RSAPrivateCrtKey) privateKey;
+            key = OpenSSLRSAPrivateCrtKey.getInstance(rsaPrivateKey);
+        } else if (privateKey instanceof RSAPrivateKey) {
+            RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) privateKey;
+            key = OpenSSLRSAPrivateKey.getInstance(rsaPrivateKey);
+        } else {
+            throw new InvalidKeyException("Need DSA or RSA private key");
+        }
+
+        // Allocate buffer according to RSA modulus size.
+        int maxSize = NativeCrypto.RSA_size(key.getPkeyContext());
+        inputBuffer = new byte[maxSize];
+        inputOffset = 0;
+    }
+
+    @Override
+    protected void engineInitVerify(PublicKey publicKey) throws InvalidKeyException {
+        if (publicKey instanceof OpenSSLRSAPublicKey) {
+            OpenSSLRSAPublicKey rsaPublicKey = (OpenSSLRSAPublicKey) publicKey;
+            key = rsaPublicKey.getOpenSSLKey();
+        } else if (publicKey instanceof RSAPublicKey) {
+            RSAPublicKey rsaPublicKey = (RSAPublicKey) publicKey;
+            key = OpenSSLRSAPublicKey.getInstance(rsaPublicKey);
+        } else {
+            throw new InvalidKeyException("Need DSA or RSA public key");
+        }
+
+        // Allocate buffer according to RSA modulus size.
+        int maxSize = NativeCrypto.RSA_size(key.getPkeyContext());
+        inputBuffer = new byte[maxSize];
+        inputOffset = 0;
+    }
+
+    @Override
+    protected void engineSetParameter(String param, Object value) throws InvalidParameterException {
+    }
+
+    @Override
+    protected byte[] engineSign() throws SignatureException {
+        if (key == null) {
+            // This can't actually happen, but you never know...
+            throw new SignatureException("Need RSA private key");
+        }
+
+        if (inputIsTooLong) {
+            throw new SignatureException("input length " + inputOffset + " != "
+                    + inputBuffer.length + " (modulus size)");
+        }
+
+        byte[] paddedBuffer = new byte[inputBuffer.length];
+        byte[] outputBuffer = new byte[inputBuffer.length];
+        try {
+            NativeCrypto.RSA_padding_add_PKCS1_type_1(paddedBuffer, paddedBuffer.length,
+                    inputBuffer, inputOffset);
+            NativeCrypto.RSA_private_encrypt(paddedBuffer.length, paddedBuffer, outputBuffer,
+                    key.getPkeyContext(), NativeCrypto.RSA_NO_PADDING);
+            return outputBuffer;
+        } catch (Exception ex) {
+            throw new SignatureException(ex);
+        } finally {
+            inputOffset = 0;
+        }
+    }
+
+    @Override
+    protected boolean engineVerify(byte[] sigBytes) throws SignatureException {
+        if (key == null) {
+            // This can't actually happen, but you never know...
+            throw new SignatureException("Need RSA public key");
+        }
+
+        if (inputIsTooLong) {
+            return false;
+        }
+
+        byte[] paddedBuffer = new byte[inputBuffer.length];
+        byte[] outputBuffer = new byte[inputBuffer.length];
+        try {
+            int paddedSize = NativeCrypto.RSA_public_decrypt(sigBytes.length, sigBytes,
+                    paddedBuffer, key.getPkeyContext(), NativeCrypto.RSA_NO_PADDING);
+
+            /*
+             * RSA_padding_check_PKCS1_type_1 expects the leading 0-byte to be
+             * truncated already.
+             */
+            paddedSize--;
+            System.arraycopy(paddedBuffer, 1, paddedBuffer, 0, paddedSize);
+
+            final int size;
+            try {
+                size = NativeCrypto.RSA_padding_check_PKCS1_type_1(outputBuffer,
+                        outputBuffer.length, paddedBuffer, paddedSize, inputBuffer.length);
+            } catch (Exception e) {
+                return false;
+            }
+
+            /* Make this constant time by comparing every byte. */
+            boolean matches = (size == inputOffset);
+            for (int i = 0; i < size; i++) {
+                if (inputBuffer[i] != outputBuffer[i]) {
+                    matches = false;
+                }
+            }
+            return matches;
+        } catch (Exception ex) {
+            throw new SignatureException(ex);
+        } finally {
+            inputOffset = 0;
+        }
+    }
+}
diff --git a/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp b/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
index 615b6b3..9f8ca6f 100644
--- a/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
+++ b/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
@@ -1010,6 +1010,158 @@ static jint NativeCrypto_RSA_generate_key_ex(JNIEnv* env, jclass, jint modulusBi
     return static_cast<jint>(reinterpret_cast<uintptr_t>(pkey.release()));
 }
 
+static jint NativeCrypto_RSA_size(JNIEnv* env, jclass, jint pkeyRef) {
+    EVP_PKEY* pkey = reinterpret_cast<EVP_PKEY*>(pkeyRef);
+    JNI_TRACE("RSA_size(%p)", pkey);
+
+    Unique_RSA rsa(EVP_PKEY_get1_RSA(pkey));
+    if (rsa.get() == NULL) {
+        jniThrowRuntimeException(env, "RSA_size failed");
+        return 0;
+    }
+
+    return static_cast<jint>(RSA_size(rsa.get()));
+}
+
+static jint NativeCrypto_RSA_private_encrypt(JNIEnv* env, jclass, jint flen,
+        jbyteArray fromJavaBytes, jbyteArray toJavaBytes, jint pkeyRef, jint padding) {
+    EVP_PKEY* pkey = reinterpret_cast<EVP_PKEY*>(pkeyRef);
+    JNI_TRACE("RSA_private_encrypt(%d, %p, %p, %p)", flen, fromJavaBytes, toJavaBytes, pkey);
+
+    Unique_RSA rsa(EVP_PKEY_get1_RSA(pkey));
+    if (rsa.get() == NULL) {
+        return -1;
+    }
+
+    ScopedByteArrayRO from(env, fromJavaBytes);
+    if (from.get() == NULL) {
+        return -1;
+    }
+
+    ScopedByteArrayRW to(env, toJavaBytes);
+    if (to.get() == NULL) {
+        return -1;
+    }
+
+    int resultSize = RSA_private_encrypt(static_cast<int>(flen),
+            reinterpret_cast<const unsigned char*>(from.get()),
+            reinterpret_cast<unsigned char*>(to.get()), rsa.get(), padding);
+    if (resultSize == -1) {
+        JNI_TRACE("RSA_private_encrypt => failed");
+        throwExceptionIfNecessary(env, "RSA_private_encrypt failed");
+        return -1;
+    }
+
+    JNI_TRACE("RSA_private_encrypt(%d, %p, %p, %p) => %d", flen, fromJavaBytes, toJavaBytes, pkey,
+            resultSize);
+    return static_cast<jint>(resultSize);
+}
+
+static jint NativeCrypto_RSA_public_decrypt(JNIEnv* env, jclass, jint flen,
+        jbyteArray fromJavaBytes, jbyteArray toJavaBytes, jint pkeyRef, jint padding) {
+    EVP_PKEY* pkey = reinterpret_cast<EVP_PKEY*>(pkeyRef);
+    JNI_TRACE("RSA_private_encrypt(%d, %p, %p, %p)", flen, fromJavaBytes, toJavaBytes, pkey);
+
+    Unique_RSA rsa(EVP_PKEY_get1_RSA(pkey));
+    if (rsa.get() == NULL) {
+        return -1;
+    }
+
+    ScopedByteArrayRO from(env, fromJavaBytes);
+    if (from.get() == NULL) {
+        return -1;
+    }
+
+    ScopedByteArrayRW to(env, toJavaBytes);
+    if (to.get() == NULL) {
+        return -1;
+    }
+
+    int resultSize = RSA_public_decrypt(static_cast<int>(flen),
+            reinterpret_cast<const unsigned char*>(from.get()),
+            reinterpret_cast<unsigned char*>(to.get()), rsa.get(), padding);
+    if (resultSize == -1) {
+        JNI_TRACE("RSA_private_encrypt => failed");
+        throwExceptionIfNecessary(env, "RSA_private_encrypt failed");
+        return -1;
+    }
+
+    JNI_TRACE("RSA_private_encrypt(%d, %p, %p, %p) => %d", flen, fromJavaBytes, toJavaBytes, pkey,
+            resultSize);
+    return static_cast<jint>(resultSize);
+}
+
+static void NativeCrypto_RSA_padding_add_PKCS1_type_1(JNIEnv* env, jclass, jbyteArray toJavaBytes,
+        jint tlen, jbyteArray fromJavaBytes, jint flen) {
+    JNI_TRACE("RSA_padding_add_PKCS1_type_1(%p, %d, %p, %d)", toJavaBytes, tlen, fJavaBytes, fl);
+
+    ScopedByteArrayRO from(env, fromJavaBytes);
+    if (from.get() == NULL) {
+        return;
+    }
+
+    if (size_t(flen) > from.size()) {
+        jniThrowException(env, "java/lang/IndexOutOfBoundsException", NULL);
+        return;
+    }
+
+    ScopedByteArrayRW to(env, toJavaBytes);
+    if (to.get() == NULL) {
+        return;
+    }
+
+    if (size_t(tlen) > to.size()) {
+        jniThrowException(env, "java/lang/IndexOutOfBoundsException", NULL);
+        return;
+    }
+
+    if (RSA_padding_add_PKCS1_type_1(reinterpret_cast<unsigned char*>(to.get()), tlen,
+            reinterpret_cast<const unsigned char*>(from.get()), flen) == 0) {
+        throwExceptionIfNecessary(env, "RSA_padding_add_PKCS1_type_1 failed");
+        return;
+    }
+
+    JNI_TRACE("RSA_padding_add_PKCS1_type_1(%p, %d, %p, %d) => done", toJavaBytes, tlen, fJavaBytes,
+            fl);
+}
+
+static jint NativeCrypto_RSA_padding_check_PKCS1_type_1(JNIEnv* env, jclass, jbyteArray toJavaBytes,
+        jint tlen, jbyteArray fromJavaBytes, jint flen, jint rsa_len) {
+    JNI_TRACE("RSA_padding_add_PKCS1_type_1(%p, %d, %p, %d, %d)", toJavaBytes, tlen, fJavaBytes, fl,
+            rsa_len);
+
+    ScopedByteArrayRW to(env, toJavaBytes);
+    if (to.get() == NULL) {
+        return 0;
+    }
+
+    if (size_t(tlen) > to.size()) {
+        jniThrowException(env, "java/lang/IndexOutOfBoundsException", NULL);
+        return 0;
+    }
+
+    ScopedByteArrayRO from(env, fromJavaBytes);
+    if (from.get() == NULL) {
+        return 0;
+    }
+
+    if (size_t(flen) > from.size()) {
+        jniThrowException(env, "java/lang/IndexOutOfBoundsException", NULL);
+        return 0;
+    }
+
+    int size = RSA_padding_check_PKCS1_type_1(reinterpret_cast<unsigned char*>(to.get()), tlen,
+            reinterpret_cast<const unsigned char*>(from.get()), flen, rsa_len);
+    if (size == -1) {
+        throwExceptionIfNecessary(env, "RSA_padding_check_PKCS1_type_1 failed");
+        return 0;
+    }
+
+    JNI_TRACE("RSA_padding_check_PKCS1_type_1(%p, %d, %p, %d, %d) => %d", toJavaBytes, tlen,
+            fJavaBytes, fl, rsa_len, size);
+    return size;
+}
+
 /*
  * public static native byte[][] get_RSA_public_params(int);
  */
@@ -4268,6 +4420,11 @@ static JNINativeMethod sNativeCryptoMethods[] = {
     NATIVE_METHOD(NativeCrypto, i2d_PUBKEY, "(I)[B"),
     NATIVE_METHOD(NativeCrypto, d2i_PUBKEY, "([B)I"),
     NATIVE_METHOD(NativeCrypto, RSA_generate_key_ex, "(I[B)I"),
+    NATIVE_METHOD(NativeCrypto, RSA_size, "(I)I"),
+    NATIVE_METHOD(NativeCrypto, RSA_private_encrypt, "(I[B[BII)I"),
+    NATIVE_METHOD(NativeCrypto, RSA_public_decrypt, "(I[B[BII)I"),
+    NATIVE_METHOD(NativeCrypto, RSA_padding_add_PKCS1_type_1, "([BI[BI)V"),
+    NATIVE_METHOD(NativeCrypto, RSA_padding_check_PKCS1_type_1, "([BI[BII)I"),
     NATIVE_METHOD(NativeCrypto, get_RSA_private_params, "(I)[[B"),
     NATIVE_METHOD(NativeCrypto, get_RSA_public_params, "(I)[[B"),
     NATIVE_METHOD(NativeCrypto, DSA_generate_key, "(I[B[B[B[B)I"),
diff --git a/luni/src/test/java/libcore/java/security/SignatureTest.java b/luni/src/test/java/libcore/java/security/SignatureTest.java
index 2cd9982..7b9b773 100644
--- a/luni/src/test/java/libcore/java/security/SignatureTest.java
+++ b/luni/src/test/java/libcore/java/security/SignatureTest.java
@@ -26,6 +26,7 @@ import java.security.Provider;
 import java.security.PublicKey;
 import java.security.Security;
 import java.security.Signature;
+import java.security.SignatureException;
 import java.security.spec.DSAPrivateKeySpec;
 import java.security.spec.DSAPublicKeySpec;
 import java.security.spec.InvalidKeySpecException;
@@ -123,9 +124,21 @@ public class SignatureTest extends TestCase {
         sig.update(DATA);
         assertTrue(sig.getAlgorithm(), sig.verify(signature));
 
-        // Calling Signature.verify a second time should not throw
-        // http://code.google.com/p/android/issues/detail?id=34933
-        sig.verify(signature);
+        /*
+         * The RI appears to clear out the input data in RawDSA while calling
+         * verify a second time.
+         */
+        if (StandardNames.IS_RI && "NONEwithDSA".equalsIgnoreCase(sig.getAlgorithm())) {
+            try {
+                sig.verify(signature);
+                fail("Expected RI to have a NONEwithDSA bug");
+            } catch (SignatureException bug) {
+            }
+        } else {
+            // Calling Signature.verify a second time should not throw
+            // http://code.google.com/p/android/issues/detail?id=34933
+            sig.verify(signature);
+        }
     }
 
     private static final byte[] PK_BYTES = hexToBytes(
@@ -326,6 +339,7 @@ public class SignatureTest extends TestCase {
         (byte) 0x39,
     });
 
+    /* Test data is: "Android.\n" */
     private static final byte[] Vector1Data = new byte[] {
         (byte) 0x41, (byte) 0x6e, (byte) 0x64, (byte) 0x72, (byte) 0x6f, (byte) 0x69, (byte) 0x64, (byte) 0x2e,
         (byte) 0x0a,
@@ -550,11 +564,61 @@ public class SignatureTest extends TestCase {
         (byte) 0x02, (byte) 0xaf, (byte) 0x8f, (byte) 0x59, (byte) 0xe5, (byte) 0x67, (byte) 0x25, (byte) 0x00,
     };
 
+    /*
+     * openssl rsautl -raw -sign -inkey rsa.key | recode ../x1 | sed 's/0x/(byte) 0x/g'
+     */
+    private static final byte[] NONEwithRSA_Vector1Signature = new byte[] {
+        (byte) 0x35, (byte) 0x43, (byte) 0x38, (byte) 0x44, (byte) 0xAD, (byte) 0x3F,
+        (byte) 0x97, (byte) 0x02, (byte) 0xFB, (byte) 0x59, (byte) 0x1F, (byte) 0x4A,
+        (byte) 0x2B, (byte) 0xB9, (byte) 0x06, (byte) 0xEC, (byte) 0x66, (byte) 0xE6,
+        (byte) 0xD2, (byte) 0xC5, (byte) 0x8B, (byte) 0x7B, (byte) 0xE3, (byte) 0x18,
+        (byte) 0xBF, (byte) 0x07, (byte) 0xD6, (byte) 0x01, (byte) 0xF9, (byte) 0xD9,
+        (byte) 0x89, (byte) 0xC4, (byte) 0xDB, (byte) 0x00, (byte) 0x68, (byte) 0xFF,
+        (byte) 0x9B, (byte) 0x43, (byte) 0x90, (byte) 0xF2, (byte) 0xDB, (byte) 0x83,
+        (byte) 0xF4, (byte) 0x7E, (byte) 0xC6, (byte) 0x81, (byte) 0x01, (byte) 0x3A,
+        (byte) 0x0B, (byte) 0xE5, (byte) 0xED, (byte) 0x08, (byte) 0x73, (byte) 0x3E,
+        (byte) 0xE1, (byte) 0x3F, (byte) 0xDF, (byte) 0x1F, (byte) 0x07, (byte) 0x6D,
+        (byte) 0x22, (byte) 0x8D, (byte) 0xCC, (byte) 0x4E, (byte) 0xE3, (byte) 0x9A,
+        (byte) 0xBC, (byte) 0xCC, (byte) 0x8F, (byte) 0x9E, (byte) 0x9B, (byte) 0x02,
+        (byte) 0x48, (byte) 0x00, (byte) 0xAC, (byte) 0x9F, (byte) 0xA4, (byte) 0x8F,
+        (byte) 0x87, (byte) 0xA1, (byte) 0xA8, (byte) 0xE6, (byte) 0x9D, (byte) 0xCD,
+        (byte) 0x8B, (byte) 0x05, (byte) 0xE9, (byte) 0xD2, (byte) 0x05, (byte) 0x8D,
+        (byte) 0xC9, (byte) 0x95, (byte) 0x16, (byte) 0xD0, (byte) 0xCD, (byte) 0x43,
+        (byte) 0x25, (byte) 0x8A, (byte) 0x11, (byte) 0x46, (byte) 0xD7, (byte) 0x74,
+        (byte) 0x4C, (byte) 0xCF, (byte) 0x58, (byte) 0xF9, (byte) 0xA1, (byte) 0x30,
+        (byte) 0x84, (byte) 0x52, (byte) 0xC9, (byte) 0x01, (byte) 0x5F, (byte) 0x24,
+        (byte) 0x4C, (byte) 0xB1, (byte) 0x9F, (byte) 0x7D, (byte) 0x12, (byte) 0x38,
+        (byte) 0x27, (byte) 0x0F, (byte) 0x5E, (byte) 0xFF, (byte) 0xE0, (byte) 0x55,
+        (byte) 0x8B, (byte) 0xA3, (byte) 0xAD, (byte) 0x60, (byte) 0x35, (byte) 0x83,
+        (byte) 0x58, (byte) 0xAF, (byte) 0x99, (byte) 0xDE, (byte) 0x3F, (byte) 0x5D,
+        (byte) 0x80, (byte) 0x80, (byte) 0xFF, (byte) 0x9B, (byte) 0xDE, (byte) 0x5C,
+        (byte) 0xAB, (byte) 0x97, (byte) 0x43, (byte) 0x64, (byte) 0xD9, (byte) 0x9F,
+        (byte) 0xFB, (byte) 0x67, (byte) 0x65, (byte) 0xA5, (byte) 0x99, (byte) 0xE7,
+        (byte) 0xE6, (byte) 0xEB, (byte) 0x05, (byte) 0x95, (byte) 0xFC, (byte) 0x46,
+        (byte) 0x28, (byte) 0x4B, (byte) 0xD8, (byte) 0x8C, (byte) 0xF5, (byte) 0x0A,
+        (byte) 0xEB, (byte) 0x1F, (byte) 0x30, (byte) 0xEA, (byte) 0xE7, (byte) 0x67,
+        (byte) 0x11, (byte) 0x25, (byte) 0xF0, (byte) 0x44, (byte) 0x75, (byte) 0x74,
+        (byte) 0x94, (byte) 0x06, (byte) 0x78, (byte) 0xD0, (byte) 0x21, (byte) 0xF4,
+        (byte) 0x3F, (byte) 0xC8, (byte) 0xC4, (byte) 0x4A, (byte) 0x57, (byte) 0xBE,
+        (byte) 0x02, (byte) 0x3C, (byte) 0x93, (byte) 0xF6, (byte) 0x95, (byte) 0xFB,
+        (byte) 0xD1, (byte) 0x77, (byte) 0x8B, (byte) 0x43, (byte) 0xF0, (byte) 0xB9,
+        (byte) 0x7D, (byte) 0xE0, (byte) 0x32, (byte) 0xE1, (byte) 0x72, (byte) 0xB5,
+        (byte) 0x62, (byte) 0x3F, (byte) 0x86, (byte) 0xC3, (byte) 0xD4, (byte) 0x5F,
+        (byte) 0x5E, (byte) 0x54, (byte) 0x1B, (byte) 0x5B, (byte) 0xE6, (byte) 0x74,
+        (byte) 0xA1, (byte) 0x0B, (byte) 0xE5, (byte) 0x18, (byte) 0xD2, (byte) 0x4F,
+        (byte) 0x93, (byte) 0xF3, (byte) 0x09, (byte) 0x58, (byte) 0xCE, (byte) 0xF0,
+        (byte) 0xA3, (byte) 0x61, (byte) 0xE4, (byte) 0x6E, (byte) 0x46, (byte) 0x45,
+        (byte) 0x89, (byte) 0x50, (byte) 0xBD, (byte) 0x03, (byte) 0x3F, (byte) 0x38,
+        (byte) 0xDA, (byte) 0x5D, (byte) 0xD0, (byte) 0x1B, (byte) 0x1F, (byte) 0xB1,
+        (byte) 0xEE, (byte) 0x89, (byte) 0x59, (byte) 0xC5,
+    };
+
     public void testGetCommonInstances_Success() throws Exception {
         assertNotNull(Signature.getInstance("SHA1withRSA"));
         assertNotNull(Signature.getInstance("SHA256withRSA"));
         assertNotNull(Signature.getInstance("SHA384withRSA"));
         assertNotNull(Signature.getInstance("SHA512withRSA"));
+        assertNotNull(Signature.getInstance("NONEwithRSA"));
         assertNotNull(Signature.getInstance("MD5withRSA"));
         assertNotNull(Signature.getInstance("SHA1withDSA"));
     }
@@ -902,6 +966,165 @@ public class SignatureTest extends TestCase {
         assertTrue("Signature must verify correctly", sig.verify(signature));
     }
 
+    public void testSign_NONEwithRSA_Key_Success() throws Exception {
+        KeyFactory kf = KeyFactory.getInstance("RSA");
+        RSAPrivateKeySpec keySpec = new RSAPrivateKeySpec(RSA_2048_modulus,
+                RSA_2048_privateExponent);
+        PrivateKey privKey = kf.generatePrivate(keySpec);
+
+        Signature sig = Signature.getInstance("NONEwithRSA");
+        sig.initSign(privKey);
+        sig.update(Vector1Data);
+
+        byte[] signature = sig.sign();
+        assertNotNull("Signature must not be null", signature);
+        assertTrue("Signature should match expected",
+                Arrays.equals(signature, NONEwithRSA_Vector1Signature));
+
+        RSAPublicKeySpec pubKeySpec = new RSAPublicKeySpec(RSA_2048_modulus,
+                RSA_2048_publicExponent);
+        PublicKey pubKey = kf.generatePublic(pubKeySpec);
+        sig.initVerify(pubKey);
+        sig.update(Vector1Data);
+        assertTrue("Signature must verify correctly", sig.verify(signature));
+    }
+
+    public void testVerify_NONEwithRSA_Key_WrongSignature_Failure() throws Exception {
+        KeyFactory kf = KeyFactory.getInstance("RSA");
+
+        RSAPublicKeySpec pubKeySpec = new RSAPublicKeySpec(RSA_2048_modulus,
+                RSA_2048_publicExponent);
+        PublicKey pubKey = kf.generatePublic(pubKeySpec);
+
+        Signature sig = Signature.getInstance("NONEwithRSA");
+        sig.initVerify(pubKey);
+        sig.update(Vector1Data);
+        assertFalse("Invalid signature must not verify", sig.verify("Invalid".getBytes()));
+    }
+
+    public void testSign_NONEwithRSA_Key_DataTooLarge_Failure() throws Exception {
+        KeyFactory kf = KeyFactory.getInstance("RSA");
+        RSAPrivateKeySpec keySpec = new RSAPrivateKeySpec(RSA_2048_modulus,
+                RSA_2048_privateExponent);
+        PrivateKey privKey = kf.generatePrivate(keySpec);
+
+        Signature sig = Signature.getInstance("NONEwithRSA");
+        sig.initSign(privKey);
+
+        final int oneTooBig = RSA_2048_modulus.bitLength() - 10;
+        for (int i = 0; i < oneTooBig; i++) {
+            sig.update((byte) i);
+        }
+
+        try {
+            sig.sign();
+            fail("Should throw exception when data is too large");
+        } catch (SignatureException success) {
+        }
+    }
+
+    public void testSign_NONEwithRSA_Key_DataTooLarge_SingleByte_Failure() throws Exception {
+        KeyFactory kf = KeyFactory.getInstance("RSA");
+        RSAPrivateKeySpec keySpec = new RSAPrivateKeySpec(RSA_2048_modulus,
+                RSA_2048_privateExponent);
+        PrivateKey privKey = kf.generatePrivate(keySpec);
+
+        Signature sig = Signature.getInstance("NONEwithRSA");
+        sig.initSign(privKey);
+
+        // This should make it two bytes too big.
+        final int oneTooBig = RSA_2048_modulus.bitLength() - 10;
+        for (int i = 0; i < oneTooBig; i++) {
+            sig.update((byte) i);
+        }
+
+        try {
+            sig.sign();
+            fail("Should throw exception when data is too large");
+        } catch (SignatureException success) {
+        }
+    }
+
+    public void testVerify_NONEwithRSA_Key_DataTooLarge_Failure() throws Exception {
+        KeyFactory kf = KeyFactory.getInstance("RSA");
+
+        RSAPublicKeySpec pubKeySpec = new RSAPublicKeySpec(RSA_2048_modulus,
+                RSA_2048_publicExponent);
+        PublicKey pubKey = kf.generatePublic(pubKeySpec);
+
+        Signature sig = Signature.getInstance("NONEwithRSA");
+        sig.initVerify(pubKey);
+
+        // This should make it one bytes too big.
+        final int oneTooBig = RSA_2048_modulus.bitLength() + 1;
+        final byte[] vector = new byte[oneTooBig];
+        for (int i = 0; i < oneTooBig; i++) {
+            vector[i] = (byte) Vector1Data[i % Vector1Data.length];
+        }
+        sig.update(vector);
+
+        assertFalse("Should not verify when signature is too large",
+                sig.verify(NONEwithRSA_Vector1Signature));
+    }
+
+    public void testVerify_NONEwithRSA_Key_DataTooLarge_SingleByte_Failure() throws Exception {
+        KeyFactory kf = KeyFactory.getInstance("RSA");
+
+        RSAPublicKeySpec pubKeySpec = new RSAPublicKeySpec(RSA_2048_modulus,
+                RSA_2048_publicExponent);
+        PublicKey pubKey = kf.generatePublic(pubKeySpec);
+
+        Signature sig = Signature.getInstance("NONEwithRSA");
+        sig.initVerify(pubKey);
+
+        // This should make it twice as big as it should be.
+        final int tooBig = RSA_2048_modulus.bitLength() * 2;
+        for (int i = 0; i < tooBig; i++) {
+            sig.update((byte) Vector1Data[i % Vector1Data.length]);
+        }
+
+        assertFalse("Should not verify when signature is too large",
+                sig.verify(NONEwithRSA_Vector1Signature));
+    }
+
+    public void testVerify_NONEwithRSA_Key_SignatureTooSmall_Failure() throws Exception {
+        KeyFactory kf = KeyFactory.getInstance("RSA");
+
+        RSAPublicKeySpec pubKeySpec = new RSAPublicKeySpec(RSA_2048_modulus,
+                RSA_2048_publicExponent);
+        PublicKey pubKey = kf.generatePublic(pubKeySpec);
+
+        Signature sig = Signature.getInstance("NONEwithRSA");
+        sig.initVerify(pubKey);
+        sig.update(Vector1Data);
+
+        assertFalse("Invalid signature should not verify", sig.verify("Invalid sig".getBytes()));
+    }
+
+    public void testVerify_NONEwithRSA_Key_SignatureTooLarge_Failure() throws Exception {
+        KeyFactory kf = KeyFactory.getInstance("RSA");
+
+        RSAPublicKeySpec pubKeySpec = new RSAPublicKeySpec(RSA_2048_modulus,
+                RSA_2048_publicExponent);
+        PublicKey pubKey = kf.generatePublic(pubKeySpec);
+
+        Signature sig = Signature.getInstance("NONEwithRSA");
+        sig.initVerify(pubKey);
+        sig.update(Vector1Data);
+
+        byte[] invalidSignature = new byte[NONEwithRSA_Vector1Signature.length * 2];
+        System.arraycopy(NONEwithRSA_Vector1Signature, 0, invalidSignature, 0,
+                NONEwithRSA_Vector1Signature.length);
+        System.arraycopy(NONEwithRSA_Vector1Signature, 0, invalidSignature,
+                NONEwithRSA_Vector1Signature.length, NONEwithRSA_Vector1Signature.length);
+
+        try {
+            sig.verify(invalidSignature);
+            fail("Should throw exception when signature is too large");
+        } catch (SignatureException success) {
+        }
+    }
+
     /*
      * These tests were generated with this DSA private key:
      *
-- 
cgit v1.1


From 7501e29e0182accf28cc317870a3bbe1e25f4bfa Mon Sep 17 00:00:00 2001
From: Kenny Root <kroot@google.com>
Date: Tue, 31 Jul 2012 13:00:10 -0700
Subject: Add raw RSA signature support

With the new Keystore changes, this is the only way you can get raw RSA
signatures which a lot of native code expects to be able to do.

(cherry-picked from c531f5f402b4cedcc35a0b7f0b540dc84c545106)

Bug: 6787078
Change-Id: I1c5ddd5287be1ab71347eedc864a41c24e156cb4
---
 .../harmony/xnet/provider/jsse/NativeCrypto.java   |  18 ++
 .../xnet/provider/jsse/OpenSSLProvider.java        |   3 +
 .../xnet/provider/jsse/OpenSSLSignatureRawRSA.java | 208 +++++++++++++++++++
 ...che_harmony_xnet_provider_jsse_NativeCrypto.cpp | 157 ++++++++++++++
 .../java/libcore/java/security/SignatureTest.java  | 229 ++++++++++++++++++++-
 5 files changed, 612 insertions(+), 3 deletions(-)
 create mode 100644 luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLSignatureRawRSA.java

diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/NativeCrypto.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/NativeCrypto.java
index f3cc1ac..5fc4aef 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/NativeCrypto.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/NativeCrypto.java
@@ -84,6 +84,20 @@ public final class NativeCrypto {
 
     public static native int RSA_generate_key_ex(int modulusBits, byte[] publicExponent);
 
+    public static native int RSA_size(int pkey);
+
+    public static native int RSA_private_encrypt(int flen, byte[] from, byte[] to, int pkey,
+            int padding);
+
+    public static native int RSA_public_decrypt(int flen, byte[] from, byte[] to, int pkey,
+            int padding);
+
+    public static native void RSA_padding_add_PKCS1_type_1(byte[] to, int tlen, byte[] from,
+            int flen);
+
+    public static native int RSA_padding_check_PKCS1_type_1(byte[] to, int tlen, byte[] from,
+            int flen, int rsa_len);
+
     /**
      * @return array of {n, e}
      */
@@ -335,6 +349,10 @@ public final class NativeCrypto {
     public static final int EVP_PKEY_DH  = 28;  // NID_dhKeyAgreement
     public static final int EVP_PKEY_EC  = 408; // NID_X9_62_id_ecPublicKey
 
+    // RSA padding modes from rsa.h
+    public static final int RSA_PKCS1_PADDING = 1;
+    public static final int RSA_NO_PADDING    = 3;
+
     // SSL mode from ssl.h
     public static final long SSL_MODE_HANDSHAKE_CUTTHROUGH = 0x00000040L;
 
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLProvider.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLProvider.java
index 4c88fc3..efb9387 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLProvider.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLProvider.java
@@ -109,6 +109,9 @@ public final class OpenSSLProvider extends Provider {
         put("Alg.Alias.Signature.DSAWithSHA1", "SHA1withDSA");
         put("Alg.Alias.Signature.1.2.840.10040.4.3", "SHA1withDSA");
 
+        put("Signature.RAWRSA", OpenSSLSignatureRawRSA.class.getName());
+        put("Alg.Alias.Signature.NONEwithRSA", "RAWRSA");
+
         // SecureRandom
         /*
          * We have to specify SHA1PRNG because various documentation mentions
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLSignatureRawRSA.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLSignatureRawRSA.java
new file mode 100644
index 0000000..70d2532
--- /dev/null
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLSignatureRawRSA.java
@@ -0,0 +1,208 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed 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.xnet.provider.jsse;
+
+import java.security.InvalidKeyException;
+import java.security.InvalidParameterException;
+import java.security.NoSuchAlgorithmException;
+import java.security.PrivateKey;
+import java.security.PublicKey;
+import java.security.Signature;
+import java.security.SignatureException;
+import java.security.interfaces.RSAPrivateCrtKey;
+import java.security.interfaces.RSAPrivateKey;
+import java.security.interfaces.RSAPublicKey;
+
+/**
+ * Implements the JDK Signature interface needed for RAW RSA signature
+ * generation and verification using OpenSSL.
+ */
+public class OpenSSLSignatureRawRSA extends Signature {
+    /**
+     * The current OpenSSL key we're operating on.
+     */
+    private OpenSSLKey key;
+
+    /**
+     * Buffer to hold value to be signed or verified.
+     */
+    private byte[] inputBuffer;
+
+    /**
+     * Current offset in input buffer.
+     */
+    private int inputOffset;
+
+    /**
+     * Provides a flag to specify when the input is too long.
+     */
+    private boolean inputIsTooLong;
+
+    /**
+     * Creates a new OpenSSLSignature instance for the given algorithm name.
+     */
+    public OpenSSLSignatureRawRSA() throws NoSuchAlgorithmException {
+        super("NONEwithRSA");
+    }
+
+    @Override
+    protected void engineUpdate(byte input) {
+        final int oldOffset = inputOffset++;
+
+        if (inputOffset > inputBuffer.length) {
+            inputIsTooLong = true;
+            return;
+        }
+
+        inputBuffer[oldOffset] = input;
+    }
+
+    @Override
+    protected void engineUpdate(byte[] input, int offset, int len) {
+        final int oldOffset = inputOffset;
+        inputOffset += len;
+
+        if (inputOffset > inputBuffer.length) {
+            inputIsTooLong = true;
+            return;
+        }
+
+        System.arraycopy(input, offset, inputBuffer, oldOffset, len);
+    }
+
+    @Override
+    protected Object engineGetParameter(String param) throws InvalidParameterException {
+        return null;
+    }
+
+    @Override
+    protected void engineInitSign(PrivateKey privateKey) throws InvalidKeyException {
+        if (privateKey instanceof OpenSSLRSAPrivateKey) {
+            OpenSSLRSAPrivateKey rsaPrivateKey = (OpenSSLRSAPrivateKey) privateKey;
+            key = rsaPrivateKey.getOpenSSLKey();
+        } else if (privateKey instanceof RSAPrivateCrtKey) {
+            RSAPrivateCrtKey rsaPrivateKey = (RSAPrivateCrtKey) privateKey;
+            key = OpenSSLRSAPrivateCrtKey.getInstance(rsaPrivateKey);
+        } else if (privateKey instanceof RSAPrivateKey) {
+            RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) privateKey;
+            key = OpenSSLRSAPrivateKey.getInstance(rsaPrivateKey);
+        } else {
+            throw new InvalidKeyException("Need DSA or RSA private key");
+        }
+
+        // Allocate buffer according to RSA modulus size.
+        int maxSize = NativeCrypto.RSA_size(key.getPkeyContext());
+        inputBuffer = new byte[maxSize];
+        inputOffset = 0;
+    }
+
+    @Override
+    protected void engineInitVerify(PublicKey publicKey) throws InvalidKeyException {
+        if (publicKey instanceof OpenSSLRSAPublicKey) {
+            OpenSSLRSAPublicKey rsaPublicKey = (OpenSSLRSAPublicKey) publicKey;
+            key = rsaPublicKey.getOpenSSLKey();
+        } else if (publicKey instanceof RSAPublicKey) {
+            RSAPublicKey rsaPublicKey = (RSAPublicKey) publicKey;
+            key = OpenSSLRSAPublicKey.getInstance(rsaPublicKey);
+        } else {
+            throw new InvalidKeyException("Need DSA or RSA public key");
+        }
+
+        // Allocate buffer according to RSA modulus size.
+        int maxSize = NativeCrypto.RSA_size(key.getPkeyContext());
+        inputBuffer = new byte[maxSize];
+        inputOffset = 0;
+    }
+
+    @Override
+    protected void engineSetParameter(String param, Object value) throws InvalidParameterException {
+    }
+
+    @Override
+    protected byte[] engineSign() throws SignatureException {
+        if (key == null) {
+            // This can't actually happen, but you never know...
+            throw new SignatureException("Need RSA private key");
+        }
+
+        if (inputIsTooLong) {
+            throw new SignatureException("input length " + inputOffset + " != "
+                    + inputBuffer.length + " (modulus size)");
+        }
+
+        byte[] paddedBuffer = new byte[inputBuffer.length];
+        byte[] outputBuffer = new byte[inputBuffer.length];
+        try {
+            NativeCrypto.RSA_padding_add_PKCS1_type_1(paddedBuffer, paddedBuffer.length,
+                    inputBuffer, inputOffset);
+            NativeCrypto.RSA_private_encrypt(paddedBuffer.length, paddedBuffer, outputBuffer,
+                    key.getPkeyContext(), NativeCrypto.RSA_NO_PADDING);
+            return outputBuffer;
+        } catch (Exception ex) {
+            throw new SignatureException(ex);
+        } finally {
+            inputOffset = 0;
+        }
+    }
+
+    @Override
+    protected boolean engineVerify(byte[] sigBytes) throws SignatureException {
+        if (key == null) {
+            // This can't actually happen, but you never know...
+            throw new SignatureException("Need RSA public key");
+        }
+
+        if (inputIsTooLong) {
+            return false;
+        }
+
+        byte[] paddedBuffer = new byte[inputBuffer.length];
+        byte[] outputBuffer = new byte[inputBuffer.length];
+        try {
+            int paddedSize = NativeCrypto.RSA_public_decrypt(sigBytes.length, sigBytes,
+                    paddedBuffer, key.getPkeyContext(), NativeCrypto.RSA_NO_PADDING);
+
+            /*
+             * RSA_padding_check_PKCS1_type_1 expects the leading 0-byte to be
+             * truncated already.
+             */
+            paddedSize--;
+            System.arraycopy(paddedBuffer, 1, paddedBuffer, 0, paddedSize);
+
+            final int size;
+            try {
+                size = NativeCrypto.RSA_padding_check_PKCS1_type_1(outputBuffer,
+                        outputBuffer.length, paddedBuffer, paddedSize, inputBuffer.length);
+            } catch (Exception e) {
+                return false;
+            }
+
+            /* Make this constant time by comparing every byte. */
+            boolean matches = (size == inputOffset);
+            for (int i = 0; i < size; i++) {
+                if (inputBuffer[i] != outputBuffer[i]) {
+                    matches = false;
+                }
+            }
+            return matches;
+        } catch (Exception ex) {
+            throw new SignatureException(ex);
+        } finally {
+            inputOffset = 0;
+        }
+    }
+}
diff --git a/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp b/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
index 65e76ec..77efc96 100644
--- a/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
+++ b/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
@@ -1010,6 +1010,158 @@ static jint NativeCrypto_RSA_generate_key_ex(JNIEnv* env, jclass, jint modulusBi
     return static_cast<jint>(reinterpret_cast<uintptr_t>(pkey.release()));
 }
 
+static jint NativeCrypto_RSA_size(JNIEnv* env, jclass, jint pkeyRef) {
+    EVP_PKEY* pkey = reinterpret_cast<EVP_PKEY*>(pkeyRef);
+    JNI_TRACE("RSA_size(%p)", pkey);
+
+    Unique_RSA rsa(EVP_PKEY_get1_RSA(pkey));
+    if (rsa.get() == NULL) {
+        jniThrowRuntimeException(env, "RSA_size failed");
+        return 0;
+    }
+
+    return static_cast<jint>(RSA_size(rsa.get()));
+}
+
+static jint NativeCrypto_RSA_private_encrypt(JNIEnv* env, jclass, jint flen,
+        jbyteArray fromJavaBytes, jbyteArray toJavaBytes, jint pkeyRef, jint padding) {
+    EVP_PKEY* pkey = reinterpret_cast<EVP_PKEY*>(pkeyRef);
+    JNI_TRACE("RSA_private_encrypt(%d, %p, %p, %p)", flen, fromJavaBytes, toJavaBytes, pkey);
+
+    Unique_RSA rsa(EVP_PKEY_get1_RSA(pkey));
+    if (rsa.get() == NULL) {
+        return -1;
+    }
+
+    ScopedByteArrayRO from(env, fromJavaBytes);
+    if (from.get() == NULL) {
+        return -1;
+    }
+
+    ScopedByteArrayRW to(env, toJavaBytes);
+    if (to.get() == NULL) {
+        return -1;
+    }
+
+    int resultSize = RSA_private_encrypt(static_cast<int>(flen),
+            reinterpret_cast<const unsigned char*>(from.get()),
+            reinterpret_cast<unsigned char*>(to.get()), rsa.get(), padding);
+    if (resultSize == -1) {
+        JNI_TRACE("RSA_private_encrypt => failed");
+        throwExceptionIfNecessary(env, "RSA_private_encrypt failed");
+        return -1;
+    }
+
+    JNI_TRACE("RSA_private_encrypt(%d, %p, %p, %p) => %d", flen, fromJavaBytes, toJavaBytes, pkey,
+            resultSize);
+    return static_cast<jint>(resultSize);
+}
+
+static jint NativeCrypto_RSA_public_decrypt(JNIEnv* env, jclass, jint flen,
+        jbyteArray fromJavaBytes, jbyteArray toJavaBytes, jint pkeyRef, jint padding) {
+    EVP_PKEY* pkey = reinterpret_cast<EVP_PKEY*>(pkeyRef);
+    JNI_TRACE("RSA_private_encrypt(%d, %p, %p, %p)", flen, fromJavaBytes, toJavaBytes, pkey);
+
+    Unique_RSA rsa(EVP_PKEY_get1_RSA(pkey));
+    if (rsa.get() == NULL) {
+        return -1;
+    }
+
+    ScopedByteArrayRO from(env, fromJavaBytes);
+    if (from.get() == NULL) {
+        return -1;
+    }
+
+    ScopedByteArrayRW to(env, toJavaBytes);
+    if (to.get() == NULL) {
+        return -1;
+    }
+
+    int resultSize = RSA_public_decrypt(static_cast<int>(flen),
+            reinterpret_cast<const unsigned char*>(from.get()),
+            reinterpret_cast<unsigned char*>(to.get()), rsa.get(), padding);
+    if (resultSize == -1) {
+        JNI_TRACE("RSA_private_encrypt => failed");
+        throwExceptionIfNecessary(env, "RSA_private_encrypt failed");
+        return -1;
+    }
+
+    JNI_TRACE("RSA_private_encrypt(%d, %p, %p, %p) => %d", flen, fromJavaBytes, toJavaBytes, pkey,
+            resultSize);
+    return static_cast<jint>(resultSize);
+}
+
+static void NativeCrypto_RSA_padding_add_PKCS1_type_1(JNIEnv* env, jclass, jbyteArray toJavaBytes,
+        jint tlen, jbyteArray fromJavaBytes, jint flen) {
+    JNI_TRACE("RSA_padding_add_PKCS1_type_1(%p, %d, %p, %d)", toJavaBytes, tlen, fJavaBytes, fl);
+
+    ScopedByteArrayRO from(env, fromJavaBytes);
+    if (from.get() == NULL) {
+        return;
+    }
+
+    if (size_t(flen) > from.size()) {
+        jniThrowException(env, "java/lang/IndexOutOfBoundsException", NULL);
+        return;
+    }
+
+    ScopedByteArrayRW to(env, toJavaBytes);
+    if (to.get() == NULL) {
+        return;
+    }
+
+    if (size_t(tlen) > to.size()) {
+        jniThrowException(env, "java/lang/IndexOutOfBoundsException", NULL);
+        return;
+    }
+
+    if (RSA_padding_add_PKCS1_type_1(reinterpret_cast<unsigned char*>(to.get()), tlen,
+            reinterpret_cast<const unsigned char*>(from.get()), flen) == 0) {
+        throwExceptionIfNecessary(env, "RSA_padding_add_PKCS1_type_1 failed");
+        return;
+    }
+
+    JNI_TRACE("RSA_padding_add_PKCS1_type_1(%p, %d, %p, %d) => done", toJavaBytes, tlen, fJavaBytes,
+            fl);
+}
+
+static jint NativeCrypto_RSA_padding_check_PKCS1_type_1(JNIEnv* env, jclass, jbyteArray toJavaBytes,
+        jint tlen, jbyteArray fromJavaBytes, jint flen, jint rsa_len) {
+    JNI_TRACE("RSA_padding_add_PKCS1_type_1(%p, %d, %p, %d, %d)", toJavaBytes, tlen, fJavaBytes, fl,
+            rsa_len);
+
+    ScopedByteArrayRW to(env, toJavaBytes);
+    if (to.get() == NULL) {
+        return 0;
+    }
+
+    if (size_t(tlen) > to.size()) {
+        jniThrowException(env, "java/lang/IndexOutOfBoundsException", NULL);
+        return 0;
+    }
+
+    ScopedByteArrayRO from(env, fromJavaBytes);
+    if (from.get() == NULL) {
+        return 0;
+    }
+
+    if (size_t(flen) > from.size()) {
+        jniThrowException(env, "java/lang/IndexOutOfBoundsException", NULL);
+        return 0;
+    }
+
+    int size = RSA_padding_check_PKCS1_type_1(reinterpret_cast<unsigned char*>(to.get()), tlen,
+            reinterpret_cast<const unsigned char*>(from.get()), flen, rsa_len);
+    if (size == -1) {
+        throwExceptionIfNecessary(env, "RSA_padding_check_PKCS1_type_1 failed");
+        return 0;
+    }
+
+    JNI_TRACE("RSA_padding_check_PKCS1_type_1(%p, %d, %p, %d, %d) => %d", toJavaBytes, tlen,
+            fJavaBytes, fl, rsa_len, size);
+    return size;
+}
+
 /*
  * public static native byte[][] get_RSA_public_params(int);
  */
@@ -4266,6 +4418,11 @@ static JNINativeMethod sNativeCryptoMethods[] = {
     NATIVE_METHOD(NativeCrypto, i2d_PUBKEY, "(I)[B"),
     NATIVE_METHOD(NativeCrypto, d2i_PUBKEY, "([B)I"),
     NATIVE_METHOD(NativeCrypto, RSA_generate_key_ex, "(I[B)I"),
+    NATIVE_METHOD(NativeCrypto, RSA_size, "(I)I"),
+    NATIVE_METHOD(NativeCrypto, RSA_private_encrypt, "(I[B[BII)I"),
+    NATIVE_METHOD(NativeCrypto, RSA_public_decrypt, "(I[B[BII)I"),
+    NATIVE_METHOD(NativeCrypto, RSA_padding_add_PKCS1_type_1, "([BI[BI)V"),
+    NATIVE_METHOD(NativeCrypto, RSA_padding_check_PKCS1_type_1, "([BI[BII)I"),
     NATIVE_METHOD(NativeCrypto, get_RSA_private_params, "(I)[[B"),
     NATIVE_METHOD(NativeCrypto, get_RSA_public_params, "(I)[[B"),
     NATIVE_METHOD(NativeCrypto, DSA_generate_key, "(I[B[B[B[B)I"),
diff --git a/luni/src/test/java/libcore/java/security/SignatureTest.java b/luni/src/test/java/libcore/java/security/SignatureTest.java
index 2cd9982..7b9b773 100644
--- a/luni/src/test/java/libcore/java/security/SignatureTest.java
+++ b/luni/src/test/java/libcore/java/security/SignatureTest.java
@@ -26,6 +26,7 @@ import java.security.Provider;
 import java.security.PublicKey;
 import java.security.Security;
 import java.security.Signature;
+import java.security.SignatureException;
 import java.security.spec.DSAPrivateKeySpec;
 import java.security.spec.DSAPublicKeySpec;
 import java.security.spec.InvalidKeySpecException;
@@ -123,9 +124,21 @@ public class SignatureTest extends TestCase {
         sig.update(DATA);
         assertTrue(sig.getAlgorithm(), sig.verify(signature));
 
-        // Calling Signature.verify a second time should not throw
-        // http://code.google.com/p/android/issues/detail?id=34933
-        sig.verify(signature);
+        /*
+         * The RI appears to clear out the input data in RawDSA while calling
+         * verify a second time.
+         */
+        if (StandardNames.IS_RI && "NONEwithDSA".equalsIgnoreCase(sig.getAlgorithm())) {
+            try {
+                sig.verify(signature);
+                fail("Expected RI to have a NONEwithDSA bug");
+            } catch (SignatureException bug) {
+            }
+        } else {
+            // Calling Signature.verify a second time should not throw
+            // http://code.google.com/p/android/issues/detail?id=34933
+            sig.verify(signature);
+        }
     }
 
     private static final byte[] PK_BYTES = hexToBytes(
@@ -326,6 +339,7 @@ public class SignatureTest extends TestCase {
         (byte) 0x39,
     });
 
+    /* Test data is: "Android.\n" */
     private static final byte[] Vector1Data = new byte[] {
         (byte) 0x41, (byte) 0x6e, (byte) 0x64, (byte) 0x72, (byte) 0x6f, (byte) 0x69, (byte) 0x64, (byte) 0x2e,
         (byte) 0x0a,
@@ -550,11 +564,61 @@ public class SignatureTest extends TestCase {
         (byte) 0x02, (byte) 0xaf, (byte) 0x8f, (byte) 0x59, (byte) 0xe5, (byte) 0x67, (byte) 0x25, (byte) 0x00,
     };
 
+    /*
+     * openssl rsautl -raw -sign -inkey rsa.key | recode ../x1 | sed 's/0x/(byte) 0x/g'
+     */
+    private static final byte[] NONEwithRSA_Vector1Signature = new byte[] {
+        (byte) 0x35, (byte) 0x43, (byte) 0x38, (byte) 0x44, (byte) 0xAD, (byte) 0x3F,
+        (byte) 0x97, (byte) 0x02, (byte) 0xFB, (byte) 0x59, (byte) 0x1F, (byte) 0x4A,
+        (byte) 0x2B, (byte) 0xB9, (byte) 0x06, (byte) 0xEC, (byte) 0x66, (byte) 0xE6,
+        (byte) 0xD2, (byte) 0xC5, (byte) 0x8B, (byte) 0x7B, (byte) 0xE3, (byte) 0x18,
+        (byte) 0xBF, (byte) 0x07, (byte) 0xD6, (byte) 0x01, (byte) 0xF9, (byte) 0xD9,
+        (byte) 0x89, (byte) 0xC4, (byte) 0xDB, (byte) 0x00, (byte) 0x68, (byte) 0xFF,
+        (byte) 0x9B, (byte) 0x43, (byte) 0x90, (byte) 0xF2, (byte) 0xDB, (byte) 0x83,
+        (byte) 0xF4, (byte) 0x7E, (byte) 0xC6, (byte) 0x81, (byte) 0x01, (byte) 0x3A,
+        (byte) 0x0B, (byte) 0xE5, (byte) 0xED, (byte) 0x08, (byte) 0x73, (byte) 0x3E,
+        (byte) 0xE1, (byte) 0x3F, (byte) 0xDF, (byte) 0x1F, (byte) 0x07, (byte) 0x6D,
+        (byte) 0x22, (byte) 0x8D, (byte) 0xCC, (byte) 0x4E, (byte) 0xE3, (byte) 0x9A,
+        (byte) 0xBC, (byte) 0xCC, (byte) 0x8F, (byte) 0x9E, (byte) 0x9B, (byte) 0x02,
+        (byte) 0x48, (byte) 0x00, (byte) 0xAC, (byte) 0x9F, (byte) 0xA4, (byte) 0x8F,
+        (byte) 0x87, (byte) 0xA1, (byte) 0xA8, (byte) 0xE6, (byte) 0x9D, (byte) 0xCD,
+        (byte) 0x8B, (byte) 0x05, (byte) 0xE9, (byte) 0xD2, (byte) 0x05, (byte) 0x8D,
+        (byte) 0xC9, (byte) 0x95, (byte) 0x16, (byte) 0xD0, (byte) 0xCD, (byte) 0x43,
+        (byte) 0x25, (byte) 0x8A, (byte) 0x11, (byte) 0x46, (byte) 0xD7, (byte) 0x74,
+        (byte) 0x4C, (byte) 0xCF, (byte) 0x58, (byte) 0xF9, (byte) 0xA1, (byte) 0x30,
+        (byte) 0x84, (byte) 0x52, (byte) 0xC9, (byte) 0x01, (byte) 0x5F, (byte) 0x24,
+        (byte) 0x4C, (byte) 0xB1, (byte) 0x9F, (byte) 0x7D, (byte) 0x12, (byte) 0x38,
+        (byte) 0x27, (byte) 0x0F, (byte) 0x5E, (byte) 0xFF, (byte) 0xE0, (byte) 0x55,
+        (byte) 0x8B, (byte) 0xA3, (byte) 0xAD, (byte) 0x60, (byte) 0x35, (byte) 0x83,
+        (byte) 0x58, (byte) 0xAF, (byte) 0x99, (byte) 0xDE, (byte) 0x3F, (byte) 0x5D,
+        (byte) 0x80, (byte) 0x80, (byte) 0xFF, (byte) 0x9B, (byte) 0xDE, (byte) 0x5C,
+        (byte) 0xAB, (byte) 0x97, (byte) 0x43, (byte) 0x64, (byte) 0xD9, (byte) 0x9F,
+        (byte) 0xFB, (byte) 0x67, (byte) 0x65, (byte) 0xA5, (byte) 0x99, (byte) 0xE7,
+        (byte) 0xE6, (byte) 0xEB, (byte) 0x05, (byte) 0x95, (byte) 0xFC, (byte) 0x46,
+        (byte) 0x28, (byte) 0x4B, (byte) 0xD8, (byte) 0x8C, (byte) 0xF5, (byte) 0x0A,
+        (byte) 0xEB, (byte) 0x1F, (byte) 0x30, (byte) 0xEA, (byte) 0xE7, (byte) 0x67,
+        (byte) 0x11, (byte) 0x25, (byte) 0xF0, (byte) 0x44, (byte) 0x75, (byte) 0x74,
+        (byte) 0x94, (byte) 0x06, (byte) 0x78, (byte) 0xD0, (byte) 0x21, (byte) 0xF4,
+        (byte) 0x3F, (byte) 0xC8, (byte) 0xC4, (byte) 0x4A, (byte) 0x57, (byte) 0xBE,
+        (byte) 0x02, (byte) 0x3C, (byte) 0x93, (byte) 0xF6, (byte) 0x95, (byte) 0xFB,
+        (byte) 0xD1, (byte) 0x77, (byte) 0x8B, (byte) 0x43, (byte) 0xF0, (byte) 0xB9,
+        (byte) 0x7D, (byte) 0xE0, (byte) 0x32, (byte) 0xE1, (byte) 0x72, (byte) 0xB5,
+        (byte) 0x62, (byte) 0x3F, (byte) 0x86, (byte) 0xC3, (byte) 0xD4, (byte) 0x5F,
+        (byte) 0x5E, (byte) 0x54, (byte) 0x1B, (byte) 0x5B, (byte) 0xE6, (byte) 0x74,
+        (byte) 0xA1, (byte) 0x0B, (byte) 0xE5, (byte) 0x18, (byte) 0xD2, (byte) 0x4F,
+        (byte) 0x93, (byte) 0xF3, (byte) 0x09, (byte) 0x58, (byte) 0xCE, (byte) 0xF0,
+        (byte) 0xA3, (byte) 0x61, (byte) 0xE4, (byte) 0x6E, (byte) 0x46, (byte) 0x45,
+        (byte) 0x89, (byte) 0x50, (byte) 0xBD, (byte) 0x03, (byte) 0x3F, (byte) 0x38,
+        (byte) 0xDA, (byte) 0x5D, (byte) 0xD0, (byte) 0x1B, (byte) 0x1F, (byte) 0xB1,
+        (byte) 0xEE, (byte) 0x89, (byte) 0x59, (byte) 0xC5,
+    };
+
     public void testGetCommonInstances_Success() throws Exception {
         assertNotNull(Signature.getInstance("SHA1withRSA"));
         assertNotNull(Signature.getInstance("SHA256withRSA"));
         assertNotNull(Signature.getInstance("SHA384withRSA"));
         assertNotNull(Signature.getInstance("SHA512withRSA"));
+        assertNotNull(Signature.getInstance("NONEwithRSA"));
         assertNotNull(Signature.getInstance("MD5withRSA"));
         assertNotNull(Signature.getInstance("SHA1withDSA"));
     }
@@ -902,6 +966,165 @@ public class SignatureTest extends TestCase {
         assertTrue("Signature must verify correctly", sig.verify(signature));
     }
 
+    public void testSign_NONEwithRSA_Key_Success() throws Exception {
+        KeyFactory kf = KeyFactory.getInstance("RSA");
+        RSAPrivateKeySpec keySpec = new RSAPrivateKeySpec(RSA_2048_modulus,
+                RSA_2048_privateExponent);
+        PrivateKey privKey = kf.generatePrivate(keySpec);
+
+        Signature sig = Signature.getInstance("NONEwithRSA");
+        sig.initSign(privKey);
+        sig.update(Vector1Data);
+
+        byte[] signature = sig.sign();
+        assertNotNull("Signature must not be null", signature);
+        assertTrue("Signature should match expected",
+                Arrays.equals(signature, NONEwithRSA_Vector1Signature));
+
+        RSAPublicKeySpec pubKeySpec = new RSAPublicKeySpec(RSA_2048_modulus,
+                RSA_2048_publicExponent);
+        PublicKey pubKey = kf.generatePublic(pubKeySpec);
+        sig.initVerify(pubKey);
+        sig.update(Vector1Data);
+        assertTrue("Signature must verify correctly", sig.verify(signature));
+    }
+
+    public void testVerify_NONEwithRSA_Key_WrongSignature_Failure() throws Exception {
+        KeyFactory kf = KeyFactory.getInstance("RSA");
+
+        RSAPublicKeySpec pubKeySpec = new RSAPublicKeySpec(RSA_2048_modulus,
+                RSA_2048_publicExponent);
+        PublicKey pubKey = kf.generatePublic(pubKeySpec);
+
+        Signature sig = Signature.getInstance("NONEwithRSA");
+        sig.initVerify(pubKey);
+        sig.update(Vector1Data);
+        assertFalse("Invalid signature must not verify", sig.verify("Invalid".getBytes()));
+    }
+
+    public void testSign_NONEwithRSA_Key_DataTooLarge_Failure() throws Exception {
+        KeyFactory kf = KeyFactory.getInstance("RSA");
+        RSAPrivateKeySpec keySpec = new RSAPrivateKeySpec(RSA_2048_modulus,
+                RSA_2048_privateExponent);
+        PrivateKey privKey = kf.generatePrivate(keySpec);
+
+        Signature sig = Signature.getInstance("NONEwithRSA");
+        sig.initSign(privKey);
+
+        final int oneTooBig = RSA_2048_modulus.bitLength() - 10;
+        for (int i = 0; i < oneTooBig; i++) {
+            sig.update((byte) i);
+        }
+
+        try {
+            sig.sign();
+            fail("Should throw exception when data is too large");
+        } catch (SignatureException success) {
+        }
+    }
+
+    public void testSign_NONEwithRSA_Key_DataTooLarge_SingleByte_Failure() throws Exception {
+        KeyFactory kf = KeyFactory.getInstance("RSA");
+        RSAPrivateKeySpec keySpec = new RSAPrivateKeySpec(RSA_2048_modulus,
+                RSA_2048_privateExponent);
+        PrivateKey privKey = kf.generatePrivate(keySpec);
+
+        Signature sig = Signature.getInstance("NONEwithRSA");
+        sig.initSign(privKey);
+
+        // This should make it two bytes too big.
+        final int oneTooBig = RSA_2048_modulus.bitLength() - 10;
+        for (int i = 0; i < oneTooBig; i++) {
+            sig.update((byte) i);
+        }
+
+        try {
+            sig.sign();
+            fail("Should throw exception when data is too large");
+        } catch (SignatureException success) {
+        }
+    }
+
+    public void testVerify_NONEwithRSA_Key_DataTooLarge_Failure() throws Exception {
+        KeyFactory kf = KeyFactory.getInstance("RSA");
+
+        RSAPublicKeySpec pubKeySpec = new RSAPublicKeySpec(RSA_2048_modulus,
+                RSA_2048_publicExponent);
+        PublicKey pubKey = kf.generatePublic(pubKeySpec);
+
+        Signature sig = Signature.getInstance("NONEwithRSA");
+        sig.initVerify(pubKey);
+
+        // This should make it one bytes too big.
+        final int oneTooBig = RSA_2048_modulus.bitLength() + 1;
+        final byte[] vector = new byte[oneTooBig];
+        for (int i = 0; i < oneTooBig; i++) {
+            vector[i] = (byte) Vector1Data[i % Vector1Data.length];
+        }
+        sig.update(vector);
+
+        assertFalse("Should not verify when signature is too large",
+                sig.verify(NONEwithRSA_Vector1Signature));
+    }
+
+    public void testVerify_NONEwithRSA_Key_DataTooLarge_SingleByte_Failure() throws Exception {
+        KeyFactory kf = KeyFactory.getInstance("RSA");
+
+        RSAPublicKeySpec pubKeySpec = new RSAPublicKeySpec(RSA_2048_modulus,
+                RSA_2048_publicExponent);
+        PublicKey pubKey = kf.generatePublic(pubKeySpec);
+
+        Signature sig = Signature.getInstance("NONEwithRSA");
+        sig.initVerify(pubKey);
+
+        // This should make it twice as big as it should be.
+        final int tooBig = RSA_2048_modulus.bitLength() * 2;
+        for (int i = 0; i < tooBig; i++) {
+            sig.update((byte) Vector1Data[i % Vector1Data.length]);
+        }
+
+        assertFalse("Should not verify when signature is too large",
+                sig.verify(NONEwithRSA_Vector1Signature));
+    }
+
+    public void testVerify_NONEwithRSA_Key_SignatureTooSmall_Failure() throws Exception {
+        KeyFactory kf = KeyFactory.getInstance("RSA");
+
+        RSAPublicKeySpec pubKeySpec = new RSAPublicKeySpec(RSA_2048_modulus,
+                RSA_2048_publicExponent);
+        PublicKey pubKey = kf.generatePublic(pubKeySpec);
+
+        Signature sig = Signature.getInstance("NONEwithRSA");
+        sig.initVerify(pubKey);
+        sig.update(Vector1Data);
+
+        assertFalse("Invalid signature should not verify", sig.verify("Invalid sig".getBytes()));
+    }
+
+    public void testVerify_NONEwithRSA_Key_SignatureTooLarge_Failure() throws Exception {
+        KeyFactory kf = KeyFactory.getInstance("RSA");
+
+        RSAPublicKeySpec pubKeySpec = new RSAPublicKeySpec(RSA_2048_modulus,
+                RSA_2048_publicExponent);
+        PublicKey pubKey = kf.generatePublic(pubKeySpec);
+
+        Signature sig = Signature.getInstance("NONEwithRSA");
+        sig.initVerify(pubKey);
+        sig.update(Vector1Data);
+
+        byte[] invalidSignature = new byte[NONEwithRSA_Vector1Signature.length * 2];
+        System.arraycopy(NONEwithRSA_Vector1Signature, 0, invalidSignature, 0,
+                NONEwithRSA_Vector1Signature.length);
+        System.arraycopy(NONEwithRSA_Vector1Signature, 0, invalidSignature,
+                NONEwithRSA_Vector1Signature.length, NONEwithRSA_Vector1Signature.length);
+
+        try {
+            sig.verify(invalidSignature);
+            fail("Should throw exception when signature is too large");
+        } catch (SignatureException success) {
+        }
+    }
+
     /*
      * These tests were generated with this DSA private key:
      *
-- 
cgit v1.1


From 474a846981ea98054f221a10f994b7dcbfee985c Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Wed, 1 Aug 2012 18:16:43 -0700
Subject: Use default UncaughtExceptionHandler to report finalizer timeouts
 when defined.

In a previous release dalvik would abort on finalizer timeouts which
would be noticed by various tools such as the monkey. However, more
recently when the handling of this was moved to managed code, we
simply logged and exited, which went unnoticed by the monkeys. By
reporting via the default UncaughtExceptionHandler, finalizer timeouts
will once again be noticed by the monkeys, this time via the
application crash reporting.

Bug: 6894375
Change-Id: I94664f8bb54dc7647b4d3666484d88b1c8428c4b
---
 luni/src/main/java/java/lang/Daemons.java | 100 +++++++++++++++++++++---------
 1 file changed, 69 insertions(+), 31 deletions(-)

diff --git a/luni/src/main/java/java/lang/Daemons.java b/luni/src/main/java/java/lang/Daemons.java
index a7d0964..78a4152 100644
--- a/luni/src/main/java/java/lang/Daemons.java
+++ b/luni/src/main/java/java/lang/Daemons.java
@@ -31,8 +31,9 @@ import libcore.util.EmptyArray;
  * @hide
  */
 public final class Daemons {
-    private static final int NANOS_PER_MILLI = 1000000;
-    private static final long MAX_FINALIZE_MILLIS = 10L * 1000L; // 10 seconds
+    private static final int NANOS_PER_MILLI = 1000 * 1000;
+    private static final int NANOS_PER_SECOND = NANOS_PER_MILLI * 1000;
+    private static final long MAX_FINALIZE_NANOS = 10L * NANOS_PER_SECOND;
 
     public static void start() {
         ReferenceQueueDaemon.INSTANCE.start();
@@ -203,41 +204,78 @@ public final class Daemons {
 
         @Override public void run() {
             while (isRunning()) {
-                try {
-                    Object object = FinalizerDaemon.INSTANCE.finalizingObject;
-                    long startedNanos = FinalizerDaemon.INSTANCE.finalizingStartedNanos;
-
-                    if (object == null) {
-                        synchronized (this) {
-                            // wait until something is being finalized
-                            // http://code.google.com/p/android/issues/detail?id=22778
-                            wait();
-                            continue;
-                        }
-                    }
+                Object object = waitForObject();
+                if (object == null) {
+                    // We have been interrupted, need to see if this daemon has been stopped.
+                    continue;
+                }
+                boolean finalized = waitForFinalization(object);
+                if (!finalized && !VMRuntime.getRuntime().isDebuggerActive()) {
+                    finalizerTimedOut(object);
+                    break;
+                }
+            }
+        }
 
-                    long elapsedMillis = (System.nanoTime() - startedNanos) / NANOS_PER_MILLI;
-                    long sleepMillis = MAX_FINALIZE_MILLIS - elapsedMillis;
-                    if (sleepMillis > 0) {
-                        Thread.sleep(sleepMillis);
-                        elapsedMillis = (System.nanoTime() - startedNanos) / NANOS_PER_MILLI;
+        private Object waitForObject() {
+            while (true) {
+                Object object = FinalizerDaemon.INSTANCE.finalizingObject;
+                if (object != null) {
+                    return object;
+                }
+                synchronized (this) {
+                    // wait until something is ready to be finalized
+                    // http://code.google.com/p/android/issues/detail?id=22778
+                    try {
+                        wait();
+                    } catch (InterruptedException e) {
+                        // Daemon.stop may have interrupted us.
+                        return null;
                     }
+                }
+            }
+        }
 
-                    if (object != FinalizerDaemon.INSTANCE.finalizingObject
-                            || VMRuntime.getRuntime().isDebuggerActive()) {
-                        continue;
+        private void sleepFor(long startNanos, long durationNanos) {
+            while (true) {
+                long elapsedNanos = System.nanoTime() - startNanos;
+                long sleepNanos = durationNanos - elapsedNanos;
+                long sleepMills = sleepNanos / NANOS_PER_MILLI;
+                if (sleepMills <= 0) {
+                    return;
+                }
+                try {
+                    Thread.sleep(sleepMills);
+                } catch (InterruptedException e) {
+                    if (!isRunning()) {
+                        return;
                     }
-
-                    // The current object has exceeded the finalization deadline; abort!
-                    Exception syntheticException = new TimeoutException();
-                    syntheticException.setStackTrace(FinalizerDaemon.INSTANCE.getStackTrace());
-                    System.logE(object.getClass().getName() + ".finalize() timed out after "
-                            + elapsedMillis + " ms; limit is " + MAX_FINALIZE_MILLIS + " ms",
-                            syntheticException);
-                    System.exit(2);
-                } catch (InterruptedException ignored) {
                 }
             }
         }
+
+        private boolean waitForFinalization(Object object) {
+            sleepFor(FinalizerDaemon.INSTANCE.finalizingStartedNanos, MAX_FINALIZE_NANOS);
+            return object != FinalizerDaemon.INSTANCE.finalizingObject;
+        }
+
+        private static void finalizerTimedOut(Object object) {
+            // The current object has exceeded the finalization deadline; abort!
+            String message = object.getClass().getName() + ".finalize() timed out after "
+                    + (MAX_FINALIZE_NANOS / NANOS_PER_SECOND) + " seconds";
+            Exception syntheticException = new TimeoutException(message);
+            // We use the stack from where finalize() was running to show where it was stuck.
+            syntheticException.setStackTrace(FinalizerDaemon.INSTANCE.getStackTrace());
+            Thread.UncaughtExceptionHandler h = Thread.getDefaultUncaughtExceptionHandler();
+            if (h == null) {
+                // If we have no handler, log and exit.
+                System.logE(message, syntheticException);
+                System.exit(2);
+            }
+            // Otherwise call the handler to do crash reporting.
+            // We don't just throw because we're not the thread that
+            // timed out; we're the thread that detected it.
+            h.uncaughtException(Thread.currentThread(), syntheticException);
+        }
     }
 }
-- 
cgit v1.1


From b9d36450c63be9096984ea167aace421af2ef05b Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Fri, 3 Aug 2012 01:27:12 -0700
Subject: Simplify locking and close race in getSecureRandomService()

Change-Id: I5c482d9a2d2a9282d7a5e5d4c4de52be05c60b93
---
 .../apache/harmony/security/fortress/Services.java | 156 +++++++++------------
 1 file changed, 65 insertions(+), 91 deletions(-)

diff --git a/luni/src/main/java/org/apache/harmony/security/fortress/Services.java b/luni/src/main/java/org/apache/harmony/security/fortress/Services.java
index a441290..4fe0d44 100644
--- a/luni/src/main/java/org/apache/harmony/security/fortress/Services.java
+++ b/luni/src/main/java/org/apache/harmony/security/fortress/Services.java
@@ -48,7 +48,7 @@ public class Services {
     private static Provider.Service cachedSecureRandomService;
 
     /**
-     * Need refresh flag. Protected by synchronizing on providers.
+     * Need refresh flag.
      */
     private static boolean needRefresh;
 
@@ -65,112 +65,94 @@ public class Services {
     private static final List<Provider> providers = new ArrayList<Provider>(20);
 
     /**
-     * Hash for quick provider access by name. Protected by synchronizing on providers.
+     * Hash for quick provider access by name.
      */
     private static final Map<String, Provider> providersNames = new HashMap<String, Provider>(20);
     static {
-        loadProviders();
-    }
-
-    private static void loadProviders() {
-        synchronized (providers) {
-            String providerClassName = null;
-            int i = 1;
-            ClassLoader cl = ClassLoader.getSystemClassLoader();
-
-            while ((providerClassName = Security.getProperty("security.provider." + i++)) != null) {
-                try {
-                    Class providerClass = Class.forName(providerClassName.trim(), true, cl);
-                    Provider p = (Provider) providerClass.newInstance();
-                    providers.add(p);
-                    providersNames.put(p.getName(), p);
-                    initServiceInfo(p);
-                } catch (ClassNotFoundException ignored) {
-                } catch (IllegalAccessException ignored) {
-                } catch (InstantiationException ignored) {
-                }
+        String providerClassName = null;
+        int i = 1;
+        ClassLoader cl = ClassLoader.getSystemClassLoader();
+
+        while ((providerClassName = Security.getProperty("security.provider." + i++)) != null) {
+            try {
+                Class providerClass = Class.forName(providerClassName.trim(), true, cl);
+                Provider p = (Provider) providerClass.newInstance();
+                providers.add(p);
+                providersNames.put(p.getName(), p);
+                initServiceInfo(p);
+            } catch (ClassNotFoundException ignored) {
+            } catch (IllegalAccessException ignored) {
+            } catch (InstantiationException ignored) {
             }
-            Engine.door.renumProviders();
         }
+        Engine.door.renumProviders();
     }
 
     /**
      * Returns a copy of the registered providers as an array.
      */
-    public static Provider[] getProviders() {
-        synchronized (providers) {
-            return providers.toArray(new Provider[providers.size()]);
-        }
+    public static synchronized Provider[] getProviders() {
+        return providers.toArray(new Provider[providers.size()]);
     }
 
     /**
      * Returns a copy of the registered providers as a list.
      */
-    public static List<Provider> getProvidersList() {
-        synchronized (providers) {
-            return new ArrayList<Provider>(providers);
-        }
+    public static synchronized List<Provider> getProvidersList() {
+        return new ArrayList<Provider>(providers);
     }
 
     /**
      * Returns the provider with the specified name.
      */
-    public static Provider getProvider(String name) {
+    public static synchronized Provider getProvider(String name) {
         if (name == null) {
             return null;
         }
-        synchronized (providers) {
-            return providersNames.get(name);
-        }
+        return providersNames.get(name);
     }
 
     /**
      * Inserts a provider at a specified 1-based position.
      */
-    public static int insertProviderAt(Provider provider, int position) {
-        synchronized (providers) {
-            int size = providers.size();
-            if ((position < 1) || (position > size)) {
-                position = size + 1;
-            }
-            providers.add(position - 1, provider);
-            providersNames.put(provider.getName(), provider);
-            setNeedRefresh();
-            return position;
+    public static synchronized int insertProviderAt(Provider provider, int position) {
+        int size = providers.size();
+        if ((position < 1) || (position > size)) {
+            position = size + 1;
         }
+        providers.add(position - 1, provider);
+        providersNames.put(provider.getName(), provider);
+        setNeedRefresh();
+        return position;
     }
 
     /**
      * Removes the provider at the specified 1-based position.
      */
-    public static void removeProvider(int providerNumber) {
-        synchronized (providers) {
-            Provider p = providers.remove(providerNumber - 1);
-            providersNames.remove(p.getName());
-            setNeedRefresh();
-        }
+    public static synchronized void removeProvider(int providerNumber) {
+        Provider p = providers.remove(providerNumber - 1);
+        providersNames.remove(p.getName());
+        setNeedRefresh();
     }
 
     /**
      * Adds information about provider services into HashMap.
      */
-    public static void initServiceInfo(Provider p) {
-        synchronized (services) {
-            for (Provider.Service service : p.getServices()) {
-                String type = service.getType();
-                if (cachedSecureRandomService == null && type.equals("SecureRandom")) {
-                    cachedSecureRandomService = service;
-                }
-                String key = type + "." + service.getAlgorithm().toUpperCase(Locale.US);
+    public static synchronized void initServiceInfo(Provider p) {
+        for (Provider.Service service : p.getServices()) {
+            String type = service.getType();
+            if (cachedSecureRandomService == null && type.equals("SecureRandom")) {
+                cachedSecureRandomService = service;
+            }
+            String key = type + "." + service.getAlgorithm().toUpperCase(Locale.US);
+            if (!services.containsKey(key)) {
+                services.put(key, service);
+            }
+            for (String alias : Engine.door.getAliases(service)) {
+                key = type + "." + alias.toUpperCase(Locale.US);
                 if (!services.containsKey(key)) {
                     services.put(key, service);
                 }
-                for (String alias : Engine.door.getAliases(service)) {
-                    key = type + "." + alias.toUpperCase(Locale.US);
-                    if (!services.containsKey(key)) {
-                        services.put(key, service);
-                    }
-                }
             }
         }
     }
@@ -178,10 +160,8 @@ public class Services {
     /**
      * Returns true if services contain any provider information.
      */
-    public static boolean isEmpty() {
-        synchronized (services) {
-            return services.isEmpty();
-        }
+    public static synchronized boolean isEmpty() {
+        return services.isEmpty();
     }
 
     /**
@@ -194,16 +174,14 @@ public class Services {
      * caches should be validated against the result of
      * Service.getCacheVersion() before use.
      */
-    public static Provider.Service getService(String key) {
-        synchronized (services) {
-            return services.get(key);
-        }
+    public static synchronized Provider.Service getService(String key) {
+        return services.get(key);
     }
 
     /**
      * Returns the default SecureRandom service description.
      */
-    public static Provider.Service getSecureRandomService() {
+    public static synchronized Provider.Service getSecureRandomService() {
         getCacheVersion();  // used for side effect of updating cache if needed
         return cachedSecureRandomService;
     }
@@ -214,30 +192,26 @@ public class Services {
      * implementation to indicate that a provides list of services has
      * changed.
      */
-    public static void setNeedRefresh() {
-        synchronized (providers) {
-            needRefresh = true;
-        }
+    public static synchronized void setNeedRefresh() {
+        needRefresh = true;
     }
 
     /**
      * Returns the current cache version. This has the possible side
      * effect of updating the cache if needed.
      */
-    public static int getCacheVersion() {
-        synchronized (providers) {
-            if (needRefresh) {
-                cacheVersion++;
-                synchronized (services) {
-                    services.clear();
-                }
-                cachedSecureRandomService = null;
-                for (Provider p : providers) {
-                    initServiceInfo(p);
-                }
-                needRefresh = false;
+    public static synchronized int getCacheVersion() {
+        if (needRefresh) {
+            cacheVersion++;
+            synchronized (services) {
+                services.clear();
+            }
+            cachedSecureRandomService = null;
+            for (Provider p : providers) {
+                initServiceInfo(p);
             }
-            return cacheVersion;
+            needRefresh = false;
         }
+        return cacheVersion;
     }
 }
-- 
cgit v1.1


From b354e381cac5ffe6f884a4513127d68324779c3b Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Fri, 3 Aug 2012 01:17:22 -0700
Subject: Tracking DSA Signature.verify behavioral change

See also:

    commit 3ff7a80532c9edbcca3331de2b9e87bbf16a0c96
    Author: Brian Carlstrom <bdc@google.com>
    Date:   Mon Jul 23 23:33:56 2012 -0700

        Signature.verify should not throw if called twice

Bug: http://code.google.com/p/android/issues/detail?id=34933
Bug: 6870225
Change-Id: Ifa4324e0d3454adcc08667e91677485bdfdcf1d5
---
 .../security/tests/java/security/Signature2Test.java     | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/luni/src/test/java/org/apache/harmony/security/tests/java/security/Signature2Test.java b/luni/src/test/java/org/apache/harmony/security/tests/java/security/Signature2Test.java
index 39423ee..7886e3e 100644
--- a/luni/src/test/java/org/apache/harmony/security/tests/java/security/Signature2Test.java
+++ b/luni/src/test/java/org/apache/harmony/security/tests/java/security/Signature2Test.java
@@ -37,6 +37,7 @@ import java.security.cert.Certificate;
 import java.security.spec.DSAParameterSpec;
 import java.util.HashSet;
 import java.util.Set;
+import libcore.java.security.StandardNames;
 
 public class Signature2Test extends junit.framework.TestCase {
 
@@ -467,10 +468,17 @@ public class Signature2Test extends junit.framework.TestCase {
         } catch (IllegalArgumentException expected) {
         }
 
-        try {
-            sig.verify(signature, signature.length, 0);
-            fail();
-        } catch (SignatureException expected) {
+        if (StandardNames.IS_RI) {
+            try {
+                sig.verify(signature, signature.length, 0);
+                fail();
+            } catch (SignatureException expected) {
+            }
+        } else {
+            // Calling Signature.verify a second time should not throw
+            // http://code.google.com/p/android/issues/detail?id=34933
+            boolean verified = sig.verify(signature, signature.length, 0);
+            assertFalse(verified);
         }
 
         try {
-- 
cgit v1.1


From c5ddc93173f32383ab456c0a24739e7cb2d19c42 Mon Sep 17 00:00:00 2001
From: Kenny Root <kroot@google.com>
Date: Thu, 2 Aug 2012 14:53:00 -0700
Subject: Add raw RSA Cipher to OpenSSLProvider

Recent changes in the way that Android Keystore (accessed via KeyChain)
necessitate all key operations be done with a provider that understands
the new OpenSSLKey object.

This adds Cipher support for the RSA algorithm in "RSA/ECB/NoPadding"
and "RSA/None/NoPadding" modes.

Change-Id: I98a8eaf3514763a863b2751bba999fbd48609c96
---
 .../xnet/provider/jsse/OpenSSLCipherRawRSA.java    | 227 +++++++
 .../xnet/provider/jsse/OpenSSLProvider.java        |   4 +
 .../test/java/libcore/javax/crypto/CipherTest.java | 735 +++++++++++++++++++++
 3 files changed, 966 insertions(+)
 create mode 100644 luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLCipherRawRSA.java

diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLCipherRawRSA.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLCipherRawRSA.java
new file mode 100644
index 0000000..8312013
--- /dev/null
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLCipherRawRSA.java
@@ -0,0 +1,227 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed 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.xnet.provider.jsse;
+
+import java.security.AlgorithmParameters;
+import java.security.InvalidAlgorithmParameterException;
+import java.security.InvalidKeyException;
+import java.security.Key;
+import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
+import java.security.interfaces.RSAPrivateCrtKey;
+import java.security.interfaces.RSAPrivateKey;
+import java.security.interfaces.RSAPublicKey;
+import java.security.spec.AlgorithmParameterSpec;
+
+import javax.crypto.BadPaddingException;
+import javax.crypto.CipherSpi;
+import javax.crypto.IllegalBlockSizeException;
+import javax.crypto.NoSuchPaddingException;
+import javax.crypto.ShortBufferException;
+
+public class OpenSSLCipherRawRSA extends CipherSpi {
+    /**
+     * An empty list that is returned from update calls.
+     */
+    private static final byte[] emptyList = new byte[0];
+
+    /**
+     * The current OpenSSL key we're operating on.
+     */
+    private OpenSSLKey key;
+
+    /**
+     * Current cipher mode: encrypting or decrypting.
+     */
+    private boolean usingPrivateKey;
+
+    /**
+     * Buffer for operations
+     */
+    private byte[] buffer;
+
+    /**
+     * Current offset in the buffer.
+     */
+    private int bufferOffset;
+
+    /**
+     * Flag that indicates an exception should be thrown when the input is too
+     * large during doFinal.
+     */
+    private boolean inputTooLarge;
+
+    @Override
+    protected void engineSetMode(String mode) throws NoSuchAlgorithmException {
+        final String modeUpper = mode.toUpperCase();
+        if ("NONE".equals(modeUpper) || "ECB".equals(modeUpper)) {
+            return;
+        }
+
+        throw new NoSuchAlgorithmException("mode not supported: " + mode);
+    }
+
+    @Override
+    protected void engineSetPadding(String padding) throws NoSuchPaddingException {
+        final String paddingUpper = padding.toUpperCase();
+        if ("NOPADDING".equals(paddingUpper)) {
+            return;
+        }
+
+        throw new NoSuchPaddingException("padding not supported: " + padding);
+    }
+
+    @Override
+    protected int engineGetBlockSize() {
+        return 0;
+    }
+
+    @Override
+    protected int engineGetOutputSize(int inputLen) {
+        if (key == null) {
+            throw new IllegalStateException("cipher is not initialized");
+        }
+
+        return buffer.length;
+    }
+
+    @Override
+    protected byte[] engineGetIV() {
+        return null;
+    }
+
+    @Override
+    protected AlgorithmParameters engineGetParameters() {
+        return null;
+    }
+
+    private void engineInitInternal(int opmode, Key key) throws InvalidKeyException {
+        if (key instanceof OpenSSLRSAPrivateKey) {
+            OpenSSLRSAPrivateKey rsaPrivateKey = (OpenSSLRSAPrivateKey) key;
+            usingPrivateKey = true;
+            this.key = rsaPrivateKey.getOpenSSLKey();
+        } else if (key instanceof RSAPrivateCrtKey) {
+            RSAPrivateCrtKey rsaPrivateKey = (RSAPrivateCrtKey) key;
+            usingPrivateKey = true;
+            this.key = OpenSSLRSAPrivateCrtKey.getInstance(rsaPrivateKey);
+        } else if (key instanceof RSAPrivateKey) {
+            RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) key;
+            usingPrivateKey = true;
+            this.key = OpenSSLRSAPrivateKey.getInstance(rsaPrivateKey);
+        } else if (key instanceof OpenSSLRSAPublicKey) {
+            OpenSSLRSAPublicKey rsaPublicKey = (OpenSSLRSAPublicKey) key;
+            usingPrivateKey = false;
+            this.key = rsaPublicKey.getOpenSSLKey();
+        } else if (key instanceof RSAPublicKey) {
+            RSAPublicKey rsaPublicKey = (RSAPublicKey) key;
+            usingPrivateKey = false;
+            this.key = OpenSSLRSAPublicKey.getInstance(rsaPublicKey);
+        } else {
+            throw new InvalidKeyException("Need RSA private or public key");
+        }
+
+        buffer = new byte[NativeCrypto.RSA_size(this.key.getPkeyContext())];
+        inputTooLarge = false;
+    }
+
+    @Override
+    protected void engineInit(int opmode, Key key, SecureRandom random) throws InvalidKeyException {
+        engineInitInternal(opmode, key);
+    }
+
+    @Override
+    protected void engineInit(int opmode, Key key, AlgorithmParameterSpec params,
+            SecureRandom random) throws InvalidKeyException, InvalidAlgorithmParameterException {
+        if (params != null) {
+            throw new InvalidAlgorithmParameterException("unknown param type: "
+                    + params.getClass().getName());
+        }
+
+        engineInitInternal(opmode, key);
+    }
+
+    @Override
+    protected void engineInit(int opmode, Key key, AlgorithmParameters params, SecureRandom random)
+            throws InvalidKeyException, InvalidAlgorithmParameterException {
+        if (params != null) {
+            throw new InvalidAlgorithmParameterException("unknown param type: "
+                    + params.getClass().getName());
+        }
+
+        engineInitInternal(opmode, key);
+    }
+
+    @Override
+    protected byte[] engineUpdate(byte[] input, int inputOffset, int inputLen) {
+        if (bufferOffset + inputLen > buffer.length) {
+            inputTooLarge = true;
+            return emptyList;
+        }
+
+        System.arraycopy(input, inputOffset, buffer, bufferOffset, inputLen);
+        bufferOffset += inputLen;
+        return emptyList;
+    }
+
+    @Override
+    protected int engineUpdate(byte[] input, int inputOffset, int inputLen, byte[] output,
+            int outputOffset) throws ShortBufferException {
+        engineUpdate(input, inputOffset, inputLen);
+        return 0;
+    }
+
+    @Override
+    protected byte[] engineDoFinal(byte[] input, int inputOffset, int inputLen)
+            throws IllegalBlockSizeException, BadPaddingException {
+        if (input != null) {
+            engineUpdate(input, inputOffset, inputLen);
+        }
+
+        if (inputTooLarge) {
+            throw new IllegalBlockSizeException("input must be under " + buffer.length + " bytes");
+        }
+
+        final byte[] tmpBuf;
+        if (bufferOffset != buffer.length) {
+            tmpBuf = new byte[buffer.length];
+            System.arraycopy(buffer, 0, tmpBuf, buffer.length - bufferOffset, bufferOffset);
+        } else {
+            tmpBuf = buffer;
+        }
+
+        final byte[] output = new byte[buffer.length];
+        if (usingPrivateKey) {
+            NativeCrypto.RSA_private_encrypt(tmpBuf.length, tmpBuf, output, key.getPkeyContext(),
+                    NativeCrypto.RSA_NO_PADDING);
+        } else {
+            NativeCrypto.RSA_public_decrypt(tmpBuf.length, tmpBuf, output, key.getPkeyContext(),
+                    NativeCrypto.RSA_NO_PADDING);
+        }
+
+        bufferOffset = 0;
+        return output;
+    }
+
+    @Override
+    protected int engineDoFinal(byte[] input, int inputOffset, int inputLen, byte[] output,
+            int outputOffset) throws ShortBufferException, IllegalBlockSizeException,
+            BadPaddingException {
+        byte[] b = engineDoFinal(input, inputOffset, inputLen);
+        System.arraycopy(output, 0, b, outputOffset, b.length);
+        return b.length;
+    }
+}
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLProvider.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLProvider.java
index efb9387..e13ccda 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLProvider.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLProvider.java
@@ -120,5 +120,9 @@ public final class OpenSSLProvider extends Provider {
          */
         put("SecureRandom.SHA1PRNG", OpenSSLRandom.class.getName());
         put("SecureRandom.SHA1PRNG ImplementedIn", "Software");
+
+        // Cipher
+        put("Cipher.RSA/ECB/NoPadding", OpenSSLCipherRawRSA.class.getName());
+        put("Alg.Alias.Cipher.RSA/None/NoPadding", "RSA/ECB/NoPadding");
     }
 }
diff --git a/luni/src/test/java/libcore/javax/crypto/CipherTest.java b/luni/src/test/java/libcore/javax/crypto/CipherTest.java
index 7919b35..a94a9d0 100644
--- a/luni/src/test/java/libcore/javax/crypto/CipherTest.java
+++ b/luni/src/test/java/libcore/javax/crypto/CipherTest.java
@@ -17,9 +17,32 @@
 package libcore.javax.crypto;
 
 import com.android.org.bouncycastle.asn1.x509.KeyUsage;
+
+import java.math.BigInteger;
 import java.security.InvalidKeyException;
+import java.security.Key;
+import java.security.KeyFactory;
+import java.security.KeyPair;
+import java.security.KeyPairGenerator;
+import java.security.PrivateKey;
+import java.security.Provider;
+import java.security.Provider.Service;
+import java.security.PublicKey;
+import java.security.Security;
 import java.security.cert.Certificate;
+import java.security.interfaces.RSAPrivateKey;
+import java.security.interfaces.RSAPublicKey;
+import java.security.spec.EncodedKeySpec;
+import java.security.spec.RSAPrivateKeySpec;
+import java.security.spec.RSAPublicKeySpec;
+import java.util.Arrays;
+import java.util.Set;
+
 import javax.crypto.Cipher;
+import javax.crypto.IllegalBlockSizeException;
+import javax.crypto.SecretKey;
+import javax.crypto.spec.SecretKeySpec;
+
 import junit.framework.TestCase;
 import libcore.java.security.TestKeyStore;
 
@@ -108,4 +131,716 @@ public final class CipherTest extends TestCase {
                 .build()
                 .getPrivateKey("RSA", "RSA").getCertificate();
     }
+
+    /*
+     * Test vectors generated with this private key:
+     *
+     * -----BEGIN RSA PRIVATE KEY-----
+     * MIIEpAIBAAKCAQEA4Ec+irjyKE/rnnQv+XSPoRjtmGM8kvUq63ouvg075gMpvnZq
+     * 0Q62pRXQ0s/ZvqeTDwwwZTeJn3lYzT6FsB+IGFJNMSWEqUslHjYltUFB7b/uGYgI
+     * 4buX/Hy0m56qr2jpyY19DtxTu8D6ADQ1bWMF+7zDxwAUBThqu8hzyw8+90JfPTPf
+     * ezFa4DbSoLZq/UdQOxab8247UWJRW3Ff2oPeryxYrrmr+zCXw8yd2dvl7ylsF2E5
+     * Ao6KZx5jBW1F9AGI0sQTNJCEXeUsJTTpxrJHjAe9rpKII7YtBmx3cPn2Pz26JH9T
+     * CER0e+eqqF2FO4vSRKzsPePImrRkU6tNJMOsaQIDAQABAoIBADd4R3al8XaY9ayW
+     * DfuDobZ1ZOZIvQWXz4q4CHGG8macJ6nsvdSA8Bl6gNBzCebGqW+SUzHlf4tKxvTU
+     * XtpFojJpwJ/EKMB6Tm7fc4oV3sl/q9Lyu0ehTyDqcvz+TDbgGtp3vRN82NTaELsW
+     * LpSkZilx8XX5hfoYjwVsuX7igW9Dq503R2Ekhs2owWGWwwgYqZXshdOEZ3kSZ7O/
+     * IfJzcQppJYYldoQcW2cSwS1L0govMpmtt8E12l6VFavadufK8qO+gFUdBzt4vxFi
+     * xIrSt/R0OgI47k0lL31efmUzzK5kzLOTYAdaL9HgNOw65c6cQIzL8OJeQRQCFoez
+     * 3UdUroECgYEA9UGIS8Nzeyki1BGe9F4t7izUy7dfRVBaFXqlAJ+Zxzot8HJKxGAk
+     * MGMy6omBd2NFRl3G3x4KbxQK/ztzluaomUrF2qloc0cv43dJ0U6z4HXmKdvrNYMz
+     * im82SdCiZUp6Qv2atr+krE1IHTkLsimwZL3DEcwb4bYxidp8QM3s8rECgYEA6hp0
+     * LduIHO23KIyH442GjdekCdFaQ/RF1Td6C1cx3b/KLa8oqOE81cCvzsM0fXSjniNa
+     * PNljPydN4rlPkt9DgzkR2enxz1jyfeLgj/RZZMcg0+whOdx8r8kSlTzeyy81Wi4s
+     * NaUPrXVMs7IxZkJLo7bjESoriYw4xcFe2yOGkzkCgYBRgo8exv2ZYCmQG68dfjN7
+     * pfCvJ+mE6tiVrOYr199O5FoiQInyzBUa880XP84EdLywTzhqLNzA4ANrokGfVFeS
+     * YtRxAL6TGYSj76Bb7PFBV03AebOpXEqD5sQ/MhTW3zLVEt4ZgIXlMeYWuD/X3Z0f
+     * TiYHwzM9B8VdEH0dOJNYcQKBgQDbT7UPUN6O21P/NMgJMYigUShn2izKBIl3WeWH
+     * wkQBDa+GZNWegIPRbBZHiTAfZ6nweAYNg0oq29NnV1toqKhCwrAqibPzH8zsiiL+
+     * OVeVxcbHQitOXXSh6ajzDndZufwtY5wfFWc+hOk6XvFQb0MVODw41Fy9GxQEj0ch
+     * 3IIyYQKBgQDYEUWTr0FfthLb8ZI3ENVNB0hiBadqO0MZSWjA3/HxHvD2GkozfV/T
+     * dBu8lkDkR7i2tsR8OsEgQ1fTsMVbqShr2nP2KSlvX6kUbYl2NX08dR51FIaWpAt0
+     * aFyCzjCQLWOdck/yTV4ulAfuNO3tLjtN9lqpvP623yjQe6aQPxZXaA==
+     * -----END RSA PRIVATE KEY-----
+     *
+     */
+
+    private static final BigInteger RSA_2048_modulus = new BigInteger(new byte[] {
+        (byte) 0x00, (byte) 0xe0, (byte) 0x47, (byte) 0x3e, (byte) 0x8a, (byte) 0xb8, (byte) 0xf2, (byte) 0x28,
+        (byte) 0x4f, (byte) 0xeb, (byte) 0x9e, (byte) 0x74, (byte) 0x2f, (byte) 0xf9, (byte) 0x74, (byte) 0x8f,
+        (byte) 0xa1, (byte) 0x18, (byte) 0xed, (byte) 0x98, (byte) 0x63, (byte) 0x3c, (byte) 0x92, (byte) 0xf5,
+        (byte) 0x2a, (byte) 0xeb, (byte) 0x7a, (byte) 0x2e, (byte) 0xbe, (byte) 0x0d, (byte) 0x3b, (byte) 0xe6,
+        (byte) 0x03, (byte) 0x29, (byte) 0xbe, (byte) 0x76, (byte) 0x6a, (byte) 0xd1, (byte) 0x0e, (byte) 0xb6,
+        (byte) 0xa5, (byte) 0x15, (byte) 0xd0, (byte) 0xd2, (byte) 0xcf, (byte) 0xd9, (byte) 0xbe, (byte) 0xa7,
+        (byte) 0x93, (byte) 0x0f, (byte) 0x0c, (byte) 0x30, (byte) 0x65, (byte) 0x37, (byte) 0x89, (byte) 0x9f,
+        (byte) 0x79, (byte) 0x58, (byte) 0xcd, (byte) 0x3e, (byte) 0x85, (byte) 0xb0, (byte) 0x1f, (byte) 0x88,
+        (byte) 0x18, (byte) 0x52, (byte) 0x4d, (byte) 0x31, (byte) 0x25, (byte) 0x84, (byte) 0xa9, (byte) 0x4b,
+        (byte) 0x25, (byte) 0x1e, (byte) 0x36, (byte) 0x25, (byte) 0xb5, (byte) 0x41, (byte) 0x41, (byte) 0xed,
+        (byte) 0xbf, (byte) 0xee, (byte) 0x19, (byte) 0x88, (byte) 0x08, (byte) 0xe1, (byte) 0xbb, (byte) 0x97,
+        (byte) 0xfc, (byte) 0x7c, (byte) 0xb4, (byte) 0x9b, (byte) 0x9e, (byte) 0xaa, (byte) 0xaf, (byte) 0x68,
+        (byte) 0xe9, (byte) 0xc9, (byte) 0x8d, (byte) 0x7d, (byte) 0x0e, (byte) 0xdc, (byte) 0x53, (byte) 0xbb,
+        (byte) 0xc0, (byte) 0xfa, (byte) 0x00, (byte) 0x34, (byte) 0x35, (byte) 0x6d, (byte) 0x63, (byte) 0x05,
+        (byte) 0xfb, (byte) 0xbc, (byte) 0xc3, (byte) 0xc7, (byte) 0x00, (byte) 0x14, (byte) 0x05, (byte) 0x38,
+        (byte) 0x6a, (byte) 0xbb, (byte) 0xc8, (byte) 0x73, (byte) 0xcb, (byte) 0x0f, (byte) 0x3e, (byte) 0xf7,
+        (byte) 0x42, (byte) 0x5f, (byte) 0x3d, (byte) 0x33, (byte) 0xdf, (byte) 0x7b, (byte) 0x31, (byte) 0x5a,
+        (byte) 0xe0, (byte) 0x36, (byte) 0xd2, (byte) 0xa0, (byte) 0xb6, (byte) 0x6a, (byte) 0xfd, (byte) 0x47,
+        (byte) 0x50, (byte) 0x3b, (byte) 0x16, (byte) 0x9b, (byte) 0xf3, (byte) 0x6e, (byte) 0x3b, (byte) 0x51,
+        (byte) 0x62, (byte) 0x51, (byte) 0x5b, (byte) 0x71, (byte) 0x5f, (byte) 0xda, (byte) 0x83, (byte) 0xde,
+        (byte) 0xaf, (byte) 0x2c, (byte) 0x58, (byte) 0xae, (byte) 0xb9, (byte) 0xab, (byte) 0xfb, (byte) 0x30,
+        (byte) 0x97, (byte) 0xc3, (byte) 0xcc, (byte) 0x9d, (byte) 0xd9, (byte) 0xdb, (byte) 0xe5, (byte) 0xef,
+        (byte) 0x29, (byte) 0x6c, (byte) 0x17, (byte) 0x61, (byte) 0x39, (byte) 0x02, (byte) 0x8e, (byte) 0x8a,
+        (byte) 0x67, (byte) 0x1e, (byte) 0x63, (byte) 0x05, (byte) 0x6d, (byte) 0x45, (byte) 0xf4, (byte) 0x01,
+        (byte) 0x88, (byte) 0xd2, (byte) 0xc4, (byte) 0x13, (byte) 0x34, (byte) 0x90, (byte) 0x84, (byte) 0x5d,
+        (byte) 0xe5, (byte) 0x2c, (byte) 0x25, (byte) 0x34, (byte) 0xe9, (byte) 0xc6, (byte) 0xb2, (byte) 0x47,
+        (byte) 0x8c, (byte) 0x07, (byte) 0xbd, (byte) 0xae, (byte) 0x92, (byte) 0x88, (byte) 0x23, (byte) 0xb6,
+        (byte) 0x2d, (byte) 0x06, (byte) 0x6c, (byte) 0x77, (byte) 0x70, (byte) 0xf9, (byte) 0xf6, (byte) 0x3f,
+        (byte) 0x3d, (byte) 0xba, (byte) 0x24, (byte) 0x7f, (byte) 0x53, (byte) 0x08, (byte) 0x44, (byte) 0x74,
+        (byte) 0x7b, (byte) 0xe7, (byte) 0xaa, (byte) 0xa8, (byte) 0x5d, (byte) 0x85, (byte) 0x3b, (byte) 0x8b,
+        (byte) 0xd2, (byte) 0x44, (byte) 0xac, (byte) 0xec, (byte) 0x3d, (byte) 0xe3, (byte) 0xc8, (byte) 0x9a,
+        (byte) 0xb4, (byte) 0x64, (byte) 0x53, (byte) 0xab, (byte) 0x4d, (byte) 0x24, (byte) 0xc3, (byte) 0xac,
+        (byte) 0x69,
+    });
+
+    private static final BigInteger RSA_2048_privateExponent = new BigInteger(new byte[] {
+        (byte) 0x37, (byte) 0x78, (byte) 0x47, (byte) 0x76, (byte) 0xa5, (byte) 0xf1, (byte) 0x76, (byte) 0x98,
+        (byte) 0xf5, (byte) 0xac, (byte) 0x96, (byte) 0x0d, (byte) 0xfb, (byte) 0x83, (byte) 0xa1, (byte) 0xb6,
+        (byte) 0x75, (byte) 0x64, (byte) 0xe6, (byte) 0x48, (byte) 0xbd, (byte) 0x05, (byte) 0x97, (byte) 0xcf,
+        (byte) 0x8a, (byte) 0xb8, (byte) 0x08, (byte) 0x71, (byte) 0x86, (byte) 0xf2, (byte) 0x66, (byte) 0x9c,
+        (byte) 0x27, (byte) 0xa9, (byte) 0xec, (byte) 0xbd, (byte) 0xd4, (byte) 0x80, (byte) 0xf0, (byte) 0x19,
+        (byte) 0x7a, (byte) 0x80, (byte) 0xd0, (byte) 0x73, (byte) 0x09, (byte) 0xe6, (byte) 0xc6, (byte) 0xa9,
+        (byte) 0x6f, (byte) 0x92, (byte) 0x53, (byte) 0x31, (byte) 0xe5, (byte) 0x7f, (byte) 0x8b, (byte) 0x4a,
+        (byte) 0xc6, (byte) 0xf4, (byte) 0xd4, (byte) 0x5e, (byte) 0xda, (byte) 0x45, (byte) 0xa2, (byte) 0x32,
+        (byte) 0x69, (byte) 0xc0, (byte) 0x9f, (byte) 0xc4, (byte) 0x28, (byte) 0xc0, (byte) 0x7a, (byte) 0x4e,
+        (byte) 0x6e, (byte) 0xdf, (byte) 0x73, (byte) 0x8a, (byte) 0x15, (byte) 0xde, (byte) 0xc9, (byte) 0x7f,
+        (byte) 0xab, (byte) 0xd2, (byte) 0xf2, (byte) 0xbb, (byte) 0x47, (byte) 0xa1, (byte) 0x4f, (byte) 0x20,
+        (byte) 0xea, (byte) 0x72, (byte) 0xfc, (byte) 0xfe, (byte) 0x4c, (byte) 0x36, (byte) 0xe0, (byte) 0x1a,
+        (byte) 0xda, (byte) 0x77, (byte) 0xbd, (byte) 0x13, (byte) 0x7c, (byte) 0xd8, (byte) 0xd4, (byte) 0xda,
+        (byte) 0x10, (byte) 0xbb, (byte) 0x16, (byte) 0x2e, (byte) 0x94, (byte) 0xa4, (byte) 0x66, (byte) 0x29,
+        (byte) 0x71, (byte) 0xf1, (byte) 0x75, (byte) 0xf9, (byte) 0x85, (byte) 0xfa, (byte) 0x18, (byte) 0x8f,
+        (byte) 0x05, (byte) 0x6c, (byte) 0xb9, (byte) 0x7e, (byte) 0xe2, (byte) 0x81, (byte) 0x6f, (byte) 0x43,
+        (byte) 0xab, (byte) 0x9d, (byte) 0x37, (byte) 0x47, (byte) 0x61, (byte) 0x24, (byte) 0x86, (byte) 0xcd,
+        (byte) 0xa8, (byte) 0xc1, (byte) 0x61, (byte) 0x96, (byte) 0xc3, (byte) 0x08, (byte) 0x18, (byte) 0xa9,
+        (byte) 0x95, (byte) 0xec, (byte) 0x85, (byte) 0xd3, (byte) 0x84, (byte) 0x67, (byte) 0x79, (byte) 0x12,
+        (byte) 0x67, (byte) 0xb3, (byte) 0xbf, (byte) 0x21, (byte) 0xf2, (byte) 0x73, (byte) 0x71, (byte) 0x0a,
+        (byte) 0x69, (byte) 0x25, (byte) 0x86, (byte) 0x25, (byte) 0x76, (byte) 0x84, (byte) 0x1c, (byte) 0x5b,
+        (byte) 0x67, (byte) 0x12, (byte) 0xc1, (byte) 0x2d, (byte) 0x4b, (byte) 0xd2, (byte) 0x0a, (byte) 0x2f,
+        (byte) 0x32, (byte) 0x99, (byte) 0xad, (byte) 0xb7, (byte) 0xc1, (byte) 0x35, (byte) 0xda, (byte) 0x5e,
+        (byte) 0x95, (byte) 0x15, (byte) 0xab, (byte) 0xda, (byte) 0x76, (byte) 0xe7, (byte) 0xca, (byte) 0xf2,
+        (byte) 0xa3, (byte) 0xbe, (byte) 0x80, (byte) 0x55, (byte) 0x1d, (byte) 0x07, (byte) 0x3b, (byte) 0x78,
+        (byte) 0xbf, (byte) 0x11, (byte) 0x62, (byte) 0xc4, (byte) 0x8a, (byte) 0xd2, (byte) 0xb7, (byte) 0xf4,
+        (byte) 0x74, (byte) 0x3a, (byte) 0x02, (byte) 0x38, (byte) 0xee, (byte) 0x4d, (byte) 0x25, (byte) 0x2f,
+        (byte) 0x7d, (byte) 0x5e, (byte) 0x7e, (byte) 0x65, (byte) 0x33, (byte) 0xcc, (byte) 0xae, (byte) 0x64,
+        (byte) 0xcc, (byte) 0xb3, (byte) 0x93, (byte) 0x60, (byte) 0x07, (byte) 0x5a, (byte) 0x2f, (byte) 0xd1,
+        (byte) 0xe0, (byte) 0x34, (byte) 0xec, (byte) 0x3a, (byte) 0xe5, (byte) 0xce, (byte) 0x9c, (byte) 0x40,
+        (byte) 0x8c, (byte) 0xcb, (byte) 0xf0, (byte) 0xe2, (byte) 0x5e, (byte) 0x41, (byte) 0x14, (byte) 0x02,
+        (byte) 0x16, (byte) 0x87, (byte) 0xb3, (byte) 0xdd, (byte) 0x47, (byte) 0x54, (byte) 0xae, (byte) 0x81,
+    });
+
+    private static final BigInteger RSA_2048_publicExponent = new BigInteger(new byte[] {
+        (byte) 0x01, (byte) 0x00, (byte) 0x01,
+    });
+
+    private static final BigInteger RSA_2048_primeP = new BigInteger(new byte[] {
+        (byte) 0x00, (byte) 0xf5, (byte) 0x41, (byte) 0x88, (byte) 0x4b, (byte) 0xc3, (byte) 0x73, (byte) 0x7b,
+        (byte) 0x29, (byte) 0x22, (byte) 0xd4, (byte) 0x11, (byte) 0x9e, (byte) 0xf4, (byte) 0x5e, (byte) 0x2d,
+        (byte) 0xee, (byte) 0x2c, (byte) 0xd4, (byte) 0xcb, (byte) 0xb7, (byte) 0x5f, (byte) 0x45, (byte) 0x50,
+        (byte) 0x5a, (byte) 0x15, (byte) 0x7a, (byte) 0xa5, (byte) 0x00, (byte) 0x9f, (byte) 0x99, (byte) 0xc7,
+        (byte) 0x3a, (byte) 0x2d, (byte) 0xf0, (byte) 0x72, (byte) 0x4a, (byte) 0xc4, (byte) 0x60, (byte) 0x24,
+        (byte) 0x30, (byte) 0x63, (byte) 0x32, (byte) 0xea, (byte) 0x89, (byte) 0x81, (byte) 0x77, (byte) 0x63,
+        (byte) 0x45, (byte) 0x46, (byte) 0x5d, (byte) 0xc6, (byte) 0xdf, (byte) 0x1e, (byte) 0x0a, (byte) 0x6f,
+        (byte) 0x14, (byte) 0x0a, (byte) 0xff, (byte) 0x3b, (byte) 0x73, (byte) 0x96, (byte) 0xe6, (byte) 0xa8,
+        (byte) 0x99, (byte) 0x4a, (byte) 0xc5, (byte) 0xda, (byte) 0xa9, (byte) 0x68, (byte) 0x73, (byte) 0x47,
+        (byte) 0x2f, (byte) 0xe3, (byte) 0x77, (byte) 0x49, (byte) 0xd1, (byte) 0x4e, (byte) 0xb3, (byte) 0xe0,
+        (byte) 0x75, (byte) 0xe6, (byte) 0x29, (byte) 0xdb, (byte) 0xeb, (byte) 0x35, (byte) 0x83, (byte) 0x33,
+        (byte) 0x8a, (byte) 0x6f, (byte) 0x36, (byte) 0x49, (byte) 0xd0, (byte) 0xa2, (byte) 0x65, (byte) 0x4a,
+        (byte) 0x7a, (byte) 0x42, (byte) 0xfd, (byte) 0x9a, (byte) 0xb6, (byte) 0xbf, (byte) 0xa4, (byte) 0xac,
+        (byte) 0x4d, (byte) 0x48, (byte) 0x1d, (byte) 0x39, (byte) 0x0b, (byte) 0xb2, (byte) 0x29, (byte) 0xb0,
+        (byte) 0x64, (byte) 0xbd, (byte) 0xc3, (byte) 0x11, (byte) 0xcc, (byte) 0x1b, (byte) 0xe1, (byte) 0xb6,
+        (byte) 0x31, (byte) 0x89, (byte) 0xda, (byte) 0x7c, (byte) 0x40, (byte) 0xcd, (byte) 0xec, (byte) 0xf2,
+        (byte) 0xb1,
+    });
+
+    private static final BigInteger RSA_2048_primeQ = new BigInteger(new byte[] {
+        (byte) 0x00, (byte) 0xea, (byte) 0x1a, (byte) 0x74, (byte) 0x2d, (byte) 0xdb, (byte) 0x88, (byte) 0x1c,
+        (byte) 0xed, (byte) 0xb7, (byte) 0x28, (byte) 0x8c, (byte) 0x87, (byte) 0xe3, (byte) 0x8d, (byte) 0x86,
+        (byte) 0x8d, (byte) 0xd7, (byte) 0xa4, (byte) 0x09, (byte) 0xd1, (byte) 0x5a, (byte) 0x43, (byte) 0xf4,
+        (byte) 0x45, (byte) 0xd5, (byte) 0x37, (byte) 0x7a, (byte) 0x0b, (byte) 0x57, (byte) 0x31, (byte) 0xdd,
+        (byte) 0xbf, (byte) 0xca, (byte) 0x2d, (byte) 0xaf, (byte) 0x28, (byte) 0xa8, (byte) 0xe1, (byte) 0x3c,
+        (byte) 0xd5, (byte) 0xc0, (byte) 0xaf, (byte) 0xce, (byte) 0xc3, (byte) 0x34, (byte) 0x7d, (byte) 0x74,
+        (byte) 0xa3, (byte) 0x9e, (byte) 0x23, (byte) 0x5a, (byte) 0x3c, (byte) 0xd9, (byte) 0x63, (byte) 0x3f,
+        (byte) 0x27, (byte) 0x4d, (byte) 0xe2, (byte) 0xb9, (byte) 0x4f, (byte) 0x92, (byte) 0xdf, (byte) 0x43,
+        (byte) 0x83, (byte) 0x39, (byte) 0x11, (byte) 0xd9, (byte) 0xe9, (byte) 0xf1, (byte) 0xcf, (byte) 0x58,
+        (byte) 0xf2, (byte) 0x7d, (byte) 0xe2, (byte) 0xe0, (byte) 0x8f, (byte) 0xf4, (byte) 0x59, (byte) 0x64,
+        (byte) 0xc7, (byte) 0x20, (byte) 0xd3, (byte) 0xec, (byte) 0x21, (byte) 0x39, (byte) 0xdc, (byte) 0x7c,
+        (byte) 0xaf, (byte) 0xc9, (byte) 0x12, (byte) 0x95, (byte) 0x3c, (byte) 0xde, (byte) 0xcb, (byte) 0x2f,
+        (byte) 0x35, (byte) 0x5a, (byte) 0x2e, (byte) 0x2c, (byte) 0x35, (byte) 0xa5, (byte) 0x0f, (byte) 0xad,
+        (byte) 0x75, (byte) 0x4c, (byte) 0xb3, (byte) 0xb2, (byte) 0x31, (byte) 0x66, (byte) 0x42, (byte) 0x4b,
+        (byte) 0xa3, (byte) 0xb6, (byte) 0xe3, (byte) 0x11, (byte) 0x2a, (byte) 0x2b, (byte) 0x89, (byte) 0x8c,
+        (byte) 0x38, (byte) 0xc5, (byte) 0xc1, (byte) 0x5e, (byte) 0xdb, (byte) 0x23, (byte) 0x86, (byte) 0x93,
+        (byte) 0x39,
+    });
+
+    /**
+     * Test data is PKCS#1 padded "Android.\n" which can be generated by:
+     * echo "Android." | openssl rsautl -inkey rsa.key -sign | openssl rsautl -inkey rsa.key -raw -verify | recode ../x1
+     */
+    private static final byte[] RSA_2048_Vector1 = new byte[] {
+        (byte) 0x00, (byte) 0x01, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
+        (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
+        (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
+        (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
+        (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
+        (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
+        (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
+        (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
+        (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
+        (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
+        (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
+        (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
+        (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
+        (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
+        (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
+        (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
+        (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
+        (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
+        (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
+        (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
+        (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
+        (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
+        (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
+        (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
+        (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
+        (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
+        (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
+        (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
+        (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
+        (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
+        (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
+        (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
+        (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
+        (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
+        (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
+        (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
+        (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
+        (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
+        (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
+        (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
+        (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF, (byte) 0xFF,
+        (byte) 0x00, (byte) 0x41, (byte) 0x6E, (byte) 0x64, (byte) 0x72, (byte) 0x6F,
+        (byte) 0x69, (byte) 0x64, (byte) 0x2E, (byte) 0x0A,
+    };
+
+    /**
+     * This vector is simply "Android.\n" which is too short.
+     */
+    private static final byte[] TooShort_Vector = new byte[] {
+        (byte) 0x41, (byte) 0x6E, (byte) 0x64, (byte) 0x72, (byte) 0x6F, (byte) 0x69,
+        (byte) 0x64, (byte) 0x2E, (byte) 0x0A,
+    };
+
+    /**
+     * This vector is simply "Android.\n" padded with zeros.
+     */
+    private static final byte[] TooShort_Vector_Zero_Padded = new byte[] {
+        (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
+        (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
+        (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
+        (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
+        (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
+        (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
+        (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
+        (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
+        (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
+        (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
+        (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
+        (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
+        (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
+        (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
+        (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
+        (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
+        (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
+        (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
+        (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
+        (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
+        (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
+        (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
+        (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
+        (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
+        (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
+        (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
+        (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
+        (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
+        (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
+        (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
+        (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
+        (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
+        (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
+        (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
+        (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
+        (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
+        (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
+        (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
+        (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
+        (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
+        (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
+        (byte) 0x00, (byte) 0x41, (byte) 0x6e, (byte) 0x64, (byte) 0x72, (byte) 0x6f,
+        (byte) 0x69, (byte) 0x64, (byte) 0x2e, (byte) 0x0a,
+    };
+
+    /**
+     * openssl rsautl -raw -sign -inkey rsa.key | recode ../x1 | sed 's/0x/(byte) 0x/g'
+     */
+    private static final byte[] RSA_Vector1_Encrypt_Private = new byte[] {
+        (byte) 0x35, (byte) 0x43, (byte) 0x38, (byte) 0x44, (byte) 0xAD, (byte) 0x3F,
+        (byte) 0x97, (byte) 0x02, (byte) 0xFB, (byte) 0x59, (byte) 0x1F, (byte) 0x4A,
+        (byte) 0x2B, (byte) 0xB9, (byte) 0x06, (byte) 0xEC, (byte) 0x66, (byte) 0xE6,
+        (byte) 0xD2, (byte) 0xC5, (byte) 0x8B, (byte) 0x7B, (byte) 0xE3, (byte) 0x18,
+        (byte) 0xBF, (byte) 0x07, (byte) 0xD6, (byte) 0x01, (byte) 0xF9, (byte) 0xD9,
+        (byte) 0x89, (byte) 0xC4, (byte) 0xDB, (byte) 0x00, (byte) 0x68, (byte) 0xFF,
+        (byte) 0x9B, (byte) 0x43, (byte) 0x90, (byte) 0xF2, (byte) 0xDB, (byte) 0x83,
+        (byte) 0xF4, (byte) 0x7E, (byte) 0xC6, (byte) 0x81, (byte) 0x01, (byte) 0x3A,
+        (byte) 0x0B, (byte) 0xE5, (byte) 0xED, (byte) 0x08, (byte) 0x73, (byte) 0x3E,
+        (byte) 0xE1, (byte) 0x3F, (byte) 0xDF, (byte) 0x1F, (byte) 0x07, (byte) 0x6D,
+        (byte) 0x22, (byte) 0x8D, (byte) 0xCC, (byte) 0x4E, (byte) 0xE3, (byte) 0x9A,
+        (byte) 0xBC, (byte) 0xCC, (byte) 0x8F, (byte) 0x9E, (byte) 0x9B, (byte) 0x02,
+        (byte) 0x48, (byte) 0x00, (byte) 0xAC, (byte) 0x9F, (byte) 0xA4, (byte) 0x8F,
+        (byte) 0x87, (byte) 0xA1, (byte) 0xA8, (byte) 0xE6, (byte) 0x9D, (byte) 0xCD,
+        (byte) 0x8B, (byte) 0x05, (byte) 0xE9, (byte) 0xD2, (byte) 0x05, (byte) 0x8D,
+        (byte) 0xC9, (byte) 0x95, (byte) 0x16, (byte) 0xD0, (byte) 0xCD, (byte) 0x43,
+        (byte) 0x25, (byte) 0x8A, (byte) 0x11, (byte) 0x46, (byte) 0xD7, (byte) 0x74,
+        (byte) 0x4C, (byte) 0xCF, (byte) 0x58, (byte) 0xF9, (byte) 0xA1, (byte) 0x30,
+        (byte) 0x84, (byte) 0x52, (byte) 0xC9, (byte) 0x01, (byte) 0x5F, (byte) 0x24,
+        (byte) 0x4C, (byte) 0xB1, (byte) 0x9F, (byte) 0x7D, (byte) 0x12, (byte) 0x38,
+        (byte) 0x27, (byte) 0x0F, (byte) 0x5E, (byte) 0xFF, (byte) 0xE0, (byte) 0x55,
+        (byte) 0x8B, (byte) 0xA3, (byte) 0xAD, (byte) 0x60, (byte) 0x35, (byte) 0x83,
+        (byte) 0x58, (byte) 0xAF, (byte) 0x99, (byte) 0xDE, (byte) 0x3F, (byte) 0x5D,
+        (byte) 0x80, (byte) 0x80, (byte) 0xFF, (byte) 0x9B, (byte) 0xDE, (byte) 0x5C,
+        (byte) 0xAB, (byte) 0x97, (byte) 0x43, (byte) 0x64, (byte) 0xD9, (byte) 0x9F,
+        (byte) 0xFB, (byte) 0x67, (byte) 0x65, (byte) 0xA5, (byte) 0x99, (byte) 0xE7,
+        (byte) 0xE6, (byte) 0xEB, (byte) 0x05, (byte) 0x95, (byte) 0xFC, (byte) 0x46,
+        (byte) 0x28, (byte) 0x4B, (byte) 0xD8, (byte) 0x8C, (byte) 0xF5, (byte) 0x0A,
+        (byte) 0xEB, (byte) 0x1F, (byte) 0x30, (byte) 0xEA, (byte) 0xE7, (byte) 0x67,
+        (byte) 0x11, (byte) 0x25, (byte) 0xF0, (byte) 0x44, (byte) 0x75, (byte) 0x74,
+        (byte) 0x94, (byte) 0x06, (byte) 0x78, (byte) 0xD0, (byte) 0x21, (byte) 0xF4,
+        (byte) 0x3F, (byte) 0xC8, (byte) 0xC4, (byte) 0x4A, (byte) 0x57, (byte) 0xBE,
+        (byte) 0x02, (byte) 0x3C, (byte) 0x93, (byte) 0xF6, (byte) 0x95, (byte) 0xFB,
+        (byte) 0xD1, (byte) 0x77, (byte) 0x8B, (byte) 0x43, (byte) 0xF0, (byte) 0xB9,
+        (byte) 0x7D, (byte) 0xE0, (byte) 0x32, (byte) 0xE1, (byte) 0x72, (byte) 0xB5,
+        (byte) 0x62, (byte) 0x3F, (byte) 0x86, (byte) 0xC3, (byte) 0xD4, (byte) 0x5F,
+        (byte) 0x5E, (byte) 0x54, (byte) 0x1B, (byte) 0x5B, (byte) 0xE6, (byte) 0x74,
+        (byte) 0xA1, (byte) 0x0B, (byte) 0xE5, (byte) 0x18, (byte) 0xD2, (byte) 0x4F,
+        (byte) 0x93, (byte) 0xF3, (byte) 0x09, (byte) 0x58, (byte) 0xCE, (byte) 0xF0,
+        (byte) 0xA3, (byte) 0x61, (byte) 0xE4, (byte) 0x6E, (byte) 0x46, (byte) 0x45,
+        (byte) 0x89, (byte) 0x50, (byte) 0xBD, (byte) 0x03, (byte) 0x3F, (byte) 0x38,
+        (byte) 0xDA, (byte) 0x5D, (byte) 0xD0, (byte) 0x1B, (byte) 0x1F, (byte) 0xB1,
+        (byte) 0xEE, (byte) 0x89, (byte) 0x59, (byte) 0xC5,
+    };
+
+    private static final byte[] RSA_Vector1_ZeroPadded_Encrypted = new byte[] {
+        (byte) 0x60, (byte) 0x4a, (byte) 0x12, (byte) 0xa3, (byte) 0xa7, (byte) 0x4a,
+        (byte) 0xa4, (byte) 0xbf, (byte) 0x6c, (byte) 0x36, (byte) 0xad, (byte) 0x66,
+        (byte) 0xdf, (byte) 0xce, (byte) 0xf1, (byte) 0xe4, (byte) 0x0f, (byte) 0xd4,
+        (byte) 0x54, (byte) 0x5f, (byte) 0x03, (byte) 0x15, (byte) 0x4b, (byte) 0x9e,
+        (byte) 0xeb, (byte) 0xfe, (byte) 0x9e, (byte) 0x24, (byte) 0xce, (byte) 0x8e,
+        (byte) 0xc3, (byte) 0x36, (byte) 0xa5, (byte) 0x76, (byte) 0xf6, (byte) 0x54,
+        (byte) 0xb7, (byte) 0x84, (byte) 0x48, (byte) 0x2f, (byte) 0xd4, (byte) 0x45,
+        (byte) 0x74, (byte) 0x48, (byte) 0x5f, (byte) 0x08, (byte) 0x4e, (byte) 0x9c,
+        (byte) 0x89, (byte) 0xcc, (byte) 0x34, (byte) 0x40, (byte) 0xb1, (byte) 0x5f,
+        (byte) 0xa7, (byte) 0x0e, (byte) 0x11, (byte) 0x4b, (byte) 0xb5, (byte) 0x94,
+        (byte) 0xbe, (byte) 0x14, (byte) 0xaa, (byte) 0xaa, (byte) 0xe0, (byte) 0x38,
+        (byte) 0x1c, (byte) 0xce, (byte) 0x40, (byte) 0x61, (byte) 0xfc, (byte) 0x08,
+        (byte) 0xcb, (byte) 0x14, (byte) 0x2b, (byte) 0xa6, (byte) 0x54, (byte) 0xdf,
+        (byte) 0x05, (byte) 0x5c, (byte) 0x9b, (byte) 0x4f, (byte) 0x14, (byte) 0x93,
+        (byte) 0xb0, (byte) 0x70, (byte) 0xd9, (byte) 0x32, (byte) 0xdc, (byte) 0x24,
+        (byte) 0xe0, (byte) 0xae, (byte) 0x48, (byte) 0xfc, (byte) 0x53, (byte) 0xee,
+        (byte) 0x7c, (byte) 0x9f, (byte) 0x69, (byte) 0x34, (byte) 0xf4, (byte) 0x76,
+        (byte) 0xee, (byte) 0x67, (byte) 0xb2, (byte) 0xa7, (byte) 0x33, (byte) 0x1c,
+        (byte) 0x47, (byte) 0xff, (byte) 0x5c, (byte) 0xf0, (byte) 0xb8, (byte) 0x04,
+        (byte) 0x2c, (byte) 0xfd, (byte) 0xe2, (byte) 0xb1, (byte) 0x4a, (byte) 0x0a,
+        (byte) 0x69, (byte) 0x1c, (byte) 0x80, (byte) 0x2b, (byte) 0xb4, (byte) 0x50,
+        (byte) 0x65, (byte) 0x5c, (byte) 0x76, (byte) 0x78, (byte) 0x9a, (byte) 0x0c,
+        (byte) 0x05, (byte) 0x62, (byte) 0xf0, (byte) 0xc4, (byte) 0x1c, (byte) 0x38,
+        (byte) 0x15, (byte) 0xd0, (byte) 0xe2, (byte) 0x5a, (byte) 0x3d, (byte) 0xb6,
+        (byte) 0xe0, (byte) 0x88, (byte) 0x85, (byte) 0xd1, (byte) 0x4f, (byte) 0x7e,
+        (byte) 0xfc, (byte) 0x77, (byte) 0x0d, (byte) 0x2a, (byte) 0x45, (byte) 0xd5,
+        (byte) 0xf8, (byte) 0x3c, (byte) 0x7b, (byte) 0x2d, (byte) 0x1b, (byte) 0x82,
+        (byte) 0xfe, (byte) 0x58, (byte) 0x22, (byte) 0x47, (byte) 0x06, (byte) 0x58,
+        (byte) 0x8b, (byte) 0x4f, (byte) 0xfb, (byte) 0x9b, (byte) 0x1c, (byte) 0x70,
+        (byte) 0x36, (byte) 0x12, (byte) 0x04, (byte) 0x17, (byte) 0x47, (byte) 0x8a,
+        (byte) 0x0a, (byte) 0xec, (byte) 0x12, (byte) 0x3b, (byte) 0xf8, (byte) 0xd2,
+        (byte) 0xdc, (byte) 0x3c, (byte) 0xc8, (byte) 0x46, (byte) 0xc6, (byte) 0x51,
+        (byte) 0x06, (byte) 0x06, (byte) 0xcb, (byte) 0x84, (byte) 0x67, (byte) 0xb5,
+        (byte) 0x68, (byte) 0xd9, (byte) 0x9c, (byte) 0xd4, (byte) 0x16, (byte) 0x5c,
+        (byte) 0xb4, (byte) 0xe2, (byte) 0x55, (byte) 0xe6, (byte) 0x3a, (byte) 0x73,
+        (byte) 0x01, (byte) 0x1d, (byte) 0x6f, (byte) 0x30, (byte) 0x31, (byte) 0x59,
+        (byte) 0x8b, (byte) 0x2f, (byte) 0x4c, (byte) 0xe7, (byte) 0x86, (byte) 0x4c,
+        (byte) 0x39, (byte) 0x4e, (byte) 0x67, (byte) 0x3b, (byte) 0x22, (byte) 0x9b,
+        (byte) 0x85, (byte) 0x5a, (byte) 0xc3, (byte) 0x29, (byte) 0xaf, (byte) 0x8c,
+        (byte) 0x7c, (byte) 0x59, (byte) 0x4a, (byte) 0x24, (byte) 0xfa, (byte) 0xba,
+        (byte) 0x55, (byte) 0x40, (byte) 0x13, (byte) 0x64, (byte) 0xd8, (byte) 0xcb,
+        (byte) 0x4b, (byte) 0x98, (byte) 0x3f, (byte) 0xae, (byte) 0x20, (byte) 0xfd,
+        (byte) 0x8a, (byte) 0x50, (byte) 0x73, (byte) 0xe4,
+    };
+
+    public void testRSA_ECB_NoPadding_Private_OnlyDoFinal_Success() throws Exception {
+        KeyFactory kf = KeyFactory.getInstance("RSA");
+        RSAPrivateKeySpec keySpec = new RSAPrivateKeySpec(RSA_2048_modulus,
+                RSA_2048_privateExponent);
+
+        final PrivateKey privKey = kf.generatePrivate(keySpec);
+
+        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding");
+
+        /*
+         * You're actually decrypting with private keys, but there is no
+         * distinction made here. It's all keyed off of what kind of key you're
+         * using. ENCRYPT_MODE and DECRYPT_MODE are the same.
+         */
+        c.init(Cipher.ENCRYPT_MODE, privKey);
+        byte[] encrypted = c.doFinal(RSA_2048_Vector1);
+        assertTrue("Encrypted should match expected",
+                Arrays.equals(RSA_Vector1_Encrypt_Private, encrypted));
+
+        c.init(Cipher.DECRYPT_MODE, privKey);
+        encrypted = c.doFinal(RSA_2048_Vector1);
+        assertTrue("Encrypted should match expected",
+                Arrays.equals(RSA_Vector1_Encrypt_Private, encrypted));
+    }
+
+    public void testRSA_ECB_NoPadding_Private_UpdateThenEmptyDoFinal_Success() throws Exception {
+        KeyFactory kf = KeyFactory.getInstance("RSA");
+        RSAPrivateKeySpec keySpec = new RSAPrivateKeySpec(RSA_2048_modulus,
+                RSA_2048_privateExponent);
+
+        final PrivateKey privKey = kf.generatePrivate(keySpec);
+
+        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding");
+
+        /*
+         * You're actually decrypting with private keys, but there is no
+         * distinction made here. It's all keyed off of what kind of key you're
+         * using. ENCRYPT_MODE and DECRYPT_MODE are the same.
+         */
+        c.init(Cipher.ENCRYPT_MODE, privKey);
+        c.update(RSA_2048_Vector1);
+        byte[] encrypted = c.doFinal();
+        assertTrue("Encrypted should match expected",
+                Arrays.equals(RSA_Vector1_Encrypt_Private, encrypted));
+
+        c.init(Cipher.DECRYPT_MODE, privKey);
+        c.update(RSA_2048_Vector1);
+        encrypted = c.doFinal();
+        assertTrue("Encrypted should match expected",
+                Arrays.equals(RSA_Vector1_Encrypt_Private, encrypted));
+    }
+
+    public void testRSA_ECB_NoPadding_Private_SingleByteUpdateThenEmptyDoFinal_Success()
+            throws Exception {
+        KeyFactory kf = KeyFactory.getInstance("RSA");
+        RSAPrivateKeySpec keySpec = new RSAPrivateKeySpec(RSA_2048_modulus,
+                RSA_2048_privateExponent);
+
+        final PrivateKey privKey = kf.generatePrivate(keySpec);
+
+        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding");
+
+        /*
+         * You're actually decrypting with private keys, but there is no
+         * distinction made here. It's all keyed off of what kind of key you're
+         * using. ENCRYPT_MODE and DECRYPT_MODE are the same.
+         */
+        c.init(Cipher.ENCRYPT_MODE, privKey);
+        int i;
+        for (i = 0; i < RSA_2048_Vector1.length / 2; i++) {
+            c.update(RSA_2048_Vector1, i, 1);
+        }
+        byte[] encrypted = c.doFinal(RSA_2048_Vector1, i, RSA_2048_Vector1.length - i);
+        assertTrue("Encrypted should match expected",
+                Arrays.equals(RSA_Vector1_Encrypt_Private, encrypted));
+
+        c.init(Cipher.DECRYPT_MODE, privKey);
+        for (i = 0; i < RSA_2048_Vector1.length / 2; i++) {
+            c.update(RSA_2048_Vector1, i, 1);
+        }
+        encrypted = c.doFinal(RSA_2048_Vector1, i, RSA_2048_Vector1.length - i);
+        assertTrue("Encrypted should match expected",
+                Arrays.equals(RSA_Vector1_Encrypt_Private, encrypted));
+    }
+
+    public void testRSA_ECB_NoPadding_Public_OnlyDoFinal_Success() throws Exception {
+        KeyFactory kf = KeyFactory.getInstance("RSA");
+        RSAPublicKeySpec keySpec = new RSAPublicKeySpec(RSA_2048_modulus, RSA_2048_publicExponent);
+
+        final PublicKey privKey = kf.generatePublic(keySpec);
+
+        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding");
+
+        /*
+         * You're actually encrypting with public keys, but there is no
+         * distinction made here. It's all keyed off of what kind of key you're
+         * using. ENCRYPT_MODE and DECRYPT_MODE are the same.
+         */
+        c.init(Cipher.ENCRYPT_MODE, privKey);
+        byte[] encrypted = c.doFinal(RSA_Vector1_Encrypt_Private);
+        assertTrue("Encrypted should match expected",
+                Arrays.equals(RSA_2048_Vector1, encrypted));
+
+        c.init(Cipher.DECRYPT_MODE, privKey);
+        encrypted = c.doFinal(RSA_Vector1_Encrypt_Private);
+        assertTrue("Encrypted should match expected",
+                Arrays.equals(RSA_2048_Vector1, encrypted));
+    }
+
+    public void testRSA_ECB_NoPadding_Public_UpdateThenEmptyDoFinal_Success() throws Exception {
+        KeyFactory kf = KeyFactory.getInstance("RSA");
+        RSAPublicKeySpec keySpec = new RSAPublicKeySpec(RSA_2048_modulus, RSA_2048_publicExponent);
+
+        final PublicKey privKey = kf.generatePublic(keySpec);
+
+        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding");
+
+        /*
+         * You're actually encrypting with public keys, but there is no
+         * distinction made here. It's all keyed off of what kind of key you're
+         * using. ENCRYPT_MODE and DECRYPT_MODE are the same.
+         */
+        c.init(Cipher.ENCRYPT_MODE, privKey);
+        c.update(RSA_Vector1_Encrypt_Private);
+        byte[] encrypted = c.doFinal();
+        assertTrue("Encrypted should match expected", Arrays.equals(RSA_2048_Vector1, encrypted));
+
+        c.init(Cipher.DECRYPT_MODE, privKey);
+        c.update(RSA_Vector1_Encrypt_Private);
+        encrypted = c.doFinal();
+        assertTrue("Encrypted should match expected", Arrays.equals(RSA_2048_Vector1, encrypted));
+    }
+
+    public void testRSA_ECB_NoPadding_Public_SingleByteUpdateThenEmptyDoFinal_Success()
+            throws Exception {
+        KeyFactory kf = KeyFactory.getInstance("RSA");
+        RSAPublicKeySpec keySpec = new RSAPublicKeySpec(RSA_2048_modulus, RSA_2048_publicExponent);
+
+        final PublicKey privKey = kf.generatePublic(keySpec);
+
+        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding");
+
+        /*
+         * You're actually encrypting with public keys, but there is no
+         * distinction made here. It's all keyed off of what kind of key you're
+         * using. ENCRYPT_MODE and DECRYPT_MODE are the same.
+         */
+        c.init(Cipher.ENCRYPT_MODE, privKey);
+        int i;
+        for (i = 0; i < RSA_Vector1_Encrypt_Private.length / 2; i++) {
+            c.update(RSA_Vector1_Encrypt_Private, i, 1);
+        }
+        byte[] encrypted = c.doFinal(RSA_Vector1_Encrypt_Private, i, RSA_2048_Vector1.length - i);
+        assertTrue("Encrypted should match expected", Arrays.equals(RSA_2048_Vector1, encrypted));
+
+        c.init(Cipher.DECRYPT_MODE, privKey);
+        for (i = 0; i < RSA_Vector1_Encrypt_Private.length / 2; i++) {
+            c.update(RSA_Vector1_Encrypt_Private, i, 1);
+        }
+        encrypted = c.doFinal(RSA_Vector1_Encrypt_Private, i, RSA_2048_Vector1.length - i);
+        assertTrue("Encrypted should match expected", Arrays.equals(RSA_2048_Vector1, encrypted));
+    }
+
+    public void testRSA_ECB_NoPadding_Public_TooSmall_Success() throws Exception {
+        KeyFactory kf = KeyFactory.getInstance("RSA");
+        RSAPublicKeySpec keySpec = new RSAPublicKeySpec(RSA_2048_modulus, RSA_2048_publicExponent);
+
+        final PublicKey privKey = kf.generatePublic(keySpec);
+
+        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding");
+
+        /*
+         * You're actually encrypting with public keys, but there is no
+         * distinction made here. It's all keyed off of what kind of key you're
+         * using. ENCRYPT_MODE and DECRYPT_MODE are the same.
+         */
+        c.init(Cipher.ENCRYPT_MODE, privKey);
+        byte[] encrypted = c.doFinal(TooShort_Vector);
+        assertTrue("Encrypted should match expected",
+                Arrays.equals(RSA_Vector1_ZeroPadded_Encrypted, encrypted));
+
+        c.init(Cipher.DECRYPT_MODE, privKey);
+        encrypted = c.doFinal(TooShort_Vector);
+        assertTrue("Encrypted should match expected",
+                Arrays.equals(RSA_Vector1_ZeroPadded_Encrypted, encrypted));
+    }
+
+    public void testRSA_ECB_NoPadding_Private_TooSmall_Success() throws Exception {
+        KeyFactory kf = KeyFactory.getInstance("RSA");
+        RSAPrivateKeySpec keySpec = new RSAPrivateKeySpec(RSA_2048_modulus,
+                RSA_2048_privateExponent);
+
+        final PrivateKey privKey = kf.generatePrivate(keySpec);
+
+        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding");
+
+        /*
+         * You're actually encrypting with public keys, but there is no
+         * distinction made here. It's all keyed off of what kind of key you're
+         * using. ENCRYPT_MODE and DECRYPT_MODE are the same.
+         */
+        c.init(Cipher.ENCRYPT_MODE, privKey);
+        byte[] encrypted = c.doFinal(RSA_Vector1_ZeroPadded_Encrypted);
+        assertTrue("Encrypted should match expected",
+                Arrays.equals(TooShort_Vector_Zero_Padded, encrypted));
+
+        c.init(Cipher.DECRYPT_MODE, privKey);
+        encrypted = c.doFinal(RSA_Vector1_ZeroPadded_Encrypted);
+        assertTrue("Encrypted should match expected",
+                Arrays.equals(TooShort_Vector_Zero_Padded, encrypted));
+    }
+
+    public void testRSA_ECB_NoPadding_Private_CombinedUpdateAndDoFinal_TooBig_Failure()
+            throws Exception {
+        KeyFactory kf = KeyFactory.getInstance("RSA");
+        RSAPrivateKeySpec keySpec = new RSAPrivateKeySpec(RSA_2048_modulus,
+                RSA_2048_privateExponent);
+
+        final PrivateKey privKey = kf.generatePrivate(keySpec);
+
+        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding");
+
+        /*
+         * You're actually encrypting with public keys, but there is no
+         * distinction made here. It's all keyed off of what kind of key you're
+         * using. ENCRYPT_MODE and DECRYPT_MODE are the same.
+         */
+        c.init(Cipher.ENCRYPT_MODE, privKey);
+        c.update(RSA_Vector1_ZeroPadded_Encrypted);
+
+        try {
+            c.doFinal(RSA_Vector1_ZeroPadded_Encrypted);
+            fail("Should have error when block size is too big.");
+        } catch (IllegalBlockSizeException success) {
+        }
+    }
+
+    public void testRSA_ECB_NoPadding_Private_UpdateInAndOutPlusDoFinal_TooBig_Failure()
+            throws Exception {
+        KeyFactory kf = KeyFactory.getInstance("RSA");
+        RSAPrivateKeySpec keySpec = new RSAPrivateKeySpec(RSA_2048_modulus,
+                RSA_2048_privateExponent);
+
+        final PrivateKey privKey = kf.generatePrivate(keySpec);
+
+        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding");
+
+        /*
+         * You're actually encrypting with public keys, but there is no
+         * distinction made here. It's all keyed off of what kind of key you're
+         * using. ENCRYPT_MODE and DECRYPT_MODE are the same.
+         */
+        c.init(Cipher.ENCRYPT_MODE, privKey);
+
+        byte[] output = new byte[RSA_2048_Vector1.length];
+        c.update(RSA_Vector1_ZeroPadded_Encrypted, 0, RSA_Vector1_ZeroPadded_Encrypted.length,
+                output);
+
+        try {
+            c.doFinal(RSA_Vector1_ZeroPadded_Encrypted);
+            fail("Should have error when block size is too big.");
+        } catch (IllegalBlockSizeException success) {
+        }
+    }
+
+    public void testRSA_ECB_NoPadding_Private_OnlyDoFinal_TooBig_Failure() throws Exception {
+        KeyFactory kf = KeyFactory.getInstance("RSA");
+        RSAPrivateKeySpec keySpec = new RSAPrivateKeySpec(RSA_2048_modulus,
+                RSA_2048_privateExponent);
+
+        final PrivateKey privKey = kf.generatePrivate(keySpec);
+
+        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding");
+
+        /*
+         * You're actually encrypting with public keys, but there is no
+         * distinction made here. It's all keyed off of what kind of key you're
+         * using. ENCRYPT_MODE and DECRYPT_MODE are the same.
+         */
+        c.init(Cipher.ENCRYPT_MODE, privKey);
+
+        byte[] tooBig_Vector = new byte[RSA_Vector1_ZeroPadded_Encrypted.length * 2];
+        System.arraycopy(RSA_Vector1_ZeroPadded_Encrypted, 0, tooBig_Vector, 0,
+                RSA_Vector1_ZeroPadded_Encrypted.length);
+        System.arraycopy(RSA_Vector1_ZeroPadded_Encrypted, 0, tooBig_Vector,
+                RSA_Vector1_ZeroPadded_Encrypted.length, RSA_Vector1_ZeroPadded_Encrypted.length);
+
+        try {
+            c.doFinal(tooBig_Vector);
+            fail("Should have error when block size is too big.");
+        } catch (IllegalBlockSizeException success) {
+        }
+    }
+
+    public void testRSA_ECB_NoPadding_GetBlockSize_Success() throws Exception {
+        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding");
+        assertEquals("RSA is not a block cipher and should return block size of 0",
+                0, c.getBlockSize());
+
+        KeyFactory kf = KeyFactory.getInstance("RSA");
+        RSAPublicKeySpec pubKeySpec = new RSAPublicKeySpec(RSA_2048_modulus,
+                RSA_2048_publicExponent);
+        final PublicKey pubKey = kf.generatePublic(pubKeySpec);
+        c.init(Cipher.ENCRYPT_MODE, pubKey);
+
+        assertEquals("RSA is not a block cipher and should return block size of 0",
+                0, c.getBlockSize());
+    }
+
+    public void testRSA_ECB_NoPadding_GetOutputSize_NoInit_Failure() throws Exception {
+        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding");
+        try {
+            c.getOutputSize(RSA_2048_Vector1.length);
+            fail("Should throw IllegalStateException if getOutputSize is called before init");
+        } catch (IllegalStateException success) {
+        }
+    }
+
+    public void testRSA_ECB_NoPadding_GetOutputSize_Success() throws Exception {
+        KeyFactory kf = KeyFactory.getInstance("RSA");
+        RSAPublicKeySpec pubKeySpec = new RSAPublicKeySpec(RSA_2048_modulus,
+                RSA_2048_publicExponent);
+        final PublicKey pubKey = kf.generatePublic(pubKeySpec);
+
+        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding");
+        c.init(Cipher.ENCRYPT_MODE, pubKey);
+
+        final int modulusInBytes = RSA_2048_modulus.bitLength() / 8;
+        assertEquals("Output size should be equal to modulus size",
+                modulusInBytes, c.getOutputSize(RSA_2048_Vector1.length));
+
+        assertEquals("Output size should be equal to modulus size",
+                modulusInBytes, c.getOutputSize(RSA_2048_Vector1.length * 2));
+
+        assertEquals("Output size should be equal to modulus size",
+                modulusInBytes, c.getOutputSize(0));
+    }
+
+    public void testRSA_ECB_NoPadding_GetIV_Success() throws Exception {
+        KeyFactory kf = KeyFactory.getInstance("RSA");
+        RSAPublicKeySpec pubKeySpec = new RSAPublicKeySpec(RSA_2048_modulus,
+                RSA_2048_publicExponent);
+        final PublicKey pubKey = kf.generatePublic(pubKeySpec);
+
+        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding");
+        assertNull("ECB mode has no IV and should be null", c.getIV());
+
+        c.init(Cipher.ENCRYPT_MODE, pubKey);
+
+        assertNull("ECB mode has no IV and should be null", c.getIV());
+    }
+
+    public void testRSA_ECB_NoPadding_GetParameters_NoneProvided_Success() throws Exception {
+        KeyFactory kf = KeyFactory.getInstance("RSA");
+        RSAPublicKeySpec pubKeySpec = new RSAPublicKeySpec(RSA_2048_modulus,
+                RSA_2048_publicExponent);
+        final PublicKey pubKey = kf.generatePublic(pubKeySpec);
+
+        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding");
+        assertNull("Parameters should be null", c.getParameters());
+    }
 }
-- 
cgit v1.1


From 699f565e8773f3aab263e7b33f6d089355814f19 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Mon, 6 Aug 2012 08:27:14 -0700
Subject: Improve the URLConnection timeout documentation slightly.

Change-Id: Ia4fbe6466f6db3f1186e6a007988d59140fc9f40
---
 luni/src/main/java/java/net/URLConnection.java | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/luni/src/main/java/java/net/URLConnection.java b/luni/src/main/java/java/net/URLConnection.java
index c832bfb..18a264e 100644
--- a/luni/src/main/java/java/net/URLConnection.java
+++ b/luni/src/main/java/java/net/URLConnection.java
@@ -948,11 +948,12 @@ public abstract class URLConnection {
     }
 
     /**
-     * Sets the maximum time to wait for a connect to complete before giving up.
+     * Sets the maximum time in milliseconds to wait while connecting.
      * Connecting to a server will fail with a {@link SocketTimeoutException} if
      * the timeout elapses before a connection is established. The default value
-     * of {@code 0} disables connect timeouts; connect attempts may wait
-     * indefinitely.
+     * of {@code 0} causes us to do a blocking connect. This does not mean we
+     * will never time out, but it probably means you'll get a TCP timeout
+     * after several minutes.
      *
      * <p><strong>Warning:</strong> if the hostname resolves to multiple IP
      * addresses, this client will try each in <a
@@ -961,7 +962,7 @@ public abstract class URLConnection {
      * elapse before the connect attempt throws an exception. Host names that
      * support both IPv6 and IPv4 always have at least 2 IP addresses.
      *
-     * @param timeoutMillis the connect timeout in milliseconds. Non-negative.
+     * @throws IllegalArgumentException if {@code timeoutMillis &lt; 0}.
      */
     public void setConnectTimeout(int timeoutMillis) {
         if (timeoutMillis < 0) {
@@ -971,8 +972,7 @@ public abstract class URLConnection {
     }
 
     /**
-     * Returns the connect timeout in milliseconds, or {@code 0} if connect
-     * attempts never timeout.
+     * Returns the connect timeout in milliseconds. (See {#setConnectTimeout}.)
      */
     public int getConnectTimeout() {
         return connectTimeout;
-- 
cgit v1.1


From ad66a888b2e48b1a185de1b3c73fd01383a1fd04 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Mon, 6 Aug 2012 10:47:32 -0700
Subject: Offer "J" in addition to "January" and "Jan".

The frameworks/base XML had out-of-date copies of this CLDR data, which
isn't accessible via SimpleDateFormat. Offer the strings direct from icu4c
so we can use them in frameworks/base.

Change-Id: If97dac05bcbb36542b209b19ae590e8b30aedb7b
---
 luni/src/main/java/libcore/icu/LocaleData.java     | 28 +++++----
 luni/src/main/native/libcore_icu_ICU.cpp           | 12 ++++
 luni/src/test/java/libcore/icu/LocaleDataTest.java | 68 ++++++++++++++++++++++
 3 files changed, 96 insertions(+), 12 deletions(-)
 create mode 100644 luni/src/test/java/libcore/icu/LocaleDataTest.java

diff --git a/luni/src/main/java/libcore/icu/LocaleData.java b/luni/src/main/java/libcore/icu/LocaleData.java
index cb9c880..d897b17 100644
--- a/luni/src/main/java/libcore/icu/LocaleData.java
+++ b/luni/src/main/java/libcore/icu/LocaleData.java
@@ -46,18 +46,22 @@ public final class LocaleData {
     public Integer minimalDaysInFirstWeek;
 
     // Used by DateFormatSymbols.
-    public String[] amPm;
-    public String[] eras;
-
-    public String[] longMonthNames;
-    public String[] shortMonthNames;
-    public String[] longStandAloneMonthNames;
-    public String[] shortStandAloneMonthNames;
-
-    public String[] longWeekdayNames;
-    public String[] shortWeekdayNames;
-    public String[] longStandAloneWeekdayNames;
-    public String[] shortStandAloneWeekdayNames;
+    public String[] amPm; // "AM", "PM".
+    public String[] eras; // "BC", "AD".
+
+    public String[] longMonthNames; // "January", ...
+    public String[] shortMonthNames; // "Jan", ...
+    public String[] tinyMonthNames; // "J", ...
+    public String[] longStandAloneMonthNames; // "January", ...
+    public String[] shortStandAloneMonthNames; // "Jan", ...
+    public String[] tinyStandAloneMonthNames; // "J", ...
+
+    public String[] longWeekdayNames; // "Sunday", ...
+    public String[] shortWeekdayNames; // "Sun", ...
+    public String[] tinyWeekdayNames; // "S", ...
+    public String[] longStandAloneWeekdayNames; // "Sunday", ...
+    public String[] shortStandAloneWeekdayNames; // "Sun", ...
+    public String[] tinyStandAloneWeekdayNames; // "S", ...
 
     public String fullTimeFormat;
     public String longTimeFormat;
diff --git a/luni/src/main/native/libcore_icu_ICU.cpp b/luni/src/main/native/libcore_icu_ICU.cpp
index 26e3e89..a4a02e6 100644
--- a/luni/src/main/native/libcore_icu_ICU.cpp
+++ b/luni/src/main/native/libcore_icu_ICU.cpp
@@ -446,12 +446,18 @@ static jboolean ICU_initLocaleDataImpl(JNIEnv* env, jclass, jstring locale, jobj
     const UnicodeString* shortMonthNames =
         dateFormatSym.getMonths(count, DateFormatSymbols::FORMAT, DateFormatSymbols::ABBREVIATED);
     setStringArrayField(env, localeData, "shortMonthNames", shortMonthNames, count);
+    const UnicodeString* tinyMonthNames =
+        dateFormatSym.getMonths(count, DateFormatSymbols::FORMAT, DateFormatSymbols::NARROW);
+    setStringArrayField(env, localeData, "tinyMonthNames", tinyMonthNames, count);
     const UnicodeString* longWeekdayNames =
         dateFormatSym.getWeekdays(count, DateFormatSymbols::FORMAT, DateFormatSymbols::WIDE);
     setStringArrayField(env, localeData, "longWeekdayNames", longWeekdayNames, count);
     const UnicodeString* shortWeekdayNames =
         dateFormatSym.getWeekdays(count, DateFormatSymbols::FORMAT, DateFormatSymbols::ABBREVIATED);
     setStringArrayField(env, localeData, "shortWeekdayNames", shortWeekdayNames, count);
+    const UnicodeString* tinyWeekdayNames =
+        dateFormatSym.getWeekdays(count, DateFormatSymbols::FORMAT, DateFormatSymbols::NARROW);
+    setStringArrayField(env, localeData, "tinyWeekdayNames", tinyWeekdayNames, count);
 
     const UnicodeString* longStandAloneMonthNames =
         dateFormatSym.getMonths(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::WIDE);
@@ -459,12 +465,18 @@ static jboolean ICU_initLocaleDataImpl(JNIEnv* env, jclass, jstring locale, jobj
     const UnicodeString* shortStandAloneMonthNames =
         dateFormatSym.getMonths(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::ABBREVIATED);
     setStringArrayField(env, localeData, "shortStandAloneMonthNames", shortStandAloneMonthNames, count);
+    const UnicodeString* tinyStandAloneMonthNames =
+        dateFormatSym.getMonths(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::NARROW);
+    setStringArrayField(env, localeData, "tinyStandAloneMonthNames", tinyStandAloneMonthNames, count);
     const UnicodeString* longStandAloneWeekdayNames =
         dateFormatSym.getWeekdays(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::WIDE);
     setStringArrayField(env, localeData, "longStandAloneWeekdayNames", longStandAloneWeekdayNames, count);
     const UnicodeString* shortStandAloneWeekdayNames =
         dateFormatSym.getWeekdays(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::ABBREVIATED);
     setStringArrayField(env, localeData, "shortStandAloneWeekdayNames", shortStandAloneWeekdayNames, count);
+    const UnicodeString* tinyStandAloneWeekdayNames =
+        dateFormatSym.getWeekdays(count, DateFormatSymbols::STANDALONE, DateFormatSymbols::NARROW);
+    setStringArrayField(env, localeData, "tinyStandAloneWeekdayNames", tinyStandAloneWeekdayNames, count);
 
     status = U_ZERO_ERROR;
 
diff --git a/luni/src/test/java/libcore/icu/LocaleDataTest.java b/luni/src/test/java/libcore/icu/LocaleDataTest.java
new file mode 100644
index 0000000..e712481
--- /dev/null
+++ b/luni/src/test/java/libcore/icu/LocaleDataTest.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed 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 libcore.icu;
+
+import java.util.Locale;
+
+public class LocaleDataTest extends junit.framework.TestCase {
+    public void test_en_US() throws Exception {
+        LocaleData l = LocaleData.get(Locale.US);
+        assertEquals("AM", l.amPm[0]);
+        assertEquals("BC", l.eras[0]);
+
+        assertEquals("January", l.longMonthNames[0]);
+        assertEquals("Jan", l.shortMonthNames[0]);
+        assertEquals("J", l.tinyMonthNames[0]);
+
+        assertEquals("January", l.longStandAloneMonthNames[0]);
+        assertEquals("Jan", l.shortStandAloneMonthNames[0]);
+        assertEquals("J", l.tinyStandAloneMonthNames[0]);
+
+        assertEquals("Sunday", l.longWeekdayNames[1]);
+        assertEquals("Sun", l.shortWeekdayNames[1]);
+        assertEquals("S", l.tinyWeekdayNames[1]);
+
+        assertEquals("Sunday", l.longStandAloneWeekdayNames[1]);
+        assertEquals("Sun", l.shortStandAloneWeekdayNames[1]);
+        assertEquals("S", l.tinyStandAloneWeekdayNames[1]);
+    }
+
+    public void test_cs_CZ() throws Exception {
+        LocaleData l = LocaleData.get(new Locale("cs", "CZ"));
+
+        assertEquals("ledna", l.longMonthNames[0]);
+        assertEquals("Led", l.shortMonthNames[0]);
+        assertEquals("1", l.tinyMonthNames[0]);
+
+        assertEquals("leden", l.longStandAloneMonthNames[0]);
+        assertEquals("1.", l.shortStandAloneMonthNames[0]);
+        assertEquals("l", l.tinyStandAloneMonthNames[0]);
+    }
+
+    public void test_ru_RU() throws Exception {
+        LocaleData l = LocaleData.get(new Locale("ru", "RU"));
+
+        assertEquals("воскресенье", l.longWeekdayNames[1]);
+        assertEquals("вс", l.shortWeekdayNames[1]);
+        assertEquals("В", l.tinyWeekdayNames[1]);
+
+        // Russian stand-alone weekday names get an initial capital.
+        assertEquals("Воскресенье", l.longStandAloneWeekdayNames[1]);
+        assertEquals("Вс", l.shortStandAloneWeekdayNames[1]);
+        assertEquals("В", l.tinyStandAloneWeekdayNames[1]);
+    }
+}
-- 
cgit v1.1


From 914e7c1a4c7fd45d7398f43cf28e5689d1422936 Mon Sep 17 00:00:00 2001
From: Kenny Root <kroot@google.com>
Date: Tue, 7 Aug 2012 15:35:21 -0700
Subject: Exit early from client_cert_cb when appropriate

Under error conditions, return -1 from client_cert_cb to cause the SSL
connection to exit early. If there is a pending Java exception that needs
to percolate up to the JVM, this should be brought up as soon as
possible.

Change-Id: Ifb3f908b027f80507ba549757f0cd6e1891d8bdd
---
 ...che_harmony_xnet_provider_jsse_NativeCrypto.cpp | 33 +++++++++++++---------
 1 file changed, 19 insertions(+), 14 deletions(-)

diff --git a/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp b/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
index 9f8ca6f..f41366c 100644
--- a/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
+++ b/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
@@ -1093,7 +1093,8 @@ static jint NativeCrypto_RSA_public_decrypt(JNIEnv* env, jclass, jint flen,
 
 static void NativeCrypto_RSA_padding_add_PKCS1_type_1(JNIEnv* env, jclass, jbyteArray toJavaBytes,
         jint tlen, jbyteArray fromJavaBytes, jint flen) {
-    JNI_TRACE("RSA_padding_add_PKCS1_type_1(%p, %d, %p, %d)", toJavaBytes, tlen, fJavaBytes, fl);
+    JNI_TRACE("RSA_padding_add_PKCS1_type_1(%p, %d, %p, %d)", toJavaBytes, tlen, fromJavaBytes,
+            flen);
 
     ScopedByteArrayRO from(env, fromJavaBytes);
     if (from.get() == NULL) {
@@ -1121,14 +1122,14 @@ static void NativeCrypto_RSA_padding_add_PKCS1_type_1(JNIEnv* env, jclass, jbyte
         return;
     }
 
-    JNI_TRACE("RSA_padding_add_PKCS1_type_1(%p, %d, %p, %d) => done", toJavaBytes, tlen, fJavaBytes,
-            fl);
+    JNI_TRACE("RSA_padding_add_PKCS1_type_1(%p, %d, %p, %d) => done", toJavaBytes, tlen,
+            fromJavaBytes, flen);
 }
 
 static jint NativeCrypto_RSA_padding_check_PKCS1_type_1(JNIEnv* env, jclass, jbyteArray toJavaBytes,
         jint tlen, jbyteArray fromJavaBytes, jint flen, jint rsa_len) {
-    JNI_TRACE("RSA_padding_add_PKCS1_type_1(%p, %d, %p, %d, %d)", toJavaBytes, tlen, fJavaBytes, fl,
-            rsa_len);
+    JNI_TRACE("RSA_padding_add_PKCS1_type_1(%p, %d, %p, %d, %d)", toJavaBytes, tlen, fromJavaBytes,
+            flen, rsa_len);
 
     ScopedByteArrayRW to(env, toJavaBytes);
     if (to.get() == NULL) {
@@ -1158,7 +1159,7 @@ static jint NativeCrypto_RSA_padding_check_PKCS1_type_1(JNIEnv* env, jclass, jby
     }
 
     JNI_TRACE("RSA_padding_check_PKCS1_type_1(%p, %d, %p, %d, %d) => %d", toJavaBytes, tlen,
-            fJavaBytes, fl, rsa_len, size);
+            fromJavaBytes, flen, rsa_len, size);
     return size;
 }
 
@@ -2534,11 +2535,19 @@ static void info_callback(const SSL* ssl, int where, int ret __attribute__ ((unu
 }
 
 /**
- * Call back to ask for a client certificate
+ * Call back to ask for a client certificate. There are three possible exit codes:
+ *
+ * 1 is success. x509Out and pkeyOut should point to the correct private key and certificate.
+ * 0 is unable to find key. x509Out and pkeyOut should be NULL.
+ * -1 is error and it doesn't matter what x509Out and pkeyOut are.
  */
 static int client_cert_cb(SSL* ssl, X509** x509Out, EVP_PKEY** pkeyOut) {
     JNI_TRACE("ssl=%p client_cert_cb x509Out=%p pkeyOut=%p", ssl, x509Out, pkeyOut);
 
+    /* Clear output of key and certificate in case of early exit due to error. */
+    *x509Out = NULL;
+    *pkeyOut = NULL;
+
     AppData* appData = toAppData(ssl);
     JNIEnv* env = appData->env;
     if (env == NULL) {
@@ -2548,7 +2557,7 @@ static int client_cert_cb(SSL* ssl, X509** x509Out, EVP_PKEY** pkeyOut) {
     }
     if (env->ExceptionCheck()) {
         JNI_TRACE("ssl=%p client_cert_cb already pending exception => 0", ssl);
-        return 0;
+        return -1;
     }
     jobject sslHandshakeCallbacks = appData->sslHandshakeCallbacks;
 
@@ -2595,21 +2604,17 @@ static int client_cert_cb(SSL* ssl, X509** x509Out, EVP_PKEY** pkeyOut) {
 
     if (env->ExceptionCheck()) {
         JNI_TRACE("ssl=%p client_cert_cb exception => 0", ssl);
-        return 0;
+        return -1;
     }
 
     // Check for values set from Java
     X509*     certificate = SSL_get_certificate(ssl);
     EVP_PKEY* privatekey  = SSL_get_privatekey(ssl);
-    int result;
+    int result = 0;
     if (certificate != NULL && privatekey != NULL) {
         *x509Out = certificate;
         *pkeyOut = privatekey;
         result = 1;
-    } else {
-        *x509Out = NULL;
-        *pkeyOut = NULL;
-        result = 0;
     }
     JNI_TRACE("ssl=%p client_cert_cb => *x509=%p *pkey=%p %d", ssl, *x509Out, *pkeyOut, result);
     return result;
-- 
cgit v1.1


From 3fb088d79e446063ef743362a030e1cfb80b2178 Mon Sep 17 00:00:00 2001
From: Kenny Root <kroot@google.com>
Date: Tue, 7 Aug 2012 11:36:02 -0700
Subject: Add chain building to TrustedCertificateStore

Since TrustedCertificateStore has information needed, use it to build
certificate chains.

OpenSSL uses Authority Key Identifier in extensions to determine if the
certificate is the same as itself. There are problems with key rotation
when a different certificate serial signs a key with the same subject
identifier. It appears to be the same with the old code, but it may
generate an invalid chain.

Change-Id: Ieaeacf535029c4d485944a8803a0ea8cff5b7b94
---
 .../security/x509/AuthorityKeyIdentifier.java      |  28 +++++
 .../security/x509/SubjectKeyIdentifier.java        |   7 ++
 .../provider/jsse/TrustedCertificateStore.java     | 117 ++++++++++++++++++++-
 .../provider/jsse/TrustedCertificateStoreTest.java |  11 ++
 4 files changed, 159 insertions(+), 4 deletions(-)

diff --git a/luni/src/main/java/org/apache/harmony/security/x509/AuthorityKeyIdentifier.java b/luni/src/main/java/org/apache/harmony/security/x509/AuthorityKeyIdentifier.java
index be43ba7..4afbb04 100644
--- a/luni/src/main/java/org/apache/harmony/security/x509/AuthorityKeyIdentifier.java
+++ b/luni/src/main/java/org/apache/harmony/security/x509/AuthorityKeyIdentifier.java
@@ -70,6 +70,34 @@ public final class AuthorityKeyIdentifier extends ExtensionValue {
         return aki;
     }
 
+    /**
+     * The key identifier for the authority.
+     *
+     * @return key identifier or {@code null}
+     */
+    public byte[] getKeyIdentifier() {
+        return keyIdentifier;
+    }
+
+    /**
+     * The GeneralNames for this authority key identifier.
+     *
+     * @return names for the authority certificate issuer or {@code null}
+     */
+    public GeneralNames getAuthorityCertIssuer() {
+        return authorityCertIssuer;
+    }
+
+    /**
+     * The serial number of the certificate identified by this authority key
+     * identifier.
+     *
+     * @return authority's certificate serial number or {@code null}
+     */
+    public BigInteger getAuthorityCertSerialNumber() {
+        return authorityCertSerialNumber;
+    }
+
     @Override public byte[] getEncoded() {
         if (encoding == null) {
             encoding = ASN1.encode(this);
diff --git a/luni/src/main/java/org/apache/harmony/security/x509/SubjectKeyIdentifier.java b/luni/src/main/java/org/apache/harmony/security/x509/SubjectKeyIdentifier.java
index 7415002..1db9598 100644
--- a/luni/src/main/java/org/apache/harmony/security/x509/SubjectKeyIdentifier.java
+++ b/luni/src/main/java/org/apache/harmony/security/x509/SubjectKeyIdentifier.java
@@ -58,6 +58,13 @@ public final class SubjectKeyIdentifier extends ExtensionValue {
         return res;
     }
 
+    /**
+     * The key identifier for this subject.
+     */
+    public byte[] getKeyIdentifier() {
+        return keyIdentifier;
+    }
+
     @Override public byte[] getEncoded() {
         if (encoding == null) {
             encoding = ASN1OctetString.getInstance().encode(keyIdentifier);
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/TrustedCertificateStore.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/TrustedCertificateStore.java
index 54116a7..abb6e55 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/TrustedCertificateStore.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/TrustedCertificateStore.java
@@ -16,6 +16,11 @@
 
 package org.apache.harmony.xnet.provider.jsse;
 
+import org.apache.harmony.security.x501.Name;
+import org.apache.harmony.security.x509.AuthorityKeyIdentifier;
+import org.apache.harmony.security.x509.GeneralName;
+import org.apache.harmony.security.x509.GeneralNames;
+import org.apache.harmony.security.x509.SubjectKeyIdentifier;
 import java.io.BufferedInputStream;
 import java.io.File;
 import java.io.FileInputStream;
@@ -23,19 +28,20 @@ import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
-import java.security.KeyStoreSpi;
-import java.security.PublicKey;
-import java.security.cert.CertSelector;
+import java.math.BigInteger;
 import java.security.cert.Certificate;
 import java.security.cert.CertificateException;
 import java.security.cert.CertificateFactory;
 import java.security.cert.X509Certificate;
-import java.util.Collections;
+import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Date;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Set;
 import javax.security.auth.x500.X500Principal;
 import libcore.io.IoUtils;
+import libcore.util.Objects;
 
 /**
  * A source for trusted root certificate authority (CA) certificates
@@ -366,6 +372,109 @@ public final class TrustedCertificateStore {
         return null;
     }
 
+    private static AuthorityKeyIdentifier getAuthorityKeyIdentifier(X509Certificate cert) {
+        final byte[] akidBytes = cert.getExtensionValue("2.5.29.35");
+        if (akidBytes == null) {
+            return null;
+        }
+
+        try {
+            return AuthorityKeyIdentifier.decode(akidBytes);
+        } catch (IOException e) {
+            return null;
+        }
+    }
+
+    private static SubjectKeyIdentifier getSubjectKeyIdentifier(X509Certificate cert) {
+        final byte[] skidBytes = cert.getExtensionValue("2.5.29.14");
+        if (skidBytes == null) {
+            return null;
+        }
+
+        try {
+            return SubjectKeyIdentifier.decode(skidBytes);
+        } catch (IOException e) {
+            return null;
+        }
+    }
+
+    private static boolean isSelfSignedCertificate(X509Certificate cert) {
+        if (!Objects.equal(cert.getSubjectX500Principal(), cert.getIssuerX500Principal())) {
+            return false;
+        }
+
+        final AuthorityKeyIdentifier akid = getAuthorityKeyIdentifier(cert);
+        if (akid != null) {
+            final byte[] akidKeyId = akid.getKeyIdentifier();
+            if (akidKeyId != null) {
+                final SubjectKeyIdentifier skid = getSubjectKeyIdentifier(cert);
+                if (!Arrays.equals(akidKeyId, skid.getKeyIdentifier())) {
+                    return false;
+                }
+            }
+
+            final BigInteger akidSerial = akid.getAuthorityCertSerialNumber();
+            if (akidSerial != null && !akidSerial.equals(cert.getSerialNumber())) {
+                return false;
+            }
+
+            final GeneralNames possibleIssuerNames = akid.getAuthorityCertIssuer();
+            if (possibleIssuerNames != null) {
+                GeneralName issuerName = null;
+
+                /* Get the first Directory Name (DN) to match how OpenSSL works. */
+                for (GeneralName possibleName : possibleIssuerNames.getNames()) {
+                    if (possibleName.getTag() == GeneralName.DIR_NAME) {
+                        issuerName = possibleName;
+                        break;
+                    }
+                }
+
+                if (issuerName != null) {
+                    final String issuerCanonical = ((Name) issuerName.getName())
+                            .getName(X500Principal.CANONICAL);
+
+                    try {
+                        final String subjectCanonical = new Name(cert.getSubjectX500Principal()
+                                .getEncoded()).getName(X500Principal.CANONICAL);
+                        if (!issuerCanonical.equals(subjectCanonical)) {
+                            return false;
+                        }
+                    } catch (IOException ignored) {
+                    }
+                }
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Attempt to build a certificate chain from the supplied {@code leaf}
+     * argument through the chain of issuers as high up as known. If the chain
+     * can't be completed, the most complete chain available will be returned.
+     * This means that a list with only the {@code leaf} certificate is returned
+     * if no issuer certificates could be found.
+     */
+    public List<X509Certificate> getCertificateChain(X509Certificate leaf) {
+        final List<X509Certificate> chain = new ArrayList<X509Certificate>();
+        chain.add(leaf);
+
+        for (int i = 0; true; i++) {
+            X509Certificate cert = chain.get(i);
+            if (isSelfSignedCertificate(cert)) {
+                break;
+            }
+            X509Certificate issuer = findIssuer(cert);
+            if (issuer == null) {
+                break;
+            }
+            chain.add(issuer);
+        }
+
+        return chain;
+    }
+
     // like java.security.cert.CertSelector but with X509Certificate and without cloning
     private static interface CertSelector {
         public boolean match(X509Certificate cert);
diff --git a/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/TrustedCertificateStoreTest.java b/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/TrustedCertificateStoreTest.java
index 6d0f50c..52880df 100644
--- a/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/TrustedCertificateStoreTest.java
+++ b/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/TrustedCertificateStoreTest.java
@@ -22,11 +22,13 @@ import java.io.OutputStream;
 import java.security.KeyStore;
 import java.security.PrivateKey;
 import java.security.PublicKey;
+import java.security.cert.Certificate;
 import java.security.cert.X509Certificate;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.Enumeration;
 import java.util.HashSet;
+import java.util.List;
 import java.util.NoSuchElementException;
 import java.util.Set;
 import javax.security.auth.x500.X500Principal;
@@ -411,6 +413,15 @@ public class TrustedCertificateStoreTest extends TestCase {
         assertAliases(alias1, alias2);
         assertEquals(getChain()[2], store.findIssuer(getChain()[1]));
         assertEquals(getChain()[1], store.findIssuer(getChain()[0]));
+
+        X509Certificate[] expected = getChain();
+        List<X509Certificate> actualList = store.getCertificateChain(expected[0]);
+
+        assertEquals("Generated CA list should be same length", expected.length, actualList.size());
+        for (int i = 0; i < expected.length; i++) {
+            assertEquals("Chain value should be the same for position " + i, expected[i],
+                    actualList.get(i));
+        }
         resetStore();
     }
 
-- 
cgit v1.1


From 5de66adb390e0885195b4f5caa3856a790abd087 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Wed, 8 Aug 2012 15:37:03 -0700
Subject: Make Charsets final.

Change-Id: I4a16ba53eda539059738f92a07b5563370ae2693
---
 luni/src/main/java/java/nio/charset/Charsets.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/luni/src/main/java/java/nio/charset/Charsets.java b/luni/src/main/java/java/nio/charset/Charsets.java
index 1c2425a..826b12a 100644
--- a/luni/src/main/java/java/nio/charset/Charsets.java
+++ b/luni/src/main/java/java/nio/charset/Charsets.java
@@ -25,7 +25,7 @@ package java.nio.charset;
  *
  * @hide internal use only
  */
-public class Charsets {
+public final class Charsets {
     /**
      * A cheap and type-safe constant for the ISO-8859-1 Charset.
      */
-- 
cgit v1.1


From 2d7d4072dbfe90e9da20106deb0c7ed6e8ed614b Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Wed, 8 Aug 2012 15:40:36 -0700
Subject: Fix the java.util.concurrent package documentation.

Android doesn't yet include Phaser.

Bug: http://code.google.com/p/android/issues/detail?id=36142
Change-Id: I237d8a2616550f809a34bab196de374b28e9273c
---
 luni/src/main/java/java/util/concurrent/package-info.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/luni/src/main/java/java/util/concurrent/package-info.java b/luni/src/main/java/java/util/concurrent/package-info.java
index 259b845..155d1b8 100644
--- a/luni/src/main/java/java/util/concurrent/package-info.java
+++ b/luni/src/main/java/java/util/concurrent/package-info.java
@@ -111,7 +111,7 @@
  *
  * <h2>Synchronizers</h2>
  *
- * Five classes aid common special-purpose synchronization idioms.
+ * Four classes aid common special-purpose synchronization idioms.
  * <ul>
  *
  * <li>{@link java.util.concurrent.Semaphore} is a classic concurrency tool.
-- 
cgit v1.1


From 83a7cea6ad5c5f066e55aeddd6da27d3ef5e62c1 Mon Sep 17 00:00:00 2001
From: Kenny Root <kroot@google.com>
Date: Tue, 7 Aug 2012 11:36:02 -0700
Subject: Add chain building to TrustedCertificateStore

Since TrustedCertificateStore has information needed, use it to build
certificate chains.

OpenSSL uses Authority Key Identifier in extensions to determine if the
certificate is the same as itself. There are problems with key rotation
when a different certificate serial signs a key with the same subject
identifier. It appears to be the same with the old code, but it may
generate an invalid chain.

(cherry-picked from 3fb088d79e446063ef743362a030e1cfb80b2178)

Change-Id: I8149bed1a0ae537f75da5dc3f3d7e3ccab353f91
---
 .../security/x509/AuthorityKeyIdentifier.java      |  28 +++++
 .../security/x509/SubjectKeyIdentifier.java        |   7 ++
 .../provider/jsse/TrustedCertificateStore.java     | 117 ++++++++++++++++++++-
 .../provider/jsse/TrustedCertificateStoreTest.java |  11 ++
 4 files changed, 159 insertions(+), 4 deletions(-)

diff --git a/luni/src/main/java/org/apache/harmony/security/x509/AuthorityKeyIdentifier.java b/luni/src/main/java/org/apache/harmony/security/x509/AuthorityKeyIdentifier.java
index be43ba7..4afbb04 100644
--- a/luni/src/main/java/org/apache/harmony/security/x509/AuthorityKeyIdentifier.java
+++ b/luni/src/main/java/org/apache/harmony/security/x509/AuthorityKeyIdentifier.java
@@ -70,6 +70,34 @@ public final class AuthorityKeyIdentifier extends ExtensionValue {
         return aki;
     }
 
+    /**
+     * The key identifier for the authority.
+     *
+     * @return key identifier or {@code null}
+     */
+    public byte[] getKeyIdentifier() {
+        return keyIdentifier;
+    }
+
+    /**
+     * The GeneralNames for this authority key identifier.
+     *
+     * @return names for the authority certificate issuer or {@code null}
+     */
+    public GeneralNames getAuthorityCertIssuer() {
+        return authorityCertIssuer;
+    }
+
+    /**
+     * The serial number of the certificate identified by this authority key
+     * identifier.
+     *
+     * @return authority's certificate serial number or {@code null}
+     */
+    public BigInteger getAuthorityCertSerialNumber() {
+        return authorityCertSerialNumber;
+    }
+
     @Override public byte[] getEncoded() {
         if (encoding == null) {
             encoding = ASN1.encode(this);
diff --git a/luni/src/main/java/org/apache/harmony/security/x509/SubjectKeyIdentifier.java b/luni/src/main/java/org/apache/harmony/security/x509/SubjectKeyIdentifier.java
index 7415002..1db9598 100644
--- a/luni/src/main/java/org/apache/harmony/security/x509/SubjectKeyIdentifier.java
+++ b/luni/src/main/java/org/apache/harmony/security/x509/SubjectKeyIdentifier.java
@@ -58,6 +58,13 @@ public final class SubjectKeyIdentifier extends ExtensionValue {
         return res;
     }
 
+    /**
+     * The key identifier for this subject.
+     */
+    public byte[] getKeyIdentifier() {
+        return keyIdentifier;
+    }
+
     @Override public byte[] getEncoded() {
         if (encoding == null) {
             encoding = ASN1OctetString.getInstance().encode(keyIdentifier);
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/TrustedCertificateStore.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/TrustedCertificateStore.java
index 54116a7..abb6e55 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/TrustedCertificateStore.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/TrustedCertificateStore.java
@@ -16,6 +16,11 @@
 
 package org.apache.harmony.xnet.provider.jsse;
 
+import org.apache.harmony.security.x501.Name;
+import org.apache.harmony.security.x509.AuthorityKeyIdentifier;
+import org.apache.harmony.security.x509.GeneralName;
+import org.apache.harmony.security.x509.GeneralNames;
+import org.apache.harmony.security.x509.SubjectKeyIdentifier;
 import java.io.BufferedInputStream;
 import java.io.File;
 import java.io.FileInputStream;
@@ -23,19 +28,20 @@ import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
-import java.security.KeyStoreSpi;
-import java.security.PublicKey;
-import java.security.cert.CertSelector;
+import java.math.BigInteger;
 import java.security.cert.Certificate;
 import java.security.cert.CertificateException;
 import java.security.cert.CertificateFactory;
 import java.security.cert.X509Certificate;
-import java.util.Collections;
+import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Date;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Set;
 import javax.security.auth.x500.X500Principal;
 import libcore.io.IoUtils;
+import libcore.util.Objects;
 
 /**
  * A source for trusted root certificate authority (CA) certificates
@@ -366,6 +372,109 @@ public final class TrustedCertificateStore {
         return null;
     }
 
+    private static AuthorityKeyIdentifier getAuthorityKeyIdentifier(X509Certificate cert) {
+        final byte[] akidBytes = cert.getExtensionValue("2.5.29.35");
+        if (akidBytes == null) {
+            return null;
+        }
+
+        try {
+            return AuthorityKeyIdentifier.decode(akidBytes);
+        } catch (IOException e) {
+            return null;
+        }
+    }
+
+    private static SubjectKeyIdentifier getSubjectKeyIdentifier(X509Certificate cert) {
+        final byte[] skidBytes = cert.getExtensionValue("2.5.29.14");
+        if (skidBytes == null) {
+            return null;
+        }
+
+        try {
+            return SubjectKeyIdentifier.decode(skidBytes);
+        } catch (IOException e) {
+            return null;
+        }
+    }
+
+    private static boolean isSelfSignedCertificate(X509Certificate cert) {
+        if (!Objects.equal(cert.getSubjectX500Principal(), cert.getIssuerX500Principal())) {
+            return false;
+        }
+
+        final AuthorityKeyIdentifier akid = getAuthorityKeyIdentifier(cert);
+        if (akid != null) {
+            final byte[] akidKeyId = akid.getKeyIdentifier();
+            if (akidKeyId != null) {
+                final SubjectKeyIdentifier skid = getSubjectKeyIdentifier(cert);
+                if (!Arrays.equals(akidKeyId, skid.getKeyIdentifier())) {
+                    return false;
+                }
+            }
+
+            final BigInteger akidSerial = akid.getAuthorityCertSerialNumber();
+            if (akidSerial != null && !akidSerial.equals(cert.getSerialNumber())) {
+                return false;
+            }
+
+            final GeneralNames possibleIssuerNames = akid.getAuthorityCertIssuer();
+            if (possibleIssuerNames != null) {
+                GeneralName issuerName = null;
+
+                /* Get the first Directory Name (DN) to match how OpenSSL works. */
+                for (GeneralName possibleName : possibleIssuerNames.getNames()) {
+                    if (possibleName.getTag() == GeneralName.DIR_NAME) {
+                        issuerName = possibleName;
+                        break;
+                    }
+                }
+
+                if (issuerName != null) {
+                    final String issuerCanonical = ((Name) issuerName.getName())
+                            .getName(X500Principal.CANONICAL);
+
+                    try {
+                        final String subjectCanonical = new Name(cert.getSubjectX500Principal()
+                                .getEncoded()).getName(X500Principal.CANONICAL);
+                        if (!issuerCanonical.equals(subjectCanonical)) {
+                            return false;
+                        }
+                    } catch (IOException ignored) {
+                    }
+                }
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * Attempt to build a certificate chain from the supplied {@code leaf}
+     * argument through the chain of issuers as high up as known. If the chain
+     * can't be completed, the most complete chain available will be returned.
+     * This means that a list with only the {@code leaf} certificate is returned
+     * if no issuer certificates could be found.
+     */
+    public List<X509Certificate> getCertificateChain(X509Certificate leaf) {
+        final List<X509Certificate> chain = new ArrayList<X509Certificate>();
+        chain.add(leaf);
+
+        for (int i = 0; true; i++) {
+            X509Certificate cert = chain.get(i);
+            if (isSelfSignedCertificate(cert)) {
+                break;
+            }
+            X509Certificate issuer = findIssuer(cert);
+            if (issuer == null) {
+                break;
+            }
+            chain.add(issuer);
+        }
+
+        return chain;
+    }
+
     // like java.security.cert.CertSelector but with X509Certificate and without cloning
     private static interface CertSelector {
         public boolean match(X509Certificate cert);
diff --git a/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/TrustedCertificateStoreTest.java b/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/TrustedCertificateStoreTest.java
index 6d0f50c..52880df 100644
--- a/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/TrustedCertificateStoreTest.java
+++ b/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/TrustedCertificateStoreTest.java
@@ -22,11 +22,13 @@ import java.io.OutputStream;
 import java.security.KeyStore;
 import java.security.PrivateKey;
 import java.security.PublicKey;
+import java.security.cert.Certificate;
 import java.security.cert.X509Certificate;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.Enumeration;
 import java.util.HashSet;
+import java.util.List;
 import java.util.NoSuchElementException;
 import java.util.Set;
 import javax.security.auth.x500.X500Principal;
@@ -411,6 +413,15 @@ public class TrustedCertificateStoreTest extends TestCase {
         assertAliases(alias1, alias2);
         assertEquals(getChain()[2], store.findIssuer(getChain()[1]));
         assertEquals(getChain()[1], store.findIssuer(getChain()[0]));
+
+        X509Certificate[] expected = getChain();
+        List<X509Certificate> actualList = store.getCertificateChain(expected[0]);
+
+        assertEquals("Generated CA list should be same length", expected.length, actualList.size());
+        for (int i = 0; i < expected.length; i++) {
+            assertEquals("Chain value should be the same for position " + i, expected[i],
+                    actualList.get(i));
+        }
         resetStore();
     }
 
-- 
cgit v1.1


From 694677f69b14ed61ca62473a04d52ac1659b8dd2 Mon Sep 17 00:00:00 2001
From: Kenny Root <kroot@google.com>
Date: Tue, 7 Aug 2012 15:35:21 -0700
Subject: Exit early from client_cert_cb when appropriate

Under error conditions, return -1 from client_cert_cb to cause the SSL
connection to exit early. If there is a pending Java exception that needs
to percolate up to the JVM, this should be brought up as soon as
possible.

(cherry-picked from 914e7c1a4c7fd45d7398f43cf28e5689d1422936)

Change-Id: Ie7b7865a8025e90b54ee16525e5856a6ca598d6d
---
 ...che_harmony_xnet_provider_jsse_NativeCrypto.cpp | 33 +++++++++++++---------
 1 file changed, 19 insertions(+), 14 deletions(-)

diff --git a/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp b/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
index 9f8ca6f..f41366c 100644
--- a/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
+++ b/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
@@ -1093,7 +1093,8 @@ static jint NativeCrypto_RSA_public_decrypt(JNIEnv* env, jclass, jint flen,
 
 static void NativeCrypto_RSA_padding_add_PKCS1_type_1(JNIEnv* env, jclass, jbyteArray toJavaBytes,
         jint tlen, jbyteArray fromJavaBytes, jint flen) {
-    JNI_TRACE("RSA_padding_add_PKCS1_type_1(%p, %d, %p, %d)", toJavaBytes, tlen, fJavaBytes, fl);
+    JNI_TRACE("RSA_padding_add_PKCS1_type_1(%p, %d, %p, %d)", toJavaBytes, tlen, fromJavaBytes,
+            flen);
 
     ScopedByteArrayRO from(env, fromJavaBytes);
     if (from.get() == NULL) {
@@ -1121,14 +1122,14 @@ static void NativeCrypto_RSA_padding_add_PKCS1_type_1(JNIEnv* env, jclass, jbyte
         return;
     }
 
-    JNI_TRACE("RSA_padding_add_PKCS1_type_1(%p, %d, %p, %d) => done", toJavaBytes, tlen, fJavaBytes,
-            fl);
+    JNI_TRACE("RSA_padding_add_PKCS1_type_1(%p, %d, %p, %d) => done", toJavaBytes, tlen,
+            fromJavaBytes, flen);
 }
 
 static jint NativeCrypto_RSA_padding_check_PKCS1_type_1(JNIEnv* env, jclass, jbyteArray toJavaBytes,
         jint tlen, jbyteArray fromJavaBytes, jint flen, jint rsa_len) {
-    JNI_TRACE("RSA_padding_add_PKCS1_type_1(%p, %d, %p, %d, %d)", toJavaBytes, tlen, fJavaBytes, fl,
-            rsa_len);
+    JNI_TRACE("RSA_padding_add_PKCS1_type_1(%p, %d, %p, %d, %d)", toJavaBytes, tlen, fromJavaBytes,
+            flen, rsa_len);
 
     ScopedByteArrayRW to(env, toJavaBytes);
     if (to.get() == NULL) {
@@ -1158,7 +1159,7 @@ static jint NativeCrypto_RSA_padding_check_PKCS1_type_1(JNIEnv* env, jclass, jby
     }
 
     JNI_TRACE("RSA_padding_check_PKCS1_type_1(%p, %d, %p, %d, %d) => %d", toJavaBytes, tlen,
-            fJavaBytes, fl, rsa_len, size);
+            fromJavaBytes, flen, rsa_len, size);
     return size;
 }
 
@@ -2534,11 +2535,19 @@ static void info_callback(const SSL* ssl, int where, int ret __attribute__ ((unu
 }
 
 /**
- * Call back to ask for a client certificate
+ * Call back to ask for a client certificate. There are three possible exit codes:
+ *
+ * 1 is success. x509Out and pkeyOut should point to the correct private key and certificate.
+ * 0 is unable to find key. x509Out and pkeyOut should be NULL.
+ * -1 is error and it doesn't matter what x509Out and pkeyOut are.
  */
 static int client_cert_cb(SSL* ssl, X509** x509Out, EVP_PKEY** pkeyOut) {
     JNI_TRACE("ssl=%p client_cert_cb x509Out=%p pkeyOut=%p", ssl, x509Out, pkeyOut);
 
+    /* Clear output of key and certificate in case of early exit due to error. */
+    *x509Out = NULL;
+    *pkeyOut = NULL;
+
     AppData* appData = toAppData(ssl);
     JNIEnv* env = appData->env;
     if (env == NULL) {
@@ -2548,7 +2557,7 @@ static int client_cert_cb(SSL* ssl, X509** x509Out, EVP_PKEY** pkeyOut) {
     }
     if (env->ExceptionCheck()) {
         JNI_TRACE("ssl=%p client_cert_cb already pending exception => 0", ssl);
-        return 0;
+        return -1;
     }
     jobject sslHandshakeCallbacks = appData->sslHandshakeCallbacks;
 
@@ -2595,21 +2604,17 @@ static int client_cert_cb(SSL* ssl, X509** x509Out, EVP_PKEY** pkeyOut) {
 
     if (env->ExceptionCheck()) {
         JNI_TRACE("ssl=%p client_cert_cb exception => 0", ssl);
-        return 0;
+        return -1;
     }
 
     // Check for values set from Java
     X509*     certificate = SSL_get_certificate(ssl);
     EVP_PKEY* privatekey  = SSL_get_privatekey(ssl);
-    int result;
+    int result = 0;
     if (certificate != NULL && privatekey != NULL) {
         *x509Out = certificate;
         *pkeyOut = privatekey;
         result = 1;
-    } else {
-        *x509Out = NULL;
-        *pkeyOut = NULL;
-        result = 0;
     }
     JNI_TRACE("ssl=%p client_cert_cb => *x509=%p *pkey=%p %d", ssl, *x509Out, *pkeyOut, result);
     return result;
-- 
cgit v1.1


From d762af619aa85042c08553425a4ca4ef7900d45a Mon Sep 17 00:00:00 2001
From: Kenny Root <kroot@google.com>
Date: Fri, 10 Aug 2012 14:55:57 -0700
Subject: Fix OpenSSLCipherRawRSA doFinal array copy

System.arraycopy was pointing the wrong way making calls to doFinal()
with offset markers get zeroed output instead of the actual output.

Also fix tests that checked RSA cipher behavior to match RI.

Bug: 6951038
Change-Id: Ife84c177a2c06a2c27b98df9960cbd3c4b62d984
---
 .../xnet/provider/jsse/OpenSSLCipherRawRSA.java    |  9 +++-
 .../test/java/libcore/javax/crypto/CipherTest.java | 58 ++++++++++++++++++++++
 .../tests/javax/crypto/func/CipherRSATest.java     |  3 --
 .../tests/javax/crypto/func/CipherRSAThread.java   |  6 ++-
 .../tests/javax/crypto/func/CipherThread.java      | 14 ++++++
 5 files changed, 85 insertions(+), 5 deletions(-)

diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLCipherRawRSA.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLCipherRawRSA.java
index 8312013..d0368fe 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLCipherRawRSA.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLCipherRawRSA.java
@@ -221,7 +221,14 @@ public class OpenSSLCipherRawRSA extends CipherSpi {
             int outputOffset) throws ShortBufferException, IllegalBlockSizeException,
             BadPaddingException {
         byte[] b = engineDoFinal(input, inputOffset, inputLen);
-        System.arraycopy(output, 0, b, outputOffset, b.length);
+
+        final int lastOffset = outputOffset + b.length;
+        if (lastOffset > output.length) {
+            throw new ShortBufferException("output buffer is too small " + output.length + " < "
+                    + lastOffset);
+        }
+
+        System.arraycopy(b, 0, output, outputOffset, b.length);
         return b.length;
     }
 }
diff --git a/luni/src/test/java/libcore/javax/crypto/CipherTest.java b/luni/src/test/java/libcore/javax/crypto/CipherTest.java
index a94a9d0..0a5ed36 100644
--- a/luni/src/test/java/libcore/javax/crypto/CipherTest.java
+++ b/luni/src/test/java/libcore/javax/crypto/CipherTest.java
@@ -567,6 +567,37 @@ public final class CipherTest extends TestCase {
                 Arrays.equals(RSA_Vector1_Encrypt_Private, encrypted));
     }
 
+    public void testRSA_ECB_NoPadding_Private_OnlyDoFinalWithOffset_Success() throws Exception {
+        KeyFactory kf = KeyFactory.getInstance("RSA");
+        RSAPrivateKeySpec keySpec = new RSAPrivateKeySpec(RSA_2048_modulus,
+                RSA_2048_privateExponent);
+        final PrivateKey privKey = kf.generatePrivate(keySpec);
+
+        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding");
+
+        /*
+         * You're actually decrypting with private keys, but there is no
+         * distinction made here. It's all keyed off of what kind of key you're
+         * using. ENCRYPT_MODE and DECRYPT_MODE are the same.
+         */
+        c.init(Cipher.ENCRYPT_MODE, privKey);
+        byte[] encrypted = new byte[RSA_Vector1_Encrypt_Private.length];
+        final int encryptLen = c
+                .doFinal(RSA_2048_Vector1, 0, RSA_2048_Vector1.length, encrypted, 0);
+        assertEquals("Encrypted size should match expected", RSA_Vector1_Encrypt_Private.length,
+                encryptLen);
+        assertTrue("Encrypted should match expected",
+                Arrays.equals(RSA_Vector1_Encrypt_Private, encrypted));
+
+        c.init(Cipher.DECRYPT_MODE, privKey);
+        final int decryptLen = c
+                .doFinal(RSA_2048_Vector1, 0, RSA_2048_Vector1.length, encrypted, 0);
+        assertEquals("Encrypted size should match expected", RSA_Vector1_Encrypt_Private.length,
+                decryptLen);
+        assertTrue("Encrypted should match expected",
+                Arrays.equals(RSA_Vector1_Encrypt_Private, encrypted));
+    }
+
     public void testRSA_ECB_NoPadding_Public_OnlyDoFinal_Success() throws Exception {
         KeyFactory kf = KeyFactory.getInstance("RSA");
         RSAPublicKeySpec keySpec = new RSAPublicKeySpec(RSA_2048_modulus, RSA_2048_publicExponent);
@@ -591,6 +622,33 @@ public final class CipherTest extends TestCase {
                 Arrays.equals(RSA_2048_Vector1, encrypted));
     }
 
+    public void testRSA_ECB_NoPadding_Public_OnlyDoFinalWithOffset_Success() throws Exception {
+        KeyFactory kf = KeyFactory.getInstance("RSA");
+        RSAPublicKeySpec keySpec = new RSAPublicKeySpec(RSA_2048_modulus, RSA_2048_publicExponent);
+
+        final PublicKey pubKey = kf.generatePublic(keySpec);
+
+        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding");
+
+        /*
+         * You're actually encrypting with public keys, but there is no
+         * distinction made here. It's all keyed off of what kind of key you're
+         * using. ENCRYPT_MODE and DECRYPT_MODE are the same.
+         */
+        c.init(Cipher.ENCRYPT_MODE, pubKey);
+        byte[] encrypted = new byte[RSA_2048_Vector1.length];
+        final int encryptLen = c.doFinal(RSA_Vector1_Encrypt_Private, 0,
+                RSA_Vector1_Encrypt_Private.length, encrypted, 0);
+        assertEquals("Encrypted size should match expected", RSA_2048_Vector1.length, encryptLen);
+        assertTrue("Encrypted should match expected", Arrays.equals(RSA_2048_Vector1, encrypted));
+
+        c.init(Cipher.DECRYPT_MODE, pubKey);
+        final int decryptLen = c.doFinal(RSA_Vector1_Encrypt_Private, 0,
+                RSA_Vector1_Encrypt_Private.length, encrypted, 0);
+        assertEquals("Encrypted size should match expected", RSA_2048_Vector1.length, decryptLen);
+        assertTrue("Encrypted should match expected", Arrays.equals(RSA_2048_Vector1, encrypted));
+    }
+
     public void testRSA_ECB_NoPadding_Public_UpdateThenEmptyDoFinal_Success() throws Exception {
         KeyFactory kf = KeyFactory.getInstance("RSA");
         RSAPublicKeySpec keySpec = new RSAPublicKeySpec(RSA_2048_modulus, RSA_2048_publicExponent);
diff --git a/luni/src/test/java/org/apache/harmony/crypto/tests/javax/crypto/func/CipherRSATest.java b/luni/src/test/java/org/apache/harmony/crypto/tests/javax/crypto/func/CipherRSATest.java
index d25d958..0e070f6 100644
--- a/luni/src/test/java/org/apache/harmony/crypto/tests/javax/crypto/func/CipherRSATest.java
+++ b/luni/src/test/java/org/apache/harmony/crypto/tests/javax/crypto/func/CipherRSATest.java
@@ -15,8 +15,6 @@
  */
 package org.apache.harmony.crypto.tests.javax.crypto.func;
 
-import dalvik.annotation.AndroidOnly;
-
 import junit.framework.TestCase;
 
 public class CipherRSATest extends TestCase {
@@ -55,7 +53,6 @@ public class CipherRSATest extends TestCase {
         assertEquals(rsa.getFailureMessages(), 0, rsa.getTotalFailuresNumber());
     }
 
-    @AndroidOnly("Fails on RI but succeeds on Android.")
     public void test_RSANoPadding() {
         CipherRSAThread rsa = new CipherRSAThread("RSA", new int[] {1024},
                 new String[] {"ECB"}, new String[] {"NOPADDING"});
diff --git a/luni/src/test/java/org/apache/harmony/crypto/tests/javax/crypto/func/CipherRSAThread.java b/luni/src/test/java/org/apache/harmony/crypto/tests/javax/crypto/func/CipherRSAThread.java
index f7445b1..31e1075 100644
--- a/luni/src/test/java/org/apache/harmony/crypto/tests/javax/crypto/func/CipherRSAThread.java
+++ b/luni/src/test/java/org/apache/harmony/crypto/tests/javax/crypto/func/CipherRSAThread.java
@@ -45,6 +45,10 @@ public class CipherRSAThread extends CipherThread {
         cip.init(Cipher.DECRYPT_MODE, kp.getPrivate());
         cip.doFinal(output, 0, outputSize, decrypted);
 
-        checkEncodedData(input, decrypted);
+        if ("NOPADDING".equals(getPadding())) {
+            checkPaddedEncodedData(input, decrypted, outputSize - input.length);
+        } else {
+            checkEncodedData(input, decrypted);
+        }
     }
 }
diff --git a/luni/src/test/java/org/apache/harmony/crypto/tests/javax/crypto/func/CipherThread.java b/luni/src/test/java/org/apache/harmony/crypto/tests/javax/crypto/func/CipherThread.java
index 4dac176..2fd388b 100644
--- a/luni/src/test/java/org/apache/harmony/crypto/tests/javax/crypto/func/CipherThread.java
+++ b/luni/src/test/java/org/apache/harmony/crypto/tests/javax/crypto/func/CipherThread.java
@@ -57,6 +57,20 @@ public abstract class CipherThread implements Runnable {
         }
     }
 
+    public void checkPaddedEncodedData(byte[] original, byte[] encoded, int offset)
+            throws Exception {
+        for (int i = 0; i < offset; i++) {
+            if (encoded[i] != 0) {
+                throw new Exception("Encoded data is not properly padded at offset " + i);
+            }
+        }
+        for (int i = 0; i < original.length; i++) {
+            if (original[i] != encoded[i + offset]) {
+                throw new Exception("Source and encoded data not match " + getCipherParameters());
+            }
+        }
+    }
+
     public void launcher() {
         Thread thread = null;
 
-- 
cgit v1.1


From 774294d74fe02e2b5040fcc2feb9f9d0913a4c77 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Tue, 14 Aug 2012 16:44:10 -0700
Subject: Add support for returning the CLDR "Yesterday", "Today", and
 "Tomorrow" strings.

This will let us remove a little more of the duplicate (and unmaintained)
CLDR data from frameworks/base.

Change-Id: Idbdb755e8469bb46e7597775ed2139c47de24b39
---
 luni/src/main/java/libcore/icu/LocaleData.java     |  5 +++++
 luni/src/main/native/libcore_icu_ICU.cpp           | 21 ++++++++++++++++++++-
 luni/src/test/java/libcore/icu/LocaleDataTest.java | 12 ++++++++++++
 3 files changed, 37 insertions(+), 1 deletion(-)

diff --git a/luni/src/main/java/libcore/icu/LocaleData.java b/luni/src/main/java/libcore/icu/LocaleData.java
index d897b17..97d5d30 100644
--- a/luni/src/main/java/libcore/icu/LocaleData.java
+++ b/luni/src/main/java/libcore/icu/LocaleData.java
@@ -63,6 +63,11 @@ public final class LocaleData {
     public String[] shortStandAloneWeekdayNames; // "Sun", ...
     public String[] tinyStandAloneWeekdayNames; // "S", ...
 
+    // Used by frameworks/base DateSorter and DateUtils.
+    public String yesterday; // "Yesterday".
+    public String today; // "Today".
+    public String tomorrow; // "Tomorrow".
+
     public String fullTimeFormat;
     public String longTimeFormat;
     public String mediumTimeFormat;
diff --git a/luni/src/main/native/libcore_icu_ICU.cpp b/luni/src/main/native/libcore_icu_ICU.cpp
index a4a02e6..2c3eb70 100644
--- a/luni/src/main/native/libcore_icu_ICU.cpp
+++ b/luni/src/main/native/libcore_icu_ICU.cpp
@@ -308,7 +308,18 @@ static void setStringField(JNIEnv* env, jobject obj, const char* fieldName, URes
     if (U_SUCCESS(status)) {
         setStringField(env, obj, fieldName, env->NewString(chars, charCount));
     } else {
-        ALOGE("Error setting String field %s from ICU resource: %s", fieldName, u_errorName(status));
+        ALOGE("Error setting String field %s from ICU resource (index %d): %s", fieldName, index, u_errorName(status));
+    }
+}
+
+static void setStringField(JNIEnv* env, jobject obj, const char* fieldName, UResourceBundle* bundle, const char* key) {
+    UErrorCode status = U_ZERO_ERROR;
+    int charCount;
+    const UChar* chars = ures_getStringByKey(bundle, key, &charCount, &status);
+    if (U_SUCCESS(status)) {
+        setStringField(env, obj, fieldName, env->NewString(chars, charCount));
+    } else {
+        ALOGE("Error setting String field %s from ICU resource (key %s): %s", fieldName, key, u_errorName(status));
     }
 }
 
@@ -407,6 +418,14 @@ static jboolean ICU_initLocaleDataImpl(JNIEnv* env, jclass, jstring locale, jobj
             setStringField(env, localeData, "longDateFormat", dateTimePatterns.get(), 5);
             setStringField(env, localeData, "mediumDateFormat", dateTimePatterns.get(), 6);
             setStringField(env, localeData, "shortDateFormat", dateTimePatterns.get(), 7);
+
+            // Get the "Yesterday", "Today", and "Tomorrow" strings.
+            ScopedResourceBundle fields(ures_getByKey(gregorian.get(), "fields", NULL, &status));
+            ScopedResourceBundle day(ures_getByKey(fields.get(), "day", NULL, &status));
+            ScopedResourceBundle relative(ures_getByKey(day.get(), "relative", NULL, &status));
+            setStringField(env, localeData, "yesterday", relative.get(), "-1");
+            setStringField(env, localeData, "today", relative.get(), "0");
+            setStringField(env, localeData, "tomorrow", relative.get(), "1");
             break;
         } else {
             status = U_ZERO_ERROR;  // get parent locale.
diff --git a/luni/src/test/java/libcore/icu/LocaleDataTest.java b/luni/src/test/java/libcore/icu/LocaleDataTest.java
index e712481..258b0c4 100644
--- a/luni/src/test/java/libcore/icu/LocaleDataTest.java
+++ b/luni/src/test/java/libcore/icu/LocaleDataTest.java
@@ -39,6 +39,18 @@ public class LocaleDataTest extends junit.framework.TestCase {
         assertEquals("Sunday", l.longStandAloneWeekdayNames[1]);
         assertEquals("Sun", l.shortStandAloneWeekdayNames[1]);
         assertEquals("S", l.tinyStandAloneWeekdayNames[1]);
+
+        assertEquals("Yesterday", l.yesterday);
+        assertEquals("Today", l.today);
+        assertEquals("Tomorrow", l.tomorrow);
+    }
+
+    public void test_de_DE() throws Exception {
+        LocaleData l = LocaleData.get(new Locale("de", "DE"));
+
+        assertEquals("Gestern", l.yesterday);
+        assertEquals("Heute", l.today);
+        assertEquals("Morgen", l.tomorrow);
     }
 
     public void test_cs_CZ() throws Exception {
-- 
cgit v1.1


From 73dc486a74a67ce375e3d90dcfaa6b5255b7c0da Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Tue, 14 Aug 2012 19:17:12 -0700
Subject: Revert "Add support for returning the CLDR "Yesterday", "Today", and
 "Tomorrow" strings."

This reverts commit 774294d74fe02e2b5040fcc2feb9f9d0913a4c77

This patch didn't work for locales that didn't explicitly specify values (and relied on fallback), and caused hard failures in those cases.

Change-Id: I7e3a45cc4d39317c8e523c2ee951c49e0aa8e811
---
 luni/src/main/java/libcore/icu/LocaleData.java     |  5 -----
 luni/src/main/native/libcore_icu_ICU.cpp           | 21 +--------------------
 luni/src/test/java/libcore/icu/LocaleDataTest.java | 12 ------------
 3 files changed, 1 insertion(+), 37 deletions(-)

diff --git a/luni/src/main/java/libcore/icu/LocaleData.java b/luni/src/main/java/libcore/icu/LocaleData.java
index 97d5d30..d897b17 100644
--- a/luni/src/main/java/libcore/icu/LocaleData.java
+++ b/luni/src/main/java/libcore/icu/LocaleData.java
@@ -63,11 +63,6 @@ public final class LocaleData {
     public String[] shortStandAloneWeekdayNames; // "Sun", ...
     public String[] tinyStandAloneWeekdayNames; // "S", ...
 
-    // Used by frameworks/base DateSorter and DateUtils.
-    public String yesterday; // "Yesterday".
-    public String today; // "Today".
-    public String tomorrow; // "Tomorrow".
-
     public String fullTimeFormat;
     public String longTimeFormat;
     public String mediumTimeFormat;
diff --git a/luni/src/main/native/libcore_icu_ICU.cpp b/luni/src/main/native/libcore_icu_ICU.cpp
index 2c3eb70..a4a02e6 100644
--- a/luni/src/main/native/libcore_icu_ICU.cpp
+++ b/luni/src/main/native/libcore_icu_ICU.cpp
@@ -308,18 +308,7 @@ static void setStringField(JNIEnv* env, jobject obj, const char* fieldName, URes
     if (U_SUCCESS(status)) {
         setStringField(env, obj, fieldName, env->NewString(chars, charCount));
     } else {
-        ALOGE("Error setting String field %s from ICU resource (index %d): %s", fieldName, index, u_errorName(status));
-    }
-}
-
-static void setStringField(JNIEnv* env, jobject obj, const char* fieldName, UResourceBundle* bundle, const char* key) {
-    UErrorCode status = U_ZERO_ERROR;
-    int charCount;
-    const UChar* chars = ures_getStringByKey(bundle, key, &charCount, &status);
-    if (U_SUCCESS(status)) {
-        setStringField(env, obj, fieldName, env->NewString(chars, charCount));
-    } else {
-        ALOGE("Error setting String field %s from ICU resource (key %s): %s", fieldName, key, u_errorName(status));
+        ALOGE("Error setting String field %s from ICU resource: %s", fieldName, u_errorName(status));
     }
 }
 
@@ -418,14 +407,6 @@ static jboolean ICU_initLocaleDataImpl(JNIEnv* env, jclass, jstring locale, jobj
             setStringField(env, localeData, "longDateFormat", dateTimePatterns.get(), 5);
             setStringField(env, localeData, "mediumDateFormat", dateTimePatterns.get(), 6);
             setStringField(env, localeData, "shortDateFormat", dateTimePatterns.get(), 7);
-
-            // Get the "Yesterday", "Today", and "Tomorrow" strings.
-            ScopedResourceBundle fields(ures_getByKey(gregorian.get(), "fields", NULL, &status));
-            ScopedResourceBundle day(ures_getByKey(fields.get(), "day", NULL, &status));
-            ScopedResourceBundle relative(ures_getByKey(day.get(), "relative", NULL, &status));
-            setStringField(env, localeData, "yesterday", relative.get(), "-1");
-            setStringField(env, localeData, "today", relative.get(), "0");
-            setStringField(env, localeData, "tomorrow", relative.get(), "1");
             break;
         } else {
             status = U_ZERO_ERROR;  // get parent locale.
diff --git a/luni/src/test/java/libcore/icu/LocaleDataTest.java b/luni/src/test/java/libcore/icu/LocaleDataTest.java
index 258b0c4..e712481 100644
--- a/luni/src/test/java/libcore/icu/LocaleDataTest.java
+++ b/luni/src/test/java/libcore/icu/LocaleDataTest.java
@@ -39,18 +39,6 @@ public class LocaleDataTest extends junit.framework.TestCase {
         assertEquals("Sunday", l.longStandAloneWeekdayNames[1]);
         assertEquals("Sun", l.shortStandAloneWeekdayNames[1]);
         assertEquals("S", l.tinyStandAloneWeekdayNames[1]);
-
-        assertEquals("Yesterday", l.yesterday);
-        assertEquals("Today", l.today);
-        assertEquals("Tomorrow", l.tomorrow);
-    }
-
-    public void test_de_DE() throws Exception {
-        LocaleData l = LocaleData.get(new Locale("de", "DE"));
-
-        assertEquals("Gestern", l.yesterday);
-        assertEquals("Heute", l.today);
-        assertEquals("Morgen", l.tomorrow);
     }
 
     public void test_cs_CZ() throws Exception {
-- 
cgit v1.1


From c4e0797a4dd028d23e788da15c3055f83f6f37d5 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Wed, 15 Aug 2012 09:27:14 -0700
Subject: Revert "Revert "Add support for returning the CLDR "Yesterday",
 "Today", and "Tomorrow" strings.""

This reverts commit 73dc486a74a67ce375e3d90dcfaa6b5255b7c0da

I've added code to handle falling back to parent locales to find relative
day names.

Change-Id: Iec2eebb62c0cbb5f6ce625365de514d80ddc05f7
---
 luni/src/main/java/libcore/icu/LocaleData.java     |   5 +
 luni/src/main/native/libcore_icu_ICU.cpp           | 254 +++++++++++++++------
 luni/src/test/java/libcore/icu/LocaleDataTest.java |  20 ++
 3 files changed, 207 insertions(+), 72 deletions(-)

diff --git a/luni/src/main/java/libcore/icu/LocaleData.java b/luni/src/main/java/libcore/icu/LocaleData.java
index d897b17..97d5d30 100644
--- a/luni/src/main/java/libcore/icu/LocaleData.java
+++ b/luni/src/main/java/libcore/icu/LocaleData.java
@@ -63,6 +63,11 @@ public final class LocaleData {
     public String[] shortStandAloneWeekdayNames; // "Sun", ...
     public String[] tinyStandAloneWeekdayNames; // "S", ...
 
+    // Used by frameworks/base DateSorter and DateUtils.
+    public String yesterday; // "Yesterday".
+    public String today; // "Today".
+    public String tomorrow; // "Tomorrow".
+
     public String fullTimeFormat;
     public String longTimeFormat;
     public String mediumTimeFormat;
diff --git a/luni/src/main/native/libcore_icu_ICU.cpp b/luni/src/main/native/libcore_icu_ICU.cpp
index a4a02e6..2131237 100644
--- a/luni/src/main/native/libcore_icu_ICU.cpp
+++ b/luni/src/main/native/libcore_icu_ICU.cpp
@@ -59,27 +59,37 @@
 #include <time.h>
 #include <unistd.h>
 
+// TODO: put this in a header file and use it everywhere!
+// DISALLOW_COPY_AND_ASSIGN disallows the copy and operator= functions.
+// It goes in the private: declarations in a class.
+#define DISALLOW_COPY_AND_ASSIGN(TypeName) \
+    TypeName(const TypeName&); \
+    void operator=(const TypeName&)
+
 class ScopedResourceBundle {
-public:
-    ScopedResourceBundle(UResourceBundle* bundle) : mBundle(bundle) {
-    }
+ public:
+  ScopedResourceBundle(UResourceBundle* bundle) : bundle_(bundle) {
+  }
 
-    ~ScopedResourceBundle() {
-        if (mBundle != NULL) {
-            ures_close(mBundle);
-        }
+  ~ScopedResourceBundle() {
+    if (bundle_ != NULL) {
+      ures_close(bundle_);
     }
+  }
 
-    UResourceBundle* get() {
-        return mBundle;
-    }
+  UResourceBundle* get() {
+    return bundle_;
+  }
 
-private:
-    UResourceBundle* mBundle;
+  bool hasKey(const char* key) {
+    UErrorCode status = U_ZERO_ERROR;
+    ures_getStringByKey(bundle_, key, NULL, &status);
+    return U_SUCCESS(status);
+  }
 
-    // Disallow copy and assignment.
-    ScopedResourceBundle(const ScopedResourceBundle&);
-    void operator=(const ScopedResourceBundle&);
+ private:
+  UResourceBundle* bundle_;
+  DISALLOW_COPY_AND_ASSIGN(ScopedResourceBundle);
 };
 
 Locale getLocale(JNIEnv* env, jstring localeName) {
@@ -302,14 +312,25 @@ static void setStringArrayField(JNIEnv* env, jobject obj, const char* fieldName,
 }
 
 static void setStringField(JNIEnv* env, jobject obj, const char* fieldName, UResourceBundle* bundle, int index) {
-    UErrorCode status = U_ZERO_ERROR;
-    int charCount;
-    const UChar* chars = ures_getStringByIndex(bundle, index, &charCount, &status);
-    if (U_SUCCESS(status)) {
-        setStringField(env, obj, fieldName, env->NewString(chars, charCount));
-    } else {
-        ALOGE("Error setting String field %s from ICU resource: %s", fieldName, u_errorName(status));
-    }
+  UErrorCode status = U_ZERO_ERROR;
+  int charCount;
+  const UChar* chars = ures_getStringByIndex(bundle, index, &charCount, &status);
+  if (U_SUCCESS(status)) {
+    setStringField(env, obj, fieldName, env->NewString(chars, charCount));
+  } else {
+    ALOGE("Error setting String field %s from ICU resource (index %d): %s", fieldName, index, u_errorName(status));
+  }
+}
+
+static void setStringField(JNIEnv* env, jobject obj, const char* fieldName, UResourceBundle* bundle, const char* key) {
+  UErrorCode status = U_ZERO_ERROR;
+  int charCount;
+  const UChar* chars = ures_getStringByKey(bundle, key, &charCount, &status);
+  if (U_SUCCESS(status)) {
+    setStringField(env, obj, fieldName, env->NewString(chars, charCount));
+  } else {
+    ALOGE("Error setting String field %s from ICU resource (key %s): %s", fieldName, key, u_errorName(status));
+  }
 }
 
 static void setCharField(JNIEnv* env, jobject obj, const char* fieldName, const UnicodeString& value) {
@@ -361,80 +382,169 @@ static void setDecimalFormatSymbolsData(JNIEnv* env, jobject obj, jstring locale
     setCharField(env, obj, "zeroDigit", dfs.getSymbol(DecimalFormatSymbols::kZeroDigitSymbol));
 }
 
+
+// Iterates up through the locale hierarchy. So "en_US" would return "en_US", "en", "".
+class LocaleNameIterator {
+ public:
+  LocaleNameIterator(const char* locale_name, UErrorCode& status) : status_(status), has_next_(true) {
+    strcpy(locale_name_, locale_name);
+    locale_name_length_ = strlen(locale_name_);
+  }
+
+  const char* Get() {
+      return locale_name_;
+  }
+
+  bool HasNext() {
+    return has_next_;
+  }
+
+  void Up() {
+    locale_name_length_ = uloc_getParent(locale_name_, locale_name_, sizeof(locale_name_), &status_);
+    if (locale_name_length_ == 0) {
+      has_next_ = false;
+    }
+  }
+
+ private:
+  UErrorCode& status_;
+  bool has_next_;
+  char locale_name_[ULOC_FULLNAME_CAPACITY];
+  int32_t locale_name_length_;
+
+  DISALLOW_COPY_AND_ASSIGN(LocaleNameIterator);
+};
+
+static bool getDateTimePatterns(JNIEnv* env, jobject localeData, const char* locale_name) {
+  UErrorCode status = U_ZERO_ERROR;
+  ScopedResourceBundle root(ures_open(NULL, locale_name, &status));
+  if (U_FAILURE(status)) {
+    return false;
+  }
+  ScopedResourceBundle calendar(ures_getByKey(root.get(), "calendar", NULL, &status));
+  if (U_FAILURE(status)) {
+    return false;
+  }
+  ScopedResourceBundle gregorian(ures_getByKey(calendar.get(), "gregorian", NULL, &status));
+  if (U_FAILURE(status)) {
+    return false;
+  }
+  ScopedResourceBundle dateTimePatterns(ures_getByKey(gregorian.get(), "DateTimePatterns", NULL, &status));
+  if (U_FAILURE(status)) {
+    return false;
+  }
+  setStringField(env, localeData, "fullTimeFormat", dateTimePatterns.get(), 0);
+  setStringField(env, localeData, "longTimeFormat", dateTimePatterns.get(), 1);
+  setStringField(env, localeData, "mediumTimeFormat", dateTimePatterns.get(), 2);
+  setStringField(env, localeData, "shortTimeFormat", dateTimePatterns.get(), 3);
+  setStringField(env, localeData, "fullDateFormat", dateTimePatterns.get(), 4);
+  setStringField(env, localeData, "longDateFormat", dateTimePatterns.get(), 5);
+  setStringField(env, localeData, "mediumDateFormat", dateTimePatterns.get(), 6);
+  setStringField(env, localeData, "shortDateFormat", dateTimePatterns.get(), 7);
+  return true;
+}
+
+static bool getYesterdayTodayAndTomorrow(JNIEnv* env, jobject localeData, const char* locale_name) {
+  UErrorCode status = U_ZERO_ERROR;
+  ScopedResourceBundle root(ures_open(NULL, locale_name, &status));
+  if (U_FAILURE(status)) {
+    return false;
+  }
+  ScopedResourceBundle calendar(ures_getByKey(root.get(), "calendar", NULL, &status));
+  if (U_FAILURE(status)) {
+    return false;
+  }
+  ScopedResourceBundle gregorian(ures_getByKey(calendar.get(), "gregorian", NULL, &status));
+  if (U_FAILURE(status)) {
+    return false;
+  }
+  ScopedResourceBundle fields(ures_getByKey(gregorian.get(), "fields", NULL, &status));
+  if (U_FAILURE(status)) {
+    return false;
+  }
+  ScopedResourceBundle day(ures_getByKey(fields.get(), "day", NULL, &status));
+  if (U_FAILURE(status)) {
+    return false;
+  }
+  ScopedResourceBundle relative(ures_getByKey(day.get(), "relative", NULL, &status));
+  if (U_FAILURE(status)) {
+    return false;
+  }
+  // bn_BD only has a "-2" entry.
+  if (relative.hasKey("-1") && relative.hasKey("0") && relative.hasKey("1")) {
+    setStringField(env, localeData, "yesterday", relative.get(), "-1");
+    setStringField(env, localeData, "today", relative.get(), "0");
+    setStringField(env, localeData, "tomorrow", relative.get(), "1");
+    return true;
+  }
+  return false;
+}
+
 static jboolean ICU_initLocaleDataImpl(JNIEnv* env, jclass, jstring locale, jobject localeData) {
     ScopedUtfChars localeName(env, locale);
     if (localeName.c_str() == NULL) {
         return JNI_FALSE;
     }
-
-    // Get DateTimePatterns
-    UErrorCode status;
-    char currentLocale[ULOC_FULLNAME_CAPACITY];
-    int32_t localeNameLen = 0;
     if (localeName.size() >= ULOC_FULLNAME_CAPACITY) {
-        return JNI_FALSE;  // Exceed ICU defined limit of the whole locale ID.
-    }
-    strcpy(currentLocale, localeName.c_str());
-    do {
-        status = U_ZERO_ERROR;
-        ScopedResourceBundle root(ures_open(NULL, currentLocale, &status));
-        if (U_FAILURE(status)) {
-            if (localeNameLen == 0) {
-                break;  // No parent locale, report this error outside the loop.
-            } else {
-                status = U_ZERO_ERROR;
-                continue;  // get parent locale.
-            }
-        }
-        ScopedResourceBundle calendar(ures_getByKey(root.get(), "calendar", NULL, &status));
-        if (U_FAILURE(status)) {
-            status = U_ZERO_ERROR;
-            continue;  // get parent locale.
-        }
+        return JNI_FALSE; // ICU has a fixed-length limit.
+    }
 
-        ScopedResourceBundle gregorian(ures_getByKey(calendar.get(), "gregorian", NULL, &status));
-        if (U_FAILURE(status)) {
-            status = U_ZERO_ERROR;
-            continue;  // get parent locale.
-        }
-        ScopedResourceBundle dateTimePatterns(ures_getByKey(gregorian.get(), "DateTimePatterns", NULL, &status));
-        if (U_SUCCESS(status)) {
-            setStringField(env, localeData, "fullTimeFormat", dateTimePatterns.get(), 0);
-            setStringField(env, localeData, "longTimeFormat", dateTimePatterns.get(), 1);
-            setStringField(env, localeData, "mediumTimeFormat", dateTimePatterns.get(), 2);
-            setStringField(env, localeData, "shortTimeFormat", dateTimePatterns.get(), 3);
-            setStringField(env, localeData, "fullDateFormat", dateTimePatterns.get(), 4);
-            setStringField(env, localeData, "longDateFormat", dateTimePatterns.get(), 5);
-            setStringField(env, localeData, "mediumDateFormat", dateTimePatterns.get(), 6);
-            setStringField(env, localeData, "shortDateFormat", dateTimePatterns.get(), 7);
-            break;
-        } else {
-            status = U_ZERO_ERROR;  // get parent locale.
-        }
-    } while((localeNameLen = uloc_getParent(currentLocale, currentLocale, sizeof(currentLocale), &status)) >= 0);
-    if (U_FAILURE(status)) {
-        ALOGE("Error getting ICU resource bundle: %s", u_errorName(status));
+    // Get the DateTimePatterns.
+    UErrorCode status = U_ZERO_ERROR;
+    bool foundDateTimePatterns = false;
+    for (LocaleNameIterator it(localeName.c_str(), status); it.HasNext(); it.Up()) {
+      if (getDateTimePatterns(env, localeData, it.Get())) {
+          foundDateTimePatterns = true;
+          break;
+      }
+    }
+    if (!foundDateTimePatterns) {
+        ALOGE("Couldn't find ICU DateTimePatterns for %s", localeName.c_str());
+        return JNI_FALSE;
+    }
+
+    // Get the "Yesterday", "Today", and "Tomorrow" strings.
+    bool foundYesterdayTodayAndTomorrow = false;
+    for (LocaleNameIterator it(localeName.c_str(), status); it.HasNext(); it.Up()) {
+      if (getYesterdayTodayAndTomorrow(env, localeData, it.Get())) {
+        foundYesterdayTodayAndTomorrow = true;
+        break;
+      }
+    }
+    if (!foundYesterdayTodayAndTomorrow) {
+      // Currently (Jelly Bean, ICU 4.8), the CLDR data for 'ps' and 'ps_AF' is missing these.
+      if (strcmp(localeName.c_str(), "ps") || strcmp(localeName.c_str(), "ps_AF")) {
+        // Deliberately use incorrect values so that anyone using 'ps' knows the CLDR is bad.
+        // (We have to include 'ps' because some of the 'ar' locales refer to it.)
+        ALOGW("Couldn't find ICU yesterday/today/tomorrow for %s; falling back", localeName.c_str());
+        setStringField(env, localeData, "yesterday", UnicodeString("Yesterday"));
+        setStringField(env, localeData, "today", UnicodeString("Today"));
+        setStringField(env, localeData, "tomorrow", UnicodeString("Tomorrow"));
+      } else {
+        ALOGE("Couldn't find ICU yesterday/today/tomorrow for %s", localeName.c_str());
         return JNI_FALSE;
+      }
     }
 
     status = U_ZERO_ERROR;
     Locale localeObj = getLocale(env, locale);
-
     UniquePtr<Calendar> cal(Calendar::createInstance(localeObj, status));
     if (U_FAILURE(status)) {
         return JNI_FALSE;
     }
+
     setIntegerField(env, localeData, "firstDayOfWeek", cal->getFirstDayOfWeek());
     setIntegerField(env, localeData, "minimalDaysInFirstWeek", cal->getMinimalDaysInFirstWeek());
 
-    // Get DateFormatSymbols
+    // Get DateFormatSymbols.
     status = U_ZERO_ERROR;
     DateFormatSymbols dateFormatSym(localeObj, status);
     if (U_FAILURE(status)) {
         return JNI_FALSE;
     }
+
+    // Get AM/PM and BC/AD.
     int32_t count = 0;
-    // Get AM/PM marker
     const UnicodeString* amPmStrs = dateFormatSym.getAmPmStrings(count);
     setStringArrayField(env, localeData, "amPm", amPmStrs, count);
     const UnicodeString* erasStrs = dateFormatSym.getEras(count);
diff --git a/luni/src/test/java/libcore/icu/LocaleDataTest.java b/luni/src/test/java/libcore/icu/LocaleDataTest.java
index e712481..e412a1d 100644
--- a/luni/src/test/java/libcore/icu/LocaleDataTest.java
+++ b/luni/src/test/java/libcore/icu/LocaleDataTest.java
@@ -19,6 +19,14 @@ package libcore.icu;
 import java.util.Locale;
 
 public class LocaleDataTest extends junit.framework.TestCase {
+    public void testAll() throws Exception {
+        // Test that we can get the locale data for all known locales.
+        for (Locale l : Locale.getAvailableLocales()) {
+            LocaleData d = LocaleData.get(l);
+            System.err.println(l + " : " + d.yesterday + " " + d.today + " " + d.tomorrow);
+        }
+    }
+
     public void test_en_US() throws Exception {
         LocaleData l = LocaleData.get(Locale.US);
         assertEquals("AM", l.amPm[0]);
@@ -39,6 +47,18 @@ public class LocaleDataTest extends junit.framework.TestCase {
         assertEquals("Sunday", l.longStandAloneWeekdayNames[1]);
         assertEquals("Sun", l.shortStandAloneWeekdayNames[1]);
         assertEquals("S", l.tinyStandAloneWeekdayNames[1]);
+
+        assertEquals("Yesterday", l.yesterday);
+        assertEquals("Today", l.today);
+        assertEquals("Tomorrow", l.tomorrow);
+    }
+
+    public void test_de_DE() throws Exception {
+        LocaleData l = LocaleData.get(new Locale("de", "DE"));
+
+        assertEquals("Gestern", l.yesterday);
+        assertEquals("Heute", l.today);
+        assertEquals("Morgen", l.tomorrow);
     }
 
     public void test_cs_CZ() throws Exception {
-- 
cgit v1.1


From 84818197ed60f59a86ba8d9274e1639d222f4040 Mon Sep 17 00:00:00 2001
From: Kenny Root <kroot@google.com>
Date: Wed, 15 Aug 2012 14:28:00 -0700
Subject: Do better comparisons for ENGINE-based keys

ENGINE-based keys need only be compared by their modulus in actuality,
because given a good random number generator each modulus should be
unique.

Change-Id: Iea1f19126c5ce306d63b3a1bcb05a43139a86846
---
 .../provider/jsse/OpenSSLRSAPrivateCrtKey.java     | 22 +++++++++++++++++-----
 .../xnet/provider/jsse/OpenSSLRSAPrivateKey.java   | 21 ++++++++++++++++-----
 2 files changed, 33 insertions(+), 10 deletions(-)

diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLRSAPrivateCrtKey.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLRSAPrivateCrtKey.java
index 8376515..48e1494 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLRSAPrivateCrtKey.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLRSAPrivateCrtKey.java
@@ -201,6 +201,16 @@ public class OpenSSLRSAPrivateCrtKey extends OpenSSLRSAPrivateKey implements RSA
             if (getOpenSSLKey().equals(other.getOpenSSLKey())) {
                 return true;
             }
+
+            /*
+             * If this key is ENGINE-based, it could be equivalent to another
+             * ENGINE-based key. The modulus may be equal, but that occurrence
+             * should be so improbably low as to never happen.
+             */
+            if (getOpenSSLKey().isEngineBased() || other.getOpenSSLKey().isEngineBased()) {
+                return publicExponent.equals(other.getPublicExponent())
+                        && getModulus().equals(other.getModulus());
+            }
         }
 
         if (o instanceof RSAPrivateCrtKey) {
@@ -232,11 +242,11 @@ public class OpenSSLRSAPrivateCrtKey extends OpenSSLRSAPrivateKey implements RSA
     public String toString() {
         final StringBuilder sb = new StringBuilder("OpenSSLRSAPrivateCrtKey{");
 
-        if (getOpenSSLKey().isEngineBased()) {
+        final boolean engineBased = getOpenSSLKey().isEngineBased();
+        if (engineBased) {
             sb.append("key=");
             sb.append(getOpenSSLKey());
             sb.append('}');
-            return sb.toString();
         }
 
         ensureReadParams();
@@ -250,9 +260,11 @@ public class OpenSSLRSAPrivateCrtKey extends OpenSSLRSAPrivateKey implements RSA
             sb.append(',');
         }
 
-        sb.append("privateExponent=");
-        sb.append(getPrivateExponent().toString(16));
-        sb.append(',');
+        if (!engineBased) {
+            sb.append("privateExponent=");
+            sb.append(getPrivateExponent().toString(16));
+            sb.append(',');
+        }
 
         if (primeP != null) {
             sb.append("primeP=");
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLRSAPrivateKey.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLRSAPrivateKey.java
index c9fa178..082bebd 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLRSAPrivateKey.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLRSAPrivateKey.java
@@ -196,6 +196,15 @@ public class OpenSSLRSAPrivateKey implements RSAPrivateKey {
             if (key.equals(other.getOpenSSLKey())) {
                 return true;
             }
+
+            /*
+             * If this key is ENGINE-based, it could be equivalent to another
+             * ENGINE-based key. The modulus may be equal, but that occurrence
+             * should be so improbably low as to never happen.
+             */
+            if (key.isEngineBased() || other.getOpenSSLKey().isEngineBased()) {
+                return modulus.equals(other.getModulus());
+            }
         }
 
         if (o instanceof RSAPrivateKey) {
@@ -226,11 +235,11 @@ public class OpenSSLRSAPrivateKey implements RSAPrivateKey {
     public String toString() {
         final StringBuilder sb = new StringBuilder("OpenSSLRSAPrivateKey{");
 
-        if (key.isEngineBased()) {
+        final boolean engineBased = key.isEngineBased();
+        if (engineBased) {
             sb.append("key=");
             sb.append(key);
             sb.append('}');
-            return sb.toString();
         }
 
         ensureReadParams();
@@ -238,9 +247,11 @@ public class OpenSSLRSAPrivateKey implements RSAPrivateKey {
         sb.append(modulus.toString(16));
         sb.append(',');
 
-        sb.append("privateExponent=");
-        sb.append(privateExponent.toString(16));
-        sb.append(',');
+        if (!engineBased) {
+            sb.append("privateExponent=");
+            sb.append(privateExponent.toString(16));
+            sb.append(',');
+        }
 
         return sb.toString();
     }
-- 
cgit v1.1


From 680b1e27caf10e3c41ec9f022054ab53d3a6bf7a Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Wed, 15 Aug 2012 16:49:05 -0700
Subject: Remove an obsolete hack for ps and ps_AF.

Made obsolete by external/icu4c change 6384944cabfb536f4ec5d584e26927405f150770.

Change-Id: Iefecb23ef87335e9f7f659f54dcdc3b36d5b4c62
---
 luni/src/main/native/libcore_icu_ICU.cpp | 14 ++------------
 1 file changed, 2 insertions(+), 12 deletions(-)

diff --git a/luni/src/main/native/libcore_icu_ICU.cpp b/luni/src/main/native/libcore_icu_ICU.cpp
index 2131237..5224420 100644
--- a/luni/src/main/native/libcore_icu_ICU.cpp
+++ b/luni/src/main/native/libcore_icu_ICU.cpp
@@ -512,18 +512,8 @@ static jboolean ICU_initLocaleDataImpl(JNIEnv* env, jclass, jstring locale, jobj
       }
     }
     if (!foundYesterdayTodayAndTomorrow) {
-      // Currently (Jelly Bean, ICU 4.8), the CLDR data for 'ps' and 'ps_AF' is missing these.
-      if (strcmp(localeName.c_str(), "ps") || strcmp(localeName.c_str(), "ps_AF")) {
-        // Deliberately use incorrect values so that anyone using 'ps' knows the CLDR is bad.
-        // (We have to include 'ps' because some of the 'ar' locales refer to it.)
-        ALOGW("Couldn't find ICU yesterday/today/tomorrow for %s; falling back", localeName.c_str());
-        setStringField(env, localeData, "yesterday", UnicodeString("Yesterday"));
-        setStringField(env, localeData, "today", UnicodeString("Today"));
-        setStringField(env, localeData, "tomorrow", UnicodeString("Tomorrow"));
-      } else {
-        ALOGE("Couldn't find ICU yesterday/today/tomorrow for %s", localeName.c_str());
-        return JNI_FALSE;
-      }
+      ALOGE("Couldn't find ICU yesterday/today/tomorrow for %s", localeName.c_str());
+      return JNI_FALSE;
     }
 
     status = U_ZERO_ERROR;
-- 
cgit v1.1


From 106a8928fb4249f2f3d4dba1dddbe73ca5cb3d61 Mon Sep 17 00:00:00 2001
From: Kenny Root <kroot@google.com>
Date: Wed, 15 Aug 2012 21:42:04 -0700
Subject: Call ENGINE_add to prevent ENGINEs from unloading

The only user of the OpenSSLEngine interface is a dynamic engine (loaded
from eng_dyn.c), so it will unload the .so when references to it
decrease to zero.

Calling ENGINE_add will add the loaded engine to the list of loaded
engines. The next time ENGINE_by_id is called, it will just use the one
from the list instead of loading the .so again.

You can still control whether the engine is ref-counted or copied with
ENGINE_set_flags(ret, ENGINE_FLAGS_BY_ID_COPY) in the engine
initialization method.

Change-Id: Ic005e9ea22a3c6027e3a5aab2adf41fb7995c1f0
---
 .../apache/harmony/xnet/provider/jsse/NativeCrypto.java   |  2 ++
 .../apache/harmony/xnet/provider/jsse/OpenSSLEngine.java  | 13 ++++++++++---
 ...org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp | 15 +++++++++++++++
 3 files changed, 27 insertions(+), 3 deletions(-)

diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/NativeCrypto.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/NativeCrypto.java
index 5fc4aef..4ba6c4b 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/NativeCrypto.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/NativeCrypto.java
@@ -52,6 +52,8 @@ public final class NativeCrypto {
 
     public static native int ENGINE_by_id(String id);
 
+    public static native int ENGINE_add(int e);
+
     public static native int ENGINE_init(int e);
 
     public static native int ENGINE_finish(int e);
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLEngine.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLEngine.java
index e91e6d8..83f0ff8 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLEngine.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLEngine.java
@@ -24,6 +24,8 @@ public class OpenSSLEngine {
         NativeCrypto.ENGINE_load_dynamic();
     }
 
+    private static final Object mLoadingLock = new Object();
+
     /** The ENGINE's native handle. */
     private final int ctx;
 
@@ -32,10 +34,14 @@ public class OpenSSLEngine {
             throw new NullPointerException("engine == null");
         }
 
-        final int engineCtx = NativeCrypto.ENGINE_by_id(engine);
+        final int engineCtx;
+        synchronized (mLoadingLock) {
+            engineCtx = NativeCrypto.ENGINE_by_id(engine);
+            if (engineCtx == 0) {
+                throw new IllegalArgumentException("Unknown ENGINE id: " + engine);
+            }
 
-        if (engineCtx == 0) {
-            throw new IllegalArgumentException("Unknown ENGINE id: " + engine);
+            NativeCrypto.ENGINE_add(engineCtx);
         }
 
         return new OpenSSLEngine(engineCtx);
@@ -45,6 +51,7 @@ public class OpenSSLEngine {
         ctx = engineCtx;
 
         if (NativeCrypto.ENGINE_init(engineCtx) == 0) {
+            NativeCrypto.ENGINE_free(engineCtx);
             throw new IllegalArgumentException("Could not initialize engine");
         }
     }
diff --git a/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp b/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
index f41366c..8e82ef0 100644
--- a/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
+++ b/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
@@ -577,6 +577,20 @@ static jint NativeCrypto_ENGINE_by_id(JNIEnv* env, jclass, jstring idJava) {
     return static_cast<jint>(reinterpret_cast<uintptr_t>(e));
 }
 
+static jint NativeCrypto_ENGINE_add(JNIEnv* env, jclass, jint engineRef) {
+    ENGINE* e = reinterpret_cast<ENGINE*>(static_cast<uintptr_t>(engineRef));
+    JNI_TRACE("ENGINE_add(%p)", e);
+
+    if (e == NULL) {
+        jniThrowException(env, "java/lang/IllegalArgumentException", "engineRef == 0");
+        return 0;
+    }
+
+    int ret = ENGINE_add(e);
+    JNI_TRACE("ENGINE_add(%p) => %d", e, ret);
+    return ret;
+}
+
 static jint NativeCrypto_ENGINE_init(JNIEnv* env, jclass, jint engineRef) {
     ENGINE* e = reinterpret_cast<ENGINE*>(static_cast<uintptr_t>(engineRef));
     JNI_TRACE("ENGINE_init(%p)", e);
@@ -4411,6 +4425,7 @@ static JNINativeMethod sNativeCryptoMethods[] = {
     NATIVE_METHOD(NativeCrypto, clinit, "()V"),
     NATIVE_METHOD(NativeCrypto, ENGINE_load_dynamic, "()V"),
     NATIVE_METHOD(NativeCrypto, ENGINE_by_id, "(Ljava/lang/String;)I"),
+    NATIVE_METHOD(NativeCrypto, ENGINE_add, "(I)I"),
     NATIVE_METHOD(NativeCrypto, ENGINE_init, "(I)I"),
     NATIVE_METHOD(NativeCrypto, ENGINE_finish, "(I)I"),
     NATIVE_METHOD(NativeCrypto, ENGINE_free, "(I)I"),
-- 
cgit v1.1


From 62fc526d80608925cad24c3d6d91657f63a56fcf Mon Sep 17 00:00:00 2001
From: Kenny Root <kroot@google.com>
Date: Wed, 15 Aug 2012 22:16:03 -0700
Subject: Add new Android-only algos to StandardNames

The ProviderTest fails if we don't add these to StandardNames.

Change the name of Signature.RAWRSA to "NONEwithRSA" so it matches the
convention in existing algorithms.

Change-Id: Id126eca46ee3b9f9d19aee596c1babd489693c7a
---
 .../java/org/apache/harmony/xnet/provider/jsse/OpenSSLProvider.java   | 3 +--
 support/src/test/java/libcore/java/security/StandardNames.java        | 4 ++++
 2 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLProvider.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLProvider.java
index e13ccda..126408f 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLProvider.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLProvider.java
@@ -109,8 +109,7 @@ public final class OpenSSLProvider extends Provider {
         put("Alg.Alias.Signature.DSAWithSHA1", "SHA1withDSA");
         put("Alg.Alias.Signature.1.2.840.10040.4.3", "SHA1withDSA");
 
-        put("Signature.RAWRSA", OpenSSLSignatureRawRSA.class.getName());
-        put("Alg.Alias.Signature.NONEwithRSA", "RAWRSA");
+        put("Signature.NONEwithRSA", OpenSSLSignatureRawRSA.class.getName());
 
         // SecureRandom
         /*
diff --git a/support/src/test/java/libcore/java/security/StandardNames.java b/support/src/test/java/libcore/java/security/StandardNames.java
index 6539e2c..8f427bf 100644
--- a/support/src/test/java/libcore/java/security/StandardNames.java
+++ b/support/src/test/java/libcore/java/security/StandardNames.java
@@ -334,6 +334,10 @@ public final class StandardNames extends Assert {
             unprovide("Signature", "SHA512WithRSA");
             provide("Signature", "SHA512WithRSAEncryption");
 
+            // Added to support Android KeyStore operations
+            provide("Signature", "NONEwithRSA");
+            provide("Cipher", "RSA/ECB/NOPADDING");
+
             // different names: JSSE Reference Guide says PKIX aka X509
             unprovide("TrustManagerFactory", "PKIX");
             provide("TrustManagerFactory", "X509");
-- 
cgit v1.1


From ac665275e161fab8ecd4225e73e159a9edf10501 Mon Sep 17 00:00:00 2001
From: Vladimir Marko <vmarko@google.com>
Date: Mon, 23 Jul 2012 18:48:49 +0100
Subject: Performance improvements: DiskLruCache, HttpResponseCache.

Add StrictLineReader for efficient reading of lines
consistent with Streams.readAsciiLine(). Use this to improve
DiskLruCache.readJournal() and initialization of
HttpResponseCache$Entry from InputStream.

(cherry-pick of e03b551079aae1204e505f1dc24f2b986ef82ec0.)

Bug: 6739304
Change-Id: If3083031f1368a9bbbd405c91553d7a205fd4e39
---
 luni/src/main/java/libcore/io/DiskLruCache.java    |  18 +-
 .../src/main/java/libcore/io/StrictLineReader.java | 241 +++++++++++++++++++++
 .../java/libcore/net/http/HttpResponseCache.java   |  43 ++--
 .../test/java/libcore/io/StrictLineReaderTest.java |  84 +++++++
 4 files changed, 351 insertions(+), 35 deletions(-)
 create mode 100644 luni/src/main/java/libcore/io/StrictLineReader.java
 create mode 100644 luni/src/test/java/libcore/io/StrictLineReaderTest.java

diff --git a/luni/src/main/java/libcore/io/DiskLruCache.java b/luni/src/main/java/libcore/io/DiskLruCache.java
index b7d246d..8338983 100644
--- a/luni/src/main/java/libcore/io/DiskLruCache.java
+++ b/luni/src/main/java/libcore/io/DiskLruCache.java
@@ -16,7 +16,6 @@
 
 package libcore.io;
 
-import java.io.BufferedInputStream;
 import java.io.BufferedWriter;
 import java.io.Closeable;
 import java.io.EOFException;
@@ -227,13 +226,14 @@ public final class DiskLruCache implements Closeable {
     }
 
     private void readJournal() throws IOException {
-        InputStream in = new BufferedInputStream(new FileInputStream(journalFile));
+        StrictLineReader reader = new StrictLineReader(new FileInputStream(journalFile),
+                Charsets.US_ASCII);
         try {
-            String magic = Streams.readAsciiLine(in);
-            String version = Streams.readAsciiLine(in);
-            String appVersionString = Streams.readAsciiLine(in);
-            String valueCountString = Streams.readAsciiLine(in);
-            String blank = Streams.readAsciiLine(in);
+            String magic = reader.readLine();
+            String version = reader.readLine();
+            String appVersionString = reader.readLine();
+            String valueCountString = reader.readLine();
+            String blank = reader.readLine();
             if (!MAGIC.equals(magic)
                     || !VERSION_1.equals(version)
                     || !Integer.toString(appVersion).equals(appVersionString)
@@ -245,13 +245,13 @@ public final class DiskLruCache implements Closeable {
 
             while (true) {
                 try {
-                    readJournalLine(Streams.readAsciiLine(in));
+                    readJournalLine(reader.readLine());
                 } catch (EOFException endOfJournal) {
                     break;
                 }
             }
         } finally {
-            IoUtils.closeQuietly(in);
+            IoUtils.closeQuietly(reader);
         }
     }
 
diff --git a/luni/src/main/java/libcore/io/StrictLineReader.java b/luni/src/main/java/libcore/io/StrictLineReader.java
new file mode 100644
index 0000000..5f8d452
--- /dev/null
+++ b/luni/src/main/java/libcore/io/StrictLineReader.java
@@ -0,0 +1,241 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed 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 libcore.io;
+
+import java.io.ByteArrayOutputStream;
+import java.io.Closeable;
+import java.io.EOFException;
+import java.io.InputStream;
+import java.io.IOException;
+import java.nio.charset.Charset;
+import java.nio.charset.Charsets;
+
+/**
+ * Buffers input from an {@link InputStream} for reading lines.
+ *
+ * This class is used for buffered reading of lines. For purposes of this class, a line ends with
+ * "\n" or "\r\n". End of input is reported by throwing {@code EOFException}. Unterminated line at
+ * end of input is invalid and will be ignored, the caller may use {@code hasUnterminatedLine()}
+ * to detect it after catching the {@code EOFException}.
+ *
+ * This class is intended for reading input that strictly consists of lines, such as line-based
+ * cache entries or cache journal. Unlike the {@link BufferedReader} which in conjunction with
+ * {@link InputStreamReader} provides similar functionality, this class uses different
+ * end-of-input reporting and a more restrictive definition of a line.
+ *
+ * This class supports only charsets that encode '\r' and '\n' as a single byte with value 13
+ * and 10, respectively, and the representation of no other character contains these values.
+ * We currently check in constructor that the charset is one of US-ASCII, UTF-8 and ISO-8859-1.
+ * The default charset is US_ASCII.
+ */
+public class StrictLineReader implements Closeable {
+    private static final byte CR = (byte)'\r';
+    private static final byte LF = (byte)'\n';
+
+    private final InputStream in;
+    private final Charset charset;
+
+    /*
+     * Buffered data is stored in {@code buf}. As long as no exception occurs, 0 <= pos <= end
+     * and the data in the range [pos, end) is buffered for reading. At end of input, if there is
+     * an unterminated line, we set end == -1, otherwise end == pos. If the underlying
+     * {@code InputStream} throws an {@code IOException}, end may remain as either pos or -1.
+     */
+    private byte[] buf;
+    private int pos;
+    private int end;
+
+    /**
+     * Constructs a new {@code StrictLineReader} with the default capacity and charset.
+     *
+     * @param in the {@code InputStream} to read data from.
+     * @throws NullPointerException if {@code in} is null.
+     */
+    public StrictLineReader(InputStream in) {
+        this(in, 8192);
+    }
+
+    /**
+     * Constructs a new {@code LineReader} with the specified capacity and the default charset.
+     *
+     * @param in the {@code InputStream} to read data from.
+     * @param capacity the capacity of the buffer.
+     * @throws NullPointerException if {@code in} is null.
+     * @throws IllegalArgumentException for negative or zero {@code capacity}.
+     */
+    public StrictLineReader(InputStream in, int capacity) {
+        this(in, capacity, Charsets.US_ASCII);
+    }
+
+    /**
+     * Constructs a new {@code LineReader} with the specified charset and the default capacity.
+     *
+     * @param in the {@code InputStream} to read data from.
+     * @param charset the charset used to decode data.
+     *         Only US-ASCII, UTF-8 and ISO-8859-1 is supported.
+     * @throws NullPointerException if {@code in} or {@code charset} is null.
+     * @throws IllegalArgumentException if the specified charset is not supported.
+     */
+    public StrictLineReader(InputStream in, Charset charset) {
+        this(in, 8192, charset);
+    }
+
+    /**
+     * Constructs a new {@code LineReader} with the specified capacity and charset.
+     *
+     * @param in the {@code InputStream} to read data from.
+     * @param capacity the capacity of the buffer.
+     * @param charset the charset used to decode data.
+     *         Only US-ASCII, UTF-8 and ISO-8859-1 is supported.
+     * @throws NullPointerException if {@code in} or {@code charset} is null.
+     * @throws IllegalArgumentException if {@code capacity} is negative or zero
+     *         or the specified charset is not supported.
+     */
+    public StrictLineReader(InputStream in, int capacity, Charset charset) {
+        if (in == null || charset == null) {
+            throw new NullPointerException();
+        }
+        if (capacity < 0) {
+            throw new IllegalArgumentException("capacity <= 0");
+        }
+        if (!(charset.equals(Charsets.US_ASCII) || charset.equals(Charsets.UTF_8) ||
+                charset.equals(Charsets.ISO_8859_1))) {
+            throw new IllegalArgumentException("Unsupported encoding");
+        }
+
+        this.in = in;
+        this.charset = charset;
+        buf = new byte[capacity];
+    }
+
+    /**
+     * Closes the reader by closing the underlying {@code InputStream} and
+     * marking this reader as closed.
+     *
+     * @throws IOException for errors when closing the underlying {@code InputStream}.
+     */
+    @Override
+    public void close() throws IOException {
+        synchronized (in) {
+            if (buf != null) {
+                buf = null;
+                in.close();
+            }
+        }
+    }
+
+    /**
+     * Reads the next line. A line ends with {@code "\n"} or {@code "\r\n"},
+     * this end of line marker is not included in the result.
+     *
+     * @return the next line from the input.
+     * @throws IOException for underlying {@code InputStream} errors.
+     * @throws EOFException for the end of source stream.
+     */
+    public String readLine() throws IOException {
+        synchronized (in) {
+            if (buf == null) {
+                throw new IOException("LineReader is closed");
+            }
+
+            // Read more data if we are at the end of the buffered data.
+            // Though it's an error to read after an exception, we will let {@code fillBuf()}
+            // throw again if that happens; thus we need to handle end == -1 as well as end == pos.
+            if (pos >= end) {
+                fillBuf();
+            }
+            // Try to find LF in the buffered data and return the line if successful.
+            for (int i = pos; i != end; ++i) {
+                if (buf[i] == LF) {
+                    int lineEnd = (i != pos && buf[i - 1] == CR) ? i - 1 : i;
+                    String res = new String(buf, pos, lineEnd - pos, charset);
+                    pos = i + 1;
+                    return res;
+                }
+            }
+
+            // Let's anticipate up to 80 characters on top of those already read.
+            ByteArrayOutputStream out = new ByteArrayOutputStream(end - pos + 80) {
+                @Override
+                public String toString() {
+                    int length = (count > 0 && buf[count - 1] == CR) ? count - 1 : count;
+                    return new String(buf, 0, length, charset);
+                }
+            };
+
+            while (true) {
+                out.write(buf, pos, end - pos);
+                // Mark unterminated line in case fillBuf throws EOFException or IOException.
+                end = -1;
+                fillBuf();
+                // Try to find LF in the buffered data and return the line if successful.
+                for (int i = pos; i != end; ++i) {
+                    if (buf[i] == LF) {
+                        if (i != pos) {
+                            out.write(buf, pos, i - pos);
+                        }
+                        pos = i + 1;
+                        return out.toString();
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Read an {@code int} from a line containing its decimal representation.
+     *
+     * @return the value of the {@code int} from the next line.
+     * @throws IOException for underlying {@code InputStream} errors or conversion error.
+     * @throws EOFException for the end of source stream.
+     */
+    public int readInt() throws IOException {
+        String intString = readLine();
+        try {
+            return Integer.parseInt(intString);
+        } catch (NumberFormatException e) {
+            throw new IOException("expected an int but was \"" + intString + "\"");
+        }
+    }
+
+    /**
+     * Check whether there was an unterminated line at end of input after the line reader reported
+     * end-of-input with EOFException. The value is meaningless in any other situation.
+     *
+     * @return true if there was an unterminated line at end of input.
+     */
+    public boolean hasUnterminatedLine() {
+        return end == -1;
+    }
+
+    /**
+     * Reads new input data into the buffer. Call only with pos == end or end == -1,
+     * depending on the desired outcome if the function throws.
+     *
+     * @throws IOException for underlying {@code InputStream} errors.
+     * @throws EOFException for the end of source stream.
+     */
+    private void fillBuf() throws IOException {
+        int result = in.read(buf, 0, buf.length);
+        if (result == -1) {
+            throw new EOFException();
+        }
+        pos = 0;
+        end = result;
+    }
+}
+
diff --git a/luni/src/main/java/libcore/net/http/HttpResponseCache.java b/luni/src/main/java/libcore/net/http/HttpResponseCache.java
index 2130fd1..1a9dfd1 100644
--- a/luni/src/main/java/libcore/net/http/HttpResponseCache.java
+++ b/luni/src/main/java/libcore/net/http/HttpResponseCache.java
@@ -16,7 +16,6 @@
 
 package libcore.net.http;
 
-import java.io.BufferedInputStream;
 import java.io.BufferedWriter;
 import java.io.ByteArrayInputStream;
 import java.io.File;
@@ -53,7 +52,7 @@ import javax.net.ssl.SSLPeerUnverifiedException;
 import libcore.io.Base64;
 import libcore.io.DiskLruCache;
 import libcore.io.IoUtils;
-import libcore.io.Streams;
+import libcore.io.StrictLineReader;
 
 /**
  * Cache responses in a directory on the file system. Most clients should use
@@ -100,7 +99,7 @@ public final class HttpResponseCache extends ResponseCache implements ExtendedRe
             if (snapshot == null) {
                 return null;
             }
-            entry = new Entry(new BufferedInputStream(snapshot.getInputStream(ENTRY_METADATA)));
+            entry = new Entry(snapshot.getInputStream(ENTRY_METADATA));
         } catch (IOException e) {
             // Give up because the cache cannot be read.
             return null;
@@ -369,29 +368,30 @@ public final class HttpResponseCache extends ResponseCache implements ExtendedRe
          */
         public Entry(InputStream in) throws IOException {
             try {
-                uri = Streams.readAsciiLine(in);
-                requestMethod = Streams.readAsciiLine(in);
+                StrictLineReader reader = new StrictLineReader(in, Charsets.US_ASCII);
+                uri = reader.readLine();
+                requestMethod = reader.readLine();
                 varyHeaders = new RawHeaders();
-                int varyRequestHeaderLineCount = readInt(in);
+                int varyRequestHeaderLineCount = reader.readInt();
                 for (int i = 0; i < varyRequestHeaderLineCount; i++) {
-                    varyHeaders.addLine(Streams.readAsciiLine(in));
+                    varyHeaders.addLine(reader.readLine());
                 }
 
                 responseHeaders = new RawHeaders();
-                responseHeaders.setStatusLine(Streams.readAsciiLine(in));
-                int responseHeaderLineCount = readInt(in);
+                responseHeaders.setStatusLine(reader.readLine());
+                int responseHeaderLineCount = reader.readInt();
                 for (int i = 0; i < responseHeaderLineCount; i++) {
-                    responseHeaders.addLine(Streams.readAsciiLine(in));
+                    responseHeaders.addLine(reader.readLine());
                 }
 
                 if (isHttps()) {
-                    String blank = Streams.readAsciiLine(in);
+                    String blank = reader.readLine();
                     if (!blank.isEmpty()) {
                         throw new IOException("expected \"\" but was \"" + blank + "\"");
                     }
-                    cipherSuite = Streams.readAsciiLine(in);
-                    peerCertificates = readCertArray(in);
-                    localCertificates = readCertArray(in);
+                    cipherSuite = reader.readLine();
+                    peerCertificates = readCertArray(reader);
+                    localCertificates = readCertArray(reader);
                 } else {
                     cipherSuite = null;
                     peerCertificates = null;
@@ -457,17 +457,8 @@ public final class HttpResponseCache extends ResponseCache implements ExtendedRe
             return uri.startsWith("https://");
         }
 
-        private int readInt(InputStream in) throws IOException {
-            String intString = Streams.readAsciiLine(in);
-            try {
-                return Integer.parseInt(intString);
-            } catch (NumberFormatException e) {
-                throw new IOException("expected an int but was \"" + intString + "\"");
-            }
-        }
-
-        private Certificate[] readCertArray(InputStream in) throws IOException {
-            int length = readInt(in);
+        private Certificate[] readCertArray(StrictLineReader reader) throws IOException {
+            int length = reader.readInt();
             if (length == -1) {
                 return null;
             }
@@ -475,7 +466,7 @@ public final class HttpResponseCache extends ResponseCache implements ExtendedRe
                 CertificateFactory certificateFactory = CertificateFactory.getInstance("X.509");
                 Certificate[] result = new Certificate[length];
                 for (int i = 0; i < result.length; i++) {
-                    String line = Streams.readAsciiLine(in);
+                    String line = reader.readLine();
                     byte[] bytes = Base64.decode(line.getBytes(Charsets.US_ASCII));
                     result[i] = certificateFactory.generateCertificate(
                             new ByteArrayInputStream(bytes));
diff --git a/luni/src/test/java/libcore/io/StrictLineReaderTest.java b/luni/src/test/java/libcore/io/StrictLineReaderTest.java
new file mode 100644
index 0000000..d5d3381
--- /dev/null
+++ b/luni/src/test/java/libcore/io/StrictLineReaderTest.java
@@ -0,0 +1,84 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed 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 libcore.io;
+
+import junit.framework.TestCase;
+
+import java.io.ByteArrayInputStream;
+import java.io.EOFException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStream;
+import java.nio.charset.Charsets;
+
+public class StrictLineReaderTest extends TestCase {
+
+    public void testLineReaderConsistencyWithReadAsciiLine () {
+        try {
+            // Testing with LineReader buffer capacity 32 to check some corner cases.
+            StrictLineReader lineReader = new StrictLineReader(createTestInputStream(), 32,
+                    Charsets.US_ASCII);
+            InputStream refStream = createTestInputStream();
+            while (true) {
+                try {
+                    String refLine = Streams.readAsciiLine(refStream);
+                    try {
+                        String line = lineReader.readLine();
+                        if (!refLine.equals(line)) {
+                            fail("line (\""+line+"\") differs from expected (\""+refLine+"\").");
+                        }
+                    } catch (EOFException eof) {
+                        fail("line reader threw EOFException too early.");
+                    }
+                } catch (EOFException refEof) {
+                    try {
+                        lineReader.readLine();
+                        fail("line reader didn't throw the expected EOFException.");
+                    } catch (EOFException eof) {
+                        // OK
+                        break;
+                    }
+                }
+            }
+            refStream.close();
+            lineReader.close();
+        } catch (IOException ioe) {
+            fail("Unexpected IOException " + ioe.toString());
+        }
+    }
+
+    private InputStream createTestInputStream() {
+        return new ByteArrayInputStream((
+                /* each source lines below should represent 32 bytes, until the next comment */
+                "12 byte line\n18 byte line......\n" +
+                "pad\nline spanning two 32-byte bu" +
+                "ffers\npad......................\n" +
+                "pad\nline spanning three 32-byte " +
+                "buffers and ending with LF at th" +
+                "e end of a 32 byte buffer......\n" +
+                "pad\nLine ending with CRLF split" +
+                " at the end of a 32-byte buffer\r" +
+                "\npad...........................\n" +
+                /* end of 32-byte lines */
+                "line ending with CRLF\r\n" +
+                "this is a long line with embedded CR \r ending with CRLF and having more than " +
+                "32 characters\r\n" +
+                "unterminated line - should be dropped"
+                ).getBytes());
+    }
+}
+
-- 
cgit v1.1


From d08422a25ada73815a0262d99ffae83cce980d40 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Thu, 16 Aug 2012 10:51:41 -0700
Subject: Fix test flakiness by not assuming we're in en_US.

Bug: 6410256
Bug: 6527877
Bug: 6971390
Change-Id: I585bb21a300876a83a6e61139e8a1cd04398788d
---
 .../java/libcore/java/text/OldDateFormatTest.java  |  4 +-
 .../libcore/java/text/SimpleDateFormatTest.java    | 12 +++---
 .../libcore/java/util/OldAndroidLocaleTest.java    | 45 ----------------------
 .../java/libcore/java/util/OldTimeZoneTest.java    | 13 +------
 4 files changed, 10 insertions(+), 64 deletions(-)

diff --git a/luni/src/test/java/libcore/java/text/OldDateFormatTest.java b/luni/src/test/java/libcore/java/text/OldDateFormatTest.java
index 6b3885c..df388d3 100644
--- a/luni/src/test/java/libcore/java/text/OldDateFormatTest.java
+++ b/luni/src/test/java/libcore/java/text/OldDateFormatTest.java
@@ -90,7 +90,7 @@ public class OldDateFormatTest extends junit.framework.TestCase {
                     DateFormat.SHORT, DateFormat.SHORT, Locale.US);
             Date current = new Date();
             String dtf = format.format(current);
-            SimpleDateFormat sdf = new SimpleDateFormat("M/d/yy h:mm a");
+            SimpleDateFormat sdf = new SimpleDateFormat("M/d/yy h:mm a", Locale.US);
             assertTrue("Incorrect date format", sdf.format(current).equals(dtf));
         } catch (Exception e) {
             fail("Unexpected exception " + e.toString());
@@ -110,7 +110,7 @@ public class OldDateFormatTest extends junit.framework.TestCase {
             StringBuffer toAppend = new StringBuffer();
             FieldPosition fp = new FieldPosition(DateFormat.YEAR_FIELD);
             StringBuffer sb = format.format(current, toAppend, fp);
-            SimpleDateFormat sdf = new SimpleDateFormat("M/d/yy h:mm a");
+            SimpleDateFormat sdf = new SimpleDateFormat("M/d/yy h:mm a", Locale.US);
             assertTrue("Incorrect date format", sdf.format(current).equals(
                     sb.toString()));
             assertTrue("Incorrect beginIndex of filed position", fp
diff --git a/luni/src/test/java/libcore/java/text/SimpleDateFormatTest.java b/luni/src/test/java/libcore/java/text/SimpleDateFormatTest.java
index c6296ff..4aabf2b 100644
--- a/luni/src/test/java/libcore/java/text/SimpleDateFormatTest.java
+++ b/luni/src/test/java/libcore/java/text/SimpleDateFormatTest.java
@@ -77,7 +77,7 @@ public class SimpleDateFormatTest extends junit.framework.TestCase {
     }
 
     public void test2038() {
-        SimpleDateFormat format = new SimpleDateFormat("EEE MMM dd HH:mm:ss yyyy");
+        SimpleDateFormat format = new SimpleDateFormat("EEE MMM dd HH:mm:ss yyyy", Locale.US);
         format.setTimeZone(TimeZone.getTimeZone("UTC"));
 
         assertEquals("Sun Nov 24 17:31:44 1833",
@@ -175,14 +175,14 @@ public class SimpleDateFormatTest extends junit.framework.TestCase {
      * longer use their DST zone but we should continue to parse it properly.
      */
     public void testObsoleteDstZoneName() throws Exception {
-        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm zzzz");
+        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm zzzz", Locale.US);
         Date normal = format.parse("1970-01-01T00:00 EET");
         Date dst = format.parse("1970-01-01T00:00 EEST");
         assertEquals(60 * 60 * 1000, normal.getTime() - dst.getTime());
     }
 
     public void testDstZoneNameWithNonDstTimestamp() throws Exception {
-        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm zzzz");
+        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm zzzz", Locale.US);
         Calendar calendar = new GregorianCalendar(AMERICA_LOS_ANGELES);
         calendar.setTime(format.parse("2011-06-21T10:00 Pacific Standard Time")); // 18:00 GMT-8
         assertEquals(11, calendar.get(Calendar.HOUR_OF_DAY)); // 18:00 GMT-7
@@ -190,7 +190,7 @@ public class SimpleDateFormatTest extends junit.framework.TestCase {
     }
 
     public void testNonDstZoneNameWithDstTimestamp() throws Exception {
-        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm zzzz");
+        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm zzzz", Locale.US);
         Calendar calendar = new GregorianCalendar(AMERICA_LOS_ANGELES);
         calendar.setTime(format.parse("2010-12-21T10:00 Pacific Daylight Time")); // 17:00 GMT-7
         assertEquals(9, calendar.get(Calendar.HOUR_OF_DAY)); // 17:00 GMT-8
@@ -199,7 +199,7 @@ public class SimpleDateFormatTest extends junit.framework.TestCase {
 
     // http://b/4723412
     public void testDstZoneWithNonDstTimestampForNonHourDstZone() throws Exception {
-        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm zzzz");
+        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm zzzz", Locale.US);
         Calendar calendar = new GregorianCalendar(AUSTRALIA_LORD_HOWE);
         calendar.setTime(format.parse("2011-06-21T20:00 Lord Howe Daylight Time")); // 9:00 GMT+11
         assertEquals(19, calendar.get(Calendar.HOUR_OF_DAY)); // 9:00 GMT+10:30
@@ -207,7 +207,7 @@ public class SimpleDateFormatTest extends junit.framework.TestCase {
     }
 
     public void testNonDstZoneWithDstTimestampForNonHourDstZone() throws Exception {
-        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm zzzz");
+        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm zzzz", Locale.US);
         Calendar calendar = new GregorianCalendar(AUSTRALIA_LORD_HOWE);
         calendar.setTime(format.parse("2010-12-21T19:30 Lord Howe Standard Time")); //9:00 GMT+10:30
         assertEquals(20, calendar.get(Calendar.HOUR_OF_DAY)); // 9:00 GMT+11:00
diff --git a/luni/src/test/java/libcore/java/util/OldAndroidLocaleTest.java b/luni/src/test/java/libcore/java/util/OldAndroidLocaleTest.java
index 547b70a..8fbe5ff 100644
--- a/luni/src/test/java/libcore/java/util/OldAndroidLocaleTest.java
+++ b/luni/src/test/java/libcore/java/util/OldAndroidLocaleTest.java
@@ -31,7 +31,6 @@ import junit.framework.TestCase;
  * resource bundles.
  */
 public class OldAndroidLocaleTest extends TestCase {
-
     // Test basic Locale infrastructure.
     public void testLocale() throws Exception {
         Locale locale = new Locale("en");
@@ -47,49 +46,6 @@ public class OldAndroidLocaleTest extends TestCase {
         assertEquals("en_US_POSIX", locale.toString());
     }
 
-    /*
-     * Tests some must-have locales. TODO: Add back "de". See discussion
-     * immediately below this method.
-     */
-    public void testResourceBundles() throws Exception {
-        Locale eng = new Locale("en", "US");
-        DateFormatSymbols engSymbols = new DateFormatSymbols(eng);
-
-        //Locale deu = new Locale("de", "DE");
-        //DateFormatSymbols deuSymbols = new DateFormatSymbols(deu);
-
-        TimeZone berlin = TimeZone.getTimeZone("Europe/Berlin");
-
-        assertEquals("January", engSymbols.getMonths()[0]);
-        //assertEquals("Januar", deuSymbols.getMonths()[0]);
-
-        assertEquals("Sunday", engSymbols.getWeekdays()[Calendar.SUNDAY]);
-        //assertEquals("Sonntag", deuSymbols.getWeekdays()[Calendar.SUNDAY]);
-
-        assertEquals("Central European Time",
-                berlin.getDisplayName(false, TimeZone.LONG, eng));
-        assertEquals("Central European Summer Time",
-                berlin.getDisplayName(true, TimeZone.LONG, eng));
-
-        //assertEquals("Mitteleurop\u00E4ische Zeit",
-        //        berlin.getDisplayName(false, TimeZone.LONG, deu));
-        //assertEquals("Mitteleurop\u00E4ische Sommerzeit",
-        //        berlin.getDisplayName(true, TimeZone.LONG, deu));
-
-        assertTrue(engSymbols.getZoneStrings().length > 100);
-    }
-
-    /*
-     * Disabled version of the above test. The version above omits
-     * checks for stuff in the "de" locale, because we stripped that
-     * out as part of the flash reduction effort (so that we could
-     * still ship on Dream). We expect to have a baseline target that
-     * includes a large enough system partition to include "de"
-     * immediately after the last official release for Dream (whenever
-     * that may be).
-     *
-    // Test some must-have locales.
-    @LargeTest
     public void testResourceBundles() throws Exception {
         Locale eng = new Locale("en", "US");
         DateFormatSymbols engSymbols = new DateFormatSymbols(eng);
@@ -117,7 +73,6 @@ public class OldAndroidLocaleTest extends TestCase {
 
         assertTrue(engSymbols.getZoneStrings().length > 100);
     }
-    */
 
     // This one makes sure we have all necessary locales installed.
     // Suppress this flaky test for now.
diff --git a/luni/src/test/java/libcore/java/util/OldTimeZoneTest.java b/luni/src/test/java/libcore/java/util/OldTimeZoneTest.java
index 240403e..4ed89de 100644
--- a/luni/src/test/java/libcore/java/util/OldTimeZoneTest.java
+++ b/luni/src/test/java/libcore/java/util/OldTimeZoneTest.java
@@ -83,6 +83,7 @@ public class OldTimeZoneTest extends TestCase {
     }
 
     public void test_getDisplayName() {
+        Locale.setDefault(Locale.US);
         TimeZone tz = TimeZone.getTimeZone("GMT-6");
         assertEquals("GMT-06:00", tz.getDisplayName());
         tz = TimeZone.getTimeZone("America/Los_Angeles");
@@ -99,6 +100,7 @@ public class OldTimeZoneTest extends TestCase {
     }
 
     public void test_getDisplayNameZI() {
+        Locale.setDefault(Locale.US);
         TimeZone tz = TimeZone.getTimeZone("America/Los_Angeles");
         assertEquals("PST",                   tz.getDisplayName(false, 0));
         assertEquals("Pacific Daylight Time", tz.getDisplayName(true, 1));
@@ -150,15 +152,4 @@ public class OldTimeZoneTest extends TestCase {
         tz.setID("New ID for GMT-6");
         assertEquals("New ID for GMT-6", tz.getID());
     }
-
-    Locale loc = null;
-
-    protected void setUp() {
-        loc = Locale.getDefault();
-        Locale.setDefault(Locale.US);
-    }
-
-    protected void tearDown() {
-        Locale.setDefault(loc);
-    }
 }
-- 
cgit v1.1


From 44f7875f2985d7944c5afecc8394ad9f2219c806 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Thu, 16 Aug 2012 12:29:52 -0700
Subject: Add chown, fchmod, fchown, lchown, and umask.

Bug: 6141031
Bug: 3107501
Change-Id: I3f514f615b397f57340066f26d43320fb3c219fa
---
 luni/src/main/java/libcore/io/ForwardingOs.java |  5 ++++
 luni/src/main/java/libcore/io/Os.java           |  5 ++++
 luni/src/main/java/libcore/io/Posix.java        |  5 ++++
 luni/src/main/native/libcore_io_Posix.cpp       | 35 +++++++++++++++++++++++++
 4 files changed, 50 insertions(+)

diff --git a/luni/src/main/java/libcore/io/ForwardingOs.java b/luni/src/main/java/libcore/io/ForwardingOs.java
index 39b9861..20b85d7 100644
--- a/luni/src/main/java/libcore/io/ForwardingOs.java
+++ b/luni/src/main/java/libcore/io/ForwardingOs.java
@@ -39,11 +39,14 @@ public class ForwardingOs implements Os {
     public boolean access(String path, int mode) throws ErrnoException { return os.access(path, mode); }
     public void bind(FileDescriptor fd, InetAddress address, int port) throws ErrnoException, SocketException { os.bind(fd, address, port); }
     public void chmod(String path, int mode) throws ErrnoException { os.chmod(path, mode); }
+    public void chown(String path, int uid, int gid) throws ErrnoException { os.chown(path, uid, gid); }
     public void close(FileDescriptor fd) throws ErrnoException { os.close(fd); }
     public void connect(FileDescriptor fd, InetAddress address, int port) throws ErrnoException, SocketException { os.connect(fd, address, port); }
     public FileDescriptor dup(FileDescriptor oldFd) throws ErrnoException { return os.dup(oldFd); }
     public FileDescriptor dup2(FileDescriptor oldFd, int newFd) throws ErrnoException { return os.dup2(oldFd, newFd); }
     public String[] environ() { return os.environ(); }
+    public void fchmod(FileDescriptor fd, int mode) throws ErrnoException { os.fchmod(fd, mode); }
+    public void fchown(FileDescriptor fd, int uid, int gid) throws ErrnoException { os.fchown(fd, uid, gid); }
     public int fcntlVoid(FileDescriptor fd, int cmd) throws ErrnoException { return os.fcntlVoid(fd, cmd); }
     public int fcntlLong(FileDescriptor fd, int cmd, long arg) throws ErrnoException { return os.fcntlLong(fd, cmd, arg); }
     public int fcntlFlock(FileDescriptor fd, int cmd, StructFlock arg) throws ErrnoException { return os.fcntlFlock(fd, cmd, arg); }
@@ -76,6 +79,7 @@ public class ForwardingOs implements Os {
     public int ioctlInt(FileDescriptor fd, int cmd, MutableInt arg) throws ErrnoException { return os.ioctlInt(fd, cmd, arg); }
     public boolean isatty(FileDescriptor fd) { return os.isatty(fd); }
     public void kill(int pid, int signal) throws ErrnoException { os.kill(pid, signal); }
+    public void lchown(String path, int uid, int gid) throws ErrnoException { os.lchown(path, uid, gid); }
     public void listen(FileDescriptor fd, int backlog) throws ErrnoException { os.listen(fd, backlog); }
     public long lseek(FileDescriptor fd, long offset, int whence) throws ErrnoException { return os.lseek(fd, offset, whence); }
     public StructStat lstat(String path) throws ErrnoException { return os.lstat(path); }
@@ -121,6 +125,7 @@ public class ForwardingOs implements Os {
     public String strerror(int errno) { return os.strerror(errno); }
     public void symlink(String oldPath, String newPath) throws ErrnoException { os.symlink(oldPath, newPath); }
     public long sysconf(int name) { return os.sysconf(name); }
+    public int umask(int mask) { return os.umask(mask); }
     public StructUtsname uname() { return os.uname(); }
     public int waitpid(int pid, MutableInt status, int options) throws ErrnoException { return os.waitpid(pid, status, options); }
     public int write(FileDescriptor fd, ByteBuffer buffer) throws ErrnoException { return os.write(fd, buffer); }
diff --git a/luni/src/main/java/libcore/io/Os.java b/luni/src/main/java/libcore/io/Os.java
index 5fdc7be..f4eaaaf 100644
--- a/luni/src/main/java/libcore/io/Os.java
+++ b/luni/src/main/java/libcore/io/Os.java
@@ -30,11 +30,14 @@ public interface Os {
     public boolean access(String path, int mode) throws ErrnoException;
     public void bind(FileDescriptor fd, InetAddress address, int port) throws ErrnoException, SocketException;
     public void chmod(String path, int mode) throws ErrnoException;
+    public void chown(String path, int uid, int gid) throws ErrnoException;
     public void close(FileDescriptor fd) throws ErrnoException;
     public void connect(FileDescriptor fd, InetAddress address, int port) throws ErrnoException, SocketException;
     public FileDescriptor dup(FileDescriptor oldFd) throws ErrnoException;
     public FileDescriptor dup2(FileDescriptor oldFd, int newFd) throws ErrnoException;
     public String[] environ();
+    public void fchmod(FileDescriptor fd, int mode) throws ErrnoException;
+    public void fchown(FileDescriptor fd, int uid, int gid) throws ErrnoException;
     public int fcntlVoid(FileDescriptor fd, int cmd) throws ErrnoException;
     public int fcntlLong(FileDescriptor fd, int cmd, long arg) throws ErrnoException;
     public int fcntlFlock(FileDescriptor fd, int cmd, StructFlock arg) throws ErrnoException;
@@ -68,6 +71,7 @@ public interface Os {
     public int ioctlInt(FileDescriptor fd, int cmd, MutableInt arg) throws ErrnoException;
     public boolean isatty(FileDescriptor fd);
     public void kill(int pid, int signal) throws ErrnoException;
+    public void lchown(String path, int uid, int gid) throws ErrnoException;
     public void listen(FileDescriptor fd, int backlog) throws ErrnoException;
     public long lseek(FileDescriptor fd, long offset, int whence) throws ErrnoException;
     public StructStat lstat(String path) throws ErrnoException;
@@ -115,6 +119,7 @@ public interface Os {
     public String strerror(int errno);
     public void symlink(String oldPath, String newPath) throws ErrnoException;
     public long sysconf(int name);
+    public int umask(int mask);
     public StructUtsname uname();
     public int waitpid(int pid, MutableInt status, int options) throws ErrnoException;
     public int write(FileDescriptor fd, ByteBuffer buffer) throws ErrnoException;
diff --git a/luni/src/main/java/libcore/io/Posix.java b/luni/src/main/java/libcore/io/Posix.java
index 0fc9f38..ec3f3e2 100644
--- a/luni/src/main/java/libcore/io/Posix.java
+++ b/luni/src/main/java/libcore/io/Posix.java
@@ -33,11 +33,14 @@ public final class Posix implements Os {
     public native boolean access(String path, int mode) throws ErrnoException;
     public native void bind(FileDescriptor fd, InetAddress address, int port) throws ErrnoException, SocketException;
     public native void chmod(String path, int mode) throws ErrnoException;
+    public native void chown(String path, int uid, int gid) throws ErrnoException;
     public native void close(FileDescriptor fd) throws ErrnoException;
     public native void connect(FileDescriptor fd, InetAddress address, int port) throws ErrnoException, SocketException;
     public native FileDescriptor dup(FileDescriptor oldFd) throws ErrnoException;
     public native FileDescriptor dup2(FileDescriptor oldFd, int newFd) throws ErrnoException;
     public native String[] environ();
+    public native void fchmod(FileDescriptor fd, int mode) throws ErrnoException;
+    public native void fchown(FileDescriptor fd, int uid, int gid) throws ErrnoException;
     public native int fcntlVoid(FileDescriptor fd, int cmd) throws ErrnoException;
     public native int fcntlLong(FileDescriptor fd, int cmd, long arg) throws ErrnoException;
     public native int fcntlFlock(FileDescriptor fd, int cmd, StructFlock arg) throws ErrnoException;
@@ -70,6 +73,7 @@ public final class Posix implements Os {
     public native int ioctlInt(FileDescriptor fd, int cmd, MutableInt arg) throws ErrnoException;
     public native boolean isatty(FileDescriptor fd);
     public native void kill(int pid, int signal) throws ErrnoException;
+    public native void lchown(String path, int uid, int gid) throws ErrnoException;
     public native void listen(FileDescriptor fd, int backlog) throws ErrnoException;
     public native long lseek(FileDescriptor fd, long offset, int whence) throws ErrnoException;
     public native StructStat lstat(String path) throws ErrnoException;
@@ -165,6 +169,7 @@ public final class Posix implements Os {
     public native String strerror(int errno);
     public native void symlink(String oldPath, String newPath) throws ErrnoException;
     public native long sysconf(int name);
+    public native int umask(int mask);
     public native StructUtsname uname();
     public native int waitpid(int pid, MutableInt status, int options) throws ErrnoException;
     public int write(FileDescriptor fd, ByteBuffer buffer) throws ErrnoException {
diff --git a/luni/src/main/native/libcore_io_Posix.cpp b/luni/src/main/native/libcore_io_Posix.cpp
index 5a3382a..64121d6 100644
--- a/luni/src/main/native/libcore_io_Posix.cpp
+++ b/luni/src/main/native/libcore_io_Posix.cpp
@@ -420,6 +420,14 @@ static void Posix_chmod(JNIEnv* env, jobject, jstring javaPath, jint mode) {
     throwIfMinusOne(env, "chmod", TEMP_FAILURE_RETRY(chmod(path.c_str(), mode)));
 }
 
+static void Posix_chown(JNIEnv* env, jobject, jstring javaPath, jint uid, jint gid) {
+    ScopedUtfChars path(env, javaPath);
+    if (path.c_str() == NULL) {
+        return;
+    }
+    throwIfMinusOne(env, "chown", TEMP_FAILURE_RETRY(chown(path.c_str(), uid, gid)));
+}
+
 static void Posix_close(JNIEnv* env, jobject, jobject javaFd) {
     // Get the FileDescriptor's 'fd' field and clear it.
     // We need to do this before we can throw an IOException (http://b/3222087).
@@ -459,6 +467,16 @@ static jobjectArray Posix_environ(JNIEnv* env, jobject) {
     return toStringArray(env, environ);
 }
 
+static void Posix_fchmod(JNIEnv* env, jobject, jobject javaFd, jint mode) {
+    int fd = jniGetFDFromFileDescriptor(env, javaFd);
+    throwIfMinusOne(env, "fchmod", TEMP_FAILURE_RETRY(fchmod(fd, mode)));
+}
+
+static void Posix_fchown(JNIEnv* env, jobject, jobject javaFd, jint uid, jint gid) {
+    int fd = jniGetFDFromFileDescriptor(env, javaFd);
+    throwIfMinusOne(env, "fchown", TEMP_FAILURE_RETRY(fchown(fd, uid, gid)));
+}
+
 static jint Posix_fcntlVoid(JNIEnv* env, jobject, jobject javaFd, jint cmd) {
     int fd = jniGetFDFromFileDescriptor(env, javaFd);
     return throwIfMinusOne(env, "fcntl", TEMP_FAILURE_RETRY(fcntl(fd, cmd)));
@@ -798,6 +816,14 @@ static void Posix_kill(JNIEnv* env, jobject, jint pid, jint sig) {
     throwIfMinusOne(env, "kill", TEMP_FAILURE_RETRY(kill(pid, sig)));
 }
 
+static void Posix_lchown(JNIEnv* env, jobject, jstring javaPath, jint uid, jint gid) {
+    ScopedUtfChars path(env, javaPath);
+    if (path.c_str() == NULL) {
+        return;
+    }
+    throwIfMinusOne(env, "lchown", TEMP_FAILURE_RETRY(lchown(path.c_str(), uid, gid)));
+}
+
 static void Posix_listen(JNIEnv* env, jobject, jobject javaFd, jint backlog) {
     int fd = jniGetFDFromFileDescriptor(env, javaFd);
     throwIfMinusOne(env, "listen", TEMP_FAILURE_RETRY(listen(fd, backlog)));
@@ -1195,6 +1221,10 @@ static jlong Posix_sysconf(JNIEnv* env, jobject, jint name) {
     return result;
 }
 
+static jint Posix_umask(JNIEnv*, jint mask) {
+    return umask(mask);
+}
+
 static jobject Posix_uname(JNIEnv* env, jobject) {
     struct utsname buf;
     if (TEMP_FAILURE_RETRY(uname(&buf)) == -1) {
@@ -1236,11 +1266,14 @@ static JNINativeMethod gMethods[] = {
     NATIVE_METHOD(Posix, access, "(Ljava/lang/String;I)Z"),
     NATIVE_METHOD(Posix, bind, "(Ljava/io/FileDescriptor;Ljava/net/InetAddress;I)V"),
     NATIVE_METHOD(Posix, chmod, "(Ljava/lang/String;I)V"),
+    NATIVE_METHOD(Posix, chown, "(Ljava/lang/String;II)V"),
     NATIVE_METHOD(Posix, close, "(Ljava/io/FileDescriptor;)V"),
     NATIVE_METHOD(Posix, connect, "(Ljava/io/FileDescriptor;Ljava/net/InetAddress;I)V"),
     NATIVE_METHOD(Posix, dup, "(Ljava/io/FileDescriptor;)Ljava/io/FileDescriptor;"),
     NATIVE_METHOD(Posix, dup2, "(Ljava/io/FileDescriptor;I)Ljava/io/FileDescriptor;"),
     NATIVE_METHOD(Posix, environ, "()[Ljava/lang/String;"),
+    NATIVE_METHOD(Posix, fchmod, "(Ljava/io/FileDescriptor;I)V"),
+    NATIVE_METHOD(Posix, fchown, "(Ljava/io/FileDescriptor;II)V"),
     NATIVE_METHOD(Posix, fcntlVoid, "(Ljava/io/FileDescriptor;I)I"),
     NATIVE_METHOD(Posix, fcntlLong, "(Ljava/io/FileDescriptor;IJ)I"),
     NATIVE_METHOD(Posix, fcntlFlock, "(Ljava/io/FileDescriptor;ILlibcore/io/StructFlock;)I"),
@@ -1273,6 +1306,7 @@ static JNINativeMethod gMethods[] = {
     NATIVE_METHOD(Posix, ioctlInt, "(Ljava/io/FileDescriptor;ILlibcore/util/MutableInt;)I"),
     NATIVE_METHOD(Posix, isatty, "(Ljava/io/FileDescriptor;)Z"),
     NATIVE_METHOD(Posix, kill, "(II)V"),
+    NATIVE_METHOD(Posix, lchown, "(Ljava/lang/String;II)V"),
     NATIVE_METHOD(Posix, listen, "(Ljava/io/FileDescriptor;I)V"),
     NATIVE_METHOD(Posix, lseek, "(Ljava/io/FileDescriptor;JI)J"),
     NATIVE_METHOD(Posix, lstat, "(Ljava/lang/String;)Llibcore/io/StructStat;"),
@@ -1313,6 +1347,7 @@ static JNINativeMethod gMethods[] = {
     NATIVE_METHOD(Posix, strerror, "(I)Ljava/lang/String;"),
     NATIVE_METHOD(Posix, symlink, "(Ljava/lang/String;Ljava/lang/String;)V"),
     NATIVE_METHOD(Posix, sysconf, "(I)J"),
+    NATIVE_METHOD(Posix, umask, "(I)I"),
     NATIVE_METHOD(Posix, uname, "()Llibcore/io/StructUtsname;"),
     NATIVE_METHOD(Posix, waitpid, "(ILlibcore/util/MutableInt;I)I"),
     NATIVE_METHOD(Posix, writeBytes, "(Ljava/io/FileDescriptor;Ljava/lang/Object;II)I"),
-- 
cgit v1.1


From 1d7a4a8f05b12e365e898a4c7639e285118643b8 Mon Sep 17 00:00:00 2001
From: Jeff Sharkey <jsharkey@android.com>
Date: Thu, 16 Aug 2012 15:20:03 -0700
Subject: Multi-user external storage support.

Add flags for mounting external storage and pass into JNI.

Bug: 6925012
Change-Id: I3704ef1616339f9f5f854f734b58efa7a02b67a4
---
 dalvik/src/main/java/dalvik/system/Zygote.java | 55 +++++++++-----------------
 1 file changed, 19 insertions(+), 36 deletions(-)

diff --git a/dalvik/src/main/java/dalvik/system/Zygote.java b/dalvik/src/main/java/dalvik/system/Zygote.java
index ec114ed..a649025 100644
--- a/dalvik/src/main/java/dalvik/system/Zygote.java
+++ b/dalvik/src/main/java/dalvik/system/Zygote.java
@@ -41,6 +41,13 @@ public class Zygote {
     /** Enable logging of third-party JNI activity. */
     public static final int DEBUG_ENABLE_JNI_LOGGING = 1 << 4;
 
+    /** No external storage should be mounted. */
+    public static final int MOUNT_EXTERNAL_NONE = 0;
+    /** Single-user external storage should be mounted. */
+    public static final int MOUNT_EXTERNAL_SINGLEUSER = 1;
+    /** Multi-user external storage should be mounted. */
+    public static final int MOUNT_EXTERNAL_MULTIUSER = 2;
+
     /**
      * When set by the system server, all subsequent apps will be launched in
      * VM safe mode.
@@ -114,27 +121,17 @@ public class Zygote {
      * @return 0 if this is the child, pid of the child
      * if this is the parent, or -1 on error.
      */
-    public static int forkAndSpecialize(int uid, int gid, int[] gids,
-            int debugFlags, int[][] rlimits, String seInfo, String niceName) {
+    public static int forkAndSpecialize(int uid, int gid, int[] gids, int debugFlags,
+            int[][] rlimits, int mountExternal, String seInfo, String niceName) {
         preFork();
-        int pid = nativeForkAndSpecialize(uid, gid, gids, debugFlags, rlimits, seInfo, niceName);
+        int pid = nativeForkAndSpecialize(
+                uid, gid, gids, debugFlags, rlimits, mountExternal, seInfo, niceName);
         postFork();
         return pid;
     }
 
-    native public static int nativeForkAndSpecialize(int uid, int gid,
-            int[] gids, int debugFlags, int[][] rlimits, String seInfo, String niceName);
-
-    /**
-     * Forks a new VM instance.
-     * @deprecated use {@link Zygote#forkAndSpecialize(int, int, int[], int, int[][])}
-     */
-    @Deprecated
-    public static int forkAndSpecialize(int uid, int gid, int[] gids,
-            boolean enableDebugger, int[][] rlimits) {
-        int debugFlags = enableDebugger ? DEBUG_ENABLE_DEBUGGER : 0;
-        return forkAndSpecialize(uid, gid, gids, debugFlags, rlimits, null, null);
-    }
+    native public static int nativeForkAndSpecialize(int uid, int gid, int[] gids, int debugFlags,
+            int[][] rlimits, int mountExternal, String seInfo, String niceName);
 
     /**
      * Special method to start the system server process. In addition to the
@@ -159,31 +156,17 @@ public class Zygote {
      * @return 0 if this is the child, pid of the child
      * if this is the parent, or -1 on error.
      */
-    public static int forkSystemServer(int uid, int gid, int[] gids,
-            int debugFlags, int[][] rlimits,
-            long permittedCapabilities, long effectiveCapabilities) {
+    public static int forkSystemServer(int uid, int gid, int[] gids, int debugFlags,
+            int[][] rlimits, long permittedCapabilities, long effectiveCapabilities) {
         preFork();
-        int pid = nativeForkSystemServer(uid, gid, gids, debugFlags, rlimits,
-                                         permittedCapabilities,
-                                         effectiveCapabilities);
+        int pid = nativeForkSystemServer(
+                uid, gid, gids, debugFlags, rlimits, permittedCapabilities, effectiveCapabilities);
         postFork();
         return pid;
     }
 
-    /**
-     * Special method to start the system server process.
-     * @deprecated use {@link Zygote#forkSystemServer(int, int, int[], int, int[][])}
-     */
-    @Deprecated
-    public static int forkSystemServer(int uid, int gid, int[] gids,
-            boolean enableDebugger, int[][] rlimits) {
-        int debugFlags = enableDebugger ? DEBUG_ENABLE_DEBUGGER : 0;
-        return forkAndSpecialize(uid, gid, gids, debugFlags, rlimits, null, null);
-    }
-
-    native public static int nativeForkSystemServer(int uid, int gid,
-            int[] gids, int debugFlags, int[][] rlimits,
-            long permittedCapabilities, long effectiveCapabilities);
+    native public static int nativeForkSystemServer(int uid, int gid, int[] gids, int debugFlags,
+            int[][] rlimits, long permittedCapabilities, long effectiveCapabilities);
 
     /**
      * Executes "/system/bin/sh -c &lt;command&gt;" using the exec() system call.
-- 
cgit v1.1


From d951031b428eb2885dca51e0484d5d29e0caad44 Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Fri, 17 Aug 2012 17:23:24 -0700
Subject: KeyStoreSpi.engineSetEntry should allow null ProtectionParameter

Change-Id: Ibf5be502a70a63abccb6e45dc6b6ff18b2c63ca9
---
 luni/src/main/java/java/security/KeyStoreSpi.java  | 16 ++--
 .../tests/java/security/KeyStoreSpiTest.java       | 99 +++++++++++-----------
 2 files changed, 57 insertions(+), 58 deletions(-)

diff --git a/luni/src/main/java/java/security/KeyStoreSpi.java b/luni/src/main/java/java/security/KeyStoreSpi.java
index 01565f5..5ae9a72 100644
--- a/luni/src/main/java/java/security/KeyStoreSpi.java
+++ b/luni/src/main/java/java/security/KeyStoreSpi.java
@@ -414,14 +414,14 @@ public abstract class KeyStoreSpi {
         }
 
         char[] passW = null;
-        if (protParam instanceof KeyStore.PasswordProtection) {
-            try {
-                passW = ((KeyStore.PasswordProtection) protParam).getPassword();
-            } catch (IllegalStateException ee) {
-                throw new KeyStoreException("Password was destroyed", ee);
-            }
-        } else {
-            if (protParam instanceof KeyStore.CallbackHandlerProtection) {
+        if (protParam != null) {
+            if (protParam instanceof KeyStore.PasswordProtection) {
+                try {
+                    passW = ((KeyStore.PasswordProtection) protParam).getPassword();
+                } catch (IllegalStateException ee) {
+                    throw new KeyStoreException("Password was destroyed", ee);
+                }
+            } else if (protParam instanceof KeyStore.CallbackHandlerProtection) {
                 try {
                     passW = getPasswordFromCallBack(protParam);
                 } catch (Exception e) {
diff --git a/luni/src/test/java/org/apache/harmony/security/tests/java/security/KeyStoreSpiTest.java b/luni/src/test/java/org/apache/harmony/security/tests/java/security/KeyStoreSpiTest.java
index 4fdddbb..a85459b 100644
--- a/luni/src/test/java/org/apache/harmony/security/tests/java/security/KeyStoreSpiTest.java
+++ b/luni/src/test/java/org/apache/harmony/security/tests/java/security/KeyStoreSpiTest.java
@@ -15,21 +15,15 @@
  *  limitations under the License.
  */
 
-/**
- * @author Vera Y. Petrashkova
- * @version $Revision$
- */
-
 package org.apache.harmony.security.tests.java.security;
 
-import junit.framework.TestCase;
-
-import org.apache.harmony.security.tests.support.MyKeyStoreSpi;
-import org.apache.harmony.security.tests.support.MyLoadStoreParams;
-
 import java.io.IOException;
 import java.io.InputStream;
 import java.security.InvalidKeyException;
+import java.security.Key;
+import java.security.KeyStore.LoadStoreParameter;
+import java.security.KeyStore.Entry;
+import java.security.KeyStore.ProtectionParameter;
 import java.security.KeyStore;
 import java.security.KeyStoreException;
 import java.security.KeyStoreSpi;
@@ -39,16 +33,15 @@ import java.security.PublicKey;
 import java.security.SignatureException;
 import java.security.UnrecoverableEntryException;
 import java.security.UnrecoverableKeyException;
-import java.security.KeyStore.LoadStoreParameter;
 import java.security.cert.Certificate;
 import java.security.cert.CertificateEncodingException;
 import java.security.cert.CertificateException;
 import java.util.Date;
+import javax.crypto.SecretKey;
+import junit.framework.TestCase;
+import org.apache.harmony.security.tests.support.MyKeyStoreSpi;
+import org.apache.harmony.security.tests.support.MyLoadStoreParams;
 
-/**
- * Tests for <code>KeyStoreSpi</code> constructor and methods
- *
- */
 public class KeyStoreSpiTest extends TestCase {
 
     @SuppressWarnings("cast")
@@ -86,62 +79,73 @@ public class KeyStoreSpiTest extends TestCase {
         try {
             assertFalse(ksSpi.engineEntryInstanceOf(null,
                     KeyStore.TrustedCertificateEntry.class));
-        } catch (NullPointerException e) {
-            // ok
+        } catch (NullPointerException expected) {
         }
 
         try {
             assertFalse(ksSpi.engineEntryInstanceOf(
                     "test_engineEntryInstanceOf_Alias1", null));
-        } catch (NullPointerException e) {
-            // ok
+        } catch (NullPointerException expected) {
         }
 
 
     }
 
-    public void testKeyStoteSpi01() throws IOException,
+    public void testKeyStoreSpi01() throws IOException,
             NoSuchAlgorithmException, CertificateException,
             UnrecoverableEntryException, KeyStoreException {
-        KeyStoreSpi ksSpi = new MyKeyStoreSpi();
+        final boolean[] keyEntryWasSet = new boolean[1];
+        KeyStoreSpi ksSpi = new MyKeyStoreSpi() {
+            @Override public void engineSetKeyEntry(String alias, Key key, char[] password,
+                Certificate[] chain) throws KeyStoreException { keyEntryWasSet[0] = true; }
+        };
+
+        BadKeyStoreEntry badEntry = new BadKeyStoreEntry();
+        BadKeyStoreProtectionParameter badParameter = new BadKeyStoreProtectionParameter();
 
-        tmpEntry entry = new tmpEntry();
-        tmpProtection pPar = new tmpProtection();
+        KeyStore.SecretKeyEntry dummyEntry = new KeyStore.SecretKeyEntry(new SecretKey() {
+            @Override public String getAlgorithm() { return null; }
+            @Override public String getFormat() { return null; }
+            @Override public byte[] getEncoded() { return null; }
+        });
 
         try {
             ksSpi.engineStore(null);
-        } catch (UnsupportedOperationException e) {
+        } catch (UnsupportedOperationException expected) {
         }
         assertNull("Not null entry", ksSpi.engineGetEntry("aaa", null));
-        assertNull("Not null entry", ksSpi.engineGetEntry(null, pPar));
-        assertNull("Not null entry", ksSpi.engineGetEntry("aaa", pPar));
+        assertNull("Not null entry", ksSpi.engineGetEntry(null, badParameter));
+        assertNull("Not null entry", ksSpi.engineGetEntry("aaa", badParameter));
 
         try {
             ksSpi.engineSetEntry("", null, null);
             fail("KeyStoreException or NullPointerException must be thrown");
-        } catch (KeyStoreException e) {
-        } catch (NullPointerException e) {
+        } catch (KeyStoreException expected) {
+        } catch (NullPointerException expected) {
         }
 
         try {
             ksSpi.engineSetEntry("", new KeyStore.TrustedCertificateEntry(
                     new MyCertificate("type", new byte[0])), null);
             fail("KeyStoreException must be thrown");
-        } catch (KeyStoreException e) {
+        } catch (KeyStoreException expected) {
         }
 
         try {
-            ksSpi.engineSetEntry("aaa", entry, null);
+            ksSpi.engineSetEntry("aaa", badEntry, null);
             fail("KeyStoreException must be thrown");
-        } catch (KeyStoreException e) {
+        } catch (KeyStoreException expected) {
         }
+
+        ksSpi.engineSetEntry("aaa", dummyEntry, null);
+        assertTrue(keyEntryWasSet[0]);
     }
 
     /**
      * Test for <code>KeyStoreSpi()</code> constructor and abstract engine
      * methods. Assertion: creates new KeyStoreSpi object.
      */
-    public void testKeyStoteSpi02() throws NoSuchAlgorithmException,
+    public void testKeyStoreSpi02() throws NoSuchAlgorithmException,
             UnrecoverableKeyException, CertificateException {
         KeyStoreSpi ksSpi = new MyKeyStoreSpi();
         assertNull("engineGetKey(..) must return null", ksSpi.engineGetKey("",
@@ -155,23 +159,23 @@ public class KeyStoreSpiTest extends TestCase {
         try {
             ksSpi.engineSetKeyEntry("", null, new char[0], new Certificate[0]);
             fail("KeyStoreException must be thrown from engineSetKeyEntry(..)");
-        } catch (KeyStoreException e) {
+        } catch (KeyStoreException expected) {
         }
         try {
             ksSpi.engineSetKeyEntry("", new byte[0], new Certificate[0]);
             fail("KeyStoreException must be thrown from engineSetKeyEntry(..)");
-        } catch (KeyStoreException e) {
+        } catch (KeyStoreException expected) {
         }
         try {
             ksSpi.engineSetCertificateEntry("", null);
             fail("KeyStoreException must be thrown "
                     + "from engineSetCertificateEntry(..)");
-        } catch (KeyStoreException e) {
+        } catch (KeyStoreException expected) {
         }
         try {
             ksSpi.engineDeleteEntry("");
             fail("KeyStoreException must be thrown from engineDeleteEntry(..)");
-        } catch (KeyStoreException e) {
+        } catch (KeyStoreException expected) {
         }
         assertNull("engineAliases() must return null", ksSpi.engineAliases());
         assertFalse("engineContainsAlias(..) must return false", ksSpi
@@ -180,7 +184,7 @@ public class KeyStoreSpiTest extends TestCase {
         try {
             ksSpi.engineStore(null, null);
             fail("IOException must be thrown");
-        } catch (IOException e) {
+        } catch (IOException expected) {
         }
     }
 
@@ -202,35 +206,30 @@ public class KeyStoreSpiTest extends TestCase {
         try {
             ksSpi.engineLoad(null);
             fail("Should throw exception");
-        } catch (RuntimeException e) {
-            assertSame(msg, e.getMessage());
+        } catch (RuntimeException expected) {
+            assertSame(msg, expected.getMessage());
         }
 
         // test: protection parameter is null
         try {
             ksSpi.engineLoad(new MyLoadStoreParams(null));
             fail("No expected UnsupportedOperationException");
-        } catch (UnsupportedOperationException e) {
+        } catch (UnsupportedOperationException expected) {
         }
 
         // test: protection parameter is not instanceof
         // PasswordProtection or CallbackHandlerProtection
         try {
-            ksSpi.engineLoad(new MyLoadStoreParams(new tmpProtection()));
+            ksSpi.engineLoad(new MyLoadStoreParams(new BadKeyStoreProtectionParameter()));
             fail("No expected UnsupportedOperationException");
-        } catch (UnsupportedOperationException e) {
+        } catch (UnsupportedOperationException expected) {
         }
     }
 }
 
-/**
- * Additional class implements KeyStore.Entry interface
- */
-class tmpEntry implements KeyStore.Entry {
-}
-
-class tmpProtection implements KeyStore.ProtectionParameter {
-}
+// These are "Bad" because they are not expected inner subclasses of the KeyStore class.
+class BadKeyStoreEntry implements Entry {}
+class BadKeyStoreProtectionParameter implements ProtectionParameter {}
 
 @SuppressWarnings("unused")
 class MyCertificate extends Certificate {
-- 
cgit v1.1


From 783004cceef470884b3ee6946cbbfc4af0f28ae7 Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Sun, 19 Aug 2012 20:55:05 -0700
Subject: Restore ability for SSLSocket.close() to interrupt reads and writes

SSLSocketTest.test_SSLSocket_interrupt didn't catch this regression so
added new test_SSLSocket_interrupt_read to cover this case
specifically.  Also cleanup SSLSocketTest to use Executors like
NativeCryptoTest instead of Threads for better error checking.

Bug: 7014266
Change-Id: I1160cd283310a0c6197cd3271a25830e0e2b1524
---
 .../xnet/provider/jsse/OpenSSLSocketImpl.java      |   7 +-
 .../java/libcore/javax/net/ssl/SSLSocketTest.java  | 393 ++++++++++-----------
 .../xnet/provider/jsse/NativeCryptoTest.java       |   2 +-
 3 files changed, 198 insertions(+), 204 deletions(-)

diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLSocketImpl.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLSocketImpl.java
index 6334d41..065dd28 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLSocketImpl.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLSocketImpl.java
@@ -915,11 +915,12 @@ public class OpenSSLSocketImpl
         }
 
         synchronized (this) {
-            synchronized (writeLock) {
-                synchronized (readLock) {
 
-                    NativeCrypto.SSL_interrupt(sslNativePointer);
+            // Interrupt any outstanding reads or writes before taking the writeLock and readLock
+            NativeCrypto.SSL_interrupt(sslNativePointer);
 
+            synchronized (writeLock) {
+                synchronized (readLock) {
                     // Shut down the SSL connection, per se.
                     try {
                         if (handshakeStarted) {
diff --git a/luni/src/test/java/libcore/javax/net/ssl/SSLSocketTest.java b/luni/src/test/java/libcore/javax/net/ssl/SSLSocketTest.java
index 8b9cb11..8c9239e 100644
--- a/luni/src/test/java/libcore/javax/net/ssl/SSLSocketTest.java
+++ b/luni/src/test/java/libcore/javax/net/ssl/SSLSocketTest.java
@@ -16,6 +16,7 @@
 
 package libcore.javax.net.ssl;
 
+import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.net.ServerSocket;
@@ -30,6 +31,10 @@ import java.security.cert.X509Certificate;
 import java.util.Arrays;
 import java.util.HashSet;
 import java.util.Set;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
 import javax.net.ssl.HandshakeCompletedEvent;
 import javax.net.ssl.HandshakeCompletedListener;
 import javax.net.ssl.KeyManager;
@@ -38,7 +43,6 @@ import javax.net.ssl.SSLException;
 import javax.net.ssl.SSLHandshakeException;
 import javax.net.ssl.SSLParameters;
 import javax.net.ssl.SSLPeerUnverifiedException;
-import javax.net.ssl.SSLHandshakeException;
 import javax.net.ssl.SSLProtocolException;
 import javax.net.ssl.SSLSession;
 import javax.net.ssl.SSLSocket;
@@ -271,32 +275,28 @@ public class SSLSocketTest extends TestCase {
         SSLSocket client = (SSLSocket) c.clientContext.getSocketFactory().createSocket(c.host,
                                                                                        c.port);
         final SSLSocket server = (SSLSocket) c.serverSocket.accept();
-        Thread thread = new Thread(new Runnable () {
-            public void run() {
+        ExecutorService executor = Executors.newSingleThreadExecutor();
+        Future<Void> future = executor.submit(new Callable<Void>() {
+            @Override public Void call() throws Exception {
+                server.startHandshake();
+                assertNotNull(server.getSession());
                 try {
-                    server.startHandshake();
-                    assertNotNull(server.getSession());
-                    try {
-                        server.getSession().getPeerCertificates();
-                        fail();
-                    } catch (SSLPeerUnverifiedException expected) {
-                    }
-                    Certificate[] localCertificates = server.getSession().getLocalCertificates();
-                    assertNotNull(localCertificates);
-                    TestKeyStore.assertChainLength(localCertificates);
-                    assertNotNull(localCertificates[0]);
-                    TestSSLContext.assertServerCertificateChain(c.serverTrustManager,
-                                                                localCertificates);
-                    TestSSLContext.assertCertificateInKeyStore(localCertificates[0],
-                                                               c.serverKeyStore);
-                } catch (RuntimeException e) {
-                    throw e;
-                } catch (Exception e) {
-                    throw new RuntimeException(e);
+                    server.getSession().getPeerCertificates();
+                    fail();
+                } catch (SSLPeerUnverifiedException expected) {
                 }
+                Certificate[] localCertificates = server.getSession().getLocalCertificates();
+                assertNotNull(localCertificates);
+                TestKeyStore.assertChainLength(localCertificates);
+                assertNotNull(localCertificates[0]);
+                TestSSLContext.assertServerCertificateChain(c.serverTrustManager,
+                                                            localCertificates);
+                TestSSLContext.assertCertificateInKeyStore(localCertificates[0],
+                                                           c.serverKeyStore);
+                return null;
             }
         });
-        thread.start();
+        executor.shutdown();
         client.startHandshake();
         assertNotNull(client.getSession());
         assertNull(client.getSession().getLocalCertificates());
@@ -307,7 +307,7 @@ public class SSLSocketTest extends TestCase {
         TestSSLContext.assertServerCertificateChain(c.clientTrustManager,
                                                     peerCertificates);
         TestSSLContext.assertCertificateInKeyStore(peerCertificates[0], c.serverKeyStore);
-        thread.join();
+        future.get();
         client.close();
         server.close();
         c.close();
@@ -321,25 +321,24 @@ public class SSLSocketTest extends TestCase {
         // RI used to throw SSLException on accept, now throws on startHandshake
         if (StandardNames.IS_RI) {
             final SSLSocket server = (SSLSocket) c.serverSocket.accept();
-            Thread thread = new Thread(new Runnable () {
-                public void run() {
+            ExecutorService executor = Executors.newSingleThreadExecutor();
+            Future<Void> future = executor.submit(new Callable<Void>() {
+                @Override public Void call() throws Exception {
                     try {
                         server.startHandshake();
+                        fail();
                     } catch (SSLHandshakeException expected) {
-                    } catch (RuntimeException e) {
-                        throw e;
-                    } catch (Exception e) {
-                        throw new RuntimeException(e);
                     }
+                    return null;
                 }
             });
-            thread.start();
+            executor.shutdown();
             try {
                 client.startHandshake();
                 fail();
             } catch (SSLHandshakeException expected) {
             }
-            thread.join();
+            future.get();
             server.close();
         } else {
             try {
@@ -359,20 +358,16 @@ public class SSLSocketTest extends TestCase {
         SSLSocket client = (SSLSocket)
             clientContext.getSocketFactory().createSocket(c.host, c.port);
         final SSLSocket server = (SSLSocket) c.serverSocket.accept();
-        Thread thread = new Thread(new Runnable () {
-            public void run() {
-                try {
-                    server.startHandshake();
-                } catch (RuntimeException e) {
-                    throw e;
-                } catch (Exception e) {
-                    throw new RuntimeException(e);
-                }
+        ExecutorService executor = Executors.newSingleThreadExecutor();
+        Future<Void> future = executor.submit(new Callable<Void>() {
+            @Override public Void call() throws Exception {
+                server.startHandshake();
+                return null;
             }
         });
-        thread.start();
+        executor.shutdown();
         client.startHandshake();
-        thread.join();
+        future.get();
         client.close();
         server.close();
         c.close();
@@ -383,18 +378,14 @@ public class SSLSocketTest extends TestCase {
         final SSLSocket client = (SSLSocket)
                 c.clientContext.getSocketFactory().createSocket(c.host, c.port);
         final SSLSocket server = (SSLSocket) c.serverSocket.accept();
-        Thread thread = new Thread(new Runnable () {
-            public void run() {
-                try {
-                    server.startHandshake();
-                } catch (RuntimeException e) {
-                    throw e;
-                } catch (Exception e) {
-                    throw new RuntimeException(e);
-                }
+        ExecutorService executor = Executors.newSingleThreadExecutor();
+        Future<Void> future = executor.submit(new Callable<Void>() {
+            @Override public Void call() throws Exception {
+                server.startHandshake();
+                return null;
             }
         });
-        thread.start();
+        executor.shutdown();
         final boolean[] handshakeCompletedListenerCalled = new boolean[1];
         client.addHandshakeCompletedListener(new HandshakeCompletedListener() {
             public void handshakeCompleted(HandshakeCompletedEvent event) {
@@ -472,7 +463,7 @@ public class SSLSocketTest extends TestCase {
             }
         });
         client.startHandshake();
-        thread.join();
+        future.get();
         if (!TestSSLContext.sslServerSocketSupportsSessionTickets()) {
             assertNotNull(c.serverContext.getServerSessionContext().getSession(
                     client.getSession().getId()));
@@ -492,25 +483,21 @@ public class SSLSocketTest extends TestCase {
         final SSLSocket client = (SSLSocket)
                 c.clientContext.getSocketFactory().createSocket(c.host, c.port);
         final SSLSocket server = (SSLSocket) c.serverSocket.accept();
-        Thread thread = new Thread(new Runnable () {
-            public void run() {
-                try {
-                    server.startHandshake();
-                } catch (RuntimeException e) {
-                    throw e;
-                } catch (Exception e) {
-                    throw new RuntimeException(e);
-                }
+        ExecutorService executor = Executors.newSingleThreadExecutor();
+        Future<Void> future = executor.submit(new Callable<Void>() {
+            @Override public Void call() throws Exception {
+                server.startHandshake();
+                return null;
             }
         });
-        thread.start();
+        executor.shutdown();
         client.addHandshakeCompletedListener(new HandshakeCompletedListener() {
             public void handshakeCompleted(HandshakeCompletedEvent event) {
                 throw new RuntimeException("RuntimeException from handshakeCompleted");
             }
         });
         client.startHandshake();
-        thread.join();
+        future.get();
         client.close();
         server.close();
         c.close();
@@ -551,22 +538,6 @@ public class SSLSocketTest extends TestCase {
         }
     }
 
-    public void test_SSLSocket_setUseClientMode_afterHandshake() throws Exception {
-
-        // can't set after handshake
-        TestSSLEnginePair pair = TestSSLEnginePair.create(null);
-        try {
-            pair.server.setUseClientMode(false);
-            fail();
-        } catch (IllegalArgumentException expected) {
-        }
-        try {
-            pair.client.setUseClientMode(false);
-            fail();
-        } catch (IllegalArgumentException expected) {
-        }
-    }
-
     private void test_SSLSocket_setUseClientMode(final boolean clientClientMode,
                                                  final boolean serverClientMode)
             throws Exception {
@@ -575,64 +546,73 @@ public class SSLSocketTest extends TestCase {
                                                                                        c.port);
         final SSLSocket server = (SSLSocket) c.serverSocket.accept();
 
-        final SSLHandshakeException[] sslHandshakeException = new SSLHandshakeException[1];
-        final SocketTimeoutException[] socketTimeoutException = new SocketTimeoutException[1];
-        Thread thread = new Thread(new Runnable () {
-            public void run() {
+        ExecutorService executor = Executors.newSingleThreadExecutor();
+        Future<IOException> future = executor.submit(new Callable<IOException>() {
+            @Override public IOException call() throws Exception {
                 try {
                     if (!serverClientMode) {
                         server.setSoTimeout(1 * 1000);
                     }
                     server.setUseClientMode(serverClientMode);
                     server.startHandshake();
+                    return null;
                 } catch (SSLHandshakeException e) {
-                    sslHandshakeException[0] = e;
+                    return e;
                 } catch (SocketTimeoutException e) {
-                    socketTimeoutException[0] = e;
-                } catch (RuntimeException e) {
-                    throw e;
-                } catch (Exception e) {
-                    throw new RuntimeException(e);
+                    return e;
                 }
             }
         });
-        thread.start();
+        executor.shutdown();
         if (!clientClientMode) {
             client.setSoTimeout(1 * 1000);
         }
         client.setUseClientMode(clientClientMode);
         client.startHandshake();
-        thread.join();
-        if (sslHandshakeException[0] != null) {
-            throw sslHandshakeException[0];
-        }
-        if (socketTimeoutException[0] != null) {
-            throw socketTimeoutException[0];
+        IOException ioe = future.get();
+        if (ioe != null) {
+            throw ioe;
         }
         client.close();
         server.close();
         c.close();
     }
 
+    public void test_SSLSocket_setUseClientMode_afterHandshake() throws Exception {
+
+        // can't set after handshake
+        TestSSLEnginePair pair = TestSSLEnginePair.create(null);
+        try {
+            pair.server.setUseClientMode(false);
+            fail();
+        } catch (IllegalArgumentException expected) {
+        }
+        try {
+            pair.client.setUseClientMode(false);
+            fail();
+        } catch (IllegalArgumentException expected) {
+        }
+    }
+
     public void test_SSLSocket_untrustedServer() throws Exception {
         TestSSLContext c = TestSSLContext.create(TestKeyStore.getClientCA2(),
                                                  TestKeyStore.getServer());
         SSLSocket client = (SSLSocket) c.clientContext.getSocketFactory().createSocket(c.host,
                                                                                        c.port);
         final SSLSocket server = (SSLSocket) c.serverSocket.accept();
-        Thread thread = new Thread(new Runnable () {
-            public void run() {
+        ExecutorService executor = Executors.newSingleThreadExecutor();
+        Future<Void> future = executor.submit(new Callable<Void>() {
+            @Override public Void call() throws Exception {
                 try {
                     server.startHandshake();
+                    assertFalse(StandardNames.IS_RI);
                 } catch (SSLHandshakeException expected) {
-                } catch (RuntimeException e) {
-                    throw e;
-                } catch (Exception e) {
-                    throw new RuntimeException(e);
+                    assertTrue(StandardNames.IS_RI);
                 }
+                return null;
             }
         });
-        thread.start();
+        executor.shutdown();
         try {
             client.startHandshake();
             fail();
@@ -641,7 +621,7 @@ public class SSLSocketTest extends TestCase {
         }
         client.close();
         server.close();
-        thread.join();
+        future.get();
     }
 
     public void test_SSLSocket_clientAuth() throws Exception {
@@ -650,43 +630,38 @@ public class SSLSocketTest extends TestCase {
         SSLSocket client = (SSLSocket) c.clientContext.getSocketFactory().createSocket(c.host,
                                                                                        c.port);
         final SSLSocket server = (SSLSocket) c.serverSocket.accept();
-        Thread thread = new Thread(new Runnable () {
-            public void run() {
-                try {
-                    assertFalse(server.getWantClientAuth());
-                    assertFalse(server.getNeedClientAuth());
-
-                    // confirm turning one on by itself
-                    server.setWantClientAuth(true);
-                    assertTrue(server.getWantClientAuth());
-                    assertFalse(server.getNeedClientAuth());
-
-                    // confirm turning setting on toggles the other
-                    server.setNeedClientAuth(true);
-                    assertFalse(server.getWantClientAuth());
-                    assertTrue(server.getNeedClientAuth());
-
-                    // confirm toggling back
-                    server.setWantClientAuth(true);
-                    assertTrue(server.getWantClientAuth());
-                    assertFalse(server.getNeedClientAuth());
-
-                    server.startHandshake();
-
-                } catch (RuntimeException e) {
-                    throw e;
-                } catch (Exception e) {
-                    throw new RuntimeException(e);
-                }
+        ExecutorService executor = Executors.newSingleThreadExecutor();
+        Future<Void> future = executor.submit(new Callable<Void>() {
+            @Override public Void call() throws Exception {
+                assertFalse(server.getWantClientAuth());
+                assertFalse(server.getNeedClientAuth());
+
+                // confirm turning one on by itself
+                server.setWantClientAuth(true);
+                assertTrue(server.getWantClientAuth());
+                assertFalse(server.getNeedClientAuth());
+
+                // confirm turning setting on toggles the other
+                server.setNeedClientAuth(true);
+                assertFalse(server.getWantClientAuth());
+                assertTrue(server.getNeedClientAuth());
+
+                // confirm toggling back
+                server.setWantClientAuth(true);
+                assertTrue(server.getWantClientAuth());
+                assertFalse(server.getNeedClientAuth());
+
+                server.startHandshake();
+                return null;
             }
         });
-        thread.start();
+        executor.shutdown();
         client.startHandshake();
         assertNotNull(client.getSession().getLocalCertificates());
         TestKeyStore.assertChainLength(client.getSession().getLocalCertificates());
         TestSSLContext.assertClientCertificateChain(c.clientTrustManager,
                                                     client.getSession().getLocalCertificates());
-        thread.join();
+        future.get();
         client.close();
         server.close();
         c.close();
@@ -727,22 +702,20 @@ public class SSLSocketTest extends TestCase {
         SSLSocket client = (SSLSocket) clientContext.getSocketFactory().createSocket(c.host,
                                                                                      c.port);
         final SSLSocket server = (SSLSocket) c.serverSocket.accept();
-        Thread thread = new Thread(new Runnable () {
-            public void run() {
+        ExecutorService executor = Executors.newSingleThreadExecutor();
+        Future<Void> future = executor.submit(new Callable<Void>() {
+            @Override public Void call() throws Exception {
                 try {
                     server.setNeedClientAuth(true);
                     server.startHandshake();
                     fail();
                 } catch (SSLHandshakeException expected) {
-                } catch (RuntimeException e) {
-                    throw e;
-                } catch (Exception e) {
-                    throw new RuntimeException(e);
                 }
+                return null;
             }
         });
 
-        thread.start();
+        executor.shutdown();
         try {
             client.startHandshake();
             fail();
@@ -750,7 +723,7 @@ public class SSLSocketTest extends TestCase {
             // before we would get a NullPointerException from passing
             // due to the null PrivateKey return by the X509KeyManager.
         }
-        thread.join();
+        future.get();
         client.close();
         server.close();
         c.close();
@@ -773,29 +746,25 @@ public class SSLSocketTest extends TestCase {
         SSLSocket client = (SSLSocket) c.clientContext.getSocketFactory().createSocket(c.host,
                                                                                        c.port);
         final SSLSocket server = (SSLSocket) c.serverSocket.accept();
-        Thread thread = new Thread(new Runnable () {
-            public void run() {
+        ExecutorService executor = Executors.newSingleThreadExecutor();
+        Future<Void> future = executor.submit(new Callable<Void>() {
+            @Override public Void call() throws Exception {
+                server.setEnableSessionCreation(false);
                 try {
-                    server.setEnableSessionCreation(false);
-                    try {
-                        server.startHandshake();
-                        fail();
-                    } catch (SSLException expected) {
-                    }
-                } catch (RuntimeException e) {
-                    throw e;
-                } catch (Exception e) {
-                    throw new RuntimeException(e);
+                    server.startHandshake();
+                    fail();
+                } catch (SSLException expected) {
                 }
+                return null;
             }
         });
-        thread.start();
+        executor.shutdown();
         try {
             client.startHandshake();
             fail();
         } catch (SSLException expected) {
         }
-        thread.join();
+        future.get();
         client.close();
         server.close();
         c.close();
@@ -806,29 +775,25 @@ public class SSLSocketTest extends TestCase {
         SSLSocket client = (SSLSocket) c.clientContext.getSocketFactory().createSocket(c.host,
                                                                                        c.port);
         final SSLSocket server = (SSLSocket) c.serverSocket.accept();
-        Thread thread = new Thread(new Runnable () {
-            public void run() {
+        ExecutorService executor = Executors.newSingleThreadExecutor();
+        Future<Void> future = executor.submit(new Callable<Void>() {
+            @Override public Void call() throws Exception {
                 try {
-                    try {
-                        server.startHandshake();
-                        fail();
-                    } catch (SSLException expected) {
-                    }
-                } catch (RuntimeException e) {
-                    throw e;
-                } catch (Exception e) {
-                    throw new RuntimeException(e);
+                    server.startHandshake();
+                    fail();
+                } catch (SSLException expected) {
                 }
+                return null;
             }
         });
-        thread.start();
+        executor.shutdown();
         client.setEnableSessionCreation(false);
         try {
             client.startHandshake();
             fail();
         } catch (SSLException expected) {
         }
-        thread.join();
+        future.get();
         client.close();
         server.close();
         c.close();
@@ -1012,32 +977,25 @@ public class SSLSocketTest extends TestCase {
                                                                 c.host.getHostName(),
                                                                 c.port,
                                                                 false);
-        Thread clientThread = new Thread(new Runnable () {
-            public void run() {
-                try {
-                    try {
-                        wrapping.startHandshake();
-                        wrapping.getOutputStream().write(42);
-                        // close the underlying socket,
-                        // so that no SSL shutdown is sent
-                        underlying.close();
-                        wrapping.close();
-                    } catch (SSLException expected) {
-                    }
-                } catch (RuntimeException e) {
-                    throw e;
-                } catch (Exception e) {
-                    throw new RuntimeException(e);
-                }
+        ExecutorService executor = Executors.newSingleThreadExecutor();
+        Future<Void> clientFuture = executor.submit(new Callable<Void>() {
+            @Override public Void call() throws Exception {
+                wrapping.startHandshake();
+                wrapping.getOutputStream().write(42);
+                // close the underlying socket,
+                // so that no SSL shutdown is sent
+                underlying.close();
+                wrapping.close();
+                return null;
             }
         });
-        clientThread.start();
+        executor.shutdown();
 
         SSLSocket server = (SSLSocket) c.serverSocket.accept();
         server.startHandshake();
         server.getInputStream().read();
         // wait for thread to finish so we know client is closed.
-        clientThread.join();
+        clientFuture.get();
         // close should cause an SSL_shutdown which will fail
         // because the peer has closed, but it shouldn't throw.
         server.close();
@@ -1127,17 +1085,15 @@ public class SSLSocketTest extends TestCase {
 
     private void test_SSLSocket_interrupt_case(Socket toRead, final Socket toClose)
             throws Exception {
-        new Thread() {
-            @Override
-            public void run() {
-                try {
-                    Thread.sleep(1 * 1000);
-                    toClose.close();
-                } catch (Exception e) {
-                    throw new RuntimeException(e);
-                }
+        ExecutorService executor = Executors.newSingleThreadExecutor();
+        Future<Void> future = executor.submit(new Callable<Void>() {
+            @Override public Void call() throws Exception {
+                Thread.sleep(1 * 1000);
+                toClose.close();
+                return null;
             }
-        }.start();
+        });
+        executor.shutdown();
         try {
             toRead.setSoTimeout(5 * 1000);
             toRead.getInputStream().read();
@@ -1146,6 +1102,43 @@ public class SSLSocketTest extends TestCase {
             throw e;
         } catch (SocketException expected) {
         }
+        future.get();
+    }
+
+    /**
+     * b/7014266 Test to confirm that an SSLSocket.close() on one
+     * thread will interupt another thread blocked reading on the same
+     * socket.
+     */
+    public void test_SSLSocket_interrupt_read() throws Exception {
+        TestSSLContext c = TestSSLContext.create();
+        final Socket underlying = new Socket(c.host, c.port);
+        final SSLSocket wrapping = (SSLSocket)
+                c.clientContext.getSocketFactory().createSocket(underlying,
+                                                                c.host.getHostName(),
+                                                                c.port,
+                                                                false);
+        ExecutorService executor = Executors.newSingleThreadExecutor();
+        Future<Void> clientFuture = executor.submit(new Callable<Void>() {
+            @Override public Void call() throws Exception {
+                try {
+                    wrapping.startHandshake();
+                    assertFalse(StandardNames.IS_RI);
+                    wrapping.setSoTimeout(5 * 1000);
+                    assertEquals(-1, wrapping.getInputStream().read());
+                } catch (Exception e) {
+                    assertTrue(StandardNames.IS_RI);
+                }
+                return null;
+            }
+        });
+        executor.shutdown();
+
+        SSLSocket server = (SSLSocket) c.serverSocket.accept();
+        server.startHandshake();
+        wrapping.close();
+        clientFuture.get();
+        server.close();
     }
 
     public void test_TestSSLSocketPair_create() {
diff --git a/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/NativeCryptoTest.java b/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/NativeCryptoTest.java
index 51c00fe..7a8b855 100644
--- a/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/NativeCryptoTest.java
+++ b/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/NativeCryptoTest.java
@@ -577,7 +577,7 @@ public class NativeCryptoTest extends TestCase {
         ExecutorService executor = Executors.newSingleThreadExecutor();
         Future<TestSSLHandshakeCallbacks> future = executor.submit(
                 new Callable<TestSSLHandshakeCallbacks>() {
-            public TestSSLHandshakeCallbacks call() throws Exception {
+            @Override public TestSSLHandshakeCallbacks call() throws Exception {
                 Socket socket = (client
                                  ? new Socket(listener.getInetAddress(),
                                               listener.getLocalPort())
-- 
cgit v1.1


From 56f51ec72d6bd9d4729e6bf85ef15b8c750e9f35 Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Tue, 21 Aug 2012 09:43:47 -0700
Subject: Updating KeyStore2Test to track change in behavior of
 KeyStoreSpi.engineSetEntry

Whether the KeyStore.setEntry call throws with an null
ProtectionParameter depends on the KeyStore algorithm.

    commit d951031b428eb2885dca51e0484d5d29e0caad44
    Author: Brian Carlstrom <bdc@google.com>
    Date:   Fri Aug 17 17:23:24 2012 -0700

        KeyStoreSpi.engineSetEntry should allow null ProtectionParameter

        Change-Id: Ibf5be502a70a63abccb6e45dc6b6ff18b2c63ca9

Change-Id: I5df8d577acb8c5e30e20c4606b2a1e8e6b5de0b9
---
 .../apache/harmony/security/tests/java/security/KeyStore2Test.java  | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/luni/src/test/java/org/apache/harmony/security/tests/java/security/KeyStore2Test.java b/luni/src/test/java/org/apache/harmony/security/tests/java/security/KeyStore2Test.java
index fd27edc..d303903 100644
--- a/luni/src/test/java/org/apache/harmony/security/tests/java/security/KeyStore2Test.java
+++ b/luni/src/test/java/org/apache/harmony/security/tests/java/security/KeyStore2Test.java
@@ -49,6 +49,7 @@ import java.util.Calendar;
 import java.util.Enumeration;
 import java.util.HashSet;
 import java.util.Set;
+import libcore.java.security.StandardNames;
 import tests.support.Support_TestProvider;
 
 public class KeyStore2Test extends junit.framework.TestCase {
@@ -817,8 +818,9 @@ public class KeyStore2Test extends junit.framework.TestCase {
 
         try {
             keyTest.setEntry("alias", pke, null);
-            fail();
-        } catch (Exception expected) {
+            assertFalse(StandardNames.IS_RI);  // BKS KeyStore does not require a password
+        } catch (KeyStoreException e) {
+            assertTrue(StandardNames.IS_RI);  // JKS KeyStore requires a password
         }
 
         keyTest.setEntry("alias", pke, pp);
-- 
cgit v1.1


From 4efbf2b6dfcbdacbc580ebbf35d39883bd7ec562 Mon Sep 17 00:00:00 2001
From: Kenny Root <kroot@google.com>
Date: Fri, 17 Aug 2012 13:42:59 -0700
Subject: Clear errors after failed ENGINE_add

Change-Id: I2f9c39717db9419c7924031fc30b7cc069c19d2e
---
 .../native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp  | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp b/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
index 8e82ef0..edc4618 100644
--- a/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
+++ b/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
@@ -587,6 +587,13 @@ static jint NativeCrypto_ENGINE_add(JNIEnv* env, jclass, jint engineRef) {
     }
 
     int ret = ENGINE_add(e);
+
+    /*
+     * We tolerate errors, because the most likely error is that
+     * the ENGINE is already in the list.
+     */
+    freeOpenSslErrorState();
+
     JNI_TRACE("ENGINE_add(%p) => %d", e, ret);
     return ret;
 }
-- 
cgit v1.1


From ff053c366fd8277f02773b1c0a6489ad67a794f1 Mon Sep 17 00:00:00 2001
From: Ying Wang <wangying@google.com>
Date: Tue, 21 Aug 2012 17:20:51 -0700
Subject: Remove obsolete variables.

Bug: 6987838
- Now emma is only enabled for apks.
- Global var  EMMA_INSTRUMENT_STATIC tells to build emma as static
  library to each module with emma enabled.

Change-Id: I1f3831ca3bbb3bc4fcc3c049fe80993a5cdc177a
---
 JavaLibrary.mk | 10 ++--------
 1 file changed, 2 insertions(+), 8 deletions(-)

diff --git a/JavaLibrary.mk b/JavaLibrary.mk
index 18fa870..0b0c08e 100644
--- a/JavaLibrary.mk
+++ b/JavaLibrary.mk
@@ -55,9 +55,11 @@ core_resource_dirs := $(call all-core-resource-dirs,main)
 test_resource_dirs := $(call all-core-resource-dirs,test)
 
 ifeq ($(EMMA_INSTRUMENT),true)
+ifneq ($(EMMA_INSTRUMENT_STATIC),true)
     core_src_files += $(call all-java-files-under, ../external/emma/core ../external/emma/pregenerated)
     core_resource_dirs += ../external/emma/core/res ../external/emma/pregenerated/res
 endif
+endif
 
 local_javac_flags=-encoding UTF-8
 #local_javac_flags+=-Xlint:all -Xlint:-serial,-deprecation,-unchecked
@@ -78,8 +80,6 @@ LOCAL_NO_STANDARD_LIBRARIES := true
 LOCAL_JAVACFLAGS := $(local_javac_flags)
 LOCAL_DX_FLAGS := --core-library
 
-LOCAL_NO_EMMA_INSTRUMENT := true
-LOCAL_NO_EMMA_COMPILE := true
 LOCAL_MODULE_TAGS := optional
 LOCAL_MODULE := core
 
@@ -98,8 +98,6 @@ LOCAL_STATIC_JAVA_LIBRARIES := sqlite-jdbc mockwebserver
 LOCAL_JAVACFLAGS := $(local_javac_flags)
 LOCAL_MODULE_TAGS := tests
 LOCAL_MODULE := core-tests
-LOCAL_NO_EMMA_INSTRUMENT := true
-LOCAL_NO_EMMA_COMPILE := true
 include $(BUILD_STATIC_JAVA_LIBRARY)
 
 # This one's tricky. One of our tests needs to have a
@@ -134,8 +132,6 @@ ifeq ($(WITH_HOST_DALVIK),true)
     LOCAL_JAVACFLAGS := $(local_javac_flags)
     LOCAL_DX_FLAGS := --core-library
 
-    LOCAL_NO_EMMA_INSTRUMENT := true
-    LOCAL_NO_EMMA_COMPILE := true
     LOCAL_BUILD_HOST_DEX := true
 
     LOCAL_MODULE_TAGS := optional
@@ -153,8 +149,6 @@ ifeq ($(WITH_HOST_DALVIK),true)
     LOCAL_JAVACFLAGS := $(local_javac_flags)
     LOCAL_MODULE_TAGS := tests
     LOCAL_MODULE := core-tests-hostdex
-    LOCAL_NO_EMMA_INSTRUMENT := true
-    LOCAL_NO_EMMA_COMPILE := true
     LOCAL_BUILD_HOST_DEX := true
     include $(BUILD_HOST_JAVA_LIBRARY)
 endif
-- 
cgit v1.1


From 86bdaf9b40263efae243d685d449e1ae30b0b161 Mon Sep 17 00:00:00 2001
From: Kenny Root <kroot@google.com>
Date: Tue, 21 Aug 2012 12:04:49 -0700
Subject: Remember key aliases for OpenSSLKeys from ENGINEs

Since it's not easy (or sometimes impossible) to retrieve key IDs for
keys loaded from an ENGINE, remember them when we create them.

Change-Id: I643b23668eae4303af04dc59899a6430e8d3a799
---
 .../harmony/xnet/provider/jsse/OpenSSLDSAPrivateKey.java       |  4 ++++
 .../org/apache/harmony/xnet/provider/jsse/OpenSSLEngine.java   |  4 ++--
 .../java/org/apache/harmony/xnet/provider/jsse/OpenSSLKey.java | 10 +++++++++-
 .../harmony/xnet/provider/jsse/OpenSSLRSAPrivateKey.java       |  4 ++++
 4 files changed, 19 insertions(+), 3 deletions(-)

diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLDSAPrivateKey.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLDSAPrivateKey.java
index 7cd16f7..761b08e 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLDSAPrivateKey.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLDSAPrivateKey.java
@@ -120,6 +120,10 @@ public class OpenSSLDSAPrivateKey implements DSAPrivateKey {
         return key.getPkeyContext();
     }
 
+    public String getPkeyAlias() {
+        return key.getAlias();
+    }
+
     @Override
     public boolean equals(Object o) {
         if (o == this) {
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLEngine.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLEngine.java
index 83f0ff8..d01dc62 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLEngine.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLEngine.java
@@ -69,9 +69,9 @@ public class OpenSSLEngine {
         final int keyType = NativeCrypto.EVP_PKEY_type(keyRef);
         switch (keyType) {
             case NativeCrypto.EVP_PKEY_RSA:
-                return OpenSSLRSAPrivateKey.getInstance(new OpenSSLKey(keyRef, this));
+                return OpenSSLRSAPrivateKey.getInstance(new OpenSSLKey(keyRef, this, id));
             case NativeCrypto.EVP_PKEY_DSA:
-                return new OpenSSLDSAPrivateKey(new OpenSSLKey(keyRef, this));
+                return new OpenSSLDSAPrivateKey(new OpenSSLKey(keyRef, this, id));
             default:
                 throw new InvalidKeyException("Unknown key type: " + keyType);
         }
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLKey.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLKey.java
index 90eb0e2..b8b9f69 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLKey.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLKey.java
@@ -21,14 +21,18 @@ class OpenSSLKey {
 
     private final OpenSSLEngine engine;
 
+    private final String alias;
+
     OpenSSLKey(int ctx) {
         this.ctx = ctx;
         engine = null;
+        alias = null;
     }
 
-    OpenSSLKey(int ctx, OpenSSLEngine engine) {
+    OpenSSLKey(int ctx, OpenSSLEngine engine, String alias) {
         this.ctx = ctx;
         this.engine = engine;
+        this.alias = alias;
     }
 
     int getPkeyContext() {
@@ -43,6 +47,10 @@ class OpenSSLKey {
         return engine != null;
     }
 
+    String getAlias() {
+        return alias;
+    }
+
     @Override
     protected void finalize() throws Throwable {
         try {
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLRSAPrivateKey.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLRSAPrivateKey.java
index 082bebd..5c2f075 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLRSAPrivateKey.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLRSAPrivateKey.java
@@ -180,6 +180,10 @@ public class OpenSSLRSAPrivateKey implements RSAPrivateKey {
         return key.getPkeyContext();
     }
 
+    public String getPkeyAlias() {
+        return key.getAlias();
+    }
+
     @Override
     public boolean equals(Object o) {
         if (o == this) {
-- 
cgit v1.1


From 796b0d2f4508e3933e53df2d372090c8634164ee Mon Sep 17 00:00:00 2001
From: Kenny Root <kroot@google.com>
Date: Tue, 21 Aug 2012 12:04:49 -0700
Subject: Remember key aliases for OpenSSLKeys from ENGINEs

Since it's not easy (or sometimes impossible) to retrieve key IDs for
keys loaded from an ENGINE, remember them when we create them.

(cherry-picked from 86bdaf9b40263efae243d685d449e1ae30b0b161)

Change-Id: I3920f56214d9eade87d51d30b024f5aeda9e8344
---
 .../harmony/xnet/provider/jsse/OpenSSLDSAPrivateKey.java       |  4 ++++
 .../org/apache/harmony/xnet/provider/jsse/OpenSSLEngine.java   |  4 ++--
 .../java/org/apache/harmony/xnet/provider/jsse/OpenSSLKey.java | 10 +++++++++-
 .../harmony/xnet/provider/jsse/OpenSSLRSAPrivateKey.java       |  4 ++++
 4 files changed, 19 insertions(+), 3 deletions(-)

diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLDSAPrivateKey.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLDSAPrivateKey.java
index 7cd16f7..761b08e 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLDSAPrivateKey.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLDSAPrivateKey.java
@@ -120,6 +120,10 @@ public class OpenSSLDSAPrivateKey implements DSAPrivateKey {
         return key.getPkeyContext();
     }
 
+    public String getPkeyAlias() {
+        return key.getAlias();
+    }
+
     @Override
     public boolean equals(Object o) {
         if (o == this) {
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLEngine.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLEngine.java
index 83f0ff8..d01dc62 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLEngine.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLEngine.java
@@ -69,9 +69,9 @@ public class OpenSSLEngine {
         final int keyType = NativeCrypto.EVP_PKEY_type(keyRef);
         switch (keyType) {
             case NativeCrypto.EVP_PKEY_RSA:
-                return OpenSSLRSAPrivateKey.getInstance(new OpenSSLKey(keyRef, this));
+                return OpenSSLRSAPrivateKey.getInstance(new OpenSSLKey(keyRef, this, id));
             case NativeCrypto.EVP_PKEY_DSA:
-                return new OpenSSLDSAPrivateKey(new OpenSSLKey(keyRef, this));
+                return new OpenSSLDSAPrivateKey(new OpenSSLKey(keyRef, this, id));
             default:
                 throw new InvalidKeyException("Unknown key type: " + keyType);
         }
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLKey.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLKey.java
index 90eb0e2..b8b9f69 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLKey.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLKey.java
@@ -21,14 +21,18 @@ class OpenSSLKey {
 
     private final OpenSSLEngine engine;
 
+    private final String alias;
+
     OpenSSLKey(int ctx) {
         this.ctx = ctx;
         engine = null;
+        alias = null;
     }
 
-    OpenSSLKey(int ctx, OpenSSLEngine engine) {
+    OpenSSLKey(int ctx, OpenSSLEngine engine, String alias) {
         this.ctx = ctx;
         this.engine = engine;
+        this.alias = alias;
     }
 
     int getPkeyContext() {
@@ -43,6 +47,10 @@ class OpenSSLKey {
         return engine != null;
     }
 
+    String getAlias() {
+        return alias;
+    }
+
     @Override
     protected void finalize() throws Throwable {
         try {
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLRSAPrivateKey.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLRSAPrivateKey.java
index 082bebd..5c2f075 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLRSAPrivateKey.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLRSAPrivateKey.java
@@ -180,6 +180,10 @@ public class OpenSSLRSAPrivateKey implements RSAPrivateKey {
         return key.getPkeyContext();
     }
 
+    public String getPkeyAlias() {
+        return key.getAlias();
+    }
+
     @Override
     public boolean equals(Object o) {
         if (o == this) {
-- 
cgit v1.1


From e79ac583cf570e66762c93c9bdfea14fd5c6249a Mon Sep 17 00:00:00 2001
From: Ying Wang <wangying@google.com>
Date: Thu, 23 Aug 2012 11:25:27 -0700
Subject: Fix build warning.

Change-Id: I931bf7b28fbefaa247f96122f823b712d0c9396f
---
 JavaLibrary.mk | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/JavaLibrary.mk b/JavaLibrary.mk
index 0b0c08e..40268ad 100644
--- a/JavaLibrary.mk
+++ b/JavaLibrary.mk
@@ -147,7 +147,7 @@ ifeq ($(WITH_HOST_DALVIK),true)
     LOCAL_JAVA_LIBRARIES := bouncycastle-hostdex core-hostdex core-junit-hostdex
     LOCAL_STATIC_JAVA_LIBRARIES := sqlite-jdbc-host mockwebserver-hostdex
     LOCAL_JAVACFLAGS := $(local_javac_flags)
-    LOCAL_MODULE_TAGS := tests
+    LOCAL_MODULE_TAGS := optional
     LOCAL_MODULE := core-tests-hostdex
     LOCAL_BUILD_HOST_DEX := true
     include $(BUILD_HOST_JAVA_LIBRARY)
-- 
cgit v1.1


From 507504c19919db8be7da16203601341b144b9e27 Mon Sep 17 00:00:00 2001
From: Ying Wang <wangying@google.com>
Date: Thu, 23 Aug 2012 11:25:27 -0700
Subject: Fix build warning.

(cherry-picked from e79ac583cf570e66762c93c9bdfea14fd5c6249a)

Change-Id: I76cc3e709606b9e58e2f5c639207ffb53462905b
---
 JavaLibrary.mk | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/JavaLibrary.mk b/JavaLibrary.mk
index 18fa870..4d91adb 100644
--- a/JavaLibrary.mk
+++ b/JavaLibrary.mk
@@ -151,7 +151,7 @@ ifeq ($(WITH_HOST_DALVIK),true)
     LOCAL_JAVA_LIBRARIES := bouncycastle-hostdex core-hostdex core-junit-hostdex
     LOCAL_STATIC_JAVA_LIBRARIES := sqlite-jdbc-host mockwebserver-hostdex
     LOCAL_JAVACFLAGS := $(local_javac_flags)
-    LOCAL_MODULE_TAGS := tests
+    LOCAL_MODULE_TAGS := optional
     LOCAL_MODULE := core-tests-hostdex
     LOCAL_NO_EMMA_INSTRUMENT := true
     LOCAL_NO_EMMA_COMPILE := true
-- 
cgit v1.1


From 7ba6c51277526eb66b328657abdaa85c05791826 Mon Sep 17 00:00:00 2001
From: Chris Dearman <chris@mips.com>
Date: Fri, 24 Aug 2012 12:42:29 -0700
Subject: [MIPS] Fix implementation of optimised bswap_2x16

Change-Id: I21e8304e4568d120dfb746cab8dd7d8ab2d53f44
---
 luni/src/main/native/libcore_io_Memory.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/luni/src/main/native/libcore_io_Memory.cpp b/luni/src/main/native/libcore_io_Memory.cpp
index bffb4a5..fe5f12d 100644
--- a/luni/src/main/native/libcore_io_Memory.cpp
+++ b/luni/src/main/native/libcore_io_Memory.cpp
@@ -69,10 +69,10 @@ template <typename T> static T cast(jint address) {
 // Byte-swap 2 jshort values packed in a jint.
 static inline jint bswap_2x16(jint v) {
     // v is initially ABCD
-    v = bswap_32(v);                              // v=DCBA
 #if defined(__mips__) && defined(__mips_isa_rev) && (__mips_isa_rev >= 2)
     __asm__ volatile ("wsbh %0, %0" : "+r" (v));  // v=BADC
 #else
+    v = bswap_32(v);                              // v=DCBA
     v = (v << 16) | ((v >> 16) & 0xffff);         // v=BADC
 #endif
     return v;
-- 
cgit v1.1


From 882ff343913f54cd02478fed2e9c41dfccd78a45 Mon Sep 17 00:00:00 2001
From: Edwin Vane <edwin.vane@intel.com>
Date: Mon, 11 Jun 2012 11:27:16 -0400
Subject: Avoid variable-length non-POD element array

Clang doesn't like variable-length arrays of non-POD types. Added new
X509Vector to hold the OpenSSL X509* references and preserve the RAII
style.

Change-Id: I85d61d6c26ff06fb7da8091376394b8438fb1fea
Reviewed-by: Kevin P Schoedel <kevin.p.schoedel@intel.com>
Author:    Edwin Vane <edwin.vane@intel.com>
---
 ...che_harmony_xnet_provider_jsse_NativeCrypto.cpp | 42 ++++++++++++++++++----
 1 file changed, 36 insertions(+), 6 deletions(-)

diff --git a/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp b/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
index 8e82ef0..b23adb7 100644
--- a/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
+++ b/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
@@ -24,6 +24,7 @@
 #include <fcntl.h>
 #include <sys/socket.h>
 #include <unistd.h>
+#include <vector>
 
 #include <jni.h>
 
@@ -154,6 +155,35 @@ struct X509_Delete {
 };
 typedef UniquePtr<X509, X509_Delete> Unique_X509;
 
+class X509Chain {
+  public:
+    X509Chain(size_t n) : x509s_(n) {}
+
+    ~X509Chain() {
+        // TODO: C++0x auto
+        for (std::vector<X509*>::const_iterator it = x509s_.begin(); it != x509s_.end(); ++it) {
+            X509_free(*it);
+        }
+    }
+
+    X509*& operator[](size_t n) {
+        return x509s_[n];
+    }
+
+    X509* operator[](size_t n) const {
+        return x509s_[n];
+    }
+
+    X509* release(size_t i) {
+        X509* x = x509s_[i];
+        x509s_[i] = NULL;
+        return x;
+    }
+
+  private:
+    std::vector<X509*> x509s_;
+};
+
 struct X509_NAME_Delete {
     void operator()(X509_NAME* p) const {
         X509_NAME_free(p);
@@ -2968,7 +2998,7 @@ static void NativeCrypto_SSL_use_certificate(JNIEnv* env, jclass,
         return;
     }
 
-    Unique_X509 certificatesX509[length];
+    X509Chain certificatesX509(length);
     for (int i = 0; i < length; i++) {
         ScopedLocalRef<jbyteArray> certificate(env,
                 reinterpret_cast<jbyteArray>(env->GetObjectArrayElement(certificates, i)));
@@ -2984,9 +3014,9 @@ static void NativeCrypto_SSL_use_certificate(JNIEnv* env, jclass,
             return;
         }
         const unsigned char* tmp = reinterpret_cast<const unsigned char*>(buf.get());
-        certificatesX509[i].reset(d2i_X509(NULL, &tmp, buf.size()));
+        certificatesX509[i] = d2i_X509(NULL, &tmp, buf.size());
 
-        if (certificatesX509[i].get() == NULL) {
+        if (certificatesX509[i] == NULL) {
             ALOGE("%s", ERR_error_string(ERR_peek_error(), NULL));
             throwSSLExceptionWithSslErrors(env, ssl, SSL_ERROR_NONE, "Error parsing certificate");
             SSL_clear(ssl);
@@ -2995,9 +3025,9 @@ static void NativeCrypto_SSL_use_certificate(JNIEnv* env, jclass,
         }
     }
 
-    int ret = SSL_use_certificate(ssl, certificatesX509[0].get());
+    int ret = SSL_use_certificate(ssl, certificatesX509[0]);
     if (ret == 1) {
-        OWNERSHIP_TRANSFERRED(certificatesX509[0]);
+        certificatesX509.release(0);
     } else {
         ALOGE("%s", ERR_error_string(ERR_peek_error(), NULL));
         throwSSLExceptionWithSslErrors(env, ssl, SSL_ERROR_NONE, "Error setting certificate");
@@ -3013,7 +3043,7 @@ static void NativeCrypto_SSL_use_certificate(JNIEnv* env, jclass,
         return;
     }
     for (int i = 1; i < length; i++) {
-        if (!sk_X509_push(chain.get(), certificatesX509[i].release())) {
+        if (!sk_X509_push(chain.get(), certificatesX509.release(i))) {
             jniThrowOutOfMemoryError(env, "Unable to push certificate");
             JNI_TRACE("ssl=%p NativeCrypto_SSL_use_certificate => certificate push error", ssl);
             return;
-- 
cgit v1.1


From 126ab1b546c71137a97cef68cc89267e7f7be634 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Tue, 28 Aug 2012 14:21:15 -0700
Subject: Improve nio IllegalArgumentException detail messages.

Bug: 7005326
Change-Id: Ibab8b776865dbed5da062cc683f834a79f068b32
---
 luni/src/main/java/java/nio/Buffer.java                 | 2 +-
 luni/src/main/java/java/nio/ByteBuffer.java             | 4 ++--
 luni/src/main/java/java/nio/CharBuffer.java             | 6 +++---
 luni/src/main/java/java/nio/DoubleBuffer.java           | 4 ++--
 luni/src/main/java/java/nio/FileChannelImpl.java        | 4 ++--
 luni/src/main/java/java/nio/FloatBuffer.java            | 4 ++--
 luni/src/main/java/java/nio/IntBuffer.java              | 4 ++--
 luni/src/main/java/java/nio/LongBuffer.java             | 4 ++--
 luni/src/main/java/java/nio/MappedByteBuffer.java       | 2 +-
 luni/src/main/java/java/nio/SelectorImpl.java           | 2 +-
 luni/src/main/java/java/nio/ShortBuffer.java            | 4 ++--
 luni/src/main/java/java/nio/SocketChannelImpl.java      | 2 +-
 luni/src/main/java/java/nio/channels/FileLock.java      | 2 +-
 luni/src/main/java/java/nio/charset/CharsetDecoder.java | 4 ++--
 luni/src/main/java/java/nio/charset/CharsetEncoder.java | 4 ++--
 luni/src/main/java/java/nio/charset/CoderResult.java    | 4 ++--
 16 files changed, 28 insertions(+), 28 deletions(-)

diff --git a/luni/src/main/java/java/nio/Buffer.java b/luni/src/main/java/java/nio/Buffer.java
index c3840a5..b90744b 100644
--- a/luni/src/main/java/java/nio/Buffer.java
+++ b/luni/src/main/java/java/nio/Buffer.java
@@ -271,7 +271,7 @@ public abstract class Buffer {
 
     final void checkWritable() {
         if (isReadOnly()) {
-            throw new IllegalArgumentException("read-only buffer");
+            throw new IllegalArgumentException("Read-only buffer");
         }
     }
 
diff --git a/luni/src/main/java/java/nio/ByteBuffer.java b/luni/src/main/java/java/nio/ByteBuffer.java
index ef725c1..6a3624a 100644
--- a/luni/src/main/java/java/nio/ByteBuffer.java
+++ b/luni/src/main/java/java/nio/ByteBuffer.java
@@ -47,7 +47,7 @@ public abstract class ByteBuffer extends Buffer implements Comparable<ByteBuffer
      */
     public static ByteBuffer allocate(int capacity) {
         if (capacity < 0) {
-            throw new IllegalArgumentException();
+            throw new IllegalArgumentException("capacity < 0: " + capacity);
         }
         return new ReadWriteHeapByteBuffer(capacity);
     }
@@ -63,7 +63,7 @@ public abstract class ByteBuffer extends Buffer implements Comparable<ByteBuffer
      */
     public static ByteBuffer allocateDirect(int capacity) {
         if (capacity < 0) {
-            throw new IllegalArgumentException();
+            throw new IllegalArgumentException("capacity < 0: " + capacity);
         }
         return new ReadWriteDirectByteBuffer(capacity);
     }
diff --git a/luni/src/main/java/java/nio/CharBuffer.java b/luni/src/main/java/java/nio/CharBuffer.java
index 03bac04..6429ae2 100644
--- a/luni/src/main/java/java/nio/CharBuffer.java
+++ b/luni/src/main/java/java/nio/CharBuffer.java
@@ -49,7 +49,7 @@ public abstract class CharBuffer extends Buffer implements
      */
     public static CharBuffer allocate(int capacity) {
         if (capacity < 0) {
-            throw new IllegalArgumentException();
+            throw new IllegalArgumentException("capacity < 0: " + capacity);
         }
         return new ReadWriteCharArrayBuffer(capacity);
     }
@@ -500,7 +500,7 @@ public abstract class CharBuffer extends Buffer implements
      */
     public CharBuffer put(CharBuffer src) {
         if (src == this) {
-            throw new IllegalArgumentException();
+            throw new IllegalArgumentException("src == this");
         }
         if (src.remaining() > remaining()) {
             throw new BufferOverflowException();
@@ -734,7 +734,7 @@ public abstract class CharBuffer extends Buffer implements
             if (remaining == 0) {
                 return -1;
             }
-            throw new IllegalArgumentException();
+            throw new IllegalArgumentException("target == this");
         }
         if (remaining == 0) {
             return limit > 0 && target.remaining() == 0 ? 0 : -1;
diff --git a/luni/src/main/java/java/nio/DoubleBuffer.java b/luni/src/main/java/java/nio/DoubleBuffer.java
index c495592..8d90f89 100644
--- a/luni/src/main/java/java/nio/DoubleBuffer.java
+++ b/luni/src/main/java/java/nio/DoubleBuffer.java
@@ -47,7 +47,7 @@ public abstract class DoubleBuffer extends Buffer implements
      */
     public static DoubleBuffer allocate(int capacity) {
         if (capacity < 0) {
-            throw new IllegalArgumentException();
+            throw new IllegalArgumentException("capacity < 0: " + capacity);
         }
         return new ReadWriteDoubleArrayBuffer(capacity);
     }
@@ -438,7 +438,7 @@ public abstract class DoubleBuffer extends Buffer implements
      */
     public DoubleBuffer put(DoubleBuffer src) {
         if (src == this) {
-            throw new IllegalArgumentException();
+            throw new IllegalArgumentException("src == this");
         }
         if (src.remaining() > remaining()) {
             throw new BufferOverflowException();
diff --git a/luni/src/main/java/java/nio/FileChannelImpl.java b/luni/src/main/java/java/nio/FileChannelImpl.java
index 76bad51..075243a 100644
--- a/luni/src/main/java/java/nio/FileChannelImpl.java
+++ b/luni/src/main/java/java/nio/FileChannelImpl.java
@@ -442,7 +442,7 @@ final class FileChannelImpl extends FileChannel {
     public FileChannel truncate(long size) throws IOException {
         checkOpen();
         if (size < 0) {
-            throw new IllegalArgumentException("size: " + size);
+            throw new IllegalArgumentException("size < 0: " + size);
         }
         checkWritable();
         if (size < size()) {
@@ -457,7 +457,7 @@ final class FileChannelImpl extends FileChannel {
 
     public int write(ByteBuffer buffer, long position) throws IOException {
         if (position < 0) {
-            throw new IllegalArgumentException("position: " + position);
+            throw new IllegalArgumentException("position < 0: " + position);
         }
         return writeImpl(buffer, position);
     }
diff --git a/luni/src/main/java/java/nio/FloatBuffer.java b/luni/src/main/java/java/nio/FloatBuffer.java
index ec361d6..814eb53 100644
--- a/luni/src/main/java/java/nio/FloatBuffer.java
+++ b/luni/src/main/java/java/nio/FloatBuffer.java
@@ -46,7 +46,7 @@ public abstract class FloatBuffer extends Buffer implements
      */
     public static FloatBuffer allocate(int capacity) {
         if (capacity < 0) {
-            throw new IllegalArgumentException();
+            throw new IllegalArgumentException("capacity < 0: " + capacity);
         }
         return new ReadWriteFloatArrayBuffer(capacity);
     }
@@ -437,7 +437,7 @@ public abstract class FloatBuffer extends Buffer implements
      */
     public FloatBuffer put(FloatBuffer src) {
         if (src == this) {
-            throw new IllegalArgumentException();
+            throw new IllegalArgumentException("src == this");
         }
         if (src.remaining() > remaining()) {
             throw new BufferOverflowException();
diff --git a/luni/src/main/java/java/nio/IntBuffer.java b/luni/src/main/java/java/nio/IntBuffer.java
index 9cc05ff..0ff758a 100644
--- a/luni/src/main/java/java/nio/IntBuffer.java
+++ b/luni/src/main/java/java/nio/IntBuffer.java
@@ -44,7 +44,7 @@ public abstract class IntBuffer extends Buffer implements Comparable<IntBuffer>
      */
     public static IntBuffer allocate(int capacity) {
         if (capacity < 0) {
-            throw new IllegalArgumentException();
+            throw new IllegalArgumentException("capacity < 0: " + capacity);
         }
         return new ReadWriteIntArrayBuffer(capacity);
     }
@@ -423,7 +423,7 @@ public abstract class IntBuffer extends Buffer implements Comparable<IntBuffer>
      */
     public IntBuffer put(IntBuffer src) {
         if (src == this) {
-            throw new IllegalArgumentException();
+            throw new IllegalArgumentException("src == this");
         }
         if (src.remaining() > remaining()) {
             throw new BufferOverflowException();
diff --git a/luni/src/main/java/java/nio/LongBuffer.java b/luni/src/main/java/java/nio/LongBuffer.java
index 27edd2e..1254ddb 100644
--- a/luni/src/main/java/java/nio/LongBuffer.java
+++ b/luni/src/main/java/java/nio/LongBuffer.java
@@ -46,7 +46,7 @@ public abstract class LongBuffer extends Buffer implements
      */
     public static LongBuffer allocate(int capacity) {
         if (capacity < 0) {
-            throw new IllegalArgumentException();
+            throw new IllegalArgumentException("capacity < 0: " + capacity);
         }
         return new ReadWriteLongArrayBuffer(capacity);
     }
@@ -427,7 +427,7 @@ public abstract class LongBuffer extends Buffer implements
      */
     public LongBuffer put(LongBuffer src) {
         if (src == this) {
-            throw new IllegalArgumentException();
+            throw new IllegalArgumentException("src == this");
         }
         if (src.remaining() > remaining()) {
             throw new BufferOverflowException();
diff --git a/luni/src/main/java/java/nio/MappedByteBuffer.java b/luni/src/main/java/java/nio/MappedByteBuffer.java
index 39c4986..0e8bf09 100644
--- a/luni/src/main/java/java/nio/MappedByteBuffer.java
+++ b/luni/src/main/java/java/nio/MappedByteBuffer.java
@@ -45,7 +45,7 @@ public abstract class MappedByteBuffer extends ByteBuffer {
     MappedByteBuffer(ByteBuffer directBuffer) {
         super(directBuffer.capacity, directBuffer.block);
         if (!directBuffer.isDirect()) {
-            throw new IllegalArgumentException();
+            throw new IllegalArgumentException("directBuffer is not a direct buffer: " + directBuffer);
         }
         this.wrapped = (DirectByteBuffer) directBuffer;
         this.mapMode = null;
diff --git a/luni/src/main/java/java/nio/SelectorImpl.java b/luni/src/main/java/java/nio/SelectorImpl.java
index 05a6497..02fdf54 100644
--- a/luni/src/main/java/java/nio/SelectorImpl.java
+++ b/luni/src/main/java/java/nio/SelectorImpl.java
@@ -150,7 +150,7 @@ final class SelectorImpl extends AbstractSelector {
 
     @Override public int select(long timeout) throws IOException {
         if (timeout < 0) {
-            throw new IllegalArgumentException();
+            throw new IllegalArgumentException("timeout < 0: " + timeout);
         }
         // Our timeout is interpreted differently to Unix's --- 0 means block. See selectNow.
         return selectInternal((timeout == 0) ? -1 : timeout);
diff --git a/luni/src/main/java/java/nio/ShortBuffer.java b/luni/src/main/java/java/nio/ShortBuffer.java
index 052cf6b..d12a49e 100644
--- a/luni/src/main/java/java/nio/ShortBuffer.java
+++ b/luni/src/main/java/java/nio/ShortBuffer.java
@@ -46,7 +46,7 @@ public abstract class ShortBuffer extends Buffer implements
      */
     public static ShortBuffer allocate(int capacity) {
         if (capacity < 0) {
-            throw new IllegalArgumentException();
+            throw new IllegalArgumentException("capacity < 0: " + capacity);
         }
         return new ReadWriteShortArrayBuffer(capacity);
     }
@@ -426,7 +426,7 @@ public abstract class ShortBuffer extends Buffer implements
      */
     public ShortBuffer put(ShortBuffer src) {
         if (src == this) {
-            throw new IllegalArgumentException();
+            throw new IllegalArgumentException("src == this");
         }
         if (src.remaining() > remaining()) {
             throw new BufferOverflowException();
diff --git a/luni/src/main/java/java/nio/SocketChannelImpl.java b/luni/src/main/java/java/nio/SocketChannelImpl.java
index 9b26812..a9d9c53 100644
--- a/luni/src/main/java/java/nio/SocketChannelImpl.java
+++ b/luni/src/main/java/java/nio/SocketChannelImpl.java
@@ -412,7 +412,7 @@ class SocketChannelImpl extends SocketChannel implements FileDescriptorChannel {
      */
     static InetSocketAddress validateAddress(SocketAddress socketAddress) {
         if (socketAddress == null) {
-            throw new IllegalArgumentException();
+            throw new IllegalArgumentException("socketAddress == null");
         }
         if (!(socketAddress instanceof InetSocketAddress)) {
             throw new UnsupportedAddressTypeException();
diff --git a/luni/src/main/java/java/nio/channels/FileLock.java b/luni/src/main/java/java/nio/channels/FileLock.java
index 0916be0..4cdcc27 100644
--- a/luni/src/main/java/java/nio/channels/FileLock.java
+++ b/luni/src/main/java/java/nio/channels/FileLock.java
@@ -98,7 +98,7 @@ public abstract class FileLock {
      */
     protected FileLock(FileChannel channel, long position, long size, boolean shared) {
         if (position < 0 || size < 0 || position + size < 0) {
-            throw new IllegalArgumentException();
+            throw new IllegalArgumentException("position=" + position + " size=" + size);
         }
         this.channel = channel;
         this.position = position;
diff --git a/luni/src/main/java/java/nio/charset/CharsetDecoder.java b/luni/src/main/java/java/nio/charset/CharsetDecoder.java
index f67dbbc..1559db4 100644
--- a/luni/src/main/java/java/nio/charset/CharsetDecoder.java
+++ b/luni/src/main/java/java/nio/charset/CharsetDecoder.java
@@ -590,7 +590,7 @@ public abstract class CharsetDecoder {
      */
     public final CharsetDecoder onMalformedInput(CodingErrorAction newAction) {
         if (newAction == null) {
-            throw new IllegalArgumentException();
+            throw new IllegalArgumentException("newAction == null");
         }
         malformedInputAction = newAction;
         implOnMalformedInput(newAction);
@@ -612,7 +612,7 @@ public abstract class CharsetDecoder {
      */
     public final CharsetDecoder onUnmappableCharacter(CodingErrorAction newAction) {
         if (newAction == null) {
-            throw new IllegalArgumentException();
+            throw new IllegalArgumentException("newAction == null");
         }
         unmappableCharacterAction = newAction;
         implOnUnmappableCharacter(newAction);
diff --git a/luni/src/main/java/java/nio/charset/CharsetEncoder.java b/luni/src/main/java/java/nio/charset/CharsetEncoder.java
index 28b2cb8..8f02f96 100644
--- a/luni/src/main/java/java/nio/charset/CharsetEncoder.java
+++ b/luni/src/main/java/java/nio/charset/CharsetEncoder.java
@@ -706,11 +706,11 @@ public abstract class CharsetEncoder {
             throw new IllegalArgumentException("replacement.length == 0");
         }
         if (replacement.length > maxBytesPerChar()) {
-            throw new IllegalArgumentException("replacement length > maxBytesPerChar: " +
+            throw new IllegalArgumentException("replacement.length > maxBytesPerChar: " +
                     replacement.length + " > " + maxBytesPerChar());
         }
         if (!isLegalReplacement(replacement)) {
-            throw new IllegalArgumentException("bad replacement: " + Arrays.toString(replacement));
+            throw new IllegalArgumentException("Bad replacement: " + Arrays.toString(replacement));
         }
         // It seems like a bug, but the RI doesn't clone, and we have tests that check we don't.
         this.replacementBytes = replacement;
diff --git a/luni/src/main/java/java/nio/charset/CoderResult.java b/luni/src/main/java/java/nio/charset/CoderResult.java
index 221cb32..3cc2673 100644
--- a/luni/src/main/java/java/nio/charset/CoderResult.java
+++ b/luni/src/main/java/java/nio/charset/CoderResult.java
@@ -121,7 +121,7 @@ public class CoderResult {
                 return r;
             }
         }
-        throw new IllegalArgumentException("Length must be greater than 0; was " + length);
+        throw new IllegalArgumentException("length <= 0: " + length);
     }
 
     /**
@@ -149,7 +149,7 @@ public class CoderResult {
                 return r;
             }
         }
-        throw new IllegalArgumentException("Length must be greater than 0; was " + length);
+        throw new IllegalArgumentException("length <= 0: " + length);
     }
 
     /**
-- 
cgit v1.1


From ee016ac51e9ca82eb9bc92795e61af02f67ae8c8 Mon Sep 17 00:00:00 2001
From: Jeff Sharkey <jsharkey@android.com>
Date: Tue, 28 Aug 2012 16:23:31 -0700
Subject: Access to all users' external storage.

System services holding this permission have external storage bound
one level higher, giving them access to all users' files.

Bug: 7003520
Change-Id: I8a81582f9ef07089a1fab3e8f6c3ffe657bb1c1b
---
 dalvik/src/main/java/dalvik/system/Zygote.java | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/dalvik/src/main/java/dalvik/system/Zygote.java b/dalvik/src/main/java/dalvik/system/Zygote.java
index a649025..c06314e 100644
--- a/dalvik/src/main/java/dalvik/system/Zygote.java
+++ b/dalvik/src/main/java/dalvik/system/Zygote.java
@@ -47,6 +47,8 @@ public class Zygote {
     public static final int MOUNT_EXTERNAL_SINGLEUSER = 1;
     /** Multi-user external storage should be mounted. */
     public static final int MOUNT_EXTERNAL_MULTIUSER = 2;
+    /** All multi-user external storage should be mounted. */
+    public static final int MOUNT_EXTERNAL_MULTIUSER_ALL = 3;
 
     /**
      * When set by the system server, all subsequent apps will be launched in
-- 
cgit v1.1


From 73d3e262ecf514ef17f47da335fdad899aecc3dc Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Tue, 28 Aug 2012 17:56:09 -0700
Subject: Add dependencies on the makefiles.

I've been enjoying this in bionic for a while now, and was annoyed
not to have make do the right thing in libcore.

Change-Id: Idcd2db48349202259887499a1f47d85c5d205d54
---
 CaCerts.mk     | 1 +
 JavaLibrary.mk | 5 +++++
 NativeCode.mk  | 3 +++
 3 files changed, 9 insertions(+)

diff --git a/CaCerts.mk b/CaCerts.mk
index cdced8f..980d0fb 100644
--- a/CaCerts.mk
+++ b/CaCerts.mk
@@ -30,6 +30,7 @@ endef
 define include-prebuilt-with-destination-directory
 include $$(CLEAR_VARS)
 LOCAL_MODULE := $(1)
+LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/CaCerts.mk
 LOCAL_MODULE_STEM := $(notdir $(2))
 LOCAL_MODULE_TAGS := optional
 LOCAL_MODULE_CLASS := ETC
diff --git a/JavaLibrary.mk b/JavaLibrary.mk
index 4d91adb..59ac2e1 100644
--- a/JavaLibrary.mk
+++ b/JavaLibrary.mk
@@ -82,6 +82,7 @@ LOCAL_NO_EMMA_INSTRUMENT := true
 LOCAL_NO_EMMA_COMPILE := true
 LOCAL_MODULE_TAGS := optional
 LOCAL_MODULE := core
+LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/JavaLibrary.mk
 
 include $(BUILD_JAVA_LIBRARY)
 
@@ -98,6 +99,7 @@ LOCAL_STATIC_JAVA_LIBRARIES := sqlite-jdbc mockwebserver
 LOCAL_JAVACFLAGS := $(local_javac_flags)
 LOCAL_MODULE_TAGS := tests
 LOCAL_MODULE := core-tests
+LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/JavaLibrary.mk
 LOCAL_NO_EMMA_INSTRUMENT := true
 LOCAL_NO_EMMA_COMPILE := true
 include $(BUILD_STATIC_JAVA_LIBRARY)
@@ -140,6 +142,7 @@ ifeq ($(WITH_HOST_DALVIK),true)
 
     LOCAL_MODULE_TAGS := optional
     LOCAL_MODULE := core-hostdex
+    LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/JavaLibrary.mk
 
     include $(BUILD_HOST_JAVA_LIBRARY)
 
@@ -153,6 +156,7 @@ ifeq ($(WITH_HOST_DALVIK),true)
     LOCAL_JAVACFLAGS := $(local_javac_flags)
     LOCAL_MODULE_TAGS := optional
     LOCAL_MODULE := core-tests-hostdex
+    LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/JavaLibrary.mk
     LOCAL_NO_EMMA_INSTRUMENT := true
     LOCAL_NO_EMMA_COMPILE := true
     LOCAL_BUILD_HOST_DEX := true
@@ -190,6 +194,7 @@ LOCAL_JAVACFLAGS := $(local_javac_flags)
 LOCAL_MODULE_CLASS:=JAVA_LIBRARIES
 
 LOCAL_MODULE := libcore
+LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/JavaLibrary.mk
 
 LOCAL_DROIDDOC_OPTIONS:= \
  -offlinemode \
diff --git a/NativeCode.mk b/NativeCode.mk
index fae0fce..1aab901 100644
--- a/NativeCode.mk
+++ b/NativeCode.mk
@@ -53,6 +53,7 @@ endef
 # set up.
 include $(CLEAR_VARS)
 LOCAL_MODULE := $(core_magic_local_target)
+LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/NativeCode.mk
 core_src_files :=
 
 # Include the sub.mk files.
@@ -88,6 +89,7 @@ LOCAL_SHARED_LIBRARIES := $(core_shared_libraries) libexpat libicuuc libicui18n
 LOCAL_STATIC_LIBRARIES := $(core_static_libraries)
 LOCAL_MODULE_TAGS := optional
 LOCAL_MODULE := libjavacore
+LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/NativeCode.mk
 
 LOCAL_C_INCLUDES += external/stlport/stlport bionic/ bionic/libstdc++/include
 LOCAL_SHARED_LIBRARIES += libstlport
@@ -108,6 +110,7 @@ ifeq ($(WITH_HOST_DALVIK),true)
     LOCAL_LDLIBS += -ldl -lpthread
     LOCAL_MODULE_TAGS := optional
     LOCAL_MODULE := libjavacore
+    LOCAL_ADDITIONAL_DEPENDENCIES := $(LOCAL_PATH)/NativeCode.mk
     LOCAL_SHARED_LIBRARIES := $(core_shared_libraries) libexpat libicuuc libicui18n libssl libcrypto libz-host
     LOCAL_STATIC_LIBRARIES := $(core_static_libraries)
     include $(BUILD_HOST_SHARED_LIBRARY)
-- 
cgit v1.1


From 1124a814d698ed6fd68ac501f5dddfa103d656fd Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Tue, 28 Aug 2012 17:57:02 -0700
Subject: Fix two unused variable warnings, and tidy up NET_FAILURE_RETRY.

Despite being the original author, every time I look at NET_FAILURE_RETRY
I think the uninitialized "int fd;" is a bug. So let's kill that. Potentially
we could offer even more complete exception detail messages now, but I've
left that as a possible TODO.

Change-Id: I3a175c659dd6bdeb111938e2547710bb4880cc02
---
 luni/src/main/native/libcore_io_Posix.cpp | 50 ++++++++++++-------------------
 1 file changed, 19 insertions(+), 31 deletions(-)

diff --git a/luni/src/main/native/libcore_io_Posix.cpp b/luni/src/main/native/libcore_io_Posix.cpp
index 64121d6..7102428 100644
--- a/luni/src/main/native/libcore_io_Posix.cpp
+++ b/luni/src/main/native/libcore_io_Posix.cpp
@@ -67,36 +67,27 @@ struct addrinfo_deleter {
 };
 
 /**
- * Used to retry syscalls that can return EINTR. This differs from TEMP_FAILURE_RETRY in that
- * it also considers the case where the reason for failure is that another thread called
- * Socket.close.
- *
- * Assumes 'JNIEnv* env' and 'jobject javaFd' (which is a java.io.FileDescriptor) are in scope.
+ * Used to retry networking system calls that can return EINTR. Unlike TEMP_FAILURE_RETRY,
+ * this also handles the case where the reason for failure is that another thread called
+ * Socket.close. This macro also throws exceptions on failure.
  *
  * Returns the result of 'exp', though a Java exception will be pending if the result is -1.
- *
- * Correct usage looks like this:
- *
- * void Posix_syscall(JNIEnv* env, jobject javaFd, ...) {
- *     ...
- *     int fd;
- *     NET_FAILURE_RETRY("syscall", syscall(fd, ...)); // Throws on error.
- * }
  */
-#define NET_FAILURE_RETRY(syscall_name, exp) ({ \
-    typeof (exp) _rc = -1; \
+#define NET_FAILURE_RETRY(jni_env, return_type, syscall_name, java_fd, ...) ({ \
+    return_type _rc = -1; \
     do { \
         { \
-            fd = jniGetFDFromFileDescriptor(env, javaFd); \
-            AsynchronousSocketCloseMonitor monitor(fd); \
-            _rc = (exp); \
+            int _fd = jniGetFDFromFileDescriptor(jni_env, java_fd); \
+            AsynchronousSocketCloseMonitor _monitor(_fd); \
+            _rc = syscall_name(_fd, __VA_ARGS__); \
         } \
         if (_rc == -1) { \
-            if (jniGetFDFromFileDescriptor(env, javaFd) == -1) { \
-                jniThrowException(env, "java/net/SocketException", "Socket closed"); \
+            if (jniGetFDFromFileDescriptor(jni_env, java_fd) == -1) { \
+                jniThrowException(jni_env, "java/net/SocketException", "Socket closed"); \
                 break; \
             } else if (errno != EINTR) { \
-                throwErrnoException(env, syscall_name); \
+                /* TODO: with a format string we could show the arguments too, like strace(1). */ \
+                throwErrnoException(jni_env, # syscall_name); \
                 break; \
             } \
         } \
@@ -379,10 +370,9 @@ static jobject Posix_accept(JNIEnv* env, jobject, jobject javaFd, jobject javaIn
     sockaddr_storage ss;
     socklen_t sl = sizeof(ss);
     memset(&ss, 0, sizeof(ss));
-    int fd;
     sockaddr* peer = (javaInetSocketAddress != NULL) ? reinterpret_cast<sockaddr*>(&ss) : NULL;
     socklen_t* peerLength = (javaInetSocketAddress != NULL) ? &sl : 0;
-    jint clientFd = NET_FAILURE_RETRY("accept", accept(fd, peer, peerLength));
+    jint clientFd = NET_FAILURE_RETRY(env, int, accept, javaFd, peer, peerLength);
     if (clientFd == -1 || !fillInetSocketAddress(env, clientFd, javaInetSocketAddress, &ss)) {
         close(clientFd);
         return NULL;
@@ -407,9 +397,9 @@ static void Posix_bind(JNIEnv* env, jobject, jobject javaFd, jobject javaAddress
     if (!inetAddressToSockaddr(env, javaAddress, port, &ss)) {
         return;
     }
-    int fd;
     const sockaddr* sa = reinterpret_cast<const sockaddr*>(&ss);
-    NET_FAILURE_RETRY("bind", bind(fd, sa, sizeof(sockaddr_storage)));
+    // We don't need the return value because we'll already have thrown.
+    (void) NET_FAILURE_RETRY(env, int, bind, javaFd, sa, sizeof(sockaddr_storage));
 }
 
 static void Posix_chmod(JNIEnv* env, jobject, jstring javaPath, jint mode) {
@@ -445,9 +435,9 @@ static void Posix_connect(JNIEnv* env, jobject, jobject javaFd, jobject javaAddr
     if (!inetAddressToSockaddr(env, javaAddress, port, &ss)) {
         return;
     }
-    int fd;
     const sockaddr* sa = reinterpret_cast<const sockaddr*>(&ss);
-    NET_FAILURE_RETRY("connect", connect(fd, sa, sizeof(sockaddr_storage)));
+    // We don't need the return value because we'll already have thrown.
+    (void) NET_FAILURE_RETRY(env, int, connect, javaFd, sa, sizeof(sockaddr_storage));
 }
 
 static jobject Posix_dup(JNIEnv* env, jobject, jobject javaOldFd) {
@@ -1009,10 +999,9 @@ static jint Posix_recvfromBytes(JNIEnv* env, jobject, jobject javaFd, jobject ja
     sockaddr_storage ss;
     socklen_t sl = sizeof(ss);
     memset(&ss, 0, sizeof(ss));
-    int fd;
     sockaddr* from = (javaInetSocketAddress != NULL) ? reinterpret_cast<sockaddr*>(&ss) : NULL;
     socklen_t* fromLength = (javaInetSocketAddress != NULL) ? &sl : 0;
-    jint recvCount = NET_FAILURE_RETRY("recvfrom", recvfrom(fd, bytes.get() + byteOffset, byteCount, flags, from, fromLength));
+    jint recvCount = NET_FAILURE_RETRY(env, ssize_t, recvfrom, javaFd, bytes.get() + byteOffset, byteCount, flags, from, fromLength);
     fillInetSocketAddress(env, recvCount, javaInetSocketAddress, &ss);
     return recvCount;
 }
@@ -1064,10 +1053,9 @@ static jint Posix_sendtoBytes(JNIEnv* env, jobject, jobject javaFd, jobject java
     if (javaInetAddress != NULL && !inetAddressToSockaddr(env, javaInetAddress, port, &ss)) {
         return -1;
     }
-    int fd;
     const sockaddr* to = (javaInetAddress != NULL) ? reinterpret_cast<const sockaddr*>(&ss) : NULL;
     socklen_t toLength = (javaInetAddress != NULL) ? sizeof(ss) : 0;
-    return NET_FAILURE_RETRY("sendto", sendto(fd, bytes.get() + byteOffset, byteCount, flags, to, toLength));
+    return NET_FAILURE_RETRY(env, ssize_t, sendto, javaFd, bytes.get() + byteOffset, byteCount, flags, to, toLength);
 }
 
 static void Posix_setegid(JNIEnv* env, jobject, jint egid) {
-- 
cgit v1.1


From a8ae31b76c5615bf025b29e96dcadf900164efed Mon Sep 17 00:00:00 2001
From: Kenny Root <kroot@google.com>
Date: Wed, 29 Aug 2012 10:38:12 -0700
Subject: Add Android KeyStore provider to StandardNames

Change-Id: Ic4bbcf5be005a74f5263e40f406f8c741e5d8d5e
---
 support/src/test/java/libcore/java/security/StandardNames.java | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/support/src/test/java/libcore/java/security/StandardNames.java b/support/src/test/java/libcore/java/security/StandardNames.java
index 8f427bf..8af3e93 100644
--- a/support/src/test/java/libcore/java/security/StandardNames.java
+++ b/support/src/test/java/libcore/java/security/StandardNames.java
@@ -450,6 +450,12 @@ public final class StandardNames extends Assert {
 
             // Android's CA store
             provide("KeyStore", "AndroidCAStore");
+
+            // Android's KeyStore provider
+            if (Security.getProvider("AndroidKeyStoreProvider") != null) {
+                provide("KeyStore", "AndroidKeyStore");
+                provide("KeyPairGenerator", "AndroidKeyPairGenerator");
+            }
         }
     }
 
-- 
cgit v1.1


From e8a6961f1019157540fb7928ca38bf0615bfccb4 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Wed, 29 Aug 2012 14:10:17 -0700
Subject: Add a test for ICU.getScript and ICU.addLikelySubtags.

Bug: 6156912
Change-Id: I44ec29812bbddd8034e0d568425eb0a63bb9d4f2
---
 luni/src/test/java/libcore/icu/ICUTest.java | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/luni/src/test/java/libcore/icu/ICUTest.java b/luni/src/test/java/libcore/icu/ICUTest.java
index 9282167..a7e732c 100644
--- a/luni/src/test/java/libcore/icu/ICUTest.java
+++ b/luni/src/test/java/libcore/icu/ICUTest.java
@@ -53,4 +53,12 @@ public class ICUTest extends junit.framework.TestCase {
         assertEquals(new Locale("", "", "POSIX"), ICU.localeFromString("__POSIX"));
         assertEquals(new Locale("aa", "BB", "CC"), ICU.localeFromString("aa_BB_CC"));
     }
+
+    public void test_getScript_addLikelySubtags() throws Exception {
+        assertEquals("Latn", ICU.getScript(ICU.addLikelySubtags("en_US")));
+        assertEquals("Hebr", ICU.getScript(ICU.addLikelySubtags("he")));
+        assertEquals("Hebr", ICU.getScript(ICU.addLikelySubtags("he_IL")));
+        assertEquals("Hebr", ICU.getScript(ICU.addLikelySubtags("iw")));
+        assertEquals("Hebr", ICU.getScript(ICU.addLikelySubtags("iw_IL")));
+    }
 }
-- 
cgit v1.1


From a3cb41e5a975dfe5ede995e8fbe6ff86ae5f6615 Mon Sep 17 00:00:00 2001
From: Kenny Root <kroot@google.com>
Date: Tue, 28 Aug 2012 16:13:39 -0700
Subject: Add test for bogus ProtectionParameter

KeyStoreTest didn't test bogus ProtectionParameter arguments.

Also fix to run under RI.

Change-Id: I4bc742f5a543facf145a29e0d4fd0e4c9d3d5a35
---
 .../java/libcore/java/security/KeyStoreTest.java   | 26 ++++++++++++++++++----
 1 file changed, 22 insertions(+), 4 deletions(-)

diff --git a/luni/src/test/java/libcore/java/security/KeyStoreTest.java b/luni/src/test/java/libcore/java/security/KeyStoreTest.java
index 14d0987..f57b73f 100644
--- a/luni/src/test/java/libcore/java/security/KeyStoreTest.java
+++ b/luni/src/test/java/libcore/java/security/KeyStoreTest.java
@@ -21,6 +21,7 @@ import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
+import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.security.Key;
@@ -50,7 +51,6 @@ import java.util.Set;
 import javax.crypto.KeyGenerator;
 import javax.crypto.SecretKey;
 import junit.framework.TestCase;
-import libcore.io.IoUtils;
 
 public class KeyStoreTest extends TestCase {
 
@@ -1755,6 +1755,9 @@ public class KeyStoreTest extends TestCase {
         }
     }
 
+    public static class FakeProtectionParameter implements ProtectionParameter {
+    }
+
     public void test_KeyStore_setEntry() throws Exception {
         for (KeyStore keyStore : keyStores()) {
             keyStore.load(null, null);
@@ -1768,6 +1771,16 @@ public class KeyStoreTest extends TestCase {
         for (KeyStore keyStore : keyStores()) {
             keyStore.load(null, null);
 
+            try {
+                keyStore.setEntry(ALIAS_PRIVATE, getPrivateKey(), new FakeProtectionParameter());
+                fail("Should not accept unknown ProtectionParameter");
+            } catch (KeyStoreException expected) {
+            }
+        }
+
+        for (KeyStore keyStore : keyStores()) {
+            keyStore.load(null, null);
+
             // test odd inputs
             try {
                 keyStore.setEntry(null, null, null);
@@ -2160,7 +2173,12 @@ public class KeyStoreTest extends TestCase {
                 assertEquals(PARAM_STORE, builder.getProtectionParameter(""));
                 assertEqualsKeyStores(file, PASSWORD_STORE, keyStore);
             } finally {
-                IoUtils.closeQuietly(os);
+                try {
+                    if (os != null) {
+                        os.close();
+                    }
+                } catch (IOException ignored) {
+                }
                 file.delete();
             }
         }
@@ -2215,7 +2233,7 @@ public class KeyStoreTest extends TestCase {
     // http://b/857840: want JKS key store
     public void testDefaultKeystore() {
         String type = KeyStore.getDefaultType();
-        assertEquals("Default keystore type must be Bouncy Castle", "BKS", type);
+        assertEquals(StandardNames.KEY_STORE_ALGORITHM, type);
 
         try {
             KeyStore store = KeyStore.getInstance(KeyStore.getDefaultType());
@@ -2225,7 +2243,7 @@ public class KeyStoreTest extends TestCase {
         }
 
         try {
-            KeyStore store = KeyStore.getInstance("BKS");
+            KeyStore store = KeyStore.getInstance(StandardNames.KEY_STORE_ALGORITHM);
             assertNotNull("Keystore must not be null", store);
         } catch (Exception ex) {
             throw new RuntimeException(ex);
-- 
cgit v1.1


From 9cc7e409710f67925a1cf3054d3ced9114d47e75 Mon Sep 17 00:00:00 2001
From: steven_huang <steven_huang@acer.com.tw>
Date: Wed, 8 Aug 2012 20:09:36 +0800
Subject: Fix SimpleDateFormatTest.java and SimpleTimeZoneTest.java's
 assumption

Not all timezone would fit standard calendar day and daylight time requirement

(cherry-pick of ca126a2e636d9803f06760c3e7ce1f046dce43d0.)

Change-Id: Ic47cc30d2f9170ca78b8820ebadd461ae9976ad3
---
 luni/src/test/java/libcore/java/text/SimpleDateFormatTest.java | 1 +
 luni/src/test/java/tests/api/java/util/SimpleTimeZoneTest.java | 1 +
 2 files changed, 2 insertions(+)

diff --git a/luni/src/test/java/libcore/java/text/SimpleDateFormatTest.java b/luni/src/test/java/libcore/java/text/SimpleDateFormatTest.java
index 4aabf2b..baa4ae2 100644
--- a/luni/src/test/java/libcore/java/text/SimpleDateFormatTest.java
+++ b/luni/src/test/java/libcore/java/text/SimpleDateFormatTest.java
@@ -51,6 +51,7 @@ public class SimpleDateFormatTest extends junit.framework.TestCase {
     // The RI fails this test because this is an ICU-compatible Android extension.
     // Necessary for correct localization in various languages (http://b/2633414).
     public void testStandAloneNames() throws Exception {
+        TimeZone.setDefault(TimeZone.getTimeZone("GMT"));
         Locale en = Locale.ENGLISH;
         Locale pl = new Locale("pl");
         Locale ru = new Locale("ru");
diff --git a/luni/src/test/java/tests/api/java/util/SimpleTimeZoneTest.java b/luni/src/test/java/tests/api/java/util/SimpleTimeZoneTest.java
index e27ec0d..618cbe4 100644
--- a/luni/src/test/java/tests/api/java/util/SimpleTimeZoneTest.java
+++ b/luni/src/test/java/tests/api/java/util/SimpleTimeZoneTest.java
@@ -691,6 +691,7 @@ public class SimpleTimeZoneTest extends junit.framework.TestCase {
      * java.util.SimpleTimeZone#setStartRule(int, int, int, int, boolean)
      */
     public void test_setStartRuleIIIIZ() {
+        TimeZone.setDefault(TimeZone.getTimeZone("GMT"));
         // Test for method void java.util.SimpleTimeZone.setStartRule(int, int,
         // int, int, boolean)
         SimpleTimeZone st = new SimpleTimeZone(TimeZone.getTimeZone("EST").getRawOffset(), "EST");
-- 
cgit v1.1


From 7695a9b3261bfee3a810e0829bd8082fe1fcb6a4 Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Wed, 29 Aug 2012 15:56:56 -0700
Subject: Disable SSL compression

Bug: 7079965

Change-Id: I8e060a827613e212bbcced66507fbf124bb04543
---
 .../main/java/libcore/net/http/HttpConnection.java |  1 -
 .../harmony/xnet/provider/jsse/NativeCrypto.java   | 64 --------------------
 .../provider/jsse/OpenSSLServerSocketImpl.java     | 24 +-------
 .../xnet/provider/jsse/OpenSSLSessionImpl.java     | 14 -----
 .../xnet/provider/jsse/OpenSSLSocketImpl.java      | 61 ++-----------------
 ...che_harmony_xnet_provider_jsse_NativeCrypto.cpp | 38 ------------
 .../xnet/provider/jsse/NativeCryptoTest.java       | 70 ----------------------
 7 files changed, 5 insertions(+), 267 deletions(-)

diff --git a/luni/src/main/java/libcore/net/http/HttpConnection.java b/luni/src/main/java/libcore/net/http/HttpConnection.java
index 2f92706..4a6e65d 100644
--- a/luni/src/main/java/libcore/net/http/HttpConnection.java
+++ b/luni/src/main/java/libcore/net/http/HttpConnection.java
@@ -199,7 +199,6 @@ final class HttpConnection {
         // tlsTolerant mimics Chrome's behavior
         if (tlsTolerant && unverifiedSocket instanceof OpenSSLSocketImpl) {
             OpenSSLSocketImpl openSslSocket = (OpenSSLSocketImpl) unverifiedSocket;
-            openSslSocket.setEnabledCompressionMethods(new String[] { "ZLIB"});
             openSslSocket.setUseSessionTickets(true);
             openSslSocket.setHostname(address.uriHost);
             // use SSLSocketFactory default enabled protocols
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/NativeCrypto.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/NativeCrypto.java
index 4ba6c4b..df35f72 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/NativeCrypto.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/NativeCrypto.java
@@ -361,7 +361,6 @@ public final class NativeCrypto {
     // SSL options from ssl.h
     public static final long SSL_OP_NO_TICKET                              = 0x00004000L;
     public static final long SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION = 0x00010000L;
-    public static final long SSL_OP_NO_COMPRESSION                         = 0x00020000L;
     public static final long SSL_OP_NO_SSLv3                               = 0x02000000L;
     public static final long SSL_OP_NO_TLSv1                               = 0x04000000L;
     public static final long SSL_OP_NO_TLSv1_1                             = 0x10000000L;
@@ -566,66 +565,6 @@ public final class NativeCrypto {
         return cipherSuites;
     }
 
-    public static final String SUPPORTED_COMPRESSION_METHOD_ZLIB = "ZLIB";
-    public static final String SUPPORTED_COMPRESSION_METHOD_NULL = "NULL";
-
-    private static final String[] SUPPORTED_COMPRESSION_METHODS
-            = { SUPPORTED_COMPRESSION_METHOD_ZLIB, SUPPORTED_COMPRESSION_METHOD_NULL };
-
-    public static String[] getSupportedCompressionMethods() {
-        return SUPPORTED_COMPRESSION_METHODS.clone();
-    }
-
-    public static final String[] getDefaultCompressionMethods() {
-        return new String[] { SUPPORTED_COMPRESSION_METHOD_NULL };
-    }
-
-    public static String[] checkEnabledCompressionMethods(String[] methods) {
-        if (methods == null) {
-            throw new IllegalArgumentException("methods == null");
-        }
-        if (methods.length < 1
-                && !methods[methods.length-1].equals(SUPPORTED_COMPRESSION_METHOD_NULL)) {
-            throw new IllegalArgumentException("last method must be NULL");
-        }
-        for (int i = 0; i < methods.length; i++) {
-            String method = methods[i];
-            if (method == null) {
-                throw new IllegalArgumentException("methods[" + i + "] == null");
-            }
-            if (!method.equals(SUPPORTED_COMPRESSION_METHOD_ZLIB)
-                    && !method.equals(SUPPORTED_COMPRESSION_METHOD_NULL)) {
-                throw new IllegalArgumentException("method " + method
-                                                   + " is not supported");
-            }
-        }
-        return methods;
-    }
-
-    public static void setEnabledCompressionMethods(int ssl, String[] methods) {
-        checkEnabledCompressionMethods(methods);
-        // openssl uses negative logic letting you disable compression.
-        // so first, assume we need to set all (disable all) and clear none (enable none).
-        // in the loop, selectively move bits from set to clear (from disable to enable)
-        long optionsToSet = (SSL_OP_NO_COMPRESSION);
-        long optionsToClear = 0;
-        for (int i = 0; i < methods.length; i++) {
-            String method = methods[i];
-            if (method.equals(SUPPORTED_COMPRESSION_METHOD_NULL)) {
-                // nothing to do to support NULL
-            } else if (method.equals(SUPPORTED_COMPRESSION_METHOD_ZLIB)) {
-                optionsToSet &= ~SSL_OP_NO_COMPRESSION;
-                optionsToClear |= SSL_OP_NO_COMPRESSION;
-            } else {
-                // error checked by checkEnabledCompressionMethods
-                throw new IllegalStateException();
-            }
-        }
-
-        SSL_set_options(ssl, optionsToSet);
-        SSL_clear_options(ssl, optionsToClear);
-    }
-
     /*
      * See the OpenSSL ssl.h header file for more information.
      */
@@ -729,9 +668,6 @@ public final class NativeCrypto {
 
     public static native String SSL_SESSION_cipher(int sslSessionNativePointer);
 
-    public static native String SSL_SESSION_compress_meth(int sslCtxNativePointer,
-                                                          int sslSessionNativePointer);
-
     public static native void SSL_SESSION_free(int sslSessionNativePointer);
 
     public static native byte[] i2d_SSL_SESSION(int sslSessionNativePointer);
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLServerSocketImpl.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLServerSocketImpl.java
index 841c31c..2f5fe59 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLServerSocketImpl.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLServerSocketImpl.java
@@ -32,7 +32,6 @@ public class OpenSSLServerSocketImpl extends javax.net.ssl.SSLServerSocket {
     private final SSLParametersImpl sslParameters;
     private String[] enabledProtocols = NativeCrypto.getSupportedProtocols();
     private String[] enabledCipherSuites = NativeCrypto.getDefaultCipherSuites();
-    private String[] enabledCompressionMethods = NativeCrypto.getDefaultCompressionMethods();
 
     protected OpenSSLServerSocketImpl(SSLParametersImpl sslParameters) throws IOException {
         this.sslParameters = sslParameters;
@@ -126,26 +125,6 @@ public class OpenSSLServerSocketImpl extends javax.net.ssl.SSLServerSocket {
         enabledCipherSuites = NativeCrypto.checkEnabledCipherSuites(suites);
     }
 
-    public String[] getSupportedCompressionMethods() {
-        return NativeCrypto.getSupportedCompressionMethods();
-    }
-
-    public String[] getEnabledCompressionMethods() {
-        return enabledCompressionMethods.clone();
-    }
-
-    /**
-     * This method enables the compression methods listed by
-     * getSupportedCompressionMethods().
-     *
-     * @param suites the names of all the compression methods to enable
-     * @throws IllegalArgumentException when one or more of the ciphers in array
-     *         suites are not supported, or when the array is null.
-     */
-    public void setEnabledCompressionMethods(String[] methods) {
-        enabledCompressionMethods = NativeCrypto.checkEnabledCompressionMethods(methods);
-    }
-
     @Override
     public boolean getWantClientAuth() {
         return sslParameters.getWantClientAuth();
@@ -185,8 +164,7 @@ public class OpenSSLServerSocketImpl extends javax.net.ssl.SSLServerSocket {
 
         OpenSSLSocketImpl socket = new OpenSSLSocketImpl(sslParameters,
                                                          enabledProtocols.clone(),
-                                                         enabledCipherSuites.clone(),
-                                                         enabledCompressionMethods.clone());
+                                                         enabledCipherSuites.clone());
         implAccept(socket);
         return socket;
     }
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLSessionImpl.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLSessionImpl.java
index 5895eec..003122f 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLSessionImpl.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLSessionImpl.java
@@ -49,7 +49,6 @@ public class OpenSSLSessionImpl implements SSLSession {
     private int peerPort = -1;
     private String cipherSuite;
     private String protocol;
-    private String compressionMethod;
     private AbstractSessionContext sessionContext;
     private byte[] id;
 
@@ -328,19 +327,6 @@ public class OpenSSLSessionImpl implements SSLSession {
     }
 
     /**
-     * Returns the compression method name used in all connections
-     * pertaining to this SSL session.
-     */
-    public String getCompressionMethod() {
-        if (compressionMethod == null) {
-            compressionMethod
-                    = NativeCrypto.SSL_SESSION_compress_meth(sessionContext.sslCtxNativePointer,
-                                                             sslSessionNativePointer);
-        }
-        return compressionMethod;
-    }
-
-    /**
      * Returns the context to which the actual SSL session is bound. A SSL
      * context consists of (1) a possible delegate, (2) a provider and (3) a
      * protocol.
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLSocketImpl.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLSocketImpl.java
index 065dd28..3720ba2 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLSocketImpl.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLSocketImpl.java
@@ -51,7 +51,6 @@ import org.apache.harmony.security.provider.cert.X509CertImpl;
  * Extensions to SSLSocket include:
  * <ul>
  * <li>handshake timeout
- * <li>compression methods
  * <li>session tickets
  * <li>Server Name Indication
  * </ul>
@@ -70,7 +69,6 @@ public class OpenSSLSocketImpl
     private byte[] npnProtocols;
     private String[] enabledProtocols;
     private String[] enabledCipherSuites;
-    private String[] enabledCompressionMethods;
     private boolean useSessionTickets;
     private String hostname;
     private OpenSSLSessionImpl sslSession;
@@ -108,10 +106,9 @@ public class OpenSSLSocketImpl
 
     protected OpenSSLSocketImpl(SSLParametersImpl sslParameters,
                                 String[] enabledProtocols,
-                                String[] enabledCipherSuites,
-                                String[] enabledCompressionMethods) throws IOException {
+                                String[] enabledCipherSuites) throws IOException {
         this.socket = this;
-        init(sslParameters, enabledProtocols, enabledCipherSuites, enabledCompressionMethods);
+        init(sslParameters, enabledProtocols, enabledCipherSuites);
     }
 
     protected OpenSSLSocketImpl(String host, int port, SSLParametersImpl sslParameters)
@@ -169,8 +166,7 @@ public class OpenSSLSocketImpl
     private void init(SSLParametersImpl sslParameters) throws IOException {
         init(sslParameters,
              NativeCrypto.getDefaultProtocols(),
-             NativeCrypto.getDefaultCipherSuites(),
-             NativeCrypto.getDefaultCompressionMethods());
+             NativeCrypto.getDefaultCipherSuites());
     }
 
     /**
@@ -179,12 +175,10 @@ public class OpenSSLSocketImpl
      */
     private void init(SSLParametersImpl sslParameters,
                       String[] enabledProtocols,
-                      String[] enabledCipherSuites,
-                      String[] enabledCompressionMethods) throws IOException {
+                      String[] enabledCipherSuites) throws IOException {
         this.sslParameters = sslParameters;
         this.enabledProtocols = enabledProtocols;
         this.enabledCipherSuites = enabledCipherSuites;
-        this.enabledCompressionMethods = enabledCompressionMethods;
     }
 
     /**
@@ -225,20 +219,6 @@ public class OpenSSLSocketImpl
             return null;
         }
 
-        String compressionMethod = session.getCompressionMethod();
-        if (!compressionMethod.equals(NativeCrypto.SUPPORTED_COMPRESSION_METHOD_NULL)) {
-            boolean compressionMethodFound = false;
-            for (String enabledCompressionMethod : enabledCompressionMethods) {
-                if (compressionMethod.equals(enabledCompressionMethod)) {
-                    compressionMethodFound = true;
-                    break;
-                }
-            }
-            if (!compressionMethodFound) {
-                return null;
-            }
-        }
-
         return session;
     }
 
@@ -316,10 +296,6 @@ public class OpenSSLSocketImpl
 
             NativeCrypto.setEnabledProtocols(sslNativePointer, enabledProtocols);
             NativeCrypto.setEnabledCipherSuites(sslNativePointer, enabledCipherSuites);
-            if (enabledCompressionMethods.length != 0) {
-                NativeCrypto.setEnabledCompressionMethods(sslNativePointer,
-                                                          enabledCompressionMethods);
-            }
             if (useSessionTickets) {
                 NativeCrypto.SSL_clear_options(sslNativePointer, NativeCrypto.SSL_OP_NO_TICKET);
             }
@@ -793,35 +769,6 @@ public class OpenSSLSocketImpl
     }
 
     /**
-     * The names of the compression methods that may be used on this SSL
-     * connection.
-     * @return an array of compression methods
-     */
-    public String[] getSupportedCompressionMethods() {
-        return NativeCrypto.getSupportedCompressionMethods();
-    }
-
-    /**
-     * The names of the compression methods versions that are in use
-     * on this SSL connection.
-     *
-     * @return an array of compression methods
-     */
-    public String[] getEnabledCompressionMethods() {
-        return enabledCompressionMethods.clone();
-    }
-
-    /**
-     * Enables compression methods listed by getSupportedCompressionMethods().
-     *
-     * @throws IllegalArgumentException when one or more of the names in the
-     *             array are not supported, or when the array is null.
-     */
-    public void setEnabledCompressionMethods(String[] methods) {
-        enabledCompressionMethods = NativeCrypto.checkEnabledCompressionMethods(methods);
-    }
-
-    /**
      * This method enables session ticket support.
      *
      * @param useSessionTickets True to enable session tickets
diff --git a/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp b/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
index b23adb7..df500ac 100644
--- a/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
+++ b/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
@@ -4347,43 +4347,6 @@ static jstring NativeCrypto_SSL_SESSION_cipher(JNIEnv* env, jclass, jint ssl_ses
 }
 
 /**
- * Gets and returns in a string the compression method negotiated for the SSL session.
- */
-static jstring NativeCrypto_SSL_SESSION_compress_meth(JNIEnv* env, jclass,
-                                                      jint ssl_ctx_address,
-                                                      jint ssl_session_address) {
-    SSL_CTX* ssl_ctx = to_SSL_CTX(env, ssl_ctx_address, true);
-    SSL_SESSION* ssl_session = to_SSL_SESSION(env, ssl_session_address, true);
-    JNI_TRACE("ssl_session=%p NativeCrypto_SSL_SESSION_compress_meth ssl_ctx=%p",
-              ssl_session, ssl_ctx);
-    if (ssl_ctx == NULL || ssl_session == NULL) {
-        return NULL;
-    }
-
-    int compress_meth = ssl_session->compress_meth;
-    if (compress_meth == 0) {
-        const char* name = "NULL";
-        JNI_TRACE("ssl_session=%p NativeCrypto_SSL_SESSION_compress_meth => %s", ssl_session, name);
-        return env->NewStringUTF(name);
-    }
-
-    int num_comp_methods = sk_SSL_COMP_num(ssl_ctx->comp_methods);
-    for (int i = 0; i < num_comp_methods; i++) {
-        SSL_COMP* comp = sk_SSL_COMP_value(ssl_ctx->comp_methods, i);
-        if (comp->id != compress_meth) {
-            continue;
-        }
-        const char* name = ((comp->method && comp->method->type == NID_zlib_compression)
-                            ? SN_zlib_compression
-                            : (comp->name ? comp->name : "UNKNOWN"));
-        JNI_TRACE("ssl_session=%p NativeCrypto_SSL_SESSION_compress_meth => %s", ssl_session, name);
-        return env->NewStringUTF(name);
-    }
-    throwSSLExceptionStr(env, "Unknown compression method");
-    return NULL;
-}
-
-/**
  * Frees the SSL session.
  */
 static void NativeCrypto_SSL_SESSION_free(JNIEnv* env, jclass, jint ssl_session_address) {
@@ -4535,7 +4498,6 @@ static JNINativeMethod sNativeCryptoMethods[] = {
     NATIVE_METHOD(NativeCrypto, SSL_SESSION_get_time, "(I)J"),
     NATIVE_METHOD(NativeCrypto, SSL_SESSION_get_version, "(I)Ljava/lang/String;"),
     NATIVE_METHOD(NativeCrypto, SSL_SESSION_cipher, "(I)Ljava/lang/String;"),
-    NATIVE_METHOD(NativeCrypto, SSL_SESSION_compress_meth, "(II)Ljava/lang/String;"),
     NATIVE_METHOD(NativeCrypto, SSL_SESSION_free, "(I)V"),
     NATIVE_METHOD(NativeCrypto, i2d_SSL_SESSION, "(I)[B"),
     NATIVE_METHOD(NativeCrypto, d2i_SSL_SESSION, "([B)I"),
diff --git a/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/NativeCryptoTest.java b/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/NativeCryptoTest.java
index 7a8b855..8618d05 100644
--- a/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/NativeCryptoTest.java
+++ b/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/NativeCryptoTest.java
@@ -1628,76 +1628,6 @@ public class NativeCryptoTest extends TestCase {
         server.get(TIMEOUT_SECONDS, TimeUnit.SECONDS);
     }
 
-    public void test_SSL_SESSION_compress_meth_null() throws Exception {
-        try {
-            NativeCrypto.SSL_SESSION_compress_meth(NULL, NULL);
-            fail();
-        } catch (NullPointerException expected) {
-        }
-
-        {
-            int c = NativeCrypto.SSL_CTX_new();
-            try {
-                NativeCrypto.SSL_SESSION_compress_meth(c, NULL);
-            } catch (NullPointerException expected) {
-            }
-            NativeCrypto.SSL_CTX_free(c);
-        }
-    }
-
-    public void test_SSL_SESSION_compress_meth_NULL() throws Exception {
-        final ServerSocket listener = new ServerSocket(0);
-
-        Hooks cHooks = new Hooks() {
-            @Override
-            public void afterHandshake(int session, int s, int c,
-                                       Socket sock, FileDescriptor fd,
-                                       SSLHandshakeCallbacks callback)
-                    throws Exception {
-                assertEquals("NULL", NativeCrypto.SSL_SESSION_compress_meth(c, session));
-                super.afterHandshake(session, s, c, sock, fd, callback);
-            }
-        };
-        Hooks sHooks = new ServerHooks(getServerPrivateKey(), getServerCertificates());
-        Future<TestSSLHandshakeCallbacks> client = handshake(listener, 0, true, cHooks, null);
-        Future<TestSSLHandshakeCallbacks> server = handshake(listener, 0, false, sHooks, null);
-        client.get(TIMEOUT_SECONDS, TimeUnit.SECONDS);
-        server.get(TIMEOUT_SECONDS, TimeUnit.SECONDS);
-    }
-
-    public void test_SSL_SESSION_compress_meth_ZLIB() throws Exception {
-        final ServerSocket listener = new ServerSocket(0);
-
-        Hooks cHooks = new Hooks() {
-            @Override
-            public int beforeHandshake(int c) throws SSLException {
-                int s = super.beforeHandshake(c);
-                NativeCrypto.SSL_clear_options(s, NativeCrypto.SSL_OP_NO_COMPRESSION);
-                return s;
-            }
-            @Override
-            public void afterHandshake(int session, int s, int c,
-                                       Socket sock, FileDescriptor fd,
-                                       SSLHandshakeCallbacks callback)
-                    throws Exception {
-                assertEquals("ZLIB", NativeCrypto.SSL_SESSION_compress_meth(c, session));
-                super.afterHandshake(session, s, c, sock, fd, callback);
-            }
-        };
-        Hooks sHooks = new ServerHooks(getServerPrivateKey(), getServerCertificates()) {
-            @Override
-            public int beforeHandshake(int c) throws SSLException {
-                int s = super.beforeHandshake(c);
-                NativeCrypto.SSL_clear_options(s, NativeCrypto.SSL_OP_NO_COMPRESSION);
-                return s;
-            }
-        };
-        Future<TestSSLHandshakeCallbacks> client = handshake(listener, 0, true, cHooks, null);
-        Future<TestSSLHandshakeCallbacks> server = handshake(listener, 0, false, sHooks, null);
-        client.get(TIMEOUT_SECONDS, TimeUnit.SECONDS);
-        server.get(TIMEOUT_SECONDS, TimeUnit.SECONDS);
-    }
-
     public void test_SSL_SESSION_free() throws Exception {
         try {
             NativeCrypto.SSL_SESSION_free(NULL);
-- 
cgit v1.1


From 5ab96b6746a5a8f9f4e3902379c0b6f062c0d2e0 Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Thu, 30 Aug 2012 16:10:33 -0700
Subject: Fix test_KeyStore_setEntry issue

Also include KeyStore type information in failure output.

Change-Id: I60f30e2264fa1516f489c79a69a6a213af961419
---
 .../java/libcore/java/security/KeyStoreTest.java   | 238 +++++++++++----------
 1 file changed, 129 insertions(+), 109 deletions(-)

diff --git a/luni/src/test/java/libcore/java/security/KeyStoreTest.java b/luni/src/test/java/libcore/java/security/KeyStoreTest.java
index f57b73f..15314c9 100644
--- a/luni/src/test/java/libcore/java/security/KeyStoreTest.java
+++ b/luni/src/test/java/libcore/java/security/KeyStoreTest.java
@@ -207,7 +207,7 @@ public class KeyStoreTest extends TestCase {
         if (isReadOnly(ks)) {
             try {
                 setPrivateKey(ks);
-                fail();
+                fail(ks.toString());
             } catch (UnsupportedOperationException e) {
             }
             return;
@@ -377,7 +377,7 @@ public class KeyStoreTest extends TestCase {
         String type = KeyStore.getDefaultType();
         try {
             KeyStore.getInstance(null);
-            fail();
+            fail(type);
         } catch (NullPointerException expected) {
         }
 
@@ -386,12 +386,12 @@ public class KeyStoreTest extends TestCase {
         String providerName = StandardNames.SECURITY_PROVIDER_NAME;
         try {
             KeyStore.getInstance(null, (String)null);
-            fail();
+            fail(type);
         } catch (IllegalArgumentException expected) {
         }
         try {
             KeyStore.getInstance(null, providerName);
-            fail();
+            fail(type);
         } catch (Exception e) {
             if (e.getClass() != NullPointerException.class
                 && e.getClass() != KeyStoreException.class) {
@@ -400,7 +400,7 @@ public class KeyStoreTest extends TestCase {
         }
         try {
             KeyStore.getInstance(type, (String)null);
-            fail();
+            fail(type);
         } catch (IllegalArgumentException expected) {
         }
         assertNotNull(KeyStore.getInstance(type, providerName));
@@ -408,17 +408,17 @@ public class KeyStoreTest extends TestCase {
         Provider provider = Security.getProvider(providerName);
         try {
             KeyStore.getInstance(null, (Provider)null);
-            fail();
+            fail(type);
         } catch (IllegalArgumentException expected) {
         }
         try {
             KeyStore.getInstance(null, provider);
-            fail();
+            fail(type);
         } catch (NullPointerException expected) {
         }
         try {
             KeyStore.getInstance(type, (Provider)null);
-            fail();
+            fail(type);
         } catch (IllegalArgumentException expected) {
         }
         assertNotNull(KeyStore.getInstance(type, provider));
@@ -457,7 +457,7 @@ public class KeyStoreTest extends TestCase {
         for (KeyStore keyStore : keyStores()) {
             try {
                 keyStore.getKey(null, null);
-                fail();
+                fail(keyStore.getType());
             } catch (KeyStoreException expected) {
             }
         }
@@ -468,7 +468,7 @@ public class KeyStoreTest extends TestCase {
             // test odd inputs
             try {
                 keyStore.getKey(null, null);
-                fail();
+                fail(keyStore.getType());
             } catch (Exception e) {
                 if (e.getClass() != NullPointerException.class
                     && e.getClass() != IllegalArgumentException.class) {
@@ -477,7 +477,7 @@ public class KeyStoreTest extends TestCase {
             }
             try {
                 keyStore.getKey(null, PASSWORD_KEY);
-                fail();
+                fail(keyStore.getType());
             } catch (Exception e) {
                 if (e.getClass() != NullPointerException.class
                     && e.getClass() != IllegalArgumentException.class
@@ -520,7 +520,7 @@ public class KeyStoreTest extends TestCase {
                 } else {
                     try {
                         keyStore.getKey(ALIAS_PRIVATE, null);
-                        fail();
+                        fail(keyStore.getType());
                     } catch (Exception e) {
                         if (e.getClass() != UnrecoverableKeyException.class
                             && e.getClass() != IllegalArgumentException.class) {
@@ -534,7 +534,7 @@ public class KeyStoreTest extends TestCase {
             } else if (isSecretKeyEnabled(keyStore)) {
                 try {
                     keyStore.getKey(ALIAS_SECRET, null);
-                    fail();
+                    fail(keyStore.getType());
                 } catch (Exception e) {
                     if (e.getClass() != UnrecoverableKeyException.class
                         && e.getClass() != IllegalArgumentException.class) {
@@ -551,7 +551,7 @@ public class KeyStoreTest extends TestCase {
             } else {
                 try {
                     keyStore.getKey(ALIAS_PRIVATE, PASSWORD_BAD);
-                    fail();
+                    fail(keyStore.getType());
                 } catch (UnrecoverableKeyException expected) {
                 }
             }
@@ -560,7 +560,7 @@ public class KeyStoreTest extends TestCase {
             } else if (isSecretKeyEnabled(keyStore)) {
                 try {
                     keyStore.getKey(ALIAS_SECRET, PASSWORD_BAD);
-                    fail();
+                    fail(keyStore.getType());
                 } catch (UnrecoverableKeyException expected) {
                 }
             }
@@ -571,7 +571,7 @@ public class KeyStoreTest extends TestCase {
         for (KeyStore keyStore : keyStores()) {
             try {
                 keyStore.getCertificateChain(null);
-                fail();
+                fail(keyStore.getType());
             } catch (KeyStoreException expected) {
             }
         }
@@ -581,7 +581,7 @@ public class KeyStoreTest extends TestCase {
             // test odd inputs
             try {
                 keyStore.getCertificateChain(null);
-                fail();
+                fail(keyStore.getType());
             } catch (Exception e) {
                 if (e.getClass() != NullPointerException.class
                     && e.getClass() != IllegalArgumentException.class) {
@@ -610,7 +610,7 @@ public class KeyStoreTest extends TestCase {
         for (KeyStore keyStore : keyStores()) {
             try {
                 keyStore.getCertificate(null);
-                fail();
+                fail(keyStore.getType());
             } catch (KeyStoreException expected) {
             }
         }
@@ -620,7 +620,7 @@ public class KeyStoreTest extends TestCase {
             // test odd inputs
             try {
                 keyStore.getCertificate(null);
-                fail();
+                fail(keyStore.getType());
             } catch (Exception e) {
                 if (e.getClass() != NullPointerException.class
                     && e.getClass() != IllegalArgumentException.class) {
@@ -651,7 +651,7 @@ public class KeyStoreTest extends TestCase {
         for (KeyStore keyStore : keyStores()) {
             try {
                 keyStore.getCreationDate(null);
-                fail();
+                fail(keyStore.getType());
             } catch (KeyStoreException expected) {
             }
         }
@@ -664,7 +664,7 @@ public class KeyStoreTest extends TestCase {
             // test odd inputs
             try {
                 keyStore.getCreationDate(null);
-                fail();
+                fail(keyStore.getType());
             } catch (NullPointerException expected) {
             }
             assertNull(keyStore.getCreationDate(""));
@@ -696,7 +696,7 @@ public class KeyStoreTest extends TestCase {
         for (KeyStore keyStore : keyStores()) {
             try {
                 keyStore.setKeyEntry(null, null, null, null);
-                fail();
+                fail(keyStore.getType());
             } catch (KeyStoreException expected) {
             }
         }
@@ -706,7 +706,7 @@ public class KeyStoreTest extends TestCase {
             if (isReadOnly(keyStore)) {
                 try {
                     keyStore.setKeyEntry(null, null, null, null);
-                    fail();
+                    fail(keyStore.getType());
                 } catch (UnsupportedOperationException expected) {
                 }
                 continue;
@@ -715,7 +715,7 @@ public class KeyStoreTest extends TestCase {
             // test odd inputs
             try {
                 keyStore.setKeyEntry(null, null, null, null);
-                fail();
+                fail(keyStore.getType());
             } catch (Exception e) {
                 if (e.getClass() != NullPointerException.class
                     && e.getClass() != KeyStoreException.class) {
@@ -724,7 +724,7 @@ public class KeyStoreTest extends TestCase {
             }
             try {
                 keyStore.setKeyEntry(null, null, PASSWORD_KEY, null);
-                fail();
+                fail(keyStore.getType());
             } catch (Exception e) {
                 if (e.getClass() != NullPointerException.class
                     && e.getClass() != KeyStoreException.class) {
@@ -736,7 +736,7 @@ public class KeyStoreTest extends TestCase {
                                      getPrivateKey().getPrivateKey(),
                                      PASSWORD_KEY,
                                      null);
-                fail();
+                fail(keyStore.getType());
             } catch (IllegalArgumentException expected) {
             }
         }
@@ -749,7 +749,7 @@ public class KeyStoreTest extends TestCase {
             if (isReadOnly(keyStore)) {
                 try {
                     keyStore.setKeyEntry(ALIAS_SECRET, getSecretKey(), PASSWORD_KEY, null);
-                    fail();
+                    fail(keyStore.getType());
                 } catch (UnsupportedOperationException expected) {
                 }
                 continue;
@@ -764,7 +764,7 @@ public class KeyStoreTest extends TestCase {
             } else {
                 try {
                     keyStore.setKeyEntry(ALIAS_SECRET, getSecretKey(), PASSWORD_KEY, null);
-                    fail();
+                    fail(keyStore.getType());
                 } catch (Exception e) {
                     if (e.getClass() != KeyStoreException.class
                         && e.getClass() != NullPointerException.class) {
@@ -820,7 +820,7 @@ public class KeyStoreTest extends TestCase {
                                          getPrivateKey().getPrivateKey(),
                                          null,
                                          getPrivateKey().getCertificateChain());
-                    fail();
+                    fail(keyStore.getType());
                 } catch (UnsupportedOperationException expected) {
                 }
                 continue;
@@ -839,7 +839,7 @@ public class KeyStoreTest extends TestCase {
                                          getPrivateKey().getPrivateKey(),
                                          null,
                                          getPrivateKey().getCertificateChain());
-                    fail();
+                    fail(keyStore.getType());
                 } catch (Exception e) {
                     if (e.getClass() != UnrecoverableKeyException.class
                         && e.getClass() != IllegalArgumentException.class
@@ -855,7 +855,7 @@ public class KeyStoreTest extends TestCase {
                 } else {
                     try {
                         keyStore.setKeyEntry(ALIAS_SECRET, getSecretKey(), null, null);
-                        fail();
+                        fail(keyStore.getType());
                     } catch (Exception e) {
                         if (e.getClass() != UnrecoverableKeyException.class
                             && e.getClass() != IllegalArgumentException.class
@@ -872,7 +872,7 @@ public class KeyStoreTest extends TestCase {
         for (KeyStore keyStore : keyStores()) {
             try {
                 keyStore.setKeyEntry(null, null, null);
-                fail();
+                fail(keyStore.getType());
             } catch (KeyStoreException expected) {
             }
         }
@@ -883,7 +883,7 @@ public class KeyStoreTest extends TestCase {
             if (isReadOnly(keyStore)) {
                 try {
                     keyStore.setKeyEntry(null, null, null);
-                    fail();
+                    fail(keyStore.getType());
                 } catch (UnsupportedOperationException expected) {
                 }
                 continue;
@@ -892,7 +892,7 @@ public class KeyStoreTest extends TestCase {
             // test odd inputs
             try {
                 keyStore.setKeyEntry(null, null, null);
-                fail();
+                fail(keyStore.getType());
             } catch (Exception e) {
                 if (e.getClass() != NullPointerException.class
                     && e.getClass() != IllegalArgumentException.class
@@ -920,7 +920,7 @@ public class KeyStoreTest extends TestCase {
             if (isReadOnly(keyStore)) {
                 try {
                     setPrivateKeyBytes(keyStore);
-                    fail();
+                    fail(keyStore.getType());
                 } catch (UnsupportedOperationException expected) {
                 }
                 continue;
@@ -935,7 +935,7 @@ public class KeyStoreTest extends TestCase {
             } else {
                 try {
                     keyStore.setKeyEntry(ALIAS_SECRET, getSecretKey().getEncoded(), null);
-                    fail();
+                    fail(keyStore.getType());
                 } catch (KeyStoreException expected) {
                 }
             }
@@ -994,7 +994,7 @@ public class KeyStoreTest extends TestCase {
         for (KeyStore keyStore : keyStores()) {
             try {
                 keyStore.setCertificateEntry(null, null);
-                fail();
+                fail(keyStore.getType());
             } catch (KeyStoreException expected) {
             }
         }
@@ -1005,7 +1005,7 @@ public class KeyStoreTest extends TestCase {
             // test odd inputs
             try {
                 keyStore.setCertificateEntry(null, null);
-                fail();
+                fail(keyStore.getType());
             } catch (Exception e) {
                 if (e.getClass() != NullPointerException.class
                     && e.getClass() != KeyStoreException.class) {
@@ -1017,7 +1017,7 @@ public class KeyStoreTest extends TestCase {
                 try {
                     assertNull(keyStore.getCertificate(ALIAS_CERTIFICATE));
                     keyStore.setCertificateEntry(ALIAS_CERTIFICATE, null);
-                    fail();
+                    fail(keyStore.getType());
                 } catch (UnsupportedOperationException expected) {
                 }
                 continue;
@@ -1042,7 +1042,7 @@ public class KeyStoreTest extends TestCase {
             } else {
                 try {
                     keyStore.setCertificateEntry(ALIAS_CERTIFICATE, null);
-                    fail();
+                    fail(keyStore.getType());
                 } catch (KeyStoreException expected) {
                 }
             }
@@ -1060,7 +1060,7 @@ public class KeyStoreTest extends TestCase {
             if (isReadOnly(keyStore)) {
                 try {
                     setCertificate(keyStore);
-                    fail();
+                    fail(keyStore.getType());
                 } catch (UnsupportedOperationException expected) {
                 }
                 continue;
@@ -1104,7 +1104,7 @@ public class KeyStoreTest extends TestCase {
         for (KeyStore keyStore : keyStores()) {
             try {
                 keyStore.deleteEntry(null);
-                fail();
+                fail(keyStore.getType());
             } catch (KeyStoreException expected) {
             }
         }
@@ -1115,7 +1115,7 @@ public class KeyStoreTest extends TestCase {
             if (isReadOnly(keyStore)) {
                 try {
                     keyStore.deleteEntry(null);
-                    fail();
+                    fail(keyStore.getType());
                 } catch (UnsupportedOperationException expected) {
                 }
                 continue;
@@ -1124,7 +1124,7 @@ public class KeyStoreTest extends TestCase {
             // test odd inputs
             try {
                 keyStore.deleteEntry(null);
-                fail();
+                fail(keyStore.getType());
             } catch (Exception e) {
                 if (e.getClass() != NullPointerException.class
                     && e.getClass() != KeyStoreException.class) {
@@ -1201,7 +1201,7 @@ public class KeyStoreTest extends TestCase {
         for (KeyStore keyStore : keyStores()) {
             try {
                 keyStore.aliases();
-                fail();
+                fail(keyStore.getType());
             } catch (KeyStoreException expected) {
             }
         }
@@ -1245,7 +1245,7 @@ public class KeyStoreTest extends TestCase {
         for (KeyStore keyStore : keyStores()) {
             try {
                 keyStore.containsAlias(null);
-                fail();
+                fail(keyStore.getType());
             } catch (KeyStoreException expected) {
             }
         }
@@ -1255,7 +1255,7 @@ public class KeyStoreTest extends TestCase {
 
             try {
                 keyStore.containsAlias(null);
-                fail();
+                fail(keyStore.getType());
             } catch (NullPointerException expected) {
             }
 
@@ -1288,7 +1288,7 @@ public class KeyStoreTest extends TestCase {
         for (KeyStore keyStore : keyStores()) {
             try {
                 keyStore.aliases();
-                fail();
+                fail(keyStore.getType());
             } catch (KeyStoreException expected) {
             }
         }
@@ -1330,7 +1330,7 @@ public class KeyStoreTest extends TestCase {
         for (KeyStore keyStore : keyStores()) {
             try {
                 keyStore.isKeyEntry(null);
-                fail();
+                fail(keyStore.getType());
             } catch (KeyStoreException expected) {
             }
         }
@@ -1340,7 +1340,7 @@ public class KeyStoreTest extends TestCase {
 
             try {
                 keyStore.isKeyEntry(null);
-                fail();
+                fail(keyStore.getType());
             } catch (NullPointerException expected) {
             }
 
@@ -1371,7 +1371,7 @@ public class KeyStoreTest extends TestCase {
         for (KeyStore keyStore : keyStores()) {
             try {
                 keyStore.isCertificateEntry(null);
-                fail();
+                fail(keyStore.getType());
             } catch (KeyStoreException expected) {
             }
         }
@@ -1382,7 +1382,7 @@ public class KeyStoreTest extends TestCase {
             if (isCertificateEnabled(keyStore)) {
                 try {
                     keyStore.isCertificateEntry(null);
-                    fail();
+                    fail(keyStore.getType());
                 } catch (NullPointerException expected) {
                 }
             } else {
@@ -1415,7 +1415,7 @@ public class KeyStoreTest extends TestCase {
         for (KeyStore keyStore : keyStores()) {
             try {
                 keyStore.getCertificateAlias(null);
-                fail();
+                fail(keyStore.getType());
             } catch (KeyStoreException expected) {
             }
         }
@@ -1479,7 +1479,7 @@ public class KeyStoreTest extends TestCase {
         for (KeyStore keyStore : keyStores()) {
             try {
                 keyStore.store(null, null);
-                fail();
+                fail(keyStore.getType());
             } catch (KeyStoreException expected) {
             }
         }
@@ -1490,7 +1490,7 @@ public class KeyStoreTest extends TestCase {
             if (isReadOnly(keyStore)) {
                 try {
                     keyStore.store(out, null);
-                    fail();
+                    fail(keyStore.getType());
                 } catch (UnsupportedOperationException expected) {
                 }
                 continue;
@@ -1504,7 +1504,7 @@ public class KeyStoreTest extends TestCase {
 
             try {
                 keyStore.store(out, null);
-                fail();
+                fail(keyStore.getType());
             } catch (Exception e) {
                 if (e.getClass() != IllegalArgumentException.class
                     && e.getClass() != NullPointerException.class) {
@@ -1520,7 +1520,7 @@ public class KeyStoreTest extends TestCase {
             if (isReadOnly(keyStore)) {
                 try {
                     keyStore.store(out, null);
-                    fail();
+                    fail(keyStore.getType());
                 } catch (UnsupportedOperationException e) {
                 }
             } else if (isNullPasswordAllowed(keyStore)) {
@@ -1529,7 +1529,7 @@ public class KeyStoreTest extends TestCase {
             } else {
                 try {
                     keyStore.store(out, null);
-                    fail();
+                    fail(keyStore.getType());
                 } catch (Exception e) {
                     if (e.getClass() != IllegalArgumentException.class
                         && e.getClass() != NullPointerException.class) {
@@ -1545,7 +1545,7 @@ public class KeyStoreTest extends TestCase {
             if (isReadOnly(keyStore)) {
                 try {
                     keyStore.store(out, PASSWORD_STORE);
-                    fail();
+                    fail(keyStore.getType());
                 } catch (UnsupportedOperationException e) {
                 }
                 continue;
@@ -1560,7 +1560,7 @@ public class KeyStoreTest extends TestCase {
             if (isReadOnly(keyStore)) {
                 try {
                     keyStore.store(out, PASSWORD_STORE);
-                    fail();
+                    fail(keyStore.getType());
                 } catch (UnsupportedOperationException e) {
                 }
                 continue;
@@ -1574,7 +1574,7 @@ public class KeyStoreTest extends TestCase {
         for (KeyStore keyStore : keyStores()) {
             try {
                 keyStore.store(null);
-                fail();
+                fail(keyStore.getType());
             } catch (KeyStoreException expected) {
             }
         }
@@ -1583,7 +1583,7 @@ public class KeyStoreTest extends TestCase {
             keyStore.load(null, null);
             try {
                 keyStore.store(null);
-                fail();
+                fail(keyStore.getType());
             } catch (UnsupportedOperationException expected) {
                 assertFalse(isLoadStoreParameterSupported(keyStore));
             } catch (IllegalArgumentException expected) {
@@ -1632,7 +1632,7 @@ public class KeyStoreTest extends TestCase {
                             return null;
                         }
                     });
-                fail();
+                fail(keyStore.getType());
             } catch (UnsupportedOperationException expected) {
             }
         }
@@ -1642,7 +1642,7 @@ public class KeyStoreTest extends TestCase {
         for (KeyStore keyStore : keyStores()) {
             try {
                 keyStore.getEntry(null, null);
-                fail();
+                fail(keyStore.getType());
             } catch (NullPointerException expected) {
             }
         }
@@ -1653,12 +1653,12 @@ public class KeyStoreTest extends TestCase {
             // test odd inputs
             try {
                 keyStore.getEntry(null, null);
-                fail();
+                fail(keyStore.getType());
             } catch (NullPointerException expected) {
             }
             try {
                 keyStore.getEntry(null, PARAM_KEY);
-                fail();
+                fail(keyStore.getType());
             } catch (NullPointerException expected) {
             }
             assertNull(keyStore.getEntry("", null));
@@ -1709,7 +1709,7 @@ public class KeyStoreTest extends TestCase {
             } else {
                 try {
                     keyStore.getEntry(ALIAS_PRIVATE, null);
-                    fail();
+                    fail(keyStore.getType());
                 } catch (Exception e) {
                     if (e.getClass() != UnrecoverableKeyException.class
                         && e.getClass() != IllegalArgumentException.class) {
@@ -1722,7 +1722,7 @@ public class KeyStoreTest extends TestCase {
             } else if (isSecretKeyEnabled(keyStore)) {
                 try {
                     keyStore.getEntry(ALIAS_SECRET, null);
-                    fail();
+                    fail(keyStore.getType());
                 } catch (Exception e) {
                     if (e.getClass() != UnrecoverableKeyException.class
                         && e.getClass() != IllegalArgumentException.class) {
@@ -1739,7 +1739,7 @@ public class KeyStoreTest extends TestCase {
             } else {
                 try {
                     keyStore.getEntry(ALIAS_PRIVATE, PARAM_BAD);
-                    fail();
+                    fail(keyStore.getType());
                 } catch (UnrecoverableKeyException expected) {
                 }
             }
@@ -1748,7 +1748,7 @@ public class KeyStoreTest extends TestCase {
             } else if (isSecretKeyEnabled(keyStore)) {
                 try {
                     keyStore.getEntry(ALIAS_SECRET, PARAM_BAD);
-                    fail();
+                    fail(keyStore.getType());
                 } catch (UnrecoverableKeyException expected) {
                 }
             }
@@ -1763,7 +1763,7 @@ public class KeyStoreTest extends TestCase {
             keyStore.load(null, null);
             try {
                 keyStore.setEntry(null, null, null);
-                fail();
+                fail(keyStore.getType());
             } catch (NullPointerException expected) {
             }
         }
@@ -1784,7 +1784,7 @@ public class KeyStoreTest extends TestCase {
             // test odd inputs
             try {
                 keyStore.setEntry(null, null, null);
-                fail();
+                fail(keyStore.getType());
             } catch (Exception e) {
                 if (e.getClass() != NullPointerException.class
                     && e.getClass() != KeyStoreException.class) {
@@ -1793,7 +1793,7 @@ public class KeyStoreTest extends TestCase {
             }
             try {
                 keyStore.setEntry(null, null, PARAM_KEY);
-                fail();
+                fail(keyStore.getType());
             } catch (Exception e) {
                 if (e.getClass() != NullPointerException.class
                     && e.getClass() != KeyStoreException.class) {
@@ -1802,7 +1802,7 @@ public class KeyStoreTest extends TestCase {
             }
             try {
                 keyStore.setEntry("", null, PARAM_KEY);
-                fail();
+                fail(keyStore.getType());
             } catch (NullPointerException expected) {
             }
         }
@@ -1815,7 +1815,7 @@ public class KeyStoreTest extends TestCase {
             if (isReadOnly(keyStore)) {
                 try {
                     keyStore.setEntry(ALIAS_PRIVATE, getPrivateKey(), PARAM_KEY);
-                    fail();
+                    fail(keyStore.getType());
                 } catch (UnsupportedOperationException expected) {
                 }
                 continue;
@@ -1830,7 +1830,7 @@ public class KeyStoreTest extends TestCase {
             } else {
                 try {
                     keyStore.setKeyEntry(ALIAS_SECRET, getSecretKey(), PASSWORD_KEY, null);
-                    fail();
+                    fail(keyStore.getType());
                 } catch (KeyStoreException expected) {
                 }
             }
@@ -1845,7 +1845,7 @@ public class KeyStoreTest extends TestCase {
                     keyStore.setEntry(ALIAS_CERTIFICATE,
                                       new TrustedCertificateEntry(getPrivateKey().getCertificate()),
                                       null);
-                    fail();
+                    fail(keyStore.getType());
                 } catch (KeyStoreException expected) {
                 }
             }
@@ -1859,7 +1859,7 @@ public class KeyStoreTest extends TestCase {
             } else {
                 try {
                     keyStore.setKeyEntry(ALIAS_UNICODE_SECRET, getSecretKey(), PASSWORD_KEY, null);
-                    fail();
+                    fail(keyStore.getType());
                 } catch (KeyStoreException expected) {
                 }
             }
@@ -1944,20 +1944,33 @@ public class KeyStoreTest extends TestCase {
             keyStore.load(null, null);
 
             // test with null/non-null passwords
-            try {
-                keyStore.setEntry(ALIAS_PRIVATE, getPrivateKey(), null);
-                fail();
-            } catch (Exception e) {
-                if (e.getClass() != UnrecoverableKeyException.class
-                    && e.getClass() != IllegalArgumentException.class
-                    && e.getClass() != KeyStoreException.class) {
-                    throw e;
+            if (isReadOnly(keyStore)) {
+                try {
+                    keyStore.setEntry(ALIAS_PRIVATE, getPrivateKey(), null);
+                    fail(keyStore.getType());
+                } catch (UnsupportedOperationException expected) {
                 }
-            }
-            if (isSecretKeyEnabled(keyStore)) {
                 try {
                     keyStore.setEntry(ALIAS_SECRET, new SecretKeyEntry(getSecretKey()), null);
-                    fail();
+                    fail(keyStore.getType());
+                } catch (UnsupportedOperationException expected) {
+                }
+                try {
+                    keyStore.setEntry(ALIAS_CERTIFICATE,
+                                      new TrustedCertificateEntry(getPrivateKey().getCertificate()),
+                                      null);
+                    fail(keyStore.getType());
+                } catch (UnsupportedOperationException expected) {
+                }
+                continue;
+            }
+            if (isNullPasswordAllowed(keyStore) || isKeyPasswordIgnored(keyStore)) {
+                keyStore.setEntry(ALIAS_PRIVATE, getPrivateKey(), null);
+                assertPrivateKey(keyStore.getKey(ALIAS_PRIVATE, null));
+            } else {
+                try {
+                    keyStore.setEntry(ALIAS_PRIVATE, getPrivateKey(), null);
+                    fail(keyStore.getType());
                 } catch (Exception e) {
                     if (e.getClass() != UnrecoverableKeyException.class
                         && e.getClass() != IllegalArgumentException.class
@@ -1966,15 +1979,22 @@ public class KeyStoreTest extends TestCase {
                     }
                 }
             }
-            if (isReadOnly(keyStore)) {
-                try {
-                    keyStore.setEntry(ALIAS_CERTIFICATE,
-                                      new TrustedCertificateEntry(getPrivateKey().getCertificate()),
-                                      PARAM_KEY);
-                    fail();
-                } catch (UnsupportedOperationException expected) {
+            if (isSecretKeyEnabled(keyStore)) {
+                if (isNullPasswordAllowed(keyStore) || isKeyPasswordIgnored(keyStore)) {
+                    keyStore.setEntry(ALIAS_SECRET, new SecretKeyEntry(getSecretKey()), null);
+                    assertSecretKey(keyStore.getKey(ALIAS_SECRET, null));
+                } else {                    
+                    try {
+                        keyStore.setEntry(ALIAS_SECRET, new SecretKeyEntry(getSecretKey()), null);
+                        fail(keyStore.getType());
+                    } catch (Exception e) {
+                        if (e.getClass() != UnrecoverableKeyException.class
+                            && e.getClass() != IllegalArgumentException.class
+                            && e.getClass() != KeyStoreException.class) {
+                            throw e;
+                        }
+                    }
                 }
-                continue;
             }
             if (isCertificateEnabled(keyStore)) {
                 if (isNullPasswordAllowed(keyStore) || isKeyPasswordIgnored(keyStore)) {
@@ -1988,7 +2008,7 @@ public class KeyStoreTest extends TestCase {
                                           new TrustedCertificateEntry(
                                                   getPrivateKey().getCertificate()),
                                           PARAM_KEY);
-                        fail();
+                        fail(keyStore.getType());
                     } catch (KeyStoreException expected) {
                     }
                 }
@@ -2000,7 +2020,7 @@ public class KeyStoreTest extends TestCase {
         for (KeyStore keyStore : keyStores()) {
             try {
                 keyStore.entryInstanceOf(null, null);
-                fail();
+                fail(keyStore.getType());
             } catch (NullPointerException expected) {
             }
         }
@@ -2010,17 +2030,17 @@ public class KeyStoreTest extends TestCase {
 
             try {
                 keyStore.entryInstanceOf(null, null);
-                fail();
+                fail(keyStore.getType());
             } catch (NullPointerException expected) {
             }
             try {
                 keyStore.entryInstanceOf(null, Entry.class);
-                fail();
+                fail(keyStore.getType());
             } catch (NullPointerException expected) {
             }
             try {
                 keyStore.entryInstanceOf("", null);
-                fail();
+                fail(keyStore.getType());
             } catch (NullPointerException expected) {
             }
 
@@ -2095,7 +2115,7 @@ public class KeyStoreTest extends TestCase {
             keyStore.load(null, null);
             try {
                 Builder.newInstance(keyStore, null);
-                fail();
+                fail(keyStore.getType());
             } catch (NullPointerException expected) {
             }
         }
@@ -2105,7 +2125,7 @@ public class KeyStoreTest extends TestCase {
                 Builder.newInstance(keyStore.getType(),
                                     keyStore.getProvider(),
                                     null);
-                fail();
+                fail(keyStore.getType());
             } catch (NullPointerException expected) {
             }
         }
@@ -2116,7 +2136,7 @@ public class KeyStoreTest extends TestCase {
                                     null,
                                     null,
                                     null);
-                fail();
+                fail(keyStore.getType());
             } catch (NullPointerException expected) {
             }
             try {
@@ -2124,7 +2144,7 @@ public class KeyStoreTest extends TestCase {
                                     keyStore.getProvider(),
                                     null,
                                     null);
-                fail();
+                fail(keyStore.getType());
             } catch (NullPointerException expected) {
             }
         }
@@ -2134,13 +2154,13 @@ public class KeyStoreTest extends TestCase {
             Builder builder = Builder.newInstance(keyStore, PARAM_STORE);
             try {
                 builder.getProtectionParameter(null);
-                fail();
+                fail(keyStore.getType());
             } catch (NullPointerException expected) {
             }
             assertEquals(keyStore, builder.getKeyStore());
             try {
                 builder.getProtectionParameter(null);
-                fail();
+                fail(keyStore.getType());
             } catch (NullPointerException expected) {
             }
             assertEquals(PARAM_STORE, builder.getProtectionParameter(""));
@@ -2156,7 +2176,7 @@ public class KeyStoreTest extends TestCase {
                 if (isReadOnly(keyStore)) {
                     try {
                         keyStore.store(os, PASSWORD_STORE);
-                        fail();
+                        fail(keyStore.getType());
                     } catch (UnsupportedOperationException expected) {
                     }
                     continue;
-- 
cgit v1.1


From 6256280922cc8a6622a156afeb7f43a31576d43f Mon Sep 17 00:00:00 2001
From: Kenny Root <kroot@google.com>
Date: Thu, 30 Aug 2012 18:17:40 -0700
Subject: Allow non-password KeyStore in tests

Change-Id: Ib78c1305ecd46f78fddb084853b4082626285e83
---
 .../java/libcore/java/security/KeyStoreTest.java   | 461 +++++++++++++++------
 1 file changed, 341 insertions(+), 120 deletions(-)

diff --git a/luni/src/test/java/libcore/java/security/KeyStoreTest.java b/luni/src/test/java/libcore/java/security/KeyStoreTest.java
index 15314c9..9302dd6 100644
--- a/luni/src/test/java/libcore/java/security/KeyStoreTest.java
+++ b/luni/src/test/java/libcore/java/security/KeyStoreTest.java
@@ -45,6 +45,7 @@ import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.Date;
+import java.util.Enumeration;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
@@ -65,10 +66,12 @@ public class KeyStoreTest extends TestCase {
     private static final String ALIAS_SECRET = "secret";
 
     private static final String ALIAS_ALT_CASE_PRIVATE = "pRiVaTe";
+    private static final String ALIAS_ALT_CASE_NO_PASSWORD_PRIVATE = "PrIvAtE-no-password";
     private static final String ALIAS_ALT_CASE_CERTIFICATE = "cErTiFiCaTe";
     private static final String ALIAS_ALT_CASE_SECRET = "sEcRet";
 
     private static final String ALIAS_UNICODE_PRIVATE = "\u6400\u7902\u3101\u8c02\u5002\u8702\udd01";
+    private static final String ALIAS_UNICODE_NO_PASSWORD_PRIVATE = "\u926c\u0967\uc65b\ubc78";
     private static final String ALIAS_UNICODE_CERTIFICATE = "\u5402\udd01\u7902\u8702\u3101\u5f02\u3101\u5402\u5002\u8702\udd01";
     private static final String ALIAS_UNICODE_SECRET = "\ue224\ud424\ud224\ue124\ud424\ue324";
 
@@ -146,7 +149,8 @@ public class KeyStoreTest extends TestCase {
         // JKS key stores cannot store secret keys, neither can the RI's PKCS12
         return (!(ks.getType().equals("JKS")
                   || ks.getType().equals("CaseExactJKS")
-                  || (ks.getType().equals("PKCS12"))));
+                  || (ks.getType().equals("PKCS12"))
+                  || (ks.getType().equals("AndroidKeyStore"))));
     }
 
     private static boolean isCertificateEnabled(KeyStore ks) {
@@ -157,7 +161,8 @@ public class KeyStoreTest extends TestCase {
     private static boolean isCaseSensitive(KeyStore ks) {
         return (ks.getType().equals("CaseExactJKS")
                 || ks.getType().equals("BKS")
-                || ks.getType().equals("BouncyCastle"));
+                || ks.getType().equals("BouncyCastle")
+                || ks.getType().equals("AndroidKeyStore"));
 
     }
 
@@ -172,7 +177,9 @@ public class KeyStoreTest extends TestCase {
                   || ks.getType().equals("JCEKS")
                   || ks.getType().equals("PKCS12")));
     }
-
+    private static boolean isKeyPasswordSupported(KeyStore ks) {
+        return !ks.getType().equals("AndroidKeyStore");
+    }
     private static boolean isKeyPasswordIgnored(KeyStore ks) {
         // BouncyCastle's PKCS12 ignores the key password unlike the RI which requires it
         return (ks.getType().equals("PKCS12") && ks.getProvider().getName().equals("BC"));
@@ -183,6 +190,14 @@ public class KeyStoreTest extends TestCase {
         return (ks.getType().equals("PKCS12") && ks.getProvider().getName().equals("BC"));
     }
 
+    private static boolean isPersistentStorage(KeyStore ks) {
+        return ks.getType().equalsIgnoreCase("AndroidKeyStore");
+    }
+
+    private static boolean isLoadStoreUnsupported(KeyStore ks) {
+        return ks.getType().equalsIgnoreCase("AndroidKeyStore");
+    }
+
     private static boolean isSetKeyByteArrayUnimplemented(KeyStore ks) {
         // All of BouncyCastle's
         // KeyStore.setKeyEntry(String,byte[],char[]) implementations
@@ -203,16 +218,10 @@ public class KeyStoreTest extends TestCase {
     }
 
     public static void populate(KeyStore ks) throws Exception {
-        ks.load(null, null);
-        if (isReadOnly(ks)) {
-            try {
-                setPrivateKey(ks);
-                fail(ks.toString());
-            } catch (UnsupportedOperationException e) {
-            }
-            return;
+        clearKeyStore(ks);
+        if (isKeyPasswordSupported(ks)) {
+            setPrivateKey(ks);
         }
-        setPrivateKey(ks);
         if (isNullPasswordAllowed(ks)) {
             ks.setKeyEntry(ALIAS_NO_PASSWORD_PRIVATE,
                            getPrivateKey().getPrivateKey(),
@@ -234,6 +243,29 @@ public class KeyStoreTest extends TestCase {
         }
     }
 
+    private static void clearKeyStore(KeyStore ks) throws Exception {
+        ks.load(null, null);
+        if (isReadOnly(ks)) {
+            try {
+                setPrivateKey(ks);
+                fail(ks.toString());
+            } catch (UnsupportedOperationException e) {
+            }
+            return;
+        }
+        if (isPersistentStorage(ks)) {
+            Enumeration<String> aliases = ks.aliases();
+            while (aliases.hasMoreElements()) {
+                String alias = aliases.nextElement();
+                ks.deleteEntry(alias);
+            }
+        }
+    }
+
+    public static void setPrivateKeyNoPassword(KeyStore ks, String alias, PrivateKeyEntry privateKey)
+            throws Exception {
+        ks.setKeyEntry(alias, privateKey.getPrivateKey(), null, privateKey.getCertificateChain());
+    }
     public static void setPrivateKey(KeyStore ks) throws Exception {
         setPrivateKey(ks, ALIAS_PRIVATE);
     }
@@ -492,7 +524,12 @@ public class KeyStoreTest extends TestCase {
             if (isReadOnly(keyStore)) {
                 assertNull(keyStore.getKey(ALIAS_PRIVATE, PASSWORD_KEY));
             } else {
-                assertPrivateKey(keyStore.getKey(ALIAS_PRIVATE, PASSWORD_KEY));
+                if (isKeyPasswordSupported(keyStore)) {
+                    assertPrivateKey(keyStore.getKey(ALIAS_PRIVATE, PASSWORD_KEY));
+                }
+                if (isNullPasswordAllowed(keyStore)) {
+                    assertPrivateKey(keyStore.getKey(ALIAS_NO_PASSWORD_PRIVATE, null));
+                }
                 if (isSecretKeyEnabled(keyStore)) {
                     assertSecretKey(keyStore.getKey(ALIAS_SECRET, PASSWORD_KEY));
                 } else {
@@ -503,21 +540,27 @@ public class KeyStoreTest extends TestCase {
             // test case insensitive
             if (isCaseSensitive(keyStore) || isReadOnly(keyStore)) {
                 assertNull(keyStore.getKey(ALIAS_ALT_CASE_PRIVATE, PASSWORD_KEY));
+                assertNull(keyStore.getKey(ALIAS_ALT_CASE_NO_PASSWORD_PRIVATE, PASSWORD_KEY));
                 assertNull(keyStore.getKey(ALIAS_ALT_CASE_SECRET, PASSWORD_KEY));
             } else {
-                assertPrivateKey(keyStore.getKey(ALIAS_ALT_CASE_PRIVATE, PASSWORD_KEY));
+                if (isKeyPasswordSupported(keyStore)) {
+                    assertPrivateKey(keyStore.getKey(ALIAS_ALT_CASE_PRIVATE, PASSWORD_KEY));
+                }
+                if (isNullPasswordAllowed(keyStore)) {
+                    assertPrivateKey(keyStore.getKey(ALIAS_ALT_CASE_NO_PASSWORD_PRIVATE, null));
+                }
                 if (isSecretKeyEnabled(keyStore)) {
                     assertSecretKey(keyStore.getKey(ALIAS_ALT_CASE_SECRET, PASSWORD_KEY));
                 }
             }
 
             // test with null passwords
-            if (isKeyPasswordIgnored(keyStore)) {
+            if (isKeyPasswordSupported(keyStore) && isKeyPasswordIgnored(keyStore)) {
                 assertPrivateKey(keyStore.getKey(ALIAS_PRIVATE, null));
             } else {
                 if (isReadOnly(keyStore)) {
                     assertNull(keyStore.getKey(ALIAS_PRIVATE, null));
-                } else {
+                } else if (isKeyPasswordSupported(keyStore)) {
                     try {
                         keyStore.getKey(ALIAS_PRIVATE, null);
                         fail(keyStore.getType());
@@ -546,9 +589,9 @@ public class KeyStoreTest extends TestCase {
             // test with bad passwords
             if (isReadOnly(keyStore)) {
                 assertNull(keyStore.getKey(ALIAS_PRIVATE, null));
-            } else if (isKeyPasswordIgnored(keyStore)) {
+            } else if (isKeyPasswordSupported(keyStore) && isKeyPasswordIgnored(keyStore)) {
                 assertPrivateKey(keyStore.getKey(ALIAS_PRIVATE, null));
-            } else {
+            } else if (isKeyPasswordSupported(keyStore)) {
                 try {
                     keyStore.getKey(ALIAS_PRIVATE, PASSWORD_BAD);
                     fail(keyStore.getType());
@@ -593,8 +636,10 @@ public class KeyStoreTest extends TestCase {
             // test case sensitive
             if (isReadOnly(keyStore)) {
                 assertNull(keyStore.getCertificateChain(ALIAS_PRIVATE));
-            } else {
+            } else if (isKeyPasswordSupported(keyStore)) {
                 assertCertificateChain(keyStore.getCertificateChain(ALIAS_PRIVATE));
+            } else if (isNullPasswordAllowed(keyStore)) {
+                assertCertificateChain(keyStore.getCertificateChain(ALIAS_NO_PASSWORD_PRIVATE));
             }
 
             // test case insensitive
@@ -657,9 +702,10 @@ public class KeyStoreTest extends TestCase {
         }
         long before = System.currentTimeMillis();
         for (KeyStore keyStore : keyStores()) {
+            populate(keyStore);
+
             // add 1000 since some key stores round of time to nearest second
             long after = System.currentTimeMillis() + 1000;
-            populate(keyStore);
 
             // test odd inputs
             try {
@@ -673,8 +719,10 @@ public class KeyStoreTest extends TestCase {
             if (!isReadOnly(keyStore) && isCertificateEnabled(keyStore)) {
                 Date date = keyStore.getCreationDate(ALIAS_CERTIFICATE);
                 assertNotNull(date);
-                assertTrue(before <= date.getTime());
-                assertTrue(date.getTime() <= after);
+                assertTrue("date should be after start time: " + date.getTime() + " >= " + before,
+                        before <= date.getTime());
+                assertTrue("date should be before expiry time: " + date.getTime() + " <= " + after,
+                        date.getTime() <= after);
             } else {
                 assertNull(keyStore.getCreationDate(ALIAS_CERTIFICATE));
             }
@@ -737,15 +785,24 @@ public class KeyStoreTest extends TestCase {
                                      PASSWORD_KEY,
                                      null);
                 fail(keyStore.getType());
-            } catch (IllegalArgumentException expected) {
+            } catch (Exception e) {
+                if (e.getClass() != IllegalArgumentException.class
+                        && e.getClass() != KeyStoreException.class) {
+                    throw e;
+                }
             }
         }
 
         for (KeyStore keyStore : keyStores()) {
-            keyStore.load(null, null);
+            clearKeyStore(keyStore);
 
             // test case sensitive
-            assertNull(keyStore.getKey(ALIAS_PRIVATE, PASSWORD_KEY));
+            if (isKeyPasswordSupported(keyStore)) {
+                assertNull(keyStore.getKey(ALIAS_PRIVATE, PASSWORD_KEY));
+            }
+            if (isNullPasswordAllowed(keyStore)) {
+                assertNull(keyStore.getKey(ALIAS_NO_PASSWORD_PRIVATE, null));
+            }
             if (isReadOnly(keyStore)) {
                 try {
                     keyStore.setKeyEntry(ALIAS_SECRET, getSecretKey(), PASSWORD_KEY, null);
@@ -754,9 +811,16 @@ public class KeyStoreTest extends TestCase {
                 }
                 continue;
             }
-            setPrivateKey(keyStore);
-            assertPrivateKey(keyStore.getKey(ALIAS_PRIVATE, PASSWORD_KEY));
-            assertCertificateChain(keyStore.getCertificateChain(ALIAS_PRIVATE));
+            if (isKeyPasswordSupported(keyStore)) {
+                setPrivateKey(keyStore);
+                assertPrivateKey(keyStore.getKey(ALIAS_PRIVATE, PASSWORD_KEY));
+                assertCertificateChain(keyStore.getCertificateChain(ALIAS_PRIVATE));
+            }
+            if (isNullPasswordAllowed(keyStore)) {
+                setPrivateKeyNoPassword(keyStore, ALIAS_NO_PASSWORD_PRIVATE, getPrivateKey());
+                assertPrivateKey(keyStore.getKey(ALIAS_NO_PASSWORD_PRIVATE, null));
+                assertCertificateChain(keyStore.getCertificateChain(ALIAS_NO_PASSWORD_PRIVATE));
+            }
             if (isSecretKeyEnabled(keyStore)) {
                 assertNull(keyStore.getKey(ALIAS_SECRET, PASSWORD_KEY));
                 setSecretKey(keyStore);
@@ -783,11 +847,22 @@ public class KeyStoreTest extends TestCase {
                 assertNull(keyStore.getKey(ALIAS_SECRET, PASSWORD_KEY));
                 assertNull(keyStore.getKey(ALIAS_ALT_CASE_SECRET, PASSWORD_KEY));
             } else if (isCaseSensitive(keyStore)) {
-                assertPrivateKey(keyStore.getKey(ALIAS_PRIVATE, PASSWORD_KEY));
-                assertNull(keyStore.getKey(ALIAS_ALT_CASE_PRIVATE, PASSWORD_KEY));
-                setPrivateKey(keyStore, ALIAS_ALT_CASE_PRIVATE, getPrivateKey2());
-                assertPrivateKey(keyStore.getKey(ALIAS_PRIVATE, PASSWORD_KEY));
-                assertPrivateKey2(keyStore.getKey(ALIAS_ALT_CASE_PRIVATE, PASSWORD_KEY));
+                if (isKeyPasswordSupported(keyStore)) {
+                    assertPrivateKey(keyStore.getKey(ALIAS_PRIVATE, PASSWORD_KEY));
+                    assertNull(keyStore.getKey(ALIAS_ALT_CASE_PRIVATE, PASSWORD_KEY));
+                    setPrivateKey(keyStore, ALIAS_ALT_CASE_PRIVATE, getPrivateKey2());
+                    assertPrivateKey(keyStore.getKey(ALIAS_PRIVATE, PASSWORD_KEY));
+                    assertPrivateKey2(keyStore.getKey(ALIAS_ALT_CASE_PRIVATE, PASSWORD_KEY));
+                }
+
+                if (isNullPasswordAllowed(keyStore)) {
+                    assertPrivateKey(keyStore.getKey(ALIAS_NO_PASSWORD_PRIVATE, null));
+                    assertNull(keyStore.getKey(ALIAS_ALT_CASE_NO_PASSWORD_PRIVATE, null));
+                    setPrivateKeyNoPassword(keyStore, ALIAS_ALT_CASE_NO_PASSWORD_PRIVATE,
+                            getPrivateKey2());
+                    assertPrivateKey(keyStore.getKey(ALIAS_NO_PASSWORD_PRIVATE, null));
+                    assertPrivateKey2(keyStore.getKey(ALIAS_ALT_CASE_NO_PASSWORD_PRIVATE, null));
+                }
 
                 if (isSecretKeyEnabled(keyStore)) {
                     assertSecretKey(keyStore.getKey(ALIAS_SECRET, PASSWORD_KEY));
@@ -797,11 +872,22 @@ public class KeyStoreTest extends TestCase {
                     assertSecretKey2(keyStore.getKey(ALIAS_ALT_CASE_SECRET, PASSWORD_KEY));
                 }
             } else {
-                assertPrivateKey(keyStore.getKey(ALIAS_PRIVATE, PASSWORD_KEY));
-                assertPrivateKey(keyStore.getKey(ALIAS_ALT_CASE_PRIVATE, PASSWORD_KEY));
-                setPrivateKey(keyStore, ALIAS_ALT_CASE_PRIVATE, getPrivateKey2());
-                assertPrivateKey2(keyStore.getKey(ALIAS_PRIVATE, PASSWORD_KEY));
-                assertPrivateKey2(keyStore.getKey(ALIAS_ALT_CASE_PRIVATE, PASSWORD_KEY));
+                if (isKeyPasswordSupported(keyStore)) {
+                    assertPrivateKey(keyStore.getKey(ALIAS_PRIVATE, PASSWORD_KEY));
+                    assertPrivateKey(keyStore.getKey(ALIAS_ALT_CASE_PRIVATE, PASSWORD_KEY));
+                    setPrivateKey(keyStore, ALIAS_ALT_CASE_PRIVATE, getPrivateKey2());
+                    assertPrivateKey2(keyStore.getKey(ALIAS_PRIVATE, PASSWORD_KEY));
+                    assertPrivateKey2(keyStore.getKey(ALIAS_ALT_CASE_PRIVATE, PASSWORD_KEY));
+                }
+
+                if (isNullPasswordAllowed(keyStore)) {
+                    assertPrivateKey(keyStore.getKey(ALIAS_PRIVATE, null));
+                    assertPrivateKey(keyStore.getKey(ALIAS_ALT_CASE_NO_PASSWORD_PRIVATE, null));
+                    setPrivateKey(keyStore, ALIAS_ALT_CASE_NO_PASSWORD_PRIVATE, getPrivateKey2());
+                    assertPrivateKey2(keyStore.getKey(ALIAS_PRIVATE, null));
+                    assertPrivateKey2(keyStore.getKey(ALIAS_ALT_CASE_NO_PASSWORD_PRIVATE, null));
+                }
+
                 if (isSecretKeyEnabled(keyStore)) {
                     assertSecretKey(keyStore.getKey(ALIAS_SECRET, PASSWORD_KEY));
                     assertSecretKey(keyStore.getKey(ALIAS_ALT_CASE_SECRET, PASSWORD_KEY));
@@ -913,10 +999,15 @@ public class KeyStoreTest extends TestCase {
                 continue;
             }
 
-            keyStore.load(null, null);
+            clearKeyStore(keyStore);
 
             // test case sensitive
-            assertNull(keyStore.getKey(ALIAS_PRIVATE, PASSWORD_KEY));
+            if (isKeyPasswordSupported(keyStore)) {
+                assertNull(keyStore.getKey(ALIAS_PRIVATE, PASSWORD_KEY));
+            }
+            if (isNullPasswordAllowed(keyStore)) {
+                assertNull(keyStore.getKey(ALIAS_NO_PASSWORD_PRIVATE, null));
+            }
             if (isReadOnly(keyStore)) {
                 try {
                     setPrivateKeyBytes(keyStore);
@@ -925,9 +1016,16 @@ public class KeyStoreTest extends TestCase {
                 }
                 continue;
             }
-            setPrivateKeyBytes(keyStore);
-            assertPrivateKey(keyStore.getKey(ALIAS_PRIVATE, PASSWORD_KEY));
-            assertCertificateChain(keyStore.getCertificateChain(ALIAS_PRIVATE));
+            if (isKeyPasswordSupported(keyStore)) {
+                setPrivateKeyBytes(keyStore);
+                assertPrivateKey(keyStore.getKey(ALIAS_PRIVATE, PASSWORD_KEY));
+                assertCertificateChain(keyStore.getCertificateChain(ALIAS_PRIVATE));
+            }
+            if (isNullPasswordAllowed(keyStore)) {
+                setPrivateKeyNoPassword(keyStore, ALIAS_NO_PASSWORD_PRIVATE, getPrivateKey());
+                assertPrivateKey(keyStore.getKey(ALIAS_NO_PASSWORD_PRIVATE, null));
+                assertCertificateChain(keyStore.getCertificateChain(ALIAS_NO_PASSWORD_PRIVATE));
+            }
             if (isSecretKeyEnabled(keyStore)) {
                 assertNull(keyStore.getKey(ALIAS_SECRET, PASSWORD_KEY));
                 setSecretKeyBytes(keyStore);
@@ -959,11 +1057,21 @@ public class KeyStoreTest extends TestCase {
                 assertNull(keyStore.getKey(ALIAS_SECRET, PASSWORD_KEY));
                 assertNull(keyStore.getKey(ALIAS_ALT_CASE_SECRET, PASSWORD_KEY));
             } else if (isCaseSensitive(keyStore)) {
-                assertPrivateKey(keyStore.getKey(ALIAS_PRIVATE, PASSWORD_KEY));
-                assertNull(keyStore.getKey(ALIAS_ALT_CASE_PRIVATE, PASSWORD_KEY));
-                setPrivateKeyBytes(keyStore, ALIAS_ALT_CASE_PRIVATE, getPrivateKey2());
-                assertPrivateKey(keyStore.getKey(ALIAS_PRIVATE, PASSWORD_KEY));
-                assertPrivateKey2(keyStore.getKey(ALIAS_ALT_CASE_PRIVATE, PASSWORD_KEY));
+                if (isKeyPasswordSupported(keyStore)) {
+                    assertPrivateKey(keyStore.getKey(ALIAS_PRIVATE, PASSWORD_KEY));
+                    assertNull(keyStore.getKey(ALIAS_ALT_CASE_PRIVATE, PASSWORD_KEY));
+                    setPrivateKeyBytes(keyStore, ALIAS_ALT_CASE_PRIVATE, getPrivateKey2());
+                    assertPrivateKey(keyStore.getKey(ALIAS_PRIVATE, PASSWORD_KEY));
+                    assertPrivateKey2(keyStore.getKey(ALIAS_ALT_CASE_PRIVATE, PASSWORD_KEY));
+                }
+                if (isNullPasswordAllowed(keyStore)) {
+                    assertPrivateKey(keyStore.getKey(ALIAS_NO_PASSWORD_PRIVATE, null));
+                    assertNull(keyStore.getKey(ALIAS_ALT_CASE_NO_PASSWORD_PRIVATE, null));
+                    setPrivateKeyNoPassword(keyStore, ALIAS_ALT_CASE_NO_PASSWORD_PRIVATE,
+                            getPrivateKey2());
+                    assertPrivateKey(keyStore.getKey(ALIAS_NO_PASSWORD_PRIVATE, null));
+                    assertPrivateKey2(keyStore.getKey(ALIAS_ALT_CASE_NO_PASSWORD_PRIVATE, null));
+                }
 
                 if (isSecretKeyEnabled(keyStore)) {
                     assertSecretKey(keyStore.getKey(ALIAS_SECRET, PASSWORD_KEY));
@@ -973,11 +1081,21 @@ public class KeyStoreTest extends TestCase {
                     assertSecretKey2(keyStore.getKey(ALIAS_ALT_CASE_SECRET, PASSWORD_KEY));
                 }
             } else {
-                assertPrivateKey(keyStore.getKey(ALIAS_PRIVATE, PASSWORD_KEY));
-                assertPrivateKey(keyStore.getKey(ALIAS_ALT_CASE_PRIVATE, PASSWORD_KEY));
-                setPrivateKeyBytes(keyStore, ALIAS_ALT_CASE_PRIVATE, getPrivateKey2());
-                assertPrivateKey2(keyStore.getKey(ALIAS_PRIVATE, PASSWORD_KEY));
-                assertPrivateKey2(keyStore.getKey(ALIAS_ALT_CASE_PRIVATE, PASSWORD_KEY));
+                if (isKeyPasswordSupported(keyStore)) {
+                    assertPrivateKey(keyStore.getKey(ALIAS_PRIVATE, PASSWORD_KEY));
+                    assertPrivateKey(keyStore.getKey(ALIAS_ALT_CASE_PRIVATE, PASSWORD_KEY));
+                    setPrivateKeyBytes(keyStore, ALIAS_ALT_CASE_PRIVATE, getPrivateKey2());
+                    assertPrivateKey2(keyStore.getKey(ALIAS_PRIVATE, PASSWORD_KEY));
+                    assertPrivateKey2(keyStore.getKey(ALIAS_ALT_CASE_PRIVATE, PASSWORD_KEY));
+                }
+                if (isNullPasswordAllowed(keyStore)) {
+                    assertPrivateKey(keyStore.getKey(ALIAS_NO_PASSWORD_PRIVATE, null));
+                    assertPrivateKey(keyStore.getKey(ALIAS_ALT_CASE_NO_PASSWORD_PRIVATE, null));
+                    setPrivateKeyNoPassword(keyStore, ALIAS_ALT_CASE_NO_PASSWORD_PRIVATE,
+                            getPrivateKey2());
+                    assertPrivateKey2(keyStore.getKey(ALIAS_NO_PASSWORD_PRIVATE, null));
+                    assertPrivateKey2(keyStore.getKey(ALIAS_ALT_CASE_NO_PASSWORD_PRIVATE, null));
+                }
 
                 if (isSecretKeyEnabled(keyStore)) {
                     assertSecretKey(keyStore.getKey(ALIAS_SECRET, PASSWORD_KEY));
@@ -1031,13 +1149,17 @@ public class KeyStoreTest extends TestCase {
                 try {
                     int size = keyStore.size();
                     keyStore.setCertificateEntry(ALIAS_CERTIFICATE, null);
-                    assertNull(keyStore.getCertificate(ALIAS_CERTIFICATE));
-                    assertEquals(size, keyStore.size());
-                    assertTrue(keyStore.isCertificateEntry(ALIAS_CERTIFICATE));
-                    assertTrue(Collections.list(keyStore.aliases()).contains(ALIAS_CERTIFICATE));
+                    assertNull(keyStore.getType(), keyStore.getCertificate(ALIAS_CERTIFICATE));
+                    assertEquals(keyStore.getType(), size, keyStore.size());
+                    assertTrue(keyStore.getType(), keyStore.isCertificateEntry(ALIAS_CERTIFICATE));
+                    assertTrue(keyStore.getType(),
+                            Collections.list(keyStore.aliases()).contains(ALIAS_CERTIFICATE));
                 } catch (NullPointerException expectedSometimes) {
-                    assertEquals("PKCS12", keyStore.getType());
-                    assertEquals("BC", keyStore.getProvider().getName());
+                    if (!("PKCS12".equalsIgnoreCase(keyStore.getType()) &&
+                                "BC".equalsIgnoreCase(keyStore.getProvider().getName()))
+                            && !"AndroidKeyStore".equalsIgnoreCase(keyStore.getType())) {
+                        throw expectedSometimes;
+                    }
                 }
             } else {
                 try {
@@ -1053,9 +1175,8 @@ public class KeyStoreTest extends TestCase {
                 continue;
             }
 
-            keyStore.load(null, null);
+            clearKeyStore(keyStore);
 
-            // test case sensitive
             assertNull(keyStore.getCertificate(ALIAS_CERTIFICATE));
             if (isReadOnly(keyStore)) {
                 try {
@@ -1077,10 +1198,8 @@ public class KeyStoreTest extends TestCase {
             populate(keyStore);
 
             if (isReadOnly(keyStore)) {
-                assertNull(keyStore.getKey(ALIAS_PRIVATE, PASSWORD_KEY));
-                assertNull(keyStore.getKey(ALIAS_ALT_CASE_PRIVATE, PASSWORD_KEY));
-                assertNull(keyStore.getKey(ALIAS_SECRET, PASSWORD_KEY));
-                assertNull(keyStore.getKey(ALIAS_ALT_CASE_SECRET, PASSWORD_KEY));
+                assertNull(keyStore.getCertificate(ALIAS_CERTIFICATE));
+                assertNull(keyStore.getCertificate(ALIAS_ALT_CASE_CERTIFICATE));
             } else if (isCaseSensitive(keyStore)) {
                 assertCertificate(keyStore.getCertificate(ALIAS_CERTIFICATE));
                 assertNull(keyStore.getCertificate(ALIAS_ALT_CASE_CERTIFICATE));
@@ -1146,10 +1265,18 @@ public class KeyStoreTest extends TestCase {
             }
 
             // test case sensitive
-            assertPrivateKey(keyStore.getKey(ALIAS_PRIVATE, PASSWORD_KEY));
-            assertCertificateChain(keyStore.getCertificateChain(ALIAS_PRIVATE));
-            keyStore.deleteEntry(ALIAS_PRIVATE);
-            assertNull(keyStore.getKey(ALIAS_PRIVATE, PASSWORD_KEY));
+            if (isKeyPasswordSupported(keyStore)) {
+                assertPrivateKey(keyStore.getKey(ALIAS_PRIVATE, PASSWORD_KEY));
+                assertCertificateChain(keyStore.getCertificateChain(ALIAS_PRIVATE));
+                keyStore.deleteEntry(ALIAS_PRIVATE);
+                assertNull(keyStore.getKey(ALIAS_PRIVATE, PASSWORD_KEY));
+            }
+            if (isNullPasswordAllowed(keyStore)) {
+                assertPrivateKey(keyStore.getKey(ALIAS_NO_PASSWORD_PRIVATE, null));
+                assertCertificateChain(keyStore.getCertificateChain(ALIAS_NO_PASSWORD_PRIVATE));
+                keyStore.deleteEntry(ALIAS_NO_PASSWORD_PRIVATE);
+                assertNull(keyStore.getKey(ALIAS_NO_PASSWORD_PRIVATE, null));
+            }
 
             if (isSecretKeyEnabled(keyStore)) {
                 assertSecretKey(keyStore.getKey(ALIAS_SECRET, PASSWORD_KEY));
@@ -1174,9 +1301,16 @@ public class KeyStoreTest extends TestCase {
             // test case insensitive
 
             if (isCaseSensitive(keyStore)) {
-                assertPrivateKey(keyStore.getKey(ALIAS_PRIVATE, PASSWORD_KEY));
-                keyStore.deleteEntry(ALIAS_ALT_CASE_PRIVATE);
-                assertPrivateKey(keyStore.getKey(ALIAS_PRIVATE, PASSWORD_KEY));
+                if (isKeyPasswordSupported(keyStore)) {
+                    assertPrivateKey(keyStore.getKey(ALIAS_PRIVATE, PASSWORD_KEY));
+                    keyStore.deleteEntry(ALIAS_ALT_CASE_PRIVATE);
+                    assertPrivateKey(keyStore.getKey(ALIAS_PRIVATE, PASSWORD_KEY));
+                }
+                if (isNullPasswordAllowed(keyStore)) {
+                    assertPrivateKey(keyStore.getKey(ALIAS_NO_PASSWORD_PRIVATE, null));
+                    keyStore.deleteEntry(ALIAS_ALT_CASE_NO_PASSWORD_PRIVATE);
+                    assertPrivateKey(keyStore.getKey(ALIAS_NO_PASSWORD_PRIVATE, null));
+                }
 
                 if (isSecretKeyEnabled(keyStore)) {
                     assertSecretKey(keyStore.getKey(ALIAS_SECRET, PASSWORD_KEY));
@@ -1208,10 +1342,14 @@ public class KeyStoreTest extends TestCase {
 
         for (KeyStore keyStore : keyStores()) {
             keyStore.load(null, null);
-            if (hasDefaultContents(keyStore)) {
-                assertTrue(keyStore.aliases().hasMoreElements());
+            if (isPersistentStorage(keyStore)) {
+                assertNotNull("Should be able to query size: " + keyStore.getType(),
+                        keyStore.aliases());
+            } else if (hasDefaultContents(keyStore)) {
+                assertTrue("Should have more than one alias already: " + keyStore.getType(),
+                        keyStore.aliases().hasMoreElements());
             } else {
-                assertEquals(Collections.EMPTY_SET,
+                assertEquals("Should have no aliases:" + keyStore.getType(), Collections.EMPTY_SET,
                         new HashSet(Collections.list(keyStore.aliases())));
             }
         }
@@ -1220,7 +1358,9 @@ public class KeyStoreTest extends TestCase {
             populate(keyStore);
 
             Set<String> expected = new HashSet<String>();
-            expected.add(ALIAS_PRIVATE);
+            if (isKeyPasswordSupported(keyStore)) {
+                expected.add(ALIAS_PRIVATE);
+            }
             if (isNullPasswordAllowed(keyStore)) {
                 expected.add(ALIAS_NO_PASSWORD_PRIVATE);
             }
@@ -1233,7 +1373,10 @@ public class KeyStoreTest extends TestCase {
             if (isCertificateEnabled(keyStore)) {
                 expected.add(ALIAS_CERTIFICATE);
             }
-            if (hasDefaultContents(keyStore)) {
+            if (isPersistentStorage(keyStore)) {
+                assertNotNull("Should be able to query size: " + keyStore.getType(),
+                        keyStore.aliases());
+            } else if (hasDefaultContents(keyStore)) {
                 assertTrue(keyStore.aliases().hasMoreElements());
             } else {
                 assertEquals(expected, new HashSet<String>(Collections.list(keyStore.aliases())));
@@ -1271,7 +1414,11 @@ public class KeyStoreTest extends TestCase {
                 assertFalse(keyStore.containsAlias(ALIAS_PRIVATE));
                 continue;
             }
-            assertTrue(keyStore.containsAlias(ALIAS_PRIVATE));
+            if (isKeyPasswordSupported(keyStore)) {
+                assertTrue(keyStore.containsAlias(ALIAS_PRIVATE));
+            } else if (isNullPasswordAllowed(keyStore)) {
+                assertTrue(keyStore.containsAlias(ALIAS_NO_PASSWORD_PRIVATE));
+            }
             assertEquals(isSecretKeyEnabled(keyStore), keyStore.containsAlias(ALIAS_SECRET));
             assertEquals(isCertificateEnabled(keyStore), keyStore.containsAlias(ALIAS_CERTIFICATE));
 
@@ -1295,21 +1442,29 @@ public class KeyStoreTest extends TestCase {
 
         for (KeyStore keyStore : keyStores()) {
             keyStore.load(null, null);
-            if (hasDefaultContents(keyStore)) {
-                assertTrue(keyStore.size() > 0);
+            if (isPersistentStorage(keyStore)) {
+                assertTrue("Should successfully query size: " + keyStore.getType(),
+                        keyStore.size() >= 0);
+            } else if (hasDefaultContents(keyStore)) {
+                assertTrue("Should have non-empty store: " + keyStore.getType(),
+                        keyStore.size() > 0);
             } else {
-                assertEquals(0, keyStore.size());
+                assertEquals("Should have empty store: " + keyStore.getType(), 0, keyStore.size());
             }
         }
 
         for (KeyStore keyStore : keyStores()) {
             populate(keyStore);
             if (hasDefaultContents(keyStore)) {
-                assertTrue(keyStore.size() > 0);
+                assertTrue("Should have non-empty store: " + keyStore.getType(),
+                        keyStore.size() > 0);
                 continue;
             }
 
-            int expected = 1;
+            int expected = 0;
+            if (isKeyPasswordSupported(keyStore)) {
+                expected++;
+            }
             if (isNullPasswordAllowed(keyStore)) {
                 expected++;
             }
@@ -1355,7 +1510,12 @@ public class KeyStoreTest extends TestCase {
                 assertFalse(keyStore.isKeyEntry(ALIAS_PRIVATE));
                 continue;
             }
-            assertTrue(keyStore.isKeyEntry(ALIAS_PRIVATE));
+            if (isKeyPasswordSupported(keyStore)) {
+                assertTrue(keyStore.isKeyEntry(ALIAS_PRIVATE));
+            }
+            if (isNullPasswordAllowed(keyStore)) {
+                assertTrue(keyStore.isKeyEntry(ALIAS_NO_PASSWORD_PRIVATE));
+            }
             assertEquals(isSecretKeyEnabled(keyStore), keyStore.isKeyEntry(ALIAS_SECRET));
             assertFalse(keyStore.isKeyEntry(ALIAS_CERTIFICATE));
 
@@ -1397,7 +1557,12 @@ public class KeyStoreTest extends TestCase {
 
             assertFalse(keyStore.isCertificateEntry(""));
 
-            assertFalse(keyStore.isCertificateEntry(ALIAS_PRIVATE));
+            if (isKeyPasswordSupported(keyStore)) {
+                assertFalse(keyStore.isCertificateEntry(ALIAS_PRIVATE));
+            }
+            if (isNullPasswordAllowed(keyStore)) {
+                assertFalse(keyStore.isCertificateEntry(ALIAS_NO_PASSWORD_PRIVATE));
+            }
             assertFalse(keyStore.isCertificateEntry(ALIAS_SECRET));
             assertEquals(isCertificateEnabled(keyStore) && !isReadOnly(keyStore),
                     keyStore.isCertificateEntry(ALIAS_CERTIFICATE));
@@ -1429,7 +1594,9 @@ public class KeyStoreTest extends TestCase {
             populate(keyStore);
 
             Set<String> expected = new HashSet<String>();
-            expected.add(ALIAS_PRIVATE);
+            if (isKeyPasswordSupported(keyStore)) {
+                expected.add(ALIAS_PRIVATE);
+            }
             if (isNullPasswordAllowed(keyStore)) {
                 expected.add(ALIAS_NO_PASSWORD_PRIVATE);
             }
@@ -1487,7 +1654,7 @@ public class KeyStoreTest extends TestCase {
         for (KeyStore keyStore : keyStores()) {
             keyStore.load(null, null);
             ByteArrayOutputStream out = new ByteArrayOutputStream();
-            if (isReadOnly(keyStore)) {
+            if (isLoadStoreUnsupported(keyStore) || isReadOnly(keyStore)) {
                 try {
                     keyStore.store(out, null);
                     fail(keyStore.getType());
@@ -1517,11 +1684,11 @@ public class KeyStoreTest extends TestCase {
             populate(keyStore);
 
             ByteArrayOutputStream out = new ByteArrayOutputStream();
-            if (isReadOnly(keyStore)) {
+            if (isLoadStoreUnsupported(keyStore) || isReadOnly(keyStore)) {
                 try {
                     keyStore.store(out, null);
                     fail(keyStore.getType());
-                } catch (UnsupportedOperationException e) {
+                } catch (UnsupportedOperationException expected) {
                 }
             } else if (isNullPasswordAllowed(keyStore)) {
                 keyStore.store(out, null);
@@ -1542,7 +1709,7 @@ public class KeyStoreTest extends TestCase {
         for (KeyStore keyStore : keyStores()) {
             keyStore.load(null, null);
             ByteArrayOutputStream out = new ByteArrayOutputStream();
-            if (isReadOnly(keyStore)) {
+            if (isLoadStoreUnsupported(keyStore) || isReadOnly(keyStore)) {
                 try {
                     keyStore.store(out, PASSWORD_STORE);
                     fail(keyStore.getType());
@@ -1557,7 +1724,7 @@ public class KeyStoreTest extends TestCase {
         for (KeyStore keyStore : keyStores()) {
             populate(keyStore);
             ByteArrayOutputStream out = new ByteArrayOutputStream();
-            if (isReadOnly(keyStore)) {
+            if (isLoadStoreUnsupported(keyStore) || isReadOnly(keyStore)) {
                 try {
                     keyStore.store(out, PASSWORD_STORE);
                     fail(keyStore.getType());
@@ -1596,19 +1763,30 @@ public class KeyStoreTest extends TestCase {
     public void test_KeyStore_load_InputStream() throws Exception {
         for (KeyStore keyStore : keyStores()) {
             keyStore.load(null, null);
-            if (hasDefaultContents(keyStore)) {
-                assertTrue(keyStore.size() > 0);
+            if (isPersistentStorage(keyStore)) {
+                assertTrue("Should be able to query size: " + keyStore.getType(),
+                        keyStore.size() >= 0);
+            } else if (hasDefaultContents(keyStore)) {
+                assertTrue("Should have non-empty store: " + keyStore.getType(),
+                        keyStore.size() > 0);
             } else {
-                assertEquals(0, keyStore.size());
+                assertEquals("Should have empty store: " + keyStore.getType(), 0, keyStore.size());
             }
         }
 
         for (KeyStore keyStore : keyStores()) {
+            if (isLoadStoreUnsupported(keyStore)) {
+                continue;
+            }
             keyStore.load(null, PASSWORD_STORE);
-            if (hasDefaultContents(keyStore)) {
-                assertTrue(keyStore.size() > 0);
+            if (isPersistentStorage(keyStore)) {
+                assertTrue("Should be able to query size: " + keyStore.getType(),
+                        keyStore.size() >= 0);
+            } else if (hasDefaultContents(keyStore)) {
+                assertTrue("Should have non-empty store: " + keyStore.getType(),
+                        keyStore.size() > 0);
             } else {
-                assertEquals(0, keyStore.size());
+                assertEquals("Should have empty store: " + keyStore.getType(), 0, keyStore.size());
             }
         }
 
@@ -1618,10 +1796,14 @@ public class KeyStoreTest extends TestCase {
     public void test_KeyStore_load_LoadStoreParameter() throws Exception {
         for (KeyStore keyStore : keyStores()) {
             keyStore.load(null);
-            if (hasDefaultContents(keyStore)) {
-                assertTrue(keyStore.size() > 0);
+            if (isPersistentStorage(keyStore)) {
+                assertTrue("Should be able to query size: " + keyStore.getType(),
+                        keyStore.size() >= 0);
+            } else if (hasDefaultContents(keyStore)) {
+                assertTrue("Should have non-empty store: " + keyStore.getType(),
+                        keyStore.size() > 0);
             } else {
-                assertEquals(0, keyStore.size());
+                assertEquals("Should have empty store: " + keyStore.getType(), 0, keyStore.size());
             }
         }
 
@@ -1668,7 +1850,11 @@ public class KeyStoreTest extends TestCase {
             if (isReadOnly(keyStore)) {
                 assertNull(keyStore.getEntry(ALIAS_PRIVATE, PARAM_KEY));
             } else {
-                assertPrivateKey(keyStore.getEntry(ALIAS_PRIVATE, PARAM_KEY));
+                if (isKeyPasswordSupported(keyStore)) {
+                    assertPrivateKey(keyStore.getEntry(ALIAS_PRIVATE, PARAM_KEY));
+                } else if (isNullPasswordAllowed(keyStore)) {
+                    assertPrivateKey(keyStore.getEntry(ALIAS_NO_PASSWORD_PRIVATE, null));
+                }
                 if (isSecretKeyEnabled(keyStore)) {
                     assertSecretKey(keyStore.getEntry(ALIAS_SECRET, PARAM_KEY));
                 } else {
@@ -1704,9 +1890,9 @@ public class KeyStoreTest extends TestCase {
                 assertNull(keyStore.getEntry(ALIAS_NO_PASSWORD_PRIVATE, null));
             } else if (isNullPasswordAllowed(keyStore)) {
                 assertPrivateKey(keyStore.getEntry(ALIAS_NO_PASSWORD_PRIVATE, null));
-            } else if (isKeyPasswordIgnored(keyStore)) {
+            } else if (isKeyPasswordSupported(keyStore) && isKeyPasswordIgnored(keyStore)) {
                 assertPrivateKey(keyStore.getEntry(ALIAS_PRIVATE, null));
-            } else {
+            } else if (isKeyPasswordIgnored(keyStore)) {
                 try {
                     keyStore.getEntry(ALIAS_PRIVATE, null);
                     fail(keyStore.getType());
@@ -1734,9 +1920,9 @@ public class KeyStoreTest extends TestCase {
             // test with bad passwords
             if (isReadOnly(keyStore)) {
                 assertNull(keyStore.getEntry(ALIAS_PRIVATE, PARAM_BAD));
-            } else if (isKeyPasswordIgnored(keyStore)) {
+            } else if (isKeyPasswordSupported(keyStore) && isKeyPasswordIgnored(keyStore)) {
                 assertPrivateKey(keyStore.getEntry(ALIAS_PRIVATE, PARAM_BAD));
-            } else {
+            } else if (isKeyPasswordSupported(keyStore)) {
                 try {
                     keyStore.getEntry(ALIAS_PRIVATE, PARAM_BAD);
                     fail(keyStore.getType());
@@ -1773,7 +1959,7 @@ public class KeyStoreTest extends TestCase {
 
             try {
                 keyStore.setEntry(ALIAS_PRIVATE, getPrivateKey(), new FakeProtectionParameter());
-                fail("Should not accept unknown ProtectionParameter");
+                fail("Should not accept unknown ProtectionParameter: " + keyStore.getProvider());
             } catch (KeyStoreException expected) {
             }
         }
@@ -1808,7 +1994,7 @@ public class KeyStoreTest extends TestCase {
         }
 
         for (KeyStore keyStore : keyStores()) {
-            keyStore.load(null, null);
+            clearKeyStore(keyStore);
 
             // test case sensitive
             assertNull(keyStore.getKey(ALIAS_PRIVATE, PASSWORD_KEY));
@@ -1820,9 +2006,16 @@ public class KeyStoreTest extends TestCase {
                 }
                 continue;
             }
-            keyStore.setEntry(ALIAS_PRIVATE, getPrivateKey(), PARAM_KEY);
-            assertPrivateKey(keyStore.getKey(ALIAS_PRIVATE, PASSWORD_KEY));
-            assertCertificateChain(keyStore.getCertificateChain(ALIAS_PRIVATE));
+            if (isKeyPasswordSupported(keyStore)) {
+                keyStore.setEntry(ALIAS_PRIVATE, getPrivateKey(), PARAM_KEY);
+                assertPrivateKey(keyStore.getKey(ALIAS_PRIVATE, PASSWORD_KEY));
+                assertCertificateChain(keyStore.getCertificateChain(ALIAS_PRIVATE));
+            }
+            if (isNullPasswordAllowed(keyStore)) {
+                keyStore.setEntry(ALIAS_NO_PASSWORD_PRIVATE, getPrivateKey(), null);
+                assertPrivateKey(keyStore.getKey(ALIAS_NO_PASSWORD_PRIVATE, null));
+                assertCertificateChain(keyStore.getCertificateChain(ALIAS_NO_PASSWORD_PRIVATE));
+            }
             if (isSecretKeyEnabled(keyStore)) {
                 assertNull(keyStore.getKey(ALIAS_SECRET, PASSWORD_KEY));
                 keyStore.setEntry(ALIAS_SECRET, new SecretKeyEntry(getSecretKey()), PARAM_KEY);
@@ -1849,9 +2042,17 @@ public class KeyStoreTest extends TestCase {
                 } catch (KeyStoreException expected) {
                 }
             }
-            keyStore.setEntry(ALIAS_UNICODE_PRIVATE, getPrivateKey(), PARAM_KEY);
-            assertPrivateKey(keyStore.getKey(ALIAS_UNICODE_PRIVATE, PASSWORD_KEY));
-            assertCertificateChain(keyStore.getCertificateChain(ALIAS_UNICODE_PRIVATE));
+            if (isKeyPasswordSupported(keyStore)) {
+                keyStore.setEntry(ALIAS_UNICODE_PRIVATE, getPrivateKey(), PARAM_KEY);
+                assertPrivateKey(keyStore.getKey(ALIAS_UNICODE_PRIVATE, PASSWORD_KEY));
+                assertCertificateChain(keyStore.getCertificateChain(ALIAS_UNICODE_PRIVATE));
+            }
+            if (isNullPasswordAllowed(keyStore)) {
+                keyStore.setEntry(ALIAS_UNICODE_NO_PASSWORD_PRIVATE, getPrivateKey(), null);
+                assertPrivateKey(keyStore.getKey(ALIAS_UNICODE_NO_PASSWORD_PRIVATE, null));
+                assertCertificateChain(keyStore
+                        .getCertificateChain(ALIAS_UNICODE_NO_PASSWORD_PRIVATE));
+            }
             if (isSecretKeyEnabled(keyStore)) {
                 assertNull(keyStore.getKey(ALIAS_UNICODE_SECRET, PASSWORD_KEY));
                 keyStore.setEntry(ALIAS_UNICODE_SECRET, new SecretKeyEntry(getSecretKey()), PARAM_KEY);
@@ -1874,11 +2075,21 @@ public class KeyStoreTest extends TestCase {
                 assertNull(keyStore.getKey(ALIAS_SECRET, PASSWORD_KEY));
                 assertNull(keyStore.getKey(ALIAS_ALT_CASE_SECRET, PASSWORD_KEY));
             } else if (isCaseSensitive(keyStore)) {
-                assertPrivateKey(keyStore.getKey(ALIAS_PRIVATE, PASSWORD_KEY));
-                assertNull(keyStore.getKey(ALIAS_ALT_CASE_PRIVATE, PASSWORD_KEY));
-                keyStore.setEntry(ALIAS_ALT_CASE_PRIVATE, getPrivateKey2(), PARAM_KEY);
-                assertPrivateKey(keyStore.getKey(ALIAS_PRIVATE, PASSWORD_KEY));
-                assertPrivateKey2(keyStore.getKey(ALIAS_ALT_CASE_PRIVATE, PASSWORD_KEY));
+                if (isKeyPasswordSupported(keyStore)) {
+                    assertPrivateKey(keyStore.getKey(ALIAS_PRIVATE, PASSWORD_KEY));
+                    assertNull(keyStore.getKey(ALIAS_ALT_CASE_PRIVATE, PASSWORD_KEY));
+                    keyStore.setEntry(ALIAS_ALT_CASE_PRIVATE, getPrivateKey2(), PARAM_KEY);
+                    assertPrivateKey(keyStore.getKey(ALIAS_PRIVATE, PASSWORD_KEY));
+                    assertPrivateKey2(keyStore.getKey(ALIAS_ALT_CASE_PRIVATE, PASSWORD_KEY));
+                }
+
+                if (isNullPasswordAllowed(keyStore)) {
+                    assertPrivateKey(keyStore.getKey(ALIAS_NO_PASSWORD_PRIVATE, null));
+                    assertNull(keyStore.getKey(ALIAS_ALT_CASE_NO_PASSWORD_PRIVATE, null));
+                    keyStore.setEntry(ALIAS_ALT_CASE_NO_PASSWORD_PRIVATE, getPrivateKey2(), null);
+                    assertPrivateKey(keyStore.getKey(ALIAS_NO_PASSWORD_PRIVATE, null));
+                    assertPrivateKey2(keyStore.getKey(ALIAS_ALT_CASE_NO_PASSWORD_PRIVATE, null));
+                }
 
                 if (isSecretKeyEnabled(keyStore)) {
                     assertSecretKey(keyStore.getKey(ALIAS_SECRET, PASSWORD_KEY));
@@ -2073,10 +2284,17 @@ public class KeyStoreTest extends TestCase {
             }
 
             // test case sensitive
-            assertTrue(keyStore.entryInstanceOf(ALIAS_PRIVATE, PrivateKeyEntry.class));
+            assertEquals(isKeyPasswordSupported(keyStore),
+                    keyStore.entryInstanceOf(ALIAS_PRIVATE, PrivateKeyEntry.class));
             assertFalse(keyStore.entryInstanceOf(ALIAS_PRIVATE, SecretKeyEntry.class));
             assertFalse(keyStore.entryInstanceOf(ALIAS_PRIVATE, TrustedCertificateEntry.class));
 
+            assertEquals(isNullPasswordAllowed(keyStore),
+                    keyStore.entryInstanceOf(ALIAS_NO_PASSWORD_PRIVATE, PrivateKeyEntry.class));
+            assertFalse(keyStore.entryInstanceOf(ALIAS_NO_PASSWORD_PRIVATE, SecretKeyEntry.class));
+            assertFalse(keyStore.entryInstanceOf(ALIAS_NO_PASSWORD_PRIVATE,
+                    TrustedCertificateEntry.class));
+
             assertEquals(isSecretKeyEnabled(keyStore),
                          keyStore.entryInstanceOf(ALIAS_SECRET, SecretKeyEntry.class));
             assertFalse(keyStore.entryInstanceOf(ALIAS_SECRET, PrivateKeyEntry.class));
@@ -2173,7 +2391,7 @@ public class KeyStoreTest extends TestCase {
             OutputStream os = null;
             try {
                 os = new FileOutputStream(file);
-                if (isReadOnly(keyStore)) {
+                if (isLoadStoreUnsupported(keyStore) || isReadOnly(keyStore)) {
                     try {
                         keyStore.store(os, PASSWORD_STORE);
                         fail(keyStore.getType());
@@ -2204,6 +2422,9 @@ public class KeyStoreTest extends TestCase {
         }
 
         for (KeyStore keyStore : keyStores()) {
+            if (isLoadStoreUnsupported(keyStore)) {
+                continue;
+            }
             Builder builder = Builder.newInstance(keyStore.getType(),
                                                   keyStore.getProvider(),
                                                   PARAM_STORE);
-- 
cgit v1.1


From a138def5cf0f28168d353184050c1e526a3c9db9 Mon Sep 17 00:00:00 2001
From: Kenny Root <kroot@google.com>
Date: Fri, 31 Aug 2012 17:03:04 -0700
Subject: Disable AndroidKeyStore in libcore tests

Change-Id: I168cc82a8feca4bd3b7a1089c1eef339278d5727
---
 luni/src/test/java/libcore/java/security/KeyStoreTest.java | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/luni/src/test/java/libcore/java/security/KeyStoreTest.java b/luni/src/test/java/libcore/java/security/KeyStoreTest.java
index 9302dd6..9e2dacb 100644
--- a/luni/src/test/java/libcore/java/security/KeyStoreTest.java
+++ b/luni/src/test/java/libcore/java/security/KeyStoreTest.java
@@ -168,7 +168,9 @@ public class KeyStoreTest extends TestCase {
 
     private static boolean isUnsupported(KeyStore ks) {
         // Don't bother testing BC on RI
-        return (StandardNames.IS_RI && ks.getProvider().getName().equals("BC"));
+        // TODO enable AndroidKeyStore when CTS can set up the keystore
+        return (StandardNames.IS_RI && ks.getProvider().getName().equals("BC"))
+                || "AndroidKeyStore".equalsIgnoreCase(ks.getType());
     }
 
     private static boolean isNullPasswordAllowed(KeyStore ks) {
-- 
cgit v1.1


From 8b43d6de8df989711dd0779d689e1a1c1f9df68e Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Fri, 31 Aug 2012 14:44:49 -0700
Subject: Fix NativeCrypto.d2i_SSL_SESSION to initialize SSL_SESSION's cipher
 field

Bug: 7091840
Change-Id: I9dee0e39bae6aba28c7ea768242e64c9443d9e49
---
 ..._apache_harmony_xnet_provider_jsse_NativeCrypto.cpp | 18 ++++++++++++++++++
 .../harmony/xnet/provider/jsse/NativeCryptoTest.java   |  8 +++++++-
 2 files changed, 25 insertions(+), 1 deletion(-)

diff --git a/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp b/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
index df500ac..27476cd 100644
--- a/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
+++ b/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
@@ -21,6 +21,7 @@
 #define LOG_TAG "NativeCrypto"
 
 #include <algorithm>
+#include <arpa/inet.h>
 #include <fcntl.h>
 #include <sys/socket.h>
 #include <unistd.h>
@@ -4408,6 +4409,23 @@ static jint NativeCrypto_d2i_SSL_SESSION(JNIEnv* env, jclass, jbyteArray javaByt
     const unsigned char* ucp = reinterpret_cast<const unsigned char*>(bytes.get());
     SSL_SESSION* ssl_session = d2i_SSL_SESSION(NULL, &ucp, bytes.size());
 
+    // Initialize SSL_SESSION cipher field based on cipher_id http://b/7091840
+    if (ssl_session != NULL) {
+        // based on ssl_get_prev_session
+        uint32_t cipher_id_network_order = htonl(ssl_session->cipher_id);
+        uint8_t* cipher_id_byte_pointer = reinterpret_cast<uint8_t*>(&cipher_id_network_order);
+        if (ssl_session->ssl_version >= SSL3_VERSION_MAJOR) {
+            cipher_id_byte_pointer += 2; // skip first two bytes for SSL3+
+        } else {
+            cipher_id_byte_pointer += 1; // skip first byte for SSL2
+        }
+        ssl_session->cipher = SSLv23_method()->get_cipher_by_char(cipher_id_byte_pointer);
+        JNI_TRACE("NativeCrypto_d2i_SSL_SESSION cipher_id=%lx hton=%x 0=%x 1=%x cipher=%s",
+                  ssl_session->cipher_id, cipher_id_network_order,
+                  cipher_id_byte_pointer[0], cipher_id_byte_pointer[1],
+                  SSL_CIPHER_get_name(ssl_session->cipher));
+    }
+
     JNI_TRACE("NativeCrypto_d2i_SSL_SESSION => %p", ssl_session);
     return static_cast<jint>(reinterpret_cast<uintptr_t>(ssl_session));
 }
diff --git a/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/NativeCryptoTest.java b/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/NativeCryptoTest.java
index 8618d05..15b175c 100644
--- a/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/NativeCryptoTest.java
+++ b/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/NativeCryptoTest.java
@@ -1658,6 +1658,12 @@ public class NativeCryptoTest extends TestCase {
                 assertNotNull(b);
                 int session2 = NativeCrypto.d2i_SSL_SESSION(b);
                 assertTrue(session2 != NULL);
+
+                // Make sure d2i_SSL_SESSION retores SSL_SESSION_cipher value http://b/7091840
+                assertTrue(NativeCrypto.SSL_SESSION_cipher(session2) != null);
+                assertEquals(NativeCrypto.SSL_SESSION_cipher(session),
+                             NativeCrypto.SSL_SESSION_cipher(session2));
+
                 NativeCrypto.SSL_SESSION_free(session2);
                 super.afterHandshake(session, s, c, sock, fd, callback);
             }
@@ -1679,7 +1685,7 @@ public class NativeCryptoTest extends TestCase {
         assertEquals(NULL, NativeCrypto.d2i_SSL_SESSION(new byte[0]));
         assertEquals(NULL, NativeCrypto.d2i_SSL_SESSION(new byte[1]));
 
-        // positively testing by test_i2d_SSL_SESSION
+        // positive testing by test_i2d_SSL_SESSION
     }
 
     public void test_X509_NAME_hashes() {
-- 
cgit v1.1


From 9596d75ebf937d47a2de195b09584e88c91eb6f6 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Wed, 29 Aug 2012 17:57:52 -0700
Subject: Fix date parsing for RTL languages such as Arabic.

(The cleanup of the native code is an irrelevant target of opportunity.)

Bug: http://code.google.com/p/android/issues/detail?id=36689
Change-Id: I6d9f0bbbd6e8f99421072102e0d785bc3429cc14
---
 luni/src/main/java/java/text/SimpleDateFormat.java | 34 +++++++++++++++++-----
 .../native/libcore_icu_NativeDecimalFormat.cpp     | 28 +++++-------------
 .../libcore/java/text/SimpleDateFormatTest.java    | 19 ++++++++++++
 3 files changed, 53 insertions(+), 28 deletions(-)

diff --git a/luni/src/main/java/java/text/SimpleDateFormat.java b/luni/src/main/java/java/text/SimpleDateFormat.java
index 5ed51a1..f39f770 100644
--- a/luni/src/main/java/java/text/SimpleDateFormat.java
+++ b/luni/src/main/java/java/text/SimpleDateFormat.java
@@ -1070,24 +1070,42 @@ public class SimpleDateFormat extends DateFormat {
     }
 
     private Number parseNumber(int max, String string, ParsePosition position) {
-        int digit, length = string.length(), result = 0;
+        int length = string.length();
         int index = position.getIndex();
         if (max > 0 && max < length - index) {
             length = index + max;
         }
-        while (index < length
-                && (string.charAt(index) == ' ' || string.charAt(index) == '\t')) {
-            index++;
+        while (index < length && (string.charAt(index) == ' ' || string.charAt(index) == '\t')) {
+            ++index;
         }
         if (max == 0) {
             position.setIndex(index);
-            return numberFormat.parse(string, position);
+            Number n = numberFormat.parse(string, position);
+            // In RTL locales, NumberFormat might have parsed "2012-" in an ISO date as the
+            // negative number -2012.
+            // Ideally, we wouldn't have this broken API that exposes a NumberFormat and expects
+            // us to use it. The next best thing would be a way to ask the NumberFormat to parse
+            // positive numbers only, but icu4c supports negative (BCE) years. The best we can do
+            // is try to recognize when icu4c has done this, and undo it.
+            if (n != null && n.longValue() < 0) {
+                if (numberFormat instanceof DecimalFormat) {
+                    DecimalFormat df = (DecimalFormat) numberFormat;
+                    char lastChar = string.charAt(position.getIndex() - 1);
+                    char minusSign = df.getDecimalFormatSymbols().getMinusSign();
+                    if (lastChar == minusSign) {
+                        n = Long.valueOf(-n.longValue()); // Make the value positive.
+                        position.setIndex(position.getIndex() - 1); // Spit out the negative sign.
+                    }
+                }
+            }
+            return n;
         }
 
-        while (index < length
-                && (digit = Character.digit(string.charAt(index), 10)) != -1) {
-            index++;
+        int result = 0;
+        int digit;
+        while (index < length && (digit = Character.digit(string.charAt(index), 10)) != -1) {
             result = result * 10 + digit;
+            ++index;
         }
         if (index == position.getIndex()) {
             position.setErrorIndex(index);
diff --git a/luni/src/main/native/libcore_icu_NativeDecimalFormat.cpp b/luni/src/main/native/libcore_icu_NativeDecimalFormat.cpp
index dead1a8..0406094 100644
--- a/luni/src/main/native/libcore_icu_NativeDecimalFormat.cpp
+++ b/luni/src/main/native/libcore_icu_NativeDecimalFormat.cpp
@@ -303,9 +303,9 @@ static jobject NativeDecimalFormat_parse(JNIEnv* env, jclass, jint addr, jstring
     fmt->parse(src.unicodeString(), res, pp);
 
     if (pp.getErrorIndex() == -1) {
-        env->CallVoidMethod(position, gPP_setIndex, (jint) pp.getIndex());
+        env->CallVoidMethod(position, gPP_setIndex, pp.getIndex());
     } else {
-        env->CallVoidMethod(position, gPP_setErrorIndex, (jint) pp.getErrorIndex());
+        env->CallVoidMethod(position, gPP_setErrorIndex, pp.getErrorIndex());
         return NULL;
     }
 
@@ -319,30 +319,18 @@ static jobject NativeDecimalFormat_parse(JNIEnv* env, jclass, jint addr, jstring
                 strncmp(data, "Inf", 3) == 0 ||
                 strncmp(data, "-Inf", 4) == 0) {
                 double resultDouble = res.getDouble(status);
-                return doubleValueOf(env, (jdouble) resultDouble);
+                return doubleValueOf(env, resultDouble);
             }
             return newBigDecimal(env, data, len);
         }
         return NULL;
     }
 
-    Formattable::Type numType = res.getType();
-        switch(numType) {
-        case Formattable::kDouble: {
-            double resultDouble = res.getDouble();
-            return doubleValueOf(env, (jdouble) resultDouble);
-        }
-        case Formattable::kLong: {
-            long resultLong = res.getLong();
-            return longValueOf(env, (jlong) resultLong);
-        }
-        case Formattable::kInt64: {
-            int64_t resultInt64 = res.getInt64();
-            return longValueOf(env, (jlong) resultInt64);
-        }
-        default: {
-            return NULL;
-        }
+    switch (res.getType()) {
+        case Formattable::kDouble: return doubleValueOf(env, res.getDouble());
+        case Formattable::kLong:   return longValueOf(env, res.getLong());
+        case Formattable::kInt64:  return longValueOf(env, res.getInt64());
+        default:                   return NULL;
     }
 }
 
diff --git a/luni/src/test/java/libcore/java/text/SimpleDateFormatTest.java b/luni/src/test/java/libcore/java/text/SimpleDateFormatTest.java
index baa4ae2..cd54d1e 100644
--- a/luni/src/test/java/libcore/java/text/SimpleDateFormatTest.java
+++ b/luni/src/test/java/libcore/java/text/SimpleDateFormatTest.java
@@ -228,4 +228,23 @@ public class SimpleDateFormatTest extends junit.framework.TestCase {
         new SimpleDateFormat("z", Locale.FRANCE).parse("UTC");
         new SimpleDateFormat("z", Locale.US).parse("UTC");
     }
+
+    // http://code.google.com/p/android/issues/detail?id=36689
+    public void testParseArabic() throws Exception {
+        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss", new Locale("ar", "EG"));
+        sdf.setTimeZone(TimeZone.getTimeZone("America/Los_Angeles"));
+
+        // Can we parse an ASCII-formatted date in an Arabic locale?
+        Date d = sdf.parse("2012-08-29 10:02:45");
+        assertEquals(1346259765000L, d.getTime());
+
+        // Can we format a date correctly in an Arabic locale?
+        String formatted = sdf.format(d);
+        assertEquals("٢٠١٢-٠٨-٢٩ ١٠:٠٢:٤٥", formatted);
+
+        // Can we parse the Arabic-formatted date in an Arabic locale, and get the same date
+        // we started with?
+        Date d2 = sdf.parse(formatted);
+        assertEquals(d, d2);
+    }
 }
-- 
cgit v1.1


From bb5816aa1626eb2f6263bd21479600b114c8a1bd Mon Sep 17 00:00:00 2001
From: Johan Redestig <johan.redestig@sonymobile.com>
Date: Tue, 10 Jan 2012 17:48:01 +0900
Subject: Make FileDescriptor.sync() work on ttys

fsync on Linux fails on tty file descriptors. This change
adds the capability to make sure all data was written to the
terminal device descriptor to java.io.FileDescriptor.sync()
implementation.

Also fixed the return value from Posix_isatty. isatty
returns 1 if an fd is a tty and 0 otherwise.

Change-Id: I6cc65db83f523b4c31b67b48d7534e18af0989e8
---
 luni/src/main/java/java/io/FileDescriptor.java  | 6 +++++-
 luni/src/main/java/libcore/io/ForwardingOs.java | 1 +
 luni/src/main/java/libcore/io/Os.java           | 1 +
 luni/src/main/java/libcore/io/Posix.java        | 1 +
 luni/src/main/native/libcore_io_Posix.cpp       | 9 ++++++++-
 5 files changed, 16 insertions(+), 2 deletions(-)

diff --git a/luni/src/main/java/java/io/FileDescriptor.java b/luni/src/main/java/java/io/FileDescriptor.java
index f04ae2c..e4eb06c 100644
--- a/luni/src/main/java/java/io/FileDescriptor.java
+++ b/luni/src/main/java/java/io/FileDescriptor.java
@@ -68,7 +68,11 @@ public final class FileDescriptor {
      */
     public void sync() throws SyncFailedException {
         try {
-            Libcore.os.fsync(this);
+            if (Libcore.os.isatty(this)) {
+                Libcore.os.tcdrain(this);
+            } else {
+                Libcore.os.fsync(this);
+            }
         } catch (ErrnoException errnoException) {
             SyncFailedException sfe = new SyncFailedException(errnoException.getMessage());
             sfe.initCause(errnoException);
diff --git a/luni/src/main/java/libcore/io/ForwardingOs.java b/luni/src/main/java/libcore/io/ForwardingOs.java
index 20b85d7..e7f3538 100644
--- a/luni/src/main/java/libcore/io/ForwardingOs.java
+++ b/luni/src/main/java/libcore/io/ForwardingOs.java
@@ -125,6 +125,7 @@ public class ForwardingOs implements Os {
     public String strerror(int errno) { return os.strerror(errno); }
     public void symlink(String oldPath, String newPath) throws ErrnoException { os.symlink(oldPath, newPath); }
     public long sysconf(int name) { return os.sysconf(name); }
+    public void tcdrain(FileDescriptor fd) throws ErrnoException { os.tcdrain(fd); }
     public int umask(int mask) { return os.umask(mask); }
     public StructUtsname uname() { return os.uname(); }
     public int waitpid(int pid, MutableInt status, int options) throws ErrnoException { return os.waitpid(pid, status, options); }
diff --git a/luni/src/main/java/libcore/io/Os.java b/luni/src/main/java/libcore/io/Os.java
index f4eaaaf..721fe7c 100644
--- a/luni/src/main/java/libcore/io/Os.java
+++ b/luni/src/main/java/libcore/io/Os.java
@@ -119,6 +119,7 @@ public interface Os {
     public String strerror(int errno);
     public void symlink(String oldPath, String newPath) throws ErrnoException;
     public long sysconf(int name);
+    public void tcdrain(FileDescriptor fd) throws ErrnoException;
     public int umask(int mask);
     public StructUtsname uname();
     public int waitpid(int pid, MutableInt status, int options) throws ErrnoException;
diff --git a/luni/src/main/java/libcore/io/Posix.java b/luni/src/main/java/libcore/io/Posix.java
index ec3f3e2..a35c1a6 100644
--- a/luni/src/main/java/libcore/io/Posix.java
+++ b/luni/src/main/java/libcore/io/Posix.java
@@ -169,6 +169,7 @@ public final class Posix implements Os {
     public native String strerror(int errno);
     public native void symlink(String oldPath, String newPath) throws ErrnoException;
     public native long sysconf(int name);
+    public native void tcdrain(FileDescriptor fd) throws ErrnoException;
     public native int umask(int mask);
     public native StructUtsname uname();
     public native int waitpid(int pid, MutableInt status, int options) throws ErrnoException;
diff --git a/luni/src/main/native/libcore_io_Posix.cpp b/luni/src/main/native/libcore_io_Posix.cpp
index 7102428..ffac077 100644
--- a/luni/src/main/native/libcore_io_Posix.cpp
+++ b/luni/src/main/native/libcore_io_Posix.cpp
@@ -52,6 +52,7 @@
 #include <sys/utsname.h>
 #include <sys/vfs.h> // Bionic doesn't have <sys/statvfs.h>
 #include <sys/wait.h>
+#include <termios.h>
 #include <unistd.h>
 
 #define TO_JAVA_STRING(NAME, EXP) \
@@ -799,7 +800,7 @@ static jint Posix_ioctlInt(JNIEnv* env, jobject, jobject javaFd, jint cmd, jobje
 
 static jboolean Posix_isatty(JNIEnv* env, jobject, jobject javaFd) {
     int fd = jniGetFDFromFileDescriptor(env, javaFd);
-    return TEMP_FAILURE_RETRY(isatty(fd)) == 0;
+    return TEMP_FAILURE_RETRY(isatty(fd)) == 1;
 }
 
 static void Posix_kill(JNIEnv* env, jobject, jint pid, jint sig) {
@@ -1209,6 +1210,11 @@ static jlong Posix_sysconf(JNIEnv* env, jobject, jint name) {
     return result;
 }
 
+static void Posix_tcdrain(JNIEnv* env, jobject, jobject javaFd) {
+    int fd = jniGetFDFromFileDescriptor(env, javaFd);
+    throwIfMinusOne(env, "tcdrain", TEMP_FAILURE_RETRY(tcdrain(fd)));
+}
+
 static jint Posix_umask(JNIEnv*, jint mask) {
     return umask(mask);
 }
@@ -1335,6 +1341,7 @@ static JNINativeMethod gMethods[] = {
     NATIVE_METHOD(Posix, strerror, "(I)Ljava/lang/String;"),
     NATIVE_METHOD(Posix, symlink, "(Ljava/lang/String;Ljava/lang/String;)V"),
     NATIVE_METHOD(Posix, sysconf, "(I)J"),
+    NATIVE_METHOD(Posix, tcdrain, "(Ljava/io/FileDescriptor;)V"),
     NATIVE_METHOD(Posix, umask, "(I)I"),
     NATIVE_METHOD(Posix, uname, "()Llibcore/io/StructUtsname;"),
     NATIVE_METHOD(Posix, waitpid, "(ILlibcore/util/MutableInt;I)I"),
-- 
cgit v1.1


From c44b3f5d857d0d3f4d3668de905cdac5080ede3b Mon Sep 17 00:00:00 2001
From: Kenny Root <kroot@google.com>
Date: Fri, 31 Aug 2012 16:23:34 -0700
Subject: Better OpenSSL key comparison

Use native code to compare OpenSSL keys instead of converting them to
Java BigIntegers first.

Change-Id: If795c9c26e41174755cdab34ff70e01c7487c9bd
---
 .../harmony/xnet/provider/jsse/NativeCrypto.java   |  2 +
 .../provider/jsse/OpenSSLRSAPrivateCrtKey.java     | 43 +++++-----
 .../xnet/provider/jsse/OpenSSLRSAPrivateKey.java   |  9 +--
 ...che_harmony_xnet_provider_jsse_NativeCrypto.cpp | 21 +++++
 .../xnet/provider/jsse/NativeCryptoTest.java       | 91 ++++++++++++++++++++++
 5 files changed, 140 insertions(+), 26 deletions(-)

diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/NativeCrypto.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/NativeCrypto.java
index df35f72..29b11c2 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/NativeCrypto.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/NativeCrypto.java
@@ -76,6 +76,8 @@ public final class NativeCrypto {
 
     public static native void EVP_PKEY_free(int pkey);
 
+    public static native int EVP_PKEY_cmp(int pkey1, int pkey2);
+
     public static native byte[] i2d_PKCS8_PRIV_KEY_INFO(int pkey);
 
     public static native int d2i_PKCS8_PRIV_KEY_INFO(byte[] data);
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLRSAPrivateCrtKey.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLRSAPrivateCrtKey.java
index 48e1494..4303e5a 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLRSAPrivateCrtKey.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLRSAPrivateCrtKey.java
@@ -191,8 +191,8 @@ public class OpenSSLRSAPrivateCrtKey extends OpenSSLRSAPrivateKey implements RSA
             return true;
         }
 
-        if (o instanceof OpenSSLRSAPrivateCrtKey) {
-            OpenSSLRSAPrivateCrtKey other = (OpenSSLRSAPrivateCrtKey) o;
+        if (o instanceof OpenSSLRSAPrivateKey) {
+            OpenSSLRSAPrivateKey other = (OpenSSLRSAPrivateKey) o;
 
             /*
              * We can shortcut the true case, but it still may be equivalent but
@@ -202,28 +202,35 @@ public class OpenSSLRSAPrivateCrtKey extends OpenSSLRSAPrivateKey implements RSA
                 return true;
             }
 
-            /*
-             * If this key is ENGINE-based, it could be equivalent to another
-             * ENGINE-based key. The modulus may be equal, but that occurrence
-             * should be so improbably low as to never happen.
-             */
-            if (getOpenSSLKey().isEngineBased() || other.getOpenSSLKey().isEngineBased()) {
-                return publicExponent.equals(other.getPublicExponent())
-                        && getModulus().equals(other.getModulus());
-            }
+            return NativeCrypto.EVP_PKEY_cmp(getPkeyContext(), other.getPkeyContext()) == 1;
         }
 
         if (o instanceof RSAPrivateCrtKey) {
             ensureReadParams();
             RSAPrivateCrtKey other = (RSAPrivateCrtKey) o;
 
-            return getModulus().equals(other.getModulus())
-                    && publicExponent.equals(other.getPublicExponent())
-                    && getPrivateExponent().equals(other.getPrivateExponent())
-                    && primeP.equals(other.getPrimeP()) && primeQ.equals(other.getPrimeQ())
-                    && primeExponentP.equals(other.getPrimeExponentP())
-                    && primeExponentQ.equals(other.getPrimeExponentQ())
-                    && crtCoefficient.equals(other.getCrtCoefficient());
+            if (getOpenSSLKey().isEngineBased()) {
+                return getModulus().equals(other.getModulus())
+                        && publicExponent.equals(other.getPublicExponent());
+            } else {
+                return getModulus().equals(other.getModulus())
+                        && publicExponent.equals(other.getPublicExponent())
+                        && getPrivateExponent().equals(other.getPrivateExponent())
+                        && primeP.equals(other.getPrimeP()) && primeQ.equals(other.getPrimeQ())
+                        && primeExponentP.equals(other.getPrimeExponentP())
+                        && primeExponentQ.equals(other.getPrimeExponentQ())
+                        && crtCoefficient.equals(other.getCrtCoefficient());
+            }
+        } else if (o instanceof RSAPrivateKey) {
+            ensureReadParams();
+            RSAPrivateKey other = (RSAPrivateKey) o;
+
+            if (getOpenSSLKey().isEngineBased()) {
+                return getModulus().equals(other.getModulus());
+            } else {
+                return getModulus().equals(other.getModulus())
+                        && getPrivateExponent().equals(other.getPrivateExponent());
+            }
         }
 
         return false;
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLRSAPrivateKey.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLRSAPrivateKey.java
index 5c2f075..adb05a9 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLRSAPrivateKey.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLRSAPrivateKey.java
@@ -201,14 +201,7 @@ public class OpenSSLRSAPrivateKey implements RSAPrivateKey {
                 return true;
             }
 
-            /*
-             * If this key is ENGINE-based, it could be equivalent to another
-             * ENGINE-based key. The modulus may be equal, but that occurrence
-             * should be so improbably low as to never happen.
-             */
-            if (key.isEngineBased() || other.getOpenSSLKey().isEngineBased()) {
-                return modulus.equals(other.getModulus());
-            }
+            return NativeCrypto.EVP_PKEY_cmp(getPkeyContext(), other.getPkeyContext()) == 1;
         }
 
         if (o instanceof RSAPrivateKey) {
diff --git a/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp b/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
index 7346525..dd42ea0 100644
--- a/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
+++ b/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
@@ -891,6 +891,26 @@ static void NativeCrypto_EVP_PKEY_free(JNIEnv*, jclass, EVP_PKEY* pkey) {
     }
 }
 
+static jint NativeCrypto_EVP_PKEY_cmp(JNIEnv* env, jclass, jint pkey1Ref, jint pkey2Ref) {
+    EVP_PKEY* pkey1 = reinterpret_cast<EVP_PKEY*>(pkey1Ref);
+    EVP_PKEY* pkey2 = reinterpret_cast<EVP_PKEY*>(pkey2Ref);
+    JNI_TRACE("EVP_PKEY_cmp(%p, %p)", pkey1, pkey2);
+
+    if (pkey1 == NULL) {
+        JNI_TRACE("EVP_PKEY_cmp(%p, %p) => failed pkey1 == NULL", pkey1, pkey2);
+        jniThrowNullPointerException(env, "pkey1 == NULL");
+        return -1;
+    } else if (pkey2 == NULL) {
+        JNI_TRACE("EVP_PKEY_cmp(%p, %p) => failed pkey2 == NULL", pkey1, pkey2);
+        jniThrowNullPointerException(env, "pkey2 == NULL");
+        return -1;
+    }
+
+    int result = EVP_PKEY_cmp(pkey1, pkey2);
+    JNI_TRACE("EVP_PKEY_cmp(%p, %p) => %d", pkey1, pkey2, result);
+    return result;
+}
+
 /*
  * static native byte[] i2d_PKCS8_PRIV_KEY_INFO(int, byte[])
  */
@@ -4453,6 +4473,7 @@ static JNINativeMethod sNativeCryptoMethods[] = {
     NATIVE_METHOD(NativeCrypto, EVP_PKEY_type, "(I)I"),
     NATIVE_METHOD(NativeCrypto, EVP_PKEY_size, "(I)I"),
     NATIVE_METHOD(NativeCrypto, EVP_PKEY_free, "(I)V"),
+    NATIVE_METHOD(NativeCrypto, EVP_PKEY_cmp, "(II)I"),
     NATIVE_METHOD(NativeCrypto, i2d_PKCS8_PRIV_KEY_INFO, "(I)[B"),
     NATIVE_METHOD(NativeCrypto, d2i_PKCS8_PRIV_KEY_INFO, "([B)I"),
     NATIVE_METHOD(NativeCrypto, i2d_PUBKEY, "(I)[B"),
diff --git a/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/NativeCryptoTest.java b/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/NativeCryptoTest.java
index 15b175c..b2be7f5 100644
--- a/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/NativeCryptoTest.java
+++ b/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/NativeCryptoTest.java
@@ -21,10 +21,14 @@ import java.io.IOException;
 import java.net.ServerSocket;
 import java.net.Socket;
 import java.net.SocketTimeoutException;
+import java.security.KeyPair;
+import java.security.KeyPairGenerator;
 import java.security.KeyStore;
 import java.security.KeyStore.PrivateKeyEntry;
 import java.security.cert.CertificateException;
 import java.security.cert.X509Certificate;
+import java.security.interfaces.RSAPrivateCrtKey;
+import java.security.interfaces.RSAPrivateKey;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
@@ -131,6 +135,93 @@ public class NativeCryptoTest extends TestCase {
         assertEquals(Arrays.deepToString(expected), Arrays.deepToString(actual));
     }
 
+    public void test_EVP_PKEY_cmp() throws Exception {
+        try {
+            NativeCrypto.EVP_PKEY_cmp(NULL, NULL);
+            fail("Should throw NullPointerException when arguments are NULL");
+        } catch (NullPointerException expected) {
+        }
+
+        KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA");
+        kpg.initialize(512);
+
+        RSAPrivateCrtKey privKey1, privKey2;
+
+        {
+            KeyPair kp1 = kpg.generateKeyPair();
+            privKey1 = (RSAPrivateCrtKey) kp1.getPrivate();
+        }
+
+        {
+            KeyPair kp2 = kpg.generateKeyPair();
+            privKey2 = (RSAPrivateCrtKey) kp2.getPrivate();
+        }
+
+        int pkey1 = 0, pkey1_copy = 0, pkey2 = 0;
+        try {
+            pkey1 = NativeCrypto.EVP_PKEY_new_RSA(privKey1.getModulus().toByteArray(),
+                        privKey1.getPublicExponent().toByteArray(),
+                        privKey1.getPrivateExponent().toByteArray(),
+                        privKey1.getPrimeP().toByteArray(),
+                        privKey1.getPrimeQ().toByteArray(),
+                        privKey1.getPrimeExponentP().toByteArray(),
+                        privKey1.getPrimeExponentQ().toByteArray(),
+                        privKey1.getCrtCoefficient().toByteArray());
+            assertNotSame(NULL, pkey1);
+
+            pkey1_copy = NativeCrypto.EVP_PKEY_new_RSA(privKey1.getModulus().toByteArray(),
+                    privKey1.getPublicExponent().toByteArray(),
+                    privKey1.getPrivateExponent().toByteArray(),
+                    privKey1.getPrimeP().toByteArray(),
+                    privKey1.getPrimeQ().toByteArray(),
+                    privKey1.getPrimeExponentP().toByteArray(),
+                    privKey1.getPrimeExponentQ().toByteArray(),
+                    privKey1.getCrtCoefficient().toByteArray());
+            assertNotSame(NULL, pkey1_copy);
+
+            pkey2 = NativeCrypto.EVP_PKEY_new_RSA(privKey2.getModulus().toByteArray(),
+                    privKey2.getPublicExponent().toByteArray(),
+                    privKey2.getPrivateExponent().toByteArray(),
+                    privKey2.getPrimeP().toByteArray(),
+                    privKey2.getPrimeQ().toByteArray(),
+                    privKey2.getPrimeExponentP().toByteArray(),
+                    privKey2.getPrimeExponentQ().toByteArray(),
+                    privKey2.getCrtCoefficient().toByteArray());
+            assertNotSame(NULL, pkey2);
+
+            try {
+                NativeCrypto.EVP_PKEY_cmp(pkey1, NULL);
+                fail("Should throw NullPointerException when arguments are NULL");
+            } catch (NullPointerException expected) {
+            }
+
+            try {
+                NativeCrypto.EVP_PKEY_cmp(NULL, pkey1);
+                fail("Should throw NullPointerException when arguments are NULL");
+            } catch (NullPointerException expected) {
+            }
+
+            assertEquals("Same keys should be the equal", 1,
+                    NativeCrypto.EVP_PKEY_cmp(pkey1, pkey1));
+
+            assertEquals("Same keys should be the equal", 1,
+                    NativeCrypto.EVP_PKEY_cmp(pkey1, pkey1_copy));
+
+            assertEquals("Different keys should not be equal", 0,
+                    NativeCrypto.EVP_PKEY_cmp(pkey1, pkey2));
+        } finally {
+            if (pkey1 != 0) {
+                NativeCrypto.EVP_PKEY_free(pkey1);
+            }
+            if (pkey1_copy != 0) {
+                NativeCrypto.EVP_PKEY_free(pkey1_copy);
+            }
+            if (pkey2 != 0) {
+                NativeCrypto.EVP_PKEY_free(pkey2);
+            }
+        }
+    }
+
     public void test_SSL_CTX_new() throws Exception {
         int c = NativeCrypto.SSL_CTX_new();
         assertTrue(c != NULL);
-- 
cgit v1.1


From 5ab0d1d4c268a760176a12b85abcbf1bdee0f455 Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Fri, 7 Sep 2012 17:14:31 -0700
Subject: KeyStoreTest should not populate read only KeyStores

Change-Id: I3dd3fd4f73ddb92c1e5b37ce1294d4abc35b2b5c
---
 luni/src/test/java/libcore/java/security/KeyStoreTest.java | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/luni/src/test/java/libcore/java/security/KeyStoreTest.java b/luni/src/test/java/libcore/java/security/KeyStoreTest.java
index 9e2dacb..ddee6ce 100644
--- a/luni/src/test/java/libcore/java/security/KeyStoreTest.java
+++ b/luni/src/test/java/libcore/java/security/KeyStoreTest.java
@@ -220,7 +220,10 @@ public class KeyStoreTest extends TestCase {
     }
 
     public static void populate(KeyStore ks) throws Exception {
-        clearKeyStore(ks);
+        boolean readOnly = clearKeyStore(ks);
+        if (readOnly) {
+            return;
+        }
         if (isKeyPasswordSupported(ks)) {
             setPrivateKey(ks);
         }
@@ -245,7 +248,7 @@ public class KeyStoreTest extends TestCase {
         }
     }
 
-    private static void clearKeyStore(KeyStore ks) throws Exception {
+    private static boolean clearKeyStore(KeyStore ks) throws Exception {
         ks.load(null, null);
         if (isReadOnly(ks)) {
             try {
@@ -253,7 +256,7 @@ public class KeyStoreTest extends TestCase {
                 fail(ks.toString());
             } catch (UnsupportedOperationException e) {
             }
-            return;
+            return true;
         }
         if (isPersistentStorage(ks)) {
             Enumeration<String> aliases = ks.aliases();
@@ -262,6 +265,7 @@ public class KeyStoreTest extends TestCase {
                 ks.deleteEntry(alias);
             }
         }
+        return false;
     }
 
     public static void setPrivateKeyNoPassword(KeyStore ks, String alias, PrivateKeyEntry privateKey)
-- 
cgit v1.1


From 44d737281c6a6c9be6ea1eb58cf678f43643650a Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Sun, 9 Sep 2012 13:08:17 -0700
Subject: Get expat header files from the approved location.

Change-Id: Ie896d616b21ba2e1db33d39a721150e4e4d59d21
---
 luni/src/main/native/org_apache_harmony_xml_ExpatParser.cpp | 2 +-
 luni/src/main/native/sub.mk                                 | 1 -
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/luni/src/main/native/org_apache_harmony_xml_ExpatParser.cpp b/luni/src/main/native/org_apache_harmony_xml_ExpatParser.cpp
index d08b7d2..ce41a51 100644
--- a/luni/src/main/native/org_apache_harmony_xml_ExpatParser.cpp
+++ b/luni/src/main/native/org_apache_harmony_xml_ExpatParser.cpp
@@ -30,7 +30,7 @@
 #include "unicode/unistr.h"
 
 #include <string.h>
-#include <expat.h>
+#include <libexpat/expat.h>
 
 #define BUCKET_COUNT 128
 
diff --git a/luni/src/main/native/sub.mk b/luni/src/main/native/sub.mk
index b67348b..d5705a6 100644
--- a/luni/src/main/native/sub.mk
+++ b/luni/src/main/native/sub.mk
@@ -52,7 +52,6 @@ LOCAL_SRC_FILES := \
 	valueOf.cpp
 
 LOCAL_C_INCLUDES += \
-	external/expat/lib \
 	external/icu4c/common \
 	external/icu4c/i18n \
 	external/openssl/include \
-- 
cgit v1.1


From b37323027a3fb66b07a2c70eb48e9dd1c4c0f466 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Tue, 11 Sep 2012 15:17:12 -0700
Subject: Document that Random.nextGaussian should use StrictMath.

Bug: 7146208
Change-Id: Ife58d868e9310de3f378500fdbf53b2f3a690f04
---
 luni/src/main/java/java/util/Random.java | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/luni/src/main/java/java/util/Random.java b/luni/src/main/java/java/util/Random.java
index cc9de58..b0a92ff 100644
--- a/luni/src/main/java/java/util/Random.java
+++ b/luni/src/main/java/java/util/Random.java
@@ -151,6 +151,8 @@ public class Random implements Serializable {
             v2 = 2 * nextDouble() - 1;
             s = v1 * v1 + v2 * v2;
         } while (s >= 1 || s == 0);
+
+        // The specification says this uses StrictMath.
         double multiplier = StrictMath.sqrt(-2 * StrictMath.log(s) / s);
         nextNextGaussian = v2 * multiplier;
         haveNextNextGaussian = true;
-- 
cgit v1.1


From 0a156e0126e8015f2791e9a7dd48bbdaeae0c335 Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Tue, 11 Sep 2012 15:22:50 -0700
Subject: Add OpenSSLProvider support for Cipher.RSA/None/PKCS1Padding

Summary:
- Add OpenSSLProvider support for Cipher.RSA/None/PKCS1Padding
  Added NativeCrypto.RSA_private_decrypt and NativeCrypto.RSA_public_encrypt
- Changed OpenSSLSignatureRawRSA to use new Cipher.RSA/None/PKCS1Padding
  Removed now obsoleted NativeCrypto APIs for
  RSA_padding_add_PKCS1_type_1 and RSA_padding_check_PKCS1_type_1
- added wrap/unwrap support OpenSSLCipherRSA
  Needed for SSLEngine (and fallback SSLSocket implementation)
  which are now picking up the new Cipher.RSA/None/PKCS1Padding
- expanded CipherTest to sanity test all algorithms and PKCS1 padding

Change-Id: I03566cc86ffce07d44d5e0094fa82c9c24587c26
---
 expectations/knownfailures.txt                     |   6 -
 .../harmony/xnet/provider/jsse/NativeCrypto.java   |  12 +-
 .../xnet/provider/jsse/OpenSSLCipherRSA.java       | 338 +++++++++++++++
 .../xnet/provider/jsse/OpenSSLCipherRawRSA.java    | 234 ----------
 .../xnet/provider/jsse/OpenSSLProvider.java        |   4 +-
 .../xnet/provider/jsse/OpenSSLSignatureRawRSA.java |  32 +-
 ...che_harmony_xnet_provider_jsse_NativeCrypto.cpp | 175 +++-----
 .../java/libcore/java/security/SignatureTest.java  |  15 +-
 .../test/java/libcore/javax/crypto/CipherTest.java | 474 ++++++++++++++++++++-
 .../java/libcore/java/security/StandardNames.java  |   1 +
 10 files changed, 891 insertions(+), 400 deletions(-)
 create mode 100644 luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLCipherRSA.java
 delete mode 100644 luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLCipherRawRSA.java

diff --git a/expectations/knownfailures.txt b/expectations/knownfailures.txt
index fe110ea..972f1ef 100644
--- a/expectations/knownfailures.txt
+++ b/expectations/knownfailures.txt
@@ -89,12 +89,6 @@
   substring: "java.net.URISyntaxException"
 },
 {
-  description: "Test regression",
-  name: "libcore.javax.crypto.spec.KeyFactoryTestDSA#testKeyFactory",
-  substring: "not implemented yet",
-  bug: 3286592
-},
-{
   description: "KxmlParser doesn't expose DTD text",
   name: "libcore.xml.KxmlPullParserDtdTest#testDoctypeWithNextToken",
   bug: 3241492
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/NativeCrypto.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/NativeCrypto.java
index df35f72..84f33f2 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/NativeCrypto.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/NativeCrypto.java
@@ -22,6 +22,7 @@ import java.net.SocketTimeoutException;
 import java.nio.ByteOrder;
 import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
+import java.security.SignatureException;
 import java.security.cert.Certificate;
 import java.security.cert.CertificateEncodingException;
 import java.security.cert.CertificateException;
@@ -31,6 +32,7 @@ import java.util.HashMap;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import javax.crypto.BadPaddingException;
 import javax.net.ssl.SSLException;
 import javax.security.auth.x500.X500Principal;
 import libcore.io.Memory;
@@ -92,13 +94,13 @@ public final class NativeCrypto {
             int padding);
 
     public static native int RSA_public_decrypt(int flen, byte[] from, byte[] to, int pkey,
-            int padding);
+            int padding) throws BadPaddingException, SignatureException;
 
-    public static native void RSA_padding_add_PKCS1_type_1(byte[] to, int tlen, byte[] from,
-            int flen);
+    public static native int RSA_public_encrypt(int flen, byte[] from, byte[] to, int pkey,
+            int padding);
 
-    public static native int RSA_padding_check_PKCS1_type_1(byte[] to, int tlen, byte[] from,
-            int flen, int rsa_len);
+    public static native int RSA_private_decrypt(int flen, byte[] from, byte[] to, int pkey,
+            int padding) throws BadPaddingException, SignatureException;
 
     /**
      * @return array of {n, e}
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLCipherRSA.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLCipherRSA.java
new file mode 100644
index 0000000..a11ffa9
--- /dev/null
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLCipherRSA.java
@@ -0,0 +1,338 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed 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.xnet.provider.jsse;
+
+import java.security.AlgorithmParameters;
+import java.security.InvalidAlgorithmParameterException;
+import java.security.InvalidKeyException;
+import java.security.InvalidParameterException;
+import java.security.Key;
+import java.security.KeyFactory;
+import java.security.NoSuchAlgorithmException;
+import java.security.SecureRandom;
+import java.security.SignatureException;
+import java.security.interfaces.RSAPrivateCrtKey;
+import java.security.interfaces.RSAPrivateKey;
+import java.security.interfaces.RSAPublicKey;
+import java.security.spec.AlgorithmParameterSpec;
+import java.security.spec.InvalidKeySpecException;
+import java.security.spec.PKCS8EncodedKeySpec;
+import java.security.spec.X509EncodedKeySpec;
+import java.util.Arrays;
+import javax.crypto.BadPaddingException;
+import javax.crypto.Cipher;
+import javax.crypto.CipherSpi;
+import javax.crypto.IllegalBlockSizeException;
+import javax.crypto.NoSuchPaddingException;
+import javax.crypto.ShortBufferException;
+import javax.crypto.spec.SecretKeySpec;
+import libcore.util.EmptyArray;
+
+public abstract class OpenSSLCipherRSA extends CipherSpi {
+    /**
+     * The current OpenSSL key we're operating on.
+     */
+    private OpenSSLKey key;
+
+    /**
+     * Current key type: private or public.
+     */
+    private boolean usingPrivateKey;
+
+    /**
+     * Current cipher mode: encrypting or decrypting.
+     */
+    private boolean encrypting;
+
+    /**
+     * Buffer for operations
+     */
+    private byte[] buffer;
+
+    /**
+     * Current offset in the buffer.
+     */
+    private int bufferOffset;
+
+    /**
+     * Flag that indicates an exception should be thrown when the input is too
+     * large during doFinal.
+     */
+    private boolean inputTooLarge;
+
+    /**
+     * Current padding mode
+     */
+    private int padding = NativeCrypto.RSA_PKCS1_PADDING;
+
+    protected OpenSSLCipherRSA(int padding) {
+        this.padding = padding;
+    }
+
+    @Override
+    protected void engineSetMode(String mode) throws NoSuchAlgorithmException {
+        final String modeUpper = mode.toUpperCase();
+        if ("NONE".equals(modeUpper) || "ECB".equals(modeUpper)) {
+            return;
+        }
+
+        throw new NoSuchAlgorithmException("mode not supported: " + mode);
+    }
+
+    @Override
+    protected void engineSetPadding(String padding) throws NoSuchPaddingException {
+        final String paddingUpper = padding.toUpperCase();
+        if ("PKCS1PADDING".equals(paddingUpper)) {
+            this.padding = NativeCrypto.RSA_PKCS1_PADDING;
+            return;
+        }
+        if ("NOPADDING".equals(paddingUpper)) {
+            this.padding = NativeCrypto.RSA_NO_PADDING;
+            return;
+        }
+
+        throw new NoSuchPaddingException("padding not supported: " + padding);
+    }
+
+    @Override
+    protected int engineGetBlockSize() {
+        return 0;
+    }
+
+    @Override
+    protected int engineGetOutputSize(int inputLen) {
+        if (key == null) {
+            throw new IllegalStateException("cipher is not initialized");
+        }
+
+        return buffer.length;
+    }
+
+    @Override
+    protected byte[] engineGetIV() {
+        return null;
+    }
+
+    @Override
+    protected AlgorithmParameters engineGetParameters() {
+        return null;
+    }
+
+    private void engineInitInternal(int opmode, Key key) throws InvalidKeyException {
+        if (opmode == Cipher.ENCRYPT_MODE || opmode == Cipher.WRAP_MODE) {
+            encrypting = true;
+        } else if (opmode == Cipher.DECRYPT_MODE || opmode == Cipher.UNWRAP_MODE) {
+            encrypting = false;
+        } else {
+            throw new InvalidParameterException("Unsupported opmode " + opmode);
+        }
+
+        if (key instanceof OpenSSLRSAPrivateKey) {
+            OpenSSLRSAPrivateKey rsaPrivateKey = (OpenSSLRSAPrivateKey) key;
+            usingPrivateKey = true;
+            this.key = rsaPrivateKey.getOpenSSLKey();
+        } else if (key instanceof RSAPrivateCrtKey) {
+            RSAPrivateCrtKey rsaPrivateKey = (RSAPrivateCrtKey) key;
+            usingPrivateKey = true;
+            this.key = OpenSSLRSAPrivateCrtKey.getInstance(rsaPrivateKey);
+        } else if (key instanceof RSAPrivateKey) {
+            RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) key;
+            usingPrivateKey = true;
+            this.key = OpenSSLRSAPrivateKey.getInstance(rsaPrivateKey);
+        } else if (key instanceof OpenSSLRSAPublicKey) {
+            OpenSSLRSAPublicKey rsaPublicKey = (OpenSSLRSAPublicKey) key;
+            usingPrivateKey = false;
+            this.key = rsaPublicKey.getOpenSSLKey();
+        } else if (key instanceof RSAPublicKey) {
+            RSAPublicKey rsaPublicKey = (RSAPublicKey) key;
+            usingPrivateKey = false;
+            this.key = OpenSSLRSAPublicKey.getInstance(rsaPublicKey);
+        } else {
+            throw new InvalidKeyException("Need RSA private or public key");
+        }
+
+        buffer = new byte[NativeCrypto.RSA_size(this.key.getPkeyContext())];
+        inputTooLarge = false;
+    }
+
+    @Override
+    protected void engineInit(int opmode, Key key, SecureRandom random) throws InvalidKeyException {
+        engineInitInternal(opmode, key);
+    }
+
+    @Override
+    protected void engineInit(int opmode, Key key, AlgorithmParameterSpec params,
+            SecureRandom random) throws InvalidKeyException, InvalidAlgorithmParameterException {
+        if (params != null) {
+            throw new InvalidAlgorithmParameterException("unknown param type: "
+                    + params.getClass().getName());
+        }
+
+        engineInitInternal(opmode, key);
+    }
+
+    @Override
+    protected void engineInit(int opmode, Key key, AlgorithmParameters params, SecureRandom random)
+            throws InvalidKeyException, InvalidAlgorithmParameterException {
+        if (params != null) {
+            throw new InvalidAlgorithmParameterException("unknown param type: "
+                    + params.getClass().getName());
+        }
+
+        engineInitInternal(opmode, key);
+    }
+
+    @Override
+    protected byte[] engineUpdate(byte[] input, int inputOffset, int inputLen) {
+        if (bufferOffset + inputLen > buffer.length) {
+            inputTooLarge = true;
+            return EmptyArray.BYTE;
+        }
+
+        System.arraycopy(input, inputOffset, buffer, bufferOffset, inputLen);
+        bufferOffset += inputLen;
+        return EmptyArray.BYTE;
+    }
+
+    @Override
+    protected int engineUpdate(byte[] input, int inputOffset, int inputLen, byte[] output,
+            int outputOffset) throws ShortBufferException {
+        engineUpdate(input, inputOffset, inputLen);
+        return 0;
+    }
+
+    @Override
+    protected byte[] engineDoFinal(byte[] input, int inputOffset, int inputLen)
+            throws IllegalBlockSizeException, BadPaddingException {
+        if (input != null) {
+            engineUpdate(input, inputOffset, inputLen);
+        }
+
+        if (inputTooLarge) {
+            throw new IllegalBlockSizeException("input must be under " + buffer.length + " bytes");
+        }
+
+        final byte[] tmpBuf;
+        if (bufferOffset != buffer.length) {
+            if (padding == NativeCrypto.RSA_NO_PADDING) {
+                tmpBuf = new byte[buffer.length];
+                System.arraycopy(buffer, 0, tmpBuf, buffer.length - bufferOffset, bufferOffset);
+            } else {
+                tmpBuf = Arrays.copyOf(buffer, bufferOffset);
+            }
+        } else {
+            tmpBuf = buffer;
+        }
+
+        byte[] output = new byte[buffer.length];
+        int resultSize;
+        if (encrypting) {
+            if (usingPrivateKey) {
+                resultSize = NativeCrypto.RSA_private_encrypt(tmpBuf.length, tmpBuf, output,
+                                                              key.getPkeyContext(), padding);
+            } else {
+                resultSize = NativeCrypto.RSA_public_encrypt(tmpBuf.length, tmpBuf, output,
+                                                             key.getPkeyContext(), padding);
+            }
+        } else {
+            try {
+                if (usingPrivateKey) {
+                    resultSize = NativeCrypto.RSA_private_decrypt(tmpBuf.length, tmpBuf, output,
+                                                                  key.getPkeyContext(), padding);
+                } else {
+                    resultSize = NativeCrypto.RSA_public_decrypt(tmpBuf.length, tmpBuf, output,
+                                                                 key.getPkeyContext(), padding);
+                }
+            } catch (SignatureException e) {
+                IllegalBlockSizeException newE = new IllegalBlockSizeException();
+                newE.initCause(e);
+                throw newE;
+            }
+        }
+        if (!encrypting && resultSize != output.length) {
+            output = Arrays.copyOf(output, resultSize);
+        }
+
+        bufferOffset = 0;
+        return output;
+    }
+
+    @Override
+    protected int engineDoFinal(byte[] input, int inputOffset, int inputLen, byte[] output,
+            int outputOffset) throws ShortBufferException, IllegalBlockSizeException,
+            BadPaddingException {
+        byte[] b = engineDoFinal(input, inputOffset, inputLen);
+
+        final int lastOffset = outputOffset + b.length;
+        if (lastOffset > output.length) {
+            throw new ShortBufferException("output buffer is too small " + output.length + " < "
+                    + lastOffset);
+        }
+
+        System.arraycopy(b, 0, output, outputOffset, b.length);
+        return b.length;
+    }
+
+    @Override
+    protected byte[] engineWrap(Key key) throws IllegalBlockSizeException, InvalidKeyException {
+        try {
+            byte[] encoded = key.getEncoded();
+            return engineDoFinal(encoded, 0, encoded.length);
+        } catch (BadPaddingException e) {
+            IllegalBlockSizeException newE = new IllegalBlockSizeException();
+            newE.initCause(e);
+            throw newE;
+        }
+    }
+
+    @Override
+    protected Key engineUnwrap(byte[] wrappedKey, String wrappedKeyAlgorithm,
+            int wrappedKeyType) throws InvalidKeyException, NoSuchAlgorithmException {
+        try {
+            byte[] encoded = engineDoFinal(wrappedKey, 0, wrappedKey.length);
+            if (wrappedKeyType == Cipher.PUBLIC_KEY) {
+                KeyFactory keyFactory = KeyFactory.getInstance(wrappedKeyAlgorithm);
+                return keyFactory.generatePublic(new X509EncodedKeySpec(encoded));
+            } else if (wrappedKeyType == Cipher.PRIVATE_KEY) {
+                KeyFactory keyFactory = KeyFactory.getInstance(wrappedKeyAlgorithm);
+                return keyFactory.generatePrivate(new PKCS8EncodedKeySpec(encoded));
+            } else if (wrappedKeyType == Cipher.SECRET_KEY) {
+                return new SecretKeySpec(encoded, wrappedKeyAlgorithm);
+            } else {
+                throw new UnsupportedOperationException("wrappedKeyType == " + wrappedKeyType);
+            }
+        } catch (IllegalBlockSizeException e) {
+            throw new InvalidKeyException(e);
+        } catch (BadPaddingException e) {
+            throw new InvalidKeyException(e);
+        } catch (InvalidKeySpecException e) {
+            throw new InvalidKeyException(e);
+        }
+    }
+
+    public static class PKCS1 extends OpenSSLCipherRSA {
+        public PKCS1() {
+            super(NativeCrypto.RSA_PKCS1_PADDING);
+        }
+    }
+
+    public static class Raw extends OpenSSLCipherRSA {
+        public Raw() {
+            super(NativeCrypto.RSA_NO_PADDING);
+        }
+    }
+}
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLCipherRawRSA.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLCipherRawRSA.java
deleted file mode 100644
index d0368fe..0000000
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLCipherRawRSA.java
+++ /dev/null
@@ -1,234 +0,0 @@
-/*
- * Copyright (C) 2012 The Android Open Source Project
- *
- * Licensed 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.xnet.provider.jsse;
-
-import java.security.AlgorithmParameters;
-import java.security.InvalidAlgorithmParameterException;
-import java.security.InvalidKeyException;
-import java.security.Key;
-import java.security.NoSuchAlgorithmException;
-import java.security.SecureRandom;
-import java.security.interfaces.RSAPrivateCrtKey;
-import java.security.interfaces.RSAPrivateKey;
-import java.security.interfaces.RSAPublicKey;
-import java.security.spec.AlgorithmParameterSpec;
-
-import javax.crypto.BadPaddingException;
-import javax.crypto.CipherSpi;
-import javax.crypto.IllegalBlockSizeException;
-import javax.crypto.NoSuchPaddingException;
-import javax.crypto.ShortBufferException;
-
-public class OpenSSLCipherRawRSA extends CipherSpi {
-    /**
-     * An empty list that is returned from update calls.
-     */
-    private static final byte[] emptyList = new byte[0];
-
-    /**
-     * The current OpenSSL key we're operating on.
-     */
-    private OpenSSLKey key;
-
-    /**
-     * Current cipher mode: encrypting or decrypting.
-     */
-    private boolean usingPrivateKey;
-
-    /**
-     * Buffer for operations
-     */
-    private byte[] buffer;
-
-    /**
-     * Current offset in the buffer.
-     */
-    private int bufferOffset;
-
-    /**
-     * Flag that indicates an exception should be thrown when the input is too
-     * large during doFinal.
-     */
-    private boolean inputTooLarge;
-
-    @Override
-    protected void engineSetMode(String mode) throws NoSuchAlgorithmException {
-        final String modeUpper = mode.toUpperCase();
-        if ("NONE".equals(modeUpper) || "ECB".equals(modeUpper)) {
-            return;
-        }
-
-        throw new NoSuchAlgorithmException("mode not supported: " + mode);
-    }
-
-    @Override
-    protected void engineSetPadding(String padding) throws NoSuchPaddingException {
-        final String paddingUpper = padding.toUpperCase();
-        if ("NOPADDING".equals(paddingUpper)) {
-            return;
-        }
-
-        throw new NoSuchPaddingException("padding not supported: " + padding);
-    }
-
-    @Override
-    protected int engineGetBlockSize() {
-        return 0;
-    }
-
-    @Override
-    protected int engineGetOutputSize(int inputLen) {
-        if (key == null) {
-            throw new IllegalStateException("cipher is not initialized");
-        }
-
-        return buffer.length;
-    }
-
-    @Override
-    protected byte[] engineGetIV() {
-        return null;
-    }
-
-    @Override
-    protected AlgorithmParameters engineGetParameters() {
-        return null;
-    }
-
-    private void engineInitInternal(int opmode, Key key) throws InvalidKeyException {
-        if (key instanceof OpenSSLRSAPrivateKey) {
-            OpenSSLRSAPrivateKey rsaPrivateKey = (OpenSSLRSAPrivateKey) key;
-            usingPrivateKey = true;
-            this.key = rsaPrivateKey.getOpenSSLKey();
-        } else if (key instanceof RSAPrivateCrtKey) {
-            RSAPrivateCrtKey rsaPrivateKey = (RSAPrivateCrtKey) key;
-            usingPrivateKey = true;
-            this.key = OpenSSLRSAPrivateCrtKey.getInstance(rsaPrivateKey);
-        } else if (key instanceof RSAPrivateKey) {
-            RSAPrivateKey rsaPrivateKey = (RSAPrivateKey) key;
-            usingPrivateKey = true;
-            this.key = OpenSSLRSAPrivateKey.getInstance(rsaPrivateKey);
-        } else if (key instanceof OpenSSLRSAPublicKey) {
-            OpenSSLRSAPublicKey rsaPublicKey = (OpenSSLRSAPublicKey) key;
-            usingPrivateKey = false;
-            this.key = rsaPublicKey.getOpenSSLKey();
-        } else if (key instanceof RSAPublicKey) {
-            RSAPublicKey rsaPublicKey = (RSAPublicKey) key;
-            usingPrivateKey = false;
-            this.key = OpenSSLRSAPublicKey.getInstance(rsaPublicKey);
-        } else {
-            throw new InvalidKeyException("Need RSA private or public key");
-        }
-
-        buffer = new byte[NativeCrypto.RSA_size(this.key.getPkeyContext())];
-        inputTooLarge = false;
-    }
-
-    @Override
-    protected void engineInit(int opmode, Key key, SecureRandom random) throws InvalidKeyException {
-        engineInitInternal(opmode, key);
-    }
-
-    @Override
-    protected void engineInit(int opmode, Key key, AlgorithmParameterSpec params,
-            SecureRandom random) throws InvalidKeyException, InvalidAlgorithmParameterException {
-        if (params != null) {
-            throw new InvalidAlgorithmParameterException("unknown param type: "
-                    + params.getClass().getName());
-        }
-
-        engineInitInternal(opmode, key);
-    }
-
-    @Override
-    protected void engineInit(int opmode, Key key, AlgorithmParameters params, SecureRandom random)
-            throws InvalidKeyException, InvalidAlgorithmParameterException {
-        if (params != null) {
-            throw new InvalidAlgorithmParameterException("unknown param type: "
-                    + params.getClass().getName());
-        }
-
-        engineInitInternal(opmode, key);
-    }
-
-    @Override
-    protected byte[] engineUpdate(byte[] input, int inputOffset, int inputLen) {
-        if (bufferOffset + inputLen > buffer.length) {
-            inputTooLarge = true;
-            return emptyList;
-        }
-
-        System.arraycopy(input, inputOffset, buffer, bufferOffset, inputLen);
-        bufferOffset += inputLen;
-        return emptyList;
-    }
-
-    @Override
-    protected int engineUpdate(byte[] input, int inputOffset, int inputLen, byte[] output,
-            int outputOffset) throws ShortBufferException {
-        engineUpdate(input, inputOffset, inputLen);
-        return 0;
-    }
-
-    @Override
-    protected byte[] engineDoFinal(byte[] input, int inputOffset, int inputLen)
-            throws IllegalBlockSizeException, BadPaddingException {
-        if (input != null) {
-            engineUpdate(input, inputOffset, inputLen);
-        }
-
-        if (inputTooLarge) {
-            throw new IllegalBlockSizeException("input must be under " + buffer.length + " bytes");
-        }
-
-        final byte[] tmpBuf;
-        if (bufferOffset != buffer.length) {
-            tmpBuf = new byte[buffer.length];
-            System.arraycopy(buffer, 0, tmpBuf, buffer.length - bufferOffset, bufferOffset);
-        } else {
-            tmpBuf = buffer;
-        }
-
-        final byte[] output = new byte[buffer.length];
-        if (usingPrivateKey) {
-            NativeCrypto.RSA_private_encrypt(tmpBuf.length, tmpBuf, output, key.getPkeyContext(),
-                    NativeCrypto.RSA_NO_PADDING);
-        } else {
-            NativeCrypto.RSA_public_decrypt(tmpBuf.length, tmpBuf, output, key.getPkeyContext(),
-                    NativeCrypto.RSA_NO_PADDING);
-        }
-
-        bufferOffset = 0;
-        return output;
-    }
-
-    @Override
-    protected int engineDoFinal(byte[] input, int inputOffset, int inputLen, byte[] output,
-            int outputOffset) throws ShortBufferException, IllegalBlockSizeException,
-            BadPaddingException {
-        byte[] b = engineDoFinal(input, inputOffset, inputLen);
-
-        final int lastOffset = outputOffset + b.length;
-        if (lastOffset > output.length) {
-            throw new ShortBufferException("output buffer is too small " + output.length + " < "
-                    + lastOffset);
-        }
-
-        System.arraycopy(b, 0, output, outputOffset, b.length);
-        return b.length;
-    }
-}
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLProvider.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLProvider.java
index 126408f..e1d0fb0 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLProvider.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLProvider.java
@@ -121,7 +121,9 @@ public final class OpenSSLProvider extends Provider {
         put("SecureRandom.SHA1PRNG ImplementedIn", "Software");
 
         // Cipher
-        put("Cipher.RSA/ECB/NoPadding", OpenSSLCipherRawRSA.class.getName());
+        put("Cipher.RSA/ECB/NoPadding", OpenSSLCipherRSA.Raw.class.getName());
         put("Alg.Alias.Cipher.RSA/None/NoPadding", "RSA/ECB/NoPadding");
+        put("Cipher.RSA/ECB/PKCS1Padding", OpenSSLCipherRSA.PKCS1.class.getName());
+        put("Alg.Alias.Cipher.RSA/None/PKCS1Padding", "RSA/ECB/PKCS1Padding");
     }
 }
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLSignatureRawRSA.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLSignatureRawRSA.java
index 70d2532..289af30 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLSignatureRawRSA.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLSignatureRawRSA.java
@@ -26,6 +26,7 @@ import java.security.SignatureException;
 import java.security.interfaces.RSAPrivateCrtKey;
 import java.security.interfaces.RSAPrivateKey;
 import java.security.interfaces.RSAPublicKey;
+import java.util.Arrays;
 
 /**
  * Implements the JDK Signature interface needed for RAW RSA signature
@@ -144,13 +145,10 @@ public class OpenSSLSignatureRawRSA extends Signature {
                     + inputBuffer.length + " (modulus size)");
         }
 
-        byte[] paddedBuffer = new byte[inputBuffer.length];
         byte[] outputBuffer = new byte[inputBuffer.length];
         try {
-            NativeCrypto.RSA_padding_add_PKCS1_type_1(paddedBuffer, paddedBuffer.length,
-                    inputBuffer, inputOffset);
-            NativeCrypto.RSA_private_encrypt(paddedBuffer.length, paddedBuffer, outputBuffer,
-                    key.getPkeyContext(), NativeCrypto.RSA_NO_PADDING);
+            NativeCrypto.RSA_private_encrypt(inputOffset, inputBuffer, outputBuffer,
+                    key.getPkeyContext(), NativeCrypto.RSA_PKCS1_PADDING);
             return outputBuffer;
         } catch (Exception ex) {
             throw new SignatureException(ex);
@@ -170,30 +168,20 @@ public class OpenSSLSignatureRawRSA extends Signature {
             return false;
         }
 
-        byte[] paddedBuffer = new byte[inputBuffer.length];
         byte[] outputBuffer = new byte[inputBuffer.length];
         try {
-            int paddedSize = NativeCrypto.RSA_public_decrypt(sigBytes.length, sigBytes,
-                    paddedBuffer, key.getPkeyContext(), NativeCrypto.RSA_NO_PADDING);
-
-            /*
-             * RSA_padding_check_PKCS1_type_1 expects the leading 0-byte to be
-             * truncated already.
-             */
-            paddedSize--;
-            System.arraycopy(paddedBuffer, 1, paddedBuffer, 0, paddedSize);
-
-            final int size;
+            final int resultSize;
             try {
-                size = NativeCrypto.RSA_padding_check_PKCS1_type_1(outputBuffer,
-                        outputBuffer.length, paddedBuffer, paddedSize, inputBuffer.length);
+                resultSize = NativeCrypto.RSA_public_decrypt(sigBytes.length, sigBytes,
+                        outputBuffer, key.getPkeyContext(), NativeCrypto.RSA_PKCS1_PADDING);
+            } catch (SignatureException e) {
+                throw e;
             } catch (Exception e) {
                 return false;
             }
-
             /* Make this constant time by comparing every byte. */
-            boolean matches = (size == inputOffset);
-            for (int i = 0; i < size; i++) {
+            boolean matches = (resultSize == inputOffset);
+            for (int i = 0; i < resultSize; i++) {
                 if (inputBuffer[i] != outputBuffer[i]) {
                     matches = false;
                 }
diff --git a/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp b/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
index 7346525..a04bebf 100644
--- a/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
+++ b/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
@@ -234,6 +234,22 @@ static void freeOpenSslErrorState(void) {
     ERR_remove_state(0);
 }
 
+/**
+ * Throws a BadPaddingException with the given string as a message.
+ */
+static void throwBadPaddingException(JNIEnv* env, const char* message) {
+    JNI_TRACE("throwBadPaddingException %s", message);
+    jniThrowException(env, "javax/crypto/BadPaddingException", message);
+}
+
+/**
+ * Throws a SignatureException with the given string as a message.
+ */
+static void throwSignatureException(JNIEnv* env, const char* message) {
+    JNI_TRACE("throwSignatureException %s", message);
+    jniThrowException(env, "java/security/SignatureException", message);
+}
+
 /*
  * Checks this thread's OpenSSL error queue and throws a RuntimeException if
  * necessary.
@@ -241,14 +257,30 @@ static void freeOpenSslErrorState(void) {
  * @return true if an exception was thrown, false if not.
  */
 static bool throwExceptionIfNecessary(JNIEnv* env, const char* location  __attribute__ ((unused))) {
-    int error = ERR_get_error();
+    const char* file;
+    int line;
+    const char* data;
+    int flags;
+    unsigned long error = ERR_get_error_line_data(&file, &line, &data, &flags);
     int result = false;
 
     if (error != 0) {
         char message[256];
         ERR_error_string_n(error, message, sizeof(message));
-        JNI_TRACE("OpenSSL error in %s %d: %s", location, error, message);
-        jniThrowRuntimeException(env, message);
+        int library = ERR_GET_LIB(error);
+        int reason = ERR_GET_REASON(error);
+        JNI_TRACE("OpenSSL error in %s error=%lx library=%x reason=%x (%s:%d): %s %s",
+                  location, error, library, reason, file, line, message,
+                  (flags & ERR_TXT_STRING) ? data : "(no data)");
+        if ((library == ERR_LIB_RSA)
+                && ((reason == RSA_R_BLOCK_TYPE_IS_NOT_01)
+                    || (reason == RSA_R_BLOCK_TYPE_IS_NOT_02))) {
+            throwBadPaddingException(env, message);
+        } else if (library == ERR_LIB_RSA && reason == RSA_R_DATA_GREATER_THAN_MOD_LEN) {
+            throwSignatureException(env, message);
+        } else {
+            jniThrowRuntimeException(env, message);
+        }
         result = true;
     }
 
@@ -1075,10 +1107,14 @@ static jint NativeCrypto_RSA_size(JNIEnv* env, jclass, jint pkeyRef) {
     return static_cast<jint>(RSA_size(rsa.get()));
 }
 
-static jint NativeCrypto_RSA_private_encrypt(JNIEnv* env, jclass, jint flen,
+typedef int RSACryptOperation(int flen, const unsigned char* from, unsigned char* to, RSA* rsa,
+                              int padding);
+
+static jint RSA_crypt_operation(RSACryptOperation operation,
+        const char* caller __attribute__ ((unused)), JNIEnv* env, jint flen,
         jbyteArray fromJavaBytes, jbyteArray toJavaBytes, jint pkeyRef, jint padding) {
     EVP_PKEY* pkey = reinterpret_cast<EVP_PKEY*>(pkeyRef);
-    JNI_TRACE("RSA_private_encrypt(%d, %p, %p, %p)", flen, fromJavaBytes, toJavaBytes, pkey);
+    JNI_TRACE("%s(%d, %p, %p, %p)", caller, flen, fromJavaBytes, toJavaBytes, pkey);
 
     Unique_RSA rsa(EVP_PKEY_get1_RSA(pkey));
     if (rsa.get() == NULL) {
@@ -1095,124 +1131,39 @@ static jint NativeCrypto_RSA_private_encrypt(JNIEnv* env, jclass, jint flen,
         return -1;
     }
 
-    int resultSize = RSA_private_encrypt(static_cast<int>(flen),
+    int resultSize = operation(static_cast<int>(flen),
             reinterpret_cast<const unsigned char*>(from.get()),
             reinterpret_cast<unsigned char*>(to.get()), rsa.get(), padding);
     if (resultSize == -1) {
-        JNI_TRACE("RSA_private_encrypt => failed");
-        throwExceptionIfNecessary(env, "RSA_private_encrypt failed");
+        JNI_TRACE("%s => failed", caller);
+        throwExceptionIfNecessary(env, "RSA_crypt_operation");
         return -1;
     }
 
-    JNI_TRACE("RSA_private_encrypt(%d, %p, %p, %p) => %d", flen, fromJavaBytes, toJavaBytes, pkey,
-            resultSize);
+    JNI_TRACE("%s(%d, %p, %p, %p) => %d", caller, flen, fromJavaBytes, toJavaBytes, pkey,
+              resultSize);
     return static_cast<jint>(resultSize);
 }
 
+static jint NativeCrypto_RSA_private_encrypt(JNIEnv* env, jclass, jint flen,
+        jbyteArray fromJavaBytes, jbyteArray toJavaBytes, jint pkeyRef, jint padding) {
+    return RSA_crypt_operation(RSA_private_encrypt, __FUNCTION__,
+                               env, flen, fromJavaBytes, toJavaBytes, pkeyRef, padding);
+}
 static jint NativeCrypto_RSA_public_decrypt(JNIEnv* env, jclass, jint flen,
         jbyteArray fromJavaBytes, jbyteArray toJavaBytes, jint pkeyRef, jint padding) {
-    EVP_PKEY* pkey = reinterpret_cast<EVP_PKEY*>(pkeyRef);
-    JNI_TRACE("RSA_private_encrypt(%d, %p, %p, %p)", flen, fromJavaBytes, toJavaBytes, pkey);
-
-    Unique_RSA rsa(EVP_PKEY_get1_RSA(pkey));
-    if (rsa.get() == NULL) {
-        return -1;
-    }
-
-    ScopedByteArrayRO from(env, fromJavaBytes);
-    if (from.get() == NULL) {
-        return -1;
-    }
-
-    ScopedByteArrayRW to(env, toJavaBytes);
-    if (to.get() == NULL) {
-        return -1;
-    }
-
-    int resultSize = RSA_public_decrypt(static_cast<int>(flen),
-            reinterpret_cast<const unsigned char*>(from.get()),
-            reinterpret_cast<unsigned char*>(to.get()), rsa.get(), padding);
-    if (resultSize == -1) {
-        JNI_TRACE("RSA_private_encrypt => failed");
-        throwExceptionIfNecessary(env, "RSA_private_encrypt failed");
-        return -1;
-    }
-
-    JNI_TRACE("RSA_private_encrypt(%d, %p, %p, %p) => %d", flen, fromJavaBytes, toJavaBytes, pkey,
-            resultSize);
-    return static_cast<jint>(resultSize);
+    return RSA_crypt_operation(RSA_public_decrypt, __FUNCTION__,
+                               env, flen, fromJavaBytes, toJavaBytes, pkeyRef, padding);
 }
-
-static void NativeCrypto_RSA_padding_add_PKCS1_type_1(JNIEnv* env, jclass, jbyteArray toJavaBytes,
-        jint tlen, jbyteArray fromJavaBytes, jint flen) {
-    JNI_TRACE("RSA_padding_add_PKCS1_type_1(%p, %d, %p, %d)", toJavaBytes, tlen, fromJavaBytes,
-            flen);
-
-    ScopedByteArrayRO from(env, fromJavaBytes);
-    if (from.get() == NULL) {
-        return;
-    }
-
-    if (size_t(flen) > from.size()) {
-        jniThrowException(env, "java/lang/IndexOutOfBoundsException", NULL);
-        return;
-    }
-
-    ScopedByteArrayRW to(env, toJavaBytes);
-    if (to.get() == NULL) {
-        return;
-    }
-
-    if (size_t(tlen) > to.size()) {
-        jniThrowException(env, "java/lang/IndexOutOfBoundsException", NULL);
-        return;
-    }
-
-    if (RSA_padding_add_PKCS1_type_1(reinterpret_cast<unsigned char*>(to.get()), tlen,
-            reinterpret_cast<const unsigned char*>(from.get()), flen) == 0) {
-        throwExceptionIfNecessary(env, "RSA_padding_add_PKCS1_type_1 failed");
-        return;
-    }
-
-    JNI_TRACE("RSA_padding_add_PKCS1_type_1(%p, %d, %p, %d) => done", toJavaBytes, tlen,
-            fromJavaBytes, flen);
+static jint NativeCrypto_RSA_public_encrypt(JNIEnv* env, jclass, jint flen,
+        jbyteArray fromJavaBytes, jbyteArray toJavaBytes, jint pkeyRef, jint padding) {
+    return RSA_crypt_operation(RSA_public_encrypt, __FUNCTION__,
+                               env, flen, fromJavaBytes, toJavaBytes, pkeyRef, padding);
 }
-
-static jint NativeCrypto_RSA_padding_check_PKCS1_type_1(JNIEnv* env, jclass, jbyteArray toJavaBytes,
-        jint tlen, jbyteArray fromJavaBytes, jint flen, jint rsa_len) {
-    JNI_TRACE("RSA_padding_add_PKCS1_type_1(%p, %d, %p, %d, %d)", toJavaBytes, tlen, fromJavaBytes,
-            flen, rsa_len);
-
-    ScopedByteArrayRW to(env, toJavaBytes);
-    if (to.get() == NULL) {
-        return 0;
-    }
-
-    if (size_t(tlen) > to.size()) {
-        jniThrowException(env, "java/lang/IndexOutOfBoundsException", NULL);
-        return 0;
-    }
-
-    ScopedByteArrayRO from(env, fromJavaBytes);
-    if (from.get() == NULL) {
-        return 0;
-    }
-
-    if (size_t(flen) > from.size()) {
-        jniThrowException(env, "java/lang/IndexOutOfBoundsException", NULL);
-        return 0;
-    }
-
-    int size = RSA_padding_check_PKCS1_type_1(reinterpret_cast<unsigned char*>(to.get()), tlen,
-            reinterpret_cast<const unsigned char*>(from.get()), flen, rsa_len);
-    if (size == -1) {
-        throwExceptionIfNecessary(env, "RSA_padding_check_PKCS1_type_1 failed");
-        return 0;
-    }
-
-    JNI_TRACE("RSA_padding_check_PKCS1_type_1(%p, %d, %p, %d, %d) => %d", toJavaBytes, tlen,
-            fromJavaBytes, flen, rsa_len, size);
-    return size;
+static jint NativeCrypto_RSA_private_decrypt(JNIEnv* env, jclass, jint flen,
+        jbyteArray fromJavaBytes, jbyteArray toJavaBytes, jint pkeyRef, jint padding) {
+    return RSA_crypt_operation(RSA_private_decrypt, __FUNCTION__,
+                               env, flen, fromJavaBytes, toJavaBytes, pkeyRef, padding);
 }
 
 /*
@@ -4461,8 +4412,8 @@ static JNINativeMethod sNativeCryptoMethods[] = {
     NATIVE_METHOD(NativeCrypto, RSA_size, "(I)I"),
     NATIVE_METHOD(NativeCrypto, RSA_private_encrypt, "(I[B[BII)I"),
     NATIVE_METHOD(NativeCrypto, RSA_public_decrypt, "(I[B[BII)I"),
-    NATIVE_METHOD(NativeCrypto, RSA_padding_add_PKCS1_type_1, "([BI[BI)V"),
-    NATIVE_METHOD(NativeCrypto, RSA_padding_check_PKCS1_type_1, "([BI[BII)I"),
+    NATIVE_METHOD(NativeCrypto, RSA_public_encrypt, "(I[B[BII)I"),
+    NATIVE_METHOD(NativeCrypto, RSA_private_decrypt, "(I[B[BII)I"),
     NATIVE_METHOD(NativeCrypto, get_RSA_private_params, "(I)[[B"),
     NATIVE_METHOD(NativeCrypto, get_RSA_public_params, "(I)[[B"),
     NATIVE_METHOD(NativeCrypto, DSA_generate_key, "(I[B[B[B[B)I"),
diff --git a/luni/src/test/java/libcore/java/security/SignatureTest.java b/luni/src/test/java/libcore/java/security/SignatureTest.java
index 7b9b773..92b5513 100644
--- a/luni/src/test/java/libcore/java/security/SignatureTest.java
+++ b/luni/src/test/java/libcore/java/security/SignatureTest.java
@@ -796,8 +796,7 @@ public class SignatureTest extends TestCase {
         try {
             sig.initSign(privKey);
             fail("Should throw error when private exponent is not available");
-        } catch (InvalidKeyException e) {
-            // success
+        } catch (InvalidKeyException expected) {
         }
     }
 
@@ -821,8 +820,7 @@ public class SignatureTest extends TestCase {
         try {
             sig.initSign(privKey);
             fail("Should throw error when modulus is not available");
-        } catch (InvalidKeyException e) {
-            // success
+        } catch (InvalidKeyException expected) {
         }
     }
 
@@ -845,8 +843,7 @@ public class SignatureTest extends TestCase {
         try {
             sig.initSign(privKey);
             fail("Should throw error when key is empty");
-        } catch (InvalidKeyException e) {
-            // success
+        } catch (InvalidKeyException expected) {
         }
     }
 
@@ -1019,7 +1016,7 @@ public class SignatureTest extends TestCase {
         try {
             sig.sign();
             fail("Should throw exception when data is too large");
-        } catch (SignatureException success) {
+        } catch (SignatureException expected) {
         }
     }
 
@@ -1041,7 +1038,7 @@ public class SignatureTest extends TestCase {
         try {
             sig.sign();
             fail("Should throw exception when data is too large");
-        } catch (SignatureException success) {
+        } catch (SignatureException expected) {
         }
     }
 
@@ -1121,7 +1118,7 @@ public class SignatureTest extends TestCase {
         try {
             sig.verify(invalidSignature);
             fail("Should throw exception when signature is too large");
-        } catch (SignatureException success) {
+        } catch (SignatureException expected) {
         }
     }
 
diff --git a/luni/src/test/java/libcore/javax/crypto/CipherTest.java b/luni/src/test/java/libcore/javax/crypto/CipherTest.java
index 0a5ed36..d31825a 100644
--- a/luni/src/test/java/libcore/javax/crypto/CipherTest.java
+++ b/luni/src/test/java/libcore/javax/crypto/CipherTest.java
@@ -17,37 +17,489 @@
 package libcore.javax.crypto;
 
 import com.android.org.bouncycastle.asn1.x509.KeyUsage;
-
 import java.math.BigInteger;
 import java.security.InvalidKeyException;
+import java.security.InvalidParameterException;
 import java.security.Key;
 import java.security.KeyFactory;
-import java.security.KeyPair;
-import java.security.KeyPairGenerator;
 import java.security.PrivateKey;
-import java.security.Provider;
 import java.security.Provider.Service;
+import java.security.Provider;
 import java.security.PublicKey;
 import java.security.Security;
 import java.security.cert.Certificate;
-import java.security.interfaces.RSAPrivateKey;
-import java.security.interfaces.RSAPublicKey;
-import java.security.spec.EncodedKeySpec;
 import java.security.spec.RSAPrivateKeySpec;
 import java.security.spec.RSAPublicKeySpec;
 import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
 import java.util.Set;
-
+import javax.crypto.BadPaddingException;
 import javax.crypto.Cipher;
+import javax.crypto.KeyGenerator;
 import javax.crypto.IllegalBlockSizeException;
-import javax.crypto.SecretKey;
-import javax.crypto.spec.SecretKeySpec;
-
 import junit.framework.TestCase;
 import libcore.java.security.TestKeyStore;
 
 public final class CipherTest extends TestCase {
 
+    private static boolean isUnsupported(String algorithm) {
+        if (algorithm.equals("PBEWITHMD5ANDRC2")) {
+            return true;
+        }
+        if (algorithm.equals("PBEWITHSHA1ANDRC2")) {
+            return true;
+        }
+        if (algorithm.equals("PBEWITHSHAAND40BITRC2-CBC")) {
+            return true;
+        }
+        if (algorithm.equals("PBEWITHSHAAND128BITRC2-CBC")) {
+            return true;
+        }
+        if (algorithm.equals("PBEWITHSHAANDTWOFISH-CBC")) {
+            return true;
+        }
+        return false;
+    }
+
+    private synchronized static int getEncryptMode(String algorithm) throws Exception {
+        if (isWrap(algorithm)) {
+            return Cipher.WRAP_MODE;
+        }
+        return Cipher.ENCRYPT_MODE;
+    }
+
+    private synchronized static int getDecryptMode(String algorithm) throws Exception {
+        if (isWrap(algorithm)) {
+            return Cipher.UNWRAP_MODE;
+        }
+        return Cipher.DECRYPT_MODE;
+    }
+
+    private static String getBaseAlgoritm(String algorithm) {
+        if (algorithm.equals("AESWRAP")) {
+            return "AES";
+        }
+        if (algorithm.equals("PBEWITHMD5AND128BITAES-CBC-OPENSSL")) {
+            return "AES";
+        }
+        if (algorithm.equals("PBEWITHMD5AND192BITAES-CBC-OPENSSL")) {
+            return "AES";
+        }
+        if (algorithm.equals("PBEWITHMD5AND256BITAES-CBC-OPENSSL")) {
+            return "AES";
+        }
+        if (algorithm.equals("PBEWITHSHA256AND128BITAES-CBC-BC")) {
+            return "AES";
+        }
+        if (algorithm.equals("PBEWITHSHA256AND192BITAES-CBC-BC")) {
+            return "AES";
+        }
+        if (algorithm.equals("PBEWITHSHA256AND256BITAES-CBC-BC")) {
+            return "AES";
+        }
+        if (algorithm.equals("PBEWITHSHAAND128BITAES-CBC-BC")) {
+            return "AES";
+        }
+        if (algorithm.equals("PBEWITHSHAAND192BITAES-CBC-BC")) {
+            return "AES";
+        }
+        if (algorithm.equals("PBEWITHSHAAND256BITAES-CBC-BC")) {
+            return "AES";
+        }
+        if (algorithm.equals("PBEWITHMD5ANDDES")) {
+            return "DES";
+        }
+        if (algorithm.equals("PBEWITHSHA1ANDDES")) {
+            return "DES";
+        }
+        if (algorithm.equals("DESEDEWRAP")) {
+            return "DESede";
+        }
+        if (algorithm.equals("PBEWITHSHAAND2-KEYTRIPLEDES-CBC")) {
+            return "DESede";
+        }
+        if (algorithm.equals("PBEWITHSHAAND3-KEYTRIPLEDES-CBC")) {
+            return "DESede";
+        }
+        if (algorithm.equals("RSA/ECB/NoPadding")) {
+            return "RSA";
+        }
+        if (algorithm.equals("RSA/ECB/PKCS1Padding")) {
+            return "RSA";
+        }
+        if (algorithm.equals("PBEWITHSHAAND40BITRC4")) {
+            return "ARC4";
+        }
+        if (algorithm.equals("PBEWITHSHAAND128BITRC4")) {
+            return "ARC4";
+        }
+        return algorithm;
+    }
+
+    private static boolean isAsymmetric(String algorithm) {
+        return getBaseAlgoritm(algorithm).equals("RSA");
+    }
+
+    private static boolean isWrap(String algorithm) {
+        return algorithm.endsWith("WRAP");
+    }
+
+    private static Map<String, Key> ENCRYPT_KEYS = new HashMap<String, Key>();
+    private synchronized static Key getEncryptKey(String algorithm) throws Exception {
+        Key key = ENCRYPT_KEYS.get(algorithm);
+        if (key != null) {
+            return key;
+        }
+        algorithm = getBaseAlgoritm(algorithm);
+        if (algorithm.equals("RSA")) {
+            KeyFactory kf = KeyFactory.getInstance("RSA");
+            RSAPrivateKeySpec keySpec = new RSAPrivateKeySpec(RSA_2048_modulus,
+                                                              RSA_2048_privateExponent);
+            key = kf.generatePrivate(keySpec);
+        } else {
+            KeyGenerator kg = KeyGenerator.getInstance(algorithm);
+            key = kg.generateKey();
+        }
+        ENCRYPT_KEYS.put(algorithm, key);
+        return key;
+    }
+
+    private static Map<String, Key> DECRYPT_KEYS = new HashMap<String, Key>();
+    private synchronized static Key getDecryptKey(String algorithm) throws Exception {
+        Key key = DECRYPT_KEYS.get(algorithm);
+        if (key != null) {
+            return key;
+        }
+        algorithm = getBaseAlgoritm(algorithm);
+        if (algorithm.equals("RSA")) {
+            KeyFactory kf = KeyFactory.getInstance("RSA");
+            RSAPublicKeySpec keySpec = new RSAPublicKeySpec(RSA_2048_modulus,
+                                                            RSA_2048_publicExponent);
+            key = kf.generatePublic(keySpec);
+        } else {
+            assertFalse(algorithm, isAsymmetric(algorithm));
+            key = getEncryptKey(algorithm);
+        }
+        DECRYPT_KEYS.put(algorithm, key);
+        return key;
+    }
+
+    private static Map<String, Integer> EXPECTED_BLOCK_SIZE = new HashMap<String, Integer>();
+    static {
+        EXPECTED_BLOCK_SIZE.put("AES", 16);
+        EXPECTED_BLOCK_SIZE.put("PBEWITHMD5AND128BITAES-CBC-OPENSSL", 16);
+        EXPECTED_BLOCK_SIZE.put("PBEWITHMD5AND192BITAES-CBC-OPENSSL", 16);
+        EXPECTED_BLOCK_SIZE.put("PBEWITHMD5AND256BITAES-CBC-OPENSSL", 16);
+        EXPECTED_BLOCK_SIZE.put("PBEWITHSHA256AND128BITAES-CBC-BC", 16);
+        EXPECTED_BLOCK_SIZE.put("PBEWITHSHA256AND192BITAES-CBC-BC", 16);
+        EXPECTED_BLOCK_SIZE.put("PBEWITHSHA256AND256BITAES-CBC-BC", 16);
+        EXPECTED_BLOCK_SIZE.put("PBEWITHSHAAND128BITAES-CBC-BC", 16);
+        EXPECTED_BLOCK_SIZE.put("PBEWITHSHAAND192BITAES-CBC-BC", 16);
+        EXPECTED_BLOCK_SIZE.put("PBEWITHSHAAND256BITAES-CBC-BC", 16);
+
+        EXPECTED_BLOCK_SIZE.put("AESWRAP", 0);
+
+        EXPECTED_BLOCK_SIZE.put("ARC4", 0);
+        EXPECTED_BLOCK_SIZE.put("PBEWITHSHAAND40BITRC4", 0);
+        EXPECTED_BLOCK_SIZE.put("PBEWITHSHAAND128BITRC4", 0);
+
+        EXPECTED_BLOCK_SIZE.put("BLOWFISH", 8);
+
+        EXPECTED_BLOCK_SIZE.put("DES", 8);
+        EXPECTED_BLOCK_SIZE.put("PBEWITHMD5ANDDES", 8);
+        EXPECTED_BLOCK_SIZE.put("PBEWITHSHA1ANDDES", 8);
+
+        EXPECTED_BLOCK_SIZE.put("DESEDE", 8);
+        EXPECTED_BLOCK_SIZE.put("PBEWITHSHAAND2-KEYTRIPLEDES-CBC", 8);
+        EXPECTED_BLOCK_SIZE.put("PBEWITHSHAAND3-KEYTRIPLEDES-CBC", 8);
+
+        EXPECTED_BLOCK_SIZE.put("DESEDEWRAP", 0);
+
+        EXPECTED_BLOCK_SIZE.put("RSA", 255);
+        EXPECTED_BLOCK_SIZE.put("RSA/ECB/NoPadding", 0);
+        EXPECTED_BLOCK_SIZE.put("RSA/ECB/PKCS1Padding", 0);
+    }
+    private static int getExpectedBlockSize(String algorithm) {
+        Integer expected = EXPECTED_BLOCK_SIZE.get(algorithm);
+        assertNotNull(algorithm, expected);
+        return expected;
+    }
+
+    private static Map<String, Integer> EXPECTED_OUTPUT_SIZE = new HashMap<String, Integer>();
+    static {
+        EXPECTED_OUTPUT_SIZE.put("AES", 16);
+        EXPECTED_OUTPUT_SIZE.put("PBEWITHMD5AND128BITAES-CBC-OPENSSL", 16);
+        EXPECTED_OUTPUT_SIZE.put("PBEWITHMD5AND192BITAES-CBC-OPENSSL", 16);
+        EXPECTED_OUTPUT_SIZE.put("PBEWITHMD5AND256BITAES-CBC-OPENSSL", 16);
+        EXPECTED_OUTPUT_SIZE.put("PBEWITHSHA256AND128BITAES-CBC-BC", 16);
+        EXPECTED_OUTPUT_SIZE.put("PBEWITHSHA256AND192BITAES-CBC-BC", 16);
+        EXPECTED_OUTPUT_SIZE.put("PBEWITHSHA256AND256BITAES-CBC-BC", 16);
+        EXPECTED_OUTPUT_SIZE.put("PBEWITHSHAAND128BITAES-CBC-BC", 16);
+        EXPECTED_OUTPUT_SIZE.put("PBEWITHSHAAND192BITAES-CBC-BC", 16);
+        EXPECTED_OUTPUT_SIZE.put("PBEWITHSHAAND256BITAES-CBC-BC", 16);
+
+        EXPECTED_OUTPUT_SIZE.put("AESWRAP", -1);
+
+        EXPECTED_OUTPUT_SIZE.put("ARC4", 0);
+        EXPECTED_OUTPUT_SIZE.put("PBEWITHSHAAND40BITRC4", 0);
+        EXPECTED_OUTPUT_SIZE.put("PBEWITHSHAAND128BITRC4", 0);
+
+        EXPECTED_OUTPUT_SIZE.put("BLOWFISH", 8);
+
+        EXPECTED_OUTPUT_SIZE.put("DES", 8);
+        EXPECTED_OUTPUT_SIZE.put("PBEWITHMD5ANDDES", 8);
+        EXPECTED_OUTPUT_SIZE.put("PBEWITHSHA1ANDDES", 8);
+
+        EXPECTED_OUTPUT_SIZE.put("DESEDE", 8);
+        EXPECTED_OUTPUT_SIZE.put("PBEWITHSHAAND2-KEYTRIPLEDES-CBC", 8);
+        EXPECTED_OUTPUT_SIZE.put("PBEWITHSHAAND3-KEYTRIPLEDES-CBC", 8);
+
+        EXPECTED_OUTPUT_SIZE.put("DESEDEWRAP", -1);
+
+        EXPECTED_OUTPUT_SIZE.put("RSA", 256);
+        EXPECTED_OUTPUT_SIZE.put("RSA/ECB/NoPadding", 256);
+        EXPECTED_OUTPUT_SIZE.put("RSA/ECB/PKCS1Padding", 256);
+    }
+    private static int getExpectedOutputSize(String algorithm) {
+        Integer expected = EXPECTED_OUTPUT_SIZE.get(algorithm);
+        assertNotNull(algorithm, expected);
+        return expected;
+    }
+
+    private static byte[] ORIGINAL_PLAIN_TEXT = new byte[] { 0x0a, 0x0b, 0x0c };
+    private static byte[] PKCS1_BLOCK_TYPE_00_PADDED_PLAIN_TEXT = new byte[] {
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x0a, 0x0b, 0x0c
+    };
+    private static byte[] PKCS1_BLOCK_TYPE_01_PADDED_PLAIN_TEXT = new byte[] {
+        (byte) 0x00, (byte) 0x01, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0x00, (byte) 0x0a, (byte) 0x0b, (byte) 0x0c
+    };
+    private static byte[] PKCS1_BLOCK_TYPE_02_PADDED_PLAIN_TEXT = new byte[] {
+        (byte) 0x00, (byte) 0x02, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff,
+        (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0xff, (byte) 0x00, (byte) 0x0a, (byte) 0x0b, (byte) 0x0c
+    };
+
+    private static byte[] getExpectedPlainText(String algorithm) {
+        if (algorithm.equals("RSA/ECB/NoPadding")) {
+            return PKCS1_BLOCK_TYPE_00_PADDED_PLAIN_TEXT;
+        }
+        return ORIGINAL_PLAIN_TEXT;
+    }
+
+    public void test_getInstance() throws Exception {
+        Provider[] providers = Security.getProviders();
+        for (Provider provider : providers) {
+            Set<Provider.Service> services = provider.getServices();
+            for (Provider.Service service : services) {
+                String type = service.getType();
+                if (!type.equals("Cipher")) {
+                    continue;
+                }
+                String algorithm = service.getAlgorithm();
+                try {
+                    // Cipher.getInstance(String)
+                    Cipher c1 = Cipher.getInstance(algorithm);
+                    assertEquals(algorithm, c1.getAlgorithm());
+                    test_Cipher(c1);
+
+                    // Cipher.getInstance(String, Provider)
+                    Cipher c2 = Cipher.getInstance(algorithm, provider);
+                    assertEquals(algorithm, c2.getAlgorithm());
+                    assertEquals(provider, c2.getProvider());
+                    test_Cipher(c2);
+
+                    // KeyGenerator.getInstance(String, String)
+                    Cipher c3 = Cipher.getInstance(algorithm, provider.getName());
+                    assertEquals(algorithm, c3.getAlgorithm());
+                    assertEquals(provider, c3.getProvider());
+                    test_Cipher(c3);
+                } catch (Throwable e) {
+                    throw new Exception("Problem testing Cipher." + algorithm, e);
+                }
+            }
+        }
+    }
+
+    private void test_Cipher(Cipher c) throws Exception {
+        // TODO: test all supported modes and padding for a given algorithm
+        String algorithm = c.getAlgorithm();
+        if (isUnsupported(algorithm)) {
+            return;
+        }
+
+        try {
+            c.getOutputSize(0);
+        } catch (IllegalStateException expected) {
+        }
+
+        // TODO: test keys from different factories (e.g. OpenSSLRSAPrivateKey vs JCERSAPrivateKey)
+        Key encryptKey = getEncryptKey(algorithm);
+        c.init(getEncryptMode(algorithm), encryptKey);
+
+        assertEquals(getExpectedBlockSize(algorithm), c.getBlockSize());
+
+        assertEquals(getExpectedOutputSize(algorithm), c.getOutputSize(0));
+
+        // TODO: test Cipher.getIV()
+
+        // TODO: test Cipher.getParameters()
+
+        assertNull(c.getExemptionMechanism());
+
+        if (isWrap(algorithm)) {
+            byte[] cipherText = c.wrap(encryptKey);
+            c.init(getDecryptMode(algorithm), getDecryptKey(algorithm));
+            int keyType = (isAsymmetric(algorithm)) ? Cipher.PRIVATE_KEY : Cipher.SECRET_KEY;
+            Key decryptedKey = c.unwrap(cipherText, encryptKey.getAlgorithm(), keyType);
+            assertEquals("encryptKey.getAlgorithm()=" + encryptKey.getAlgorithm()
+                         + " decryptedKey.getAlgorithm()=" + decryptedKey.getAlgorithm()
+                         + " encryptKey.getEncoded()=" + Arrays.toString(encryptKey.getEncoded())
+                         + " decryptedKey.getEncoded()=" + Arrays.toString(decryptedKey.getEncoded()),
+                         encryptKey, decryptedKey);
+        } else {
+            byte[] cipherText = c.doFinal(ORIGINAL_PLAIN_TEXT);
+            c.init(getDecryptMode(algorithm), getDecryptKey(algorithm));
+            byte[] decryptedPlainText = c.doFinal(cipherText);
+            assertEquals(Arrays.toString(getExpectedPlainText(algorithm)),
+                         Arrays.toString(decryptedPlainText));
+        }
+    }
+
+    public void testInputPKCS1Padding() throws Exception {
+        testInputPKCS1Padding(PKCS1_BLOCK_TYPE_01_PADDED_PLAIN_TEXT, getEncryptKey("RSA"), getDecryptKey("RSA"));
+        try {
+            testInputPKCS1Padding(PKCS1_BLOCK_TYPE_02_PADDED_PLAIN_TEXT, getEncryptKey("RSA"), getDecryptKey("RSA"));
+            fail();
+        } catch (BadPaddingException expected) {
+        }
+        try {
+            testInputPKCS1Padding(PKCS1_BLOCK_TYPE_01_PADDED_PLAIN_TEXT, getDecryptKey("RSA"), getEncryptKey("RSA"));
+            fail();
+        } catch (BadPaddingException expected) {
+        }
+        testInputPKCS1Padding(PKCS1_BLOCK_TYPE_02_PADDED_PLAIN_TEXT, getDecryptKey("RSA"), getEncryptKey("RSA"));
+    }
+
+    private void testInputPKCS1Padding(byte[] prePaddedPlainText, Key encryptKey, Key decryptKey) throws Exception {
+        Cipher encryptCipher = Cipher.getInstance("RSA/ECB/NoPadding");
+        encryptCipher.init(Cipher.ENCRYPT_MODE, encryptKey);
+        byte[] cipherText = encryptCipher.doFinal(prePaddedPlainText);
+        Cipher decryptCipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
+        decryptCipher.init(Cipher.DECRYPT_MODE, decryptKey);
+        byte[] plainText = decryptCipher.doFinal(cipherText);
+        assertEquals(Arrays.toString(ORIGINAL_PLAIN_TEXT),
+                     Arrays.toString(plainText));
+    }
+
+    public void testOutputPKCS1Padding() throws Exception {
+       testOutputPKCS1Padding((byte) 1, getEncryptKey("RSA"), getDecryptKey("RSA"));
+       testOutputPKCS1Padding((byte) 2, getDecryptKey("RSA"), getEncryptKey("RSA"));
+    }
+
+    private void testOutputPKCS1Padding(byte expectedBlockType, Key encryptKey, Key decryptKey) throws Exception {
+        Cipher encryptCipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
+        encryptCipher.init(Cipher.ENCRYPT_MODE, encryptKey);
+        byte[] cipherText = encryptCipher.doFinal(ORIGINAL_PLAIN_TEXT);
+        Cipher decryptCipher = Cipher.getInstance("RSA/ECB/NoPadding");
+        decryptCipher.init(Cipher.DECRYPT_MODE, decryptKey);
+        byte[] plainText = decryptCipher.doFinal(cipherText);
+        assertPadding(expectedBlockType, ORIGINAL_PLAIN_TEXT, plainText);
+    }
+
+    private void assertPadding(byte expectedBlockType, byte[] expectedData, byte[] actualDataWithPadding) {
+        assertNotNull(actualDataWithPadding);
+        assertEquals(getExpectedOutputSize("RSA"), actualDataWithPadding.length);
+        assertEquals(0, actualDataWithPadding[0]);
+        byte actualBlockType = actualDataWithPadding[1];
+        assertEquals(expectedBlockType, actualBlockType);
+        int actualDataOffset = actualDataWithPadding.length - expectedData.length;
+        if (actualBlockType == 1) {
+            for (int i = 2; i < actualDataOffset - 1; i++) {
+                assertEquals((byte) 0xFF, actualDataWithPadding[i]);
+            }
+        }
+        assertEquals(0x00, actualDataWithPadding[actualDataOffset-1]);
+        byte[] actualData = new byte[expectedData.length];
+        System.arraycopy(actualDataWithPadding, actualDataOffset, actualData, 0, actualData.length);
+        assertEquals(Arrays.toString(expectedData), Arrays.toString(actualData));
+    }
+
     public void testCipherInitWithCertificate () throws Exception {
         // no key usage specified, everything is fine
         assertCipherInitWithKeyUsage(0,                         true,  true, true,  true);
diff --git a/support/src/test/java/libcore/java/security/StandardNames.java b/support/src/test/java/libcore/java/security/StandardNames.java
index 8f427bf..eb53ba5 100644
--- a/support/src/test/java/libcore/java/security/StandardNames.java
+++ b/support/src/test/java/libcore/java/security/StandardNames.java
@@ -337,6 +337,7 @@ public final class StandardNames extends Assert {
             // Added to support Android KeyStore operations
             provide("Signature", "NONEwithRSA");
             provide("Cipher", "RSA/ECB/NOPADDING");
+            provide("Cipher", "RSA/ECB/PKCS1PADDING");
 
             // different names: JSSE Reference Guide says PKIX aka X509
             unprovide("TrustManagerFactory", "PKIX");
-- 
cgit v1.1


From fe8b870db2b374e21c69c2ff0050e6a34e0d8d94 Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Tue, 4 Sep 2012 23:01:09 -0700
Subject: Tracking upgrade to bouncycastle 1.47

Change-Id: Ie1f2ae92638e81ccd7e4ec2459199e6eecdac75f
---
 .../xnet/provider/jsse/OpenSSLProvider.java        | 40 +++++++++++-----------
 .../crypto/tests/javax/crypto/CipherTest.java      |  6 +++-
 .../java/libcore/java/security/StandardNames.java  |  8 -----
 3 files changed, 25 insertions(+), 29 deletions(-)

diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLProvider.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLProvider.java
index e1d0fb0..fd9be17 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLProvider.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLProvider.java
@@ -80,26 +80,26 @@ public final class OpenSSLProvider extends Provider {
         put("Alg.Alias.Signature.1.2.840.113549.2.5with1.2.840.113549.1.1.1",
                 "MD5WithRSAEncryption");
 
-        put("Signature.SHA1WithRSAEncryption", OpenSSLSignature.SHA1RSA.class.getName());
-        put("Alg.Alias.Signature.SHA1WithRSA", "SHA1WithRSAEncryption");
-        put("Alg.Alias.Signature.SHA1/RSA", "SHA1WithRSAEncryption");
-        put("Alg.Alias.Signature.SHA-1/RSA", "SHA1WithRSAEncryption");
-        put("Alg.Alias.Signature.1.2.840.113549.1.1.5", "SHA1WithRSAEncryption");
-        put("Alg.Alias.Signature.1.3.14.3.2.26with1.2.840.113549.1.1.1", "SHA1WithRSAEncryption");
-        put("Alg.Alias.Signature.1.3.14.3.2.26with1.2.840.113549.1.1.5", "SHA1WithRSAEncryption");
-        put("Alg.Alias.Signature.1.3.14.3.2.29", "SHA1WithRSAEncryption");
-
-        put("Signature.SHA256WithRSAEncryption", OpenSSLSignature.SHA256RSA.class.getName());
-        put("Alg.Alias.Signature.SHA256WithRSA", "SHA256WithRSAEncryption");
-        put("Alg.Alias.Signature.1.2.840.113549.1.1.11", "SHA256WithRSAEncryption");
-
-        put("Signature.SHA384WithRSAEncryption", OpenSSLSignature.SHA384RSA.class.getName());
-        put("Alg.Alias.Signature.SHA384WithRSA", "SHA384WithRSAEncryption");
-        put("Alg.Alias.Signature.1.2.840.113549.1.1.12", "SHA384WithRSAEncryption");
-
-        put("Signature.SHA512WithRSAEncryption", OpenSSLSignature.SHA512RSA.class.getName());
-        put("Alg.Alias.Signature.SHA512WithRSA", "SHA512WithRSAEncryption");
-        put("Alg.Alias.Signature.1.2.840.113549.1.1.13", "SHA512WithRSAEncryption");
+        put("Signature.SHA1WithRSA", OpenSSLSignature.SHA1RSA.class.getName());
+        put("Alg.Alias.Signature.SHA1WithRSA", "SHA1WithRSA");
+        put("Alg.Alias.Signature.SHA1/RSA", "SHA1WithRSA");
+        put("Alg.Alias.Signature.SHA-1/RSA", "SHA1WithRSA");
+        put("Alg.Alias.Signature.1.2.840.113549.1.1.5", "SHA1WithRSA");
+        put("Alg.Alias.Signature.1.3.14.3.2.26with1.2.840.113549.1.1.1", "SHA1WithRSA");
+        put("Alg.Alias.Signature.1.3.14.3.2.26with1.2.840.113549.1.1.5", "SHA1WithRSA");
+        put("Alg.Alias.Signature.1.3.14.3.2.29", "SHA1WithRSA");
+
+        put("Signature.SHA256WithRSA", OpenSSLSignature.SHA256RSA.class.getName());
+        put("Alg.Alias.Signature.SHA256WithRSAEncryption", "SHA256WithRSA");
+        put("Alg.Alias.Signature.1.2.840.113549.1.1.11", "SHA256WithRSA");
+
+        put("Signature.SHA384WithRSA", OpenSSLSignature.SHA384RSA.class.getName());
+        put("Alg.Alias.Signature.SHA384WithRSAEncryption", "SHA384WithRSA");
+        put("Alg.Alias.Signature.1.2.840.113549.1.1.12", "SHA384WithRSA");
+
+        put("Signature.SHA512WithRSA", OpenSSLSignature.SHA512RSA.class.getName());
+        put("Alg.Alias.Signature.SHA512WithRSAEncryption", "SHA512WithRSA");
+        put("Alg.Alias.Signature.1.2.840.113549.1.1.13", "SHA512WithRSA");
 
         put("Signature.SHA1withDSA", OpenSSLSignature.SHA1DSA.class.getName());
         put("Alg.Alias.Signature.SHA/DSA", "SHA1withDSA");
diff --git a/luni/src/test/java/org/apache/harmony/crypto/tests/javax/crypto/CipherTest.java b/luni/src/test/java/org/apache/harmony/crypto/tests/javax/crypto/CipherTest.java
index 7442210..c07b180 100644
--- a/luni/src/test/java/org/apache/harmony/crypto/tests/javax/crypto/CipherTest.java
+++ b/luni/src/test/java/org/apache/harmony/crypto/tests/javax/crypto/CipherTest.java
@@ -47,6 +47,7 @@ import javax.crypto.ShortBufferException;
 import javax.crypto.spec.DESedeKeySpec;
 import javax.crypto.spec.IvParameterSpec;
 import javax.crypto.spec.SecretKeySpec;
+import libcore.java.security.StandardNames;
 import org.apache.harmony.crypto.tests.support.MyCipher;
 import tests.support.resource.Support_Resources;
 
@@ -545,7 +546,10 @@ public class CipherTest extends junit.framework.TestCase {
         try {
             c.doFinal(b, 3, 6, b1, 5);
             fail();
-        } catch (ShortBufferException expected) {
+        } catch (IllegalBlockSizeException maybeExpected) {
+            assertTrue(StandardNames.IS_RI);
+        } catch (ShortBufferException maybeExpected) {
+            assertFalse(StandardNames.IS_RI);
         }
     }
 
diff --git a/support/src/test/java/libcore/java/security/StandardNames.java b/support/src/test/java/libcore/java/security/StandardNames.java
index 793fd4b..dc57086 100644
--- a/support/src/test/java/libcore/java/security/StandardNames.java
+++ b/support/src/test/java/libcore/java/security/StandardNames.java
@@ -325,14 +325,6 @@ public final class StandardNames extends Assert {
             // different names: added "Encryption" suffix
             unprovide("Signature", "MD5withRSA");
             provide("Signature", "MD5WithRSAEncryption");
-            unprovide("Signature", "SHA1withRSA");
-            provide("Signature", "SHA1WithRSAEncryption");
-            unprovide("Signature", "SHA256WithRSA");
-            provide("Signature", "SHA256WithRSAEncryption");
-            unprovide("Signature", "SHA384WithRSA");
-            provide("Signature", "SHA384WithRSAEncryption");
-            unprovide("Signature", "SHA512WithRSA");
-            provide("Signature", "SHA512WithRSAEncryption");
 
             // Added to support Android KeyStore operations
             provide("Signature", "NONEwithRSA");
-- 
cgit v1.1


From 6d2a17ab04ab0967e3bff7fe6280066ef66d1d76 Mon Sep 17 00:00:00 2001
From: Geremy Condra <gcondra@google.com>
Date: Mon, 11 Jun 2012 14:06:23 -0700
Subject: Added basic cert pinning support.

This has four main changes:

First, it adds a CertPinManager to TrustManagerImpl that checks to
ensure that the chain is properly pinned.

Second, it adds the CertPinManager and associated classes to
implement cert pinning at this level.

Third, it changes the callers of checkServerTrusted to pass in a
hostname where possible, allowing them to make use of the pinning
transparently.

Finally, it changes checkServerTrusted to return the ultimate
chain that was verified, which is useful for implementing pinning
at a higher level.

cherry-picked from 5315f29b2de4aace0077b78f0b99634fda440b85

Change-Id: I150e010da3e2aeed57bd5330ff113d3a7fbbee2a
---
 .../harmony/xnet/provider/jsse/CertPinManager.java | 181 +++++++++++++++++++++
 .../xnet/provider/jsse/ClientHandshakeImpl.java    |  24 ++-
 .../xnet/provider/jsse/OpenSSLSocketImpl.java      |  13 +-
 .../xnet/provider/jsse/PinEntryException.java      |  28 ++++
 .../harmony/xnet/provider/jsse/PinListEntry.java   | 140 ++++++++++++++++
 .../xnet/provider/jsse/PinManagerException.java    |  32 ++++
 .../xnet/provider/jsse/SSLSocketFactoryImpl.java   |   2 +-
 .../harmony/xnet/provider/jsse/SSLSocketImpl.java  |  37 +++++
 .../xnet/provider/jsse/SSLSocketWrapper.java       |   5 +-
 .../xnet/provider/jsse/TrustManagerImpl.java       | 103 +++++++++---
 .../xnet/provider/jsse/CertPinManagerTest.java     | 177 ++++++++++++++++++++
 .../xnet/provider/jsse/TrustManagerImplTest.java   | 112 ++++++++++++-
 12 files changed, 819 insertions(+), 35 deletions(-)
 create mode 100644 luni/src/main/java/org/apache/harmony/xnet/provider/jsse/CertPinManager.java
 create mode 100644 luni/src/main/java/org/apache/harmony/xnet/provider/jsse/PinEntryException.java
 create mode 100644 luni/src/main/java/org/apache/harmony/xnet/provider/jsse/PinListEntry.java
 create mode 100644 luni/src/main/java/org/apache/harmony/xnet/provider/jsse/PinManagerException.java
 create mode 100644 luni/src/test/java/org/apache/harmony/xnet/provider/jsse/CertPinManagerTest.java

diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/CertPinManager.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/CertPinManager.java
new file mode 100644
index 0000000..aa956dd
--- /dev/null
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/CertPinManager.java
@@ -0,0 +1,181 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed 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.xnet.provider.jsse;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.security.cert.X509Certificate;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import javax.net.ssl.DefaultHostnameVerifier;
+import libcore.io.IoUtils;
+import libcore.util.BasicLruCache;
+
+/**
+ * This class provides a simple interface for cert pinning.
+ */
+public class CertPinManager {
+
+    private long lastModified;
+
+    private final Map<String, PinListEntry> entries = new HashMap<String, PinListEntry>();
+    private final BasicLruCache<String, String> hostnameCache = new BasicLruCache<String, String>(10);
+    private final DefaultHostnameVerifier verifier = new DefaultHostnameVerifier();
+
+    private boolean initialized = false;
+    private static final boolean DEBUG = false;
+
+    private final File pinFile;
+
+    public CertPinManager() throws PinManagerException {
+        pinFile = new File("/data/misc/keychain/pins");
+        rebuild();
+    }
+
+    /** Test only */
+    public CertPinManager(String path) throws PinManagerException {
+        if (path == null) {
+            throw new NullPointerException("path == null");
+        }
+        pinFile = new File(path);
+        rebuild();
+    }
+
+    /**
+     * This is the public interface for cert pinning.
+     *
+     * Given a hostname and a certificate chain this verifies that the chain includes
+     * certs from the pinned list provided.
+     *
+     * If the chain doesn't include those certs and is in enforcing mode, then this method
+     * returns true and the certificate check should fail.
+     */
+    public boolean chainIsNotPinned(String hostname, List<X509Certificate> chain)
+            throws PinManagerException {
+        // lookup the entry
+        PinListEntry entry = lookup(hostname);
+
+        // return its result or false if there's no pin
+        if (entry != null) {
+            return entry.chainIsNotPinned(chain);
+        }
+        return false;
+    }
+
+    private synchronized void rebuild() throws PinManagerException {
+        // reread the pin file
+        String pinFileContents = readPinFile();
+
+        if (pinFileContents != null) {
+            // rebuild the pinned certs
+            for (String entry : getPinFileEntries(pinFileContents)) {
+                try {
+                    PinListEntry pin = new PinListEntry(entry);
+                    entries.put(pin.getCommonName(), pin);
+                } catch (PinEntryException e) {
+                    log("Pinlist contains a malformed pin: " + entry, e);
+                }
+            }
+
+            // clear the cache
+            hostnameCache.evictAll();
+
+            // set the last modified time
+            lastModified = pinFile.lastModified();
+
+            // we've been fully initialized and are ready to go
+            initialized = true;
+        }
+    }
+
+    private String readPinFile() throws PinManagerException {
+        try {
+            return IoUtils.readFileAsString(pinFile.getPath());
+        } catch (FileNotFoundException e) {
+            // there's no pin list, all certs are unpinned
+            return null;
+        } catch (IOException e) {
+            // this is unexpected, fail
+            throw new PinManagerException("Unexpected error reading pin list; failing.", e);
+        }
+    }
+
+    private static String[] getPinFileEntries(String pinFileContents) {
+        return pinFileContents.split("\n");
+    }
+
+    private synchronized PinListEntry lookup(String hostname) throws PinManagerException {
+
+        // if we don't have any data, don't bother
+        if (!initialized) {
+            return null;
+        }
+
+        // check to see if our cache is valid
+        if (cacheIsNotValid()) {
+            rebuild();
+        }
+
+        // if so, check the hostname cache
+        String cn = hostnameCache.get(hostname);
+        if (cn != null) {
+            // if we hit, return the corresponding entry
+            return entries.get(cn);
+        }
+
+        // otherwise, get the matching cn
+        cn = getMatchingCN(hostname);
+        if (cn != null) {
+            hostnameCache.put(hostname, cn);
+            // we have a matching CN, return that entry
+            return entries.get(cn);
+        }
+
+        // if we got here, we don't have a matching CN for this hostname
+        return null;
+    }
+
+    private boolean cacheIsNotValid() {
+        return pinFile.lastModified() != lastModified;
+    }
+
+    private String getMatchingCN(String hostname) {
+        String bestMatch = "";
+        for (String cn : entries.keySet()) {
+            // skip shorter CNs since they can't be better matches
+            if (cn.length() < bestMatch.length()) {
+                continue;
+            }
+            // now verify that the CN matches at all
+            if (verifier.verifyHostName(hostname, cn)) {
+                bestMatch = cn;
+            }
+        }
+        return bestMatch;
+    }
+
+    private static void log(String s, Exception e) {
+        if (DEBUG) {
+            System.out.println("PINFILE: " + s);
+            if (e != null) {
+                e.printStackTrace();
+            }
+        }
+    }
+}
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/ClientHandshakeImpl.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/ClientHandshakeImpl.java
index 83f86ae..c855c0c 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/ClientHandshakeImpl.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/ClientHandshakeImpl.java
@@ -37,6 +37,7 @@ import javax.crypto.spec.DHPublicKeySpec;
 import javax.crypto.spec.SecretKeySpec;
 import javax.net.ssl.X509ExtendedKeyManager;
 import javax.net.ssl.X509KeyManager;
+import javax.net.ssl.X509TrustManager;
 import javax.security.auth.x500.X500Principal;
 
 /**
@@ -88,7 +89,7 @@ public class ClientHandshakeImpl extends HandshakeProtocol {
             if (engineOwner != null) {
                 session.setPeer(engineOwner.getPeerHost(), engineOwner.getPeerPort());
             } else {
-                session.setPeer(socketOwner.getInetAddress().getHostName(), socketOwner.getPort());
+                session.setPeer(socketOwner.getPeerHostName(), socketOwner.getPeerPort());
             }
             session.protocol = ProtocolVersion.getLatestVersion(parameters.getEnabledProtocols());
             recordProtocol.setVersion(session.protocol.version);
@@ -109,7 +110,7 @@ public class ClientHandshakeImpl extends HandshakeProtocol {
             if (engineOwner != null) {
                 session.setPeer(engineOwner.getPeerHost(), engineOwner.getPeerPort());
             } else {
-                session.setPeer(socketOwner.getInetAddress().getHostName(), socketOwner.getPort());
+                session.setPeer(socketOwner.getPeerHostName(), socketOwner.getPeerPort());
             }
             session.protocol = ProtocolVersion.getLatestVersion(parameters.getEnabledProtocols());
             recordProtocol.setVersion(session.protocol.version);
@@ -527,8 +528,21 @@ public class ClientHandshakeImpl extends HandshakeProtocol {
         if (authType == null) {
             return;
         }
+        String hostname = null;
+        if (engineOwner != null) {
+            hostname = engineOwner.getPeerHost();
+        } else {
+            // we don't want to do an inet address lookup here in case we're talking to a proxy
+            hostname = socketOwner.getWrappedHostName();
+        }
         try {
-            parameters.getTrustManager().checkServerTrusted(serverCert.certs, authType);
+            X509TrustManager x509tm = parameters.getTrustManager();
+            if (x509tm instanceof TrustManagerImpl) {
+                TrustManagerImpl tm = (TrustManagerImpl) x509tm;
+                tm.checkServerTrusted(serverCert.certs, authType, hostname);
+            } else {
+                x509tm.checkServerTrusted(serverCert.certs, authType);
+            }
         } catch (CertificateException e) {
             fatalAlert(AlertProtocol.BAD_CERTIFICATE, "Not trusted server certificate", e);
             return;
@@ -559,8 +573,8 @@ public class ClientHandshakeImpl extends HandshakeProtocol {
             host = engineOwner.getPeerHost();
             port = engineOwner.getPeerPort();
         } else {
-            host = socketOwner.getInetAddress().getHostName();
-            port = socketOwner.getPort();
+            host = socketOwner.getPeerHostName();
+            port = socketOwner.getPeerPort();
         }
         if (host == null || port == -1) {
             return null; // starts new session
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLSocketImpl.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLSocketImpl.java
index 3720ba2..5ab5aa7 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLSocketImpl.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLSocketImpl.java
@@ -418,7 +418,7 @@ public class OpenSSLSocketImpl
         }
     }
 
-    private String getPeerHostName() {
+    String getPeerHostName() {
         if (wrappedHost != null) {
             return wrappedHost;
         }
@@ -429,7 +429,7 @@ public class OpenSSLSocketImpl
         return null;
     }
 
-    private int getPeerPort() {
+    int getPeerPort() {
         return wrappedHost == null ? super.getPort() : wrappedPort;
     }
 
@@ -570,8 +570,13 @@ public class OpenSSLSocketImpl
             }
             boolean client = sslParameters.getUseClientMode();
             if (client) {
-                sslParameters.getTrustManager().checkServerTrusted(peerCertificateChain,
-                                                                   authMethod);
+                X509TrustManager x509tm = sslParameters.getTrustManager();
+                if (x509tm instanceof TrustManagerImpl) {
+                    TrustManagerImpl tm = (TrustManagerImpl) x509tm;
+                    tm.checkServerTrusted(peerCertificateChain, authMethod, wrappedHost);
+                } else {
+                    x509tm.checkServerTrusted(peerCertificateChain, authMethod);
+                }
             } else {
                 String authType = peerCertificateChain[0].getPublicKey().getAlgorithm();
                 sslParameters.getTrustManager().checkClientTrusted(peerCertificateChain,
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/PinEntryException.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/PinEntryException.java
new file mode 100644
index 0000000..8e49bec
--- /dev/null
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/PinEntryException.java
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed 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.xnet.provider.jsse;
+
+class PinEntryException extends Exception {
+
+    PinEntryException() {
+    }
+
+    PinEntryException(String msg) {
+        super(msg);
+    }
+}
+
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/PinListEntry.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/PinListEntry.java
new file mode 100644
index 0000000..adb0cbd
--- /dev/null
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/PinListEntry.java
@@ -0,0 +1,140 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed 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.xnet.provider.jsse;
+
+import java.math.BigInteger;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.security.cert.X509Certificate;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * This class represents a single entry in the pin file.
+ */
+class PinListEntry {
+
+    /** The Common Name (CN) as used on the SSL certificate */
+    private final String cn;
+
+    /**
+     * Determines whether a failed match here will prevent the chain from being accepted. If true,
+     *  an unpinned chain will log and cause a match failure. If false, it will merely log.
+     */
+    private final boolean enforcing;
+
+    private final Set<String> pinnedFingerprints = new HashSet<String>();
+
+    private static final boolean DEBUG = false;
+
+    public String getCommonName() {
+        return cn;
+    }
+
+    public boolean getEnforcing() {
+        return enforcing;
+    }
+
+    public PinListEntry(String entry) throws PinEntryException {
+        if (entry == null) {
+            throw new NullPointerException("entry == null");
+        }
+        // Examples:
+        // *.google.com=true|34c8a0d...9e04ca05f,9e04ca05f...34c8a0d
+        // *.android.com=true|ca05f...8a0d34c
+        // clients.google.com=false|9e04ca05f...34c8a0d,34c8a0d...9e04ca05f
+        String[] values = entry.split("[=,|]");
+        // entry must have a CN, an enforcement value, and at least one pin
+        if (values.length < 3) {
+            throw new PinEntryException("Received malformed pin entry");
+        }
+        // get the cn
+        cn = values[0];        // is there more validation we can do here?
+        enforcing = enforcementValueFromString(values[1]);
+        // the remainder should be pins
+        addPins(Arrays.copyOfRange(values, 2, values.length));
+    }
+
+    private static boolean enforcementValueFromString(String val) throws PinEntryException {
+        if (val.equals("true")) {
+            return true;
+        } else if (val.equals("false")) {
+            return false;
+        } else {
+            throw new PinEntryException("Enforcement status is not a valid value");
+        }
+    }
+
+    /**
+     * Checks the given chain against the pin list corresponding to this entry.
+     *
+     * If the pin list does not contain the required certs and the enforcing field is true then
+     * this returns true, indicating a verification error. Otherwise, it returns false and
+     * verification should proceed.
+     */
+    public boolean chainIsNotPinned(List<X509Certificate> chain) {
+        for (X509Certificate cert : chain) {
+            String fingerprint = getFingerprint(cert);
+            if (pinnedFingerprints.contains(fingerprint)) {
+                return false;
+            }
+        }
+        log("Received unpinned chain for " + cn);
+        return enforcing;
+    }
+
+    private static String getFingerprint(X509Certificate cert) {
+        try {
+            MessageDigest dgst = MessageDigest.getInstance("SHA512");
+            byte[] encoded = cert.getPublicKey().getEncoded();
+            byte[] fingerprint = dgst.digest(encoded);
+            return IntegralToString.bytesToHexString(fingerprint, false);
+        } catch (NoSuchAlgorithmException e) {
+            throw new AssertionError(e);
+        }
+    }
+
+    private void addPins(String[] pins) {
+        for (String pin : pins) {
+            validatePin(pin);
+        }
+        Collections.addAll(pinnedFingerprints, pins);
+    }
+
+    private static void validatePin(String pin) {
+        // check to make sure the length is correct
+        if (pin.length() != 128) {
+            throw new IllegalArgumentException("Pin is not a valid length");
+        }
+        // check to make sure that it's a valid hex string
+        try {
+            new BigInteger(pin, 16);
+        } catch (NumberFormatException e) {
+            throw new IllegalArgumentException("Pin is not a valid hex string", e);
+        }
+    }
+
+    private static void log(String s) {
+        if (DEBUG) {
+            System.out.println("PINENTRY: " + s);
+        }
+    }
+}
+
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/PinManagerException.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/PinManagerException.java
new file mode 100644
index 0000000..74b3c65
--- /dev/null
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/PinManagerException.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed 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.xnet.provider.jsse;
+
+class PinManagerException extends Exception {
+
+    PinManagerException() {
+    }
+
+    PinManagerException(String msg) {
+        super(msg);
+    }
+
+    PinManagerException(String msg, Exception e) {
+        super(msg, e);
+    }
+}
+
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/SSLSocketFactoryImpl.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/SSLSocketFactoryImpl.java
index be9a7fc..93496cf 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/SSLSocketFactoryImpl.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/SSLSocketFactoryImpl.java
@@ -88,7 +88,7 @@ public class SSLSocketFactoryImpl extends SSLSocketFactory {
         if (instantiationException != null) {
             throw instantiationException;
         }
-        return new SSLSocketWrapper(s, autoClose, (SSLParametersImpl) sslParameters
+        return new SSLSocketWrapper(s, host, port, autoClose, (SSLParametersImpl) sslParameters
                 .clone());
     }
 
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/SSLSocketImpl.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/SSLSocketImpl.java
index 6e5fddd..2cd2cf5 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/SSLSocketImpl.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/SSLSocketImpl.java
@@ -41,6 +41,10 @@ public class SSLSocketImpl extends SSLSocket {
     // indicates if handshake has been started
     private boolean handshake_started = false;
 
+    // used when we're wrapping a socket
+    private final String wrappedHost;
+    private final int wrappedPort;
+
     // record protocol to be used
     protected SSLRecordProtocol recordProtocol;
     // handshake protocol to be used
@@ -83,6 +87,8 @@ public class SSLSocketImpl extends SSLSocket {
      */
     protected SSLSocketImpl(SSLParametersImpl sslParameters) {
         this.sslParameters = sslParameters;
+        this.wrappedHost = null;
+        this.wrappedPort = -1;
         // init should be called after creation!
     }
 
@@ -99,6 +105,8 @@ public class SSLSocketImpl extends SSLSocket {
     protected SSLSocketImpl(String host, int port, SSLParametersImpl sslParameters)
             throws IOException, UnknownHostException {
         super(host, port);
+        this.wrappedHost = host;
+        this.wrappedPort = port;
         this.sslParameters = sslParameters;
         init();
     }
@@ -120,6 +128,8 @@ public class SSLSocketImpl extends SSLSocket {
             SSLParametersImpl sslParameters) throws IOException,
             UnknownHostException {
         super(host, port, localHost, localPort);
+        this.wrappedHost = host;
+        this.wrappedPort = port;
         this.sslParameters = sslParameters;
         init();
     }
@@ -138,6 +148,8 @@ public class SSLSocketImpl extends SSLSocket {
             SSLParametersImpl sslParameters) throws IOException {
         super(host, port);
         this.sslParameters = sslParameters;
+        this.wrappedHost = null;
+        this.wrappedPort = -1;
         init();
     }
 
@@ -158,6 +170,8 @@ public class SSLSocketImpl extends SSLSocket {
             SSLParametersImpl sslParameters) throws IOException {
         super(address, port, localAddress, localPort);
         this.sslParameters = sslParameters;
+        this.wrappedHost = null;
+        this.wrappedPort = -1;
         init();
     }
 
@@ -193,6 +207,29 @@ public class SSLSocketImpl extends SSLSocket {
         }
     }
 
+    String getWrappedHostName() {
+        return wrappedHost;
+    }
+
+    int getWrappedPort() {
+        return wrappedPort;
+    }
+
+    String getPeerHostName() {
+        if (wrappedHost != null) {
+            return wrappedHost;
+        }
+        InetAddress inetAddress = super.getInetAddress();
+        if (inetAddress != null) {
+            return inetAddress.getHostName();
+        }
+        return null;
+    }
+
+    int getPeerPort() {
+        return (wrappedPort == -1) ? super.getPort() : wrappedPort;
+    }
+
     // --------------- SSLParameters based methods ---------------------
 
     /**
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/SSLSocketWrapper.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/SSLSocketWrapper.java
index 27bbead..a393e24 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/SSLSocketWrapper.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/SSLSocketWrapper.java
@@ -32,8 +32,9 @@ public class SSLSocketWrapper extends SSLSocketImpl {
     private final Socket socket;
     private final boolean autoClose;
 
-    protected SSLSocketWrapper(Socket socket, boolean autoClose, SSLParametersImpl sslParameters) throws IOException {
-        super(sslParameters);
+    protected SSLSocketWrapper(Socket socket, String host, int port, boolean autoClose,
+                               SSLParametersImpl sslParameters) throws IOException {
+        super(host, port, sslParameters);
         if (!socket.isConnected()) {
             throw new SocketException("Socket is not connected.");
         }
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/TrustManagerImpl.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/TrustManagerImpl.java
index 3f362c5..5010ef2 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/TrustManagerImpl.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/TrustManagerImpl.java
@@ -52,6 +52,11 @@ public final class TrustManagerImpl implements X509TrustManager {
     private final KeyStore rootKeyStore;
 
     /**
+     * The CertPinManager, which validates the chain against a host-to-pin mapping
+     */
+    private CertPinManager pinManager;
+
+    /**
      * The backing store for the AndroidCAStore if non-null. This will
      * be null when the rootKeyStore is null, implying we are not
      * using the AndroidCAStore.
@@ -83,6 +88,13 @@ public final class TrustManagerImpl implements X509TrustManager {
      * @param ks
      */
     public TrustManagerImpl(KeyStore keyStore) {
+        this(keyStore, null);
+    }
+
+    /**
+     * For testing only
+     */
+    public TrustManagerImpl(KeyStore keyStore, CertPinManager manager) {
         CertPathValidator validatorLocal = null;
         CertificateFactory factoryLocal = null;
         KeyStore rootKeyStoreLocal = null;
@@ -111,6 +123,17 @@ public final class TrustManagerImpl implements X509TrustManager {
         } catch (Exception e) {
             errLocal = e;
         }
+
+        if (manager != null) {
+            this.pinManager = manager;
+        } else {
+            try {
+                pinManager = new CertPinManager();
+            } catch (PinManagerException e) {
+                throw new SecurityException("Could not initialize CertPinManager", e);
+            }
+        }
+
         this.rootKeyStore = rootKeyStoreLocal;
         this.trustedCertificateStore = trustedCertificateStoreLocal;
         this.validator = validatorLocal;
@@ -155,12 +178,22 @@ public final class TrustManagerImpl implements X509TrustManager {
 
     @Override public void checkClientTrusted(X509Certificate[] chain, String authType)
             throws CertificateException {
-        checkTrusted(chain, authType);
+        checkTrusted(chain, authType, null);
     }
 
     @Override public void checkServerTrusted(X509Certificate[] chain, String authType)
             throws CertificateException {
-        checkTrusted(chain, authType);
+        checkTrusted(chain, authType, null);
+    }
+
+    /**
+     * Validates whether a server is trusted. If hostname is given and non-null it also checks if
+     * chain is pinned appropriately for that host. If null, it does not check for pinned certs.
+     * The return value is a list of the certificates used for making the trust decision.
+     */
+    public List<X509Certificate> checkServerTrusted(X509Certificate[] chain, String authType,
+                                                    String host) throws CertificateException {
+        return checkTrusted(chain, authType, host);
     }
 
     public void handleTrustStorageUpdate() {
@@ -168,10 +201,10 @@ public final class TrustManagerImpl implements X509TrustManager {
             trustedCertificateIndex.reset();
         } else {
             trustedCertificateIndex.reset(trustAnchors(acceptedIssuers));
-        }
+       }
     }
 
-    private void checkTrusted(X509Certificate[] chain, String authType)
+    private List<X509Certificate> checkTrusted(X509Certificate[] chain, String authType, String host)
             throws CertificateException {
         if (chain == null || chain.length == 0 || authType == null || authType.length() == 0) {
             throw new IllegalArgumentException("null or zero-length parameter");
@@ -180,14 +213,38 @@ public final class TrustManagerImpl implements X509TrustManager {
             throw new CertificateException(err);
         }
 
+        // get the cleaned up chain and trust anchors
         Set<TrustAnchor> trustAnchors = new HashSet<TrustAnchor>();
         X509Certificate[] newChain = cleanupCertChainAndFindTrustAnchors(chain, trustAnchors);
+
+        // build the whole chain including all the trust anchors
+        List<X509Certificate> wholeChain = new ArrayList<X509Certificate>();
+        wholeChain.addAll(Arrays.asList(newChain));
+        for (TrustAnchor trust : trustAnchors) {
+            wholeChain.add(trust.getTrustedCert());
+        }
+
+        // build the cert path from the array of certs sans trust anchors
+        CertPath certPath = factory.generateCertPath(Arrays.asList(newChain));
+
+        if (host != null) {
+            boolean chainIsNotPinned = true;
+            try {
+                chainIsNotPinned = pinManager.chainIsNotPinned(host, wholeChain);
+            } catch (PinManagerException e) {
+                throw new CertificateException(e);
+            }
+            if (chainIsNotPinned) {
+                throw new CertificateException(new CertPathValidatorException(
+                        "Certificate path is not properly pinned.", null, certPath, -1));
+            }
+        }
+
         if (newChain.length == 0) {
             // chain was entirely trusted, skip the validator
-            return;
+            return wholeChain;
         }
 
-        CertPath certPath = factory.generateCertPath(Arrays.asList(newChain));
         if (trustAnchors.isEmpty()) {
             throw new CertificateException(new CertPathValidatorException(
                     "Trust anchor for certification path not found.", null, certPath, -1));
@@ -211,6 +268,8 @@ public final class TrustManagerImpl implements X509TrustManager {
         } catch (CertPathValidatorException e) {
             throw new CertificateException(e);
         }
+
+        return wholeChain;
     }
 
     /**
@@ -232,17 +291,9 @@ public final class TrustManagerImpl implements X509TrustManager {
         // Start with the first certificate in the chain, assuming it
         // is the leaf certificate (server or client cert).
         for (currIndex = 0; currIndex < chain.length; currIndex++) {
-            // If the current cert is a TrustAnchor, we can ignore the rest of the chain.
-            // This avoids including "bridge" CA certs that added for legacy compatability.
-            TrustAnchor trustAnchor = findTrustAnchorBySubjectAndPublicKey(chain[currIndex]);
-            if (trustAnchor != null) {
-                trustAnchors.add(trustAnchor);
-                currIndex--;
-                break;
-            }
-            // Walk the rest of the chain to find a "subject" matching
+            // Walk the chain to find a "subject" matching
             // the "issuer" of the current certificate. In a properly
-            // order chain this should be the next cert and be fast.
+            // ordered chain this should be the next cert and be fast.
             // If not, we reorder things to be as the validator will
             // expect.
             boolean foundNext = false;
@@ -271,15 +322,27 @@ public final class TrustManagerImpl implements X509TrustManager {
             }
         }
 
-        // 2. If the chain is now shorter, copy to an appropriately sized array.
-        int chainLength = currIndex + 1;
+        // 2. Find the trust anchor in the chain, if any
+        int anchorIndex;
+        for (anchorIndex = 0; anchorIndex < chain.length; anchorIndex++) {
+            // If the current cert is a TrustAnchor, we can ignore the rest of the chain.
+            // This avoids including "bridge" CA certs that added for legacy compatibility.
+            TrustAnchor trustAnchor = findTrustAnchorBySubjectAndPublicKey(chain[anchorIndex]);
+            if (trustAnchor != null) {
+                trustAnchors.add(trustAnchor);
+                break;
+            }
+        }
+
+        // 3. If the chain is now shorter, copy to an appropriately sized array.
+        int chainLength = anchorIndex;
         X509Certificate[] newChain = ((chainLength == chain.length)
                                       ? chain
                                       : Arrays.copyOf(chain, chainLength));
 
-        // 3. If no TrustAnchor was found in cleanup, look for one now
+        // 4. If we didn't find a trust anchor earlier, look for one now
         if (trustAnchors.isEmpty()) {
-            TrustAnchor trustAnchor = findTrustAnchorByIssuerAndSignature(newChain[chainLength-1]);
+            TrustAnchor trustAnchor = findTrustAnchorByIssuerAndSignature(newChain[anchorIndex-1]);
             if (trustAnchor != null) {
                 trustAnchors.add(trustAnchor);
             }
diff --git a/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/CertPinManagerTest.java b/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/CertPinManagerTest.java
new file mode 100644
index 0000000..a888165
--- /dev/null
+++ b/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/CertPinManagerTest.java
@@ -0,0 +1,177 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed 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.xnet.provider.jsse;
+
+import java.io.File;
+import java.io.FileWriter;
+import java.security.cert.X509Certificate;
+import java.security.KeyStore;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.ArrayList;
+import java.util.List;
+import junit.framework.TestCase;
+import libcore.java.security.TestKeyStore;
+
+public class CertPinManagerTest extends TestCase {
+
+    private X509Certificate[] chain;
+    private List<X509Certificate> shortChain;
+    private List<X509Certificate> longChain;
+    private String shortPin;
+    private String longPin;
+    private List<File> tmpFiles = new ArrayList<File>();
+
+    private String writeTmpPinFile(String text) throws Exception {
+        File tmp = File.createTempFile("pins", null);
+        FileWriter fstream = new FileWriter(tmp);
+        fstream.write(text);
+        fstream.close();
+        tmpFiles.add(tmp);
+        return tmp.getPath();
+    }
+
+    private static String getFingerprint(X509Certificate cert) throws NoSuchAlgorithmException {
+        MessageDigest dgst = MessageDigest.getInstance("SHA512");
+        byte[] encoded = cert.getPublicKey().getEncoded();
+        byte[] fingerprint = dgst.digest(encoded);
+        return IntegralToString.bytesToHexString(fingerprint, false);
+    }
+
+    @Override
+    public void setUp() throws Exception {
+        super.setUp();
+        // build some valid chains
+        KeyStore.PrivateKeyEntry pke = TestKeyStore.getServer().getPrivateKey("RSA", "RSA");
+        chain = (X509Certificate[]) pke.getCertificateChain();
+        X509Certificate root = chain[2];
+        X509Certificate server = chain[0];
+
+        // build the short and long chains
+        shortChain = new ArrayList<X509Certificate>();
+        shortChain.add(root);
+        longChain = new ArrayList<X509Certificate>();
+        longChain.add(server);
+
+        // we'll use the root as the pin for the short entry and the server as the pin for the long
+        shortPin = getFingerprint(root);
+        longPin = getFingerprint(server);
+    }
+
+    @Override
+    public void tearDown() throws Exception {
+        try {
+            for (File f : tmpFiles) {
+                f.delete();
+            }
+            tmpFiles.clear();
+        } finally {
+            super.tearDown();
+        }
+    }
+
+    public void testPinFileMaximumLookup() throws Exception {
+
+        // write a pinfile with two entries, one longer than the other
+        String shortEntry = "*.google.com=true|" + shortPin;
+        String longEntry = "*.clients.google.com=true|" + longPin;
+
+        // create the pinFile
+        String path = writeTmpPinFile(shortEntry + "\n" + longEntry);
+        CertPinManager pf = new CertPinManager(path);
+
+        // verify that the shorter chain doesn't work for a name matching the longer
+        assertTrue("short chain long uri failed",
+                   pf.chainIsNotPinned("android.clients.google.com", shortChain));
+        // verify that the longer chain doesn't work for a name matching the shorter
+        assertTrue("long chain short uri failed",
+                   pf.chainIsNotPinned("android.google.com", longChain));
+        // verify that the shorter chain works for the shorter domain
+        assertTrue("short chain short uri failed",
+                   !pf.chainIsNotPinned("android.google.com", shortChain));
+        // and the same for the longer
+        assertTrue("long chain long uri failed",
+                   !pf.chainIsNotPinned("android.clients.google.com", longChain));
+    }
+
+    public void testPinEntryMalformedEntry() throws Exception {
+        // set up the pinEntry with a bogus entry
+        String entry = "*.google.com=";
+        try {
+            new PinListEntry(entry);
+            fail("Accepted an empty pin list entry.");
+        } catch (PinEntryException expected) {
+            // did what we're supposed to do
+        }
+    }
+
+    public void testPinEntryNull() throws Exception {
+        // set up the pinEntry with a bogus entry
+        String entry = null;
+        try {
+            new PinListEntry(entry);
+            fail("Accepted a basically wholly bogus entry.");
+        } catch (NullPointerException expected) {
+            // did what we're supposed to do
+        }
+    }
+
+    public void testPinEntryEmpty() throws Exception {
+        // set up the pinEntry with a bogus entry
+        try {
+            new PinListEntry("");
+            fail("Accepted an empty entry.");
+        } catch (PinEntryException expected) {
+        }
+    }
+
+    public void testPinEntryPinFailure() throws Exception {
+        // write a pinfile with two entries, one longer than the other
+        String shortEntry = "*.google.com=true|" + shortPin;
+
+        // set up the pinEntry with a pinlist that doesn't match what we'll give it
+        PinListEntry e = new PinListEntry(shortEntry);
+        assertTrue("Not enforcing!", e.getEnforcing());
+        // verify that it doesn't accept
+        boolean retval = e.chainIsNotPinned(longChain);
+        assertTrue("Accepted an incorrect pinning, this is very bad", retval);
+    }
+
+    public void testPinEntryPinSuccess() throws Exception {
+        // write a pinfile with two entries, one longer than the other
+        String shortEntry = "*.google.com=true|" + shortPin;
+
+        // set up the pinEntry with a pinlist that matches what we'll give it
+        PinListEntry e = new PinListEntry(shortEntry);
+        assertTrue("Not enforcing!", e.getEnforcing());
+        // verify that it accepts
+        boolean retval = e.chainIsNotPinned(shortChain);
+        assertTrue("Failed on a correct pinning, this is very bad", !retval);
+    }
+
+    public void testPinEntryNonEnforcing() throws Exception {
+        // write a pinfile with two entries, one longer than the other
+        String shortEntry = "*.google.com=false|" + shortPin;
+
+        // set up the pinEntry with a pinlist that matches what we'll give it
+        PinListEntry e = new PinListEntry(shortEntry);
+        assertFalse("Enforcing!", e.getEnforcing());
+        // verify that it accepts
+        boolean retval = e.chainIsNotPinned(shortChain);
+        assertTrue("Failed on an unenforced pinning, this is bad-ish", !retval);
+    }
+}
diff --git a/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/TrustManagerImplTest.java b/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/TrustManagerImplTest.java
index 26ebc85..97032d9 100644
--- a/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/TrustManagerImplTest.java
+++ b/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/TrustManagerImplTest.java
@@ -16,9 +16,15 @@
 
 package org.apache.harmony.xnet.provider.jsse;
 
-import java.security.KeyStore;
+import java.io.File;
+import java.io.FileWriter;
 import java.security.cert.CertificateException;
 import java.security.cert.X509Certificate;
+import java.security.KeyStore;
+import java.security.MessageDigest;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
 import javax.net.ssl.TrustManager;
 import javax.net.ssl.TrustManagerFactory;
 import javax.net.ssl.X509TrustManager;
@@ -27,12 +33,41 @@ import libcore.java.security.TestKeyStore;
 
 public class TrustManagerImplTest extends TestCase {
 
+    private List<File> tmpFiles = new ArrayList<File>();
+
+    private String getFingerprint(X509Certificate cert) throws Exception {
+        MessageDigest dgst = MessageDigest.getInstance("SHA512");
+        byte[] encoded = cert.getPublicKey().getEncoded();
+        byte[] fingerprint = dgst.digest(encoded);
+        return IntegralToString.bytesToHexString(fingerprint, false);
+    }
+
+    private String writeTmpPinFile(String text) throws Exception {
+        File tmp = File.createTempFile("pins", null);
+        FileWriter fstream = new FileWriter(tmp);
+        fstream.write(text);
+        fstream.close();
+        tmpFiles.add(tmp);
+        return tmp.getPath();
+    }
+
+    @Override
+    public void tearDown() throws Exception {
+        try {
+            for (File f : tmpFiles) {
+                f.delete();
+            }
+            tmpFiles.clear();
+        } finally {
+            super.tearDown();
+        }
+    }
+
     /**
      * Ensure that our non-standard behavior of learning to trust new
      * intermediate CAs does not regress. http://b/3404902
      */
     public void testLearnIntermediate() throws Exception {
-
         // chain3 should be server/intermediate/root
         KeyStore.PrivateKeyEntry pke = TestKeyStore.getServer().getPrivateKey("RSA", "RSA");
         X509Certificate[] chain3 = (X509Certificate[])pke.getCertificateChain();
@@ -63,6 +98,31 @@ public class TrustManagerImplTest extends TestCase {
         assertValid(chain1, tm);
     }
 
+    public void testCertPinning() throws Exception {
+        // chain3 should be server/intermediate/root
+        KeyStore.PrivateKeyEntry pke = TestKeyStore.getServer().getPrivateKey("RSA", "RSA");
+        X509Certificate[] chain3 = (X509Certificate[]) pke.getCertificateChain();
+        X509Certificate root = chain3[2];
+        X509Certificate intermediate = chain3[1];
+        X509Certificate server = chain3[0];
+        X509Certificate[] chain2 =  new X509Certificate[] { server, intermediate };
+        X509Certificate[] chain1 =  new X509Certificate[] { server };
+
+        // test without a hostname, expecting failure
+        assertInvalidPinned(chain1, trustManager(root, "gugle.com", root), null);
+        // test without a hostname, expecting success
+        assertValidPinned(chain3, trustManager(root, "gugle.com", root), null, chain3);
+        // test an unpinned hostname that should fail
+        assertInvalidPinned(chain1, trustManager(root, "gugle.com", root), "purple.com");
+        // test an unpinned hostname that should succeed
+        assertValidPinned(chain3, trustManager(root, "gugle.com", root), "purple.com", chain3);
+        // test a pinned hostname that should fail
+        assertInvalidPinned(chain1, trustManager(intermediate, "gugle.com", root), "gugle.com");
+        // test a pinned hostname that should succeed
+        assertValidPinned(chain2, trustManager(intermediate, "gugle.com", server), "gugle.com",
+                                                                                            chain2);
+    }
+
     private X509TrustManager trustManager(X509Certificate ca) throws Exception {
         KeyStore keyStore = TestKeyStore.createKeyStore();
         keyStore.setCertificateEntry("alias", ca);
@@ -73,10 +133,45 @@ public class TrustManagerImplTest extends TestCase {
         return (X509TrustManager) tmf.getTrustManagers()[0];
     }
 
+    private TrustManagerImpl trustManager(X509Certificate ca, String hostname, X509Certificate pin)
+                                          throws Exception {
+        // build the cert pin manager
+        CertPinManager cm = certManager(hostname, pin);
+        // insert it into the trust manager
+        KeyStore keyStore = TestKeyStore.createKeyStore();
+        keyStore.setCertificateEntry("alias", ca);
+        return new TrustManagerImpl(keyStore, cm);
+    }
+
+    private CertPinManager certManager(String hostname, X509Certificate pin) throws Exception {
+        String pinString = "";
+        if (pin != null) {
+            pinString = hostname + "=true|" + getFingerprint(pin);
+        }
+        // write it to a pinfile
+        String path = writeTmpPinFile(pinString);
+        // build the certpinmanager
+        return new CertPinManager(path);
+    }
+
     private void assertValid(X509Certificate[] chain, X509TrustManager tm) throws Exception {
-        tm.checkClientTrusted(chain, "RSA");
+        if (tm instanceof TrustManagerImpl) {
+            TrustManagerImpl tmi = (TrustManagerImpl) tm;
+            tmi.checkServerTrusted(chain, "RSA");
+        }
+        tm.checkServerTrusted(chain, "RSA");
+    }
+
+    private void assertValidPinned(X509Certificate[] chain, X509TrustManager tm, String hostname,
+                                   X509Certificate[] fullChain) throws Exception {
+        if (tm instanceof TrustManagerImpl) {
+            TrustManagerImpl tmi = (TrustManagerImpl) tm;
+            List<X509Certificate> checkedChain = tmi.checkServerTrusted(chain, "RSA", hostname);
+            assertEquals(checkedChain, Arrays.asList(fullChain));
+        }
         tm.checkServerTrusted(chain, "RSA");
     }
+
     private void assertInvalid(X509Certificate[] chain, X509TrustManager tm) {
         try {
             tm.checkClientTrusted(chain, "RSA");
@@ -89,4 +184,15 @@ public class TrustManagerImplTest extends TestCase {
         } catch (CertificateException expected) {
         }
     }
+
+    private void assertInvalidPinned(X509Certificate[] chain, X509TrustManager tm, String hostname)
+                                     throws Exception {
+        assertTrue(tm.getClass().getName(), tm instanceof TrustManagerImpl);
+        try {
+            TrustManagerImpl tmi = (TrustManagerImpl) tm;
+            tmi.checkServerTrusted(chain, "RSA", hostname);
+            fail();
+        } catch (CertificateException expected) {
+        }
+    }
 }
-- 
cgit v1.1


From e88bbba97a2a68287b93fecba822d11f272325b7 Mon Sep 17 00:00:00 2001
From: Geremy Condra <gcondra@google.com>
Date: Tue, 11 Sep 2012 19:35:09 -0700
Subject: Added event logging to PinListEntry.

This is done by adding a stub EventLogger that writes to the
usual logs if not overriden by the framework. If it has been
then we will wind up writing the code + Objects to the event
log.

cherry-picked from 52dc295e93679baa72f95b5b873dd21d5a2ccb32

Change-Id: I2c887c233d019910c9b018c4639a36c0808efc02
---
 luni/src/main/java/libcore/io/EventLogger.java     | 69 ++++++++++++++++++++++
 .../harmony/xnet/provider/jsse/PinListEntry.java   | 12 ++--
 2 files changed, 77 insertions(+), 4 deletions(-)
 create mode 100644 luni/src/main/java/libcore/io/EventLogger.java

diff --git a/luni/src/main/java/libcore/io/EventLogger.java b/luni/src/main/java/libcore/io/EventLogger.java
new file mode 100644
index 0000000..9709cc9
--- /dev/null
+++ b/luni/src/main/java/libcore/io/EventLogger.java
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed 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 libcore.io;
+
+public final class EventLogger {
+
+    /**
+     * Hook for customizing how events are reported.
+     */
+    private static volatile Reporter REPORTER = new DefaultReporter();
+
+    /**
+     * Used to replace default Reporter for logging events. Must be non-null.
+     */
+    public static void setReporter(Reporter reporter) {
+        if (reporter == null) {
+            throw new NullPointerException("reporter == null");
+        }
+        REPORTER = reporter;
+    }
+
+    /**
+     * Returns non-null Reporter.
+     */
+    public static Reporter getReporter() {
+        return REPORTER;
+    }
+
+    /**
+     * Interface to allow customization of reporting behavior.
+     */
+    public static interface Reporter {
+        public void report (int code, Object... list);
+    }
+
+    /**
+     * Default Reporter which reports events to the log.
+     */
+    private static final class DefaultReporter implements Reporter {
+        @Override
+        public void report (int code, Object... list) {
+            StringBuilder sb = new StringBuilder();
+            sb.append(code);
+            for (Object o : list) {
+                sb.append(",");
+                sb.append(o.toString());
+            }
+            System.out.println(sb);
+        }
+    }
+
+    public static void writeEvent(int code, Object... list) {
+        getReporter().report(code, list);
+    }
+}
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/PinListEntry.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/PinListEntry.java
index adb0cbd..cefa3ef 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/PinListEntry.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/PinListEntry.java
@@ -25,6 +25,7 @@ import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
+import libcore.io.EventLogger;
 
 /**
  * This class represents a single entry in the pin file.
@@ -96,7 +97,7 @@ class PinListEntry {
                 return false;
             }
         }
-        log("Received unpinned chain for " + cn);
+        logPinFailure(cn, chain);
         return enforcing;
     }
 
@@ -131,10 +132,13 @@ class PinListEntry {
         }
     }
 
-    private static void log(String s) {
-        if (DEBUG) {
-            System.out.println("PINENTRY: " + s);
+    private void logPinFailure(String cn, List<X509Certificate> chain) {
+        Object[] values = new Object[chain.size() + 1];
+        values[0] = (Object) cn;
+        for (int i=0; i < chain.size(); i++) {
+            values[i+1] = chain.get(i).toString();
         }
+        EventLogger.writeEvent(90100, values);
     }
 }
 
-- 
cgit v1.1


From 86acc043d3334651ee26c65467d78d6cefedd397 Mon Sep 17 00:00:00 2001
From: Kenny Root <kroot@google.com>
Date: Wed, 12 Sep 2012 10:32:58 -0700
Subject: Add consistent reasons for NullPointerException

Semi-automated replacement of empty and non-conforming
NullPointerException reason messages.

Change-Id: Iedeb4b21949e973c4042ce5982dda315f2e785e1
---
 .../java/java/beans/PropertyChangeSupport.java     |  2 +-
 luni/src/main/java/java/io/BufferedWriter.java     | 22 +++++-----
 luni/src/main/java/java/io/File.java               |  2 +-
 luni/src/main/java/java/io/InputStreamReader.java  |  2 +-
 luni/src/main/java/java/io/ObjectInputStream.java  |  2 +-
 luni/src/main/java/java/io/ObjectStreamField.java  | 14 ++++---
 luni/src/main/java/java/io/OutputStreamWriter.java |  2 +-
 luni/src/main/java/java/io/PipedOutputStream.java  |  2 +-
 luni/src/main/java/java/io/PipedWriter.java        |  2 +-
 luni/src/main/java/java/io/PrintStream.java        | 42 ++++++++++---------
 luni/src/main/java/java/io/Reader.java             |  2 +-
 .../src/main/java/java/io/SequenceInputStream.java |  6 +--
 luni/src/main/java/java/io/StreamTokenizer.java    |  4 +-
 .../main/java/java/io/StringBufferInputStream.java |  2 +-
 luni/src/main/java/java/io/Writer.java             |  2 +-
 .../main/java/java/lang/AbstractStringBuilder.java |  2 +-
 luni/src/main/java/java/lang/Character.java        | 20 ++++-----
 luni/src/main/java/java/lang/ClassLoader.java      |  2 +-
 luni/src/main/java/java/lang/Enum.java             |  6 ++-
 luni/src/main/java/java/lang/ProcessBuilder.java   |  4 +-
 luni/src/main/java/java/lang/ProcessManager.java   | 16 ++++----
 luni/src/main/java/java/lang/Runtime.java          | 18 ++++----
 .../src/main/java/java/lang/StackTraceElement.java |  6 ++-
 luni/src/main/java/java/lang/String.java           | 10 ++---
 luni/src/main/java/java/lang/StringBuilder.java    |  6 +--
 luni/src/main/java/java/lang/System.java           |  4 +-
 luni/src/main/java/java/lang/Thread.java           | 12 +++---
 luni/src/main/java/java/lang/Throwable.java        | 10 ++---
 .../java/java/lang/reflect/GenericArrayType.java   |  2 +-
 luni/src/main/java/java/lang/reflect/Proxy.java    |  8 ++--
 luni/src/main/java/java/math/BigDecimal.java       |  8 ++--
 luni/src/main/java/java/math/BigInt.java           |  2 +-
 luni/src/main/java/java/net/CookieStore.java       |  2 +-
 luni/src/main/java/java/net/DatagramSocket.java    |  6 +--
 .../src/main/java/java/net/URISyntaxException.java | 12 ++++--
 luni/src/main/java/java/net/URLClassLoader.java    |  2 +-
 .../main/java/java/nio/DatagramChannelImpl.java    |  2 +-
 luni/src/main/java/java/nio/SocketChannelImpl.java |  2 +-
 luni/src/main/java/java/nio/channels/Channels.java | 12 +++---
 .../java/security/AlgorithmParameterGenerator.java |  4 +-
 .../java/java/security/AlgorithmParameters.java    |  8 ++--
 luni/src/main/java/java/security/KeyFactory.java   |  4 +-
 .../main/java/java/security/KeyPairGenerator.java  |  4 +-
 luni/src/main/java/java/security/KeyStore.java     |  4 +-
 .../src/main/java/java/security/MessageDigest.java |  6 +--
 luni/src/main/java/java/security/Provider.java     | 23 +++++++----
 luni/src/main/java/java/security/SecureRandom.java |  4 +-
 luni/src/main/java/java/security/Security.java     |  4 +-
 luni/src/main/java/java/security/Signature.java    |  6 +--
 luni/src/main/java/java/security/Signer.java       |  2 +-
 .../java/java/security/cert/CertPathBuilder.java   |  8 ++--
 .../java/java/security/cert/CertPathValidator.java |  4 +-
 .../main/java/java/security/cert/CertStore.java    |  8 ++--
 .../java/security/cert/CertificateFactory.java     |  8 ++--
 .../cert/CollectionCertStoreParameters.java        |  6 +--
 .../security/cert/LDAPCertStoreParameters.java     | 12 +++---
 .../security/cert/PKIXCertPathBuilderResult.java   |  4 +-
 luni/src/main/java/java/security/cert/X509CRL.java |  2 +-
 .../java/security/spec/ECGenParameterSpec.java     |  2 +-
 luni/src/main/java/java/sql/DriverManager.java     |  2 +-
 luni/src/main/java/java/text/AttributedString.java |  8 ++--
 luni/src/main/java/java/text/Collator.java         |  2 +-
 .../src/main/java/java/text/DateFormatSymbols.java |  6 +--
 luni/src/main/java/java/text/DecimalFormat.java    |  4 +-
 .../main/java/java/text/DecimalFormatSymbols.java  |  6 +--
 luni/src/main/java/java/text/MessageFormat.java    |  2 +-
 luni/src/main/java/java/text/NumberFormat.java     |  2 +-
 .../src/main/java/java/text/RuleBasedCollator.java | 12 +++---
 luni/src/main/java/java/text/SimpleDateFormat.java |  2 +-
 luni/src/main/java/java/util/AbstractQueue.java    |  4 +-
 luni/src/main/java/java/util/ArrayDeque.java       |  4 +-
 luni/src/main/java/java/util/Arrays.java           |  4 +-
 luni/src/main/java/java/util/Calendar.java         |  2 +-
 luni/src/main/java/java/util/Collections.java      | 46 ++++++++++++---------
 .../java/util/DuplicateFormatFlagsException.java   |  2 +-
 luni/src/main/java/java/util/EnumMap.java          |  2 +-
 .../FormatFlagsConversionMismatchException.java    |  2 +-
 luni/src/main/java/java/util/Formatter.java        |  2 +-
 luni/src/main/java/java/util/Hashtable.java        | 16 +++++---
 .../util/IllegalFormatConversionException.java     |  2 +-
 .../java/util/IllegalFormatFlagsException.java     |  2 +-
 .../main/java/java/util/ListResourceBundle.java    |  2 +-
 .../java/util/MissingFormatArgumentException.java  |  2 +-
 .../java/util/MissingFormatWidthException.java     |  2 +-
 luni/src/main/java/java/util/Observable.java       |  2 +-
 luni/src/main/java/java/util/PriorityQueue.java    |  4 +-
 luni/src/main/java/java/util/Properties.java       | 12 +++---
 .../java/java/util/PropertyResourceBundle.java     |  2 +-
 luni/src/main/java/java/util/ResourceBundle.java   | 48 ++++++++++++++--------
 luni/src/main/java/java/util/Scanner.java          |  6 +--
 luni/src/main/java/java/util/ServiceLoader.java    |  2 +-
 luni/src/main/java/java/util/StringTokenizer.java  | 18 ++++----
 luni/src/main/java/java/util/TimeZone.java         |  2 +-
 luni/src/main/java/java/util/Timer.java            |  2 +-
 luni/src/main/java/java/util/UUID.java             |  4 +-
 .../util/UnknownFormatConversionException.java     |  2 +-
 .../java/util/UnknownFormatFlagsException.java     |  2 +-
 .../main/java/java/util/jar/JarOutputStream.java   | 12 +++---
 .../main/java/java/util/logging/FileHandler.java   |  6 ++-
 luni/src/main/java/java/util/logging/Handler.java  | 16 ++++----
 .../main/java/java/util/logging/LogManager.java    |  2 +-
 .../main/java/java/util/logging/StreamHandler.java |  2 +-
 .../java/java/util/prefs/AbstractPreferences.java  | 18 ++++----
 .../java/java/util/zip/DeflaterInputStream.java    |  6 ++-
 .../java/java/util/zip/DeflaterOutputStream.java   |  6 ++-
 .../java/java/util/zip/InflaterInputStream.java    |  6 ++-
 .../java/java/util/zip/InflaterOutputStream.java   |  6 ++-
 luni/src/main/java/java/util/zip/ZipEntry.java     |  2 +-
 luni/src/main/java/java/util/zip/ZipFile.java      |  2 +-
 .../main/java/java/util/zip/ZipInputStream.java    |  2 +-
 luni/src/main/java/javax/crypto/Cipher.java        |  8 ++--
 .../main/java/javax/crypto/CipherInputStream.java  |  2 +-
 .../java/javax/crypto/EncryptedPrivateKeyInfo.java | 10 ++---
 .../main/java/javax/crypto/ExemptionMechanism.java |  6 +--
 luni/src/main/java/javax/crypto/KeyAgreement.java  |  4 +-
 luni/src/main/java/javax/crypto/KeyGenerator.java  |  4 +-
 luni/src/main/java/javax/crypto/Mac.java           |  4 +-
 .../main/java/javax/crypto/SecretKeyFactory.java   |  4 +-
 .../main/java/javax/crypto/spec/DESedeKeySpec.java |  4 +-
 .../java/javax/crypto/spec/OAEPParameterSpec.java  |  8 +++-
 luni/src/main/java/javax/crypto/spec/PSource.java  |  4 +-
 .../main/java/javax/net/ssl/KeyManagerFactory.java |  4 +-
 luni/src/main/java/javax/net/ssl/SSLContext.java   |  4 +-
 .../java/javax/net/ssl/TrustManagerFactory.java    |  4 +-
 .../src/main/java/javax/security/auth/Subject.java | 18 ++++----
 .../javax/security/auth/x500/X500Principal.java    |  4 +-
 .../java/javax/xml/datatype/DatatypeFactory.java   |  4 +-
 .../src/main/java/javax/xml/datatype/Duration.java |  6 +--
 .../java/javax/xml/validation/SchemaFactory.java   | 14 ++++---
 .../javax/xml/validation/SchemaFactoryFinder.java  |  4 +-
 .../main/java/javax/xml/validation/Validator.java  | 16 ++++++--
 .../javax/xml/validation/ValidatorHandler.java     | 20 +++++----
 .../main/java/javax/xml/xpath/XPathException.java  |  8 ++--
 .../main/java/javax/xml/xpath/XPathFactory.java    |  8 +---
 .../java/javax/xml/xpath/XPathFactoryFinder.java   |  4 +-
 luni/src/main/java/libcore/icu/NativeIDN.java      |  2 +-
 .../java/libcore/icu/RuleBasedCollatorICU.java     |  2 +-
 .../src/main/java/libcore/io/StrictLineReader.java |  6 ++-
 luni/src/main/java/libcore/net/UriCodec.java       |  2 +-
 luni/src/main/java/libcore/util/BasicLruCache.java |  8 ++--
 .../harmony/crypto/internal/NullCipherSpi.java     |  6 ++-
 .../org/apache/harmony/security/SystemScope.java   |  2 +-
 .../security/provider/cert/X509CRLImpl.java        |  2 +-
 .../provider/crypto/SHA1withDSA_SignatureImpl.java |  2 +-
 .../org/apache/harmony/xml/ExpatAttributes.java    | 16 ++++----
 .../java/org/apache/harmony/xml/dom/NodeImpl.java  |  4 +-
 .../xml/parsers/DocumentBuilderFactoryImpl.java    |  4 +-
 .../harmony/xml/parsers/SAXParserFactoryImpl.java  |  4 +-
 .../xnet/provider/jsse/FileClientSessionCache.java |  4 +-
 149 files changed, 530 insertions(+), 447 deletions(-)

diff --git a/luni/src/main/java/java/beans/PropertyChangeSupport.java b/luni/src/main/java/java/beans/PropertyChangeSupport.java
index 04f8155..1db12b7 100644
--- a/luni/src/main/java/java/beans/PropertyChangeSupport.java
+++ b/luni/src/main/java/java/beans/PropertyChangeSupport.java
@@ -66,7 +66,7 @@ public class PropertyChangeSupport implements Serializable {
      */
     public PropertyChangeSupport(Object sourceBean) {
         if (sourceBean == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("sourceBean == null");
         }
         this.sourceBean = sourceBean;
     }
diff --git a/luni/src/main/java/java/io/BufferedWriter.java b/luni/src/main/java/java/io/BufferedWriter.java
index e4cbe7c..55ae121 100644
--- a/luni/src/main/java/java/io/BufferedWriter.java
+++ b/luni/src/main/java/java/io/BufferedWriter.java
@@ -163,33 +163,33 @@ public class BufferedWriter extends Writer {
 
     /**
      * Writes {@code count} characters starting at {@code offset} in
-     * {@code cbuf} to this writer. If {@code count} is greater than this
+     * {@code buffer} to this writer. If {@code count} is greater than this
      * writer's buffer, then the buffer is flushed and the characters are
      * written directly to the target writer.
      *
-     * @param cbuf
+     * @param buffer
      *            the array containing characters to write.
      * @param offset
-     *            the start position in {@code cbuf} for retrieving characters.
+     *            the start position in {@code buffer} for retrieving characters.
      * @param count
      *            the maximum number of characters to write.
      * @throws IndexOutOfBoundsException
      *             if {@code offset < 0} or {@code count < 0}, or if
      *             {@code offset + count} is greater than the size of
-     *             {@code cbuf}.
+     *             {@code buffer}.
      * @throws IOException
      *             if this writer is closed or another I/O error occurs.
      */
     @Override
-    public void write(char[] cbuf, int offset, int count) throws IOException {
+    public void write(char[] buffer, int offset, int count) throws IOException {
         synchronized (lock) {
             checkNotClosed();
-            if (cbuf == null) {
+            if (buffer == null) {
                 throw new NullPointerException("buffer == null");
             }
-            Arrays.checkOffsetAndCount(cbuf.length, offset, count);
+            Arrays.checkOffsetAndCount(buffer.length, offset, count);
             if (pos == 0 && count >= this.buf.length) {
-                out.write(cbuf, offset, count);
+                out.write(buffer, offset, count);
                 return;
             }
             int available = this.buf.length - pos;
@@ -197,7 +197,7 @@ public class BufferedWriter extends Writer {
                 available = count;
             }
             if (available > 0) {
-                System.arraycopy(cbuf, offset, this.buf, pos, available);
+                System.arraycopy(buffer, offset, this.buf, pos, available);
                 pos += available;
             }
             if (pos == this.buf.length) {
@@ -207,11 +207,11 @@ public class BufferedWriter extends Writer {
                     offset += available;
                     available = count - available;
                     if (available >= this.buf.length) {
-                        out.write(cbuf, offset, available);
+                        out.write(buffer, offset, available);
                         return;
                     }
 
-                    System.arraycopy(cbuf, offset, this.buf, pos, available);
+                    System.arraycopy(buffer, offset, this.buf, pos, available);
                     pos += available;
                 }
             }
diff --git a/luni/src/main/java/java/io/File.java b/luni/src/main/java/java/io/File.java
index ac67e7c..ec87fed 100644
--- a/luni/src/main/java/java/io/File.java
+++ b/luni/src/main/java/java/io/File.java
@@ -147,7 +147,7 @@ public class File implements Serializable, Comparable<File> {
      */
     public File(String dirPath, String name) {
         if (name == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("name == null");
         }
         if (dirPath == null || dirPath.isEmpty()) {
             this.path = fixSlashes(name);
diff --git a/luni/src/main/java/java/io/InputStreamReader.java b/luni/src/main/java/java/io/InputStreamReader.java
index 59be9ed..2e9b381 100644
--- a/luni/src/main/java/java/io/InputStreamReader.java
+++ b/luni/src/main/java/java/io/InputStreamReader.java
@@ -78,7 +78,7 @@ public class InputStreamReader extends Reader {
             throws UnsupportedEncodingException {
         super(in);
         if (enc == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("enc == null");
         }
         this.in = in;
         try {
diff --git a/luni/src/main/java/java/io/ObjectInputStream.java b/luni/src/main/java/java/io/ObjectInputStream.java
index 0d75a44..0476901 100644
--- a/luni/src/main/java/java/io/ObjectInputStream.java
+++ b/luni/src/main/java/java/io/ObjectInputStream.java
@@ -2344,7 +2344,7 @@ public class ObjectInputStream extends InputStream implements ObjectInput, Objec
     public int skipBytes(int length) throws IOException {
         // To be used with available. Ok to call if reading primitive buffer
         if (input == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("source stream is null");
         }
 
         int offset = 0;
diff --git a/luni/src/main/java/java/io/ObjectStreamField.java b/luni/src/main/java/java/io/ObjectStreamField.java
index db450e0..78a6903 100644
--- a/luni/src/main/java/java/io/ObjectStreamField.java
+++ b/luni/src/main/java/java/io/ObjectStreamField.java
@@ -58,8 +58,10 @@ public class ObjectStreamField implements Comparable<Object> {
      *             if {@code name} or {@code cl} is {@code null}.
      */
     public ObjectStreamField(String name, Class<?> cl) {
-        if (name == null || cl == null) {
-            throw new NullPointerException();
+        if (name == null) {
+            throw new NullPointerException("name == null");
+        } else if (cl == null) {
+            throw new NullPointerException("cl == null");
         }
         this.name = name;
         this.type = new WeakReference<Class<?>>(cl);
@@ -81,8 +83,10 @@ public class ObjectStreamField implements Comparable<Object> {
      * @see ObjectOutputStream#writeUnshared(Object)
      */
     public ObjectStreamField(String name, Class<?> cl, boolean unshared) {
-        if (name == null || cl == null) {
-            throw new NullPointerException();
+        if (name == null) {
+            throw new NullPointerException("name == null");
+        } else if (cl == null) {
+            throw new NullPointerException("cl == null");
         }
         this.name = name;
         this.type = (cl.getClassLoader() == null) ? cl : new WeakReference<Class<?>>(cl);
@@ -100,7 +104,7 @@ public class ObjectStreamField implements Comparable<Object> {
      */
     ObjectStreamField(String signature, String name) {
         if (name == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("name == null");
         }
         this.name = name;
         this.typeString = signature.replace('.', '/').intern();
diff --git a/luni/src/main/java/java/io/OutputStreamWriter.java b/luni/src/main/java/java/io/OutputStreamWriter.java
index 86b62fc..c09c9e3 100644
--- a/luni/src/main/java/java/io/OutputStreamWriter.java
+++ b/luni/src/main/java/java/io/OutputStreamWriter.java
@@ -74,7 +74,7 @@ public class OutputStreamWriter extends Writer {
             throws UnsupportedEncodingException {
         super(out);
         if (enc == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("enc == null");
         }
         this.out = out;
         try {
diff --git a/luni/src/main/java/java/io/PipedOutputStream.java b/luni/src/main/java/java/io/PipedOutputStream.java
index a674bb3..1b139e9 100644
--- a/luni/src/main/java/java/io/PipedOutputStream.java
+++ b/luni/src/main/java/java/io/PipedOutputStream.java
@@ -81,7 +81,7 @@ public class PipedOutputStream extends OutputStream {
      */
     public void connect(PipedInputStream stream) throws IOException {
         if (stream == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("stream == null");
         }
         synchronized (stream) {
             if (this.target != null) {
diff --git a/luni/src/main/java/java/io/PipedWriter.java b/luni/src/main/java/java/io/PipedWriter.java
index ece899a..ad8974b 100644
--- a/luni/src/main/java/java/io/PipedWriter.java
+++ b/luni/src/main/java/java/io/PipedWriter.java
@@ -85,7 +85,7 @@ public class PipedWriter extends Writer {
      */
     public void connect(PipedReader reader) throws IOException {
         if (reader == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("reader == null");
         }
         synchronized (reader) {
             if (this.destination != null) {
diff --git a/luni/src/main/java/java/io/PrintStream.java b/luni/src/main/java/java/io/PrintStream.java
index ba48b04..ea67d46 100644
--- a/luni/src/main/java/java/io/PrintStream.java
+++ b/luni/src/main/java/java/io/PrintStream.java
@@ -59,7 +59,7 @@ public class PrintStream extends FilterOutputStream implements Appendable, Close
     public PrintStream(OutputStream out) {
         super(out);
         if (out == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("out == null");
         }
     }
 
@@ -80,7 +80,7 @@ public class PrintStream extends FilterOutputStream implements Appendable, Close
     public PrintStream(OutputStream out, boolean autoFlush) {
         super(out);
         if (out == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("out == null");
         }
         this.autoFlush = autoFlush;
     }
@@ -106,8 +106,10 @@ public class PrintStream extends FilterOutputStream implements Appendable, Close
     public PrintStream(OutputStream out, boolean autoFlush, String enc)
             throws UnsupportedEncodingException {
         super(out);
-        if (out == null || enc == null) {
-            throw new NullPointerException();
+        if (out == null) {
+            throw new NullPointerException("out == null");
+        } else if (enc == null) {
+            throw new NullPointerException("enc == null");
         }
         this.autoFlush = autoFlush;
         try {
@@ -136,30 +138,30 @@ public class PrintStream extends FilterOutputStream implements Appendable, Close
 
     /**
      * Constructs a new {@code PrintStream} with {@code file} as its target. The
-     * character set named {@code csn} is used for character encoding.
+     * character set named {@code charSetName} is used for character encoding.
      *
      * @param file
      *            the target file. If the file already exists, its contents are
      *            removed, otherwise a new file is created.
-     * @param csn
+     * @param charSetName
      *            the name of the character set used for character encoding.
      * @throws FileNotFoundException
      *             if an error occurs while opening or creating the target file.
      * @throws NullPointerException
-     *             if {@code csn} is {@code null}.
+     *             if {@code charSetName} is {@code null}.
      * @throws UnsupportedEncodingException
-     *             if the encoding specified by {@code csn} is not supported.
+     *             if the encoding specified by {@code charSetName} is not supported.
      */
-    public PrintStream(File file, String csn) throws FileNotFoundException,
+    public PrintStream(File file, String charSetName) throws FileNotFoundException,
             UnsupportedEncodingException {
         super(new FileOutputStream(file));
-        if (csn == null) {
-            throw new NullPointerException();
+        if (charSetName == null) {
+            throw new NullPointerException("charSetName == null");
         }
-        if (!Charset.isSupported(csn)) {
-            throw new UnsupportedEncodingException(csn);
+        if (!Charset.isSupported(charSetName)) {
+            throw new UnsupportedEncodingException(charSetName);
         }
-        encoding = csn;
+        encoding = charSetName;
     }
 
     /**
@@ -179,24 +181,24 @@ public class PrintStream extends FilterOutputStream implements Appendable, Close
 
     /**
      * Constructs a new {@code PrintStream} with the file identified by
-     * {@code fileName} as its target. The character set named {@code csn} is
+     * {@code fileName} as its target. The character set named {@code charSetName} is
      * used for character encoding.
      *
      * @param fileName
      *            the target file's name. If the file already exists, its
      *            contents are removed, otherwise a new file is created.
-     * @param csn
+     * @param charSetName
      *            the name of the character set used for character encoding.
      * @throws FileNotFoundException
      *             if an error occurs while opening or creating the target file.
      * @throws NullPointerException
-     *             if {@code csn} is {@code null}.
+     *             if {@code charSetName} is {@code null}.
      * @throws UnsupportedEncodingException
-     *             if the encoding specified by {@code csn} is not supported.
+     *             if the encoding specified by {@code charSetName} is not supported.
      */
-    public PrintStream(String fileName, String csn)
+    public PrintStream(String fileName, String charSetName)
             throws FileNotFoundException, UnsupportedEncodingException {
-        this(new File(fileName), csn);
+        this(new File(fileName), charSetName);
     }
 
     /**
diff --git a/luni/src/main/java/java/io/Reader.java b/luni/src/main/java/java/io/Reader.java
index 310a57c..e947d08 100644
--- a/luni/src/main/java/java/io/Reader.java
+++ b/luni/src/main/java/java/io/Reader.java
@@ -61,7 +61,7 @@ public abstract class Reader implements Readable, Closeable {
      */
     protected Reader(Object lock) {
         if (lock == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("lock == null");
         }
         this.lock = lock;
     }
diff --git a/luni/src/main/java/java/io/SequenceInputStream.java b/luni/src/main/java/java/io/SequenceInputStream.java
index 9ae1901..8333834 100644
--- a/luni/src/main/java/java/io/SequenceInputStream.java
+++ b/luni/src/main/java/java/io/SequenceInputStream.java
@@ -50,7 +50,7 @@ public class SequenceInputStream extends InputStream {
      */
     public SequenceInputStream(InputStream s1, InputStream s2) {
         if (s1 == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("s1 == null");
         }
         Vector<InputStream> inVector = new Vector<InputStream>(1);
         inVector.addElement(s2);
@@ -73,7 +73,7 @@ public class SequenceInputStream extends InputStream {
         if (e.hasMoreElements()) {
             in = e.nextElement();
             if (in == null) {
-                throw new NullPointerException();
+                throw new NullPointerException("element is null");
             }
         }
     }
@@ -112,7 +112,7 @@ public class SequenceInputStream extends InputStream {
         if (e.hasMoreElements()) {
             in = e.nextElement();
             if (in == null) {
-                throw new NullPointerException();
+                throw new NullPointerException("element is null");
             }
         } else {
             in = null;
diff --git a/luni/src/main/java/java/io/StreamTokenizer.java b/luni/src/main/java/java/io/StreamTokenizer.java
index 0522be6..a16dc4b 100644
--- a/luni/src/main/java/java/io/StreamTokenizer.java
+++ b/luni/src/main/java/java/io/StreamTokenizer.java
@@ -167,7 +167,7 @@ public class StreamTokenizer {
     public StreamTokenizer(InputStream is) {
         this();
         if (is == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("is == null");
         }
         inStream = is;
     }
@@ -194,7 +194,7 @@ public class StreamTokenizer {
     public StreamTokenizer(Reader r) {
         this();
         if (r == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("r == null");
         }
         inReader = r;
     }
diff --git a/luni/src/main/java/java/io/StringBufferInputStream.java b/luni/src/main/java/java/io/StringBufferInputStream.java
index 1fada57..1768abe 100644
--- a/luni/src/main/java/java/io/StringBufferInputStream.java
+++ b/luni/src/main/java/java/io/StringBufferInputStream.java
@@ -54,7 +54,7 @@ public class StringBufferInputStream extends InputStream {
      */
     public StringBufferInputStream(String str) {
         if (str == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("str == null");
         }
         buffer = str;
         count = str.length();
diff --git a/luni/src/main/java/java/io/Writer.java b/luni/src/main/java/java/io/Writer.java
index 2e28b80..33d7604 100644
--- a/luni/src/main/java/java/io/Writer.java
+++ b/luni/src/main/java/java/io/Writer.java
@@ -59,7 +59,7 @@ public abstract class Writer implements Appendable, Closeable, Flushable {
      */
     protected Writer(Object lock) {
         if (lock == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("lock == null");
         }
         this.lock = lock;
     }
diff --git a/luni/src/main/java/java/lang/AbstractStringBuilder.java b/luni/src/main/java/java/lang/AbstractStringBuilder.java
index 6e46d26..c3107f2 100644
--- a/luni/src/main/java/java/lang/AbstractStringBuilder.java
+++ b/luni/src/main/java/java/lang/AbstractStringBuilder.java
@@ -437,7 +437,7 @@ abstract class AbstractStringBuilder {
             }
             if (start == end) {
                 if (string == null) {
-                    throw new NullPointerException();
+                    throw new NullPointerException("string == null");
                 }
                 insert0(start, string);
                 return;
diff --git a/luni/src/main/java/java/lang/Character.java b/luni/src/main/java/java/lang/Character.java
index 1a41ec2..cf0ab84 100644
--- a/luni/src/main/java/java/lang/Character.java
+++ b/luni/src/main/java/java/lang/Character.java
@@ -532,7 +532,7 @@ public final class Character implements Serializable, Comparable<Character> {
          */
         protected Subset(String string) {
             if (string == null) {
-                throw new NullPointerException();
+                throw new NullPointerException("string == null");
             }
             name = string;
         }
@@ -1502,7 +1502,7 @@ public final class Character implements Serializable, Comparable<Character> {
          */
         public static UnicodeBlock forName(String blockName) {
             if (blockName == null) {
-                throw new NullPointerException();
+                throw new NullPointerException("blockName == null");
             }
             int block = forNameImpl(blockName);
             if (block == -1) {
@@ -1798,7 +1798,7 @@ public final class Character implements Serializable, Comparable<Character> {
      */
     public static int codePointAt(CharSequence seq, int index) {
         if (seq == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("seq == null");
         }
         int len = seq.length();
         if (index < 0 || index >= len) {
@@ -1840,7 +1840,7 @@ public final class Character implements Serializable, Comparable<Character> {
      */
     public static int codePointAt(char[] seq, int index) {
         if (seq == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("seq == null");
         }
         int len = seq.length;
         if (index < 0 || index >= len) {
@@ -1923,7 +1923,7 @@ public final class Character implements Serializable, Comparable<Character> {
      */
     public static int codePointBefore(CharSequence seq, int index) {
         if (seq == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("seq == null");
         }
         int len = seq.length();
         if (index < 1 || index > len) {
@@ -1965,7 +1965,7 @@ public final class Character implements Serializable, Comparable<Character> {
      */
     public static int codePointBefore(char[] seq, int index) {
         if (seq == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("seq == null");
         }
         int len = seq.length;
         if (index < 1 || index > len) {
@@ -2012,7 +2012,7 @@ public final class Character implements Serializable, Comparable<Character> {
      */
     public static int codePointBefore(char[] seq, int index, int start) {
         if (seq == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("seq == null");
         }
         int len = seq.length;
         if (index <= start || index > len || start < 0 || start >= len) {
@@ -2055,7 +2055,7 @@ public final class Character implements Serializable, Comparable<Character> {
     public static int toChars(int codePoint, char[] dst, int dstIndex) {
         checkValidCodePoint(codePoint);
         if (dst == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("dst == null");
         }
         if (dstIndex < 0 || dstIndex >= dst.length) {
             throw new IndexOutOfBoundsException();
@@ -2126,7 +2126,7 @@ public final class Character implements Serializable, Comparable<Character> {
     public static int codePointCount(CharSequence seq, int beginIndex,
             int endIndex) {
         if (seq == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("seq == null");
         }
         int len = seq.length();
         if (beginIndex < 0 || endIndex > len || beginIndex > endIndex) {
@@ -2215,7 +2215,7 @@ public final class Character implements Serializable, Comparable<Character> {
      */
     public static int offsetByCodePoints(CharSequence seq, int index, int codePointOffset) {
         if (seq == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("seq == null");
         }
         int len = seq.length();
         if (index < 0 || index > len) {
diff --git a/luni/src/main/java/java/lang/ClassLoader.java b/luni/src/main/java/java/lang/ClassLoader.java
index 0cdc448..c99d57c 100644
--- a/luni/src/main/java/java/lang/ClassLoader.java
+++ b/luni/src/main/java/java/lang/ClassLoader.java
@@ -195,7 +195,7 @@ public abstract class ClassLoader {
      */
     ClassLoader(ClassLoader parentLoader, boolean nullAllowed) {
         if (parentLoader == null && !nullAllowed) {
-            throw new NullPointerException("Parent ClassLoader may not be null");
+            throw new NullPointerException("parentLoader == null && !nullAllowed");
         }
         parent = parentLoader;
     }
diff --git a/luni/src/main/java/java/lang/Enum.java b/luni/src/main/java/java/lang/Enum.java
index 3d9e68b..7a0f514 100644
--- a/luni/src/main/java/java/lang/Enum.java
+++ b/luni/src/main/java/java/lang/Enum.java
@@ -181,8 +181,10 @@ public abstract class Enum<E extends Enum<E>> implements Serializable, Comparabl
      *             have a constant value called {@code name}.
      */
     public static <T extends Enum<T>> T valueOf(Class<T> enumType, String name) {
-        if (enumType == null || name == null) {
-            throw new NullPointerException("enumType == null || name == null");
+        if (enumType == null) {
+            throw new NullPointerException("enumType == null");
+        } else if (name == null) {
+            throw new NullPointerException("name == null");
         }
         T[] values = getSharedConstants(enumType);
         if (values == null) {
diff --git a/luni/src/main/java/java/lang/ProcessBuilder.java b/luni/src/main/java/java/lang/ProcessBuilder.java
index 5b7efdc..57e21b6 100644
--- a/luni/src/main/java/java/lang/ProcessBuilder.java
+++ b/luni/src/main/java/java/lang/ProcessBuilder.java
@@ -59,7 +59,7 @@ public final class ProcessBuilder {
      */
     public ProcessBuilder(List<String> command) {
         if (command == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("command == null");
         }
         this.command = command;
 
@@ -102,7 +102,7 @@ public final class ProcessBuilder {
      */
     public ProcessBuilder command(List<String> command) {
         if (command == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("command == null");
         }
         this.command = command;
         return this;
diff --git a/luni/src/main/java/java/lang/ProcessManager.java b/luni/src/main/java/java/lang/ProcessManager.java
index 1e820a9..28314b7 100644
--- a/luni/src/main/java/java/lang/ProcessManager.java
+++ b/luni/src/main/java/java/lang/ProcessManager.java
@@ -168,10 +168,10 @@ final class ProcessManager {
             boolean redirectErrorStream) throws IOException {
         // Make sure we throw the same exceptions as the RI.
         if (taintedCommand == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("taintedCommand == null");
         }
         if (taintedCommand.length == 0) {
-            throw new IndexOutOfBoundsException();
+            throw new IndexOutOfBoundsException("taintedCommand.length == 0");
         }
 
         // Handle security and safety by copying mutable inputs and checking them.
@@ -179,16 +179,16 @@ final class ProcessManager {
         String[] environment = taintedEnvironment != null ? taintedEnvironment.clone() : null;
 
         // Check we're not passing null Strings to the native exec.
-        for (String arg : command) {
-            if (arg == null) {
-                throw new NullPointerException();
+        for (int i = 0; i < command.length; i++) {
+            if (command[i] == null) {
+                throw new NullPointerException("taintedCommand[" + i + "] == null");
             }
         }
         // The environment is allowed to be null or empty, but no element may be null.
         if (environment != null) {
-            for (String env : environment) {
-                if (env == null) {
-                    throw new NullPointerException();
+            for (int i = 0; i < environment.length; i++) {
+                if (environment[i] == null) {
+                    throw new NullPointerException("taintedEnvironment[" + i + "] == null");
                 }
             }
         }
diff --git a/luni/src/main/java/java/lang/Runtime.java b/luni/src/main/java/java/lang/Runtime.java
index efe2303..a2debfd 100644
--- a/luni/src/main/java/java/lang/Runtime.java
+++ b/luni/src/main/java/java/lang/Runtime.java
@@ -224,9 +224,9 @@ public class Runtime {
     public Process exec(String prog, String[] envp, File directory) throws java.io.IOException {
         // Sanity checks
         if (prog == null) {
-            throw new NullPointerException();
-        } else if (prog.length() == 0) {
-            throw new IllegalArgumentException();
+            throw new NullPointerException("prog == null");
+        } else if (prog.isEmpty()) {
+            throw new IllegalArgumentException("prog is empty");
         }
 
         // Break down into tokens, as described in Java docs
@@ -331,11 +331,11 @@ public class Runtime {
     /*
      * Loads and links a library without security checks.
      */
-    void load(String filename, ClassLoader loader) {
-        if (filename == null) {
-            throw new NullPointerException("library path was null.");
+    void load(String pathName, ClassLoader loader) {
+        if (pathName == null) {
+            throw new NullPointerException("pathName == null");
         }
-        String error = nativeLoad(filename, loader);
+        String error = nativeLoad(pathName, loader);
         if (error != null) {
             throw new UnsatisfiedLinkError(error);
         }
@@ -538,7 +538,7 @@ public class Runtime {
     public void addShutdownHook(Thread hook) {
         // Sanity checks
         if (hook == null) {
-            throw new NullPointerException("Hook may not be null.");
+            throw new NullPointerException("hook == null");
         }
 
         if (shuttingDown) {
@@ -571,7 +571,7 @@ public class Runtime {
     public boolean removeShutdownHook(Thread hook) {
         // Sanity checks
         if (hook == null) {
-            throw new NullPointerException("Hook may not be null.");
+            throw new NullPointerException("hook == null");
         }
 
         if (shuttingDown) {
diff --git a/luni/src/main/java/java/lang/StackTraceElement.java b/luni/src/main/java/java/lang/StackTraceElement.java
index b83120c..a59935a 100644
--- a/luni/src/main/java/java/lang/StackTraceElement.java
+++ b/luni/src/main/java/java/lang/StackTraceElement.java
@@ -58,8 +58,10 @@ public final class StackTraceElement implements Serializable {
      *             if {@code cls} or {@code method} is {@code null}.
      */
     public StackTraceElement(String cls, String method, String file, int line) {
-        if (cls == null || method == null) {
-            throw new NullPointerException();
+        if (cls == null) {
+            throw new NullPointerException("cls == null");
+        } else if (method == null) {
+            throw new NullPointerException("method == null");
         }
         declaringClass = cls;
         methodName = method;
diff --git a/luni/src/main/java/java/lang/String.java b/luni/src/main/java/java/lang/String.java
index 224a268..f3aeb64 100644
--- a/luni/src/main/java/java/lang/String.java
+++ b/luni/src/main/java/java/lang/String.java
@@ -514,7 +514,7 @@ outer:
      */
     public String(int[] codePoints, int offset, int count) {
         if (codePoints == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("codePoints == null");
         }
         if ((offset | count) < 0 || count > codePoints.length - offset) {
             throw failedBoundsCheck(codePoints.length, offset, count);
@@ -1222,7 +1222,7 @@ outer:
      */
     public boolean regionMatches(int thisStart, String string, int start, int length) {
         if (string == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("string == null");
         }
         if (start < 0 || string.count - start < length) {
             return false;
@@ -1719,7 +1719,7 @@ outer:
      */
     public boolean contentEquals(CharSequence cs) {
         if (cs == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("cs == null");
         }
 
         int len = cs.length();
@@ -1912,7 +1912,7 @@ outer:
      */
     public boolean contains(CharSequence cs) {
         if (cs == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("cs == null");
         }
         return indexOf(cs.toString()) >= 0;
     }
@@ -1981,7 +1981,7 @@ outer:
      */
     public static String format(Locale locale, String format, Object... args) {
         if (format == null) {
-            throw new NullPointerException("null format argument");
+            throw new NullPointerException("format == null");
         }
         int bufferSize = format.length() + (args == null ? 0 : args.length * 10);
         Formatter f = new Formatter(new StringBuilder(bufferSize), locale);
diff --git a/luni/src/main/java/java/lang/StringBuilder.java b/luni/src/main/java/java/lang/StringBuilder.java
index d886100..a944e68 100644
--- a/luni/src/main/java/java/lang/StringBuilder.java
+++ b/luni/src/main/java/java/lang/StringBuilder.java
@@ -624,7 +624,7 @@ public final class StringBuilder extends AbstractStringBuilder implements
      *            the inclusive begin index.
      * @param end
      *            the exclusive end index.
-     * @param str
+     * @param string
      *            the replacement string.
      * @return this builder.
      * @throws StringIndexOutOfBoundsException
@@ -633,8 +633,8 @@ public final class StringBuilder extends AbstractStringBuilder implements
      * @throws NullPointerException
      *            if {@code str} is {@code null}.
      */
-    public StringBuilder replace(int start, int end, String str) {
-        replace0(start, end, str);
+    public StringBuilder replace(int start, int end, String string) {
+        replace0(start, end, string);
         return this;
     }
 
diff --git a/luni/src/main/java/java/lang/System.java b/luni/src/main/java/java/lang/System.java
index de99161..df84c61 100644
--- a/luni/src/main/java/java/lang/System.java
+++ b/luni/src/main/java/java/lang/System.java
@@ -455,7 +455,7 @@ public final class System {
      */
     public static String clearProperty(String key) {
         if (key == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("key == null");
         }
         if (key.isEmpty()) {
             throw new IllegalArgumentException();
@@ -679,7 +679,7 @@ public final class System {
 
         private String toNonNullString(Object o) {
             if (o == null) {
-                throw new NullPointerException();
+                throw new NullPointerException("o == null");
             }
             return (String) o;
         }
diff --git a/luni/src/main/java/java/lang/Thread.java b/luni/src/main/java/java/lang/Thread.java
index a61f669..210b90c 100644
--- a/luni/src/main/java/java/lang/Thread.java
+++ b/luni/src/main/java/java/lang/Thread.java
@@ -232,7 +232,7 @@ public class Thread implements Runnable {
      */
     public Thread(Runnable runnable, String threadName) {
         if (threadName == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("threadName == null");
         }
 
         create(null, runnable, threadName, 0);
@@ -252,7 +252,7 @@ public class Thread implements Runnable {
      */
     public Thread(String threadName) {
         if (threadName == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("threadName == null");
         }
 
         create(null, null, threadName, 0);
@@ -296,7 +296,7 @@ public class Thread implements Runnable {
      */
     public Thread(ThreadGroup group, Runnable runnable, String threadName) {
         if (threadName == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("threadName == null");
         }
 
         create(group, runnable, threadName, 0);
@@ -317,7 +317,7 @@ public class Thread implements Runnable {
      */
     public Thread(ThreadGroup group, String threadName) {
         if (threadName == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("threadName == null");
         }
 
         create(group, null, threadName, 0);
@@ -346,7 +346,7 @@ public class Thread implements Runnable {
      */
     public Thread(ThreadGroup group, Runnable runnable, String threadName, long stackSize) {
         if (threadName == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("threadName == null");
         }
         create(group, runnable, threadName, stackSize);
     }
@@ -943,7 +943,7 @@ public class Thread implements Runnable {
      */
     public final void setName(String threadName) {
         if (threadName == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("threadName == null");
         }
 
         name = threadName;
diff --git a/luni/src/main/java/java/lang/Throwable.java b/luni/src/main/java/java/lang/Throwable.java
index 31eb538..b20b882 100644
--- a/luni/src/main/java/java/lang/Throwable.java
+++ b/luni/src/main/java/java/lang/Throwable.java
@@ -219,9 +219,9 @@ public class Throwable implements java.io.Serializable {
      */
     public void setStackTrace(StackTraceElement[] trace) {
         StackTraceElement[] newTrace = trace.clone();
-        for (StackTraceElement element : newTrace) {
-            if (element == null) {
-                throw new NullPointerException();
+        for (int i = 0; i < newTrace.length; i++) {
+            if (newTrace[i] == null) {
+                throw new NullPointerException("trace[" + i + "] == null");
             }
         }
         stackTrace = newTrace;
@@ -413,10 +413,10 @@ public class Throwable implements java.io.Serializable {
      */
     public final void addSuppressed(Throwable throwable) {
         if (throwable == this) {
-            throw new IllegalArgumentException("suppressed == this");
+            throw new IllegalArgumentException("throwable == this");
         }
         if (throwable == null) {
-            throw new NullPointerException("suppressed == null");
+            throw new NullPointerException("throwable == null");
         }
         if (suppressedExceptions != null) {
             // suppressed exceptions are enabled
diff --git a/luni/src/main/java/java/lang/reflect/GenericArrayType.java b/luni/src/main/java/java/lang/reflect/GenericArrayType.java
index 6344019..fc03f78 100644
--- a/luni/src/main/java/java/lang/reflect/GenericArrayType.java
+++ b/luni/src/main/java/java/lang/reflect/GenericArrayType.java
@@ -36,4 +36,4 @@ public interface GenericArrayType extends Type {
      *             instantiated for some reason
      */
     Type getGenericComponentType();
-}
\ No newline at end of file
+}
diff --git a/luni/src/main/java/java/lang/reflect/Proxy.java b/luni/src/main/java/java/lang/reflect/Proxy.java
index a24514d..3b10887 100644
--- a/luni/src/main/java/java/lang/reflect/Proxy.java
+++ b/luni/src/main/java/java/lang/reflect/Proxy.java
@@ -89,13 +89,13 @@ public class Proxy implements Serializable {
             Class<?>... interfaces) throws IllegalArgumentException {
         // check that interfaces are a valid array of visible interfaces
         if (interfaces == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("interfaces == null");
         }
         String commonPackageName = null;
         for (int i = 0, length = interfaces.length; i < length; i++) {
             Class<?> next = interfaces[i];
             if (next == null) {
-                throw new NullPointerException();
+                throw new NullPointerException("interfaces[" + i + "] == null");
             }
             String name = next.getName();
             if (!next.isInterface()) {
@@ -206,7 +206,7 @@ public class Proxy implements Serializable {
             Class<?>[] interfaces, InvocationHandler h)
             throws IllegalArgumentException {
         if (h == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("h == null");
         }
         try {
             return getProxyClass(loader, interfaces).getConstructor(
@@ -241,7 +241,7 @@ public class Proxy implements Serializable {
      */
     public static boolean isProxyClass(Class<?> cl) {
         if (cl == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("cl == null");
         }
         synchronized (proxyCache) {
             return proxyCache.containsKey(cl);
diff --git a/luni/src/main/java/java/math/BigDecimal.java b/luni/src/main/java/java/math/BigDecimal.java
index 3a5f3cd..335e3bc 100644
--- a/luni/src/main/java/java/math/BigDecimal.java
+++ b/luni/src/main/java/java/math/BigDecimal.java
@@ -276,7 +276,7 @@ public class BigDecimal extends Number implements Comparable<BigDecimal>, Serial
         long newScale; // the new scale
 
         if (in == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("in == null");
         }
         if ((last >= in.length) || (offset < 0) || (len <= 0) || (last < 0)) {
             throw new NumberFormatException("Bad offset/length: offset=" + offset +
@@ -601,7 +601,7 @@ public class BigDecimal extends Number implements Comparable<BigDecimal>, Serial
      */
     public BigDecimal(BigInteger unscaledVal, int scale) {
         if (unscaledVal == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("unscaledVal == null");
         }
         this.scale = scale;
         setUnscaledValue(unscaledVal);
@@ -1059,7 +1059,7 @@ public class BigDecimal extends Number implements Comparable<BigDecimal>, Serial
     public BigDecimal divide(BigDecimal divisor, int scale, RoundingMode roundingMode) {
         // Let be: this = [u1,s1]  and  divisor = [u2,s2]
         if (roundingMode == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("roundingMode == null");
         }
         if (divisor.isZero()) {
             throw new ArithmeticException("Division by zero");
@@ -1916,7 +1916,7 @@ public class BigDecimal extends Number implements Comparable<BigDecimal>, Serial
      */
     public BigDecimal setScale(int newScale, RoundingMode roundingMode) {
         if (roundingMode == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("roundingMode == null");
         }
         long diffScale = newScale - (long)scale;
         // Let be:  'this' = [u,s]
diff --git a/luni/src/main/java/java/math/BigInt.java b/luni/src/main/java/java/math/BigInt.java
index 1768676..614dbb4 100644
--- a/luni/src/main/java/java/math/BigInt.java
+++ b/luni/src/main/java/java/math/BigInt.java
@@ -153,7 +153,7 @@ final class BigInt {
      */
     String checkString(String s, int base) {
         if (s == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("s == null");
         }
         // A valid big integer consists of an optional '-' or '+' followed by
         // one or more digit characters appropriate to the given base,
diff --git a/luni/src/main/java/java/net/CookieStore.java b/luni/src/main/java/java/net/CookieStore.java
index d09b7e8..619d65c 100644
--- a/luni/src/main/java/java/net/CookieStore.java
+++ b/luni/src/main/java/java/net/CookieStore.java
@@ -100,4 +100,4 @@ public interface CookieStore {
      * @return true if any cookies were removed as a result of this call.
      */
     boolean removeAll();
-}
\ No newline at end of file
+}
diff --git a/luni/src/main/java/java/net/DatagramSocket.java b/luni/src/main/java/java/net/DatagramSocket.java
index 2b468fa..c01f3af 100644
--- a/luni/src/main/java/java/net/DatagramSocket.java
+++ b/luni/src/main/java/java/net/DatagramSocket.java
@@ -244,7 +244,7 @@ public class DatagramSocket {
         checkOpen();
         ensureBound();
         if (pack == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("pack == null");
         }
         if (pendingConnectException != null) {
             throw new SocketException("Pending connect failure", pendingConnectException);
@@ -295,7 +295,7 @@ public class DatagramSocket {
      */
     public void setNetworkInterface(NetworkInterface netInterface) throws SocketException {
         if (netInterface == null) {
-            throw new NullPointerException("networkInterface == null");
+            throw new NullPointerException("netInterface == null");
         }
         try {
             Libcore.os.setsockoptIfreq(impl.fd, SOL_SOCKET, SO_BINDTODEVICE, netInterface.getName());
@@ -374,7 +374,7 @@ public class DatagramSocket {
      */
     protected DatagramSocket(DatagramSocketImpl socketImpl) {
         if (socketImpl == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("socketImpl == null");
         }
         impl = socketImpl;
     }
diff --git a/luni/src/main/java/java/net/URISyntaxException.java b/luni/src/main/java/java/net/URISyntaxException.java
index e08f444..957ea31 100644
--- a/luni/src/main/java/java/net/URISyntaxException.java
+++ b/luni/src/main/java/java/net/URISyntaxException.java
@@ -49,8 +49,10 @@ public class URISyntaxException extends Exception {
     public URISyntaxException(String input, String reason, int index) {
         super(reason);
 
-        if (input == null || reason == null) {
-            throw new NullPointerException();
+        if (input == null) {
+            throw new NullPointerException("input == null");
+        } else if (reason == null) {
+            throw new NullPointerException("reason == null");
         }
 
         if (index < -1) {
@@ -76,8 +78,10 @@ public class URISyntaxException extends Exception {
     public URISyntaxException(String input, String reason) {
         super(reason);
 
-        if (input == null || reason == null) {
-            throw new NullPointerException();
+        if (input == null) {
+            throw new NullPointerException("input == null");
+        } else if (reason == null) {
+            throw new NullPointerException("reason == null");
         }
 
         this.input = input;
diff --git a/luni/src/main/java/java/net/URLClassLoader.java b/luni/src/main/java/java/net/URLClassLoader.java
index 1c8bc43..efb7531 100644
--- a/luni/src/main/java/java/net/URLClassLoader.java
+++ b/luni/src/main/java/java/net/URLClassLoader.java
@@ -822,7 +822,7 @@ public class URLClassLoader extends SecureClassLoader {
         while (!searchList.isEmpty()) {
             URL nextCandidate = searchList.remove(0);
             if (nextCandidate == null) {
-                throw new NullPointerException("A URL is null");
+                throw new NullPointerException("nextCandidate == null");
             }
             if (!handlerMap.containsKey(nextCandidate)) {
                 URLHandler result;
diff --git a/luni/src/main/java/java/nio/DatagramChannelImpl.java b/luni/src/main/java/java/nio/DatagramChannelImpl.java
index a0e064d..4d2fc5a 100644
--- a/luni/src/main/java/java/nio/DatagramChannelImpl.java
+++ b/luni/src/main/java/java/nio/DatagramChannelImpl.java
@@ -448,7 +448,7 @@ class DatagramChannelImpl extends DatagramChannel implements FileDescriptorChann
      */
     private void checkNotNull(ByteBuffer source) {
         if (source == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("source == null");
         }
     }
 
diff --git a/luni/src/main/java/java/nio/SocketChannelImpl.java b/luni/src/main/java/java/nio/SocketChannelImpl.java
index a9d9c53..ff2c157 100644
--- a/luni/src/main/java/java/nio/SocketChannelImpl.java
+++ b/luni/src/main/java/java/nio/SocketChannelImpl.java
@@ -318,7 +318,7 @@ class SocketChannelImpl extends SocketChannel implements FileDescriptorChannel {
     @Override
     public int write(ByteBuffer src) throws IOException {
         if (src == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("src == null");
         }
         checkOpenConnected();
         if (!src.hasRemaining()) {
diff --git a/luni/src/main/java/java/nio/channels/Channels.java b/luni/src/main/java/java/nio/channels/Channels.java
index 3af1465..b59eeac 100644
--- a/luni/src/main/java/java/nio/channels/Channels.java
+++ b/luni/src/main/java/java/nio/channels/Channels.java
@@ -150,7 +150,7 @@ public final class Channels {
     public static Reader newReader(ReadableByteChannel channel,
             String charsetName) {
         if (charsetName == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("charsetName == null");
         }
         return newReader(channel, Charset.forName(charsetName).newDecoder(), -1);
     }
@@ -193,7 +193,7 @@ public final class Channels {
     public static Writer newWriter(WritableByteChannel channel,
             String charsetName) {
         if (charsetName == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("charsetName == null");
         }
         return newWriter(channel, Charset.forName(charsetName).newEncoder(), -1);
     }
@@ -207,7 +207,7 @@ public final class Channels {
 
         ChannelInputStream(ReadableByteChannel channel) {
             if (channel == null) {
-                throw new NullPointerException();
+                throw new NullPointerException("channel == null");
             }
             this.channel = channel;
         }
@@ -247,7 +247,7 @@ public final class Channels {
 
         ChannelOutputStream(WritableByteChannel channel) {
             if (channel == null) {
-                throw new NullPointerException();
+                throw new NullPointerException("channel == null");
             }
             this.channel = channel;
         }
@@ -289,7 +289,7 @@ public final class Channels {
 
         InputStreamChannel(InputStream inputStream) {
             if (inputStream == null) {
-                throw new NullPointerException();
+                throw new NullPointerException("inputStream == null");
             }
             this.inputStream = inputStream;
         }
@@ -328,7 +328,7 @@ public final class Channels {
 
         OutputStreamChannel(OutputStream outputStream) {
             if (outputStream == null) {
-                throw new NullPointerException();
+                throw new NullPointerException("outputStream == null");
             }
             this.outputStream = outputStream;
         }
diff --git a/luni/src/main/java/java/security/AlgorithmParameterGenerator.java b/luni/src/main/java/java/security/AlgorithmParameterGenerator.java
index daefa3c..3edc167 100644
--- a/luni/src/main/java/java/security/AlgorithmParameterGenerator.java
+++ b/luni/src/main/java/java/security/AlgorithmParameterGenerator.java
@@ -88,7 +88,7 @@ public class AlgorithmParameterGenerator {
     public static AlgorithmParameterGenerator getInstance(String algorithm)
             throws NoSuchAlgorithmException {
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Engine.SpiAndProvider sap = ENGINE.getInstance(algorithm, null);
         return new AlgorithmParameterGenerator((AlgorithmParameterGeneratorSpi) sap.spi,
@@ -149,7 +149,7 @@ public class AlgorithmParameterGenerator {
             throw new IllegalArgumentException();
         }
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Object spi = ENGINE.getInstance(algorithm, provider, null);
         return new AlgorithmParameterGenerator((AlgorithmParameterGeneratorSpi) spi, provider,
diff --git a/luni/src/main/java/java/security/AlgorithmParameters.java b/luni/src/main/java/java/security/AlgorithmParameters.java
index 8bbbe1b..073460e 100644
--- a/luni/src/main/java/java/security/AlgorithmParameters.java
+++ b/luni/src/main/java/java/security/AlgorithmParameters.java
@@ -92,7 +92,7 @@ public class AlgorithmParameters {
     public static AlgorithmParameters getInstance(String algorithm)
             throws NoSuchAlgorithmException {
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Engine.SpiAndProvider sap = ENGINE.getInstance(algorithm, null);
         return new AlgorithmParameters((AlgorithmParametersSpi) sap.spi, sap.provider, algorithm);
@@ -120,7 +120,7 @@ public class AlgorithmParameters {
             String provider) throws NoSuchAlgorithmException,
             NoSuchProviderException {
         if (provider == null || provider.isEmpty()) {
-            throw new IllegalArgumentException();
+            throw new IllegalArgumentException("provider == null || provider.isEmpty()");
         }
         Provider p = Security.getProvider(provider);
         if (p == null) {
@@ -148,10 +148,10 @@ public class AlgorithmParameters {
     public static AlgorithmParameters getInstance(String algorithm,
             Provider provider) throws NoSuchAlgorithmException {
         if (provider == null) {
-            throw new IllegalArgumentException();
+            throw new IllegalArgumentException("provider == null");
         }
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Object spi = ENGINE.getInstance(algorithm, provider, null);
         return new AlgorithmParameters((AlgorithmParametersSpi) spi, provider, algorithm);
diff --git a/luni/src/main/java/java/security/KeyFactory.java b/luni/src/main/java/java/security/KeyFactory.java
index 554885a..8d39003 100644
--- a/luni/src/main/java/java/security/KeyFactory.java
+++ b/luni/src/main/java/java/security/KeyFactory.java
@@ -76,7 +76,7 @@ public class KeyFactory {
     public static KeyFactory getInstance(String algorithm)
             throws NoSuchAlgorithmException {
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Engine.SpiAndProvider sap = ENGINE.getInstance(algorithm, null);
         return new KeyFactory((KeyFactorySpi) sap.spi, sap.provider, algorithm);
@@ -130,7 +130,7 @@ public class KeyFactory {
             throw new IllegalArgumentException();
         }
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Object spi = ENGINE.getInstance(algorithm, provider, null);
         return new KeyFactory((KeyFactorySpi) spi, provider, algorithm);
diff --git a/luni/src/main/java/java/security/KeyPairGenerator.java b/luni/src/main/java/java/security/KeyPairGenerator.java
index d5851fa..5c17d79 100644
--- a/luni/src/main/java/java/security/KeyPairGenerator.java
+++ b/luni/src/main/java/java/security/KeyPairGenerator.java
@@ -80,7 +80,7 @@ public abstract class KeyPairGenerator extends KeyPairGeneratorSpi {
     public static KeyPairGenerator getInstance(String algorithm)
             throws NoSuchAlgorithmException {
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Engine.SpiAndProvider sap = ENGINE.getInstance(algorithm, null);
         Object spi = sap.spi;
@@ -143,7 +143,7 @@ public abstract class KeyPairGenerator extends KeyPairGeneratorSpi {
             throw new IllegalArgumentException();
         }
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Object spi = ENGINE.getInstance(algorithm, provider, null);
         if (spi instanceof KeyPairGenerator) {
diff --git a/luni/src/main/java/java/security/KeyStore.java b/luni/src/main/java/java/security/KeyStore.java
index c233a5b..3d856f7 100644
--- a/luni/src/main/java/java/security/KeyStore.java
+++ b/luni/src/main/java/java/security/KeyStore.java
@@ -110,7 +110,7 @@ public class KeyStore {
      */
     public static KeyStore getInstance(String type) throws KeyStoreException {
         if (type == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("type == null");
         }
         try {
             Engine.SpiAndProvider sap = ENGINE.getInstance(type, null);
@@ -182,7 +182,7 @@ public class KeyStore {
             throw new IllegalArgumentException();
         }
         if (type == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("type == null");
         }
         // return KeyStore instance
         try {
diff --git a/luni/src/main/java/java/security/MessageDigest.java b/luni/src/main/java/java/security/MessageDigest.java
index 3154028..6f1bf21 100644
--- a/luni/src/main/java/java/security/MessageDigest.java
+++ b/luni/src/main/java/java/security/MessageDigest.java
@@ -86,7 +86,7 @@ public abstract class MessageDigest extends MessageDigestSpi {
     public static MessageDigest getInstance(String algorithm)
             throws NoSuchAlgorithmException {
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Engine.SpiAndProvider sap = ENGINE.getInstance(algorithm, null);
         Object spi = sap.spi;
@@ -152,7 +152,7 @@ public abstract class MessageDigest extends MessageDigestSpi {
             throw new IllegalArgumentException();
         }
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Object spi = ENGINE.getInstance(algorithm, provider, null);
         if (spi instanceof MessageDigest) {
@@ -217,7 +217,7 @@ public abstract class MessageDigest extends MessageDigestSpi {
      */
     public void update(byte[] input) {
         if (input == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("input == null");
         }
         engineUpdate(input, 0, input.length);
     }
diff --git a/luni/src/main/java/java/security/Provider.java b/luni/src/main/java/java/security/Provider.java
index 018e268..899625a 100644
--- a/luni/src/main/java/java/security/Provider.java
+++ b/luni/src/main/java/java/security/Provider.java
@@ -407,8 +407,10 @@ public abstract class Provider extends Properties {
      */
     public synchronized Provider.Service getService(String type,
             String algorithm) {
-        if (type == null || algorithm == null) {
-            throw new NullPointerException();
+        if (type == null) {
+            throw new NullPointerException("type == null");
+        } else if (algorithm == null) {
+            throw new NullPointerException("algorithm == null");
         }
 
         if (type.equals(lastServiceName) && algorithm.equalsIgnoreCase(lastAlgorithm)) {
@@ -475,7 +477,7 @@ public abstract class Provider extends Properties {
      */
     protected synchronized void putService(Provider.Service s) {
         if (s == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("s == null");
         }
         if ("Provider".equals(s.getType())) { // Provider service type cannot be added
             return;
@@ -507,7 +509,7 @@ public abstract class Provider extends Properties {
      */
     protected synchronized void removeService(Provider.Service s) {
         if (s == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("s == null");
         }
         servicesChanged();
         if (serviceTable != null) {
@@ -852,9 +854,14 @@ public abstract class Provider extends Properties {
          */
         public Service(Provider provider, String type, String algorithm,
                 String className, List<String> aliases, Map<String, String> attributes) {
-            if (provider == null || type == null || algorithm == null
-                    || className == null) {
-                throw new NullPointerException();
+            if (provider == null) {
+                throw new NullPointerException("provider == null");
+            } else if (type == null) {
+                throw new NullPointerException("type == null");
+            } else if (algorithm == null) {
+                throw new NullPointerException("algorithm == null");
+            } else if (className == null) {
+                throw new NullPointerException("className == null");
             }
             this.provider = provider;
             this.type = type;
@@ -943,7 +950,7 @@ public abstract class Provider extends Properties {
          */
         public final String getAttribute(String name) {
             if (name == null) {
-                throw new NullPointerException();
+                throw new NullPointerException("name == null");
             }
             if (attributes == null) {
                 return null;
diff --git a/luni/src/main/java/java/security/SecureRandom.java b/luni/src/main/java/java/security/SecureRandom.java
index 9091f73..6ed631c 100644
--- a/luni/src/main/java/java/security/SecureRandom.java
+++ b/luni/src/main/java/java/security/SecureRandom.java
@@ -153,7 +153,7 @@ public class SecureRandom extends Random {
      */
     public static SecureRandom getInstance(String algorithm) throws NoSuchAlgorithmException {
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Engine.SpiAndProvider sap = ENGINE.getInstance(algorithm, null);
         return new SecureRandom((SecureRandomSpi) sap.spi, sap.provider,
@@ -212,7 +212,7 @@ public class SecureRandom extends Random {
             throw new IllegalArgumentException();
         }
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Object spi = ENGINE.getInstance(algorithm, provider, null);
         return new SecureRandom((SecureRandomSpi) spi, provider, algorithm);
diff --git a/luni/src/main/java/java/security/Security.java b/luni/src/main/java/java/security/Security.java
index a4cc6e1..b5bd02a 100644
--- a/luni/src/main/java/java/security/Security.java
+++ b/luni/src/main/java/java/security/Security.java
@@ -227,7 +227,7 @@ public final class Security {
      */
     public static Provider[] getProviders(String filter) {
         if (filter == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("filter == null");
         }
         if (filter.length() == 0) {
             throw new InvalidParameterException();
@@ -271,7 +271,7 @@ public final class Security {
      */
     public static synchronized Provider[] getProviders(Map<String,String> filter) {
         if (filter == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("filter == null");
         }
         if (filter.isEmpty()) {
             return null;
diff --git a/luni/src/main/java/java/security/Signature.java b/luni/src/main/java/java/security/Signature.java
index d9e1e41..be89654 100644
--- a/luni/src/main/java/java/security/Signature.java
+++ b/luni/src/main/java/java/security/Signature.java
@@ -99,7 +99,7 @@ public abstract class Signature extends SignatureSpi {
     public static Signature getInstance(String algorithm)
             throws NoSuchAlgorithmException {
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Engine.SpiAndProvider sap = ENGINE.getInstance(algorithm, null);
         Object spi = sap.spi;
@@ -134,7 +134,7 @@ public abstract class Signature extends SignatureSpi {
     public static Signature getInstance(String algorithm, String provider)
             throws NoSuchAlgorithmException, NoSuchProviderException {
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         if (provider == null || provider.isEmpty()) {
             throw new IllegalArgumentException();
@@ -165,7 +165,7 @@ public abstract class Signature extends SignatureSpi {
     public static Signature getInstance(String algorithm, Provider provider)
             throws NoSuchAlgorithmException {
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         if (provider == null) {
             throw new IllegalArgumentException();
diff --git a/luni/src/main/java/java/security/Signer.java b/luni/src/main/java/java/security/Signer.java
index 1e4412a..b892090 100644
--- a/luni/src/main/java/java/security/Signer.java
+++ b/luni/src/main/java/java/security/Signer.java
@@ -83,7 +83,7 @@ public abstract class Signer extends Identity {
      */
     public final void setKeyPair(KeyPair pair) throws InvalidParameterException, KeyException {
         if (pair == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("pair == null");
         }
 
         if (pair.getPrivate() == null || pair.getPublic() == null) {
diff --git a/luni/src/main/java/java/security/cert/CertPathBuilder.java b/luni/src/main/java/java/security/cert/CertPathBuilder.java
index aa65fe7..42029e5 100644
--- a/luni/src/main/java/java/security/cert/CertPathBuilder.java
+++ b/luni/src/main/java/java/security/cert/CertPathBuilder.java
@@ -102,7 +102,7 @@ public class CertPathBuilder {
     public static CertPathBuilder getInstance(String algorithm)
             throws NoSuchAlgorithmException {
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Engine.SpiAndProvider sap = ENGINE.getInstance(algorithm, null);
         return new CertPathBuilder((CertPathBuilderSpi) sap.spi, sap.provider, algorithm);
@@ -128,7 +128,7 @@ public class CertPathBuilder {
     public static CertPathBuilder getInstance(String algorithm, String provider)
             throws NoSuchAlgorithmException, NoSuchProviderException {
         if (provider == null || provider.isEmpty()) {
-            throw new IllegalArgumentException();
+            throw new IllegalArgumentException("provider == null || provider.isEmpty()");
         }
         Provider impProvider = Security.getProvider(provider);
         if (impProvider == null) {
@@ -156,10 +156,10 @@ public class CertPathBuilder {
     public static CertPathBuilder getInstance(String algorithm,
             Provider provider) throws NoSuchAlgorithmException {
         if (provider == null) {
-            throw new IllegalArgumentException();
+            throw new IllegalArgumentException("provider == null");
         }
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Object spi = ENGINE.getInstance(algorithm, provider, null);
         return new CertPathBuilder((CertPathBuilderSpi) spi, provider, algorithm);
diff --git a/luni/src/main/java/java/security/cert/CertPathValidator.java b/luni/src/main/java/java/security/cert/CertPathValidator.java
index 69b9f99..ddf78bf 100644
--- a/luni/src/main/java/java/security/cert/CertPathValidator.java
+++ b/luni/src/main/java/java/security/cert/CertPathValidator.java
@@ -101,7 +101,7 @@ public class CertPathValidator {
     public static CertPathValidator getInstance(String algorithm)
             throws NoSuchAlgorithmException {
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Engine.SpiAndProvider sap = ENGINE.getInstance(algorithm, null);
         return new CertPathValidator((CertPathValidatorSpi) sap.spi, sap.provider, algorithm);
@@ -160,7 +160,7 @@ public class CertPathValidator {
             throw new IllegalArgumentException();
         }
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Object spi = ENGINE.getInstance(algorithm, provider, null);
         return new CertPathValidator((CertPathValidatorSpi) spi, provider, algorithm);
diff --git a/luni/src/main/java/java/security/cert/CertStore.java b/luni/src/main/java/java/security/cert/CertStore.java
index 6cdaea7..2e28828 100644
--- a/luni/src/main/java/java/security/cert/CertStore.java
+++ b/luni/src/main/java/java/security/cert/CertStore.java
@@ -97,7 +97,7 @@ public class CertStore {
     public static CertStore getInstance(String type, CertStoreParameters params)
             throws InvalidAlgorithmParameterException, NoSuchAlgorithmException {
         if (type == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("type == null");
         }
         try {
             Engine.SpiAndProvider sap = ENGINE.getInstance(type, params);
@@ -140,7 +140,7 @@ public class CertStore {
             throws InvalidAlgorithmParameterException,
             NoSuchAlgorithmException, NoSuchProviderException {
         if (provider == null || provider.isEmpty()) {
-            throw new IllegalArgumentException();
+            throw new IllegalArgumentException("provider == null || provider.isEmpty()");
         }
         Provider impProvider = Security.getProvider(provider);
         if (impProvider == null) {
@@ -172,10 +172,10 @@ public class CertStore {
             CertStoreParameters params, Provider provider)
             throws NoSuchAlgorithmException, InvalidAlgorithmParameterException {
         if (provider == null) {
-            throw new IllegalArgumentException();
+            throw new IllegalArgumentException("provider == null");
         }
         if (type == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("type == null");
         }
         try {
             Object spi = ENGINE.getInstance(type, provider, params);
diff --git a/luni/src/main/java/java/security/cert/CertificateFactory.java b/luni/src/main/java/java/security/cert/CertificateFactory.java
index 1aac1a0..83d40d3 100644
--- a/luni/src/main/java/java/security/cert/CertificateFactory.java
+++ b/luni/src/main/java/java/security/cert/CertificateFactory.java
@@ -84,7 +84,7 @@ public class CertificateFactory {
     public static final CertificateFactory getInstance(String type)
             throws CertificateException {
         if (type == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("type == null");
         }
         try {
             Engine.SpiAndProvider sap = ENGINE.getInstance(type, null);
@@ -117,7 +117,7 @@ public class CertificateFactory {
             String provider) throws CertificateException,
             NoSuchProviderException {
         if (provider == null || provider.isEmpty()) {
-            throw new IllegalArgumentException();
+            throw new IllegalArgumentException("provider == null || provider.isEmpty()");
         }
         Provider impProvider = Security.getProvider(provider);
         if (impProvider == null) {
@@ -147,10 +147,10 @@ public class CertificateFactory {
     public static final CertificateFactory getInstance(String type,
             Provider provider) throws CertificateException {
         if (provider == null) {
-            throw new IllegalArgumentException();
+            throw new IllegalArgumentException("provider == null");
         }
         if (type == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("type == null");
         }
         try {
             Object spi = ENGINE.getInstance(type, provider, null);
diff --git a/luni/src/main/java/java/security/cert/CollectionCertStoreParameters.java b/luni/src/main/java/java/security/cert/CollectionCertStoreParameters.java
index de3c85d..9373b40 100644
--- a/luni/src/main/java/java/security/cert/CollectionCertStoreParameters.java
+++ b/luni/src/main/java/java/security/cert/CollectionCertStoreParameters.java
@@ -58,10 +58,10 @@ public class CollectionCertStoreParameters implements CertStoreParameters {
      *             if {@code collection is null}.
      */
     public CollectionCertStoreParameters(Collection<?> collection) {
-        this.collection = collection;
-        if (this.collection == null) {
-            throw new NullPointerException();
+        if (collection == null) {
+            throw new NullPointerException("collection == null");
         }
+        this.collection = collection;
     }
 
     /**
diff --git a/luni/src/main/java/java/security/cert/LDAPCertStoreParameters.java b/luni/src/main/java/java/security/cert/LDAPCertStoreParameters.java
index 5b01f90..163c99a 100644
--- a/luni/src/main/java/java/security/cert/LDAPCertStoreParameters.java
+++ b/luni/src/main/java/java/security/cert/LDAPCertStoreParameters.java
@@ -43,11 +43,11 @@ public class LDAPCertStoreParameters implements CertStoreParameters {
      *             is {@code serverName} is {@code null}.
      */
     public LDAPCertStoreParameters(String serverName, int port) {
+        if (serverName == null) {
+            throw new NullPointerException("serverName == null");
+        }
         this.port = port;
         this.serverName = serverName;
-        if (this.serverName == null) {
-            throw new NullPointerException();
-        }
     }
 
     /**
@@ -71,11 +71,11 @@ public class LDAPCertStoreParameters implements CertStoreParameters {
      *             if {@code serverName} is {@code null}.
      */
     public LDAPCertStoreParameters(String serverName) {
+        if (serverName == null) {
+            throw new NullPointerException("serverName == null");
+        }
         this.port = DEFAULT_LDAP_PORT;
         this.serverName = serverName;
-        if (this.serverName == null) {
-            throw new NullPointerException();
-        }
     }
 
     /**
diff --git a/luni/src/main/java/java/security/cert/PKIXCertPathBuilderResult.java b/luni/src/main/java/java/security/cert/PKIXCertPathBuilderResult.java
index 589ce82..2359612 100644
--- a/luni/src/main/java/java/security/cert/PKIXCertPathBuilderResult.java
+++ b/luni/src/main/java/java/security/cert/PKIXCertPathBuilderResult.java
@@ -49,10 +49,10 @@ public class PKIXCertPathBuilderResult extends PKIXCertPathValidatorResult
     public PKIXCertPathBuilderResult(CertPath certPath, TrustAnchor trustAnchor,
             PolicyNode policyTree, PublicKey subjectPublicKey) {
         super(trustAnchor, policyTree, subjectPublicKey);
-        this.certPath = certPath;
-        if (this.certPath == null) {
+        if (certPath == null) {
             throw new NullPointerException("certPath == null");
         }
+        this.certPath = certPath;
     }
 
     /**
diff --git a/luni/src/main/java/java/security/cert/X509CRL.java b/luni/src/main/java/java/security/cert/X509CRL.java
index 4badd59..4addb0e 100644
--- a/luni/src/main/java/java/security/cert/X509CRL.java
+++ b/luni/src/main/java/java/security/cert/X509CRL.java
@@ -218,7 +218,7 @@ public abstract class X509CRL extends CRL implements X509Extension {
      */
     public X509CRLEntry getRevokedCertificate(X509Certificate certificate) {
         if (certificate == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("certificate == null");
         }
         return getRevokedCertificate(certificate.getSerialNumber());
     }
diff --git a/luni/src/main/java/java/security/spec/ECGenParameterSpec.java b/luni/src/main/java/java/security/spec/ECGenParameterSpec.java
index fe66b1e..c22038d 100644
--- a/luni/src/main/java/java/security/spec/ECGenParameterSpec.java
+++ b/luni/src/main/java/java/security/spec/ECGenParameterSpec.java
@@ -35,7 +35,7 @@ public class ECGenParameterSpec implements AlgorithmParameterSpec {
     public ECGenParameterSpec(String name) {
         this.name = name;
         if (this.name == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("name == null");
         }
     }
 
diff --git a/luni/src/main/java/java/sql/DriverManager.java b/luni/src/main/java/java/sql/DriverManager.java
index 4cee1fe..c547585 100644
--- a/luni/src/main/java/java/sql/DriverManager.java
+++ b/luni/src/main/java/java/sql/DriverManager.java
@@ -329,7 +329,7 @@ public class DriverManager {
      */
     public static void registerDriver(Driver driver) throws SQLException {
         if (driver == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("driver == null");
         }
         synchronized (theDrivers) {
             theDrivers.add(driver);
diff --git a/luni/src/main/java/java/text/AttributedString.java b/luni/src/main/java/java/text/AttributedString.java
index 1335067..d679283 100644
--- a/luni/src/main/java/java/text/AttributedString.java
+++ b/luni/src/main/java/java/text/AttributedString.java
@@ -519,7 +519,7 @@ public class AttributedString {
      */
     public AttributedString(String value) {
         if (value == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("value == null");
         }
         text = value;
         attributeMap = new HashMap<Attribute, List<Range>>(11);
@@ -542,7 +542,7 @@ public class AttributedString {
     public AttributedString(String value,
             Map<? extends AttributedCharacterIterator.Attribute, ?> attributes) {
         if (value == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("value == null");
         }
         if (value.length() == 0 && !attributes.isEmpty()) {
             throw new IllegalArgumentException("Cannot add attributes to empty string");
@@ -575,7 +575,7 @@ public class AttributedString {
      */
     public void addAttribute(AttributedCharacterIterator.Attribute attribute, Object value) {
         if (attribute == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("attribute == null");
         }
         if (text.length() == 0) {
             throw new IllegalArgumentException();
@@ -612,7 +612,7 @@ public class AttributedString {
     public void addAttribute(AttributedCharacterIterator.Attribute attribute,
             Object value, int start, int end) {
         if (attribute == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("attribute == null");
         }
         if (start < 0 || end > text.length() || start >= end) {
             throw new IllegalArgumentException();
diff --git a/luni/src/main/java/java/text/Collator.java b/luni/src/main/java/java/text/Collator.java
index 0fa8c71..2ddb516 100644
--- a/luni/src/main/java/java/text/Collator.java
+++ b/luni/src/main/java/java/text/Collator.java
@@ -286,7 +286,7 @@ public abstract class Collator implements Comparator<Object>, Cloneable {
      */
     public static Collator getInstance(Locale locale) {
         if (locale == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("locale == null");
         }
         return new RuleBasedCollator(new RuleBasedCollatorICU(locale));
     }
diff --git a/luni/src/main/java/java/text/DateFormatSymbols.java b/luni/src/main/java/java/text/DateFormatSymbols.java
index 3c4768d..e2a2345 100644
--- a/luni/src/main/java/java/text/DateFormatSymbols.java
+++ b/luni/src/main/java/java/text/DateFormatSymbols.java
@@ -142,7 +142,7 @@ public class DateFormatSymbols implements Serializable, Cloneable {
      */
     public static final DateFormatSymbols getInstance(Locale locale) {
         if (locale == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("locale == null");
         }
         return new DateFormatSymbols(locale);
     }
@@ -410,7 +410,7 @@ public class DateFormatSymbols implements Serializable, Cloneable {
      */
     public void setLocalPatternChars(String data) {
         if (data == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("data == null");
         }
         localPatternChars = data;
     }
@@ -471,7 +471,7 @@ public class DateFormatSymbols implements Serializable, Cloneable {
      */
     public void setZoneStrings(String[][] zoneStrings) {
         if (zoneStrings == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("zoneStrings == null");
         }
         for (String[] row : zoneStrings) {
             if (row.length < 5) {
diff --git a/luni/src/main/java/java/text/DecimalFormat.java b/luni/src/main/java/java/text/DecimalFormat.java
index c1a48db..eded6a8 100644
--- a/luni/src/main/java/java/text/DecimalFormat.java
+++ b/luni/src/main/java/java/text/DecimalFormat.java
@@ -654,7 +654,7 @@ public class DecimalFormat extends NumberFormat {
     @Override
     public AttributedCharacterIterator formatToCharacterIterator(Object object) {
         if (object == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("object == null");
         }
         return dform.formatToCharacterIterator(object);
     }
@@ -1248,7 +1248,7 @@ public class DecimalFormat extends NumberFormat {
      */
     public void setRoundingMode(RoundingMode roundingMode) {
         if (roundingMode == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("roundingMode == null");
         }
         this.roundingMode = roundingMode;
         if (roundingMode != RoundingMode.UNNECESSARY) { // ICU4C doesn't support UNNECESSARY.
diff --git a/luni/src/main/java/java/text/DecimalFormatSymbols.java b/luni/src/main/java/java/text/DecimalFormatSymbols.java
index 9d2bcc1..708b291 100644
--- a/luni/src/main/java/java/text/DecimalFormatSymbols.java
+++ b/luni/src/main/java/java/text/DecimalFormatSymbols.java
@@ -127,7 +127,7 @@ public class DecimalFormatSymbols implements Cloneable, Serializable {
      */
     public static DecimalFormatSymbols getInstance(Locale locale) {
         if (locale == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("locale == null");
         }
         return new DecimalFormatSymbols(locale);
     }
@@ -389,7 +389,7 @@ public class DecimalFormatSymbols implements Cloneable, Serializable {
      */
     public void setCurrency(Currency currency) {
         if (currency == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("currency == null");
         }
         if (currency == this.currency) {
             return;
@@ -558,7 +558,7 @@ public class DecimalFormatSymbols implements Cloneable, Serializable {
      */
     public void setExponentSeparator(String value) {
         if (value == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("value == null");
         }
         this.exponentSeparator = value;
     }
diff --git a/luni/src/main/java/java/text/MessageFormat.java b/luni/src/main/java/java/text/MessageFormat.java
index a98e4fd..2ab78db 100644
--- a/luni/src/main/java/java/text/MessageFormat.java
+++ b/luni/src/main/java/java/text/MessageFormat.java
@@ -506,7 +506,7 @@ public class MessageFormat extends Format {
     @Override
     public AttributedCharacterIterator formatToCharacterIterator(Object object) {
         if (object == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("object == null");
         }
 
         StringBuffer buffer = new StringBuffer();
diff --git a/luni/src/main/java/java/text/NumberFormat.java b/luni/src/main/java/java/text/NumberFormat.java
index 3bff6ad..070174b 100644
--- a/luni/src/main/java/java/text/NumberFormat.java
+++ b/luni/src/main/java/java/text/NumberFormat.java
@@ -570,7 +570,7 @@ public abstract class NumberFormat extends Format {
     @Override
     public final Object parseObject(String string, ParsePosition position) {
         if (position == null) {
-            throw new NullPointerException("position is null");
+            throw new NullPointerException("position == null");
         }
         try {
             return parse(string, position);
diff --git a/luni/src/main/java/java/text/RuleBasedCollator.java b/luni/src/main/java/java/text/RuleBasedCollator.java
index 4fd8650..cda06db 100644
--- a/luni/src/main/java/java/text/RuleBasedCollator.java
+++ b/luni/src/main/java/java/text/RuleBasedCollator.java
@@ -284,7 +284,7 @@ public class RuleBasedCollator extends Collator {
      */
     public RuleBasedCollator(String rules) throws ParseException {
         if (rules == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("rules == null");
         }
         if (rules.isEmpty()) {
             throw new ParseException("empty rules", 0);
@@ -314,7 +314,7 @@ public class RuleBasedCollator extends Collator {
      */
     public CollationElementIterator getCollationElementIterator(CharacterIterator source) {
         if (source == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("source == null");
         }
         return new CollationElementIterator(icuColl.getCollationElementIterator(source));
     }
@@ -328,7 +328,7 @@ public class RuleBasedCollator extends Collator {
      */
     public CollationElementIterator getCollationElementIterator(String source) {
         if (source == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("source == null");
         }
         return new CollationElementIterator(icuColl.getCollationElementIterator(source));
     }
@@ -385,8 +385,10 @@ public class RuleBasedCollator extends Collator {
      */
     @Override
     public int compare(String source, String target) {
-        if (source == null || target == null) {
-            throw new NullPointerException();
+        if (source == null) {
+            throw new NullPointerException("source == null");
+        } else if (target == null) {
+            throw new NullPointerException("target == null");
         }
         return icuColl.compare(source, target);
     }
diff --git a/luni/src/main/java/java/text/SimpleDateFormat.java b/luni/src/main/java/java/text/SimpleDateFormat.java
index f39f770..da5af85 100644
--- a/luni/src/main/java/java/text/SimpleDateFormat.java
+++ b/luni/src/main/java/java/text/SimpleDateFormat.java
@@ -471,7 +471,7 @@ public class SimpleDateFormat extends DateFormat {
     @Override
     public AttributedCharacterIterator formatToCharacterIterator(Object object) {
         if (object == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("object == null");
         }
         if (object instanceof Date) {
             return formatToCharacterIteratorImpl((Date) object);
diff --git a/luni/src/main/java/java/util/AbstractQueue.java b/luni/src/main/java/java/util/AbstractQueue.java
index b046559..47f81fd 100644
--- a/luni/src/main/java/java/util/AbstractQueue.java
+++ b/luni/src/main/java/java/util/AbstractQueue.java
@@ -150,9 +150,9 @@ public abstract class AbstractQueue<E>
      */
     public boolean addAll(Collection<? extends E> c) {
         if (c == null)
-            throw new NullPointerException();
+            throw new NullPointerException("c == null");
         if (c == this)
-            throw new IllegalArgumentException();
+            throw new IllegalArgumentException("c == this");
         boolean modified = false;
         for (E e : c)
             if (add(e))
diff --git a/luni/src/main/java/java/util/ArrayDeque.java b/luni/src/main/java/java/util/ArrayDeque.java
index c4d67b8..5ee3f81 100644
--- a/luni/src/main/java/java/util/ArrayDeque.java
+++ b/luni/src/main/java/java/util/ArrayDeque.java
@@ -193,7 +193,7 @@ public class ArrayDeque<E> extends AbstractCollection<E>
      */
     public void addFirst(E e) {
         if (e == null)
-            throw new NullPointerException();
+            throw new NullPointerException("e == null");
         elements[head = (head - 1) & (elements.length - 1)] = e;
         if (head == tail)
             doubleCapacity();
@@ -209,7 +209,7 @@ public class ArrayDeque<E> extends AbstractCollection<E>
      */
     public void addLast(E e) {
         if (e == null)
-            throw new NullPointerException();
+            throw new NullPointerException("e == null");
         elements[tail] = e;
         if ( (tail = (tail + 1) & (elements.length - 1)) == head)
             doubleCapacity();
diff --git a/luni/src/main/java/java/util/Arrays.java b/luni/src/main/java/java/util/Arrays.java
index 588410f..4a149b7 100644
--- a/luni/src/main/java/java/util/Arrays.java
+++ b/luni/src/main/java/java/util/Arrays.java
@@ -35,7 +35,7 @@ public class Arrays {
 
         ArrayList(E[] storage) {
             if (storage == null) {
-                throw new NullPointerException();
+                throw new NullPointerException("storage == null");
             }
             a = storage;
         }
@@ -2611,7 +2611,7 @@ public class Arrays {
      */
     public static <T> T[] copyOf(T[] original, int newLength) {
         if (original == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("original == null");
         }
         if (newLength < 0) {
             throw new NegativeArraySizeException(Integer.toString(newLength));
diff --git a/luni/src/main/java/java/util/Calendar.java b/luni/src/main/java/java/util/Calendar.java
index 4cabd4a..81d01fb 100644
--- a/luni/src/main/java/java/util/Calendar.java
+++ b/luni/src/main/java/java/util/Calendar.java
@@ -1389,7 +1389,7 @@ public abstract class Calendar implements Serializable, Cloneable, Comparable<Ca
      */
     public int compareTo(Calendar anotherCalendar) {
         if (anotherCalendar == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("anotherCalendar == null");
         }
         long timeInMillis = getTimeInMillis();
         long anotherTimeInMillis = anotherCalendar.getTimeInMillis();
diff --git a/luni/src/main/java/java/util/Collections.java b/luni/src/main/java/java/util/Collections.java
index b6729b4..d49ca85 100644
--- a/luni/src/main/java/java/util/Collections.java
+++ b/luni/src/main/java/java/util/Collections.java
@@ -1412,7 +1412,7 @@ public class Collections {
     @SuppressWarnings("unchecked")
     public static <T> int binarySearch(List<? extends Comparable<? super T>> list, T object) {
         if (list == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("list == null");
         }
         if (list.isEmpty()) {
             return -1;
@@ -1916,7 +1916,7 @@ public class Collections {
     @SuppressWarnings("unchecked")
     public static void swap(List<?> list, int index1, int index2) {
         if (list == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("list == null");
         }
         final int size = list.size();
         if (index1 < 0 || index1 >= size || index2 < 0 || index2 >= size) {
@@ -2174,7 +2174,7 @@ public class Collections {
     public static <T> Collection<T> synchronizedCollection(
             Collection<T> collection) {
         if (collection == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("collection == null");
         }
         return new SynchronizedCollection<T>(collection);
     }
@@ -2189,7 +2189,7 @@ public class Collections {
      */
     public static <T> List<T> synchronizedList(List<T> list) {
         if (list == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("list == null");
         }
         if (list instanceof RandomAccess) {
             return new SynchronizedRandomAccessList<T>(list);
@@ -2207,7 +2207,7 @@ public class Collections {
      */
     public static <K, V> Map<K, V> synchronizedMap(Map<K, V> map) {
         if (map == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("map == null");
         }
         return new SynchronizedMap<K, V>(map);
     }
@@ -2222,7 +2222,7 @@ public class Collections {
      */
     public static <E> Set<E> synchronizedSet(Set<E> set) {
         if (set == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("set == null");
         }
         return new SynchronizedSet<E>(set);
     }
@@ -2238,7 +2238,7 @@ public class Collections {
     public static <K, V> SortedMap<K, V> synchronizedSortedMap(
             SortedMap<K, V> map) {
         if (map == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("map == null");
         }
         return new SynchronizedSortedMap<K, V>(map);
     }
@@ -2253,7 +2253,7 @@ public class Collections {
      */
     public static <E> SortedSet<E> synchronizedSortedSet(SortedSet<E> set) {
         if (set == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("set == null");
         }
         return new SynchronizedSortedSet<E>(set);
     }
@@ -2271,7 +2271,7 @@ public class Collections {
     public static <E> Collection<E> unmodifiableCollection(
             Collection<? extends E> collection) {
         if (collection == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("collection == null");
         }
         return new UnmodifiableCollection<E>((Collection<E>) collection);
     }
@@ -2288,7 +2288,7 @@ public class Collections {
     @SuppressWarnings("unchecked")
     public static <E> List<E> unmodifiableList(List<? extends E> list) {
         if (list == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("list == null");
         }
         if (list instanceof RandomAccess) {
             return new UnmodifiableRandomAccessList<E>((List<E>) list);
@@ -2309,7 +2309,7 @@ public class Collections {
     public static <K, V> Map<K, V> unmodifiableMap(
             Map<? extends K, ? extends V> map) {
         if (map == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("map == null");
         }
         return new UnmodifiableMap<K, V>((Map<K, V>) map);
     }
@@ -2326,7 +2326,7 @@ public class Collections {
     @SuppressWarnings("unchecked")
     public static <E> Set<E> unmodifiableSet(Set<? extends E> set) {
         if (set == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("set == null");
         }
         return new UnmodifiableSet<E>((Set<E>) set);
     }
@@ -2344,7 +2344,7 @@ public class Collections {
     public static <K, V> SortedMap<K, V> unmodifiableSortedMap(
             SortedMap<K, ? extends V> map) {
         if (map == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("map == null");
         }
         return new UnmodifiableSortedMap<K, V>((SortedMap<K, V>) map);
     }
@@ -2360,7 +2360,7 @@ public class Collections {
      */
     public static <E> SortedSet<E> unmodifiableSortedSet(SortedSet<E> set) {
         if (set == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("set == null");
         }
         return new UnmodifiableSortedSet<E>(set);
     }
@@ -2381,7 +2381,7 @@ public class Collections {
      */
     public static int frequency(Collection<?> c, Object o) {
         if (c == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("c == null");
         }
         if (c.isEmpty()) {
             return 0;
@@ -2834,8 +2834,10 @@ public class Collections {
         Class<E> type;
 
         public CheckedCollection(Collection<E> c, Class<E> type) {
-            if (c == null || type == null) {
-                throw new NullPointerException();
+            if (c == null) {
+                throw new NullPointerException("c == null");
+            } else if (type == null) {
+                throw new NullPointerException("type == null");
             }
             this.c = c;
             this.type = type;
@@ -3079,8 +3081,12 @@ public class Collections {
         Class<V> valueType;
 
         private CheckedMap(Map<K, V> m, Class<K> keyType, Class<V> valueType) {
-            if (m == null || keyType == null || valueType == null) {
-                throw new NullPointerException();
+            if (m == null) {
+                throw new NullPointerException("m == null");
+            } else if (keyType == null) {
+                throw new NullPointerException("keyType == null");
+            } else if (valueType == null) {
+                throw new NullPointerException("valueType == null");
             }
             this.m = m;
             this.keyType = keyType;
@@ -3172,7 +3178,7 @@ public class Collections {
 
             public CheckedEntry(Map.Entry<K, V> e, Class<V> valueType) {
                 if (e == null) {
-                    throw new NullPointerException();
+                    throw new NullPointerException("e == null");
                 }
                 this.e = e;
                 this.valueType = valueType;
diff --git a/luni/src/main/java/java/util/DuplicateFormatFlagsException.java b/luni/src/main/java/java/util/DuplicateFormatFlagsException.java
index d04db8e..2a2bc2e 100644
--- a/luni/src/main/java/java/util/DuplicateFormatFlagsException.java
+++ b/luni/src/main/java/java/util/DuplicateFormatFlagsException.java
@@ -37,7 +37,7 @@ public class DuplicateFormatFlagsException extends IllegalFormatException {
      */
     public DuplicateFormatFlagsException(String f) {
         if (f == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("f == null");
         }
         flags = f;
     }
diff --git a/luni/src/main/java/java/util/EnumMap.java b/luni/src/main/java/java/util/EnumMap.java
index d3d42b4..a721ee3 100644
--- a/luni/src/main/java/java/util/EnumMap.java
+++ b/luni/src/main/java/java/util/EnumMap.java
@@ -773,7 +773,7 @@ public class EnumMap<K extends Enum<K>, V> extends AbstractMap<K, V> implements
     @SuppressWarnings("unchecked")
     private V putImpl(K key, V value) {
         if (key == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("key == null");
         }
         keyType.cast(key); // Called to throw ClassCastException.
         int keyOrdinal = key.ordinal();
diff --git a/luni/src/main/java/java/util/FormatFlagsConversionMismatchException.java b/luni/src/main/java/java/util/FormatFlagsConversionMismatchException.java
index 5792877..5c36788 100644
--- a/luni/src/main/java/java/util/FormatFlagsConversionMismatchException.java
+++ b/luni/src/main/java/java/util/FormatFlagsConversionMismatchException.java
@@ -44,7 +44,7 @@ public class FormatFlagsConversionMismatchException extends
      */
     public FormatFlagsConversionMismatchException(String f, char c) {
         if (f == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("f == null");
         }
         this.f = f;
         this.c = c;
diff --git a/luni/src/main/java/java/util/Formatter.java b/luni/src/main/java/java/util/Formatter.java
index e9a2f4a..021da08 100644
--- a/luni/src/main/java/java/util/Formatter.java
+++ b/luni/src/main/java/java/util/Formatter.java
@@ -884,7 +884,7 @@ public final class Formatter implements Closeable, Flushable {
      */
     public Formatter(PrintStream ps) {
         if (ps == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("ps == null");
         }
         out = ps;
         locale = Locale.getDefault();
diff --git a/luni/src/main/java/java/util/Hashtable.java b/luni/src/main/java/java/util/Hashtable.java
index 4ea26fb..a4e24bc 100644
--- a/luni/src/main/java/java/util/Hashtable.java
+++ b/luni/src/main/java/java/util/Hashtable.java
@@ -313,7 +313,7 @@ public class Hashtable<K, V> extends Dictionary<K, V>
      */
     public synchronized boolean containsValue(Object value) {
         if (value == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("value == null");
         }
 
         HashtableEntry[] tab = table;
@@ -361,8 +361,10 @@ public class Hashtable<K, V> extends Dictionary<K, V>
      * @see java.lang.Object#equals
      */
     public synchronized V put(K key, V value) {
-        if (key == null || value == null) {
-            throw new NullPointerException("key=" + key + " value=" + value);
+        if (key == null) {
+            throw new NullPointerException("key == null");
+        } else if (value == null) {
+            throw new NullPointerException("value == null");
         }
         int hash = secondaryHash(key.hashCode());
         HashtableEntry<K, V>[] tab = table;
@@ -395,8 +397,10 @@ public class Hashtable<K, V> extends Dictionary<K, V>
      * ensure that capacity is sufficient, and does not increment modCount.
      */
     private void constructorPut(K key, V value) {
-        if (key == null || value == null) {
-            throw new NullPointerException("key=" + key + " value=" + value);
+        if (key == null) {
+            throw new NullPointerException("key == null");
+        } else if (value == null) {
+            throw new NullPointerException("value == null");
         }
         int hash = secondaryHash(key.hashCode());
         HashtableEntry<K, V>[] tab = table;
@@ -680,7 +684,7 @@ public class Hashtable<K, V> extends Dictionary<K, V>
 
         public final V setValue(V value) {
             if (value == null) {
-                throw new NullPointerException("key=" + key + " value=" + value);
+                throw new NullPointerException("value == null");
             }
             V oldValue = this.value;
             this.value = value;
diff --git a/luni/src/main/java/java/util/IllegalFormatConversionException.java b/luni/src/main/java/java/util/IllegalFormatConversionException.java
index 31c0eed..af986f6 100644
--- a/luni/src/main/java/java/util/IllegalFormatConversionException.java
+++ b/luni/src/main/java/java/util/IllegalFormatConversionException.java
@@ -46,7 +46,7 @@ public class IllegalFormatConversionException extends IllegalFormatException
     public IllegalFormatConversionException(char c, Class<?> arg) {
         this.c = c;
         if (arg == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("arg == null");
         }
         this.arg = arg;
     }
diff --git a/luni/src/main/java/java/util/IllegalFormatFlagsException.java b/luni/src/main/java/java/util/IllegalFormatFlagsException.java
index 6947912..4946c55 100644
--- a/luni/src/main/java/java/util/IllegalFormatFlagsException.java
+++ b/luni/src/main/java/java/util/IllegalFormatFlagsException.java
@@ -38,7 +38,7 @@ public class IllegalFormatFlagsException extends IllegalFormatException implemen
      */
     public IllegalFormatFlagsException(String flags) {
         if (flags == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("flags == null");
         }
         this.flags = flags;
     }
diff --git a/luni/src/main/java/java/util/ListResourceBundle.java b/luni/src/main/java/java/util/ListResourceBundle.java
index 1508b93..fc6ab97 100644
--- a/luni/src/main/java/java/util/ListResourceBundle.java
+++ b/luni/src/main/java/java/util/ListResourceBundle.java
@@ -108,7 +108,7 @@ public abstract class ListResourceBundle extends ResourceBundle {
     public final Object handleGetObject(String key) {
         initializeTable();
         if (key == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("key == null");
         }
         return table.get(key);
     }
diff --git a/luni/src/main/java/java/util/MissingFormatArgumentException.java b/luni/src/main/java/java/util/MissingFormatArgumentException.java
index ce72efa..1733501 100644
--- a/luni/src/main/java/java/util/MissingFormatArgumentException.java
+++ b/luni/src/main/java/java/util/MissingFormatArgumentException.java
@@ -37,7 +37,7 @@ public class MissingFormatArgumentException extends IllegalFormatException {
      */
     public MissingFormatArgumentException(String s) {
         if (s == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("s == null");
         }
         this.s = s;
     }
diff --git a/luni/src/main/java/java/util/MissingFormatWidthException.java b/luni/src/main/java/java/util/MissingFormatWidthException.java
index b6d0ca6..0a3b5ae 100644
--- a/luni/src/main/java/java/util/MissingFormatWidthException.java
+++ b/luni/src/main/java/java/util/MissingFormatWidthException.java
@@ -36,7 +36,7 @@ public class MissingFormatWidthException extends IllegalFormatException {
      */
     public MissingFormatWidthException(String s) {
         if (s == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("s == null");
         }
         this.s = s;
     }
diff --git a/luni/src/main/java/java/util/Observable.java b/luni/src/main/java/java/util/Observable.java
index 2c2877e..c984c68 100644
--- a/luni/src/main/java/java/util/Observable.java
+++ b/luni/src/main/java/java/util/Observable.java
@@ -49,7 +49,7 @@ public class Observable {
      */
     public void addObserver(Observer observer) {
         if (observer == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("observer == null");
         }
         synchronized (this) {
             if (!observers.contains(observer))
diff --git a/luni/src/main/java/java/util/PriorityQueue.java b/luni/src/main/java/java/util/PriorityQueue.java
index 10c5968..e09eb05 100644
--- a/luni/src/main/java/java/util/PriorityQueue.java
+++ b/luni/src/main/java/java/util/PriorityQueue.java
@@ -186,7 +186,7 @@ public class PriorityQueue<E> extends AbstractQueue<E> implements Serializable {
      */
     public boolean offer(E o) {
         if (o == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("o == null");
         }
         growToSize(size + 1);
         elements[size] = o;
@@ -387,7 +387,7 @@ public class PriorityQueue<E> extends AbstractQueue<E> implements Serializable {
 
     private void initSize(Collection<? extends E> c) {
         if (c == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("c == null");
         }
         if (c.isEmpty()) {
             elements = newElementArray(1);
diff --git a/luni/src/main/java/java/util/Properties.java b/luni/src/main/java/java/util/Properties.java
index 1731ad8..57c6a00 100644
--- a/luni/src/main/java/java/util/Properties.java
+++ b/luni/src/main/java/java/util/Properties.java
@@ -243,7 +243,7 @@ public class Properties extends Hashtable<Object, Object> {
      */
     public synchronized void load(InputStream in) throws IOException {
         if (in == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("in == null");
         }
         load(new InputStreamReader(in, "ISO-8859-1"));
     }
@@ -276,7 +276,7 @@ public class Properties extends Hashtable<Object, Object> {
     @SuppressWarnings("fallthrough")
     public synchronized void load(Reader in) throws IOException {
         if (in == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("in == null");
         }
         int mode = NONE, unicode = 0, count = 0;
         char nextChar, buf[] = new char[40];
@@ -578,7 +578,7 @@ public class Properties extends Hashtable<Object, Object> {
     public synchronized void loadFromXML(InputStream in) throws IOException,
             InvalidPropertiesFormatException {
         if (in == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("in == null");
         }
 
         if (builder == null) {
@@ -690,8 +690,10 @@ public class Properties extends Hashtable<Object, Object> {
     public synchronized void storeToXML(OutputStream os, String comment,
             String encoding) throws IOException {
 
-        if (os == null || encoding == null) {
-            throw new NullPointerException();
+        if (os == null) {
+            throw new NullPointerException("os == null");
+        } else if (encoding == null) {
+            throw new NullPointerException("encoding == null");
         }
 
         /*
diff --git a/luni/src/main/java/java/util/PropertyResourceBundle.java b/luni/src/main/java/java/util/PropertyResourceBundle.java
index 4029ee1..dbbd139 100644
--- a/luni/src/main/java/java/util/PropertyResourceBundle.java
+++ b/luni/src/main/java/java/util/PropertyResourceBundle.java
@@ -46,7 +46,7 @@ public class PropertyResourceBundle extends ResourceBundle {
      */
     public PropertyResourceBundle(InputStream stream) throws IOException {
         if (stream == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("stream == null");
         }
         resources = new Properties();
         resources.load(stream);
diff --git a/luni/src/main/java/java/util/ResourceBundle.java b/luni/src/main/java/java/util/ResourceBundle.java
index ff38b5b..f5c8285 100644
--- a/luni/src/main/java/java/util/ResourceBundle.java
+++ b/luni/src/main/java/java/util/ResourceBundle.java
@@ -211,8 +211,10 @@ public abstract class ResourceBundle {
      */
     public static ResourceBundle getBundle(String bundleName, Locale locale,
             ClassLoader loader) throws MissingResourceException {
-        if (loader == null || bundleName == null) {
-            throw new NullPointerException();
+        if (loader == null) {
+            throw new NullPointerException("loader == null");
+        } else if (bundleName == null) {
+            throw new NullPointerException("bundleName == null");
         }
         Locale defaultLocale = Locale.getDefault();
         if (!cacheLocale.equals(defaultLocale)) {
@@ -610,14 +612,14 @@ public abstract class ResourceBundle {
 
     public static void clearCache(ClassLoader loader) {
         if (loader == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("loader == null");
         }
         cache.remove(loader);
     }
 
     public boolean containsKey(String key) {
         if (key == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("key == null");
         }
         return keySet().contains(key);
     }
@@ -665,8 +667,10 @@ public abstract class ResourceBundle {
 
         @Override
         public Locale getFallbackLocale(String baseName, Locale locale) {
-            if (baseName == null || locale == null) {
-                throw new NullPointerException();
+            if (baseName == null) {
+                throw new NullPointerException("baseName == null");
+            } else if (locale == null) {
+                throw new NullPointerException("locale == null");
             }
             return null;
         }
@@ -804,8 +808,10 @@ public abstract class ResourceBundle {
          * {@code locale}.
          */
         public List<Locale> getCandidateLocales(String baseName, Locale locale) {
-            if (baseName == null || locale == null) {
-                throw new NullPointerException();
+            if (baseName == null) {
+                throw new NullPointerException("baseName == null");
+            } else if (locale == null) {
+                throw new NullPointerException("locale == null");
             }
             List<Locale> retList = new ArrayList<Locale>();
             String language = locale.getLanguage();
@@ -829,7 +835,7 @@ public abstract class ResourceBundle {
          */
         public List<String> getFormats(String baseName) {
             if (baseName == null) {
-                throw new NullPointerException();
+                throw new NullPointerException("baseName == null");
             }
             return format;
         }
@@ -838,8 +844,10 @@ public abstract class ResourceBundle {
          * Returns the fallback locale for {@code baseName} in {@code locale}.
          */
         public Locale getFallbackLocale(String baseName, Locale locale) {
-            if (baseName == null || locale == null) {
-                throw new NullPointerException();
+            if (baseName == null) {
+                throw new NullPointerException("baseName == null");
+            } else if (locale == null) {
+                throw new NullPointerException("locale == null");
             }
             if (Locale.getDefault() != locale) {
                 return Locale.getDefault();
@@ -872,8 +880,10 @@ public abstract class ResourceBundle {
                 String format, ClassLoader loader, boolean reload)
                 throws IllegalAccessException, InstantiationException,
                 IOException {
-            if (format == null || loader == null) {
-                throw new NullPointerException();
+            if (format == null) {
+                throw new NullPointerException("format == null");
+            } else if (loader == null) {
+                throw new NullPointerException("loader == null");
             }
             final String bundleName = toBundleName(baseName, locale);
             final ClassLoader clsloader = loader;
@@ -938,8 +948,10 @@ public abstract class ResourceBundle {
          * default is TTL_NO_EXPIRATION_CONTROL.
          */
         public long getTimeToLive(String baseName, Locale locale) {
-            if (baseName == null || locale == null) {
-                throw new NullPointerException();
+            if (baseName == null) {
+                throw new NullPointerException("baseName == null");
+            } else if (locale == null) {
+                throw new NullPointerException("locale == null");
             }
             return TTL_NO_EXPIRATION_CONTROL;
         }
@@ -966,7 +978,7 @@ public abstract class ResourceBundle {
                 long loadTime) {
             if (bundle == null) {
                 // FIXME what's the use of bundle?
-                throw new NullPointerException();
+                throw new NullPointerException("bundle == null");
             }
             String bundleName = toBundleName(baseName, locale);
             String suffix = format;
@@ -1004,7 +1016,7 @@ public abstract class ResourceBundle {
             final String preString = UNDER_SCORE;
             final String underline = UNDER_SCORE;
             if (baseName == null) {
-                throw new NullPointerException();
+                throw new NullPointerException("baseName == null");
             }
             StringBuilder ret = new StringBuilder();
             StringBuilder prefix = new StringBuilder();
@@ -1044,7 +1056,7 @@ public abstract class ResourceBundle {
          */
         public final String toResourceName(String bundleName, String suffix) {
             if (suffix == null) {
-                throw new NullPointerException();
+                throw new NullPointerException("suffix == null");
             }
             StringBuilder ret = new StringBuilder(bundleName.replace('.', '/'));
             ret.append('.');
diff --git a/luni/src/main/java/java/util/Scanner.java b/luni/src/main/java/java/util/Scanner.java
index 8f889b3..5f7d0e3 100644
--- a/luni/src/main/java/java/util/Scanner.java
+++ b/luni/src/main/java/java/util/Scanner.java
@@ -241,7 +241,7 @@ public final class Scanner implements Iterator<String> {
      */
     public Scanner(Readable src) {
         if (src == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("src == null");
         }
         input = src;
         initialization();
@@ -1664,7 +1664,7 @@ public final class Scanner implements Iterator<String> {
      */
     public Scanner useLocale(Locale l) {
         if (l == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("l == null");
         }
         this.locale = l;
         return this;
@@ -1724,7 +1724,7 @@ public final class Scanner implements Iterator<String> {
      */
     private void checkNull(Pattern pattern) {
         if (pattern == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("pattern == null");
         }
     }
 
diff --git a/luni/src/main/java/java/util/ServiceLoader.java b/luni/src/main/java/java/util/ServiceLoader.java
index beacaab..016ab3f 100644
--- a/luni/src/main/java/java/util/ServiceLoader.java
+++ b/luni/src/main/java/java/util/ServiceLoader.java
@@ -78,7 +78,7 @@ public final class ServiceLoader<S> implements Iterable<S> {
         // It makes no sense for service to be null.
         // classLoader is null if you want the system class loader.
         if (service == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("service == null");
         }
         this.service = service;
         this.classLoader = classLoader;
diff --git a/luni/src/main/java/java/util/StringTokenizer.java b/luni/src/main/java/java/util/StringTokenizer.java
index 1b07604..e6686e8 100644
--- a/luni/src/main/java/java/util/StringTokenizer.java
+++ b/luni/src/main/java/java/util/StringTokenizer.java
@@ -91,13 +91,13 @@ public class StringTokenizer implements Enumeration<Object> {
      */
     public StringTokenizer(String string, String delimiters,
             boolean returnDelimiters) {
-        if (string != null) {
-            this.string = string;
-            this.delimiters = delimiters;
-            this.returnDelimiters = returnDelimiters;
-            this.position = 0;
-        } else
-            throw new NullPointerException();
+        if (string == null) {
+            throw new NullPointerException("string == null");
+        }
+        this.string = string;
+        this.delimiters = delimiters;
+        this.returnDelimiters = returnDelimiters;
+        this.position = 0;
     }
 
     /**
@@ -143,7 +143,7 @@ public class StringTokenizer implements Enumeration<Object> {
      */
     public boolean hasMoreTokens() {
         if (delimiters == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("delimiters == null");
         }
         int length = string.length();
         if (position < length) {
@@ -180,7 +180,7 @@ public class StringTokenizer implements Enumeration<Object> {
      */
     public String nextToken() {
         if (delimiters == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("delimiters == null");
         }
         int i = position;
         int length = string.length();
diff --git a/luni/src/main/java/java/util/TimeZone.java b/luni/src/main/java/java/util/TimeZone.java
index b7d7da1..85011bc 100644
--- a/luni/src/main/java/java/util/TimeZone.java
+++ b/luni/src/main/java/java/util/TimeZone.java
@@ -405,7 +405,7 @@ public abstract class TimeZone implements Serializable, Cloneable {
      */
     public void setID(String id) {
         if (id == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("id == null");
         }
         ID = id;
     }
diff --git a/luni/src/main/java/java/util/Timer.java b/luni/src/main/java/java/util/Timer.java
index b4f7a83..afc745c 100644
--- a/luni/src/main/java/java/util/Timer.java
+++ b/luni/src/main/java/java/util/Timer.java
@@ -362,7 +362,7 @@ public class Timer {
      */
     public Timer(String name, boolean isDaemon) {
         if (name == null) {
-            throw new NullPointerException("name is null");
+            throw new NullPointerException("name == null");
         }
         this.impl = new TimerImpl(name, isDaemon);
         this.finalizer = new FinalizerHelper(impl);
diff --git a/luni/src/main/java/java/util/UUID.java b/luni/src/main/java/java/util/UUID.java
index a932bb2..8ac0a63 100644
--- a/luni/src/main/java/java/util/UUID.java
+++ b/luni/src/main/java/java/util/UUID.java
@@ -142,7 +142,7 @@ public final class UUID implements Serializable, Comparable<UUID> {
      */
     public static UUID nameUUIDFromBytes(byte[] name) {
         if (name == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("name == null");
         }
         try {
             MessageDigest md = MessageDigest.getInstance("MD5");
@@ -179,7 +179,7 @@ public final class UUID implements Serializable, Comparable<UUID> {
      */
     public static UUID fromString(String uuid) {
         if (uuid == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("uuid == null");
         }
 
         int[] position = new int[5];
diff --git a/luni/src/main/java/java/util/UnknownFormatConversionException.java b/luni/src/main/java/java/util/UnknownFormatConversionException.java
index e26de91..29af4e1 100644
--- a/luni/src/main/java/java/util/UnknownFormatConversionException.java
+++ b/luni/src/main/java/java/util/UnknownFormatConversionException.java
@@ -35,7 +35,7 @@ public class UnknownFormatConversionException extends IllegalFormatException {
      */
     public UnknownFormatConversionException(String s) {
         if (s == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("s == null");
         }
         this.s = s;
     }
diff --git a/luni/src/main/java/java/util/UnknownFormatFlagsException.java b/luni/src/main/java/java/util/UnknownFormatFlagsException.java
index 9daa3f1..990432b 100644
--- a/luni/src/main/java/java/util/UnknownFormatFlagsException.java
+++ b/luni/src/main/java/java/util/UnknownFormatFlagsException.java
@@ -37,7 +37,7 @@ public class UnknownFormatFlagsException extends IllegalFormatException {
      */
     public UnknownFormatFlagsException(String f) {
         if (f == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("f == null");
         }
         flags = f;
     }
diff --git a/luni/src/main/java/java/util/jar/JarOutputStream.java b/luni/src/main/java/java/util/jar/JarOutputStream.java
index 78e3aa5..fc0645e 100644
--- a/luni/src/main/java/java/util/jar/JarOutputStream.java
+++ b/luni/src/main/java/java/util/jar/JarOutputStream.java
@@ -37,20 +37,20 @@ public class JarOutputStream extends ZipOutputStream {
      *
      * @param os
      *            the {@code OutputStream} to write to
-     * @param mf
+     * @param manifest
      *            the {@code Manifest} to output for this JAR file.
      * @throws IOException
      *             if an error occurs creating the {@code JarOutputStream}.
      */
-    public JarOutputStream(OutputStream os, Manifest mf) throws IOException {
+    public JarOutputStream(OutputStream os, Manifest manifest) throws IOException {
         super(os);
-        if (mf == null) {
-            throw new NullPointerException();
+        if (manifest == null) {
+            throw new NullPointerException("manifest == null");
         }
-        manifest = mf;
+        this.manifest = manifest;
         ZipEntry ze = new ZipEntry(JarFile.MANIFEST_NAME);
         putNextEntry(ze);
-        manifest.write(this);
+        this.manifest.write(this);
         closeEntry();
     }
 
diff --git a/luni/src/main/java/java/util/logging/FileHandler.java b/luni/src/main/java/java/util/logging/FileHandler.java
index 980955a..6ffef87 100644
--- a/luni/src/main/java/java/util/logging/FileHandler.java
+++ b/luni/src/main/java/java/util/logging/FileHandler.java
@@ -214,8 +214,10 @@ public class FileHandler extends StreamHandler {
         String className = this.getClass().getName();
         pattern = (p == null) ? getStringProperty(className + ".pattern",
                 DEFAULT_PATTERN) : p;
-        if (pattern == null || pattern.isEmpty()) {
-            throw new NullPointerException("Pattern cannot be empty or null");
+        if (pattern == null) {
+            throw new NullPointerException("pattern == null");
+        } else if (pattern.isEmpty()) {
+            throw new NullPointerException("pattern.isEmpty()");
         }
         append = (a == null) ? getBooleanProperty(className + ".append",
                 DEFAULT_APPEND) : a.booleanValue();
diff --git a/luni/src/main/java/java/util/logging/Handler.java b/luni/src/main/java/java/util/logging/Handler.java
index 5a6c14e..13dbdd5 100644
--- a/luni/src/main/java/java/util/logging/Handler.java
+++ b/luni/src/main/java/java/util/logging/Handler.java
@@ -227,7 +227,7 @@ public abstract class Handler {
      */
     public boolean isLoggable(LogRecord record) {
         if (record == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("record == null");
         }
         if (this.level.intValue() == Level.OFF.intValue()) {
             return false;
@@ -294,17 +294,17 @@ public abstract class Handler {
     /**
      * Sets the error manager for this handler.
      *
-     * @param em
+     * @param newErrorManager
      *            the error manager to set.
      * @throws NullPointerException
      *             if {@code em} is {@code null}.
      */
-    public void setErrorManager(ErrorManager em) {
+    public void setErrorManager(ErrorManager newErrorManager) {
         LogManager.getLogManager().checkAccess();
-        if (em == null) {
-            throw new NullPointerException();
+        if (newErrorManager == null) {
+            throw new NullPointerException("newErrorManager == null");
         }
-        this.errorMan = em;
+        this.errorMan = newErrorManager;
     }
 
     /**
@@ -327,7 +327,7 @@ public abstract class Handler {
      */
     void internalSetFormatter(Formatter newFormatter) {
         if (newFormatter == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("newFormatter == null");
         }
         this.formatter = newFormatter;
     }
@@ -356,7 +356,7 @@ public abstract class Handler {
      */
     public void setLevel(Level newLevel) {
         if (newLevel == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("newLevel == null");
         }
         LogManager.getLogManager().checkAccess();
         this.level = newLevel;
diff --git a/luni/src/main/java/java/util/logging/LogManager.java b/luni/src/main/java/java/util/logging/LogManager.java
index 449c263..8877cd5 100644
--- a/luni/src/main/java/java/util/logging/LogManager.java
+++ b/luni/src/main/java/java/util/logging/LogManager.java
@@ -446,7 +446,7 @@ public class LogManager {
      */
     public void addPropertyChangeListener(PropertyChangeListener l) {
         if (l == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("l == null");
         }
         checkAccess();
         listeners.addPropertyChangeListener(l);
diff --git a/luni/src/main/java/java/util/logging/StreamHandler.java b/luni/src/main/java/java/util/logging/StreamHandler.java
index 7581835..60b4321 100644
--- a/luni/src/main/java/java/util/logging/StreamHandler.java
+++ b/luni/src/main/java/java/util/logging/StreamHandler.java
@@ -167,7 +167,7 @@ public class StreamHandler extends Handler {
      */
     protected void setOutputStream(OutputStream os) {
         if (os == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("os == null");
         }
         LogManager.getLogManager().checkAccess();
         close(true);
diff --git a/luni/src/main/java/java/util/prefs/AbstractPreferences.java b/luni/src/main/java/java/util/prefs/AbstractPreferences.java
index d86d789..71110c3 100644
--- a/luni/src/main/java/java/util/prefs/AbstractPreferences.java
+++ b/luni/src/main/java/java/util/prefs/AbstractPreferences.java
@@ -372,7 +372,7 @@ public abstract class AbstractPreferences extends Preferences {
     @Override
     public void exportNode(OutputStream ostream) throws IOException, BackingStoreException {
         if (ostream == null) {
-            throw new NullPointerException("Stream is null");
+            throw new NullPointerException("ostream == null");
         }
         checkState();
         XMLParser.exportPrefs(this, ostream, false);
@@ -381,7 +381,7 @@ public abstract class AbstractPreferences extends Preferences {
     @Override
     public void exportSubtree(OutputStream ostream) throws IOException, BackingStoreException {
         if (ostream == null) {
-            throw new NullPointerException("Stream is null");
+            throw new NullPointerException("ostream == null");
         }
         checkState();
         XMLParser.exportPrefs(this, ostream, true);
@@ -402,7 +402,7 @@ public abstract class AbstractPreferences extends Preferences {
     @Override
     public String get(String key, String deflt) {
         if (key == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("key == null");
         }
         String result = null;
         synchronized (lock) {
@@ -597,7 +597,7 @@ public abstract class AbstractPreferences extends Preferences {
     @Override
     public boolean nodeExists(String name) throws BackingStoreException {
         if (name == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("name == null");
         }
         AbstractPreferences startNode = null;
         synchronized (lock) {
@@ -640,8 +640,10 @@ public abstract class AbstractPreferences extends Preferences {
 
     @Override
     public void put(String key, String value) {
-        if (key == null || value == null) {
-            throw new NullPointerException();
+        if (key == null) {
+            throw new NullPointerException("key == null");
+        } else if (value == null) {
+            throw new NullPointerException("value == null");
         }
         if (key.length() > MAX_KEY_LENGTH || value.length() > MAX_VALUE_LENGTH) {
             throw new IllegalArgumentException();
@@ -730,7 +732,7 @@ public abstract class AbstractPreferences extends Preferences {
     @Override
     public void addNodeChangeListener(NodeChangeListener ncl) {
         if (ncl == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("ncl == null");
         }
         checkState();
         synchronized (nodeChangeListeners) {
@@ -741,7 +743,7 @@ public abstract class AbstractPreferences extends Preferences {
     @Override
     public void addPreferenceChangeListener(PreferenceChangeListener pcl) {
         if (pcl == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("pcl == null");
         }
         checkState();
         synchronized (preferenceChangeListeners) {
diff --git a/luni/src/main/java/java/util/zip/DeflaterInputStream.java b/luni/src/main/java/java/util/zip/DeflaterInputStream.java
index c6e95f2..805ce17 100644
--- a/luni/src/main/java/java/util/zip/DeflaterInputStream.java
+++ b/luni/src/main/java/java/util/zip/DeflaterInputStream.java
@@ -72,8 +72,10 @@ public class DeflaterInputStream extends FilterInputStream {
      */
     public DeflaterInputStream(InputStream in, Deflater deflater, int bufferSize) {
         super(in);
-        if (in == null || deflater == null) {
-            throw new NullPointerException();
+        if (in == null) {
+            throw new NullPointerException("in == null");
+        } else if (deflater == null) {
+            throw new NullPointerException("deflater == null");
         }
         if (bufferSize <= 0) {
             throw new IllegalArgumentException();
diff --git a/luni/src/main/java/java/util/zip/DeflaterOutputStream.java b/luni/src/main/java/java/util/zip/DeflaterOutputStream.java
index b0bcb99..d336e72 100644
--- a/luni/src/main/java/java/util/zip/DeflaterOutputStream.java
+++ b/luni/src/main/java/java/util/zip/DeflaterOutputStream.java
@@ -115,8 +115,10 @@ public class DeflaterOutputStream extends FilterOutputStream {
      */
     public DeflaterOutputStream(OutputStream os, Deflater def, int bsize, boolean syncFlush) {
         super(os);
-        if (os == null || def == null) {
-            throw new NullPointerException();
+        if (os == null) {
+            throw new NullPointerException("os == null");
+        } else if (def == null) {
+            throw new NullPointerException("def == null");
         }
         if (bsize <= 0) {
             throw new IllegalArgumentException();
diff --git a/luni/src/main/java/java/util/zip/InflaterInputStream.java b/luni/src/main/java/java/util/zip/InflaterInputStream.java
index 580d605..6081037 100644
--- a/luni/src/main/java/java/util/zip/InflaterInputStream.java
+++ b/luni/src/main/java/java/util/zip/InflaterInputStream.java
@@ -103,8 +103,10 @@ public class InflaterInputStream extends FilterInputStream {
      */
     public InflaterInputStream(InputStream is, Inflater inflater, int bsize) {
         super(is);
-        if (is == null || inflater == null) {
-            throw new NullPointerException();
+        if (is == null) {
+            throw new NullPointerException("is == null");
+        } else if (inflater == null) {
+            throw new NullPointerException("inflater == null");
         }
         if (bsize <= 0) {
             throw new IllegalArgumentException();
diff --git a/luni/src/main/java/java/util/zip/InflaterOutputStream.java b/luni/src/main/java/java/util/zip/InflaterOutputStream.java
index c9687b6..9a699a8 100644
--- a/luni/src/main/java/java/util/zip/InflaterOutputStream.java
+++ b/luni/src/main/java/java/util/zip/InflaterOutputStream.java
@@ -70,8 +70,10 @@ public class InflaterOutputStream extends FilterOutputStream {
      */
     public InflaterOutputStream(OutputStream out, Inflater inf, int bufferSize) {
         super(out);
-        if (out == null || inf == null) {
-            throw new NullPointerException();
+        if (out == null) {
+            throw new NullPointerException("out == null");
+        } else if (inf == null) {
+            throw new NullPointerException("inf == null");
         }
         if (bufferSize <= 0) {
             throw new IllegalArgumentException();
diff --git a/luni/src/main/java/java/util/zip/ZipEntry.java b/luni/src/main/java/java/util/zip/ZipEntry.java
index 988bd2c..e2bfc8d 100644
--- a/luni/src/main/java/java/util/zip/ZipEntry.java
+++ b/luni/src/main/java/java/util/zip/ZipEntry.java
@@ -71,7 +71,7 @@ public class ZipEntry implements ZipConstants, Cloneable {
      */
     public ZipEntry(String name) {
         if (name == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("name == null");
         }
         if (name.length() > 0xFFFF) {
             throw new IllegalArgumentException("Name too long: " + name.length());
diff --git a/luni/src/main/java/java/util/zip/ZipFile.java b/luni/src/main/java/java/util/zip/ZipFile.java
index 363f57e..6ecd489 100644
--- a/luni/src/main/java/java/util/zip/ZipFile.java
+++ b/luni/src/main/java/java/util/zip/ZipFile.java
@@ -223,7 +223,7 @@ public class ZipFile implements ZipConstants {
     public ZipEntry getEntry(String entryName) {
         checkNotClosed();
         if (entryName == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("entryName == null");
         }
 
         ZipEntry ze = mEntries.get(entryName);
diff --git a/luni/src/main/java/java/util/zip/ZipInputStream.java b/luni/src/main/java/java/util/zip/ZipInputStream.java
index d082fc7..e7c4566 100644
--- a/luni/src/main/java/java/util/zip/ZipInputStream.java
+++ b/luni/src/main/java/java/util/zip/ZipInputStream.java
@@ -101,7 +101,7 @@ public class ZipInputStream extends InflaterInputStream implements ZipConstants
     public ZipInputStream(InputStream stream) {
         super(new PushbackInputStream(stream, BUF_SIZE), new Inflater(true));
         if (stream == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("stream == null");
         }
     }
 
diff --git a/luni/src/main/java/javax/crypto/Cipher.java b/luni/src/main/java/javax/crypto/Cipher.java
index 1dacd46..aeb5def 100644
--- a/luni/src/main/java/javax/crypto/Cipher.java
+++ b/luni/src/main/java/javax/crypto/Cipher.java
@@ -141,10 +141,10 @@ public class Cipher {
     protected Cipher(CipherSpi cipherSpi, Provider provider,
             String transformation) {
         if (cipherSpi == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("cipherSpi == null");
         }
         if (!(cipherSpi instanceof NullCipherSpi) && provider == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("provider == null");
         }
         this.provider = provider;
         this.transformation = transformation;
@@ -1332,7 +1332,7 @@ public class Cipher {
     public static final int getMaxAllowedKeyLength(String transformation)
             throws NoSuchAlgorithmException {
         if (transformation == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("transformation == null");
         }
         checkTransformation(transformation);
         //FIXME jurisdiction policy files
@@ -1356,7 +1356,7 @@ public class Cipher {
     public static final AlgorithmParameterSpec getMaxAllowedParameterSpec(
             String transformation) throws NoSuchAlgorithmException {
         if (transformation == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("transformation == null");
         }
         checkTransformation(transformation);
         //FIXME jurisdiction policy files
diff --git a/luni/src/main/java/javax/crypto/CipherInputStream.java b/luni/src/main/java/javax/crypto/CipherInputStream.java
index 39dcfda..a59a425 100644
--- a/luni/src/main/java/javax/crypto/CipherInputStream.java
+++ b/luni/src/main/java/javax/crypto/CipherInputStream.java
@@ -135,7 +135,7 @@ public class CipherInputStream extends FilterInputStream {
     @Override
     public int read(byte[] buf, int off, int len) throws IOException {
         if (in == null) {
-            throw new NullPointerException("Underlying input stream is null");
+            throw new NullPointerException("in == null");
         }
 
         int i;
diff --git a/luni/src/main/java/javax/crypto/EncryptedPrivateKeyInfo.java b/luni/src/main/java/javax/crypto/EncryptedPrivateKeyInfo.java
index 034f07a..0fb5b76 100644
--- a/luni/src/main/java/javax/crypto/EncryptedPrivateKeyInfo.java
+++ b/luni/src/main/java/javax/crypto/EncryptedPrivateKeyInfo.java
@@ -121,7 +121,7 @@ public class EncryptedPrivateKeyInfo {
      * Creates an {@code EncryptedPrivateKeyInfo} instance from an algorithm
      * name and its encrypted data.
      *
-     * @param encrAlgName
+     * @param encryptionAlgorithmName
      *            the name of an algorithm.
      * @param encryptedData
      *            the encrypted data.
@@ -133,12 +133,12 @@ public class EncryptedPrivateKeyInfo {
      * @throws IllegalArgumentException
      *             if {@code encryptedData} is empty.
      */
-    public EncryptedPrivateKeyInfo(String encrAlgName, byte[] encryptedData)
+    public EncryptedPrivateKeyInfo(String encryptionAlgorithmName, byte[] encryptedData)
         throws NoSuchAlgorithmException {
-        if (encrAlgName == null) {
-            throw new NullPointerException("the algName parameter is null");
+        if (encryptionAlgorithmName == null) {
+            throw new NullPointerException("encryptionAlgorithmName == null");
         }
-        this.algName = encrAlgName;
+        this.algName = encryptionAlgorithmName;
         if (!mapAlgName()) {
             throw new NoSuchAlgorithmException("Unsupported algorithm: " + this.algName);
         }
diff --git a/luni/src/main/java/javax/crypto/ExemptionMechanism.java b/luni/src/main/java/javax/crypto/ExemptionMechanism.java
index 2ac4994..8745b78 100644
--- a/luni/src/main/java/javax/crypto/ExemptionMechanism.java
+++ b/luni/src/main/java/javax/crypto/ExemptionMechanism.java
@@ -98,7 +98,7 @@ public class ExemptionMechanism {
     public static final ExemptionMechanism getInstance(String algorithm)
             throws NoSuchAlgorithmException {
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Engine.SpiAndProvider sap = ENGINE.getInstance(algorithm, null);
         return new ExemptionMechanism((ExemptionMechanismSpi) sap.spi, sap.provider, algorithm);
@@ -134,7 +134,7 @@ public class ExemptionMechanism {
             throw new NoSuchProviderException(provider);
         }
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         return getInstance(algorithm, impProvider);
     }
@@ -159,7 +159,7 @@ public class ExemptionMechanism {
     public static final ExemptionMechanism getInstance(String algorithm,
             Provider provider) throws NoSuchAlgorithmException {
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         if (provider == null) {
             throw new IllegalArgumentException("provider == null");
diff --git a/luni/src/main/java/javax/crypto/KeyAgreement.java b/luni/src/main/java/javax/crypto/KeyAgreement.java
index 9c5d86c..51b4cd1 100644
--- a/luni/src/main/java/javax/crypto/KeyAgreement.java
+++ b/luni/src/main/java/javax/crypto/KeyAgreement.java
@@ -99,7 +99,7 @@ public class KeyAgreement {
     public static final KeyAgreement getInstance(String algorithm)
             throws NoSuchAlgorithmException {
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Engine.SpiAndProvider sap = ENGINE.getInstance(algorithm, null);
         return new KeyAgreement((KeyAgreementSpi) sap.spi, sap.provider, algorithm);
@@ -161,7 +161,7 @@ public class KeyAgreement {
             throw new IllegalArgumentException("provider == null");
         }
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Object spi = ENGINE.getInstance(algorithm, provider, null);
         return new KeyAgreement((KeyAgreementSpi) spi, provider, algorithm);
diff --git a/luni/src/main/java/javax/crypto/KeyGenerator.java b/luni/src/main/java/javax/crypto/KeyGenerator.java
index 77b1a82..606998a 100644
--- a/luni/src/main/java/javax/crypto/KeyGenerator.java
+++ b/luni/src/main/java/javax/crypto/KeyGenerator.java
@@ -98,7 +98,7 @@ public class KeyGenerator {
     public static final KeyGenerator getInstance(String algorithm)
             throws NoSuchAlgorithmException {
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Engine.SpiAndProvider sap = ENGINE.getInstance(algorithm, null);
         return new KeyGenerator((KeyGeneratorSpi) sap.spi, sap.provider, algorithm);
@@ -158,7 +158,7 @@ public class KeyGenerator {
             throw new IllegalArgumentException("provider == null");
         }
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Object spi = ENGINE.getInstance(algorithm, provider, null);
         return new KeyGenerator((KeyGeneratorSpi) spi, provider, algorithm);
diff --git a/luni/src/main/java/javax/crypto/Mac.java b/luni/src/main/java/javax/crypto/Mac.java
index 1a05b59..46be141 100644
--- a/luni/src/main/java/javax/crypto/Mac.java
+++ b/luni/src/main/java/javax/crypto/Mac.java
@@ -101,7 +101,7 @@ public class Mac implements Cloneable {
     public static final Mac getInstance(String algorithm)
             throws NoSuchAlgorithmException {
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Engine.SpiAndProvider sap = ENGINE.getInstance(algorithm, null);
         return new Mac((MacSpi) sap.spi, sap.provider, algorithm);
@@ -163,7 +163,7 @@ public class Mac implements Cloneable {
             throw new IllegalArgumentException("provider == null");
         }
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Object spi = ENGINE.getInstance(algorithm, provider, null);
         return new Mac((MacSpi) spi, provider, algorithm);
diff --git a/luni/src/main/java/javax/crypto/SecretKeyFactory.java b/luni/src/main/java/javax/crypto/SecretKeyFactory.java
index 5e47abe..8ab3eb8 100644
--- a/luni/src/main/java/javax/crypto/SecretKeyFactory.java
+++ b/luni/src/main/java/javax/crypto/SecretKeyFactory.java
@@ -103,7 +103,7 @@ public class SecretKeyFactory {
     public static final SecretKeyFactory getInstance(String algorithm)
             throws NoSuchAlgorithmException {
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Engine.SpiAndProvider sap = ENGINE.getInstance(algorithm, null);
         return new SecretKeyFactory((SecretKeyFactorySpi) sap.spi, sap.provider, algorithm);
@@ -165,7 +165,7 @@ public class SecretKeyFactory {
             throw new IllegalArgumentException("provider == null");
         }
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Object spi = ENGINE.getInstance(algorithm, provider, null);
         return new SecretKeyFactory((SecretKeyFactorySpi) spi, provider, algorithm);
diff --git a/luni/src/main/java/javax/crypto/spec/DESedeKeySpec.java b/luni/src/main/java/javax/crypto/spec/DESedeKeySpec.java
index fe86aeb..fcfe749 100644
--- a/luni/src/main/java/javax/crypto/spec/DESedeKeySpec.java
+++ b/luni/src/main/java/javax/crypto/spec/DESedeKeySpec.java
@@ -45,7 +45,7 @@ public class DESedeKeySpec implements KeySpec {
      */
     public DESedeKeySpec(byte[] key) throws InvalidKeyException {
         if (key == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("key == null");
         }
         if (key.length < DES_EDE_KEY_LEN) {
             throw new InvalidKeyException();
@@ -71,7 +71,7 @@ public class DESedeKeySpec implements KeySpec {
      */
     public DESedeKeySpec(byte[] key, int offset) throws InvalidKeyException {
         if (key == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("key == null");
         }
         if (key.length - offset < DES_EDE_KEY_LEN) {
             throw new InvalidKeyException();
diff --git a/luni/src/main/java/javax/crypto/spec/OAEPParameterSpec.java b/luni/src/main/java/javax/crypto/spec/OAEPParameterSpec.java
index 3bc9ab4..340e57f 100644
--- a/luni/src/main/java/javax/crypto/spec/OAEPParameterSpec.java
+++ b/luni/src/main/java/javax/crypto/spec/OAEPParameterSpec.java
@@ -73,8 +73,12 @@ public class OAEPParameterSpec implements AlgorithmParameterSpec {
      */
     public OAEPParameterSpec(String mdName, String mgfName,
                                 AlgorithmParameterSpec mgfSpec, PSource pSrc) {
-        if ((mdName == null) || (mgfName == null) || (pSrc == null)) {
-            throw new NullPointerException();
+        if (mdName == null) {
+            throw new NullPointerException("mdName == null");
+        } else if (mgfName == null) {
+            throw new NullPointerException("mgfName == null");
+        } else if (pSrc == null) {
+            throw new NullPointerException("pSrc == null");
         }
         this.mdName = mdName;
         this.mgfName = mgfName;
diff --git a/luni/src/main/java/javax/crypto/spec/PSource.java b/luni/src/main/java/javax/crypto/spec/PSource.java
index 0efa1e9..f644316 100644
--- a/luni/src/main/java/javax/crypto/spec/PSource.java
+++ b/luni/src/main/java/javax/crypto/spec/PSource.java
@@ -40,7 +40,7 @@ public class PSource {
      */
     protected PSource(String pSrcName) {
         if (pSrcName == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("pSrcName == null");
         }
         this.pSrcName = pSrcName;
     }
@@ -85,7 +85,7 @@ public class PSource {
         public PSpecified(byte[] p) {
             super("PSpecified");
             if (p == null) {
-                throw new NullPointerException();
+                throw new NullPointerException("p == null");
             }
             //TODO: It is unknown which name should be used!
             //super("");
diff --git a/luni/src/main/java/javax/net/ssl/KeyManagerFactory.java b/luni/src/main/java/javax/net/ssl/KeyManagerFactory.java
index 82ce8a1..0b3db61 100644
--- a/luni/src/main/java/javax/net/ssl/KeyManagerFactory.java
+++ b/luni/src/main/java/javax/net/ssl/KeyManagerFactory.java
@@ -68,7 +68,7 @@ public class KeyManagerFactory {
     public static final KeyManagerFactory getInstance(String algorithm)
             throws NoSuchAlgorithmException {
         if (algorithm == null) {
-            throw new NullPointerException("algorithm is null");
+            throw new NullPointerException("algorithm == null");
         }
         Engine.SpiAndProvider sap = ENGINE.getInstance(algorithm, null);
         return new KeyManagerFactory((KeyManagerFactorySpi) sap.spi, sap.provider, algorithm);
@@ -127,7 +127,7 @@ public class KeyManagerFactory {
             throw new IllegalArgumentException("Provider is null");
         }
         if (algorithm == null) {
-            throw new NullPointerException("algorithm is null");
+            throw new NullPointerException("algorithm == null");
         }
         Object spi = ENGINE.getInstance(algorithm, provider, null);
         return new KeyManagerFactory((KeyManagerFactorySpi) spi, provider, algorithm);
diff --git a/luni/src/main/java/javax/net/ssl/SSLContext.java b/luni/src/main/java/javax/net/ssl/SSLContext.java
index 9097bb9..a59f301 100644
--- a/luni/src/main/java/javax/net/ssl/SSLContext.java
+++ b/luni/src/main/java/javax/net/ssl/SSLContext.java
@@ -93,7 +93,7 @@ public class SSLContext {
      */
     public static SSLContext getInstance(String protocol) throws NoSuchAlgorithmException {
         if (protocol == null) {
-            throw new NullPointerException("protocol is null");
+            throw new NullPointerException("protocol == null");
         }
         Engine.SpiAndProvider sap = ENGINE.getInstance(protocol, null);
         return new SSLContext((SSLContextSpi) sap.spi, sap.provider, protocol);
@@ -154,7 +154,7 @@ public class SSLContext {
             throw new IllegalArgumentException("provider is null");
         }
         if (protocol == null) {
-            throw new NullPointerException("protocol is null");
+            throw new NullPointerException("protocol == null");
         }
         Object spi = ENGINE.getInstance(protocol, provider, null);
         return new SSLContext((SSLContextSpi) spi, provider, protocol);
diff --git a/luni/src/main/java/javax/net/ssl/TrustManagerFactory.java b/luni/src/main/java/javax/net/ssl/TrustManagerFactory.java
index bf3bf8c..be9db06 100644
--- a/luni/src/main/java/javax/net/ssl/TrustManagerFactory.java
+++ b/luni/src/main/java/javax/net/ssl/TrustManagerFactory.java
@@ -67,7 +67,7 @@ public class TrustManagerFactory {
     public static final TrustManagerFactory getInstance(String algorithm)
             throws NoSuchAlgorithmException {
         if (algorithm == null) {
-            throw new NullPointerException("algorithm is null");
+            throw new NullPointerException("algorithm == null");
         }
         Engine.SpiAndProvider sap = ENGINE.getInstance(algorithm, null);
         return new TrustManagerFactory((TrustManagerFactorySpi) sap.spi, sap.provider, algorithm);
@@ -126,7 +126,7 @@ public class TrustManagerFactory {
             throw new IllegalArgumentException("Provider is null");
         }
         if (algorithm == null) {
-            throw new NullPointerException("algorithm is null");
+            throw new NullPointerException("algorithm == null");
         }
         Object spi = ENGINE.getInstance(algorithm, provider, null);
         return new TrustManagerFactory((TrustManagerFactorySpi) spi, provider, algorithm);
diff --git a/luni/src/main/java/javax/security/auth/Subject.java b/luni/src/main/java/javax/security/auth/Subject.java
index a958484..6c9c036 100644
--- a/luni/src/main/java/javax/security/auth/Subject.java
+++ b/luni/src/main/java/javax/security/auth/Subject.java
@@ -116,8 +116,12 @@ public final class Subject implements Serializable {
     public Subject(boolean readOnly, Set<? extends Principal> subjPrincipals,
             Set<?> pubCredentials, Set<?> privCredentials) {
 
-        if (subjPrincipals == null || pubCredentials == null || privCredentials == null) {
-            throw new NullPointerException();
+        if (subjPrincipals == null) {
+            throw new NullPointerException("subjPrincipals == null");
+        } else if (pubCredentials == null) {
+            throw new NullPointerException("pubCredentials == null");
+        } else if (privCredentials == null) {
+            throw new NullPointerException("privCredentials == null");
         }
 
         principals = new SecureSet<Principal>(_PRINCIPALS, subjPrincipals);
@@ -467,7 +471,7 @@ public final class Subject implements Serializable {
      */
     public static Subject getSubject(final AccessControlContext context) {
         if (context == null) {
-            throw new NullPointerException("AccessControlContext cannot be null");
+            throw new NullPointerException("context == null");
         }
         PrivilegedAction<DomainCombiner> action = new PrivilegedAction<DomainCombiner>() {
             public DomainCombiner run() {
@@ -554,7 +558,7 @@ public final class Subject implements Serializable {
         private void verifyElement(Object o) {
 
             if (o == null) {
-                throw new NullPointerException();
+                throw new NullPointerException("o == null");
             }
             if (permission == _PRINCIPALS && !(Principal.class.isAssignableFrom(o.getClass()))) {
                 throw new IllegalArgumentException("Element is not instance of java.security.Principal");
@@ -607,7 +611,7 @@ public final class Subject implements Serializable {
         public boolean retainAll(Collection<?> c) {
 
             if (c == null) {
-                throw new NullPointerException();
+                throw new NullPointerException("c == null");
             }
             return super.retainAll(c);
         }
@@ -624,7 +628,7 @@ public final class Subject implements Serializable {
         protected final <E> Set<E> get(final Class<E> c) {
 
             if (c == null) {
-                throw new NullPointerException();
+                throw new NullPointerException("c == null");
             }
 
             AbstractSet<E> s = new AbstractSet<E>() {
@@ -652,7 +656,7 @@ public final class Subject implements Serializable {
                 public boolean retainAll(Collection<?> c) {
 
                     if (c == null) {
-                        throw new NullPointerException();
+                        throw new NullPointerException("c == null");
                     }
                     return super.retainAll(c);
                 }
diff --git a/luni/src/main/java/javax/security/auth/x500/X500Principal.java b/luni/src/main/java/javax/security/auth/x500/X500Principal.java
index e6453e9..cedebe0 100644
--- a/luni/src/main/java/javax/security/auth/x500/X500Principal.java
+++ b/luni/src/main/java/javax/security/auth/x500/X500Principal.java
@@ -123,7 +123,7 @@ public final class X500Principal implements Serializable, Principal {
      */
     public X500Principal(String name) {
         if (name == null) {
-            throw new NullPointerException("Name cannot be null");
+            throw new NullPointerException("name == null");
         }
         try {
             dn = new Name(name);
@@ -134,7 +134,7 @@ public final class X500Principal implements Serializable, Principal {
 
     public X500Principal(String name, Map<String,String> keywordMap){
         if (name == null) {
-            throw new NullPointerException("Name cannot be null");
+            throw new NullPointerException("name == null");
         }
         try {
             dn = new Name(substituteNameFromMap(name, keywordMap));
diff --git a/luni/src/main/java/javax/xml/datatype/DatatypeFactory.java b/luni/src/main/java/javax/xml/datatype/DatatypeFactory.java
index 6a89dae..68291b6 100644
--- a/luni/src/main/java/javax/xml/datatype/DatatypeFactory.java
+++ b/luni/src/main/java/javax/xml/datatype/DatatypeFactory.java
@@ -326,7 +326,7 @@ public abstract class DatatypeFactory {
      */
     public Duration newDurationDayTime(final String lexicalRepresentation) {
         if (lexicalRepresentation == null) {
-            throw new NullPointerException("The lexical representation cannot be null.");
+            throw new NullPointerException("lexicalRepresentation == null");
         }
         // The lexical representation must match the pattern [^YM]*(T.*)?
         int pos = lexicalRepresentation.indexOf('T');
@@ -539,7 +539,7 @@ public abstract class DatatypeFactory {
      */
     public Duration newDurationYearMonth(final String lexicalRepresentation) {
         if (lexicalRepresentation == null) {
-            throw new NullPointerException("The lexical representation cannot be null.");
+            throw new NullPointerException("lexicalRepresentation == null");
         }
         // The lexical representation must match the pattern [^DT]*.
         int length = lexicalRepresentation.length();
diff --git a/luni/src/main/java/javax/xml/datatype/Duration.java b/luni/src/main/java/javax/xml/datatype/Duration.java
index 8121d36..fcdd4c5 100644
--- a/luni/src/main/java/javax/xml/datatype/Duration.java
+++ b/luni/src/main/java/javax/xml/datatype/Duration.java
@@ -552,11 +552,7 @@ public abstract class   Duration {
 
         // check data parameter
         if (date == null) {
-            throw new NullPointerException(
-                    "Cannot call "
-                    + this.getClass().getName()
-                    + "#addTo(Date date) with date == null."
-            );
+            throw new NullPointerException("date == null");
         }
 
         Calendar cal = new GregorianCalendar();
diff --git a/luni/src/main/java/javax/xml/validation/SchemaFactory.java b/luni/src/main/java/javax/xml/validation/SchemaFactory.java
index 23e4798..2018067 100644
--- a/luni/src/main/java/javax/xml/validation/SchemaFactory.java
+++ b/luni/src/main/java/javax/xml/validation/SchemaFactory.java
@@ -203,8 +203,10 @@ public abstract class SchemaFactory {
      */
     public static SchemaFactory newInstance(String schemaLanguage, String factoryClassName,
             ClassLoader classLoader) {
-        if (schemaLanguage == null || factoryClassName == null) {
-            throw new NullPointerException("schemaLanguage == null || factoryClassName == null");
+        if (schemaLanguage == null) {
+            throw new NullPointerException("schemaLanguage == null");
+        } else if (factoryClassName == null) {
+            throw new NullPointerException("factoryClassName == null");
         }
         if (classLoader == null) {
             classLoader = Thread.currentThread().getContextClassLoader();
@@ -265,7 +267,7 @@ public abstract class SchemaFactory {
     public boolean getFeature(String name) throws SAXNotRecognizedException, SAXNotSupportedException {
 
         if (name == null) {
-            throw new NullPointerException("the name parameter is null");
+            throw new NullPointerException("name == null");
         }
         throw new SAXNotRecognizedException(name);
     }
@@ -313,7 +315,7 @@ public abstract class SchemaFactory {
      */
     public void setFeature(String name, boolean value) throws SAXNotRecognizedException, SAXNotSupportedException {
         if (name == null) {
-            throw new NullPointerException("the name parameter is null");
+            throw new NullPointerException("name == null");
         }
         throw new SAXNotRecognizedException(name);
     }
@@ -340,7 +342,7 @@ public abstract class SchemaFactory {
      */
     public void setProperty(String name, Object object) throws SAXNotRecognizedException, SAXNotSupportedException {
         if (name == null) {
-            throw new NullPointerException("the name parameter is null");
+            throw new NullPointerException("name == null");
         }
         throw new SAXNotRecognizedException(name);
     }
@@ -371,7 +373,7 @@ public abstract class SchemaFactory {
      */
     public Object getProperty(String name) throws SAXNotRecognizedException, SAXNotSupportedException {
         if (name == null) {
-            throw new NullPointerException("the name parameter is null");
+            throw new NullPointerException("name == null");
         }
         throw new SAXNotRecognizedException(name);
     }
diff --git a/luni/src/main/java/javax/xml/validation/SchemaFactoryFinder.java b/luni/src/main/java/javax/xml/validation/SchemaFactoryFinder.java
index 3a6cb83..636777c 100644
--- a/luni/src/main/java/javax/xml/validation/SchemaFactoryFinder.java
+++ b/luni/src/main/java/javax/xml/validation/SchemaFactoryFinder.java
@@ -131,7 +131,9 @@ final class SchemaFactoryFinder  {
      *      If the <tt>schemaLanguage</tt> parameter is null.
      */
     public SchemaFactory newFactory(String schemaLanguage) {
-        if(schemaLanguage==null)        throw new NullPointerException();
+        if (schemaLanguage == null) {
+            throw new NullPointerException("schemaLanguage == null");
+        }
         SchemaFactory f = _newFactory(schemaLanguage);
         if (debug) {
             if (f != null) {
diff --git a/luni/src/main/java/javax/xml/validation/Validator.java b/luni/src/main/java/javax/xml/validation/Validator.java
index b4ee1ca..ea7908a 100644
--- a/luni/src/main/java/javax/xml/validation/Validator.java
+++ b/luni/src/main/java/javax/xml/validation/Validator.java
@@ -339,7 +339,9 @@ public abstract class Validator {
      * @see #setFeature(String, boolean)
      */
     public boolean getFeature(String name) throws SAXNotRecognizedException, SAXNotSupportedException {
-        if(name==null) throw new NullPointerException("the name parameter is null");
+        if (name == null) {
+            throw new NullPointerException("name == null");
+        }
         throw new SAXNotRecognizedException(name);
     }
 
@@ -372,7 +374,9 @@ public abstract class Validator {
      * @see #getFeature(String)
      */
     public void setFeature(String name, boolean value) throws SAXNotRecognizedException, SAXNotSupportedException {
-        if(name==null) throw new NullPointerException("the name parameter is null");
+        if (name == null) {
+            throw new NullPointerException("name == null");
+        }
         throw new SAXNotRecognizedException(name);
     }
 
@@ -400,7 +404,9 @@ public abstract class Validator {
      *          When the name parameter is null.
      */
     public void setProperty(String name, Object object) throws SAXNotRecognizedException, SAXNotSupportedException {
-        if(name==null) throw new NullPointerException("the name parameter is null");
+        if (name == null) {
+            throw new NullPointerException("name == null");
+        }
         throw new SAXNotRecognizedException(name);
     }
 
@@ -431,7 +437,9 @@ public abstract class Validator {
      * @see #setProperty(String, Object)
      */
     public Object getProperty(String name) throws SAXNotRecognizedException, SAXNotSupportedException {
-        if(name==null) throw new NullPointerException("the name parameter is null");
+        if (name == null) {
+            throw new NullPointerException("name == null");
+        }
         throw new SAXNotRecognizedException(name);
     }
 }
diff --git a/luni/src/main/java/javax/xml/validation/ValidatorHandler.java b/luni/src/main/java/javax/xml/validation/ValidatorHandler.java
index 9606193..2b621ff 100644
--- a/luni/src/main/java/javax/xml/validation/ValidatorHandler.java
+++ b/luni/src/main/java/javax/xml/validation/ValidatorHandler.java
@@ -347,8 +347,9 @@ public abstract class ValidatorHandler implements ContentHandler {
      * @see #setFeature(String, boolean)
      */
     public boolean getFeature(String name) throws SAXNotRecognizedException, SAXNotSupportedException {
-        if(name==null)
-            throw new NullPointerException();
+        if (name == null) {
+            throw new NullPointerException("name == null");
+        }
         throw new SAXNotRecognizedException(name);
     }
 
@@ -381,8 +382,9 @@ public abstract class ValidatorHandler implements ContentHandler {
      * @see #getFeature(String)
      */
     public void setFeature(String name, boolean value) throws SAXNotRecognizedException, SAXNotSupportedException {
-        if(name==null)
-            throw new NullPointerException();
+        if (name == null) {
+            throw new NullPointerException("name == null");
+        }
         throw new SAXNotRecognizedException(name);
     }
 
@@ -411,8 +413,9 @@ public abstract class ValidatorHandler implements ContentHandler {
      *          When the name parameter is null.
      */
     public void setProperty(String name, Object object) throws SAXNotRecognizedException, SAXNotSupportedException {
-        if(name==null)
-            throw new NullPointerException();
+        if (name == null) {
+            throw new NullPointerException("name == null");
+        }
         throw new SAXNotRecognizedException(name);
     }
 
@@ -443,8 +446,9 @@ public abstract class ValidatorHandler implements ContentHandler {
      * @see #setProperty(String, Object)
      */
     public Object getProperty(String name) throws SAXNotRecognizedException, SAXNotSupportedException {
-        if(name==null)
-            throw new NullPointerException();
+        if (name == null) {
+            throw new NullPointerException("name == null");
+        }
         throw new SAXNotRecognizedException(name);
     }
 }
diff --git a/luni/src/main/java/javax/xml/xpath/XPathException.java b/luni/src/main/java/javax/xml/xpath/XPathException.java
index 8db369b..376d477 100644
--- a/luni/src/main/java/javax/xml/xpath/XPathException.java
+++ b/luni/src/main/java/javax/xml/xpath/XPathException.java
@@ -48,8 +48,8 @@ public class XPathException extends Exception {
      */
     public XPathException(String message) {
         super(message);
-        if ( message == null ) {
-            throw new NullPointerException ( "message can't be null");
+        if (message == null) {
+            throw new NullPointerException("message == null");
         }
         this.cause = null;
     }
@@ -66,8 +66,8 @@ public class XPathException extends Exception {
     public XPathException(Throwable cause) {
         super(cause == null ? null : cause.toString());
         this.cause = cause;
-        if ( cause == null ) {
-            throw new NullPointerException ( "cause can't be null");
+        if (cause == null) {
+            throw new NullPointerException("cause == null");
         }
     }
 
diff --git a/luni/src/main/java/javax/xml/xpath/XPathFactory.java b/luni/src/main/java/javax/xml/xpath/XPathFactory.java
index 8b1c1fa..57f2195 100644
--- a/luni/src/main/java/javax/xml/xpath/XPathFactory.java
+++ b/luni/src/main/java/javax/xml/xpath/XPathFactory.java
@@ -133,9 +133,7 @@ public abstract class XPathFactory {
     public static final XPathFactory newInstance(final String uri)
         throws XPathFactoryConfigurationException {
         if (uri == null) {
-            throw new NullPointerException(
-                "XPathFactory#newInstance(String uri) cannot be called with uri == null"
-            );
+            throw new NullPointerException("uri == null");
         }
         if (uri.length() == 0) {
             throw new IllegalArgumentException(
@@ -167,9 +165,7 @@ public abstract class XPathFactory {
     public static XPathFactory newInstance(String uri, String factoryClassName,
             ClassLoader classLoader) throws XPathFactoryConfigurationException {
         if (uri == null) {
-            throw new NullPointerException(
-                "XPathFactory#newInstance(String uri) cannot be called with uri == null"
-            );
+            throw new NullPointerException("uri == null");
         }
         if (uri.length() == 0) {
             throw new IllegalArgumentException(
diff --git a/luni/src/main/java/javax/xml/xpath/XPathFactoryFinder.java b/luni/src/main/java/javax/xml/xpath/XPathFactoryFinder.java
index 652a1d8..0113e7d 100644
--- a/luni/src/main/java/javax/xml/xpath/XPathFactoryFinder.java
+++ b/luni/src/main/java/javax/xml/xpath/XPathFactoryFinder.java
@@ -126,7 +126,9 @@ final class XPathFactoryFinder {
      *      If the parameter is null.
      */
     public XPathFactory newFactory(String uri) {
-        if(uri==null)        throw new NullPointerException();
+        if (uri == null) {
+            throw new NullPointerException("uri == null");
+        }
         XPathFactory f = _newFactory(uri);
         if (debug) {
             if (f != null) {
diff --git a/luni/src/main/java/libcore/icu/NativeIDN.java b/luni/src/main/java/libcore/icu/NativeIDN.java
index 9bf5cb1..db93379 100644
--- a/luni/src/main/java/libcore/icu/NativeIDN.java
+++ b/luni/src/main/java/libcore/icu/NativeIDN.java
@@ -34,7 +34,7 @@ public final class NativeIDN {
 
     private static String convert(String s, int flags, boolean toAscii) {
         if (s == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("s == null");
         }
         return convertImpl(s, flags, toAscii);
     }
diff --git a/luni/src/main/java/libcore/icu/RuleBasedCollatorICU.java b/luni/src/main/java/libcore/icu/RuleBasedCollatorICU.java
index d036c98..4221fe6 100644
--- a/luni/src/main/java/libcore/icu/RuleBasedCollatorICU.java
+++ b/luni/src/main/java/libcore/icu/RuleBasedCollatorICU.java
@@ -46,7 +46,7 @@ public final class RuleBasedCollatorICU implements Cloneable {
 
     public RuleBasedCollatorICU(String rules) throws ParseException {
         if (rules == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("rules == null");
         }
         address = NativeCollation.openCollatorFromRules(rules, VALUE_OFF, VALUE_DEFAULT_STRENGTH);
     }
diff --git a/luni/src/main/java/libcore/io/StrictLineReader.java b/luni/src/main/java/libcore/io/StrictLineReader.java
index 5f8d452..36556a0 100644
--- a/luni/src/main/java/libcore/io/StrictLineReader.java
+++ b/luni/src/main/java/libcore/io/StrictLineReader.java
@@ -106,8 +106,10 @@ public class StrictLineReader implements Closeable {
      *         or the specified charset is not supported.
      */
     public StrictLineReader(InputStream in, int capacity, Charset charset) {
-        if (in == null || charset == null) {
-            throw new NullPointerException();
+        if (in == null) {
+            throw new NullPointerException("in == null");
+        } else if (charset == null) {
+            throw new NullPointerException("charset == null");
         }
         if (capacity < 0) {
             throw new IllegalArgumentException("capacity <= 0");
diff --git a/luni/src/main/java/libcore/net/UriCodec.java b/luni/src/main/java/libcore/net/UriCodec.java
index bde922b..6624474 100644
--- a/luni/src/main/java/libcore/net/UriCodec.java
+++ b/luni/src/main/java/libcore/net/UriCodec.java
@@ -94,7 +94,7 @@ public abstract class UriCodec {
     private void appendEncoded(StringBuilder builder, String s, Charset charset,
             boolean isPartiallyEncoded) {
         if (s == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("s == null");
         }
 
         int escapeStart = -1;
diff --git a/luni/src/main/java/libcore/util/BasicLruCache.java b/luni/src/main/java/libcore/util/BasicLruCache.java
index 13ab3db..75e4a75 100644
--- a/luni/src/main/java/libcore/util/BasicLruCache.java
+++ b/luni/src/main/java/libcore/util/BasicLruCache.java
@@ -43,7 +43,7 @@ public class BasicLruCache<K, V> {
      */
     public synchronized final V get(K key) {
         if (key == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("key == null");
         }
 
         V result = map.get(key);
@@ -68,8 +68,10 @@ public class BasicLruCache<K, V> {
      *     no longer cached, it has not been passed to {@link #entryEvicted}.
      */
     public synchronized final V put(K key, V value) {
-        if (key == null || value == null) {
-            throw new NullPointerException();
+        if (key == null) {
+            throw new NullPointerException("key == null");
+        } else if (value == null) {
+            throw new NullPointerException("value == null");
         }
 
         V previous = map.put(key, value);
diff --git a/luni/src/main/java/org/apache/harmony/crypto/internal/NullCipherSpi.java b/luni/src/main/java/org/apache/harmony/crypto/internal/NullCipherSpi.java
index 270f63b..151b403 100644
--- a/luni/src/main/java/org/apache/harmony/crypto/internal/NullCipherSpi.java
+++ b/luni/src/main/java/org/apache/harmony/crypto/internal/NullCipherSpi.java
@@ -115,8 +115,10 @@ public class NullCipherSpi extends CipherSpi {
     @Override
     public int engineUpdate(ByteBuffer input, ByteBuffer output)
             throws ShortBufferException {
-        if (input == null || output == null) {
-            throw new NullPointerException();
+        if (input == null) {
+            throw new NullPointerException("input == null");
+        } else if (output == null) {
+            throw new NullPointerException("output == null");
         }
         int result = input.limit() - input.position();
         try {
diff --git a/luni/src/main/java/org/apache/harmony/security/SystemScope.java b/luni/src/main/java/org/apache/harmony/security/SystemScope.java
index 89cf56b..bf4f849 100644
--- a/luni/src/main/java/org/apache/harmony/security/SystemScope.java
+++ b/luni/src/main/java/org/apache/harmony/security/SystemScope.java
@@ -79,7 +79,7 @@ public class SystemScope extends IdentityScope {
      */
     public synchronized Identity getIdentity(String name) {
         if (name == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("name == null");
         }
         return (Identity) names.get(name);
     }
diff --git a/luni/src/main/java/org/apache/harmony/security/provider/cert/X509CRLImpl.java b/luni/src/main/java/org/apache/harmony/security/provider/cert/X509CRLImpl.java
index 134d8f9..68ec38a 100644
--- a/luni/src/main/java/org/apache/harmony/security/provider/cert/X509CRLImpl.java
+++ b/luni/src/main/java/org/apache/harmony/security/provider/cert/X509CRLImpl.java
@@ -237,7 +237,7 @@ public class X509CRLImpl extends X509CRL {
      */
     public X509CRLEntry getRevokedCertificate(X509Certificate certificate) {
         if (certificate == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("certificate == null");
         }
         if (!entriesRetrieved) {
             retrieveEntries();
diff --git a/luni/src/main/java/org/apache/harmony/security/provider/crypto/SHA1withDSA_SignatureImpl.java b/luni/src/main/java/org/apache/harmony/security/provider/crypto/SHA1withDSA_SignatureImpl.java
index d2a9c6d..2958e00 100644
--- a/luni/src/main/java/org/apache/harmony/security/provider/crypto/SHA1withDSA_SignatureImpl.java
+++ b/luni/src/main/java/org/apache/harmony/security/provider/crypto/SHA1withDSA_SignatureImpl.java
@@ -57,7 +57,7 @@ public class SHA1withDSA_SignatureImpl extends Signature {
     protected Object engineGetParameter(String param)
             throws InvalidParameterException {
         if (param == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("param == null");
         }
         return null;
     }
diff --git a/luni/src/main/java/org/apache/harmony/xml/ExpatAttributes.java b/luni/src/main/java/org/apache/harmony/xml/ExpatAttributes.java
index b92fc50..5ec632c 100644
--- a/luni/src/main/java/org/apache/harmony/xml/ExpatAttributes.java
+++ b/luni/src/main/java/org/apache/harmony/xml/ExpatAttributes.java
@@ -76,10 +76,10 @@ abstract class ExpatAttributes implements Attributes {
 
     public int getIndex(String uri, String localName) {
         if (uri == null) {
-            throw new NullPointerException("uri");
+            throw new NullPointerException("uri == null");
         }
         if (localName == null) {
-            throw new NullPointerException("local name");
+            throw new NullPointerException("localName == null");
         }
         int pointer = getPointer();
         if (pointer == 0) {
@@ -90,7 +90,7 @@ abstract class ExpatAttributes implements Attributes {
 
     public int getIndex(String qName) {
         if (qName == null) {
-            throw new NullPointerException("uri");
+            throw new NullPointerException("qName == null");
         }
         int pointer = getPointer();
         if (pointer == 0) {
@@ -101,10 +101,10 @@ abstract class ExpatAttributes implements Attributes {
 
     public String getType(String uri, String localName) {
         if (uri == null) {
-            throw new NullPointerException("uri");
+            throw new NullPointerException("uri == null");
         }
         if (localName == null) {
-            throw new NullPointerException("local name");
+            throw new NullPointerException("localName == null");
         }
         return getIndex(uri, localName) == -1 ? null : CDATA;
     }
@@ -115,10 +115,10 @@ abstract class ExpatAttributes implements Attributes {
 
     public String getValue(String uri, String localName) {
         if (uri == null) {
-            throw new NullPointerException("uri");
+            throw new NullPointerException("uri == null");
         }
         if (localName == null) {
-            throw new NullPointerException("local name");
+            throw new NullPointerException("localName == null");
         }
         int pointer = getPointer();
         if (pointer == 0) {
@@ -129,7 +129,7 @@ abstract class ExpatAttributes implements Attributes {
 
     public String getValue(String qName) {
         if (qName == null) {
-            throw new NullPointerException("qName");
+            throw new NullPointerException("qName == null");
         }
         int pointer = getPointer();
         if (pointer == 0) {
diff --git a/luni/src/main/java/org/apache/harmony/xml/dom/NodeImpl.java b/luni/src/main/java/org/apache/harmony/xml/dom/NodeImpl.java
index 1f1293b..af4002f 100644
--- a/luni/src/main/java/org/apache/harmony/xml/dom/NodeImpl.java
+++ b/luni/src/main/java/org/apache/harmony/xml/dom/NodeImpl.java
@@ -697,7 +697,7 @@ public abstract class NodeImpl implements Node {
 
     public final Object setUserData(String key, Object data, UserDataHandler handler) {
         if (key == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("key == null");
         }
         Map<String, UserData> map = document.getUserDataMap(this);
         UserData previous = data == null
@@ -708,7 +708,7 @@ public abstract class NodeImpl implements Node {
 
     public final Object getUserData(String key) {
         if (key == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("key == null");
         }
         Map<String, UserData> map = document.getUserDataMapForRead(this);
         UserData userData = map.get(key);
diff --git a/luni/src/main/java/org/apache/harmony/xml/parsers/DocumentBuilderFactoryImpl.java b/luni/src/main/java/org/apache/harmony/xml/parsers/DocumentBuilderFactoryImpl.java
index 8efaa30..debbb20 100644
--- a/luni/src/main/java/org/apache/harmony/xml/parsers/DocumentBuilderFactoryImpl.java
+++ b/luni/src/main/java/org/apache/harmony/xml/parsers/DocumentBuilderFactoryImpl.java
@@ -42,7 +42,7 @@ public class DocumentBuilderFactoryImpl extends DocumentBuilderFactory {
     @Override
     public boolean getFeature(String name) throws ParserConfigurationException {
         if (name == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("name == null");
         }
 
         if (NAMESPACES.equals(name)) {
@@ -90,7 +90,7 @@ public class DocumentBuilderFactoryImpl extends DocumentBuilderFactory {
     public void setFeature(String name, boolean value)
             throws ParserConfigurationException {
         if (name == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("name == null");
         }
 
         if (NAMESPACES.equals(name)) {
diff --git a/luni/src/main/java/org/apache/harmony/xml/parsers/SAXParserFactoryImpl.java b/luni/src/main/java/org/apache/harmony/xml/parsers/SAXParserFactoryImpl.java
index 08657b9..e2e3778 100644
--- a/luni/src/main/java/org/apache/harmony/xml/parsers/SAXParserFactoryImpl.java
+++ b/luni/src/main/java/org/apache/harmony/xml/parsers/SAXParserFactoryImpl.java
@@ -41,7 +41,7 @@ public class SAXParserFactoryImpl extends SAXParserFactory {
     @Override
     public boolean getFeature(String name) throws SAXNotRecognizedException {
         if (name == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("name == null");
         }
 
         if (!name.startsWith("http://xml.org/sax/features/")) {
@@ -86,7 +86,7 @@ public class SAXParserFactoryImpl extends SAXParserFactory {
     @Override
     public void setFeature(String name, boolean value) throws SAXNotRecognizedException {
         if (name == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("name == null");
         }
 
         if (!name.startsWith("http://xml.org/sax/features/")) {
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/FileClientSessionCache.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/FileClientSessionCache.java
index 6619d1d..0f1fe24 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/FileClientSessionCache.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/FileClientSessionCache.java
@@ -121,7 +121,7 @@ public class FileClientSessionCache {
          */
         private static String fileName(String host, int port) {
             if (host == null) {
-                throw new NullPointerException("host");
+                throw new NullPointerException("host == null");
             }
             return host + "." + port;
         }
@@ -182,7 +182,7 @@ public class FileClientSessionCache {
                 byte[] sessionData) {
             String host = session.getPeerHost();
             if (sessionData == null) {
-                throw new NullPointerException("sessionData");
+                throw new NullPointerException("sessionData == null");
             }
 
             String name = fileName(host, session.getPeerPort());
-- 
cgit v1.1


From e390842aabb31c195bbbe53686029cd6634d9466 Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Fri, 14 Sep 2012 00:26:46 -0700
Subject: Fix Security2Test to not be case sensitive

Also KeyRepTest cleanup while debugging and removed useless KeyStoreLoadStoreParameterTest.

Change-Id: Id716193792b95de210d9679f2a4372c5b11decf6
---
 .../security/tests/java/security/KeyRepTest.java   | 135 +++++++--------------
 .../security/KeyStoreLoadStoreParameterTest.java   |  15 ---
 .../tests/java/security/Security2Test.java         | 108 ++++++-----------
 3 files changed, 79 insertions(+), 179 deletions(-)
 delete mode 100644 luni/src/test/java/org/apache/harmony/security/tests/java/security/KeyStoreLoadStoreParameterTest.java

diff --git a/luni/src/test/java/org/apache/harmony/security/tests/java/security/KeyRepTest.java b/luni/src/test/java/org/apache/harmony/security/tests/java/security/KeyRepTest.java
index 0dad827..a6529e8 100644
--- a/luni/src/test/java/org/apache/harmony/security/tests/java/security/KeyRepTest.java
+++ b/luni/src/test/java/org/apache/harmony/security/tests/java/security/KeyRepTest.java
@@ -26,199 +26,146 @@ import java.io.NotSerializableException;
 import java.io.ObjectStreamException;
 import java.security.KeyRep;
 import java.security.Security;
-import java.util.Iterator;
 import java.util.Set;
-
 import junit.framework.TestCase;
 
-/**
- *
- *
- */
 public class KeyRepTest extends TestCase {
 
-    private static final Set<String> keyFactoryAlgorithm;
+    private static final Set<String> keyFactoryAlgorithms = Security.getAlgorithms("KeyFactory");
     static {
-        keyFactoryAlgorithm = Security.getAlgorithms("KeyFactory");
+        assertFalse(keyFactoryAlgorithms.isEmpty());
     }
 
     public final void testKeyRep01() {
-        try {
-            assertNotNull(new KeyRep(KeyRep.Type.SECRET, "", "", new byte[] {}));
-        } catch (Exception e) {
-            fail("Unexpected exception " + e.getMessage());
-        }
-
-        try {
-            assertNotNull(new KeyRep(KeyRep.Type.PUBLIC, "", "", new byte[] {}));
-        } catch (Exception e) {
-            fail("Unexpected exception " + e.getMessage());
-        }
-
-        try {
-            assertNotNull(new KeyRep(KeyRep.Type.PRIVATE, "", "", new byte[] {}));
-        } catch (Exception e) {
-            fail("Unexpected exception " + e.getMessage());
-        }
+        assertNotNull(new KeyRep(KeyRep.Type.SECRET, "", "", new byte[] {}));
+        assertNotNull(new KeyRep(KeyRep.Type.PUBLIC, "", "", new byte[] {}));
+        assertNotNull(new KeyRep(KeyRep.Type.PRIVATE, "", "", new byte[] {}));
     }
 
     public final void testKeyRep02() {
         try {
             new KeyRep(null, "", "", new byte[] {});
             fail("NullPointerException has not been thrown (type)");
-        } catch (NullPointerException ok) {
-
+        } catch (NullPointerException expected) {
         }
         try {
             new KeyRep(KeyRep.Type.SECRET, null, "", new byte[] {});
             fail("NullPointerException has not been thrown (alg)");
-        } catch (NullPointerException ok) {
-
+        } catch (NullPointerException expected) {
         }
         try {
             new KeyRep(KeyRep.Type.PRIVATE, "", null, new byte[] {});
             fail("NullPointerException has not been thrown (format)");
-        } catch (NullPointerException ok) {
-
+        } catch (NullPointerException expected) {
         }
         try {
             new KeyRep(KeyRep.Type.PUBLIC, "", "", null);
             fail("NullPointerException has not been thrown (encoding)");
-        } catch (NullPointerException ok) {
-
+        } catch (NullPointerException expected) {
         }
     }
 
-    public final void testReadResolve01() throws ObjectStreamException {
-        KeyRepChild kr = new KeyRepChild(KeyRep.Type.SECRET, "", "",
-                new byte[] {});
+    public final void testReadResolve01() throws Exception {
+        KeyRepChild kr = new KeyRepChild(KeyRep.Type.SECRET, "", "", new byte[] {});
         try {
             kr.readResolve();
             fail("NotSerializableException has not been thrown (no format)");
-        } catch (NotSerializableException ok) {
-
+        } catch (NotSerializableException expected) {
         }
 
         kr = new KeyRepChild(KeyRep.Type.SECRET, "", "X.509", new byte[] {});
         try {
             kr.readResolve();
             fail("NotSerializableException has not been thrown (unacceptable format)");
-        } catch (NotSerializableException ok) {
-
+        } catch (NotSerializableException expected) {
         }
 
         kr = new KeyRepChild(KeyRep.Type.SECRET, "", "RAW", new byte[] {});
         try {
             kr.readResolve();
             fail("NotSerializableException has not been thrown (empty key)");
-        } catch (NotSerializableException ok) {
-
+        } catch (NotSerializableException expected) {
         }
     }
 
-    public final void testReadResolve02() throws ObjectStreamException {
-        KeyRepChild kr = new KeyRepChild(KeyRep.Type.PUBLIC, "", "",
-                new byte[] {});
+    public final void testReadResolve02() throws Exception {
+        KeyRepChild kr = new KeyRepChild(KeyRep.Type.PUBLIC, "", "", new byte[] {});
         try {
             kr.readResolve();
             fail("NotSerializableException has not been thrown (no format)");
-        } catch (NotSerializableException ok) {
-
+        } catch (NotSerializableException expected) {
         }
 
         kr = new KeyRepChild(KeyRep.Type.PUBLIC, "", "RAW", new byte[] {});
         try {
             kr.readResolve();
             fail("NotSerializableException has not been thrown (unacceptable format)");
-        } catch (NotSerializableException ok) {
-
+        } catch (NotSerializableException expected) {
         }
 
-        kr = new KeyRepChild(KeyRep.Type.PUBLIC, "bla-bla", "X.509",
-                new byte[] {});
+        kr = new KeyRepChild(KeyRep.Type.PUBLIC, "bla-bla", "X.509", new byte[] {});
         try {
             kr.readResolve();
             fail("NotSerializableException has not been thrown (unknown KeyFactory algorithm)");
-        } catch (NotSerializableException ok) {
-
+        } catch (NotSerializableException expected) {
         }
     }
 
-    public final void testReadResolve03() throws ObjectStreamException {
-        KeyRepChild kr = new KeyRepChild(KeyRep.Type.PRIVATE, "", "",
-                new byte[] {});
+    public final void testReadResolve03() throws Exception {
+        KeyRepChild kr = new KeyRepChild(KeyRep.Type.PRIVATE, "", "", new byte[] {});
         try {
             kr.readResolve();
             fail("NotSerializableException has not been thrown (no format)");
-        } catch (NotSerializableException ok) {
-
+        } catch (NotSerializableException expected) {
         }
 
         kr = new KeyRepChild(KeyRep.Type.PRIVATE, "", "RAW", new byte[] {});
         try {
             kr.readResolve();
             fail("NotSerializableException has not been thrown (unacceptable format)");
-        } catch (NotSerializableException ok) {
-
+        } catch (NotSerializableException expected) {
         }
 
-        kr = new KeyRepChild(KeyRep.Type.PRIVATE, "bla-bla", "PKCS#8",
-                new byte[] {});
+        kr = new KeyRepChild(KeyRep.Type.PRIVATE, "bla-bla", "PKCS#8", new byte[] {});
         try {
             kr.readResolve();
             fail("NotSerializableException has not been thrown (unknown KeyFactory algorithm)");
-        } catch (NotSerializableException ok) {
-
+        } catch (NotSerializableException expected) {
         }
     }
 
-    public final void testReadResolve04() throws ObjectStreamException {
-        if (keyFactoryAlgorithm.isEmpty()) {
-            System.err.println(getName()
-                    + ": skipped - no KeyFactory algorithms available");
-            return;
-        } else {
-        }
-        for (Iterator<String> i = keyFactoryAlgorithm.iterator(); i.hasNext();) {
-            KeyRepChild kr = new KeyRepChild(KeyRep.Type.PUBLIC, i.next(),
-                    "X.509", new byte[] { 1, 2, 3 });
+    public final void testReadResolve04() throws Exception {
+        for (String algorithm : keyFactoryAlgorithms) {
+            KeyRepChild kr = new KeyRepChild(KeyRep.Type.PUBLIC, algorithm, "X.509",
+                                             new byte[] { 1, 2, 3 });
             try {
                 kr.readResolve();
-                fail("NotSerializableException has not been thrown (no format)");
-            } catch (NotSerializableException ok) {
-
+                fail("NotSerializableException has not been thrown (no format) " + algorithm);
+            } catch (NotSerializableException expected) {
             }
         }
     }
 
-    public final void testReadResolve05() throws ObjectStreamException {
-        if (keyFactoryAlgorithm.isEmpty()) {
-            System.err.println(getName()
-                    + ": skipped - no KeyFactory algorithms available");
-            return;
-        } else {
-        }
-        for (Iterator<String> i = keyFactoryAlgorithm.iterator(); i.hasNext();) {
-            KeyRepChild kr = new KeyRepChild(KeyRep.Type.PRIVATE, i.next(),
-                    "PKCS#8", new byte[] { 1, 2, 3 });
+    public final void testReadResolve05() throws Exception {
+        for (String algorithm : keyFactoryAlgorithms) {
+            KeyRepChild kr = new KeyRepChild(KeyRep.Type.PRIVATE, algorithm, "PKCS#8",
+                                             new byte[] { 1, 2, 3 });
             try {
                 kr.readResolve();
-                fail("NotSerializableException has not been thrown (no format)");
-            } catch (NotSerializableException ok) {
-
+                fail("NotSerializableException has not been thrown (no format) " + algorithm);
+            } catch (NotSerializableException expected) {
             }
         }
     }
 
     class KeyRepChild extends KeyRep {
-        public KeyRepChild(KeyRep.Type type, String algorithm, String format,
-                byte[] encoded) {
+        public KeyRepChild(KeyRep.Type type, String algorithm, String format, byte[] encoded) {
             super(type, algorithm, format, encoded);
         }
 
-        public Object readResolve() throws ObjectStreamException {
+        // Overriden to make public for testing
+        @Override public Object readResolve() throws ObjectStreamException {
             return super.readResolve();
         }
-
     }
 }
diff --git a/luni/src/test/java/org/apache/harmony/security/tests/java/security/KeyStoreLoadStoreParameterTest.java b/luni/src/test/java/org/apache/harmony/security/tests/java/security/KeyStoreLoadStoreParameterTest.java
deleted file mode 100644
index 81ec30d..0000000
--- a/luni/src/test/java/org/apache/harmony/security/tests/java/security/KeyStoreLoadStoreParameterTest.java
+++ /dev/null
@@ -1,15 +0,0 @@
-package org.apache.harmony.security.tests.java.security;
-
-import java.security.KeyStore;
-
-public class KeyStoreLoadStoreParameterTest {
-
-    class MyLoadStoreParameter implements KeyStore.LoadStoreParameter {
-       public KeyStore.ProtectionParameter getProtectionParameter() {
-            return null;
-       }
-    }
-
-
-
-}
diff --git a/luni/src/test/java/org/apache/harmony/security/tests/java/security/Security2Test.java b/luni/src/test/java/org/apache/harmony/security/tests/java/security/Security2Test.java
index d9f4dd7..68e7cbc 100644
--- a/luni/src/test/java/org/apache/harmony/security/tests/java/security/Security2Test.java
+++ b/luni/src/test/java/org/apache/harmony/security/tests/java/security/Security2Test.java
@@ -20,14 +20,14 @@ package org.apache.harmony.security.tests.java.security;
 import java.security.InvalidParameterException;
 import java.security.Provider;
 import java.security.Security;
-import java.util.Hashtable;
-import java.util.Iterator;
+import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;
+import junit.framework.TestCase;
 import tests.support.Support_ProviderTrust;
 import tests.support.Support_TestProvider;
 
-public class Security2Test extends junit.framework.TestCase {
+public class Security2Test extends TestCase {
 
     /**
      * java.security.Security#getProviders(java.lang.String)
@@ -36,16 +36,13 @@ public class Security2Test extends junit.framework.TestCase {
         // Test for method void
         // java.security.Security.getProviders(java.lang.String)
 
-        Hashtable<String, Integer> allSupported = new Hashtable<String, Integer>();
+        Map<String, Integer> allSupported = new HashMap<String, Integer>();
         Provider[] allProviders = Security.getProviders();
 
         // Add all non-alias entries to allSupported
-        for (int i = 0; i < allProviders.length; i++) {
-            Provider provider = allProviders[i];
-            Iterator it = provider.entrySet().iterator();
-            while (it.hasNext()) {
-                Map.Entry entry = (Map.Entry) it.next();
-                String key = (String) entry.getKey();
+        for (Provider provider : allProviders) {
+            for (Object k : provider.keySet()) {
+                String key = (String) k;
                 // No aliases and no provider data
                 if (!isAlias(key) && !isProviderData(key)) {
                     addOrIncrementTable(allSupported, key);
@@ -56,22 +53,18 @@ public class Security2Test extends junit.framework.TestCase {
         // Now walk through aliases. If an alias has actually been added
         // to the allSupported table then increment the count of the
         // entry that is being aliased.
-        for (int i = 0; i < allProviders.length; i++) {
-            Provider provider = allProviders[i];
-            Iterator it = provider.entrySet().iterator();
-            while (it.hasNext()) {
-                Map.Entry entry = (Map.Entry) it.next();
+        for (Provider provider : allProviders) {
+            for (Map.Entry entry : provider.entrySet()) {
                 String key = (String) entry.getKey();
                 if (isAlias(key)) {
                     String aliasVal = key.substring("ALG.ALIAS.".length());
-                    String aliasKey = aliasVal.substring(0, aliasVal
-                            .indexOf(".") + 1)
+                    String aliasKey = aliasVal.substring(0, aliasVal.indexOf(".") + 1)
                             + entry.getValue();
                     // Skip over nonsense alias declarations where alias and
                     // aliased are identical. Such entries can occur.
-                    if (!aliasVal.equals(aliasKey)) {
+                    if (!aliasVal.equalsIgnoreCase(aliasKey)) {
                         // Has a real entry been added for aliasValue ?
-                        if (allSupported.containsKey(aliasVal)) {
+                        if (allSupported.containsKey(aliasVal.toUpperCase())) {
                             // Add 1 to the provider count of the thing being
                             // aliased
                             addOrIncrementTable(allSupported, aliasKey);
@@ -81,17 +74,13 @@ public class Security2Test extends junit.framework.TestCase {
             }// end while more entries
         }// end for all providers
 
-        Provider provTest[] = null;
-        Iterator it = allSupported.keySet().iterator();
-        while (it.hasNext()) {
-            String filterString = (String) it.next();
+        for (String filterString : allSupported.keySet()) {
             try {
-                provTest = Security.getProviders(filterString);
-                int expected = ((Integer) allSupported.get(filterString))
-                        .intValue();
-                assertEquals(
-                        "Unexpected number of providers returned for filter "
-                                + filterString, expected, provTest.length);
+                Provider[] provTest = Security.getProviders(filterString);
+                int expected = allSupported.get(filterString);
+                assertEquals("Unexpected number of providers returned for filter " + filterString
+                             + ":\n" + allSupported,
+                             expected, provTest.length);
             } catch (InvalidParameterException e) {
                 // NO OP
             }
@@ -99,62 +88,43 @@ public class Security2Test extends junit.framework.TestCase {
 
         // exception
         try {
-            provTest = Security.getProviders("Signature.SHA1withDSA :512");
+            Security.getProviders("Signature.SHA1withDSA :512");
             fail("InvalidParameterException should be thrown <Signature.SHA1withDSA :512>");
         } catch (InvalidParameterException e) {
             // Expected
         }
     }
 
-    /**
-     * @param key
-     * @return
-     */
     private boolean isProviderData(String key) {
         return key.toUpperCase().startsWith("PROVIDER.");
     }
 
-    /**
-     * @param key
-     * @return
-     */
     private boolean isAlias(String key) {
         return key.toUpperCase().startsWith("ALG.ALIAS.");
     }
 
-    /**
-     * @param table
-     * @param key
-     */
-    private void addOrIncrementTable(Hashtable<String, Integer> table, String key) {
+    private void addOrIncrementTable(Map<String, Integer> table, String k) {
+        String key = k.toUpperCase(); 
         if (table.containsKey(key)) {
-            Integer before = (Integer) table.get(key);
-            table.put(key, new Integer(before.intValue() + 1));
+            int before = table.get(key);
+            table.put(key, before + 1);
         } else {
-            table.put(key, new Integer(1));
+            table.put(key, 1);
         }
     }
 
-    /**
-     * @param filterMap
-     * @return
-     */
     private int getProvidersCount(Map filterMap) {
         int result = 0;
         Provider[] allProviders = Security.getProviders();
 
         // for each provider
-        for (int i = 0; i < allProviders.length; i++) {
-            Provider provider = allProviders[i];
+        for (Provider provider : allProviders) {
             Set allProviderKeys = provider.keySet();
             boolean noMatchFoundForFilterEntry = false;
 
             // for each filter item
-            Set allFilterKeys = filterMap.keySet();
-            Iterator fkIter = allFilterKeys.iterator();
-            while (fkIter.hasNext()) {
-                String filterString = ((String) fkIter.next()).trim();
-
+            for (Object filter : filterMap.keySet()) {
+                String filterString = (String) filter;
                 // Remove any "=" characters that may be on the end of the
                 // map keys (no, I don't know why they might be there either
                 // but I have seen them)
@@ -211,10 +181,10 @@ public class Security2Test extends junit.framework.TestCase {
         // Test for method void
         // java.security.Security.getProviders(java.util.Map)
 
-        Map<String, String> filter = new Hashtable<String, String>();
+        Map<String, String> filter = new HashMap<String, String>();
         filter.put("KeyStore.BKS", "");
         filter.put("Signature.SHA1withDSA", "");
-        Provider provTest[] = Security.getProviders(filter);
+        Provider[] provTest = Security.getProviders(filter);
         if (provTest == null) {
             assertEquals("Filter : <KeyStore.BKS>,<Signature.SHA1withDSA>",
                     0, getProvidersCount(filter));
@@ -223,7 +193,7 @@ public class Security2Test extends junit.framework.TestCase {
                     getProvidersCount(filter), provTest.length);
         }
 
-        filter = new Hashtable<String, String>();
+        filter = new HashMap<String, String>();
         filter.put("MessageDigest.SHA-384", "");
         filter.put("CertificateFactory.X.509", "");
         filter.put("KeyFactory.RSA", "");
@@ -237,7 +207,7 @@ public class Security2Test extends junit.framework.TestCase {
                     getProvidersCount(filter), provTest.length);
         }
 
-        filter = new Hashtable<String, String>();
+        filter = new HashMap<String, String>();
         filter.put("MessageDigest.SHA1", "");
         filter.put("TrustManagerFactory.X509", "");
         provTest = Security.getProviders(filter);
@@ -250,7 +220,7 @@ public class Security2Test extends junit.framework.TestCase {
                     getProvidersCount(filter), provTest.length);
         }
 
-        filter = new Hashtable<String, String>();
+        filter = new HashMap<String, String>();
         filter.put("CertificateFactory.X509", "");
         provTest = Security.getProviders(filter);
         if (provTest == null) {
@@ -261,7 +231,7 @@ public class Security2Test extends junit.framework.TestCase {
                     getProvidersCount(filter), provTest.length);
         }
 
-        filter = new Hashtable<String, String>();
+        filter = new HashMap<String, String>();
         filter.put("Provider.id name", "DRLCertFactory");
         provTest = Security.getProviders(filter);
         assertNull("Filter : <Provider.id name, DRLCertFactory >",
@@ -270,7 +240,7 @@ public class Security2Test extends junit.framework.TestCase {
         // exception - no attribute name after the service.algorithm yet we
         // still supply an expected value. This is not valid.
         try {
-            filter = new Hashtable<String, String>();
+            filter = new HashMap<String, String>();
             filter.put("Signature.SHA1withDSA", "512");
             provTest = Security.getProviders(filter);
             fail("InvalidParameterException should be thrown <Signature.SHA1withDSA><512>");
@@ -280,7 +250,7 @@ public class Security2Test extends junit.framework.TestCase {
 
         // exception - space character in the service.algorithm pair. Not valid.
         try {
-            filter = new Hashtable<String, String>();
+            filter = new HashMap<String, String>();
             filter.put("Signature. KeySize", "512");
             provTest = Security.getProviders(filter);
             fail("InvalidParameterException should be thrown <Signature. KeySize><512>");
@@ -320,11 +290,9 @@ public class Security2Test extends junit.framework.TestCase {
             assertTrue("Failed to add provider", addResult != -1);
 
             Security.removeProvider(entrust.getName());
-            Provider provTest[] = Security.getProviders();
-            for (int i = 0; i < provTest.length; i++) {
-                assertTrue(
-                        "the provider entrust is found after it was removed",
-                        provTest[i].getName() != entrust.getName());
+            for (Provider provider : Security.getProviders()) {
+                assertTrue("the provider entrust is found after it was removed",
+                           provider.getName() != entrust.getName());
             }
         } finally {
             // Tidy up - the following calls do nothing if the providers were
-- 
cgit v1.1


From bf9c47975631cda6ead2eda00d3db3c93444eeba Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Fri, 14 Sep 2012 11:53:35 -0700
Subject: Manually inline StrictMath.min(JJ) and StrictMath.max(JJ).

Also add new intrinsic tests.

Bug: 7146208
Change-Id: Ic454c8c5b218c51ce1c21f0c11163455392b4e72
---
 luni/src/main/java/java/lang/Math.java             | 71 --------------------
 luni/src/main/java/java/lang/StrictMath.java       | 75 +---------------------
 .../test/java/libcore/java/lang/IntrinsicTest.java | 26 ++++++++
 3 files changed, 28 insertions(+), 144 deletions(-)

diff --git a/luni/src/main/java/java/lang/Math.java b/luni/src/main/java/java/lang/Math.java
index 68db4fa..22c89ce 100644
--- a/luni/src/main/java/java/lang/Math.java
+++ b/luni/src/main/java/java/lang/Math.java
@@ -53,10 +53,6 @@ public final class Math {
      * <li>{@code abs(-infinity) = +infinity}</li>
      * <li>{@code abs(NaN) = NaN}</li>
      * </ul>
-     *
-     * @param d
-     *            the value whose absolute value has to be computed.
-     * @return the absolute value of the argument.
      */
     public static native double abs(double d);
 
@@ -70,11 +66,6 @@ public final class Math {
      * <li>{@code abs(-infinity) = +infinity}</li>
      * <li>{@code abs(NaN) = NaN}</li>
      * </ul>
-     *
-     * @param f
-     *            the value whose absolute value has to be computed.
-     * @return the argument if it is positive, otherwise the negation of the
-     *         argument.
      */
     public static native float abs(float f);
 
@@ -83,22 +74,12 @@ public final class Math {
      * <p>
      * If the argument is {@code Integer.MIN_VALUE}, {@code Integer.MIN_VALUE}
      * is returned.
-     *
-     * @param i
-     *            the value whose absolute value has to be computed.
-     * @return the argument if it is positive, otherwise the negation of the
-     *         argument.
      */
     public static native int abs(int i);
 
     /**
      * Returns the absolute value of the argument. If the argument is {@code
      * Long.MIN_VALUE}, {@code Long.MIN_VALUE} is returned.
-     *
-     * @param l
-     *            the value whose absolute value has to be computed.
-     * @return the argument if it is positive, otherwise the negation of the
-     *         argument.
      */
     public static native long abs(long l);
 
@@ -467,12 +448,6 @@ public final class Math {
      * <li>{@code max(+0.0, -0.0) = +0.0}</li>
      * <li>{@code max(-0.0, +0.0) = +0.0}</li>
      * </ul>
-     *
-     * @param d1
-     *            the first argument.
-     * @param d2
-     *            the second argument.
-     * @return the larger of {@code d1} and {@code d2}.
      */
     public static double max(double d1, double d2) {
         if (d1 > d2) {
@@ -504,12 +479,6 @@ public final class Math {
      * <li>{@code max(+0.0, -0.0) = +0.0}</li>
      * <li>{@code max(-0.0, +0.0) = +0.0}</li>
      * </ul>
-     *
-     * @param f1
-     *            the first argument.
-     * @param f2
-     *            the second argument.
-     * @return the larger of {@code f1} and {@code f2}.
      */
     public static float max(float f1, float f2) {
         if (f1 > f2) {
@@ -533,24 +502,12 @@ public final class Math {
     /**
      * Returns the most positive (closest to positive infinity) of the two
      * arguments.
-     *
-     * @param i1
-     *            the first argument.
-     * @param i2
-     *            the second argument.
-     * @return the larger of {@code i1} and {@code i2}.
      */
     public static native int max(int i1, int i2);
 
     /**
      * Returns the most positive (closest to positive infinity) of the two
      * arguments.
-     *
-     * @param l1
-     *            the first argument.
-     * @param l2
-     *            the second argument.
-     * @return the larger of {@code l1} and {@code l2}.
      */
     public static long max(long l1, long l2) {
         return l1 > l2 ? l1 : l2;
@@ -567,12 +524,6 @@ public final class Math {
      * <li>{@code min(+0.0, -0.0) = -0.0}</li>
      * <li>{@code min(-0.0, +0.0) = -0.0}</li>
      * </ul>
-     *
-     * @param d1
-     *            the first argument.
-     * @param d2
-     *            the second argument.
-     * @return the smaller of {@code d1} and {@code d2}.
      */
     public static double min(double d1, double d2) {
         if (d1 > d2) {
@@ -604,12 +555,6 @@ public final class Math {
      * <li>{@code min(+0.0, -0.0) = -0.0}</li>
      * <li>{@code min(-0.0, +0.0) = -0.0}</li>
      * </ul>
-     *
-     * @param f1
-     *            the first argument.
-     * @param f2
-     *            the second argument.
-     * @return the smaller of {@code f1} and {@code f2}.
      */
     public static float min(float f1, float f2) {
         if (f1 > f2) {
@@ -633,24 +578,12 @@ public final class Math {
     /**
      * Returns the most negative (closest to negative infinity) of the two
      * arguments.
-     *
-     * @param i1
-     *            the first argument.
-     * @param i2
-     *            the second argument.
-     * @return the smaller of {@code i1} and {@code i2}.
      */
     public static native int min(int i1, int i2);
 
     /**
      * Returns the most negative (closest to negative infinity) of the two
      * arguments.
-     *
-     * @param l1
-     *            the first argument.
-     * @param l2
-     *            the second argument.
-     * @return the smaller of {@code l1} and {@code l2}.
      */
     public static long min(long l1, long l2) {
         return l1 < l2 ? l1 : l2;
@@ -884,10 +817,6 @@ public final class Math {
      * <li>{@code sqrt(+infinity) = +infinity}</li>
      * <li>{@code sqrt(NaN) = NaN}</li>
      * </ul>
-     *
-     * @param d
-     *            the value whose square root has to be computed.
-     * @return the square root of the argument.
      */
     public static native double sqrt(double d);
 
diff --git a/luni/src/main/java/java/lang/StrictMath.java b/luni/src/main/java/java/lang/StrictMath.java
index d21027b..6571b2d 100644
--- a/luni/src/main/java/java/lang/StrictMath.java
+++ b/luni/src/main/java/java/lang/StrictMath.java
@@ -62,10 +62,6 @@ public final class StrictMath {
      * <li>{@code abs(-infinity) = +infinity}</li>
      * <li>{@code abs(NaN) = NaN}</li>
      * </ul>
-     *
-     * @param d
-     *            the value whose absolute value has to be computed.
-     * @return the absolute value of the argument.
      */
     public static double abs(double d) {
         return Math.abs(d);
@@ -81,11 +77,6 @@ public final class StrictMath {
      * <li>{@code abs(-infinity) = +infinity}</li>
      * <li>{@code abs(NaN) = NaN}</li>
      * </ul>
-     *
-     * @param f
-     *            the value whose absolute value has to be computed.
-     * @return the argument if it is positive, otherwise the negation of the
-     *         argument.
      */
     public static float abs(float f) {
         return Math.abs(f);
@@ -96,11 +87,6 @@ public final class StrictMath {
      * <p>
      * If the argument is {@code Integer.MIN_VALUE}, {@code Integer.MIN_VALUE}
      * is returned.
-     *
-     * @param i
-     *            the value whose absolute value has to be computed.
-     * @return the argument if it is positive, otherwise the negation of the
-     *         argument.
      */
     public static int abs(int i) {
         return Math.abs(i);
@@ -111,11 +97,6 @@ public final class StrictMath {
      * <p>
      * If the argument is {@code Long.MIN_VALUE}, {@code Long.MIN_VALUE} is
      * returned.
-     *
-     * @param l
-     *            the value whose absolute value has to be computed.
-     * @return the argument if it is positive, otherwise the negation of the
-     *         argument.
      */
     public static long abs(long l) {
         return Math.abs(l);
@@ -469,12 +450,6 @@ public final class StrictMath {
      * <li>{@code max(+0.0, -0.0) = +0.0}</li>
      * <li>{@code max(-0.0, +0.0) = +0.0}</li>
      * </ul>
-     *
-     * @param d1
-     *            the first argument.
-     * @param d2
-     *            the second argument.
-     * @return the larger of {@code d1} and {@code d2}.
      */
     public static double max(double d1, double d2) {
         if (d1 > d2)
@@ -502,12 +477,6 @@ public final class StrictMath {
      * <li>{@code max(+0.0, -0.0) = +0.0}</li>
      * <li>{@code max(-0.0, +0.0) = +0.0}</li>
      * </ul>
-     *
-     * @param f1
-     *            the first argument.
-     * @param f2
-     *            the second argument.
-     * @return the larger of {@code f1} and {@code f2}.
      */
     public static float max(float f1, float f2) {
         if (f1 > f2)
@@ -527,12 +496,6 @@ public final class StrictMath {
     /**
      * Returns the most positive (closest to positive infinity) of the two
      * arguments.
-     *
-     * @param i1
-     *            the first argument.
-     * @param i2
-     *            the second argument.
-     * @return the larger of {@code i1} and {@code i2}.
      */
     public static int max(int i1, int i2) {
         return Math.max(i1, i2);
@@ -541,15 +504,9 @@ public final class StrictMath {
     /**
      * Returns the most positive (closest to positive infinity) of the two
      * arguments.
-     *
-     * @param l1
-     *            the first argument.
-     * @param l2
-     *            the second argument.
-     * @return the larger of {@code l1} and {@code l2}.
      */
     public static long max(long l1, long l2) {
-        return Math.max(l1, l2);
+        return l1 > l2 ? l1 : l2;
     }
 
     /**
@@ -563,12 +520,6 @@ public final class StrictMath {
      * <li>{@code min(+0.0, -0.0) = -0.0}</li>
      * <li>{@code min(-0.0, +0.0) = -0.0}</li>
      * </ul>
-     *
-     * @param d1
-     *            the first argument.
-     * @param d2
-     *            the second argument.
-     * @return the smaller of {@code d1} and {@code d2}.
      */
     public static double min(double d1, double d2) {
         if (d1 > d2)
@@ -596,12 +547,6 @@ public final class StrictMath {
      * <li>{@code min(+0.0, -0.0) = -0.0}</li>
      * <li>{@code min(-0.0, +0.0) = -0.0}</li>
      * </ul>
-     *
-     * @param f1
-     *            the first argument.
-     * @param f2
-     *            the second argument.
-     * @return the smaller of {@code f1} and {@code f2}.
      */
     public static float min(float f1, float f2) {
         if (f1 > f2)
@@ -621,12 +566,6 @@ public final class StrictMath {
     /**
      * Returns the most negative (closest to negative infinity) of the two
      * arguments.
-     *
-     * @param i1
-     *            the first argument.
-     * @param i2
-     *            the second argument.
-     * @return the smaller of {@code i1} and {@code i2}.
      */
     public static int min(int i1, int i2) {
         return Math.min(i1, i2);
@@ -635,15 +574,9 @@ public final class StrictMath {
     /**
      * Returns the most negative (closest to negative infinity) of the two
      * arguments.
-     *
-     * @param l1
-     *            the first argument.
-     * @param l2
-     *            the second argument.
-     * @return the smaller of {@code l1} and {@code l2}.
      */
     public static long min(long l1, long l2) {
-        return Math.min(l1, l2);
+        return l1 < l2 ? l1 : l2;
     }
 
     /**
@@ -856,10 +789,6 @@ public final class StrictMath {
      * <li>{@code sqrt(+infinity) = +infinity}</li>
      * <li>{@code sqrt(NaN) = NaN}</li>
      * </ul>
-     *
-     * @param d
-     *            the value whose square root has to be computed.
-     * @return the square root of the argument.
      */
     public static native double sqrt(double d);
 
diff --git a/luni/src/test/java/libcore/java/lang/IntrinsicTest.java b/luni/src/test/java/libcore/java/lang/IntrinsicTest.java
index fcf0522..75a4e42 100644
--- a/luni/src/test/java/libcore/java/lang/IntrinsicTest.java
+++ b/luni/src/test/java/libcore/java/lang/IntrinsicTest.java
@@ -60,6 +60,32 @@ public final class IntrinsicTest extends TestCase {
         Math.class.getMethod("abs", double.class).invoke(null, 1.0);
     }
 
+    public void testStrictMath_abs() throws Exception {
+        StrictMath.abs(1);
+        StrictMath.class.getMethod("abs", int.class).invoke(null, 1);
+        StrictMath.abs(1L);
+        StrictMath.class.getMethod("abs", long.class).invoke(null, 1L);
+        StrictMath.abs(1.0f);
+        StrictMath.class.getMethod("abs", float.class).invoke(null, 1.0f);
+        StrictMath.abs(1.0);
+        StrictMath.class.getMethod("abs", double.class).invoke(null, 1.0);
+    }
+
+    public void testStrictMath_min() throws Exception {
+        StrictMath.min(1, 2);
+        StrictMath.class.getMethod("min", int.class, int.class).invoke(null, 1, 2);
+    }
+
+    public void testStrictMath_max() throws Exception {
+        StrictMath.max(1, 2);
+        StrictMath.class.getMethod("max", int.class, int.class).invoke(null, 1, 2);
+    }
+
+    public void testStrictMath_sqrt() throws Exception {
+        StrictMath.sqrt(2.0);
+        StrictMath.class.getMethod("sqrt", double.class).invoke(null, 2.0);
+    }
+
     public void testMath_min() throws Exception {
         Math.min(1, 2);
         Math.class.getMethod("min", int.class, int.class).invoke(null, 1, 2);
-- 
cgit v1.1


From d43b9ef11a1095967a3396b246639b563e1a4128 Mon Sep 17 00:00:00 2001
From: Kenny Root <kroot@google.com>
Date: Wed, 12 Sep 2012 10:32:58 -0700
Subject: Add consistent reasons for NullPointerException

Semi-automated replacement of empty and non-conforming
NullPointerException reason messages.

(cherry-pick of 86acc043d3334651ee26c65467d78d6cefedd397.)

Change-Id: I6d893979f5c20a50e841e32af9fd7b2d8bc9d54d
---
 .../java/java/beans/PropertyChangeSupport.java     |  2 +-
 luni/src/main/java/java/io/BufferedWriter.java     | 22 +++++-----
 luni/src/main/java/java/io/File.java               |  2 +-
 luni/src/main/java/java/io/InputStreamReader.java  |  2 +-
 luni/src/main/java/java/io/ObjectInputStream.java  |  2 +-
 luni/src/main/java/java/io/ObjectStreamField.java  | 14 ++++---
 luni/src/main/java/java/io/OutputStreamWriter.java |  2 +-
 luni/src/main/java/java/io/PipedOutputStream.java  |  2 +-
 luni/src/main/java/java/io/PipedWriter.java        |  2 +-
 luni/src/main/java/java/io/PrintStream.java        | 42 ++++++++++---------
 luni/src/main/java/java/io/Reader.java             |  2 +-
 .../src/main/java/java/io/SequenceInputStream.java |  6 +--
 luni/src/main/java/java/io/StreamTokenizer.java    |  4 +-
 .../main/java/java/io/StringBufferInputStream.java |  2 +-
 luni/src/main/java/java/io/Writer.java             |  2 +-
 .../main/java/java/lang/AbstractStringBuilder.java |  2 +-
 luni/src/main/java/java/lang/Character.java        | 20 ++++-----
 luni/src/main/java/java/lang/ClassLoader.java      |  2 +-
 luni/src/main/java/java/lang/Enum.java             |  6 ++-
 luni/src/main/java/java/lang/ProcessBuilder.java   |  4 +-
 luni/src/main/java/java/lang/ProcessManager.java   | 16 ++++----
 luni/src/main/java/java/lang/Runtime.java          | 18 ++++----
 .../src/main/java/java/lang/StackTraceElement.java |  6 ++-
 luni/src/main/java/java/lang/String.java           | 10 ++---
 luni/src/main/java/java/lang/StringBuilder.java    |  6 +--
 luni/src/main/java/java/lang/System.java           |  4 +-
 luni/src/main/java/java/lang/Thread.java           | 12 +++---
 luni/src/main/java/java/lang/Throwable.java        | 10 ++---
 .../java/java/lang/reflect/GenericArrayType.java   |  2 +-
 luni/src/main/java/java/lang/reflect/Proxy.java    |  8 ++--
 luni/src/main/java/java/math/BigDecimal.java       |  8 ++--
 luni/src/main/java/java/math/BigInt.java           |  2 +-
 luni/src/main/java/java/net/CookieStore.java       |  2 +-
 luni/src/main/java/java/net/DatagramSocket.java    |  6 +--
 .../src/main/java/java/net/URISyntaxException.java | 12 ++++--
 luni/src/main/java/java/net/URLClassLoader.java    |  2 +-
 .../main/java/java/nio/DatagramChannelImpl.java    |  2 +-
 luni/src/main/java/java/nio/SocketChannelImpl.java |  2 +-
 luni/src/main/java/java/nio/channels/Channels.java | 12 +++---
 .../java/security/AlgorithmParameterGenerator.java |  4 +-
 .../java/java/security/AlgorithmParameters.java    |  8 ++--
 luni/src/main/java/java/security/KeyFactory.java   |  4 +-
 .../main/java/java/security/KeyPairGenerator.java  |  4 +-
 luni/src/main/java/java/security/KeyStore.java     |  4 +-
 .../src/main/java/java/security/MessageDigest.java |  6 +--
 luni/src/main/java/java/security/Provider.java     | 23 +++++++----
 luni/src/main/java/java/security/SecureRandom.java |  4 +-
 luni/src/main/java/java/security/Security.java     |  4 +-
 luni/src/main/java/java/security/Signature.java    |  6 +--
 luni/src/main/java/java/security/Signer.java       |  2 +-
 .../java/java/security/cert/CertPathBuilder.java   |  8 ++--
 .../java/java/security/cert/CertPathValidator.java |  4 +-
 .../main/java/java/security/cert/CertStore.java    |  8 ++--
 .../java/security/cert/CertificateFactory.java     |  8 ++--
 .../cert/CollectionCertStoreParameters.java        |  6 +--
 .../security/cert/LDAPCertStoreParameters.java     | 12 +++---
 .../security/cert/PKIXCertPathBuilderResult.java   |  4 +-
 luni/src/main/java/java/security/cert/X509CRL.java |  2 +-
 .../java/security/spec/ECGenParameterSpec.java     |  2 +-
 luni/src/main/java/java/sql/DriverManager.java     |  2 +-
 luni/src/main/java/java/text/AttributedString.java |  8 ++--
 luni/src/main/java/java/text/Collator.java         |  2 +-
 .../src/main/java/java/text/DateFormatSymbols.java |  6 +--
 luni/src/main/java/java/text/DecimalFormat.java    |  4 +-
 .../main/java/java/text/DecimalFormatSymbols.java  |  6 +--
 luni/src/main/java/java/text/MessageFormat.java    |  2 +-
 luni/src/main/java/java/text/NumberFormat.java     |  2 +-
 .../src/main/java/java/text/RuleBasedCollator.java | 12 +++---
 luni/src/main/java/java/text/SimpleDateFormat.java |  2 +-
 luni/src/main/java/java/util/AbstractQueue.java    |  4 +-
 luni/src/main/java/java/util/ArrayDeque.java       |  4 +-
 luni/src/main/java/java/util/Arrays.java           |  4 +-
 luni/src/main/java/java/util/Calendar.java         |  2 +-
 luni/src/main/java/java/util/Collections.java      | 46 ++++++++++++---------
 .../java/util/DuplicateFormatFlagsException.java   |  2 +-
 luni/src/main/java/java/util/EnumMap.java          |  2 +-
 .../FormatFlagsConversionMismatchException.java    |  2 +-
 luni/src/main/java/java/util/Formatter.java        |  2 +-
 luni/src/main/java/java/util/Hashtable.java        | 16 +++++---
 .../util/IllegalFormatConversionException.java     |  2 +-
 .../java/util/IllegalFormatFlagsException.java     |  2 +-
 .../main/java/java/util/ListResourceBundle.java    |  2 +-
 .../java/util/MissingFormatArgumentException.java  |  2 +-
 .../java/util/MissingFormatWidthException.java     |  2 +-
 luni/src/main/java/java/util/Observable.java       |  2 +-
 luni/src/main/java/java/util/PriorityQueue.java    |  4 +-
 luni/src/main/java/java/util/Properties.java       | 12 +++---
 .../java/java/util/PropertyResourceBundle.java     |  2 +-
 luni/src/main/java/java/util/ResourceBundle.java   | 48 ++++++++++++++--------
 luni/src/main/java/java/util/Scanner.java          |  6 +--
 luni/src/main/java/java/util/ServiceLoader.java    |  2 +-
 luni/src/main/java/java/util/StringTokenizer.java  | 18 ++++----
 luni/src/main/java/java/util/TimeZone.java         |  2 +-
 luni/src/main/java/java/util/Timer.java            |  2 +-
 luni/src/main/java/java/util/UUID.java             |  4 +-
 .../util/UnknownFormatConversionException.java     |  2 +-
 .../java/util/UnknownFormatFlagsException.java     |  2 +-
 .../main/java/java/util/jar/JarOutputStream.java   | 12 +++---
 .../main/java/java/util/logging/FileHandler.java   |  6 ++-
 luni/src/main/java/java/util/logging/Handler.java  | 16 ++++----
 .../main/java/java/util/logging/LogManager.java    |  2 +-
 .../main/java/java/util/logging/StreamHandler.java |  2 +-
 .../java/java/util/prefs/AbstractPreferences.java  | 18 ++++----
 .../java/java/util/zip/DeflaterInputStream.java    |  6 ++-
 .../java/java/util/zip/DeflaterOutputStream.java   |  6 ++-
 .../java/java/util/zip/InflaterInputStream.java    |  6 ++-
 .../java/java/util/zip/InflaterOutputStream.java   |  6 ++-
 luni/src/main/java/java/util/zip/ZipEntry.java     |  2 +-
 luni/src/main/java/java/util/zip/ZipFile.java      |  2 +-
 .../main/java/java/util/zip/ZipInputStream.java    |  2 +-
 luni/src/main/java/javax/crypto/Cipher.java        |  8 ++--
 .../main/java/javax/crypto/CipherInputStream.java  |  2 +-
 .../java/javax/crypto/EncryptedPrivateKeyInfo.java | 10 ++---
 .../main/java/javax/crypto/ExemptionMechanism.java |  6 +--
 luni/src/main/java/javax/crypto/KeyAgreement.java  |  4 +-
 luni/src/main/java/javax/crypto/KeyGenerator.java  |  4 +-
 luni/src/main/java/javax/crypto/Mac.java           |  4 +-
 .../main/java/javax/crypto/SecretKeyFactory.java   |  4 +-
 .../main/java/javax/crypto/spec/DESedeKeySpec.java |  4 +-
 .../java/javax/crypto/spec/OAEPParameterSpec.java  |  8 +++-
 luni/src/main/java/javax/crypto/spec/PSource.java  |  4 +-
 .../main/java/javax/net/ssl/KeyManagerFactory.java |  4 +-
 luni/src/main/java/javax/net/ssl/SSLContext.java   |  4 +-
 .../java/javax/net/ssl/TrustManagerFactory.java    |  4 +-
 .../src/main/java/javax/security/auth/Subject.java | 18 ++++----
 .../javax/security/auth/x500/X500Principal.java    |  4 +-
 .../java/javax/xml/datatype/DatatypeFactory.java   |  4 +-
 .../src/main/java/javax/xml/datatype/Duration.java |  6 +--
 .../java/javax/xml/validation/SchemaFactory.java   | 14 ++++---
 .../javax/xml/validation/SchemaFactoryFinder.java  |  4 +-
 .../main/java/javax/xml/validation/Validator.java  | 16 ++++++--
 .../javax/xml/validation/ValidatorHandler.java     | 20 +++++----
 .../main/java/javax/xml/xpath/XPathException.java  |  8 ++--
 .../main/java/javax/xml/xpath/XPathFactory.java    |  8 +---
 .../java/javax/xml/xpath/XPathFactoryFinder.java   |  4 +-
 luni/src/main/java/libcore/icu/NativeIDN.java      |  2 +-
 .../java/libcore/icu/RuleBasedCollatorICU.java     |  2 +-
 .../src/main/java/libcore/io/StrictLineReader.java |  6 ++-
 luni/src/main/java/libcore/net/UriCodec.java       |  2 +-
 luni/src/main/java/libcore/util/BasicLruCache.java |  8 ++--
 .../harmony/crypto/internal/NullCipherSpi.java     |  6 ++-
 .../org/apache/harmony/security/SystemScope.java   |  2 +-
 .../security/provider/cert/X509CRLImpl.java        |  2 +-
 .../provider/crypto/SHA1withDSA_SignatureImpl.java |  2 +-
 .../org/apache/harmony/xml/ExpatAttributes.java    | 16 ++++----
 .../java/org/apache/harmony/xml/dom/NodeImpl.java  |  4 +-
 .../xml/parsers/DocumentBuilderFactoryImpl.java    |  4 +-
 .../harmony/xml/parsers/SAXParserFactoryImpl.java  |  4 +-
 .../xnet/provider/jsse/FileClientSessionCache.java |  4 +-
 149 files changed, 530 insertions(+), 447 deletions(-)

diff --git a/luni/src/main/java/java/beans/PropertyChangeSupport.java b/luni/src/main/java/java/beans/PropertyChangeSupport.java
index 04f8155..1db12b7 100644
--- a/luni/src/main/java/java/beans/PropertyChangeSupport.java
+++ b/luni/src/main/java/java/beans/PropertyChangeSupport.java
@@ -66,7 +66,7 @@ public class PropertyChangeSupport implements Serializable {
      */
     public PropertyChangeSupport(Object sourceBean) {
         if (sourceBean == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("sourceBean == null");
         }
         this.sourceBean = sourceBean;
     }
diff --git a/luni/src/main/java/java/io/BufferedWriter.java b/luni/src/main/java/java/io/BufferedWriter.java
index e4cbe7c..55ae121 100644
--- a/luni/src/main/java/java/io/BufferedWriter.java
+++ b/luni/src/main/java/java/io/BufferedWriter.java
@@ -163,33 +163,33 @@ public class BufferedWriter extends Writer {
 
     /**
      * Writes {@code count} characters starting at {@code offset} in
-     * {@code cbuf} to this writer. If {@code count} is greater than this
+     * {@code buffer} to this writer. If {@code count} is greater than this
      * writer's buffer, then the buffer is flushed and the characters are
      * written directly to the target writer.
      *
-     * @param cbuf
+     * @param buffer
      *            the array containing characters to write.
      * @param offset
-     *            the start position in {@code cbuf} for retrieving characters.
+     *            the start position in {@code buffer} for retrieving characters.
      * @param count
      *            the maximum number of characters to write.
      * @throws IndexOutOfBoundsException
      *             if {@code offset < 0} or {@code count < 0}, or if
      *             {@code offset + count} is greater than the size of
-     *             {@code cbuf}.
+     *             {@code buffer}.
      * @throws IOException
      *             if this writer is closed or another I/O error occurs.
      */
     @Override
-    public void write(char[] cbuf, int offset, int count) throws IOException {
+    public void write(char[] buffer, int offset, int count) throws IOException {
         synchronized (lock) {
             checkNotClosed();
-            if (cbuf == null) {
+            if (buffer == null) {
                 throw new NullPointerException("buffer == null");
             }
-            Arrays.checkOffsetAndCount(cbuf.length, offset, count);
+            Arrays.checkOffsetAndCount(buffer.length, offset, count);
             if (pos == 0 && count >= this.buf.length) {
-                out.write(cbuf, offset, count);
+                out.write(buffer, offset, count);
                 return;
             }
             int available = this.buf.length - pos;
@@ -197,7 +197,7 @@ public class BufferedWriter extends Writer {
                 available = count;
             }
             if (available > 0) {
-                System.arraycopy(cbuf, offset, this.buf, pos, available);
+                System.arraycopy(buffer, offset, this.buf, pos, available);
                 pos += available;
             }
             if (pos == this.buf.length) {
@@ -207,11 +207,11 @@ public class BufferedWriter extends Writer {
                     offset += available;
                     available = count - available;
                     if (available >= this.buf.length) {
-                        out.write(cbuf, offset, available);
+                        out.write(buffer, offset, available);
                         return;
                     }
 
-                    System.arraycopy(cbuf, offset, this.buf, pos, available);
+                    System.arraycopy(buffer, offset, this.buf, pos, available);
                     pos += available;
                 }
             }
diff --git a/luni/src/main/java/java/io/File.java b/luni/src/main/java/java/io/File.java
index ac67e7c..ec87fed 100644
--- a/luni/src/main/java/java/io/File.java
+++ b/luni/src/main/java/java/io/File.java
@@ -147,7 +147,7 @@ public class File implements Serializable, Comparable<File> {
      */
     public File(String dirPath, String name) {
         if (name == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("name == null");
         }
         if (dirPath == null || dirPath.isEmpty()) {
             this.path = fixSlashes(name);
diff --git a/luni/src/main/java/java/io/InputStreamReader.java b/luni/src/main/java/java/io/InputStreamReader.java
index 59be9ed..2e9b381 100644
--- a/luni/src/main/java/java/io/InputStreamReader.java
+++ b/luni/src/main/java/java/io/InputStreamReader.java
@@ -78,7 +78,7 @@ public class InputStreamReader extends Reader {
             throws UnsupportedEncodingException {
         super(in);
         if (enc == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("enc == null");
         }
         this.in = in;
         try {
diff --git a/luni/src/main/java/java/io/ObjectInputStream.java b/luni/src/main/java/java/io/ObjectInputStream.java
index 0d75a44..0476901 100644
--- a/luni/src/main/java/java/io/ObjectInputStream.java
+++ b/luni/src/main/java/java/io/ObjectInputStream.java
@@ -2344,7 +2344,7 @@ public class ObjectInputStream extends InputStream implements ObjectInput, Objec
     public int skipBytes(int length) throws IOException {
         // To be used with available. Ok to call if reading primitive buffer
         if (input == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("source stream is null");
         }
 
         int offset = 0;
diff --git a/luni/src/main/java/java/io/ObjectStreamField.java b/luni/src/main/java/java/io/ObjectStreamField.java
index db450e0..78a6903 100644
--- a/luni/src/main/java/java/io/ObjectStreamField.java
+++ b/luni/src/main/java/java/io/ObjectStreamField.java
@@ -58,8 +58,10 @@ public class ObjectStreamField implements Comparable<Object> {
      *             if {@code name} or {@code cl} is {@code null}.
      */
     public ObjectStreamField(String name, Class<?> cl) {
-        if (name == null || cl == null) {
-            throw new NullPointerException();
+        if (name == null) {
+            throw new NullPointerException("name == null");
+        } else if (cl == null) {
+            throw new NullPointerException("cl == null");
         }
         this.name = name;
         this.type = new WeakReference<Class<?>>(cl);
@@ -81,8 +83,10 @@ public class ObjectStreamField implements Comparable<Object> {
      * @see ObjectOutputStream#writeUnshared(Object)
      */
     public ObjectStreamField(String name, Class<?> cl, boolean unshared) {
-        if (name == null || cl == null) {
-            throw new NullPointerException();
+        if (name == null) {
+            throw new NullPointerException("name == null");
+        } else if (cl == null) {
+            throw new NullPointerException("cl == null");
         }
         this.name = name;
         this.type = (cl.getClassLoader() == null) ? cl : new WeakReference<Class<?>>(cl);
@@ -100,7 +104,7 @@ public class ObjectStreamField implements Comparable<Object> {
      */
     ObjectStreamField(String signature, String name) {
         if (name == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("name == null");
         }
         this.name = name;
         this.typeString = signature.replace('.', '/').intern();
diff --git a/luni/src/main/java/java/io/OutputStreamWriter.java b/luni/src/main/java/java/io/OutputStreamWriter.java
index 86b62fc..c09c9e3 100644
--- a/luni/src/main/java/java/io/OutputStreamWriter.java
+++ b/luni/src/main/java/java/io/OutputStreamWriter.java
@@ -74,7 +74,7 @@ public class OutputStreamWriter extends Writer {
             throws UnsupportedEncodingException {
         super(out);
         if (enc == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("enc == null");
         }
         this.out = out;
         try {
diff --git a/luni/src/main/java/java/io/PipedOutputStream.java b/luni/src/main/java/java/io/PipedOutputStream.java
index a674bb3..1b139e9 100644
--- a/luni/src/main/java/java/io/PipedOutputStream.java
+++ b/luni/src/main/java/java/io/PipedOutputStream.java
@@ -81,7 +81,7 @@ public class PipedOutputStream extends OutputStream {
      */
     public void connect(PipedInputStream stream) throws IOException {
         if (stream == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("stream == null");
         }
         synchronized (stream) {
             if (this.target != null) {
diff --git a/luni/src/main/java/java/io/PipedWriter.java b/luni/src/main/java/java/io/PipedWriter.java
index ece899a..ad8974b 100644
--- a/luni/src/main/java/java/io/PipedWriter.java
+++ b/luni/src/main/java/java/io/PipedWriter.java
@@ -85,7 +85,7 @@ public class PipedWriter extends Writer {
      */
     public void connect(PipedReader reader) throws IOException {
         if (reader == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("reader == null");
         }
         synchronized (reader) {
             if (this.destination != null) {
diff --git a/luni/src/main/java/java/io/PrintStream.java b/luni/src/main/java/java/io/PrintStream.java
index ba48b04..ea67d46 100644
--- a/luni/src/main/java/java/io/PrintStream.java
+++ b/luni/src/main/java/java/io/PrintStream.java
@@ -59,7 +59,7 @@ public class PrintStream extends FilterOutputStream implements Appendable, Close
     public PrintStream(OutputStream out) {
         super(out);
         if (out == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("out == null");
         }
     }
 
@@ -80,7 +80,7 @@ public class PrintStream extends FilterOutputStream implements Appendable, Close
     public PrintStream(OutputStream out, boolean autoFlush) {
         super(out);
         if (out == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("out == null");
         }
         this.autoFlush = autoFlush;
     }
@@ -106,8 +106,10 @@ public class PrintStream extends FilterOutputStream implements Appendable, Close
     public PrintStream(OutputStream out, boolean autoFlush, String enc)
             throws UnsupportedEncodingException {
         super(out);
-        if (out == null || enc == null) {
-            throw new NullPointerException();
+        if (out == null) {
+            throw new NullPointerException("out == null");
+        } else if (enc == null) {
+            throw new NullPointerException("enc == null");
         }
         this.autoFlush = autoFlush;
         try {
@@ -136,30 +138,30 @@ public class PrintStream extends FilterOutputStream implements Appendable, Close
 
     /**
      * Constructs a new {@code PrintStream} with {@code file} as its target. The
-     * character set named {@code csn} is used for character encoding.
+     * character set named {@code charSetName} is used for character encoding.
      *
      * @param file
      *            the target file. If the file already exists, its contents are
      *            removed, otherwise a new file is created.
-     * @param csn
+     * @param charSetName
      *            the name of the character set used for character encoding.
      * @throws FileNotFoundException
      *             if an error occurs while opening or creating the target file.
      * @throws NullPointerException
-     *             if {@code csn} is {@code null}.
+     *             if {@code charSetName} is {@code null}.
      * @throws UnsupportedEncodingException
-     *             if the encoding specified by {@code csn} is not supported.
+     *             if the encoding specified by {@code charSetName} is not supported.
      */
-    public PrintStream(File file, String csn) throws FileNotFoundException,
+    public PrintStream(File file, String charSetName) throws FileNotFoundException,
             UnsupportedEncodingException {
         super(new FileOutputStream(file));
-        if (csn == null) {
-            throw new NullPointerException();
+        if (charSetName == null) {
+            throw new NullPointerException("charSetName == null");
         }
-        if (!Charset.isSupported(csn)) {
-            throw new UnsupportedEncodingException(csn);
+        if (!Charset.isSupported(charSetName)) {
+            throw new UnsupportedEncodingException(charSetName);
         }
-        encoding = csn;
+        encoding = charSetName;
     }
 
     /**
@@ -179,24 +181,24 @@ public class PrintStream extends FilterOutputStream implements Appendable, Close
 
     /**
      * Constructs a new {@code PrintStream} with the file identified by
-     * {@code fileName} as its target. The character set named {@code csn} is
+     * {@code fileName} as its target. The character set named {@code charSetName} is
      * used for character encoding.
      *
      * @param fileName
      *            the target file's name. If the file already exists, its
      *            contents are removed, otherwise a new file is created.
-     * @param csn
+     * @param charSetName
      *            the name of the character set used for character encoding.
      * @throws FileNotFoundException
      *             if an error occurs while opening or creating the target file.
      * @throws NullPointerException
-     *             if {@code csn} is {@code null}.
+     *             if {@code charSetName} is {@code null}.
      * @throws UnsupportedEncodingException
-     *             if the encoding specified by {@code csn} is not supported.
+     *             if the encoding specified by {@code charSetName} is not supported.
      */
-    public PrintStream(String fileName, String csn)
+    public PrintStream(String fileName, String charSetName)
             throws FileNotFoundException, UnsupportedEncodingException {
-        this(new File(fileName), csn);
+        this(new File(fileName), charSetName);
     }
 
     /**
diff --git a/luni/src/main/java/java/io/Reader.java b/luni/src/main/java/java/io/Reader.java
index 310a57c..e947d08 100644
--- a/luni/src/main/java/java/io/Reader.java
+++ b/luni/src/main/java/java/io/Reader.java
@@ -61,7 +61,7 @@ public abstract class Reader implements Readable, Closeable {
      */
     protected Reader(Object lock) {
         if (lock == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("lock == null");
         }
         this.lock = lock;
     }
diff --git a/luni/src/main/java/java/io/SequenceInputStream.java b/luni/src/main/java/java/io/SequenceInputStream.java
index 9ae1901..8333834 100644
--- a/luni/src/main/java/java/io/SequenceInputStream.java
+++ b/luni/src/main/java/java/io/SequenceInputStream.java
@@ -50,7 +50,7 @@ public class SequenceInputStream extends InputStream {
      */
     public SequenceInputStream(InputStream s1, InputStream s2) {
         if (s1 == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("s1 == null");
         }
         Vector<InputStream> inVector = new Vector<InputStream>(1);
         inVector.addElement(s2);
@@ -73,7 +73,7 @@ public class SequenceInputStream extends InputStream {
         if (e.hasMoreElements()) {
             in = e.nextElement();
             if (in == null) {
-                throw new NullPointerException();
+                throw new NullPointerException("element is null");
             }
         }
     }
@@ -112,7 +112,7 @@ public class SequenceInputStream extends InputStream {
         if (e.hasMoreElements()) {
             in = e.nextElement();
             if (in == null) {
-                throw new NullPointerException();
+                throw new NullPointerException("element is null");
             }
         } else {
             in = null;
diff --git a/luni/src/main/java/java/io/StreamTokenizer.java b/luni/src/main/java/java/io/StreamTokenizer.java
index 0522be6..a16dc4b 100644
--- a/luni/src/main/java/java/io/StreamTokenizer.java
+++ b/luni/src/main/java/java/io/StreamTokenizer.java
@@ -167,7 +167,7 @@ public class StreamTokenizer {
     public StreamTokenizer(InputStream is) {
         this();
         if (is == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("is == null");
         }
         inStream = is;
     }
@@ -194,7 +194,7 @@ public class StreamTokenizer {
     public StreamTokenizer(Reader r) {
         this();
         if (r == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("r == null");
         }
         inReader = r;
     }
diff --git a/luni/src/main/java/java/io/StringBufferInputStream.java b/luni/src/main/java/java/io/StringBufferInputStream.java
index 1fada57..1768abe 100644
--- a/luni/src/main/java/java/io/StringBufferInputStream.java
+++ b/luni/src/main/java/java/io/StringBufferInputStream.java
@@ -54,7 +54,7 @@ public class StringBufferInputStream extends InputStream {
      */
     public StringBufferInputStream(String str) {
         if (str == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("str == null");
         }
         buffer = str;
         count = str.length();
diff --git a/luni/src/main/java/java/io/Writer.java b/luni/src/main/java/java/io/Writer.java
index 2e28b80..33d7604 100644
--- a/luni/src/main/java/java/io/Writer.java
+++ b/luni/src/main/java/java/io/Writer.java
@@ -59,7 +59,7 @@ public abstract class Writer implements Appendable, Closeable, Flushable {
      */
     protected Writer(Object lock) {
         if (lock == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("lock == null");
         }
         this.lock = lock;
     }
diff --git a/luni/src/main/java/java/lang/AbstractStringBuilder.java b/luni/src/main/java/java/lang/AbstractStringBuilder.java
index 6e46d26..c3107f2 100644
--- a/luni/src/main/java/java/lang/AbstractStringBuilder.java
+++ b/luni/src/main/java/java/lang/AbstractStringBuilder.java
@@ -437,7 +437,7 @@ abstract class AbstractStringBuilder {
             }
             if (start == end) {
                 if (string == null) {
-                    throw new NullPointerException();
+                    throw new NullPointerException("string == null");
                 }
                 insert0(start, string);
                 return;
diff --git a/luni/src/main/java/java/lang/Character.java b/luni/src/main/java/java/lang/Character.java
index 1a41ec2..cf0ab84 100644
--- a/luni/src/main/java/java/lang/Character.java
+++ b/luni/src/main/java/java/lang/Character.java
@@ -532,7 +532,7 @@ public final class Character implements Serializable, Comparable<Character> {
          */
         protected Subset(String string) {
             if (string == null) {
-                throw new NullPointerException();
+                throw new NullPointerException("string == null");
             }
             name = string;
         }
@@ -1502,7 +1502,7 @@ public final class Character implements Serializable, Comparable<Character> {
          */
         public static UnicodeBlock forName(String blockName) {
             if (blockName == null) {
-                throw new NullPointerException();
+                throw new NullPointerException("blockName == null");
             }
             int block = forNameImpl(blockName);
             if (block == -1) {
@@ -1798,7 +1798,7 @@ public final class Character implements Serializable, Comparable<Character> {
      */
     public static int codePointAt(CharSequence seq, int index) {
         if (seq == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("seq == null");
         }
         int len = seq.length();
         if (index < 0 || index >= len) {
@@ -1840,7 +1840,7 @@ public final class Character implements Serializable, Comparable<Character> {
      */
     public static int codePointAt(char[] seq, int index) {
         if (seq == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("seq == null");
         }
         int len = seq.length;
         if (index < 0 || index >= len) {
@@ -1923,7 +1923,7 @@ public final class Character implements Serializable, Comparable<Character> {
      */
     public static int codePointBefore(CharSequence seq, int index) {
         if (seq == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("seq == null");
         }
         int len = seq.length();
         if (index < 1 || index > len) {
@@ -1965,7 +1965,7 @@ public final class Character implements Serializable, Comparable<Character> {
      */
     public static int codePointBefore(char[] seq, int index) {
         if (seq == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("seq == null");
         }
         int len = seq.length;
         if (index < 1 || index > len) {
@@ -2012,7 +2012,7 @@ public final class Character implements Serializable, Comparable<Character> {
      */
     public static int codePointBefore(char[] seq, int index, int start) {
         if (seq == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("seq == null");
         }
         int len = seq.length;
         if (index <= start || index > len || start < 0 || start >= len) {
@@ -2055,7 +2055,7 @@ public final class Character implements Serializable, Comparable<Character> {
     public static int toChars(int codePoint, char[] dst, int dstIndex) {
         checkValidCodePoint(codePoint);
         if (dst == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("dst == null");
         }
         if (dstIndex < 0 || dstIndex >= dst.length) {
             throw new IndexOutOfBoundsException();
@@ -2126,7 +2126,7 @@ public final class Character implements Serializable, Comparable<Character> {
     public static int codePointCount(CharSequence seq, int beginIndex,
             int endIndex) {
         if (seq == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("seq == null");
         }
         int len = seq.length();
         if (beginIndex < 0 || endIndex > len || beginIndex > endIndex) {
@@ -2215,7 +2215,7 @@ public final class Character implements Serializable, Comparable<Character> {
      */
     public static int offsetByCodePoints(CharSequence seq, int index, int codePointOffset) {
         if (seq == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("seq == null");
         }
         int len = seq.length();
         if (index < 0 || index > len) {
diff --git a/luni/src/main/java/java/lang/ClassLoader.java b/luni/src/main/java/java/lang/ClassLoader.java
index 0cdc448..c99d57c 100644
--- a/luni/src/main/java/java/lang/ClassLoader.java
+++ b/luni/src/main/java/java/lang/ClassLoader.java
@@ -195,7 +195,7 @@ public abstract class ClassLoader {
      */
     ClassLoader(ClassLoader parentLoader, boolean nullAllowed) {
         if (parentLoader == null && !nullAllowed) {
-            throw new NullPointerException("Parent ClassLoader may not be null");
+            throw new NullPointerException("parentLoader == null && !nullAllowed");
         }
         parent = parentLoader;
     }
diff --git a/luni/src/main/java/java/lang/Enum.java b/luni/src/main/java/java/lang/Enum.java
index 3d9e68b..7a0f514 100644
--- a/luni/src/main/java/java/lang/Enum.java
+++ b/luni/src/main/java/java/lang/Enum.java
@@ -181,8 +181,10 @@ public abstract class Enum<E extends Enum<E>> implements Serializable, Comparabl
      *             have a constant value called {@code name}.
      */
     public static <T extends Enum<T>> T valueOf(Class<T> enumType, String name) {
-        if (enumType == null || name == null) {
-            throw new NullPointerException("enumType == null || name == null");
+        if (enumType == null) {
+            throw new NullPointerException("enumType == null");
+        } else if (name == null) {
+            throw new NullPointerException("name == null");
         }
         T[] values = getSharedConstants(enumType);
         if (values == null) {
diff --git a/luni/src/main/java/java/lang/ProcessBuilder.java b/luni/src/main/java/java/lang/ProcessBuilder.java
index 5b7efdc..57e21b6 100644
--- a/luni/src/main/java/java/lang/ProcessBuilder.java
+++ b/luni/src/main/java/java/lang/ProcessBuilder.java
@@ -59,7 +59,7 @@ public final class ProcessBuilder {
      */
     public ProcessBuilder(List<String> command) {
         if (command == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("command == null");
         }
         this.command = command;
 
@@ -102,7 +102,7 @@ public final class ProcessBuilder {
      */
     public ProcessBuilder command(List<String> command) {
         if (command == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("command == null");
         }
         this.command = command;
         return this;
diff --git a/luni/src/main/java/java/lang/ProcessManager.java b/luni/src/main/java/java/lang/ProcessManager.java
index 1e820a9..28314b7 100644
--- a/luni/src/main/java/java/lang/ProcessManager.java
+++ b/luni/src/main/java/java/lang/ProcessManager.java
@@ -168,10 +168,10 @@ final class ProcessManager {
             boolean redirectErrorStream) throws IOException {
         // Make sure we throw the same exceptions as the RI.
         if (taintedCommand == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("taintedCommand == null");
         }
         if (taintedCommand.length == 0) {
-            throw new IndexOutOfBoundsException();
+            throw new IndexOutOfBoundsException("taintedCommand.length == 0");
         }
 
         // Handle security and safety by copying mutable inputs and checking them.
@@ -179,16 +179,16 @@ final class ProcessManager {
         String[] environment = taintedEnvironment != null ? taintedEnvironment.clone() : null;
 
         // Check we're not passing null Strings to the native exec.
-        for (String arg : command) {
-            if (arg == null) {
-                throw new NullPointerException();
+        for (int i = 0; i < command.length; i++) {
+            if (command[i] == null) {
+                throw new NullPointerException("taintedCommand[" + i + "] == null");
             }
         }
         // The environment is allowed to be null or empty, but no element may be null.
         if (environment != null) {
-            for (String env : environment) {
-                if (env == null) {
-                    throw new NullPointerException();
+            for (int i = 0; i < environment.length; i++) {
+                if (environment[i] == null) {
+                    throw new NullPointerException("taintedEnvironment[" + i + "] == null");
                 }
             }
         }
diff --git a/luni/src/main/java/java/lang/Runtime.java b/luni/src/main/java/java/lang/Runtime.java
index efe2303..a2debfd 100644
--- a/luni/src/main/java/java/lang/Runtime.java
+++ b/luni/src/main/java/java/lang/Runtime.java
@@ -224,9 +224,9 @@ public class Runtime {
     public Process exec(String prog, String[] envp, File directory) throws java.io.IOException {
         // Sanity checks
         if (prog == null) {
-            throw new NullPointerException();
-        } else if (prog.length() == 0) {
-            throw new IllegalArgumentException();
+            throw new NullPointerException("prog == null");
+        } else if (prog.isEmpty()) {
+            throw new IllegalArgumentException("prog is empty");
         }
 
         // Break down into tokens, as described in Java docs
@@ -331,11 +331,11 @@ public class Runtime {
     /*
      * Loads and links a library without security checks.
      */
-    void load(String filename, ClassLoader loader) {
-        if (filename == null) {
-            throw new NullPointerException("library path was null.");
+    void load(String pathName, ClassLoader loader) {
+        if (pathName == null) {
+            throw new NullPointerException("pathName == null");
         }
-        String error = nativeLoad(filename, loader);
+        String error = nativeLoad(pathName, loader);
         if (error != null) {
             throw new UnsatisfiedLinkError(error);
         }
@@ -538,7 +538,7 @@ public class Runtime {
     public void addShutdownHook(Thread hook) {
         // Sanity checks
         if (hook == null) {
-            throw new NullPointerException("Hook may not be null.");
+            throw new NullPointerException("hook == null");
         }
 
         if (shuttingDown) {
@@ -571,7 +571,7 @@ public class Runtime {
     public boolean removeShutdownHook(Thread hook) {
         // Sanity checks
         if (hook == null) {
-            throw new NullPointerException("Hook may not be null.");
+            throw new NullPointerException("hook == null");
         }
 
         if (shuttingDown) {
diff --git a/luni/src/main/java/java/lang/StackTraceElement.java b/luni/src/main/java/java/lang/StackTraceElement.java
index b83120c..a59935a 100644
--- a/luni/src/main/java/java/lang/StackTraceElement.java
+++ b/luni/src/main/java/java/lang/StackTraceElement.java
@@ -58,8 +58,10 @@ public final class StackTraceElement implements Serializable {
      *             if {@code cls} or {@code method} is {@code null}.
      */
     public StackTraceElement(String cls, String method, String file, int line) {
-        if (cls == null || method == null) {
-            throw new NullPointerException();
+        if (cls == null) {
+            throw new NullPointerException("cls == null");
+        } else if (method == null) {
+            throw new NullPointerException("method == null");
         }
         declaringClass = cls;
         methodName = method;
diff --git a/luni/src/main/java/java/lang/String.java b/luni/src/main/java/java/lang/String.java
index 224a268..f3aeb64 100644
--- a/luni/src/main/java/java/lang/String.java
+++ b/luni/src/main/java/java/lang/String.java
@@ -514,7 +514,7 @@ outer:
      */
     public String(int[] codePoints, int offset, int count) {
         if (codePoints == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("codePoints == null");
         }
         if ((offset | count) < 0 || count > codePoints.length - offset) {
             throw failedBoundsCheck(codePoints.length, offset, count);
@@ -1222,7 +1222,7 @@ outer:
      */
     public boolean regionMatches(int thisStart, String string, int start, int length) {
         if (string == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("string == null");
         }
         if (start < 0 || string.count - start < length) {
             return false;
@@ -1719,7 +1719,7 @@ outer:
      */
     public boolean contentEquals(CharSequence cs) {
         if (cs == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("cs == null");
         }
 
         int len = cs.length();
@@ -1912,7 +1912,7 @@ outer:
      */
     public boolean contains(CharSequence cs) {
         if (cs == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("cs == null");
         }
         return indexOf(cs.toString()) >= 0;
     }
@@ -1981,7 +1981,7 @@ outer:
      */
     public static String format(Locale locale, String format, Object... args) {
         if (format == null) {
-            throw new NullPointerException("null format argument");
+            throw new NullPointerException("format == null");
         }
         int bufferSize = format.length() + (args == null ? 0 : args.length * 10);
         Formatter f = new Formatter(new StringBuilder(bufferSize), locale);
diff --git a/luni/src/main/java/java/lang/StringBuilder.java b/luni/src/main/java/java/lang/StringBuilder.java
index d886100..a944e68 100644
--- a/luni/src/main/java/java/lang/StringBuilder.java
+++ b/luni/src/main/java/java/lang/StringBuilder.java
@@ -624,7 +624,7 @@ public final class StringBuilder extends AbstractStringBuilder implements
      *            the inclusive begin index.
      * @param end
      *            the exclusive end index.
-     * @param str
+     * @param string
      *            the replacement string.
      * @return this builder.
      * @throws StringIndexOutOfBoundsException
@@ -633,8 +633,8 @@ public final class StringBuilder extends AbstractStringBuilder implements
      * @throws NullPointerException
      *            if {@code str} is {@code null}.
      */
-    public StringBuilder replace(int start, int end, String str) {
-        replace0(start, end, str);
+    public StringBuilder replace(int start, int end, String string) {
+        replace0(start, end, string);
         return this;
     }
 
diff --git a/luni/src/main/java/java/lang/System.java b/luni/src/main/java/java/lang/System.java
index de99161..df84c61 100644
--- a/luni/src/main/java/java/lang/System.java
+++ b/luni/src/main/java/java/lang/System.java
@@ -455,7 +455,7 @@ public final class System {
      */
     public static String clearProperty(String key) {
         if (key == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("key == null");
         }
         if (key.isEmpty()) {
             throw new IllegalArgumentException();
@@ -679,7 +679,7 @@ public final class System {
 
         private String toNonNullString(Object o) {
             if (o == null) {
-                throw new NullPointerException();
+                throw new NullPointerException("o == null");
             }
             return (String) o;
         }
diff --git a/luni/src/main/java/java/lang/Thread.java b/luni/src/main/java/java/lang/Thread.java
index a61f669..210b90c 100644
--- a/luni/src/main/java/java/lang/Thread.java
+++ b/luni/src/main/java/java/lang/Thread.java
@@ -232,7 +232,7 @@ public class Thread implements Runnable {
      */
     public Thread(Runnable runnable, String threadName) {
         if (threadName == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("threadName == null");
         }
 
         create(null, runnable, threadName, 0);
@@ -252,7 +252,7 @@ public class Thread implements Runnable {
      */
     public Thread(String threadName) {
         if (threadName == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("threadName == null");
         }
 
         create(null, null, threadName, 0);
@@ -296,7 +296,7 @@ public class Thread implements Runnable {
      */
     public Thread(ThreadGroup group, Runnable runnable, String threadName) {
         if (threadName == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("threadName == null");
         }
 
         create(group, runnable, threadName, 0);
@@ -317,7 +317,7 @@ public class Thread implements Runnable {
      */
     public Thread(ThreadGroup group, String threadName) {
         if (threadName == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("threadName == null");
         }
 
         create(group, null, threadName, 0);
@@ -346,7 +346,7 @@ public class Thread implements Runnable {
      */
     public Thread(ThreadGroup group, Runnable runnable, String threadName, long stackSize) {
         if (threadName == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("threadName == null");
         }
         create(group, runnable, threadName, stackSize);
     }
@@ -943,7 +943,7 @@ public class Thread implements Runnable {
      */
     public final void setName(String threadName) {
         if (threadName == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("threadName == null");
         }
 
         name = threadName;
diff --git a/luni/src/main/java/java/lang/Throwable.java b/luni/src/main/java/java/lang/Throwable.java
index 31eb538..b20b882 100644
--- a/luni/src/main/java/java/lang/Throwable.java
+++ b/luni/src/main/java/java/lang/Throwable.java
@@ -219,9 +219,9 @@ public class Throwable implements java.io.Serializable {
      */
     public void setStackTrace(StackTraceElement[] trace) {
         StackTraceElement[] newTrace = trace.clone();
-        for (StackTraceElement element : newTrace) {
-            if (element == null) {
-                throw new NullPointerException();
+        for (int i = 0; i < newTrace.length; i++) {
+            if (newTrace[i] == null) {
+                throw new NullPointerException("trace[" + i + "] == null");
             }
         }
         stackTrace = newTrace;
@@ -413,10 +413,10 @@ public class Throwable implements java.io.Serializable {
      */
     public final void addSuppressed(Throwable throwable) {
         if (throwable == this) {
-            throw new IllegalArgumentException("suppressed == this");
+            throw new IllegalArgumentException("throwable == this");
         }
         if (throwable == null) {
-            throw new NullPointerException("suppressed == null");
+            throw new NullPointerException("throwable == null");
         }
         if (suppressedExceptions != null) {
             // suppressed exceptions are enabled
diff --git a/luni/src/main/java/java/lang/reflect/GenericArrayType.java b/luni/src/main/java/java/lang/reflect/GenericArrayType.java
index 6344019..fc03f78 100644
--- a/luni/src/main/java/java/lang/reflect/GenericArrayType.java
+++ b/luni/src/main/java/java/lang/reflect/GenericArrayType.java
@@ -36,4 +36,4 @@ public interface GenericArrayType extends Type {
      *             instantiated for some reason
      */
     Type getGenericComponentType();
-}
\ No newline at end of file
+}
diff --git a/luni/src/main/java/java/lang/reflect/Proxy.java b/luni/src/main/java/java/lang/reflect/Proxy.java
index a24514d..3b10887 100644
--- a/luni/src/main/java/java/lang/reflect/Proxy.java
+++ b/luni/src/main/java/java/lang/reflect/Proxy.java
@@ -89,13 +89,13 @@ public class Proxy implements Serializable {
             Class<?>... interfaces) throws IllegalArgumentException {
         // check that interfaces are a valid array of visible interfaces
         if (interfaces == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("interfaces == null");
         }
         String commonPackageName = null;
         for (int i = 0, length = interfaces.length; i < length; i++) {
             Class<?> next = interfaces[i];
             if (next == null) {
-                throw new NullPointerException();
+                throw new NullPointerException("interfaces[" + i + "] == null");
             }
             String name = next.getName();
             if (!next.isInterface()) {
@@ -206,7 +206,7 @@ public class Proxy implements Serializable {
             Class<?>[] interfaces, InvocationHandler h)
             throws IllegalArgumentException {
         if (h == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("h == null");
         }
         try {
             return getProxyClass(loader, interfaces).getConstructor(
@@ -241,7 +241,7 @@ public class Proxy implements Serializable {
      */
     public static boolean isProxyClass(Class<?> cl) {
         if (cl == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("cl == null");
         }
         synchronized (proxyCache) {
             return proxyCache.containsKey(cl);
diff --git a/luni/src/main/java/java/math/BigDecimal.java b/luni/src/main/java/java/math/BigDecimal.java
index 3a5f3cd..335e3bc 100644
--- a/luni/src/main/java/java/math/BigDecimal.java
+++ b/luni/src/main/java/java/math/BigDecimal.java
@@ -276,7 +276,7 @@ public class BigDecimal extends Number implements Comparable<BigDecimal>, Serial
         long newScale; // the new scale
 
         if (in == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("in == null");
         }
         if ((last >= in.length) || (offset < 0) || (len <= 0) || (last < 0)) {
             throw new NumberFormatException("Bad offset/length: offset=" + offset +
@@ -601,7 +601,7 @@ public class BigDecimal extends Number implements Comparable<BigDecimal>, Serial
      */
     public BigDecimal(BigInteger unscaledVal, int scale) {
         if (unscaledVal == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("unscaledVal == null");
         }
         this.scale = scale;
         setUnscaledValue(unscaledVal);
@@ -1059,7 +1059,7 @@ public class BigDecimal extends Number implements Comparable<BigDecimal>, Serial
     public BigDecimal divide(BigDecimal divisor, int scale, RoundingMode roundingMode) {
         // Let be: this = [u1,s1]  and  divisor = [u2,s2]
         if (roundingMode == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("roundingMode == null");
         }
         if (divisor.isZero()) {
             throw new ArithmeticException("Division by zero");
@@ -1916,7 +1916,7 @@ public class BigDecimal extends Number implements Comparable<BigDecimal>, Serial
      */
     public BigDecimal setScale(int newScale, RoundingMode roundingMode) {
         if (roundingMode == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("roundingMode == null");
         }
         long diffScale = newScale - (long)scale;
         // Let be:  'this' = [u,s]
diff --git a/luni/src/main/java/java/math/BigInt.java b/luni/src/main/java/java/math/BigInt.java
index 1768676..614dbb4 100644
--- a/luni/src/main/java/java/math/BigInt.java
+++ b/luni/src/main/java/java/math/BigInt.java
@@ -153,7 +153,7 @@ final class BigInt {
      */
     String checkString(String s, int base) {
         if (s == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("s == null");
         }
         // A valid big integer consists of an optional '-' or '+' followed by
         // one or more digit characters appropriate to the given base,
diff --git a/luni/src/main/java/java/net/CookieStore.java b/luni/src/main/java/java/net/CookieStore.java
index d09b7e8..619d65c 100644
--- a/luni/src/main/java/java/net/CookieStore.java
+++ b/luni/src/main/java/java/net/CookieStore.java
@@ -100,4 +100,4 @@ public interface CookieStore {
      * @return true if any cookies were removed as a result of this call.
      */
     boolean removeAll();
-}
\ No newline at end of file
+}
diff --git a/luni/src/main/java/java/net/DatagramSocket.java b/luni/src/main/java/java/net/DatagramSocket.java
index 2b468fa..c01f3af 100644
--- a/luni/src/main/java/java/net/DatagramSocket.java
+++ b/luni/src/main/java/java/net/DatagramSocket.java
@@ -244,7 +244,7 @@ public class DatagramSocket {
         checkOpen();
         ensureBound();
         if (pack == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("pack == null");
         }
         if (pendingConnectException != null) {
             throw new SocketException("Pending connect failure", pendingConnectException);
@@ -295,7 +295,7 @@ public class DatagramSocket {
      */
     public void setNetworkInterface(NetworkInterface netInterface) throws SocketException {
         if (netInterface == null) {
-            throw new NullPointerException("networkInterface == null");
+            throw new NullPointerException("netInterface == null");
         }
         try {
             Libcore.os.setsockoptIfreq(impl.fd, SOL_SOCKET, SO_BINDTODEVICE, netInterface.getName());
@@ -374,7 +374,7 @@ public class DatagramSocket {
      */
     protected DatagramSocket(DatagramSocketImpl socketImpl) {
         if (socketImpl == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("socketImpl == null");
         }
         impl = socketImpl;
     }
diff --git a/luni/src/main/java/java/net/URISyntaxException.java b/luni/src/main/java/java/net/URISyntaxException.java
index e08f444..957ea31 100644
--- a/luni/src/main/java/java/net/URISyntaxException.java
+++ b/luni/src/main/java/java/net/URISyntaxException.java
@@ -49,8 +49,10 @@ public class URISyntaxException extends Exception {
     public URISyntaxException(String input, String reason, int index) {
         super(reason);
 
-        if (input == null || reason == null) {
-            throw new NullPointerException();
+        if (input == null) {
+            throw new NullPointerException("input == null");
+        } else if (reason == null) {
+            throw new NullPointerException("reason == null");
         }
 
         if (index < -1) {
@@ -76,8 +78,10 @@ public class URISyntaxException extends Exception {
     public URISyntaxException(String input, String reason) {
         super(reason);
 
-        if (input == null || reason == null) {
-            throw new NullPointerException();
+        if (input == null) {
+            throw new NullPointerException("input == null");
+        } else if (reason == null) {
+            throw new NullPointerException("reason == null");
         }
 
         this.input = input;
diff --git a/luni/src/main/java/java/net/URLClassLoader.java b/luni/src/main/java/java/net/URLClassLoader.java
index 1c8bc43..efb7531 100644
--- a/luni/src/main/java/java/net/URLClassLoader.java
+++ b/luni/src/main/java/java/net/URLClassLoader.java
@@ -822,7 +822,7 @@ public class URLClassLoader extends SecureClassLoader {
         while (!searchList.isEmpty()) {
             URL nextCandidate = searchList.remove(0);
             if (nextCandidate == null) {
-                throw new NullPointerException("A URL is null");
+                throw new NullPointerException("nextCandidate == null");
             }
             if (!handlerMap.containsKey(nextCandidate)) {
                 URLHandler result;
diff --git a/luni/src/main/java/java/nio/DatagramChannelImpl.java b/luni/src/main/java/java/nio/DatagramChannelImpl.java
index a0e064d..4d2fc5a 100644
--- a/luni/src/main/java/java/nio/DatagramChannelImpl.java
+++ b/luni/src/main/java/java/nio/DatagramChannelImpl.java
@@ -448,7 +448,7 @@ class DatagramChannelImpl extends DatagramChannel implements FileDescriptorChann
      */
     private void checkNotNull(ByteBuffer source) {
         if (source == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("source == null");
         }
     }
 
diff --git a/luni/src/main/java/java/nio/SocketChannelImpl.java b/luni/src/main/java/java/nio/SocketChannelImpl.java
index a9d9c53..ff2c157 100644
--- a/luni/src/main/java/java/nio/SocketChannelImpl.java
+++ b/luni/src/main/java/java/nio/SocketChannelImpl.java
@@ -318,7 +318,7 @@ class SocketChannelImpl extends SocketChannel implements FileDescriptorChannel {
     @Override
     public int write(ByteBuffer src) throws IOException {
         if (src == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("src == null");
         }
         checkOpenConnected();
         if (!src.hasRemaining()) {
diff --git a/luni/src/main/java/java/nio/channels/Channels.java b/luni/src/main/java/java/nio/channels/Channels.java
index 3af1465..b59eeac 100644
--- a/luni/src/main/java/java/nio/channels/Channels.java
+++ b/luni/src/main/java/java/nio/channels/Channels.java
@@ -150,7 +150,7 @@ public final class Channels {
     public static Reader newReader(ReadableByteChannel channel,
             String charsetName) {
         if (charsetName == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("charsetName == null");
         }
         return newReader(channel, Charset.forName(charsetName).newDecoder(), -1);
     }
@@ -193,7 +193,7 @@ public final class Channels {
     public static Writer newWriter(WritableByteChannel channel,
             String charsetName) {
         if (charsetName == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("charsetName == null");
         }
         return newWriter(channel, Charset.forName(charsetName).newEncoder(), -1);
     }
@@ -207,7 +207,7 @@ public final class Channels {
 
         ChannelInputStream(ReadableByteChannel channel) {
             if (channel == null) {
-                throw new NullPointerException();
+                throw new NullPointerException("channel == null");
             }
             this.channel = channel;
         }
@@ -247,7 +247,7 @@ public final class Channels {
 
         ChannelOutputStream(WritableByteChannel channel) {
             if (channel == null) {
-                throw new NullPointerException();
+                throw new NullPointerException("channel == null");
             }
             this.channel = channel;
         }
@@ -289,7 +289,7 @@ public final class Channels {
 
         InputStreamChannel(InputStream inputStream) {
             if (inputStream == null) {
-                throw new NullPointerException();
+                throw new NullPointerException("inputStream == null");
             }
             this.inputStream = inputStream;
         }
@@ -328,7 +328,7 @@ public final class Channels {
 
         OutputStreamChannel(OutputStream outputStream) {
             if (outputStream == null) {
-                throw new NullPointerException();
+                throw new NullPointerException("outputStream == null");
             }
             this.outputStream = outputStream;
         }
diff --git a/luni/src/main/java/java/security/AlgorithmParameterGenerator.java b/luni/src/main/java/java/security/AlgorithmParameterGenerator.java
index daefa3c..3edc167 100644
--- a/luni/src/main/java/java/security/AlgorithmParameterGenerator.java
+++ b/luni/src/main/java/java/security/AlgorithmParameterGenerator.java
@@ -88,7 +88,7 @@ public class AlgorithmParameterGenerator {
     public static AlgorithmParameterGenerator getInstance(String algorithm)
             throws NoSuchAlgorithmException {
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Engine.SpiAndProvider sap = ENGINE.getInstance(algorithm, null);
         return new AlgorithmParameterGenerator((AlgorithmParameterGeneratorSpi) sap.spi,
@@ -149,7 +149,7 @@ public class AlgorithmParameterGenerator {
             throw new IllegalArgumentException();
         }
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Object spi = ENGINE.getInstance(algorithm, provider, null);
         return new AlgorithmParameterGenerator((AlgorithmParameterGeneratorSpi) spi, provider,
diff --git a/luni/src/main/java/java/security/AlgorithmParameters.java b/luni/src/main/java/java/security/AlgorithmParameters.java
index 8bbbe1b..073460e 100644
--- a/luni/src/main/java/java/security/AlgorithmParameters.java
+++ b/luni/src/main/java/java/security/AlgorithmParameters.java
@@ -92,7 +92,7 @@ public class AlgorithmParameters {
     public static AlgorithmParameters getInstance(String algorithm)
             throws NoSuchAlgorithmException {
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Engine.SpiAndProvider sap = ENGINE.getInstance(algorithm, null);
         return new AlgorithmParameters((AlgorithmParametersSpi) sap.spi, sap.provider, algorithm);
@@ -120,7 +120,7 @@ public class AlgorithmParameters {
             String provider) throws NoSuchAlgorithmException,
             NoSuchProviderException {
         if (provider == null || provider.isEmpty()) {
-            throw new IllegalArgumentException();
+            throw new IllegalArgumentException("provider == null || provider.isEmpty()");
         }
         Provider p = Security.getProvider(provider);
         if (p == null) {
@@ -148,10 +148,10 @@ public class AlgorithmParameters {
     public static AlgorithmParameters getInstance(String algorithm,
             Provider provider) throws NoSuchAlgorithmException {
         if (provider == null) {
-            throw new IllegalArgumentException();
+            throw new IllegalArgumentException("provider == null");
         }
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Object spi = ENGINE.getInstance(algorithm, provider, null);
         return new AlgorithmParameters((AlgorithmParametersSpi) spi, provider, algorithm);
diff --git a/luni/src/main/java/java/security/KeyFactory.java b/luni/src/main/java/java/security/KeyFactory.java
index 554885a..8d39003 100644
--- a/luni/src/main/java/java/security/KeyFactory.java
+++ b/luni/src/main/java/java/security/KeyFactory.java
@@ -76,7 +76,7 @@ public class KeyFactory {
     public static KeyFactory getInstance(String algorithm)
             throws NoSuchAlgorithmException {
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Engine.SpiAndProvider sap = ENGINE.getInstance(algorithm, null);
         return new KeyFactory((KeyFactorySpi) sap.spi, sap.provider, algorithm);
@@ -130,7 +130,7 @@ public class KeyFactory {
             throw new IllegalArgumentException();
         }
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Object spi = ENGINE.getInstance(algorithm, provider, null);
         return new KeyFactory((KeyFactorySpi) spi, provider, algorithm);
diff --git a/luni/src/main/java/java/security/KeyPairGenerator.java b/luni/src/main/java/java/security/KeyPairGenerator.java
index d5851fa..5c17d79 100644
--- a/luni/src/main/java/java/security/KeyPairGenerator.java
+++ b/luni/src/main/java/java/security/KeyPairGenerator.java
@@ -80,7 +80,7 @@ public abstract class KeyPairGenerator extends KeyPairGeneratorSpi {
     public static KeyPairGenerator getInstance(String algorithm)
             throws NoSuchAlgorithmException {
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Engine.SpiAndProvider sap = ENGINE.getInstance(algorithm, null);
         Object spi = sap.spi;
@@ -143,7 +143,7 @@ public abstract class KeyPairGenerator extends KeyPairGeneratorSpi {
             throw new IllegalArgumentException();
         }
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Object spi = ENGINE.getInstance(algorithm, provider, null);
         if (spi instanceof KeyPairGenerator) {
diff --git a/luni/src/main/java/java/security/KeyStore.java b/luni/src/main/java/java/security/KeyStore.java
index c233a5b..3d856f7 100644
--- a/luni/src/main/java/java/security/KeyStore.java
+++ b/luni/src/main/java/java/security/KeyStore.java
@@ -110,7 +110,7 @@ public class KeyStore {
      */
     public static KeyStore getInstance(String type) throws KeyStoreException {
         if (type == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("type == null");
         }
         try {
             Engine.SpiAndProvider sap = ENGINE.getInstance(type, null);
@@ -182,7 +182,7 @@ public class KeyStore {
             throw new IllegalArgumentException();
         }
         if (type == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("type == null");
         }
         // return KeyStore instance
         try {
diff --git a/luni/src/main/java/java/security/MessageDigest.java b/luni/src/main/java/java/security/MessageDigest.java
index 3154028..6f1bf21 100644
--- a/luni/src/main/java/java/security/MessageDigest.java
+++ b/luni/src/main/java/java/security/MessageDigest.java
@@ -86,7 +86,7 @@ public abstract class MessageDigest extends MessageDigestSpi {
     public static MessageDigest getInstance(String algorithm)
             throws NoSuchAlgorithmException {
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Engine.SpiAndProvider sap = ENGINE.getInstance(algorithm, null);
         Object spi = sap.spi;
@@ -152,7 +152,7 @@ public abstract class MessageDigest extends MessageDigestSpi {
             throw new IllegalArgumentException();
         }
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Object spi = ENGINE.getInstance(algorithm, provider, null);
         if (spi instanceof MessageDigest) {
@@ -217,7 +217,7 @@ public abstract class MessageDigest extends MessageDigestSpi {
      */
     public void update(byte[] input) {
         if (input == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("input == null");
         }
         engineUpdate(input, 0, input.length);
     }
diff --git a/luni/src/main/java/java/security/Provider.java b/luni/src/main/java/java/security/Provider.java
index 018e268..899625a 100644
--- a/luni/src/main/java/java/security/Provider.java
+++ b/luni/src/main/java/java/security/Provider.java
@@ -407,8 +407,10 @@ public abstract class Provider extends Properties {
      */
     public synchronized Provider.Service getService(String type,
             String algorithm) {
-        if (type == null || algorithm == null) {
-            throw new NullPointerException();
+        if (type == null) {
+            throw new NullPointerException("type == null");
+        } else if (algorithm == null) {
+            throw new NullPointerException("algorithm == null");
         }
 
         if (type.equals(lastServiceName) && algorithm.equalsIgnoreCase(lastAlgorithm)) {
@@ -475,7 +477,7 @@ public abstract class Provider extends Properties {
      */
     protected synchronized void putService(Provider.Service s) {
         if (s == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("s == null");
         }
         if ("Provider".equals(s.getType())) { // Provider service type cannot be added
             return;
@@ -507,7 +509,7 @@ public abstract class Provider extends Properties {
      */
     protected synchronized void removeService(Provider.Service s) {
         if (s == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("s == null");
         }
         servicesChanged();
         if (serviceTable != null) {
@@ -852,9 +854,14 @@ public abstract class Provider extends Properties {
          */
         public Service(Provider provider, String type, String algorithm,
                 String className, List<String> aliases, Map<String, String> attributes) {
-            if (provider == null || type == null || algorithm == null
-                    || className == null) {
-                throw new NullPointerException();
+            if (provider == null) {
+                throw new NullPointerException("provider == null");
+            } else if (type == null) {
+                throw new NullPointerException("type == null");
+            } else if (algorithm == null) {
+                throw new NullPointerException("algorithm == null");
+            } else if (className == null) {
+                throw new NullPointerException("className == null");
             }
             this.provider = provider;
             this.type = type;
@@ -943,7 +950,7 @@ public abstract class Provider extends Properties {
          */
         public final String getAttribute(String name) {
             if (name == null) {
-                throw new NullPointerException();
+                throw new NullPointerException("name == null");
             }
             if (attributes == null) {
                 return null;
diff --git a/luni/src/main/java/java/security/SecureRandom.java b/luni/src/main/java/java/security/SecureRandom.java
index 9091f73..6ed631c 100644
--- a/luni/src/main/java/java/security/SecureRandom.java
+++ b/luni/src/main/java/java/security/SecureRandom.java
@@ -153,7 +153,7 @@ public class SecureRandom extends Random {
      */
     public static SecureRandom getInstance(String algorithm) throws NoSuchAlgorithmException {
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Engine.SpiAndProvider sap = ENGINE.getInstance(algorithm, null);
         return new SecureRandom((SecureRandomSpi) sap.spi, sap.provider,
@@ -212,7 +212,7 @@ public class SecureRandom extends Random {
             throw new IllegalArgumentException();
         }
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Object spi = ENGINE.getInstance(algorithm, provider, null);
         return new SecureRandom((SecureRandomSpi) spi, provider, algorithm);
diff --git a/luni/src/main/java/java/security/Security.java b/luni/src/main/java/java/security/Security.java
index a4cc6e1..b5bd02a 100644
--- a/luni/src/main/java/java/security/Security.java
+++ b/luni/src/main/java/java/security/Security.java
@@ -227,7 +227,7 @@ public final class Security {
      */
     public static Provider[] getProviders(String filter) {
         if (filter == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("filter == null");
         }
         if (filter.length() == 0) {
             throw new InvalidParameterException();
@@ -271,7 +271,7 @@ public final class Security {
      */
     public static synchronized Provider[] getProviders(Map<String,String> filter) {
         if (filter == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("filter == null");
         }
         if (filter.isEmpty()) {
             return null;
diff --git a/luni/src/main/java/java/security/Signature.java b/luni/src/main/java/java/security/Signature.java
index d9e1e41..be89654 100644
--- a/luni/src/main/java/java/security/Signature.java
+++ b/luni/src/main/java/java/security/Signature.java
@@ -99,7 +99,7 @@ public abstract class Signature extends SignatureSpi {
     public static Signature getInstance(String algorithm)
             throws NoSuchAlgorithmException {
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Engine.SpiAndProvider sap = ENGINE.getInstance(algorithm, null);
         Object spi = sap.spi;
@@ -134,7 +134,7 @@ public abstract class Signature extends SignatureSpi {
     public static Signature getInstance(String algorithm, String provider)
             throws NoSuchAlgorithmException, NoSuchProviderException {
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         if (provider == null || provider.isEmpty()) {
             throw new IllegalArgumentException();
@@ -165,7 +165,7 @@ public abstract class Signature extends SignatureSpi {
     public static Signature getInstance(String algorithm, Provider provider)
             throws NoSuchAlgorithmException {
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         if (provider == null) {
             throw new IllegalArgumentException();
diff --git a/luni/src/main/java/java/security/Signer.java b/luni/src/main/java/java/security/Signer.java
index 1e4412a..b892090 100644
--- a/luni/src/main/java/java/security/Signer.java
+++ b/luni/src/main/java/java/security/Signer.java
@@ -83,7 +83,7 @@ public abstract class Signer extends Identity {
      */
     public final void setKeyPair(KeyPair pair) throws InvalidParameterException, KeyException {
         if (pair == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("pair == null");
         }
 
         if (pair.getPrivate() == null || pair.getPublic() == null) {
diff --git a/luni/src/main/java/java/security/cert/CertPathBuilder.java b/luni/src/main/java/java/security/cert/CertPathBuilder.java
index aa65fe7..42029e5 100644
--- a/luni/src/main/java/java/security/cert/CertPathBuilder.java
+++ b/luni/src/main/java/java/security/cert/CertPathBuilder.java
@@ -102,7 +102,7 @@ public class CertPathBuilder {
     public static CertPathBuilder getInstance(String algorithm)
             throws NoSuchAlgorithmException {
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Engine.SpiAndProvider sap = ENGINE.getInstance(algorithm, null);
         return new CertPathBuilder((CertPathBuilderSpi) sap.spi, sap.provider, algorithm);
@@ -128,7 +128,7 @@ public class CertPathBuilder {
     public static CertPathBuilder getInstance(String algorithm, String provider)
             throws NoSuchAlgorithmException, NoSuchProviderException {
         if (provider == null || provider.isEmpty()) {
-            throw new IllegalArgumentException();
+            throw new IllegalArgumentException("provider == null || provider.isEmpty()");
         }
         Provider impProvider = Security.getProvider(provider);
         if (impProvider == null) {
@@ -156,10 +156,10 @@ public class CertPathBuilder {
     public static CertPathBuilder getInstance(String algorithm,
             Provider provider) throws NoSuchAlgorithmException {
         if (provider == null) {
-            throw new IllegalArgumentException();
+            throw new IllegalArgumentException("provider == null");
         }
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Object spi = ENGINE.getInstance(algorithm, provider, null);
         return new CertPathBuilder((CertPathBuilderSpi) spi, provider, algorithm);
diff --git a/luni/src/main/java/java/security/cert/CertPathValidator.java b/luni/src/main/java/java/security/cert/CertPathValidator.java
index 69b9f99..ddf78bf 100644
--- a/luni/src/main/java/java/security/cert/CertPathValidator.java
+++ b/luni/src/main/java/java/security/cert/CertPathValidator.java
@@ -101,7 +101,7 @@ public class CertPathValidator {
     public static CertPathValidator getInstance(String algorithm)
             throws NoSuchAlgorithmException {
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Engine.SpiAndProvider sap = ENGINE.getInstance(algorithm, null);
         return new CertPathValidator((CertPathValidatorSpi) sap.spi, sap.provider, algorithm);
@@ -160,7 +160,7 @@ public class CertPathValidator {
             throw new IllegalArgumentException();
         }
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Object spi = ENGINE.getInstance(algorithm, provider, null);
         return new CertPathValidator((CertPathValidatorSpi) spi, provider, algorithm);
diff --git a/luni/src/main/java/java/security/cert/CertStore.java b/luni/src/main/java/java/security/cert/CertStore.java
index 6cdaea7..2e28828 100644
--- a/luni/src/main/java/java/security/cert/CertStore.java
+++ b/luni/src/main/java/java/security/cert/CertStore.java
@@ -97,7 +97,7 @@ public class CertStore {
     public static CertStore getInstance(String type, CertStoreParameters params)
             throws InvalidAlgorithmParameterException, NoSuchAlgorithmException {
         if (type == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("type == null");
         }
         try {
             Engine.SpiAndProvider sap = ENGINE.getInstance(type, params);
@@ -140,7 +140,7 @@ public class CertStore {
             throws InvalidAlgorithmParameterException,
             NoSuchAlgorithmException, NoSuchProviderException {
         if (provider == null || provider.isEmpty()) {
-            throw new IllegalArgumentException();
+            throw new IllegalArgumentException("provider == null || provider.isEmpty()");
         }
         Provider impProvider = Security.getProvider(provider);
         if (impProvider == null) {
@@ -172,10 +172,10 @@ public class CertStore {
             CertStoreParameters params, Provider provider)
             throws NoSuchAlgorithmException, InvalidAlgorithmParameterException {
         if (provider == null) {
-            throw new IllegalArgumentException();
+            throw new IllegalArgumentException("provider == null");
         }
         if (type == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("type == null");
         }
         try {
             Object spi = ENGINE.getInstance(type, provider, params);
diff --git a/luni/src/main/java/java/security/cert/CertificateFactory.java b/luni/src/main/java/java/security/cert/CertificateFactory.java
index 1aac1a0..83d40d3 100644
--- a/luni/src/main/java/java/security/cert/CertificateFactory.java
+++ b/luni/src/main/java/java/security/cert/CertificateFactory.java
@@ -84,7 +84,7 @@ public class CertificateFactory {
     public static final CertificateFactory getInstance(String type)
             throws CertificateException {
         if (type == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("type == null");
         }
         try {
             Engine.SpiAndProvider sap = ENGINE.getInstance(type, null);
@@ -117,7 +117,7 @@ public class CertificateFactory {
             String provider) throws CertificateException,
             NoSuchProviderException {
         if (provider == null || provider.isEmpty()) {
-            throw new IllegalArgumentException();
+            throw new IllegalArgumentException("provider == null || provider.isEmpty()");
         }
         Provider impProvider = Security.getProvider(provider);
         if (impProvider == null) {
@@ -147,10 +147,10 @@ public class CertificateFactory {
     public static final CertificateFactory getInstance(String type,
             Provider provider) throws CertificateException {
         if (provider == null) {
-            throw new IllegalArgumentException();
+            throw new IllegalArgumentException("provider == null");
         }
         if (type == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("type == null");
         }
         try {
             Object spi = ENGINE.getInstance(type, provider, null);
diff --git a/luni/src/main/java/java/security/cert/CollectionCertStoreParameters.java b/luni/src/main/java/java/security/cert/CollectionCertStoreParameters.java
index de3c85d..9373b40 100644
--- a/luni/src/main/java/java/security/cert/CollectionCertStoreParameters.java
+++ b/luni/src/main/java/java/security/cert/CollectionCertStoreParameters.java
@@ -58,10 +58,10 @@ public class CollectionCertStoreParameters implements CertStoreParameters {
      *             if {@code collection is null}.
      */
     public CollectionCertStoreParameters(Collection<?> collection) {
-        this.collection = collection;
-        if (this.collection == null) {
-            throw new NullPointerException();
+        if (collection == null) {
+            throw new NullPointerException("collection == null");
         }
+        this.collection = collection;
     }
 
     /**
diff --git a/luni/src/main/java/java/security/cert/LDAPCertStoreParameters.java b/luni/src/main/java/java/security/cert/LDAPCertStoreParameters.java
index 5b01f90..163c99a 100644
--- a/luni/src/main/java/java/security/cert/LDAPCertStoreParameters.java
+++ b/luni/src/main/java/java/security/cert/LDAPCertStoreParameters.java
@@ -43,11 +43,11 @@ public class LDAPCertStoreParameters implements CertStoreParameters {
      *             is {@code serverName} is {@code null}.
      */
     public LDAPCertStoreParameters(String serverName, int port) {
+        if (serverName == null) {
+            throw new NullPointerException("serverName == null");
+        }
         this.port = port;
         this.serverName = serverName;
-        if (this.serverName == null) {
-            throw new NullPointerException();
-        }
     }
 
     /**
@@ -71,11 +71,11 @@ public class LDAPCertStoreParameters implements CertStoreParameters {
      *             if {@code serverName} is {@code null}.
      */
     public LDAPCertStoreParameters(String serverName) {
+        if (serverName == null) {
+            throw new NullPointerException("serverName == null");
+        }
         this.port = DEFAULT_LDAP_PORT;
         this.serverName = serverName;
-        if (this.serverName == null) {
-            throw new NullPointerException();
-        }
     }
 
     /**
diff --git a/luni/src/main/java/java/security/cert/PKIXCertPathBuilderResult.java b/luni/src/main/java/java/security/cert/PKIXCertPathBuilderResult.java
index 589ce82..2359612 100644
--- a/luni/src/main/java/java/security/cert/PKIXCertPathBuilderResult.java
+++ b/luni/src/main/java/java/security/cert/PKIXCertPathBuilderResult.java
@@ -49,10 +49,10 @@ public class PKIXCertPathBuilderResult extends PKIXCertPathValidatorResult
     public PKIXCertPathBuilderResult(CertPath certPath, TrustAnchor trustAnchor,
             PolicyNode policyTree, PublicKey subjectPublicKey) {
         super(trustAnchor, policyTree, subjectPublicKey);
-        this.certPath = certPath;
-        if (this.certPath == null) {
+        if (certPath == null) {
             throw new NullPointerException("certPath == null");
         }
+        this.certPath = certPath;
     }
 
     /**
diff --git a/luni/src/main/java/java/security/cert/X509CRL.java b/luni/src/main/java/java/security/cert/X509CRL.java
index 4badd59..4addb0e 100644
--- a/luni/src/main/java/java/security/cert/X509CRL.java
+++ b/luni/src/main/java/java/security/cert/X509CRL.java
@@ -218,7 +218,7 @@ public abstract class X509CRL extends CRL implements X509Extension {
      */
     public X509CRLEntry getRevokedCertificate(X509Certificate certificate) {
         if (certificate == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("certificate == null");
         }
         return getRevokedCertificate(certificate.getSerialNumber());
     }
diff --git a/luni/src/main/java/java/security/spec/ECGenParameterSpec.java b/luni/src/main/java/java/security/spec/ECGenParameterSpec.java
index fe66b1e..c22038d 100644
--- a/luni/src/main/java/java/security/spec/ECGenParameterSpec.java
+++ b/luni/src/main/java/java/security/spec/ECGenParameterSpec.java
@@ -35,7 +35,7 @@ public class ECGenParameterSpec implements AlgorithmParameterSpec {
     public ECGenParameterSpec(String name) {
         this.name = name;
         if (this.name == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("name == null");
         }
     }
 
diff --git a/luni/src/main/java/java/sql/DriverManager.java b/luni/src/main/java/java/sql/DriverManager.java
index 4cee1fe..c547585 100644
--- a/luni/src/main/java/java/sql/DriverManager.java
+++ b/luni/src/main/java/java/sql/DriverManager.java
@@ -329,7 +329,7 @@ public class DriverManager {
      */
     public static void registerDriver(Driver driver) throws SQLException {
         if (driver == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("driver == null");
         }
         synchronized (theDrivers) {
             theDrivers.add(driver);
diff --git a/luni/src/main/java/java/text/AttributedString.java b/luni/src/main/java/java/text/AttributedString.java
index 1335067..d679283 100644
--- a/luni/src/main/java/java/text/AttributedString.java
+++ b/luni/src/main/java/java/text/AttributedString.java
@@ -519,7 +519,7 @@ public class AttributedString {
      */
     public AttributedString(String value) {
         if (value == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("value == null");
         }
         text = value;
         attributeMap = new HashMap<Attribute, List<Range>>(11);
@@ -542,7 +542,7 @@ public class AttributedString {
     public AttributedString(String value,
             Map<? extends AttributedCharacterIterator.Attribute, ?> attributes) {
         if (value == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("value == null");
         }
         if (value.length() == 0 && !attributes.isEmpty()) {
             throw new IllegalArgumentException("Cannot add attributes to empty string");
@@ -575,7 +575,7 @@ public class AttributedString {
      */
     public void addAttribute(AttributedCharacterIterator.Attribute attribute, Object value) {
         if (attribute == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("attribute == null");
         }
         if (text.length() == 0) {
             throw new IllegalArgumentException();
@@ -612,7 +612,7 @@ public class AttributedString {
     public void addAttribute(AttributedCharacterIterator.Attribute attribute,
             Object value, int start, int end) {
         if (attribute == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("attribute == null");
         }
         if (start < 0 || end > text.length() || start >= end) {
             throw new IllegalArgumentException();
diff --git a/luni/src/main/java/java/text/Collator.java b/luni/src/main/java/java/text/Collator.java
index 0fa8c71..2ddb516 100644
--- a/luni/src/main/java/java/text/Collator.java
+++ b/luni/src/main/java/java/text/Collator.java
@@ -286,7 +286,7 @@ public abstract class Collator implements Comparator<Object>, Cloneable {
      */
     public static Collator getInstance(Locale locale) {
         if (locale == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("locale == null");
         }
         return new RuleBasedCollator(new RuleBasedCollatorICU(locale));
     }
diff --git a/luni/src/main/java/java/text/DateFormatSymbols.java b/luni/src/main/java/java/text/DateFormatSymbols.java
index 3c4768d..e2a2345 100644
--- a/luni/src/main/java/java/text/DateFormatSymbols.java
+++ b/luni/src/main/java/java/text/DateFormatSymbols.java
@@ -142,7 +142,7 @@ public class DateFormatSymbols implements Serializable, Cloneable {
      */
     public static final DateFormatSymbols getInstance(Locale locale) {
         if (locale == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("locale == null");
         }
         return new DateFormatSymbols(locale);
     }
@@ -410,7 +410,7 @@ public class DateFormatSymbols implements Serializable, Cloneable {
      */
     public void setLocalPatternChars(String data) {
         if (data == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("data == null");
         }
         localPatternChars = data;
     }
@@ -471,7 +471,7 @@ public class DateFormatSymbols implements Serializable, Cloneable {
      */
     public void setZoneStrings(String[][] zoneStrings) {
         if (zoneStrings == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("zoneStrings == null");
         }
         for (String[] row : zoneStrings) {
             if (row.length < 5) {
diff --git a/luni/src/main/java/java/text/DecimalFormat.java b/luni/src/main/java/java/text/DecimalFormat.java
index c1a48db..eded6a8 100644
--- a/luni/src/main/java/java/text/DecimalFormat.java
+++ b/luni/src/main/java/java/text/DecimalFormat.java
@@ -654,7 +654,7 @@ public class DecimalFormat extends NumberFormat {
     @Override
     public AttributedCharacterIterator formatToCharacterIterator(Object object) {
         if (object == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("object == null");
         }
         return dform.formatToCharacterIterator(object);
     }
@@ -1248,7 +1248,7 @@ public class DecimalFormat extends NumberFormat {
      */
     public void setRoundingMode(RoundingMode roundingMode) {
         if (roundingMode == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("roundingMode == null");
         }
         this.roundingMode = roundingMode;
         if (roundingMode != RoundingMode.UNNECESSARY) { // ICU4C doesn't support UNNECESSARY.
diff --git a/luni/src/main/java/java/text/DecimalFormatSymbols.java b/luni/src/main/java/java/text/DecimalFormatSymbols.java
index 9d2bcc1..708b291 100644
--- a/luni/src/main/java/java/text/DecimalFormatSymbols.java
+++ b/luni/src/main/java/java/text/DecimalFormatSymbols.java
@@ -127,7 +127,7 @@ public class DecimalFormatSymbols implements Cloneable, Serializable {
      */
     public static DecimalFormatSymbols getInstance(Locale locale) {
         if (locale == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("locale == null");
         }
         return new DecimalFormatSymbols(locale);
     }
@@ -389,7 +389,7 @@ public class DecimalFormatSymbols implements Cloneable, Serializable {
      */
     public void setCurrency(Currency currency) {
         if (currency == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("currency == null");
         }
         if (currency == this.currency) {
             return;
@@ -558,7 +558,7 @@ public class DecimalFormatSymbols implements Cloneable, Serializable {
      */
     public void setExponentSeparator(String value) {
         if (value == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("value == null");
         }
         this.exponentSeparator = value;
     }
diff --git a/luni/src/main/java/java/text/MessageFormat.java b/luni/src/main/java/java/text/MessageFormat.java
index a98e4fd..2ab78db 100644
--- a/luni/src/main/java/java/text/MessageFormat.java
+++ b/luni/src/main/java/java/text/MessageFormat.java
@@ -506,7 +506,7 @@ public class MessageFormat extends Format {
     @Override
     public AttributedCharacterIterator formatToCharacterIterator(Object object) {
         if (object == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("object == null");
         }
 
         StringBuffer buffer = new StringBuffer();
diff --git a/luni/src/main/java/java/text/NumberFormat.java b/luni/src/main/java/java/text/NumberFormat.java
index 3bff6ad..070174b 100644
--- a/luni/src/main/java/java/text/NumberFormat.java
+++ b/luni/src/main/java/java/text/NumberFormat.java
@@ -570,7 +570,7 @@ public abstract class NumberFormat extends Format {
     @Override
     public final Object parseObject(String string, ParsePosition position) {
         if (position == null) {
-            throw new NullPointerException("position is null");
+            throw new NullPointerException("position == null");
         }
         try {
             return parse(string, position);
diff --git a/luni/src/main/java/java/text/RuleBasedCollator.java b/luni/src/main/java/java/text/RuleBasedCollator.java
index 4fd8650..cda06db 100644
--- a/luni/src/main/java/java/text/RuleBasedCollator.java
+++ b/luni/src/main/java/java/text/RuleBasedCollator.java
@@ -284,7 +284,7 @@ public class RuleBasedCollator extends Collator {
      */
     public RuleBasedCollator(String rules) throws ParseException {
         if (rules == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("rules == null");
         }
         if (rules.isEmpty()) {
             throw new ParseException("empty rules", 0);
@@ -314,7 +314,7 @@ public class RuleBasedCollator extends Collator {
      */
     public CollationElementIterator getCollationElementIterator(CharacterIterator source) {
         if (source == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("source == null");
         }
         return new CollationElementIterator(icuColl.getCollationElementIterator(source));
     }
@@ -328,7 +328,7 @@ public class RuleBasedCollator extends Collator {
      */
     public CollationElementIterator getCollationElementIterator(String source) {
         if (source == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("source == null");
         }
         return new CollationElementIterator(icuColl.getCollationElementIterator(source));
     }
@@ -385,8 +385,10 @@ public class RuleBasedCollator extends Collator {
      */
     @Override
     public int compare(String source, String target) {
-        if (source == null || target == null) {
-            throw new NullPointerException();
+        if (source == null) {
+            throw new NullPointerException("source == null");
+        } else if (target == null) {
+            throw new NullPointerException("target == null");
         }
         return icuColl.compare(source, target);
     }
diff --git a/luni/src/main/java/java/text/SimpleDateFormat.java b/luni/src/main/java/java/text/SimpleDateFormat.java
index f39f770..da5af85 100644
--- a/luni/src/main/java/java/text/SimpleDateFormat.java
+++ b/luni/src/main/java/java/text/SimpleDateFormat.java
@@ -471,7 +471,7 @@ public class SimpleDateFormat extends DateFormat {
     @Override
     public AttributedCharacterIterator formatToCharacterIterator(Object object) {
         if (object == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("object == null");
         }
         if (object instanceof Date) {
             return formatToCharacterIteratorImpl((Date) object);
diff --git a/luni/src/main/java/java/util/AbstractQueue.java b/luni/src/main/java/java/util/AbstractQueue.java
index b046559..47f81fd 100644
--- a/luni/src/main/java/java/util/AbstractQueue.java
+++ b/luni/src/main/java/java/util/AbstractQueue.java
@@ -150,9 +150,9 @@ public abstract class AbstractQueue<E>
      */
     public boolean addAll(Collection<? extends E> c) {
         if (c == null)
-            throw new NullPointerException();
+            throw new NullPointerException("c == null");
         if (c == this)
-            throw new IllegalArgumentException();
+            throw new IllegalArgumentException("c == this");
         boolean modified = false;
         for (E e : c)
             if (add(e))
diff --git a/luni/src/main/java/java/util/ArrayDeque.java b/luni/src/main/java/java/util/ArrayDeque.java
index c4d67b8..5ee3f81 100644
--- a/luni/src/main/java/java/util/ArrayDeque.java
+++ b/luni/src/main/java/java/util/ArrayDeque.java
@@ -193,7 +193,7 @@ public class ArrayDeque<E> extends AbstractCollection<E>
      */
     public void addFirst(E e) {
         if (e == null)
-            throw new NullPointerException();
+            throw new NullPointerException("e == null");
         elements[head = (head - 1) & (elements.length - 1)] = e;
         if (head == tail)
             doubleCapacity();
@@ -209,7 +209,7 @@ public class ArrayDeque<E> extends AbstractCollection<E>
      */
     public void addLast(E e) {
         if (e == null)
-            throw new NullPointerException();
+            throw new NullPointerException("e == null");
         elements[tail] = e;
         if ( (tail = (tail + 1) & (elements.length - 1)) == head)
             doubleCapacity();
diff --git a/luni/src/main/java/java/util/Arrays.java b/luni/src/main/java/java/util/Arrays.java
index 588410f..4a149b7 100644
--- a/luni/src/main/java/java/util/Arrays.java
+++ b/luni/src/main/java/java/util/Arrays.java
@@ -35,7 +35,7 @@ public class Arrays {
 
         ArrayList(E[] storage) {
             if (storage == null) {
-                throw new NullPointerException();
+                throw new NullPointerException("storage == null");
             }
             a = storage;
         }
@@ -2611,7 +2611,7 @@ public class Arrays {
      */
     public static <T> T[] copyOf(T[] original, int newLength) {
         if (original == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("original == null");
         }
         if (newLength < 0) {
             throw new NegativeArraySizeException(Integer.toString(newLength));
diff --git a/luni/src/main/java/java/util/Calendar.java b/luni/src/main/java/java/util/Calendar.java
index 4cabd4a..81d01fb 100644
--- a/luni/src/main/java/java/util/Calendar.java
+++ b/luni/src/main/java/java/util/Calendar.java
@@ -1389,7 +1389,7 @@ public abstract class Calendar implements Serializable, Cloneable, Comparable<Ca
      */
     public int compareTo(Calendar anotherCalendar) {
         if (anotherCalendar == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("anotherCalendar == null");
         }
         long timeInMillis = getTimeInMillis();
         long anotherTimeInMillis = anotherCalendar.getTimeInMillis();
diff --git a/luni/src/main/java/java/util/Collections.java b/luni/src/main/java/java/util/Collections.java
index b6729b4..d49ca85 100644
--- a/luni/src/main/java/java/util/Collections.java
+++ b/luni/src/main/java/java/util/Collections.java
@@ -1412,7 +1412,7 @@ public class Collections {
     @SuppressWarnings("unchecked")
     public static <T> int binarySearch(List<? extends Comparable<? super T>> list, T object) {
         if (list == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("list == null");
         }
         if (list.isEmpty()) {
             return -1;
@@ -1916,7 +1916,7 @@ public class Collections {
     @SuppressWarnings("unchecked")
     public static void swap(List<?> list, int index1, int index2) {
         if (list == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("list == null");
         }
         final int size = list.size();
         if (index1 < 0 || index1 >= size || index2 < 0 || index2 >= size) {
@@ -2174,7 +2174,7 @@ public class Collections {
     public static <T> Collection<T> synchronizedCollection(
             Collection<T> collection) {
         if (collection == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("collection == null");
         }
         return new SynchronizedCollection<T>(collection);
     }
@@ -2189,7 +2189,7 @@ public class Collections {
      */
     public static <T> List<T> synchronizedList(List<T> list) {
         if (list == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("list == null");
         }
         if (list instanceof RandomAccess) {
             return new SynchronizedRandomAccessList<T>(list);
@@ -2207,7 +2207,7 @@ public class Collections {
      */
     public static <K, V> Map<K, V> synchronizedMap(Map<K, V> map) {
         if (map == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("map == null");
         }
         return new SynchronizedMap<K, V>(map);
     }
@@ -2222,7 +2222,7 @@ public class Collections {
      */
     public static <E> Set<E> synchronizedSet(Set<E> set) {
         if (set == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("set == null");
         }
         return new SynchronizedSet<E>(set);
     }
@@ -2238,7 +2238,7 @@ public class Collections {
     public static <K, V> SortedMap<K, V> synchronizedSortedMap(
             SortedMap<K, V> map) {
         if (map == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("map == null");
         }
         return new SynchronizedSortedMap<K, V>(map);
     }
@@ -2253,7 +2253,7 @@ public class Collections {
      */
     public static <E> SortedSet<E> synchronizedSortedSet(SortedSet<E> set) {
         if (set == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("set == null");
         }
         return new SynchronizedSortedSet<E>(set);
     }
@@ -2271,7 +2271,7 @@ public class Collections {
     public static <E> Collection<E> unmodifiableCollection(
             Collection<? extends E> collection) {
         if (collection == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("collection == null");
         }
         return new UnmodifiableCollection<E>((Collection<E>) collection);
     }
@@ -2288,7 +2288,7 @@ public class Collections {
     @SuppressWarnings("unchecked")
     public static <E> List<E> unmodifiableList(List<? extends E> list) {
         if (list == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("list == null");
         }
         if (list instanceof RandomAccess) {
             return new UnmodifiableRandomAccessList<E>((List<E>) list);
@@ -2309,7 +2309,7 @@ public class Collections {
     public static <K, V> Map<K, V> unmodifiableMap(
             Map<? extends K, ? extends V> map) {
         if (map == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("map == null");
         }
         return new UnmodifiableMap<K, V>((Map<K, V>) map);
     }
@@ -2326,7 +2326,7 @@ public class Collections {
     @SuppressWarnings("unchecked")
     public static <E> Set<E> unmodifiableSet(Set<? extends E> set) {
         if (set == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("set == null");
         }
         return new UnmodifiableSet<E>((Set<E>) set);
     }
@@ -2344,7 +2344,7 @@ public class Collections {
     public static <K, V> SortedMap<K, V> unmodifiableSortedMap(
             SortedMap<K, ? extends V> map) {
         if (map == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("map == null");
         }
         return new UnmodifiableSortedMap<K, V>((SortedMap<K, V>) map);
     }
@@ -2360,7 +2360,7 @@ public class Collections {
      */
     public static <E> SortedSet<E> unmodifiableSortedSet(SortedSet<E> set) {
         if (set == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("set == null");
         }
         return new UnmodifiableSortedSet<E>(set);
     }
@@ -2381,7 +2381,7 @@ public class Collections {
      */
     public static int frequency(Collection<?> c, Object o) {
         if (c == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("c == null");
         }
         if (c.isEmpty()) {
             return 0;
@@ -2834,8 +2834,10 @@ public class Collections {
         Class<E> type;
 
         public CheckedCollection(Collection<E> c, Class<E> type) {
-            if (c == null || type == null) {
-                throw new NullPointerException();
+            if (c == null) {
+                throw new NullPointerException("c == null");
+            } else if (type == null) {
+                throw new NullPointerException("type == null");
             }
             this.c = c;
             this.type = type;
@@ -3079,8 +3081,12 @@ public class Collections {
         Class<V> valueType;
 
         private CheckedMap(Map<K, V> m, Class<K> keyType, Class<V> valueType) {
-            if (m == null || keyType == null || valueType == null) {
-                throw new NullPointerException();
+            if (m == null) {
+                throw new NullPointerException("m == null");
+            } else if (keyType == null) {
+                throw new NullPointerException("keyType == null");
+            } else if (valueType == null) {
+                throw new NullPointerException("valueType == null");
             }
             this.m = m;
             this.keyType = keyType;
@@ -3172,7 +3178,7 @@ public class Collections {
 
             public CheckedEntry(Map.Entry<K, V> e, Class<V> valueType) {
                 if (e == null) {
-                    throw new NullPointerException();
+                    throw new NullPointerException("e == null");
                 }
                 this.e = e;
                 this.valueType = valueType;
diff --git a/luni/src/main/java/java/util/DuplicateFormatFlagsException.java b/luni/src/main/java/java/util/DuplicateFormatFlagsException.java
index d04db8e..2a2bc2e 100644
--- a/luni/src/main/java/java/util/DuplicateFormatFlagsException.java
+++ b/luni/src/main/java/java/util/DuplicateFormatFlagsException.java
@@ -37,7 +37,7 @@ public class DuplicateFormatFlagsException extends IllegalFormatException {
      */
     public DuplicateFormatFlagsException(String f) {
         if (f == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("f == null");
         }
         flags = f;
     }
diff --git a/luni/src/main/java/java/util/EnumMap.java b/luni/src/main/java/java/util/EnumMap.java
index d3d42b4..a721ee3 100644
--- a/luni/src/main/java/java/util/EnumMap.java
+++ b/luni/src/main/java/java/util/EnumMap.java
@@ -773,7 +773,7 @@ public class EnumMap<K extends Enum<K>, V> extends AbstractMap<K, V> implements
     @SuppressWarnings("unchecked")
     private V putImpl(K key, V value) {
         if (key == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("key == null");
         }
         keyType.cast(key); // Called to throw ClassCastException.
         int keyOrdinal = key.ordinal();
diff --git a/luni/src/main/java/java/util/FormatFlagsConversionMismatchException.java b/luni/src/main/java/java/util/FormatFlagsConversionMismatchException.java
index 5792877..5c36788 100644
--- a/luni/src/main/java/java/util/FormatFlagsConversionMismatchException.java
+++ b/luni/src/main/java/java/util/FormatFlagsConversionMismatchException.java
@@ -44,7 +44,7 @@ public class FormatFlagsConversionMismatchException extends
      */
     public FormatFlagsConversionMismatchException(String f, char c) {
         if (f == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("f == null");
         }
         this.f = f;
         this.c = c;
diff --git a/luni/src/main/java/java/util/Formatter.java b/luni/src/main/java/java/util/Formatter.java
index e9a2f4a..021da08 100644
--- a/luni/src/main/java/java/util/Formatter.java
+++ b/luni/src/main/java/java/util/Formatter.java
@@ -884,7 +884,7 @@ public final class Formatter implements Closeable, Flushable {
      */
     public Formatter(PrintStream ps) {
         if (ps == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("ps == null");
         }
         out = ps;
         locale = Locale.getDefault();
diff --git a/luni/src/main/java/java/util/Hashtable.java b/luni/src/main/java/java/util/Hashtable.java
index 4ea26fb..a4e24bc 100644
--- a/luni/src/main/java/java/util/Hashtable.java
+++ b/luni/src/main/java/java/util/Hashtable.java
@@ -313,7 +313,7 @@ public class Hashtable<K, V> extends Dictionary<K, V>
      */
     public synchronized boolean containsValue(Object value) {
         if (value == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("value == null");
         }
 
         HashtableEntry[] tab = table;
@@ -361,8 +361,10 @@ public class Hashtable<K, V> extends Dictionary<K, V>
      * @see java.lang.Object#equals
      */
     public synchronized V put(K key, V value) {
-        if (key == null || value == null) {
-            throw new NullPointerException("key=" + key + " value=" + value);
+        if (key == null) {
+            throw new NullPointerException("key == null");
+        } else if (value == null) {
+            throw new NullPointerException("value == null");
         }
         int hash = secondaryHash(key.hashCode());
         HashtableEntry<K, V>[] tab = table;
@@ -395,8 +397,10 @@ public class Hashtable<K, V> extends Dictionary<K, V>
      * ensure that capacity is sufficient, and does not increment modCount.
      */
     private void constructorPut(K key, V value) {
-        if (key == null || value == null) {
-            throw new NullPointerException("key=" + key + " value=" + value);
+        if (key == null) {
+            throw new NullPointerException("key == null");
+        } else if (value == null) {
+            throw new NullPointerException("value == null");
         }
         int hash = secondaryHash(key.hashCode());
         HashtableEntry<K, V>[] tab = table;
@@ -680,7 +684,7 @@ public class Hashtable<K, V> extends Dictionary<K, V>
 
         public final V setValue(V value) {
             if (value == null) {
-                throw new NullPointerException("key=" + key + " value=" + value);
+                throw new NullPointerException("value == null");
             }
             V oldValue = this.value;
             this.value = value;
diff --git a/luni/src/main/java/java/util/IllegalFormatConversionException.java b/luni/src/main/java/java/util/IllegalFormatConversionException.java
index 31c0eed..af986f6 100644
--- a/luni/src/main/java/java/util/IllegalFormatConversionException.java
+++ b/luni/src/main/java/java/util/IllegalFormatConversionException.java
@@ -46,7 +46,7 @@ public class IllegalFormatConversionException extends IllegalFormatException
     public IllegalFormatConversionException(char c, Class<?> arg) {
         this.c = c;
         if (arg == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("arg == null");
         }
         this.arg = arg;
     }
diff --git a/luni/src/main/java/java/util/IllegalFormatFlagsException.java b/luni/src/main/java/java/util/IllegalFormatFlagsException.java
index 6947912..4946c55 100644
--- a/luni/src/main/java/java/util/IllegalFormatFlagsException.java
+++ b/luni/src/main/java/java/util/IllegalFormatFlagsException.java
@@ -38,7 +38,7 @@ public class IllegalFormatFlagsException extends IllegalFormatException implemen
      */
     public IllegalFormatFlagsException(String flags) {
         if (flags == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("flags == null");
         }
         this.flags = flags;
     }
diff --git a/luni/src/main/java/java/util/ListResourceBundle.java b/luni/src/main/java/java/util/ListResourceBundle.java
index 1508b93..fc6ab97 100644
--- a/luni/src/main/java/java/util/ListResourceBundle.java
+++ b/luni/src/main/java/java/util/ListResourceBundle.java
@@ -108,7 +108,7 @@ public abstract class ListResourceBundle extends ResourceBundle {
     public final Object handleGetObject(String key) {
         initializeTable();
         if (key == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("key == null");
         }
         return table.get(key);
     }
diff --git a/luni/src/main/java/java/util/MissingFormatArgumentException.java b/luni/src/main/java/java/util/MissingFormatArgumentException.java
index ce72efa..1733501 100644
--- a/luni/src/main/java/java/util/MissingFormatArgumentException.java
+++ b/luni/src/main/java/java/util/MissingFormatArgumentException.java
@@ -37,7 +37,7 @@ public class MissingFormatArgumentException extends IllegalFormatException {
      */
     public MissingFormatArgumentException(String s) {
         if (s == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("s == null");
         }
         this.s = s;
     }
diff --git a/luni/src/main/java/java/util/MissingFormatWidthException.java b/luni/src/main/java/java/util/MissingFormatWidthException.java
index b6d0ca6..0a3b5ae 100644
--- a/luni/src/main/java/java/util/MissingFormatWidthException.java
+++ b/luni/src/main/java/java/util/MissingFormatWidthException.java
@@ -36,7 +36,7 @@ public class MissingFormatWidthException extends IllegalFormatException {
      */
     public MissingFormatWidthException(String s) {
         if (s == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("s == null");
         }
         this.s = s;
     }
diff --git a/luni/src/main/java/java/util/Observable.java b/luni/src/main/java/java/util/Observable.java
index 2c2877e..c984c68 100644
--- a/luni/src/main/java/java/util/Observable.java
+++ b/luni/src/main/java/java/util/Observable.java
@@ -49,7 +49,7 @@ public class Observable {
      */
     public void addObserver(Observer observer) {
         if (observer == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("observer == null");
         }
         synchronized (this) {
             if (!observers.contains(observer))
diff --git a/luni/src/main/java/java/util/PriorityQueue.java b/luni/src/main/java/java/util/PriorityQueue.java
index 10c5968..e09eb05 100644
--- a/luni/src/main/java/java/util/PriorityQueue.java
+++ b/luni/src/main/java/java/util/PriorityQueue.java
@@ -186,7 +186,7 @@ public class PriorityQueue<E> extends AbstractQueue<E> implements Serializable {
      */
     public boolean offer(E o) {
         if (o == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("o == null");
         }
         growToSize(size + 1);
         elements[size] = o;
@@ -387,7 +387,7 @@ public class PriorityQueue<E> extends AbstractQueue<E> implements Serializable {
 
     private void initSize(Collection<? extends E> c) {
         if (c == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("c == null");
         }
         if (c.isEmpty()) {
             elements = newElementArray(1);
diff --git a/luni/src/main/java/java/util/Properties.java b/luni/src/main/java/java/util/Properties.java
index 1731ad8..57c6a00 100644
--- a/luni/src/main/java/java/util/Properties.java
+++ b/luni/src/main/java/java/util/Properties.java
@@ -243,7 +243,7 @@ public class Properties extends Hashtable<Object, Object> {
      */
     public synchronized void load(InputStream in) throws IOException {
         if (in == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("in == null");
         }
         load(new InputStreamReader(in, "ISO-8859-1"));
     }
@@ -276,7 +276,7 @@ public class Properties extends Hashtable<Object, Object> {
     @SuppressWarnings("fallthrough")
     public synchronized void load(Reader in) throws IOException {
         if (in == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("in == null");
         }
         int mode = NONE, unicode = 0, count = 0;
         char nextChar, buf[] = new char[40];
@@ -578,7 +578,7 @@ public class Properties extends Hashtable<Object, Object> {
     public synchronized void loadFromXML(InputStream in) throws IOException,
             InvalidPropertiesFormatException {
         if (in == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("in == null");
         }
 
         if (builder == null) {
@@ -690,8 +690,10 @@ public class Properties extends Hashtable<Object, Object> {
     public synchronized void storeToXML(OutputStream os, String comment,
             String encoding) throws IOException {
 
-        if (os == null || encoding == null) {
-            throw new NullPointerException();
+        if (os == null) {
+            throw new NullPointerException("os == null");
+        } else if (encoding == null) {
+            throw new NullPointerException("encoding == null");
         }
 
         /*
diff --git a/luni/src/main/java/java/util/PropertyResourceBundle.java b/luni/src/main/java/java/util/PropertyResourceBundle.java
index 4029ee1..dbbd139 100644
--- a/luni/src/main/java/java/util/PropertyResourceBundle.java
+++ b/luni/src/main/java/java/util/PropertyResourceBundle.java
@@ -46,7 +46,7 @@ public class PropertyResourceBundle extends ResourceBundle {
      */
     public PropertyResourceBundle(InputStream stream) throws IOException {
         if (stream == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("stream == null");
         }
         resources = new Properties();
         resources.load(stream);
diff --git a/luni/src/main/java/java/util/ResourceBundle.java b/luni/src/main/java/java/util/ResourceBundle.java
index ff38b5b..f5c8285 100644
--- a/luni/src/main/java/java/util/ResourceBundle.java
+++ b/luni/src/main/java/java/util/ResourceBundle.java
@@ -211,8 +211,10 @@ public abstract class ResourceBundle {
      */
     public static ResourceBundle getBundle(String bundleName, Locale locale,
             ClassLoader loader) throws MissingResourceException {
-        if (loader == null || bundleName == null) {
-            throw new NullPointerException();
+        if (loader == null) {
+            throw new NullPointerException("loader == null");
+        } else if (bundleName == null) {
+            throw new NullPointerException("bundleName == null");
         }
         Locale defaultLocale = Locale.getDefault();
         if (!cacheLocale.equals(defaultLocale)) {
@@ -610,14 +612,14 @@ public abstract class ResourceBundle {
 
     public static void clearCache(ClassLoader loader) {
         if (loader == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("loader == null");
         }
         cache.remove(loader);
     }
 
     public boolean containsKey(String key) {
         if (key == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("key == null");
         }
         return keySet().contains(key);
     }
@@ -665,8 +667,10 @@ public abstract class ResourceBundle {
 
         @Override
         public Locale getFallbackLocale(String baseName, Locale locale) {
-            if (baseName == null || locale == null) {
-                throw new NullPointerException();
+            if (baseName == null) {
+                throw new NullPointerException("baseName == null");
+            } else if (locale == null) {
+                throw new NullPointerException("locale == null");
             }
             return null;
         }
@@ -804,8 +808,10 @@ public abstract class ResourceBundle {
          * {@code locale}.
          */
         public List<Locale> getCandidateLocales(String baseName, Locale locale) {
-            if (baseName == null || locale == null) {
-                throw new NullPointerException();
+            if (baseName == null) {
+                throw new NullPointerException("baseName == null");
+            } else if (locale == null) {
+                throw new NullPointerException("locale == null");
             }
             List<Locale> retList = new ArrayList<Locale>();
             String language = locale.getLanguage();
@@ -829,7 +835,7 @@ public abstract class ResourceBundle {
          */
         public List<String> getFormats(String baseName) {
             if (baseName == null) {
-                throw new NullPointerException();
+                throw new NullPointerException("baseName == null");
             }
             return format;
         }
@@ -838,8 +844,10 @@ public abstract class ResourceBundle {
          * Returns the fallback locale for {@code baseName} in {@code locale}.
          */
         public Locale getFallbackLocale(String baseName, Locale locale) {
-            if (baseName == null || locale == null) {
-                throw new NullPointerException();
+            if (baseName == null) {
+                throw new NullPointerException("baseName == null");
+            } else if (locale == null) {
+                throw new NullPointerException("locale == null");
             }
             if (Locale.getDefault() != locale) {
                 return Locale.getDefault();
@@ -872,8 +880,10 @@ public abstract class ResourceBundle {
                 String format, ClassLoader loader, boolean reload)
                 throws IllegalAccessException, InstantiationException,
                 IOException {
-            if (format == null || loader == null) {
-                throw new NullPointerException();
+            if (format == null) {
+                throw new NullPointerException("format == null");
+            } else if (loader == null) {
+                throw new NullPointerException("loader == null");
             }
             final String bundleName = toBundleName(baseName, locale);
             final ClassLoader clsloader = loader;
@@ -938,8 +948,10 @@ public abstract class ResourceBundle {
          * default is TTL_NO_EXPIRATION_CONTROL.
          */
         public long getTimeToLive(String baseName, Locale locale) {
-            if (baseName == null || locale == null) {
-                throw new NullPointerException();
+            if (baseName == null) {
+                throw new NullPointerException("baseName == null");
+            } else if (locale == null) {
+                throw new NullPointerException("locale == null");
             }
             return TTL_NO_EXPIRATION_CONTROL;
         }
@@ -966,7 +978,7 @@ public abstract class ResourceBundle {
                 long loadTime) {
             if (bundle == null) {
                 // FIXME what's the use of bundle?
-                throw new NullPointerException();
+                throw new NullPointerException("bundle == null");
             }
             String bundleName = toBundleName(baseName, locale);
             String suffix = format;
@@ -1004,7 +1016,7 @@ public abstract class ResourceBundle {
             final String preString = UNDER_SCORE;
             final String underline = UNDER_SCORE;
             if (baseName == null) {
-                throw new NullPointerException();
+                throw new NullPointerException("baseName == null");
             }
             StringBuilder ret = new StringBuilder();
             StringBuilder prefix = new StringBuilder();
@@ -1044,7 +1056,7 @@ public abstract class ResourceBundle {
          */
         public final String toResourceName(String bundleName, String suffix) {
             if (suffix == null) {
-                throw new NullPointerException();
+                throw new NullPointerException("suffix == null");
             }
             StringBuilder ret = new StringBuilder(bundleName.replace('.', '/'));
             ret.append('.');
diff --git a/luni/src/main/java/java/util/Scanner.java b/luni/src/main/java/java/util/Scanner.java
index 8f889b3..5f7d0e3 100644
--- a/luni/src/main/java/java/util/Scanner.java
+++ b/luni/src/main/java/java/util/Scanner.java
@@ -241,7 +241,7 @@ public final class Scanner implements Iterator<String> {
      */
     public Scanner(Readable src) {
         if (src == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("src == null");
         }
         input = src;
         initialization();
@@ -1664,7 +1664,7 @@ public final class Scanner implements Iterator<String> {
      */
     public Scanner useLocale(Locale l) {
         if (l == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("l == null");
         }
         this.locale = l;
         return this;
@@ -1724,7 +1724,7 @@ public final class Scanner implements Iterator<String> {
      */
     private void checkNull(Pattern pattern) {
         if (pattern == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("pattern == null");
         }
     }
 
diff --git a/luni/src/main/java/java/util/ServiceLoader.java b/luni/src/main/java/java/util/ServiceLoader.java
index beacaab..016ab3f 100644
--- a/luni/src/main/java/java/util/ServiceLoader.java
+++ b/luni/src/main/java/java/util/ServiceLoader.java
@@ -78,7 +78,7 @@ public final class ServiceLoader<S> implements Iterable<S> {
         // It makes no sense for service to be null.
         // classLoader is null if you want the system class loader.
         if (service == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("service == null");
         }
         this.service = service;
         this.classLoader = classLoader;
diff --git a/luni/src/main/java/java/util/StringTokenizer.java b/luni/src/main/java/java/util/StringTokenizer.java
index 1b07604..e6686e8 100644
--- a/luni/src/main/java/java/util/StringTokenizer.java
+++ b/luni/src/main/java/java/util/StringTokenizer.java
@@ -91,13 +91,13 @@ public class StringTokenizer implements Enumeration<Object> {
      */
     public StringTokenizer(String string, String delimiters,
             boolean returnDelimiters) {
-        if (string != null) {
-            this.string = string;
-            this.delimiters = delimiters;
-            this.returnDelimiters = returnDelimiters;
-            this.position = 0;
-        } else
-            throw new NullPointerException();
+        if (string == null) {
+            throw new NullPointerException("string == null");
+        }
+        this.string = string;
+        this.delimiters = delimiters;
+        this.returnDelimiters = returnDelimiters;
+        this.position = 0;
     }
 
     /**
@@ -143,7 +143,7 @@ public class StringTokenizer implements Enumeration<Object> {
      */
     public boolean hasMoreTokens() {
         if (delimiters == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("delimiters == null");
         }
         int length = string.length();
         if (position < length) {
@@ -180,7 +180,7 @@ public class StringTokenizer implements Enumeration<Object> {
      */
     public String nextToken() {
         if (delimiters == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("delimiters == null");
         }
         int i = position;
         int length = string.length();
diff --git a/luni/src/main/java/java/util/TimeZone.java b/luni/src/main/java/java/util/TimeZone.java
index b7d7da1..85011bc 100644
--- a/luni/src/main/java/java/util/TimeZone.java
+++ b/luni/src/main/java/java/util/TimeZone.java
@@ -405,7 +405,7 @@ public abstract class TimeZone implements Serializable, Cloneable {
      */
     public void setID(String id) {
         if (id == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("id == null");
         }
         ID = id;
     }
diff --git a/luni/src/main/java/java/util/Timer.java b/luni/src/main/java/java/util/Timer.java
index b4f7a83..afc745c 100644
--- a/luni/src/main/java/java/util/Timer.java
+++ b/luni/src/main/java/java/util/Timer.java
@@ -362,7 +362,7 @@ public class Timer {
      */
     public Timer(String name, boolean isDaemon) {
         if (name == null) {
-            throw new NullPointerException("name is null");
+            throw new NullPointerException("name == null");
         }
         this.impl = new TimerImpl(name, isDaemon);
         this.finalizer = new FinalizerHelper(impl);
diff --git a/luni/src/main/java/java/util/UUID.java b/luni/src/main/java/java/util/UUID.java
index a932bb2..8ac0a63 100644
--- a/luni/src/main/java/java/util/UUID.java
+++ b/luni/src/main/java/java/util/UUID.java
@@ -142,7 +142,7 @@ public final class UUID implements Serializable, Comparable<UUID> {
      */
     public static UUID nameUUIDFromBytes(byte[] name) {
         if (name == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("name == null");
         }
         try {
             MessageDigest md = MessageDigest.getInstance("MD5");
@@ -179,7 +179,7 @@ public final class UUID implements Serializable, Comparable<UUID> {
      */
     public static UUID fromString(String uuid) {
         if (uuid == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("uuid == null");
         }
 
         int[] position = new int[5];
diff --git a/luni/src/main/java/java/util/UnknownFormatConversionException.java b/luni/src/main/java/java/util/UnknownFormatConversionException.java
index e26de91..29af4e1 100644
--- a/luni/src/main/java/java/util/UnknownFormatConversionException.java
+++ b/luni/src/main/java/java/util/UnknownFormatConversionException.java
@@ -35,7 +35,7 @@ public class UnknownFormatConversionException extends IllegalFormatException {
      */
     public UnknownFormatConversionException(String s) {
         if (s == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("s == null");
         }
         this.s = s;
     }
diff --git a/luni/src/main/java/java/util/UnknownFormatFlagsException.java b/luni/src/main/java/java/util/UnknownFormatFlagsException.java
index 9daa3f1..990432b 100644
--- a/luni/src/main/java/java/util/UnknownFormatFlagsException.java
+++ b/luni/src/main/java/java/util/UnknownFormatFlagsException.java
@@ -37,7 +37,7 @@ public class UnknownFormatFlagsException extends IllegalFormatException {
      */
     public UnknownFormatFlagsException(String f) {
         if (f == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("f == null");
         }
         flags = f;
     }
diff --git a/luni/src/main/java/java/util/jar/JarOutputStream.java b/luni/src/main/java/java/util/jar/JarOutputStream.java
index 78e3aa5..fc0645e 100644
--- a/luni/src/main/java/java/util/jar/JarOutputStream.java
+++ b/luni/src/main/java/java/util/jar/JarOutputStream.java
@@ -37,20 +37,20 @@ public class JarOutputStream extends ZipOutputStream {
      *
      * @param os
      *            the {@code OutputStream} to write to
-     * @param mf
+     * @param manifest
      *            the {@code Manifest} to output for this JAR file.
      * @throws IOException
      *             if an error occurs creating the {@code JarOutputStream}.
      */
-    public JarOutputStream(OutputStream os, Manifest mf) throws IOException {
+    public JarOutputStream(OutputStream os, Manifest manifest) throws IOException {
         super(os);
-        if (mf == null) {
-            throw new NullPointerException();
+        if (manifest == null) {
+            throw new NullPointerException("manifest == null");
         }
-        manifest = mf;
+        this.manifest = manifest;
         ZipEntry ze = new ZipEntry(JarFile.MANIFEST_NAME);
         putNextEntry(ze);
-        manifest.write(this);
+        this.manifest.write(this);
         closeEntry();
     }
 
diff --git a/luni/src/main/java/java/util/logging/FileHandler.java b/luni/src/main/java/java/util/logging/FileHandler.java
index 980955a..6ffef87 100644
--- a/luni/src/main/java/java/util/logging/FileHandler.java
+++ b/luni/src/main/java/java/util/logging/FileHandler.java
@@ -214,8 +214,10 @@ public class FileHandler extends StreamHandler {
         String className = this.getClass().getName();
         pattern = (p == null) ? getStringProperty(className + ".pattern",
                 DEFAULT_PATTERN) : p;
-        if (pattern == null || pattern.isEmpty()) {
-            throw new NullPointerException("Pattern cannot be empty or null");
+        if (pattern == null) {
+            throw new NullPointerException("pattern == null");
+        } else if (pattern.isEmpty()) {
+            throw new NullPointerException("pattern.isEmpty()");
         }
         append = (a == null) ? getBooleanProperty(className + ".append",
                 DEFAULT_APPEND) : a.booleanValue();
diff --git a/luni/src/main/java/java/util/logging/Handler.java b/luni/src/main/java/java/util/logging/Handler.java
index 5a6c14e..13dbdd5 100644
--- a/luni/src/main/java/java/util/logging/Handler.java
+++ b/luni/src/main/java/java/util/logging/Handler.java
@@ -227,7 +227,7 @@ public abstract class Handler {
      */
     public boolean isLoggable(LogRecord record) {
         if (record == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("record == null");
         }
         if (this.level.intValue() == Level.OFF.intValue()) {
             return false;
@@ -294,17 +294,17 @@ public abstract class Handler {
     /**
      * Sets the error manager for this handler.
      *
-     * @param em
+     * @param newErrorManager
      *            the error manager to set.
      * @throws NullPointerException
      *             if {@code em} is {@code null}.
      */
-    public void setErrorManager(ErrorManager em) {
+    public void setErrorManager(ErrorManager newErrorManager) {
         LogManager.getLogManager().checkAccess();
-        if (em == null) {
-            throw new NullPointerException();
+        if (newErrorManager == null) {
+            throw new NullPointerException("newErrorManager == null");
         }
-        this.errorMan = em;
+        this.errorMan = newErrorManager;
     }
 
     /**
@@ -327,7 +327,7 @@ public abstract class Handler {
      */
     void internalSetFormatter(Formatter newFormatter) {
         if (newFormatter == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("newFormatter == null");
         }
         this.formatter = newFormatter;
     }
@@ -356,7 +356,7 @@ public abstract class Handler {
      */
     public void setLevel(Level newLevel) {
         if (newLevel == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("newLevel == null");
         }
         LogManager.getLogManager().checkAccess();
         this.level = newLevel;
diff --git a/luni/src/main/java/java/util/logging/LogManager.java b/luni/src/main/java/java/util/logging/LogManager.java
index 449c263..8877cd5 100644
--- a/luni/src/main/java/java/util/logging/LogManager.java
+++ b/luni/src/main/java/java/util/logging/LogManager.java
@@ -446,7 +446,7 @@ public class LogManager {
      */
     public void addPropertyChangeListener(PropertyChangeListener l) {
         if (l == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("l == null");
         }
         checkAccess();
         listeners.addPropertyChangeListener(l);
diff --git a/luni/src/main/java/java/util/logging/StreamHandler.java b/luni/src/main/java/java/util/logging/StreamHandler.java
index 7581835..60b4321 100644
--- a/luni/src/main/java/java/util/logging/StreamHandler.java
+++ b/luni/src/main/java/java/util/logging/StreamHandler.java
@@ -167,7 +167,7 @@ public class StreamHandler extends Handler {
      */
     protected void setOutputStream(OutputStream os) {
         if (os == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("os == null");
         }
         LogManager.getLogManager().checkAccess();
         close(true);
diff --git a/luni/src/main/java/java/util/prefs/AbstractPreferences.java b/luni/src/main/java/java/util/prefs/AbstractPreferences.java
index d86d789..71110c3 100644
--- a/luni/src/main/java/java/util/prefs/AbstractPreferences.java
+++ b/luni/src/main/java/java/util/prefs/AbstractPreferences.java
@@ -372,7 +372,7 @@ public abstract class AbstractPreferences extends Preferences {
     @Override
     public void exportNode(OutputStream ostream) throws IOException, BackingStoreException {
         if (ostream == null) {
-            throw new NullPointerException("Stream is null");
+            throw new NullPointerException("ostream == null");
         }
         checkState();
         XMLParser.exportPrefs(this, ostream, false);
@@ -381,7 +381,7 @@ public abstract class AbstractPreferences extends Preferences {
     @Override
     public void exportSubtree(OutputStream ostream) throws IOException, BackingStoreException {
         if (ostream == null) {
-            throw new NullPointerException("Stream is null");
+            throw new NullPointerException("ostream == null");
         }
         checkState();
         XMLParser.exportPrefs(this, ostream, true);
@@ -402,7 +402,7 @@ public abstract class AbstractPreferences extends Preferences {
     @Override
     public String get(String key, String deflt) {
         if (key == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("key == null");
         }
         String result = null;
         synchronized (lock) {
@@ -597,7 +597,7 @@ public abstract class AbstractPreferences extends Preferences {
     @Override
     public boolean nodeExists(String name) throws BackingStoreException {
         if (name == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("name == null");
         }
         AbstractPreferences startNode = null;
         synchronized (lock) {
@@ -640,8 +640,10 @@ public abstract class AbstractPreferences extends Preferences {
 
     @Override
     public void put(String key, String value) {
-        if (key == null || value == null) {
-            throw new NullPointerException();
+        if (key == null) {
+            throw new NullPointerException("key == null");
+        } else if (value == null) {
+            throw new NullPointerException("value == null");
         }
         if (key.length() > MAX_KEY_LENGTH || value.length() > MAX_VALUE_LENGTH) {
             throw new IllegalArgumentException();
@@ -730,7 +732,7 @@ public abstract class AbstractPreferences extends Preferences {
     @Override
     public void addNodeChangeListener(NodeChangeListener ncl) {
         if (ncl == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("ncl == null");
         }
         checkState();
         synchronized (nodeChangeListeners) {
@@ -741,7 +743,7 @@ public abstract class AbstractPreferences extends Preferences {
     @Override
     public void addPreferenceChangeListener(PreferenceChangeListener pcl) {
         if (pcl == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("pcl == null");
         }
         checkState();
         synchronized (preferenceChangeListeners) {
diff --git a/luni/src/main/java/java/util/zip/DeflaterInputStream.java b/luni/src/main/java/java/util/zip/DeflaterInputStream.java
index c6e95f2..805ce17 100644
--- a/luni/src/main/java/java/util/zip/DeflaterInputStream.java
+++ b/luni/src/main/java/java/util/zip/DeflaterInputStream.java
@@ -72,8 +72,10 @@ public class DeflaterInputStream extends FilterInputStream {
      */
     public DeflaterInputStream(InputStream in, Deflater deflater, int bufferSize) {
         super(in);
-        if (in == null || deflater == null) {
-            throw new NullPointerException();
+        if (in == null) {
+            throw new NullPointerException("in == null");
+        } else if (deflater == null) {
+            throw new NullPointerException("deflater == null");
         }
         if (bufferSize <= 0) {
             throw new IllegalArgumentException();
diff --git a/luni/src/main/java/java/util/zip/DeflaterOutputStream.java b/luni/src/main/java/java/util/zip/DeflaterOutputStream.java
index b0bcb99..d336e72 100644
--- a/luni/src/main/java/java/util/zip/DeflaterOutputStream.java
+++ b/luni/src/main/java/java/util/zip/DeflaterOutputStream.java
@@ -115,8 +115,10 @@ public class DeflaterOutputStream extends FilterOutputStream {
      */
     public DeflaterOutputStream(OutputStream os, Deflater def, int bsize, boolean syncFlush) {
         super(os);
-        if (os == null || def == null) {
-            throw new NullPointerException();
+        if (os == null) {
+            throw new NullPointerException("os == null");
+        } else if (def == null) {
+            throw new NullPointerException("def == null");
         }
         if (bsize <= 0) {
             throw new IllegalArgumentException();
diff --git a/luni/src/main/java/java/util/zip/InflaterInputStream.java b/luni/src/main/java/java/util/zip/InflaterInputStream.java
index 580d605..6081037 100644
--- a/luni/src/main/java/java/util/zip/InflaterInputStream.java
+++ b/luni/src/main/java/java/util/zip/InflaterInputStream.java
@@ -103,8 +103,10 @@ public class InflaterInputStream extends FilterInputStream {
      */
     public InflaterInputStream(InputStream is, Inflater inflater, int bsize) {
         super(is);
-        if (is == null || inflater == null) {
-            throw new NullPointerException();
+        if (is == null) {
+            throw new NullPointerException("is == null");
+        } else if (inflater == null) {
+            throw new NullPointerException("inflater == null");
         }
         if (bsize <= 0) {
             throw new IllegalArgumentException();
diff --git a/luni/src/main/java/java/util/zip/InflaterOutputStream.java b/luni/src/main/java/java/util/zip/InflaterOutputStream.java
index c9687b6..9a699a8 100644
--- a/luni/src/main/java/java/util/zip/InflaterOutputStream.java
+++ b/luni/src/main/java/java/util/zip/InflaterOutputStream.java
@@ -70,8 +70,10 @@ public class InflaterOutputStream extends FilterOutputStream {
      */
     public InflaterOutputStream(OutputStream out, Inflater inf, int bufferSize) {
         super(out);
-        if (out == null || inf == null) {
-            throw new NullPointerException();
+        if (out == null) {
+            throw new NullPointerException("out == null");
+        } else if (inf == null) {
+            throw new NullPointerException("inf == null");
         }
         if (bufferSize <= 0) {
             throw new IllegalArgumentException();
diff --git a/luni/src/main/java/java/util/zip/ZipEntry.java b/luni/src/main/java/java/util/zip/ZipEntry.java
index 988bd2c..e2bfc8d 100644
--- a/luni/src/main/java/java/util/zip/ZipEntry.java
+++ b/luni/src/main/java/java/util/zip/ZipEntry.java
@@ -71,7 +71,7 @@ public class ZipEntry implements ZipConstants, Cloneable {
      */
     public ZipEntry(String name) {
         if (name == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("name == null");
         }
         if (name.length() > 0xFFFF) {
             throw new IllegalArgumentException("Name too long: " + name.length());
diff --git a/luni/src/main/java/java/util/zip/ZipFile.java b/luni/src/main/java/java/util/zip/ZipFile.java
index 363f57e..6ecd489 100644
--- a/luni/src/main/java/java/util/zip/ZipFile.java
+++ b/luni/src/main/java/java/util/zip/ZipFile.java
@@ -223,7 +223,7 @@ public class ZipFile implements ZipConstants {
     public ZipEntry getEntry(String entryName) {
         checkNotClosed();
         if (entryName == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("entryName == null");
         }
 
         ZipEntry ze = mEntries.get(entryName);
diff --git a/luni/src/main/java/java/util/zip/ZipInputStream.java b/luni/src/main/java/java/util/zip/ZipInputStream.java
index d082fc7..e7c4566 100644
--- a/luni/src/main/java/java/util/zip/ZipInputStream.java
+++ b/luni/src/main/java/java/util/zip/ZipInputStream.java
@@ -101,7 +101,7 @@ public class ZipInputStream extends InflaterInputStream implements ZipConstants
     public ZipInputStream(InputStream stream) {
         super(new PushbackInputStream(stream, BUF_SIZE), new Inflater(true));
         if (stream == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("stream == null");
         }
     }
 
diff --git a/luni/src/main/java/javax/crypto/Cipher.java b/luni/src/main/java/javax/crypto/Cipher.java
index 1dacd46..aeb5def 100644
--- a/luni/src/main/java/javax/crypto/Cipher.java
+++ b/luni/src/main/java/javax/crypto/Cipher.java
@@ -141,10 +141,10 @@ public class Cipher {
     protected Cipher(CipherSpi cipherSpi, Provider provider,
             String transformation) {
         if (cipherSpi == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("cipherSpi == null");
         }
         if (!(cipherSpi instanceof NullCipherSpi) && provider == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("provider == null");
         }
         this.provider = provider;
         this.transformation = transformation;
@@ -1332,7 +1332,7 @@ public class Cipher {
     public static final int getMaxAllowedKeyLength(String transformation)
             throws NoSuchAlgorithmException {
         if (transformation == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("transformation == null");
         }
         checkTransformation(transformation);
         //FIXME jurisdiction policy files
@@ -1356,7 +1356,7 @@ public class Cipher {
     public static final AlgorithmParameterSpec getMaxAllowedParameterSpec(
             String transformation) throws NoSuchAlgorithmException {
         if (transformation == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("transformation == null");
         }
         checkTransformation(transformation);
         //FIXME jurisdiction policy files
diff --git a/luni/src/main/java/javax/crypto/CipherInputStream.java b/luni/src/main/java/javax/crypto/CipherInputStream.java
index 39dcfda..a59a425 100644
--- a/luni/src/main/java/javax/crypto/CipherInputStream.java
+++ b/luni/src/main/java/javax/crypto/CipherInputStream.java
@@ -135,7 +135,7 @@ public class CipherInputStream extends FilterInputStream {
     @Override
     public int read(byte[] buf, int off, int len) throws IOException {
         if (in == null) {
-            throw new NullPointerException("Underlying input stream is null");
+            throw new NullPointerException("in == null");
         }
 
         int i;
diff --git a/luni/src/main/java/javax/crypto/EncryptedPrivateKeyInfo.java b/luni/src/main/java/javax/crypto/EncryptedPrivateKeyInfo.java
index 034f07a..0fb5b76 100644
--- a/luni/src/main/java/javax/crypto/EncryptedPrivateKeyInfo.java
+++ b/luni/src/main/java/javax/crypto/EncryptedPrivateKeyInfo.java
@@ -121,7 +121,7 @@ public class EncryptedPrivateKeyInfo {
      * Creates an {@code EncryptedPrivateKeyInfo} instance from an algorithm
      * name and its encrypted data.
      *
-     * @param encrAlgName
+     * @param encryptionAlgorithmName
      *            the name of an algorithm.
      * @param encryptedData
      *            the encrypted data.
@@ -133,12 +133,12 @@ public class EncryptedPrivateKeyInfo {
      * @throws IllegalArgumentException
      *             if {@code encryptedData} is empty.
      */
-    public EncryptedPrivateKeyInfo(String encrAlgName, byte[] encryptedData)
+    public EncryptedPrivateKeyInfo(String encryptionAlgorithmName, byte[] encryptedData)
         throws NoSuchAlgorithmException {
-        if (encrAlgName == null) {
-            throw new NullPointerException("the algName parameter is null");
+        if (encryptionAlgorithmName == null) {
+            throw new NullPointerException("encryptionAlgorithmName == null");
         }
-        this.algName = encrAlgName;
+        this.algName = encryptionAlgorithmName;
         if (!mapAlgName()) {
             throw new NoSuchAlgorithmException("Unsupported algorithm: " + this.algName);
         }
diff --git a/luni/src/main/java/javax/crypto/ExemptionMechanism.java b/luni/src/main/java/javax/crypto/ExemptionMechanism.java
index 2ac4994..8745b78 100644
--- a/luni/src/main/java/javax/crypto/ExemptionMechanism.java
+++ b/luni/src/main/java/javax/crypto/ExemptionMechanism.java
@@ -98,7 +98,7 @@ public class ExemptionMechanism {
     public static final ExemptionMechanism getInstance(String algorithm)
             throws NoSuchAlgorithmException {
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Engine.SpiAndProvider sap = ENGINE.getInstance(algorithm, null);
         return new ExemptionMechanism((ExemptionMechanismSpi) sap.spi, sap.provider, algorithm);
@@ -134,7 +134,7 @@ public class ExemptionMechanism {
             throw new NoSuchProviderException(provider);
         }
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         return getInstance(algorithm, impProvider);
     }
@@ -159,7 +159,7 @@ public class ExemptionMechanism {
     public static final ExemptionMechanism getInstance(String algorithm,
             Provider provider) throws NoSuchAlgorithmException {
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         if (provider == null) {
             throw new IllegalArgumentException("provider == null");
diff --git a/luni/src/main/java/javax/crypto/KeyAgreement.java b/luni/src/main/java/javax/crypto/KeyAgreement.java
index 9c5d86c..51b4cd1 100644
--- a/luni/src/main/java/javax/crypto/KeyAgreement.java
+++ b/luni/src/main/java/javax/crypto/KeyAgreement.java
@@ -99,7 +99,7 @@ public class KeyAgreement {
     public static final KeyAgreement getInstance(String algorithm)
             throws NoSuchAlgorithmException {
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Engine.SpiAndProvider sap = ENGINE.getInstance(algorithm, null);
         return new KeyAgreement((KeyAgreementSpi) sap.spi, sap.provider, algorithm);
@@ -161,7 +161,7 @@ public class KeyAgreement {
             throw new IllegalArgumentException("provider == null");
         }
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Object spi = ENGINE.getInstance(algorithm, provider, null);
         return new KeyAgreement((KeyAgreementSpi) spi, provider, algorithm);
diff --git a/luni/src/main/java/javax/crypto/KeyGenerator.java b/luni/src/main/java/javax/crypto/KeyGenerator.java
index 77b1a82..606998a 100644
--- a/luni/src/main/java/javax/crypto/KeyGenerator.java
+++ b/luni/src/main/java/javax/crypto/KeyGenerator.java
@@ -98,7 +98,7 @@ public class KeyGenerator {
     public static final KeyGenerator getInstance(String algorithm)
             throws NoSuchAlgorithmException {
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Engine.SpiAndProvider sap = ENGINE.getInstance(algorithm, null);
         return new KeyGenerator((KeyGeneratorSpi) sap.spi, sap.provider, algorithm);
@@ -158,7 +158,7 @@ public class KeyGenerator {
             throw new IllegalArgumentException("provider == null");
         }
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Object spi = ENGINE.getInstance(algorithm, provider, null);
         return new KeyGenerator((KeyGeneratorSpi) spi, provider, algorithm);
diff --git a/luni/src/main/java/javax/crypto/Mac.java b/luni/src/main/java/javax/crypto/Mac.java
index 1a05b59..46be141 100644
--- a/luni/src/main/java/javax/crypto/Mac.java
+++ b/luni/src/main/java/javax/crypto/Mac.java
@@ -101,7 +101,7 @@ public class Mac implements Cloneable {
     public static final Mac getInstance(String algorithm)
             throws NoSuchAlgorithmException {
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Engine.SpiAndProvider sap = ENGINE.getInstance(algorithm, null);
         return new Mac((MacSpi) sap.spi, sap.provider, algorithm);
@@ -163,7 +163,7 @@ public class Mac implements Cloneable {
             throw new IllegalArgumentException("provider == null");
         }
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Object spi = ENGINE.getInstance(algorithm, provider, null);
         return new Mac((MacSpi) spi, provider, algorithm);
diff --git a/luni/src/main/java/javax/crypto/SecretKeyFactory.java b/luni/src/main/java/javax/crypto/SecretKeyFactory.java
index 5e47abe..8ab3eb8 100644
--- a/luni/src/main/java/javax/crypto/SecretKeyFactory.java
+++ b/luni/src/main/java/javax/crypto/SecretKeyFactory.java
@@ -103,7 +103,7 @@ public class SecretKeyFactory {
     public static final SecretKeyFactory getInstance(String algorithm)
             throws NoSuchAlgorithmException {
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Engine.SpiAndProvider sap = ENGINE.getInstance(algorithm, null);
         return new SecretKeyFactory((SecretKeyFactorySpi) sap.spi, sap.provider, algorithm);
@@ -165,7 +165,7 @@ public class SecretKeyFactory {
             throw new IllegalArgumentException("provider == null");
         }
         if (algorithm == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("algorithm == null");
         }
         Object spi = ENGINE.getInstance(algorithm, provider, null);
         return new SecretKeyFactory((SecretKeyFactorySpi) spi, provider, algorithm);
diff --git a/luni/src/main/java/javax/crypto/spec/DESedeKeySpec.java b/luni/src/main/java/javax/crypto/spec/DESedeKeySpec.java
index fe86aeb..fcfe749 100644
--- a/luni/src/main/java/javax/crypto/spec/DESedeKeySpec.java
+++ b/luni/src/main/java/javax/crypto/spec/DESedeKeySpec.java
@@ -45,7 +45,7 @@ public class DESedeKeySpec implements KeySpec {
      */
     public DESedeKeySpec(byte[] key) throws InvalidKeyException {
         if (key == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("key == null");
         }
         if (key.length < DES_EDE_KEY_LEN) {
             throw new InvalidKeyException();
@@ -71,7 +71,7 @@ public class DESedeKeySpec implements KeySpec {
      */
     public DESedeKeySpec(byte[] key, int offset) throws InvalidKeyException {
         if (key == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("key == null");
         }
         if (key.length - offset < DES_EDE_KEY_LEN) {
             throw new InvalidKeyException();
diff --git a/luni/src/main/java/javax/crypto/spec/OAEPParameterSpec.java b/luni/src/main/java/javax/crypto/spec/OAEPParameterSpec.java
index 3bc9ab4..340e57f 100644
--- a/luni/src/main/java/javax/crypto/spec/OAEPParameterSpec.java
+++ b/luni/src/main/java/javax/crypto/spec/OAEPParameterSpec.java
@@ -73,8 +73,12 @@ public class OAEPParameterSpec implements AlgorithmParameterSpec {
      */
     public OAEPParameterSpec(String mdName, String mgfName,
                                 AlgorithmParameterSpec mgfSpec, PSource pSrc) {
-        if ((mdName == null) || (mgfName == null) || (pSrc == null)) {
-            throw new NullPointerException();
+        if (mdName == null) {
+            throw new NullPointerException("mdName == null");
+        } else if (mgfName == null) {
+            throw new NullPointerException("mgfName == null");
+        } else if (pSrc == null) {
+            throw new NullPointerException("pSrc == null");
         }
         this.mdName = mdName;
         this.mgfName = mgfName;
diff --git a/luni/src/main/java/javax/crypto/spec/PSource.java b/luni/src/main/java/javax/crypto/spec/PSource.java
index 0efa1e9..f644316 100644
--- a/luni/src/main/java/javax/crypto/spec/PSource.java
+++ b/luni/src/main/java/javax/crypto/spec/PSource.java
@@ -40,7 +40,7 @@ public class PSource {
      */
     protected PSource(String pSrcName) {
         if (pSrcName == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("pSrcName == null");
         }
         this.pSrcName = pSrcName;
     }
@@ -85,7 +85,7 @@ public class PSource {
         public PSpecified(byte[] p) {
             super("PSpecified");
             if (p == null) {
-                throw new NullPointerException();
+                throw new NullPointerException("p == null");
             }
             //TODO: It is unknown which name should be used!
             //super("");
diff --git a/luni/src/main/java/javax/net/ssl/KeyManagerFactory.java b/luni/src/main/java/javax/net/ssl/KeyManagerFactory.java
index 82ce8a1..0b3db61 100644
--- a/luni/src/main/java/javax/net/ssl/KeyManagerFactory.java
+++ b/luni/src/main/java/javax/net/ssl/KeyManagerFactory.java
@@ -68,7 +68,7 @@ public class KeyManagerFactory {
     public static final KeyManagerFactory getInstance(String algorithm)
             throws NoSuchAlgorithmException {
         if (algorithm == null) {
-            throw new NullPointerException("algorithm is null");
+            throw new NullPointerException("algorithm == null");
         }
         Engine.SpiAndProvider sap = ENGINE.getInstance(algorithm, null);
         return new KeyManagerFactory((KeyManagerFactorySpi) sap.spi, sap.provider, algorithm);
@@ -127,7 +127,7 @@ public class KeyManagerFactory {
             throw new IllegalArgumentException("Provider is null");
         }
         if (algorithm == null) {
-            throw new NullPointerException("algorithm is null");
+            throw new NullPointerException("algorithm == null");
         }
         Object spi = ENGINE.getInstance(algorithm, provider, null);
         return new KeyManagerFactory((KeyManagerFactorySpi) spi, provider, algorithm);
diff --git a/luni/src/main/java/javax/net/ssl/SSLContext.java b/luni/src/main/java/javax/net/ssl/SSLContext.java
index 9097bb9..a59f301 100644
--- a/luni/src/main/java/javax/net/ssl/SSLContext.java
+++ b/luni/src/main/java/javax/net/ssl/SSLContext.java
@@ -93,7 +93,7 @@ public class SSLContext {
      */
     public static SSLContext getInstance(String protocol) throws NoSuchAlgorithmException {
         if (protocol == null) {
-            throw new NullPointerException("protocol is null");
+            throw new NullPointerException("protocol == null");
         }
         Engine.SpiAndProvider sap = ENGINE.getInstance(protocol, null);
         return new SSLContext((SSLContextSpi) sap.spi, sap.provider, protocol);
@@ -154,7 +154,7 @@ public class SSLContext {
             throw new IllegalArgumentException("provider is null");
         }
         if (protocol == null) {
-            throw new NullPointerException("protocol is null");
+            throw new NullPointerException("protocol == null");
         }
         Object spi = ENGINE.getInstance(protocol, provider, null);
         return new SSLContext((SSLContextSpi) spi, provider, protocol);
diff --git a/luni/src/main/java/javax/net/ssl/TrustManagerFactory.java b/luni/src/main/java/javax/net/ssl/TrustManagerFactory.java
index bf3bf8c..be9db06 100644
--- a/luni/src/main/java/javax/net/ssl/TrustManagerFactory.java
+++ b/luni/src/main/java/javax/net/ssl/TrustManagerFactory.java
@@ -67,7 +67,7 @@ public class TrustManagerFactory {
     public static final TrustManagerFactory getInstance(String algorithm)
             throws NoSuchAlgorithmException {
         if (algorithm == null) {
-            throw new NullPointerException("algorithm is null");
+            throw new NullPointerException("algorithm == null");
         }
         Engine.SpiAndProvider sap = ENGINE.getInstance(algorithm, null);
         return new TrustManagerFactory((TrustManagerFactorySpi) sap.spi, sap.provider, algorithm);
@@ -126,7 +126,7 @@ public class TrustManagerFactory {
             throw new IllegalArgumentException("Provider is null");
         }
         if (algorithm == null) {
-            throw new NullPointerException("algorithm is null");
+            throw new NullPointerException("algorithm == null");
         }
         Object spi = ENGINE.getInstance(algorithm, provider, null);
         return new TrustManagerFactory((TrustManagerFactorySpi) spi, provider, algorithm);
diff --git a/luni/src/main/java/javax/security/auth/Subject.java b/luni/src/main/java/javax/security/auth/Subject.java
index a958484..6c9c036 100644
--- a/luni/src/main/java/javax/security/auth/Subject.java
+++ b/luni/src/main/java/javax/security/auth/Subject.java
@@ -116,8 +116,12 @@ public final class Subject implements Serializable {
     public Subject(boolean readOnly, Set<? extends Principal> subjPrincipals,
             Set<?> pubCredentials, Set<?> privCredentials) {
 
-        if (subjPrincipals == null || pubCredentials == null || privCredentials == null) {
-            throw new NullPointerException();
+        if (subjPrincipals == null) {
+            throw new NullPointerException("subjPrincipals == null");
+        } else if (pubCredentials == null) {
+            throw new NullPointerException("pubCredentials == null");
+        } else if (privCredentials == null) {
+            throw new NullPointerException("privCredentials == null");
         }
 
         principals = new SecureSet<Principal>(_PRINCIPALS, subjPrincipals);
@@ -467,7 +471,7 @@ public final class Subject implements Serializable {
      */
     public static Subject getSubject(final AccessControlContext context) {
         if (context == null) {
-            throw new NullPointerException("AccessControlContext cannot be null");
+            throw new NullPointerException("context == null");
         }
         PrivilegedAction<DomainCombiner> action = new PrivilegedAction<DomainCombiner>() {
             public DomainCombiner run() {
@@ -554,7 +558,7 @@ public final class Subject implements Serializable {
         private void verifyElement(Object o) {
 
             if (o == null) {
-                throw new NullPointerException();
+                throw new NullPointerException("o == null");
             }
             if (permission == _PRINCIPALS && !(Principal.class.isAssignableFrom(o.getClass()))) {
                 throw new IllegalArgumentException("Element is not instance of java.security.Principal");
@@ -607,7 +611,7 @@ public final class Subject implements Serializable {
         public boolean retainAll(Collection<?> c) {
 
             if (c == null) {
-                throw new NullPointerException();
+                throw new NullPointerException("c == null");
             }
             return super.retainAll(c);
         }
@@ -624,7 +628,7 @@ public final class Subject implements Serializable {
         protected final <E> Set<E> get(final Class<E> c) {
 
             if (c == null) {
-                throw new NullPointerException();
+                throw new NullPointerException("c == null");
             }
 
             AbstractSet<E> s = new AbstractSet<E>() {
@@ -652,7 +656,7 @@ public final class Subject implements Serializable {
                 public boolean retainAll(Collection<?> c) {
 
                     if (c == null) {
-                        throw new NullPointerException();
+                        throw new NullPointerException("c == null");
                     }
                     return super.retainAll(c);
                 }
diff --git a/luni/src/main/java/javax/security/auth/x500/X500Principal.java b/luni/src/main/java/javax/security/auth/x500/X500Principal.java
index e6453e9..cedebe0 100644
--- a/luni/src/main/java/javax/security/auth/x500/X500Principal.java
+++ b/luni/src/main/java/javax/security/auth/x500/X500Principal.java
@@ -123,7 +123,7 @@ public final class X500Principal implements Serializable, Principal {
      */
     public X500Principal(String name) {
         if (name == null) {
-            throw new NullPointerException("Name cannot be null");
+            throw new NullPointerException("name == null");
         }
         try {
             dn = new Name(name);
@@ -134,7 +134,7 @@ public final class X500Principal implements Serializable, Principal {
 
     public X500Principal(String name, Map<String,String> keywordMap){
         if (name == null) {
-            throw new NullPointerException("Name cannot be null");
+            throw new NullPointerException("name == null");
         }
         try {
             dn = new Name(substituteNameFromMap(name, keywordMap));
diff --git a/luni/src/main/java/javax/xml/datatype/DatatypeFactory.java b/luni/src/main/java/javax/xml/datatype/DatatypeFactory.java
index 6a89dae..68291b6 100644
--- a/luni/src/main/java/javax/xml/datatype/DatatypeFactory.java
+++ b/luni/src/main/java/javax/xml/datatype/DatatypeFactory.java
@@ -326,7 +326,7 @@ public abstract class DatatypeFactory {
      */
     public Duration newDurationDayTime(final String lexicalRepresentation) {
         if (lexicalRepresentation == null) {
-            throw new NullPointerException("The lexical representation cannot be null.");
+            throw new NullPointerException("lexicalRepresentation == null");
         }
         // The lexical representation must match the pattern [^YM]*(T.*)?
         int pos = lexicalRepresentation.indexOf('T');
@@ -539,7 +539,7 @@ public abstract class DatatypeFactory {
      */
     public Duration newDurationYearMonth(final String lexicalRepresentation) {
         if (lexicalRepresentation == null) {
-            throw new NullPointerException("The lexical representation cannot be null.");
+            throw new NullPointerException("lexicalRepresentation == null");
         }
         // The lexical representation must match the pattern [^DT]*.
         int length = lexicalRepresentation.length();
diff --git a/luni/src/main/java/javax/xml/datatype/Duration.java b/luni/src/main/java/javax/xml/datatype/Duration.java
index 8121d36..fcdd4c5 100644
--- a/luni/src/main/java/javax/xml/datatype/Duration.java
+++ b/luni/src/main/java/javax/xml/datatype/Duration.java
@@ -552,11 +552,7 @@ public abstract class   Duration {
 
         // check data parameter
         if (date == null) {
-            throw new NullPointerException(
-                    "Cannot call "
-                    + this.getClass().getName()
-                    + "#addTo(Date date) with date == null."
-            );
+            throw new NullPointerException("date == null");
         }
 
         Calendar cal = new GregorianCalendar();
diff --git a/luni/src/main/java/javax/xml/validation/SchemaFactory.java b/luni/src/main/java/javax/xml/validation/SchemaFactory.java
index 23e4798..2018067 100644
--- a/luni/src/main/java/javax/xml/validation/SchemaFactory.java
+++ b/luni/src/main/java/javax/xml/validation/SchemaFactory.java
@@ -203,8 +203,10 @@ public abstract class SchemaFactory {
      */
     public static SchemaFactory newInstance(String schemaLanguage, String factoryClassName,
             ClassLoader classLoader) {
-        if (schemaLanguage == null || factoryClassName == null) {
-            throw new NullPointerException("schemaLanguage == null || factoryClassName == null");
+        if (schemaLanguage == null) {
+            throw new NullPointerException("schemaLanguage == null");
+        } else if (factoryClassName == null) {
+            throw new NullPointerException("factoryClassName == null");
         }
         if (classLoader == null) {
             classLoader = Thread.currentThread().getContextClassLoader();
@@ -265,7 +267,7 @@ public abstract class SchemaFactory {
     public boolean getFeature(String name) throws SAXNotRecognizedException, SAXNotSupportedException {
 
         if (name == null) {
-            throw new NullPointerException("the name parameter is null");
+            throw new NullPointerException("name == null");
         }
         throw new SAXNotRecognizedException(name);
     }
@@ -313,7 +315,7 @@ public abstract class SchemaFactory {
      */
     public void setFeature(String name, boolean value) throws SAXNotRecognizedException, SAXNotSupportedException {
         if (name == null) {
-            throw new NullPointerException("the name parameter is null");
+            throw new NullPointerException("name == null");
         }
         throw new SAXNotRecognizedException(name);
     }
@@ -340,7 +342,7 @@ public abstract class SchemaFactory {
      */
     public void setProperty(String name, Object object) throws SAXNotRecognizedException, SAXNotSupportedException {
         if (name == null) {
-            throw new NullPointerException("the name parameter is null");
+            throw new NullPointerException("name == null");
         }
         throw new SAXNotRecognizedException(name);
     }
@@ -371,7 +373,7 @@ public abstract class SchemaFactory {
      */
     public Object getProperty(String name) throws SAXNotRecognizedException, SAXNotSupportedException {
         if (name == null) {
-            throw new NullPointerException("the name parameter is null");
+            throw new NullPointerException("name == null");
         }
         throw new SAXNotRecognizedException(name);
     }
diff --git a/luni/src/main/java/javax/xml/validation/SchemaFactoryFinder.java b/luni/src/main/java/javax/xml/validation/SchemaFactoryFinder.java
index 3a6cb83..636777c 100644
--- a/luni/src/main/java/javax/xml/validation/SchemaFactoryFinder.java
+++ b/luni/src/main/java/javax/xml/validation/SchemaFactoryFinder.java
@@ -131,7 +131,9 @@ final class SchemaFactoryFinder  {
      *      If the <tt>schemaLanguage</tt> parameter is null.
      */
     public SchemaFactory newFactory(String schemaLanguage) {
-        if(schemaLanguage==null)        throw new NullPointerException();
+        if (schemaLanguage == null) {
+            throw new NullPointerException("schemaLanguage == null");
+        }
         SchemaFactory f = _newFactory(schemaLanguage);
         if (debug) {
             if (f != null) {
diff --git a/luni/src/main/java/javax/xml/validation/Validator.java b/luni/src/main/java/javax/xml/validation/Validator.java
index b4ee1ca..ea7908a 100644
--- a/luni/src/main/java/javax/xml/validation/Validator.java
+++ b/luni/src/main/java/javax/xml/validation/Validator.java
@@ -339,7 +339,9 @@ public abstract class Validator {
      * @see #setFeature(String, boolean)
      */
     public boolean getFeature(String name) throws SAXNotRecognizedException, SAXNotSupportedException {
-        if(name==null) throw new NullPointerException("the name parameter is null");
+        if (name == null) {
+            throw new NullPointerException("name == null");
+        }
         throw new SAXNotRecognizedException(name);
     }
 
@@ -372,7 +374,9 @@ public abstract class Validator {
      * @see #getFeature(String)
      */
     public void setFeature(String name, boolean value) throws SAXNotRecognizedException, SAXNotSupportedException {
-        if(name==null) throw new NullPointerException("the name parameter is null");
+        if (name == null) {
+            throw new NullPointerException("name == null");
+        }
         throw new SAXNotRecognizedException(name);
     }
 
@@ -400,7 +404,9 @@ public abstract class Validator {
      *          When the name parameter is null.
      */
     public void setProperty(String name, Object object) throws SAXNotRecognizedException, SAXNotSupportedException {
-        if(name==null) throw new NullPointerException("the name parameter is null");
+        if (name == null) {
+            throw new NullPointerException("name == null");
+        }
         throw new SAXNotRecognizedException(name);
     }
 
@@ -431,7 +437,9 @@ public abstract class Validator {
      * @see #setProperty(String, Object)
      */
     public Object getProperty(String name) throws SAXNotRecognizedException, SAXNotSupportedException {
-        if(name==null) throw new NullPointerException("the name parameter is null");
+        if (name == null) {
+            throw new NullPointerException("name == null");
+        }
         throw new SAXNotRecognizedException(name);
     }
 }
diff --git a/luni/src/main/java/javax/xml/validation/ValidatorHandler.java b/luni/src/main/java/javax/xml/validation/ValidatorHandler.java
index 9606193..2b621ff 100644
--- a/luni/src/main/java/javax/xml/validation/ValidatorHandler.java
+++ b/luni/src/main/java/javax/xml/validation/ValidatorHandler.java
@@ -347,8 +347,9 @@ public abstract class ValidatorHandler implements ContentHandler {
      * @see #setFeature(String, boolean)
      */
     public boolean getFeature(String name) throws SAXNotRecognizedException, SAXNotSupportedException {
-        if(name==null)
-            throw new NullPointerException();
+        if (name == null) {
+            throw new NullPointerException("name == null");
+        }
         throw new SAXNotRecognizedException(name);
     }
 
@@ -381,8 +382,9 @@ public abstract class ValidatorHandler implements ContentHandler {
      * @see #getFeature(String)
      */
     public void setFeature(String name, boolean value) throws SAXNotRecognizedException, SAXNotSupportedException {
-        if(name==null)
-            throw new NullPointerException();
+        if (name == null) {
+            throw new NullPointerException("name == null");
+        }
         throw new SAXNotRecognizedException(name);
     }
 
@@ -411,8 +413,9 @@ public abstract class ValidatorHandler implements ContentHandler {
      *          When the name parameter is null.
      */
     public void setProperty(String name, Object object) throws SAXNotRecognizedException, SAXNotSupportedException {
-        if(name==null)
-            throw new NullPointerException();
+        if (name == null) {
+            throw new NullPointerException("name == null");
+        }
         throw new SAXNotRecognizedException(name);
     }
 
@@ -443,8 +446,9 @@ public abstract class ValidatorHandler implements ContentHandler {
      * @see #setProperty(String, Object)
      */
     public Object getProperty(String name) throws SAXNotRecognizedException, SAXNotSupportedException {
-        if(name==null)
-            throw new NullPointerException();
+        if (name == null) {
+            throw new NullPointerException("name == null");
+        }
         throw new SAXNotRecognizedException(name);
     }
 }
diff --git a/luni/src/main/java/javax/xml/xpath/XPathException.java b/luni/src/main/java/javax/xml/xpath/XPathException.java
index 8db369b..376d477 100644
--- a/luni/src/main/java/javax/xml/xpath/XPathException.java
+++ b/luni/src/main/java/javax/xml/xpath/XPathException.java
@@ -48,8 +48,8 @@ public class XPathException extends Exception {
      */
     public XPathException(String message) {
         super(message);
-        if ( message == null ) {
-            throw new NullPointerException ( "message can't be null");
+        if (message == null) {
+            throw new NullPointerException("message == null");
         }
         this.cause = null;
     }
@@ -66,8 +66,8 @@ public class XPathException extends Exception {
     public XPathException(Throwable cause) {
         super(cause == null ? null : cause.toString());
         this.cause = cause;
-        if ( cause == null ) {
-            throw new NullPointerException ( "cause can't be null");
+        if (cause == null) {
+            throw new NullPointerException("cause == null");
         }
     }
 
diff --git a/luni/src/main/java/javax/xml/xpath/XPathFactory.java b/luni/src/main/java/javax/xml/xpath/XPathFactory.java
index 8b1c1fa..57f2195 100644
--- a/luni/src/main/java/javax/xml/xpath/XPathFactory.java
+++ b/luni/src/main/java/javax/xml/xpath/XPathFactory.java
@@ -133,9 +133,7 @@ public abstract class XPathFactory {
     public static final XPathFactory newInstance(final String uri)
         throws XPathFactoryConfigurationException {
         if (uri == null) {
-            throw new NullPointerException(
-                "XPathFactory#newInstance(String uri) cannot be called with uri == null"
-            );
+            throw new NullPointerException("uri == null");
         }
         if (uri.length() == 0) {
             throw new IllegalArgumentException(
@@ -167,9 +165,7 @@ public abstract class XPathFactory {
     public static XPathFactory newInstance(String uri, String factoryClassName,
             ClassLoader classLoader) throws XPathFactoryConfigurationException {
         if (uri == null) {
-            throw new NullPointerException(
-                "XPathFactory#newInstance(String uri) cannot be called with uri == null"
-            );
+            throw new NullPointerException("uri == null");
         }
         if (uri.length() == 0) {
             throw new IllegalArgumentException(
diff --git a/luni/src/main/java/javax/xml/xpath/XPathFactoryFinder.java b/luni/src/main/java/javax/xml/xpath/XPathFactoryFinder.java
index 652a1d8..0113e7d 100644
--- a/luni/src/main/java/javax/xml/xpath/XPathFactoryFinder.java
+++ b/luni/src/main/java/javax/xml/xpath/XPathFactoryFinder.java
@@ -126,7 +126,9 @@ final class XPathFactoryFinder {
      *      If the parameter is null.
      */
     public XPathFactory newFactory(String uri) {
-        if(uri==null)        throw new NullPointerException();
+        if (uri == null) {
+            throw new NullPointerException("uri == null");
+        }
         XPathFactory f = _newFactory(uri);
         if (debug) {
             if (f != null) {
diff --git a/luni/src/main/java/libcore/icu/NativeIDN.java b/luni/src/main/java/libcore/icu/NativeIDN.java
index 9bf5cb1..db93379 100644
--- a/luni/src/main/java/libcore/icu/NativeIDN.java
+++ b/luni/src/main/java/libcore/icu/NativeIDN.java
@@ -34,7 +34,7 @@ public final class NativeIDN {
 
     private static String convert(String s, int flags, boolean toAscii) {
         if (s == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("s == null");
         }
         return convertImpl(s, flags, toAscii);
     }
diff --git a/luni/src/main/java/libcore/icu/RuleBasedCollatorICU.java b/luni/src/main/java/libcore/icu/RuleBasedCollatorICU.java
index d036c98..4221fe6 100644
--- a/luni/src/main/java/libcore/icu/RuleBasedCollatorICU.java
+++ b/luni/src/main/java/libcore/icu/RuleBasedCollatorICU.java
@@ -46,7 +46,7 @@ public final class RuleBasedCollatorICU implements Cloneable {
 
     public RuleBasedCollatorICU(String rules) throws ParseException {
         if (rules == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("rules == null");
         }
         address = NativeCollation.openCollatorFromRules(rules, VALUE_OFF, VALUE_DEFAULT_STRENGTH);
     }
diff --git a/luni/src/main/java/libcore/io/StrictLineReader.java b/luni/src/main/java/libcore/io/StrictLineReader.java
index 5f8d452..36556a0 100644
--- a/luni/src/main/java/libcore/io/StrictLineReader.java
+++ b/luni/src/main/java/libcore/io/StrictLineReader.java
@@ -106,8 +106,10 @@ public class StrictLineReader implements Closeable {
      *         or the specified charset is not supported.
      */
     public StrictLineReader(InputStream in, int capacity, Charset charset) {
-        if (in == null || charset == null) {
-            throw new NullPointerException();
+        if (in == null) {
+            throw new NullPointerException("in == null");
+        } else if (charset == null) {
+            throw new NullPointerException("charset == null");
         }
         if (capacity < 0) {
             throw new IllegalArgumentException("capacity <= 0");
diff --git a/luni/src/main/java/libcore/net/UriCodec.java b/luni/src/main/java/libcore/net/UriCodec.java
index bde922b..6624474 100644
--- a/luni/src/main/java/libcore/net/UriCodec.java
+++ b/luni/src/main/java/libcore/net/UriCodec.java
@@ -94,7 +94,7 @@ public abstract class UriCodec {
     private void appendEncoded(StringBuilder builder, String s, Charset charset,
             boolean isPartiallyEncoded) {
         if (s == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("s == null");
         }
 
         int escapeStart = -1;
diff --git a/luni/src/main/java/libcore/util/BasicLruCache.java b/luni/src/main/java/libcore/util/BasicLruCache.java
index 13ab3db..75e4a75 100644
--- a/luni/src/main/java/libcore/util/BasicLruCache.java
+++ b/luni/src/main/java/libcore/util/BasicLruCache.java
@@ -43,7 +43,7 @@ public class BasicLruCache<K, V> {
      */
     public synchronized final V get(K key) {
         if (key == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("key == null");
         }
 
         V result = map.get(key);
@@ -68,8 +68,10 @@ public class BasicLruCache<K, V> {
      *     no longer cached, it has not been passed to {@link #entryEvicted}.
      */
     public synchronized final V put(K key, V value) {
-        if (key == null || value == null) {
-            throw new NullPointerException();
+        if (key == null) {
+            throw new NullPointerException("key == null");
+        } else if (value == null) {
+            throw new NullPointerException("value == null");
         }
 
         V previous = map.put(key, value);
diff --git a/luni/src/main/java/org/apache/harmony/crypto/internal/NullCipherSpi.java b/luni/src/main/java/org/apache/harmony/crypto/internal/NullCipherSpi.java
index 270f63b..151b403 100644
--- a/luni/src/main/java/org/apache/harmony/crypto/internal/NullCipherSpi.java
+++ b/luni/src/main/java/org/apache/harmony/crypto/internal/NullCipherSpi.java
@@ -115,8 +115,10 @@ public class NullCipherSpi extends CipherSpi {
     @Override
     public int engineUpdate(ByteBuffer input, ByteBuffer output)
             throws ShortBufferException {
-        if (input == null || output == null) {
-            throw new NullPointerException();
+        if (input == null) {
+            throw new NullPointerException("input == null");
+        } else if (output == null) {
+            throw new NullPointerException("output == null");
         }
         int result = input.limit() - input.position();
         try {
diff --git a/luni/src/main/java/org/apache/harmony/security/SystemScope.java b/luni/src/main/java/org/apache/harmony/security/SystemScope.java
index 89cf56b..bf4f849 100644
--- a/luni/src/main/java/org/apache/harmony/security/SystemScope.java
+++ b/luni/src/main/java/org/apache/harmony/security/SystemScope.java
@@ -79,7 +79,7 @@ public class SystemScope extends IdentityScope {
      */
     public synchronized Identity getIdentity(String name) {
         if (name == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("name == null");
         }
         return (Identity) names.get(name);
     }
diff --git a/luni/src/main/java/org/apache/harmony/security/provider/cert/X509CRLImpl.java b/luni/src/main/java/org/apache/harmony/security/provider/cert/X509CRLImpl.java
index 134d8f9..68ec38a 100644
--- a/luni/src/main/java/org/apache/harmony/security/provider/cert/X509CRLImpl.java
+++ b/luni/src/main/java/org/apache/harmony/security/provider/cert/X509CRLImpl.java
@@ -237,7 +237,7 @@ public class X509CRLImpl extends X509CRL {
      */
     public X509CRLEntry getRevokedCertificate(X509Certificate certificate) {
         if (certificate == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("certificate == null");
         }
         if (!entriesRetrieved) {
             retrieveEntries();
diff --git a/luni/src/main/java/org/apache/harmony/security/provider/crypto/SHA1withDSA_SignatureImpl.java b/luni/src/main/java/org/apache/harmony/security/provider/crypto/SHA1withDSA_SignatureImpl.java
index d2a9c6d..2958e00 100644
--- a/luni/src/main/java/org/apache/harmony/security/provider/crypto/SHA1withDSA_SignatureImpl.java
+++ b/luni/src/main/java/org/apache/harmony/security/provider/crypto/SHA1withDSA_SignatureImpl.java
@@ -57,7 +57,7 @@ public class SHA1withDSA_SignatureImpl extends Signature {
     protected Object engineGetParameter(String param)
             throws InvalidParameterException {
         if (param == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("param == null");
         }
         return null;
     }
diff --git a/luni/src/main/java/org/apache/harmony/xml/ExpatAttributes.java b/luni/src/main/java/org/apache/harmony/xml/ExpatAttributes.java
index b92fc50..5ec632c 100644
--- a/luni/src/main/java/org/apache/harmony/xml/ExpatAttributes.java
+++ b/luni/src/main/java/org/apache/harmony/xml/ExpatAttributes.java
@@ -76,10 +76,10 @@ abstract class ExpatAttributes implements Attributes {
 
     public int getIndex(String uri, String localName) {
         if (uri == null) {
-            throw new NullPointerException("uri");
+            throw new NullPointerException("uri == null");
         }
         if (localName == null) {
-            throw new NullPointerException("local name");
+            throw new NullPointerException("localName == null");
         }
         int pointer = getPointer();
         if (pointer == 0) {
@@ -90,7 +90,7 @@ abstract class ExpatAttributes implements Attributes {
 
     public int getIndex(String qName) {
         if (qName == null) {
-            throw new NullPointerException("uri");
+            throw new NullPointerException("qName == null");
         }
         int pointer = getPointer();
         if (pointer == 0) {
@@ -101,10 +101,10 @@ abstract class ExpatAttributes implements Attributes {
 
     public String getType(String uri, String localName) {
         if (uri == null) {
-            throw new NullPointerException("uri");
+            throw new NullPointerException("uri == null");
         }
         if (localName == null) {
-            throw new NullPointerException("local name");
+            throw new NullPointerException("localName == null");
         }
         return getIndex(uri, localName) == -1 ? null : CDATA;
     }
@@ -115,10 +115,10 @@ abstract class ExpatAttributes implements Attributes {
 
     public String getValue(String uri, String localName) {
         if (uri == null) {
-            throw new NullPointerException("uri");
+            throw new NullPointerException("uri == null");
         }
         if (localName == null) {
-            throw new NullPointerException("local name");
+            throw new NullPointerException("localName == null");
         }
         int pointer = getPointer();
         if (pointer == 0) {
@@ -129,7 +129,7 @@ abstract class ExpatAttributes implements Attributes {
 
     public String getValue(String qName) {
         if (qName == null) {
-            throw new NullPointerException("qName");
+            throw new NullPointerException("qName == null");
         }
         int pointer = getPointer();
         if (pointer == 0) {
diff --git a/luni/src/main/java/org/apache/harmony/xml/dom/NodeImpl.java b/luni/src/main/java/org/apache/harmony/xml/dom/NodeImpl.java
index 1f1293b..af4002f 100644
--- a/luni/src/main/java/org/apache/harmony/xml/dom/NodeImpl.java
+++ b/luni/src/main/java/org/apache/harmony/xml/dom/NodeImpl.java
@@ -697,7 +697,7 @@ public abstract class NodeImpl implements Node {
 
     public final Object setUserData(String key, Object data, UserDataHandler handler) {
         if (key == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("key == null");
         }
         Map<String, UserData> map = document.getUserDataMap(this);
         UserData previous = data == null
@@ -708,7 +708,7 @@ public abstract class NodeImpl implements Node {
 
     public final Object getUserData(String key) {
         if (key == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("key == null");
         }
         Map<String, UserData> map = document.getUserDataMapForRead(this);
         UserData userData = map.get(key);
diff --git a/luni/src/main/java/org/apache/harmony/xml/parsers/DocumentBuilderFactoryImpl.java b/luni/src/main/java/org/apache/harmony/xml/parsers/DocumentBuilderFactoryImpl.java
index 8efaa30..debbb20 100644
--- a/luni/src/main/java/org/apache/harmony/xml/parsers/DocumentBuilderFactoryImpl.java
+++ b/luni/src/main/java/org/apache/harmony/xml/parsers/DocumentBuilderFactoryImpl.java
@@ -42,7 +42,7 @@ public class DocumentBuilderFactoryImpl extends DocumentBuilderFactory {
     @Override
     public boolean getFeature(String name) throws ParserConfigurationException {
         if (name == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("name == null");
         }
 
         if (NAMESPACES.equals(name)) {
@@ -90,7 +90,7 @@ public class DocumentBuilderFactoryImpl extends DocumentBuilderFactory {
     public void setFeature(String name, boolean value)
             throws ParserConfigurationException {
         if (name == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("name == null");
         }
 
         if (NAMESPACES.equals(name)) {
diff --git a/luni/src/main/java/org/apache/harmony/xml/parsers/SAXParserFactoryImpl.java b/luni/src/main/java/org/apache/harmony/xml/parsers/SAXParserFactoryImpl.java
index 08657b9..e2e3778 100644
--- a/luni/src/main/java/org/apache/harmony/xml/parsers/SAXParserFactoryImpl.java
+++ b/luni/src/main/java/org/apache/harmony/xml/parsers/SAXParserFactoryImpl.java
@@ -41,7 +41,7 @@ public class SAXParserFactoryImpl extends SAXParserFactory {
     @Override
     public boolean getFeature(String name) throws SAXNotRecognizedException {
         if (name == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("name == null");
         }
 
         if (!name.startsWith("http://xml.org/sax/features/")) {
@@ -86,7 +86,7 @@ public class SAXParserFactoryImpl extends SAXParserFactory {
     @Override
     public void setFeature(String name, boolean value) throws SAXNotRecognizedException {
         if (name == null) {
-            throw new NullPointerException();
+            throw new NullPointerException("name == null");
         }
 
         if (!name.startsWith("http://xml.org/sax/features/")) {
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/FileClientSessionCache.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/FileClientSessionCache.java
index 6619d1d..0f1fe24 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/FileClientSessionCache.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/FileClientSessionCache.java
@@ -121,7 +121,7 @@ public class FileClientSessionCache {
          */
         private static String fileName(String host, int port) {
             if (host == null) {
-                throw new NullPointerException("host");
+                throw new NullPointerException("host == null");
             }
             return host + "." + port;
         }
@@ -182,7 +182,7 @@ public class FileClientSessionCache {
                 byte[] sessionData) {
             String host = session.getPeerHost();
             if (sessionData == null) {
-                throw new NullPointerException("sessionData");
+                throw new NullPointerException("sessionData == null");
             }
 
             String name = fileName(host, session.getPeerPort());
-- 
cgit v1.1


From 9b9e9145bc55a47be42a9d3f7ecc9f6b533739b2 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Fri, 14 Sep 2012 14:50:09 -0700
Subject: Consistently use "charsetName" for charset names.

Change-Id: I147217077790c1ddfb815e870409abade31839c6
---
 .../main/java/java/io/ByteArrayOutputStream.java   |  8 ++--
 luni/src/main/java/java/io/InputStreamReader.java  | 18 ++++----
 luni/src/main/java/java/io/OutputStreamWriter.java | 28 +++++------
 luni/src/main/java/java/io/PrintStream.java        | 54 +++++++++++-----------
 .../security/x509/AuthorityKeyIdentifier.java      |  6 +--
 5 files changed, 57 insertions(+), 57 deletions(-)

diff --git a/luni/src/main/java/java/io/ByteArrayOutputStream.java b/luni/src/main/java/java/io/ByteArrayOutputStream.java
index 3ab2c20..ff9c7df 100644
--- a/luni/src/main/java/java/io/ByteArrayOutputStream.java
+++ b/luni/src/main/java/java/io/ByteArrayOutputStream.java
@@ -162,17 +162,17 @@ public class ByteArrayOutputStream extends OutputStream {
 
     /**
      * Returns the contents of this ByteArrayOutputStream as a string converted
-     * according to the encoding declared in {@code enc}.
+     * according to the encoding declared in {@code charsetName}.
      *
-     * @param enc
+     * @param charsetName
      *            a string representing the encoding to use when translating
      *            this stream to a string.
      * @return this stream's current contents as an encoded string.
      * @throws UnsupportedEncodingException
      *             if the provided encoding is not supported.
      */
-    public String toString(String enc) throws UnsupportedEncodingException {
-        return new String(buf, 0, count, enc);
+    public String toString(String charsetName) throws UnsupportedEncodingException {
+        return new String(buf, 0, count, charsetName);
     }
 
     /**
diff --git a/luni/src/main/java/java/io/InputStreamReader.java b/luni/src/main/java/java/io/InputStreamReader.java
index 2e9b381..d3650dc 100644
--- a/luni/src/main/java/java/io/InputStreamReader.java
+++ b/luni/src/main/java/java/io/InputStreamReader.java
@@ -62,32 +62,32 @@ public class InputStreamReader extends Reader {
     /**
      * Constructs a new InputStreamReader on the InputStream {@code in}. The
      * character converter that is used to decode bytes into characters is
-     * identified by name by {@code enc}. If the encoding cannot be found, an
+     * identified by name by {@code charsetName}. If the encoding cannot be found, an
      * UnsupportedEncodingException error is thrown.
      *
      * @param in
      *            the InputStream from which to read characters.
-     * @param enc
+     * @param charsetName
      *            identifies the character converter to use.
      * @throws NullPointerException
-     *             if {@code enc} is {@code null}.
+     *             if {@code charsetName} is {@code null}.
      * @throws UnsupportedEncodingException
-     *             if the encoding specified by {@code enc} cannot be found.
+     *             if the encoding specified by {@code charsetName} cannot be found.
      */
-    public InputStreamReader(InputStream in, final String enc)
+    public InputStreamReader(InputStream in, final String charsetName)
             throws UnsupportedEncodingException {
         super(in);
-        if (enc == null) {
-            throw new NullPointerException("enc == null");
+        if (charsetName == null) {
+            throw new NullPointerException("charsetName == null");
         }
         this.in = in;
         try {
-            decoder = Charset.forName(enc).newDecoder().onMalformedInput(
+            decoder = Charset.forName(charsetName).newDecoder().onMalformedInput(
                     CodingErrorAction.REPLACE).onUnmappableCharacter(
                     CodingErrorAction.REPLACE);
         } catch (IllegalArgumentException e) {
             throw (UnsupportedEncodingException)
-                    new UnsupportedEncodingException(enc).initCause(e);
+                    new UnsupportedEncodingException(charsetName).initCause(e);
         }
         bytes.limit(0);
     }
diff --git a/luni/src/main/java/java/io/OutputStreamWriter.java b/luni/src/main/java/java/io/OutputStreamWriter.java
index c09c9e3..5dffdfe 100644
--- a/luni/src/main/java/java/io/OutputStreamWriter.java
+++ b/luni/src/main/java/java/io/OutputStreamWriter.java
@@ -57,30 +57,30 @@ public class OutputStreamWriter extends Writer {
 
     /**
      * Constructs a new OutputStreamWriter using {@code out} as the target
-     * stream to write converted characters to and {@code enc} as the character
+     * stream to write converted characters to and {@code charsetName} as the character
      * encoding. If the encoding cannot be found, an
      * UnsupportedEncodingException error is thrown.
      *
      * @param out
      *            the target stream to write converted bytes to.
-     * @param enc
+     * @param charsetName
      *            the string describing the desired character encoding.
      * @throws NullPointerException
-     *             if {@code enc} is {@code null}.
+     *             if {@code charsetName} is {@code null}.
      * @throws UnsupportedEncodingException
-     *             if the encoding specified by {@code enc} cannot be found.
+     *             if the encoding specified by {@code charsetName} cannot be found.
      */
-    public OutputStreamWriter(OutputStream out, final String enc)
+    public OutputStreamWriter(OutputStream out, final String charsetName)
             throws UnsupportedEncodingException {
         super(out);
-        if (enc == null) {
-            throw new NullPointerException("enc == null");
+        if (charsetName == null) {
+            throw new NullPointerException("charsetName == null");
         }
         this.out = out;
         try {
-            encoder = Charset.forName(enc).newEncoder();
+            encoder = Charset.forName(charsetName).newEncoder();
         } catch (Exception e) {
-            throw new UnsupportedEncodingException(enc);
+            throw new UnsupportedEncodingException(charsetName);
         }
         encoder.onMalformedInput(CodingErrorAction.REPLACE);
         encoder.onUnmappableCharacter(CodingErrorAction.REPLACE);
@@ -106,19 +106,19 @@ public class OutputStreamWriter extends Writer {
 
     /**
      * Constructs a new OutputStreamWriter using {@code out} as the target
-     * stream to write converted characters to and {@code enc} as the character
+     * stream to write converted characters to and {@code charsetEncoder} as the character
      * encoder.
      *
      * @param out
      *            the target stream to write converted bytes to.
-     * @param enc
+     * @param charsetEncoder
      *            the character encoder used for character conversion.
      */
-    public OutputStreamWriter(OutputStream out, CharsetEncoder enc) {
+    public OutputStreamWriter(OutputStream out, CharsetEncoder charsetEncoder) {
         super(out);
-        enc.charset();
+        charsetEncoder.charset();
         this.out = out;
-        encoder = enc;
+        encoder = charsetEncoder;
     }
 
     /**
diff --git a/luni/src/main/java/java/io/PrintStream.java b/luni/src/main/java/java/io/PrintStream.java
index ea67d46..18f2310 100644
--- a/luni/src/main/java/java/io/PrintStream.java
+++ b/luni/src/main/java/java/io/PrintStream.java
@@ -87,7 +87,7 @@ public class PrintStream extends FilterOutputStream implements Appendable, Close
 
     /**
      * Constructs a new {@code PrintStream} with {@code out} as its target
-     * stream and using the character encoding {@code enc} while writing. The
+     * stream and using the character encoding {@code charsetName} while writing. The
      * parameter {@code autoFlush} determines if the print stream automatically
      * flushes its contents to the target stream when a newline is encountered.
      *
@@ -96,30 +96,30 @@ public class PrintStream extends FilterOutputStream implements Appendable, Close
      * @param autoFlush
      *            indicates whether or not to flush contents upon encountering a
      *            newline sequence.
-     * @param enc
+     * @param charsetName
      *            the non-null string describing the desired character encoding.
      * @throws NullPointerException
-     *             if {@code out} or {@code enc} are {@code null}.
+     *             if {@code out} or {@code charsetName} are {@code null}.
      * @throws UnsupportedEncodingException
-     *             if the encoding specified by {@code enc} is not supported.
+     *             if the encoding specified by {@code charsetName} is not supported.
      */
-    public PrintStream(OutputStream out, boolean autoFlush, String enc)
+    public PrintStream(OutputStream out, boolean autoFlush, String charsetName)
             throws UnsupportedEncodingException {
         super(out);
         if (out == null) {
             throw new NullPointerException("out == null");
-        } else if (enc == null) {
-            throw new NullPointerException("enc == null");
+        } else if (charsetName == null) {
+            throw new NullPointerException("charsetName == null");
         }
         this.autoFlush = autoFlush;
         try {
-            if (!Charset.isSupported(enc)) {
-                throw new UnsupportedEncodingException(enc);
+            if (!Charset.isSupported(charsetName)) {
+                throw new UnsupportedEncodingException(charsetName);
             }
         } catch (IllegalCharsetNameException e) {
-            throw new UnsupportedEncodingException(enc);
+            throw new UnsupportedEncodingException(charsetName);
         }
-        encoding = enc;
+        encoding = charsetName;
     }
 
     /**
@@ -138,30 +138,30 @@ public class PrintStream extends FilterOutputStream implements Appendable, Close
 
     /**
      * Constructs a new {@code PrintStream} with {@code file} as its target. The
-     * character set named {@code charSetName} is used for character encoding.
+     * character set named {@code charsetName} is used for character encoding.
      *
      * @param file
      *            the target file. If the file already exists, its contents are
      *            removed, otherwise a new file is created.
-     * @param charSetName
+     * @param charsetName
      *            the name of the character set used for character encoding.
      * @throws FileNotFoundException
      *             if an error occurs while opening or creating the target file.
      * @throws NullPointerException
-     *             if {@code charSetName} is {@code null}.
+     *             if {@code charsetName} is {@code null}.
      * @throws UnsupportedEncodingException
-     *             if the encoding specified by {@code charSetName} is not supported.
+     *             if the encoding specified by {@code charsetName} is not supported.
      */
-    public PrintStream(File file, String charSetName) throws FileNotFoundException,
+    public PrintStream(File file, String charsetName) throws FileNotFoundException,
             UnsupportedEncodingException {
         super(new FileOutputStream(file));
-        if (charSetName == null) {
-            throw new NullPointerException("charSetName == null");
+        if (charsetName == null) {
+            throw new NullPointerException("charsetName == null");
         }
-        if (!Charset.isSupported(charSetName)) {
-            throw new UnsupportedEncodingException(charSetName);
+        if (!Charset.isSupported(charsetName)) {
+            throw new UnsupportedEncodingException(charsetName);
         }
-        encoding = charSetName;
+        encoding = charsetName;
     }
 
     /**
@@ -181,24 +181,24 @@ public class PrintStream extends FilterOutputStream implements Appendable, Close
 
     /**
      * Constructs a new {@code PrintStream} with the file identified by
-     * {@code fileName} as its target. The character set named {@code charSetName} is
+     * {@code fileName} as its target. The character set named {@code charsetName} is
      * used for character encoding.
      *
      * @param fileName
      *            the target file's name. If the file already exists, its
      *            contents are removed, otherwise a new file is created.
-     * @param charSetName
+     * @param charsetName
      *            the name of the character set used for character encoding.
      * @throws FileNotFoundException
      *             if an error occurs while opening or creating the target file.
      * @throws NullPointerException
-     *             if {@code charSetName} is {@code null}.
+     *             if {@code charsetName} is {@code null}.
      * @throws UnsupportedEncodingException
-     *             if the encoding specified by {@code charSetName} is not supported.
+     *             if the encoding specified by {@code charsetName} is not supported.
      */
-    public PrintStream(String fileName, String charSetName)
+    public PrintStream(String fileName, String charsetName)
             throws FileNotFoundException, UnsupportedEncodingException {
-        this(new File(fileName), charSetName);
+        this(new File(fileName), charsetName);
     }
 
     /**
diff --git a/luni/src/main/java/org/apache/harmony/security/x509/AuthorityKeyIdentifier.java b/luni/src/main/java/org/apache/harmony/security/x509/AuthorityKeyIdentifier.java
index 4afbb04..4985aff 100644
--- a/luni/src/main/java/org/apache/harmony/security/x509/AuthorityKeyIdentifier.java
+++ b/luni/src/main/java/org/apache/harmony/security/x509/AuthorityKeyIdentifier.java
@@ -138,10 +138,10 @@ public final class AuthorityKeyIdentifier extends ExtensionValue {
         @Override protected Object getDecodedObject(BerInputStream in) throws IOException {
             Object[] values = (Object[]) in.content;
 
-            byte[] enc = (byte[]) values[2];
+            byte[] bytes = (byte[]) values[2];
             BigInteger authorityCertSerialNumber = null;
-            if (enc != null) {
-                authorityCertSerialNumber = new BigInteger(enc);
+            if (bytes != null) {
+                authorityCertSerialNumber = new BigInteger(bytes);
             }
 
             return new AuthorityKeyIdentifier((byte[]) values[0],
-- 
cgit v1.1


From 5a97188382a40d3345300b92147f80b230b620bc Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Sun, 16 Sep 2012 21:00:11 -0700
Subject: Make PinListEntry and PinEntryException public for CertPinManagerTest

Change-Id: If61f800e20613e37a076bf049c259abca1072e4b
---
 .../java/org/apache/harmony/xnet/provider/jsse/PinEntryException.java  | 3 ++-
 .../main/java/org/apache/harmony/xnet/provider/jsse/PinListEntry.java  | 3 ++-
 .../java/org/apache/harmony/xnet/provider/jsse/CertPinManagerTest.java | 2 --
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/PinEntryException.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/PinEntryException.java
index 8e49bec..8b74514 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/PinEntryException.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/PinEntryException.java
@@ -16,7 +16,8 @@
 
 package org.apache.harmony.xnet.provider.jsse;
 
-class PinEntryException extends Exception {
+// public for testing by CertPinManagerTest
+public class PinEntryException extends Exception {
 
     PinEntryException() {
     }
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/PinListEntry.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/PinListEntry.java
index cefa3ef..15a07c1 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/PinListEntry.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/PinListEntry.java
@@ -30,7 +30,8 @@ import libcore.io.EventLogger;
 /**
  * This class represents a single entry in the pin file.
  */
-class PinListEntry {
+// public for testing by CertPinManagerTest
+public class PinListEntry {
 
     /** The Common Name (CN) as used on the SSL certificate */
     private final String cn;
diff --git a/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/CertPinManagerTest.java b/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/CertPinManagerTest.java
index a888165..7d37492 100644
--- a/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/CertPinManagerTest.java
+++ b/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/CertPinManagerTest.java
@@ -115,7 +115,6 @@ public class CertPinManagerTest extends TestCase {
             new PinListEntry(entry);
             fail("Accepted an empty pin list entry.");
         } catch (PinEntryException expected) {
-            // did what we're supposed to do
         }
     }
 
@@ -126,7 +125,6 @@ public class CertPinManagerTest extends TestCase {
             new PinListEntry(entry);
             fail("Accepted a basically wholly bogus entry.");
         } catch (NullPointerException expected) {
-            // did what we're supposed to do
         }
     }
 
-- 
cgit v1.1


From dd538c3bbd85d14ccae83ab3b384b2ebcc4a4c13 Mon Sep 17 00:00:00 2001
From: Kenny Root <kroot@google.com>
Date: Mon, 17 Sep 2012 17:34:26 -0700
Subject: OsConstants: add O_NOFOLLOW

Change-Id: I91619191d83ca8e0a13d30588f761e4defefc30d
---
 luni/src/main/java/libcore/io/OsConstants.java  | 1 +
 luni/src/main/native/libcore_io_OsConstants.cpp | 1 +
 2 files changed, 2 insertions(+)

diff --git a/luni/src/main/java/libcore/io/OsConstants.java b/luni/src/main/java/libcore/io/OsConstants.java
index 68a165c..9f381f5 100644
--- a/luni/src/main/java/libcore/io/OsConstants.java
+++ b/luni/src/main/java/libcore/io/OsConstants.java
@@ -224,6 +224,7 @@ public final class OsConstants {
     public static final int O_CREAT = placeholder();
     public static final int O_EXCL = placeholder();
     public static final int O_NOCTTY = placeholder();
+    public static final int O_NOFOLLOW = placeholder();
     public static final int O_NONBLOCK = placeholder();
     public static final int O_RDONLY = placeholder();
     public static final int O_RDWR = placeholder();
diff --git a/luni/src/main/native/libcore_io_OsConstants.cpp b/luni/src/main/native/libcore_io_OsConstants.cpp
index a1cfcf0..4a719af 100644
--- a/luni/src/main/native/libcore_io_OsConstants.cpp
+++ b/luni/src/main/native/libcore_io_OsConstants.cpp
@@ -230,6 +230,7 @@ static void OsConstants_initConstants(JNIEnv* env, jclass c) {
     initConstant(env, c, "O_CREAT", O_CREAT);
     initConstant(env, c, "O_EXCL", O_EXCL);
     initConstant(env, c, "O_NOCTTY", O_NOCTTY);
+    initConstant(env, c, "O_NOFOLLOW", O_NOFOLLOW);
     initConstant(env, c, "O_NONBLOCK", O_NONBLOCK);
     initConstant(env, c, "O_RDONLY", O_RDONLY);
     initConstant(env, c, "O_RDWR", O_RDWR);
-- 
cgit v1.1


From 5c9add3e84fd426fafbec289738f1f09c49aaf90 Mon Sep 17 00:00:00 2001
From: Geremy Condra <gcondra@google.com>
Date: Mon, 17 Sep 2012 19:51:16 -0700
Subject: Add logging to detect cert pin failures caused by MITM proxies.

Change-Id: Ie9554aaa824506a75534d888432ed8a91e14e386
---
 .../harmony/xnet/provider/jsse/TrustManagerImpl.java | 11 +++++++++++
 .../xnet/provider/jsse/TrustedCertificateStore.java  |  8 ++++++++
 .../provider/jsse/TrustedCertificateStoreTest.java   | 20 ++++++++++++++++++++
 3 files changed, 39 insertions(+)

diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/TrustManagerImpl.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/TrustManagerImpl.java
index 5010ef2..48dbaba 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/TrustManagerImpl.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/TrustManagerImpl.java
@@ -35,6 +35,7 @@ import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 import javax.net.ssl.X509TrustManager;
+import libcore.io.EventLogger;
 
 /**
  *
@@ -235,6 +236,7 @@ public final class TrustManagerImpl implements X509TrustManager {
                 throw new CertificateException(e);
             }
             if (chainIsNotPinned) {
+                EventLogger.writeEvent(90102, chainContainsUserCert(wholeChain));
                 throw new CertificateException(new CertPathValidatorException(
                         "Certificate path is not properly pinned.", null, certPath, -1));
             }
@@ -396,4 +398,13 @@ public final class TrustManagerImpl implements X509TrustManager {
     @Override public X509Certificate[] getAcceptedIssuers() {
         return (acceptedIssuers != null) ? acceptedIssuers.clone() : acceptedIssuers(rootKeyStore);
     }
+
+    private boolean chainContainsUserCert(List<X509Certificate> chain) {
+        for (X509Certificate cert : chain) {
+            if (trustedCertificateStore.isUserAddedCertificate(cert)) {
+                return true;
+            }
+        }
+        return false;
+    }
 }
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/TrustedCertificateStore.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/TrustedCertificateStore.java
index abb6e55..e7b1a7c 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/TrustedCertificateStore.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/TrustedCertificateStore.java
@@ -298,6 +298,14 @@ public final class TrustedCertificateStore {
     }
 
     /**
+     * Returns true to indicate that the certificate was added by the
+     * user, false otherwise.
+     */
+    public boolean isUserAddedCertificate(X509Certificate cert) {
+        return getCertificateFile(addedDir, cert).exists();
+    }
+
+    /**
      * Returns a File for where the certificate is found if it exists
      * or where it should be installed if it does not exist. The
      * caller can disambiguate these cases by calling {@code
diff --git a/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/TrustedCertificateStoreTest.java b/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/TrustedCertificateStoreTest.java
index 52880df..8f9b7fa 100644
--- a/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/TrustedCertificateStoreTest.java
+++ b/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/TrustedCertificateStoreTest.java
@@ -530,6 +530,26 @@ public class TrustedCertificateStoreTest extends TestCase {
         assertDeleted(getCa1(), getAliasSystemCa1());
     }
 
+    public void testIsUserAddedCertificate() throws Exception {
+        assertFalse(store.isUserAddedCertificate(getCa1()));
+        assertFalse(store.isUserAddedCertificate(getCa2()));
+        install(getCa1(), getAliasSystemCa1());
+        assertFalse(store.isUserAddedCertificate(getCa1()));
+        assertFalse(store.isUserAddedCertificate(getCa2()));
+        install(getCa1(), getAliasUserCa1());
+        assertTrue(store.isUserAddedCertificate(getCa1()));
+        assertFalse(store.isUserAddedCertificate(getCa2()));
+        install(getCa2(), getAliasUserCa2());
+        assertTrue(store.isUserAddedCertificate(getCa1()));
+        assertTrue(store.isUserAddedCertificate(getCa2()));
+        store.deleteCertificateEntry(getAliasUserCa1());
+        assertFalse(store.isUserAddedCertificate(getCa1()));
+        assertTrue(store.isUserAddedCertificate(getCa2()));
+        store.deleteCertificateEntry(getAliasUserCa2());
+        assertFalse(store.isUserAddedCertificate(getCa1()));
+        assertFalse(store.isUserAddedCertificate(getCa2()));
+    }
+
     private void assertRootCa(X509Certificate x, String alias) {
         assertIntermediateCa(x, alias);
         assertEquals(x, store.findIssuer(x));
-- 
cgit v1.1


From 56a5c4e1143d65ba39e9f6f72352521fb0451501 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Tue, 18 Sep 2012 11:24:44 -0700
Subject: Explain the (non-obvious) purpose of IntrinsicTest.

Change-Id: If336e3a8d3f99ffbce5e115a5ab82a044a3e282f
---
 luni/src/test/java/libcore/java/lang/IntrinsicTest.java | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/luni/src/test/java/libcore/java/lang/IntrinsicTest.java b/luni/src/test/java/libcore/java/lang/IntrinsicTest.java
index 75a4e42..6425b85 100644
--- a/luni/src/test/java/libcore/java/lang/IntrinsicTest.java
+++ b/luni/src/test/java/libcore/java/lang/IntrinsicTest.java
@@ -18,6 +18,9 @@ package libcore.java.lang;
 
 import junit.framework.TestCase;
 
+/**
+ * Tests that all intrinsic methods are still invokable via reflection.
+ */
 public final class IntrinsicTest extends TestCase {
     public void testString_charAt() throws Exception {
         "hello".charAt(0);
-- 
cgit v1.1


From 924af71bb26b7c35f702de9a3425109c73184a53 Mon Sep 17 00:00:00 2001
From: Geremy Condra <gcondra@google.com>
Date: Tue, 18 Sep 2012 19:07:13 -0700
Subject: Restructure logging to ease the transition to dropbox.

Bug: 7190096
Change-Id: Ib16bcd47712890fd627027ebacacc511870b31b0
---
 .../harmony/xnet/provider/jsse/CertPinManager.java |  9 ++--
 .../xnet/provider/jsse/PinFailureLogger.java       | 60 ++++++++++++++++++++++
 .../harmony/xnet/provider/jsse/PinListEntry.java   | 26 +++++++---
 .../xnet/provider/jsse/TrustManagerImpl.java       | 12 +----
 .../xnet/provider/jsse/CertPinManagerTest.java     | 14 ++---
 .../xnet/provider/jsse/TrustManagerImplTest.java   |  2 +-
 6 files changed, 93 insertions(+), 30 deletions(-)
 create mode 100644 luni/src/main/java/org/apache/harmony/xnet/provider/jsse/PinFailureLogger.java

diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/CertPinManager.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/CertPinManager.java
index aa956dd..4cdd8d2 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/CertPinManager.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/CertPinManager.java
@@ -42,18 +42,21 @@ public class CertPinManager {
     private static final boolean DEBUG = false;
 
     private final File pinFile;
+    private final TrustedCertificateStore certStore;
 
-    public CertPinManager() throws PinManagerException {
+    public CertPinManager(TrustedCertificateStore store) throws PinManagerException {
         pinFile = new File("/data/misc/keychain/pins");
+        certStore = store;
         rebuild();
     }
 
     /** Test only */
-    public CertPinManager(String path) throws PinManagerException {
+    public CertPinManager(String path, TrustedCertificateStore store) throws PinManagerException {
         if (path == null) {
             throw new NullPointerException("path == null");
         }
         pinFile = new File(path);
+        certStore = store;
         rebuild();
     }
 
@@ -86,7 +89,7 @@ public class CertPinManager {
             // rebuild the pinned certs
             for (String entry : getPinFileEntries(pinFileContents)) {
                 try {
-                    PinListEntry pin = new PinListEntry(entry);
+                    PinListEntry pin = new PinListEntry(entry, certStore);
                     entries.put(pin.getCommonName(), pin);
                 } catch (PinEntryException e) {
                     log("Pinlist contains a malformed pin: " + entry, e);
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/PinFailureLogger.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/PinFailureLogger.java
new file mode 100644
index 0000000..4878a9e
--- /dev/null
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/PinFailureLogger.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed 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.xnet.provider.jsse;
+
+import java.security.cert.X509Certificate;
+import java.util.List;
+import libcore.io.EventLogger;
+
+public class PinFailureLogger {
+
+    private static final long LOG_INTERVAL_NANOS = 1000 * 1000 * 1000 * 60 * 60;
+
+    private static long lastLoggedNanos = 0;
+
+    public static synchronized void log(String cn, boolean chainContainsUserCert,
+                                        boolean pinIsEnforcing,
+                                        List<X509Certificate> chain) {
+        // if we've logged recently, don't do it again
+        if (!timeToLog()) {
+            return;
+        }
+        // otherwise, log the event
+        writeToLog(cn, chainContainsUserCert, pinIsEnforcing, chain);
+        // update the last logged time
+        lastLoggedNanos = System.nanoTime();
+    }
+
+    protected static synchronized void writeToLog(String cn, boolean chainContainsUserCert,
+                                                  boolean pinIsEnforcing,
+                                                  List<X509Certificate> chain) {
+        Object[] values = new Object[chain.size() + 3];
+        values[0] = cn;
+        values[1] = chainContainsUserCert;
+        values[2] = pinIsEnforcing;
+        for (int i=0; i < chain.size(); i++) {
+            values[i+3] = chain.get(i).toString();
+        }
+        EventLogger.writeEvent(90100, values);
+    }
+
+    protected static boolean timeToLog() {
+        long currentTimeNanos = System.nanoTime();
+        return ((currentTimeNanos - lastLoggedNanos) > LOG_INTERVAL_NANOS);
+    }
+}
+
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/PinListEntry.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/PinListEntry.java
index 15a07c1..748606b 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/PinListEntry.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/PinListEntry.java
@@ -46,6 +46,8 @@ public class PinListEntry {
 
     private static final boolean DEBUG = false;
 
+    private final TrustedCertificateStore certStore;
+
     public String getCommonName() {
         return cn;
     }
@@ -54,10 +56,14 @@ public class PinListEntry {
         return enforcing;
     }
 
-    public PinListEntry(String entry) throws PinEntryException {
+    public PinListEntry(String entry, TrustedCertificateStore store) throws PinEntryException {
         if (entry == null) {
             throw new NullPointerException("entry == null");
         }
+        if (store == null) {
+            throw new NullPointerException("store == null");
+        }
+        certStore = store;
         // Examples:
         // *.google.com=true|34c8a0d...9e04ca05f,9e04ca05f...34c8a0d
         // *.android.com=true|ca05f...8a0d34c
@@ -98,7 +104,7 @@ public class PinListEntry {
                 return false;
             }
         }
-        logPinFailure(cn, chain);
+        logPinFailure(chain);
         return enforcing;
     }
 
@@ -133,13 +139,17 @@ public class PinListEntry {
         }
     }
 
-    private void logPinFailure(String cn, List<X509Certificate> chain) {
-        Object[] values = new Object[chain.size() + 1];
-        values[0] = (Object) cn;
-        for (int i=0; i < chain.size(); i++) {
-            values[i+1] = chain.get(i).toString();
+    private boolean chainContainsUserCert(List<X509Certificate> chain) {
+        for (X509Certificate cert : chain) {
+            if (certStore.isUserAddedCertificate(cert)) {
+                return true;
+            }
         }
-        EventLogger.writeEvent(90100, values);
+        return false;
+    }
+
+    private void logPinFailure(List<X509Certificate> chain) {
+        PinFailureLogger.log(cn, chainContainsUserCert(chain), enforcing, chain);
     }
 }
 
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/TrustManagerImpl.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/TrustManagerImpl.java
index 48dbaba..92b709b 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/TrustManagerImpl.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/TrustManagerImpl.java
@@ -129,7 +129,7 @@ public final class TrustManagerImpl implements X509TrustManager {
             this.pinManager = manager;
         } else {
             try {
-                pinManager = new CertPinManager();
+                pinManager = new CertPinManager(trustedCertificateStoreLocal);
             } catch (PinManagerException e) {
                 throw new SecurityException("Could not initialize CertPinManager", e);
             }
@@ -236,7 +236,6 @@ public final class TrustManagerImpl implements X509TrustManager {
                 throw new CertificateException(e);
             }
             if (chainIsNotPinned) {
-                EventLogger.writeEvent(90102, chainContainsUserCert(wholeChain));
                 throw new CertificateException(new CertPathValidatorException(
                         "Certificate path is not properly pinned.", null, certPath, -1));
             }
@@ -398,13 +397,4 @@ public final class TrustManagerImpl implements X509TrustManager {
     @Override public X509Certificate[] getAcceptedIssuers() {
         return (acceptedIssuers != null) ? acceptedIssuers.clone() : acceptedIssuers(rootKeyStore);
     }
-
-    private boolean chainContainsUserCert(List<X509Certificate> chain) {
-        for (X509Certificate cert : chain) {
-            if (trustedCertificateStore.isUserAddedCertificate(cert)) {
-                return true;
-            }
-        }
-        return false;
-    }
 }
diff --git a/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/CertPinManagerTest.java b/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/CertPinManagerTest.java
index 7d37492..8359c99 100644
--- a/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/CertPinManagerTest.java
+++ b/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/CertPinManagerTest.java
@@ -92,7 +92,7 @@ public class CertPinManagerTest extends TestCase {
 
         // create the pinFile
         String path = writeTmpPinFile(shortEntry + "\n" + longEntry);
-        CertPinManager pf = new CertPinManager(path);
+        CertPinManager pf = new CertPinManager(path, new TrustedCertificateStore());
 
         // verify that the shorter chain doesn't work for a name matching the longer
         assertTrue("short chain long uri failed",
@@ -112,7 +112,7 @@ public class CertPinManagerTest extends TestCase {
         // set up the pinEntry with a bogus entry
         String entry = "*.google.com=";
         try {
-            new PinListEntry(entry);
+            new PinListEntry(entry, new TrustedCertificateStore());
             fail("Accepted an empty pin list entry.");
         } catch (PinEntryException expected) {
         }
@@ -122,7 +122,7 @@ public class CertPinManagerTest extends TestCase {
         // set up the pinEntry with a bogus entry
         String entry = null;
         try {
-            new PinListEntry(entry);
+            new PinListEntry(entry, new TrustedCertificateStore());
             fail("Accepted a basically wholly bogus entry.");
         } catch (NullPointerException expected) {
         }
@@ -131,7 +131,7 @@ public class CertPinManagerTest extends TestCase {
     public void testPinEntryEmpty() throws Exception {
         // set up the pinEntry with a bogus entry
         try {
-            new PinListEntry("");
+            new PinListEntry("", new TrustedCertificateStore());
             fail("Accepted an empty entry.");
         } catch (PinEntryException expected) {
         }
@@ -142,7 +142,7 @@ public class CertPinManagerTest extends TestCase {
         String shortEntry = "*.google.com=true|" + shortPin;
 
         // set up the pinEntry with a pinlist that doesn't match what we'll give it
-        PinListEntry e = new PinListEntry(shortEntry);
+        PinListEntry e = new PinListEntry(shortEntry, new TrustedCertificateStore());
         assertTrue("Not enforcing!", e.getEnforcing());
         // verify that it doesn't accept
         boolean retval = e.chainIsNotPinned(longChain);
@@ -154,7 +154,7 @@ public class CertPinManagerTest extends TestCase {
         String shortEntry = "*.google.com=true|" + shortPin;
 
         // set up the pinEntry with a pinlist that matches what we'll give it
-        PinListEntry e = new PinListEntry(shortEntry);
+        PinListEntry e = new PinListEntry(shortEntry, new TrustedCertificateStore());
         assertTrue("Not enforcing!", e.getEnforcing());
         // verify that it accepts
         boolean retval = e.chainIsNotPinned(shortChain);
@@ -166,7 +166,7 @@ public class CertPinManagerTest extends TestCase {
         String shortEntry = "*.google.com=false|" + shortPin;
 
         // set up the pinEntry with a pinlist that matches what we'll give it
-        PinListEntry e = new PinListEntry(shortEntry);
+        PinListEntry e = new PinListEntry(shortEntry, new TrustedCertificateStore());
         assertFalse("Enforcing!", e.getEnforcing());
         // verify that it accepts
         boolean retval = e.chainIsNotPinned(shortChain);
diff --git a/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/TrustManagerImplTest.java b/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/TrustManagerImplTest.java
index 97032d9..4be6242 100644
--- a/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/TrustManagerImplTest.java
+++ b/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/TrustManagerImplTest.java
@@ -151,7 +151,7 @@ public class TrustManagerImplTest extends TestCase {
         // write it to a pinfile
         String path = writeTmpPinFile(pinString);
         // build the certpinmanager
-        return new CertPinManager(path);
+        return new CertPinManager(path, new TrustedCertificateStore());
     }
 
     private void assertValid(X509Certificate[] chain, X509TrustManager tm) throws Exception {
-- 
cgit v1.1


From aeb2d41a75b5df69711b4dd5e4ec53190c14e657 Mon Sep 17 00:00:00 2001
From: Geremy Condra <gcondra@google.com>
Date: Tue, 18 Sep 2012 22:15:18 -0700
Subject: Add dummy DropBox to libcore.

Bug:7190096
Change-Id: Iacd3321153c53c80353e61d8626e8f435091c9d5
---
 luni/src/main/java/libcore/io/DropBox.java | 72 ++++++++++++++++++++++++++++++
 1 file changed, 72 insertions(+)
 create mode 100644 luni/src/main/java/libcore/io/DropBox.java

diff --git a/luni/src/main/java/libcore/io/DropBox.java b/luni/src/main/java/libcore/io/DropBox.java
new file mode 100644
index 0000000..7187427
--- /dev/null
+++ b/luni/src/main/java/libcore/io/DropBox.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed 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 libcore.io;
+
+public final class DropBox {
+
+    /**
+     * Hook for customizing how events are reported.
+     */
+    private static volatile Reporter REPORTER = new DefaultReporter();
+
+    /**
+     * Used to replace default Reporter for logging events. Must be non-null.
+     */
+    public static void setReporter(Reporter reporter) {
+        if (reporter == null) {
+            throw new NullPointerException("reporter == null");
+        }
+        REPORTER = reporter;
+    }
+
+    /**
+     * Returns non-null Reporter.
+     */
+    public static Reporter getReporter() {
+        return REPORTER;
+    }
+
+    /**
+     * Interface to allow customization of reporting behavior.
+     */
+    public static interface Reporter {
+        public void addData(String tag, byte[] data, int flags);
+        public void addText(String tag, String data);
+    }
+
+    /**
+     * Default Reporter which reports events to the log.
+     */
+    private static final class DefaultReporter implements Reporter {
+
+        public void addData(String tag, byte[] data, int flags) {
+            System.out.println(tag + ": " + Base64.encode(data));
+        }
+
+        public void addText(String tag, String data) {
+            System.out.println(tag + ": " + data);
+        }
+    }
+
+    public void addData(String tag, byte[] data, int flags) {
+        getReporter().addData(tag, data, flags);
+    }
+
+    public void addText(String tag, String data) {
+        getReporter().addText(tag, data);
+    }
+}
-- 
cgit v1.1


From 5ab2ad7ebf828d06710868f33458fb1fbe1aa50b Mon Sep 17 00:00:00 2001
From: Geremy Condra <gcondra@google.com>
Date: Wed, 19 Sep 2012 11:15:33 -0700
Subject: Migrate PinFailureLogger to use the DropBox.

Also change the DropBox add* methods to be static, since they can be.

Change-Id: Iedab6948754dfc0db5d432a918bdc6297e3b8f02
---
 luni/src/main/java/libcore/io/DropBox.java         |  4 ++--
 .../xnet/provider/jsse/PinFailureLogger.java       | 26 +++++++++++++++-------
 2 files changed, 20 insertions(+), 10 deletions(-)

diff --git a/luni/src/main/java/libcore/io/DropBox.java b/luni/src/main/java/libcore/io/DropBox.java
index 7187427..cf88106 100644
--- a/luni/src/main/java/libcore/io/DropBox.java
+++ b/luni/src/main/java/libcore/io/DropBox.java
@@ -62,11 +62,11 @@ public final class DropBox {
         }
     }
 
-    public void addData(String tag, byte[] data, int flags) {
+    public static void addData(String tag, byte[] data, int flags) {
         getReporter().addData(tag, data, flags);
     }
 
-    public void addText(String tag, String data) {
+    public static void addText(String tag, String data) {
         getReporter().addText(tag, data);
     }
 }
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/PinFailureLogger.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/PinFailureLogger.java
index 4878a9e..40b1838 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/PinFailureLogger.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/PinFailureLogger.java
@@ -16,9 +16,11 @@
 
 package org.apache.harmony.xnet.provider.jsse;
 
+import java.security.cert.CertificateEncodingException;
 import java.security.cert.X509Certificate;
 import java.util.List;
-import libcore.io.EventLogger;
+import libcore.io.Base64;
+import libcore.io.DropBox;
 
 public class PinFailureLogger {
 
@@ -42,14 +44,22 @@ public class PinFailureLogger {
     protected static synchronized void writeToLog(String cn, boolean chainContainsUserCert,
                                                   boolean pinIsEnforcing,
                                                   List<X509Certificate> chain) {
-        Object[] values = new Object[chain.size() + 3];
-        values[0] = cn;
-        values[1] = chainContainsUserCert;
-        values[2] = pinIsEnforcing;
-        for (int i=0; i < chain.size(); i++) {
-            values[i+3] = chain.get(i).toString();
+        StringBuilder sb = new StringBuilder();
+        sb.append(cn);
+        sb.append("|");
+        sb.append(chainContainsUserCert);
+        sb.append("|");
+        sb.append(pinIsEnforcing);
+        sb.append("|");
+        for (X509Certificate cert : chain) {
+            try {
+                sb.append(Base64.encode(cert.getEncoded()));
+            } catch (CertificateEncodingException e) {
+                sb.append("Error: could not encode certificate");
+            }
+            sb.append("|");
         }
-        EventLogger.writeEvent(90100, values);
+        DropBox.addText("cert_pin_failure", sb.toString());
     }
 
     protected static boolean timeToLog() {
-- 
cgit v1.1


From 7b5bf805d03c2b71266886fa75513400817de9f1 Mon Sep 17 00:00:00 2001
From: Geremy Condra <gcondra@google.com>
Date: Wed, 19 Sep 2012 13:03:08 -0700
Subject: Move null check for cert store to the consumer code.

This allows the check to operate if TrustManagerImpl gets a non-
AndroidCAStore cert store.

Bug:7190096
Change-Id: I7c55e48afdbee293e08a0594ad3957b4695a6415
---
 .../java/org/apache/harmony/xnet/provider/jsse/PinListEntry.java    | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/PinListEntry.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/PinListEntry.java
index 748606b..c05a391 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/PinListEntry.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/PinListEntry.java
@@ -60,9 +60,6 @@ public class PinListEntry {
         if (entry == null) {
             throw new NullPointerException("entry == null");
         }
-        if (store == null) {
-            throw new NullPointerException("store == null");
-        }
         certStore = store;
         // Examples:
         // *.google.com=true|34c8a0d...9e04ca05f,9e04ca05f...34c8a0d
@@ -140,6 +137,9 @@ public class PinListEntry {
     }
 
     private boolean chainContainsUserCert(List<X509Certificate> chain) {
+        if (certStore == null) {
+            return false;
+        }
         for (X509Certificate cert : chain) {
             if (certStore.isUserAddedCertificate(cert)) {
                 return true;
-- 
cgit v1.1


From 9473606aca0af1a6410b2ea396c8a6609cf16940 Mon Sep 17 00:00:00 2001
From: Geremy Condra <gcondra@google.com>
Date: Wed, 19 Sep 2012 16:17:58 -0700
Subject: Add cached trust anchors to the chain prior to checking pinning.

This avoids an issue where intermediate certs are assumed cached
rather than provided by the server.

Bug: 7195828
Change-Id: I44e033ddc40a7a259bac888bf2b873d9bb81becc
---
 .../xnet/provider/jsse/TrustManagerImpl.java       | 40 ++++++++++++++++++----
 .../xnet/provider/jsse/TrustManagerImplTest.java   | 21 ++++++++++++
 2 files changed, 54 insertions(+), 7 deletions(-)

diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/TrustManagerImpl.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/TrustManagerImpl.java
index 92b709b..0218249 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/TrustManagerImpl.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/TrustManagerImpl.java
@@ -214,17 +214,43 @@ public final class TrustManagerImpl implements X509TrustManager {
             throw new CertificateException(err);
         }
 
-        // get the cleaned up chain and trust anchors
-        Set<TrustAnchor> trustAnchors = new HashSet<TrustAnchor>();
-        X509Certificate[] newChain = cleanupCertChainAndFindTrustAnchors(chain, trustAnchors);
+        // get the cleaned up chain and trust anchor
+        Set<TrustAnchor> trustAnchor = new HashSet<TrustAnchor>(); // there can only be one!
+        X509Certificate[] newChain = cleanupCertChainAndFindTrustAnchors(chain, trustAnchor);
 
-        // build the whole chain including all the trust anchors
+        // add the first trust anchor to the chain, which may be an intermediate
         List<X509Certificate> wholeChain = new ArrayList<X509Certificate>();
         wholeChain.addAll(Arrays.asList(newChain));
-        for (TrustAnchor trust : trustAnchors) {
+        // trustAnchor is actually just a single element
+        for (TrustAnchor trust : trustAnchor) {
             wholeChain.add(trust.getTrustedCert());
         }
 
+        // add all the cached certificates from the cert index, avoiding loops
+        // this gives us a full chain from leaf to root, which we use for cert pinning and pass
+        // back out to callers when we return.
+        X509Certificate last = wholeChain.get(wholeChain.size() - 1);
+        while (true) {
+            TrustAnchor cachedTrust = trustedCertificateIndex.findByIssuerAndSignature(last);
+            // the cachedTrust can be null if there isn't anything in the index or if a user has
+            // trusted a non-self-signed cert.
+            if (cachedTrust == null) {
+                break;
+            }
+
+            // at this point we have a cached trust anchor, but don't know if its one we got from
+            // the server. Extract the cert, compare it to the last element in the chain, and add it
+            // if we haven't seen it before.
+            X509Certificate next = cachedTrust.getTrustedCert();
+            if (next != last) {
+                wholeChain.add(next);
+                last = next;
+            } else {
+                // if next == last then we found a self-signed cert and the chain is done
+                break;
+            }
+        }
+
         // build the cert path from the array of certs sans trust anchors
         CertPath certPath = factory.generateCertPath(Arrays.asList(newChain));
 
@@ -246,13 +272,13 @@ public final class TrustManagerImpl implements X509TrustManager {
             return wholeChain;
         }
 
-        if (trustAnchors.isEmpty()) {
+        if (trustAnchor.isEmpty()) {
             throw new CertificateException(new CertPathValidatorException(
                     "Trust anchor for certification path not found.", null, certPath, -1));
         }
 
         try {
-            PKIXParameters params = new PKIXParameters(trustAnchors);
+            PKIXParameters params = new PKIXParameters(trustAnchor);
             params.setRevocationEnabled(false);
             validator.validate(certPath, params);
             // Add intermediate CAs to the index to tolerate sites
diff --git a/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/TrustManagerImplTest.java b/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/TrustManagerImplTest.java
index 4be6242..fe5f4f0 100644
--- a/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/TrustManagerImplTest.java
+++ b/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/TrustManagerImplTest.java
@@ -98,6 +98,27 @@ public class TrustManagerImplTest extends TestCase {
         assertValid(chain1, tm);
     }
 
+    public void testGetFullChain() throws Exception {
+        // build the trust manager
+        KeyStore.PrivateKeyEntry pke = TestKeyStore.getServer().getPrivateKey("RSA", "RSA");
+        X509Certificate[] chain3 = (X509Certificate[])pke.getCertificateChain();
+        X509Certificate root = chain3[2];
+        X509TrustManager tm = trustManager(root);
+
+        // build the chains we'll use for testing
+        X509Certificate intermediate = chain3[1];
+        X509Certificate server = chain3[0];
+        X509Certificate[] chain2 =  new X509Certificate[] { server, intermediate };
+        X509Certificate[] chain1 =  new X509Certificate[] { server };
+
+        assertTrue(tm instanceof TrustManagerImpl);
+        TrustManagerImpl tmi = (TrustManagerImpl) tm;
+        List<X509Certificate> certs = tmi.checkServerTrusted(chain2, "RSA", "purple.com");
+        assertEquals(Arrays.asList(chain3), certs);
+        certs = tmi.checkServerTrusted(chain1, "RSA", "purple.com");
+        assertEquals(Arrays.asList(chain3), certs);
+    }
+
     public void testCertPinning() throws Exception {
         // chain3 should be server/intermediate/root
         KeyStore.PrivateKeyEntry pke = TestKeyStore.getServer().getPrivateKey("RSA", "RSA");
-- 
cgit v1.1


From e6281f0d5775a3d61d9ec27d29f32c170f05027b Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Thu, 20 Sep 2012 13:25:55 -0700
Subject: Remove obsolete ThirdPartyProject.prop files.

Change-Id: I5288c5c1f6ce094bcac2792f6fa7fc6a455f756a
---
 ThirdPartyProject.prop                               | 9 ---------
 luni/src/main/java/org/xml/ThirdPartyProject.prop    | 9 ---------
 xml/src/main/java/org/kxml2/ThirdPartyProject.prop   | 9 ---------
 xml/src/main/java/org/xmlpull/ThirdPartyProject.prop | 9 ---------
 4 files changed, 36 deletions(-)
 delete mode 100644 ThirdPartyProject.prop
 delete mode 100644 luni/src/main/java/org/xml/ThirdPartyProject.prop
 delete mode 100644 xml/src/main/java/org/kxml2/ThirdPartyProject.prop
 delete mode 100644 xml/src/main/java/org/xmlpull/ThirdPartyProject.prop

diff --git a/ThirdPartyProject.prop b/ThirdPartyProject.prop
deleted file mode 100644
index 9f828fa..0000000
--- a/ThirdPartyProject.prop
+++ /dev/null
@@ -1,9 +0,0 @@
-# Copyright 2010 Google Inc. All Rights Reserved.
-#Fri Jul 16 10:03:08 PDT 2010
-currentVersion=5.0M10
-version=Unknown
-isNative=false
-name=apache_harmony
-keywords=apache harmony
-onDevice=true
-homepage=http\://harmony.apache.org/
diff --git a/luni/src/main/java/org/xml/ThirdPartyProject.prop b/luni/src/main/java/org/xml/ThirdPartyProject.prop
deleted file mode 100644
index b8ac0da..0000000
--- a/luni/src/main/java/org/xml/ThirdPartyProject.prop
+++ /dev/null
@@ -1,9 +0,0 @@
-# Copyright 2010 Google Inc. All Rights Reserved.
-#Fri Jul 16 10:03:09 PDT 2010
-currentVersion=2.0.2
-version=2.0.2
-isNative=false
-name=xml_sax_parser
-keywords=xml sax parser
-onDevice=true
-homepage=http\://www.saxproject.org
diff --git a/xml/src/main/java/org/kxml2/ThirdPartyProject.prop b/xml/src/main/java/org/kxml2/ThirdPartyProject.prop
deleted file mode 100644
index aabb1c7..0000000
--- a/xml/src/main/java/org/kxml2/ThirdPartyProject.prop
+++ /dev/null
@@ -1,9 +0,0 @@
-# Copyright 2010 Google Inc. All Rights Reserved.
-#Fri Jul 16 10:03:09 PDT 2010
-currentVersion=2.3.0
-version=Unknown
-isNative=false
-name=kxml
-keywords=kxml
-onDevice=true
-homepage=http\://kxml.sourceforge.net/
diff --git a/xml/src/main/java/org/xmlpull/ThirdPartyProject.prop b/xml/src/main/java/org/xmlpull/ThirdPartyProject.prop
deleted file mode 100644
index 9ccbf09..0000000
--- a/xml/src/main/java/org/xmlpull/ThirdPartyProject.prop
+++ /dev/null
@@ -1,9 +0,0 @@
-# Copyright 2010 Google Inc. All Rights Reserved.
-#Fri Jul 16 10:03:09 PDT 2010
-currentVersion=1.1.3.4c
-version=Unknown
-isNative=false
-name=xml_pull_parser
-keywords=xml pull parser
-onDevice=true
-homepage=http\://xmlpull.org
-- 
cgit v1.1


From 34a3a0501220dd62b88ddb4a355bad46b15c25a2 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Thu, 20 Sep 2012 15:46:51 -0700
Subject: Fix a native memory leak in SimpleDateFormat cloning.

We didn't use the regular finalization idiom in NativeDecimalFormat because
Formatter used to create a lot of these objects, and we wanted to be able to
close them manually rather than clogging up the GC. We've since rewritten
the Formatter code so this is no longer relevant, but we left the finalization
in the wrong class.

Tested with a "while (true) sdf.clone();" loop and ps(1).

Bug: http://code.google.com/p/android/issues/detail?id=37607
Change-Id: I0c435edf8c1bced00ebf04bd7187883344e971e7
---
 luni/src/main/java/java/text/DateFormat.java       |   4 -
 luni/src/main/java/java/text/DecimalFormat.java    | 154 ++++++++++-----------
 luni/src/main/java/java/text/NumberFormat.java     |   6 +-
 luni/src/main/java/java/text/SimpleDateFormat.java |   3 -
 .../main/java/libcore/icu/NativeDecimalFormat.java |  42 +++---
 5 files changed, 94 insertions(+), 115 deletions(-)

diff --git a/luni/src/main/java/java/text/DateFormat.java b/luni/src/main/java/java/text/DateFormat.java
index 4055d20..b45e699 100644
--- a/luni/src/main/java/java/text/DateFormat.java
+++ b/luni/src/main/java/java/text/DateFormat.java
@@ -286,10 +286,6 @@ public abstract class DateFormat extends Format {
 
     /**
      * Returns a new instance of {@code DateFormat} with the same properties.
-     *
-     * @return a shallow copy of this {@code DateFormat}.
-     *
-     * @see java.lang.Cloneable
      */
     @Override
     public Object clone() {
diff --git a/luni/src/main/java/java/text/DecimalFormat.java b/luni/src/main/java/java/text/DecimalFormat.java
index eded6a8..948bec1 100644
--- a/luni/src/main/java/java/text/DecimalFormat.java
+++ b/luni/src/main/java/java/text/DecimalFormat.java
@@ -501,16 +501,7 @@ public class DecimalFormat extends NumberFormat {
 
     private transient DecimalFormatSymbols symbols;
 
-    private transient NativeDecimalFormat dform;
-    private final Object finalizerGuardian = new Object() {
-        @Override protected void finalize() throws Throwable {
-            try {
-                dform.close();
-            } finally {
-                super.finalize();
-            }
-        }
-    };
+    private transient NativeDecimalFormat ndf;
 
     private transient RoundingMode roundingMode = RoundingMode.HALF_EVEN;
 
@@ -562,14 +553,14 @@ public class DecimalFormat extends NumberFormat {
 
     private void initNative(String pattern) {
         try {
-            this.dform = new NativeDecimalFormat(pattern, symbols);
+            this.ndf = new NativeDecimalFormat(pattern, symbols);
         } catch (IllegalArgumentException ex) {
             throw new IllegalArgumentException(pattern);
         }
-        super.setMaximumFractionDigits(dform.getMaximumFractionDigits());
-        super.setMaximumIntegerDigits(dform.getMaximumIntegerDigits());
-        super.setMinimumFractionDigits(dform.getMinimumFractionDigits());
-        super.setMinimumIntegerDigits(dform.getMinimumIntegerDigits());
+        super.setMaximumFractionDigits(ndf.getMaximumFractionDigits());
+        super.setMaximumIntegerDigits(ndf.getMaximumIntegerDigits());
+        super.setMinimumFractionDigits(ndf.getMinimumFractionDigits());
+        super.setMinimumIntegerDigits(ndf.getMinimumIntegerDigits());
     }
 
     /**
@@ -582,7 +573,7 @@ public class DecimalFormat extends NumberFormat {
      *            if the pattern cannot be parsed.
      */
     public void applyLocalizedPattern(String pattern) {
-        dform.applyLocalizedPattern(pattern);
+        ndf.applyLocalizedPattern(pattern);
     }
 
     /**
@@ -595,20 +586,17 @@ public class DecimalFormat extends NumberFormat {
      *            if the pattern cannot be parsed.
      */
     public void applyPattern(String pattern) {
-        dform.applyPattern(pattern);
+        ndf.applyPattern(pattern);
     }
 
     /**
      * Returns a new instance of {@code DecimalFormat} with the same pattern and
-     * properties as this decimal format.
-     *
-     * @return a shallow copy of this decimal format.
-     * @see java.lang.Cloneable
+     * properties.
      */
     @Override
     public Object clone() {
         DecimalFormat clone = (DecimalFormat) super.clone();
-        clone.dform = (NativeDecimalFormat) dform.clone();
+        clone.ndf = (NativeDecimalFormat) ndf.clone();
         clone.symbols = (DecimalFormatSymbols) symbols.clone();
         return clone;
     }
@@ -633,7 +621,7 @@ public class DecimalFormat extends NumberFormat {
             return false;
         }
         DecimalFormat other = (DecimalFormat) object;
-        return (this.dform == null ? other.dform == null : this.dform.equals(other.dform)) &&
+        return (this.ndf == null ? other.ndf == null : this.ndf.equals(other.ndf)) &&
                 getDecimalFormatSymbols().equals(other.getDecimalFormatSymbols());
     }
 
@@ -656,7 +644,7 @@ public class DecimalFormat extends NumberFormat {
         if (object == null) {
             throw new NullPointerException("object == null");
         }
-        return dform.formatToCharacterIterator(object);
+        return ndf.formatToCharacterIterator(object);
     }
 
     private void checkBufferAndFieldPosition(StringBuffer buffer, FieldPosition position) {
@@ -686,14 +674,14 @@ public class DecimalFormat extends NumberFormat {
                 setRoundingMode(RoundingMode.UNNECESSARY);
             }
         }
-        buffer.append(dform.formatDouble(value, position));
+        buffer.append(ndf.formatDouble(value, position));
         return buffer;
     }
 
     @Override
     public StringBuffer format(long value, StringBuffer buffer, FieldPosition position) {
         checkBufferAndFieldPosition(buffer, position);
-        buffer.append(dform.formatLong(value, position));
+        buffer.append(ndf.formatLong(value, position));
         return buffer;
     }
 
@@ -703,12 +691,12 @@ public class DecimalFormat extends NumberFormat {
         if (number instanceof BigInteger) {
             BigInteger bigInteger = (BigInteger) number;
             char[] chars = (bigInteger.bitLength() < 64)
-                    ? dform.formatLong(bigInteger.longValue(), position)
-                    : dform.formatBigInteger(bigInteger, position);
+                    ? ndf.formatLong(bigInteger.longValue(), position)
+                    : ndf.formatBigInteger(bigInteger, position);
             buffer.append(chars);
             return buffer;
         } else if (number instanceof BigDecimal) {
-            buffer.append(dform.formatBigDecimal((BigDecimal) number, position));
+            buffer.append(ndf.formatBigDecimal((BigDecimal) number, position));
             return buffer;
         }
         return super.format(number, buffer, position);
@@ -743,7 +731,7 @@ public class DecimalFormat extends NumberFormat {
      * @return the number of digits grouped together.
      */
     public int getGroupingSize() {
-        return dform.getGroupingSize();
+        return ndf.getGroupingSize();
     }
 
     /**
@@ -753,7 +741,7 @@ public class DecimalFormat extends NumberFormat {
      * @return the multiplier.
      */
     public int getMultiplier() {
-        return dform.getMultiplier();
+        return ndf.getMultiplier();
     }
 
     /**
@@ -762,7 +750,7 @@ public class DecimalFormat extends NumberFormat {
      * @return the negative prefix.
      */
     public String getNegativePrefix() {
-        return dform.getNegativePrefix();
+        return ndf.getNegativePrefix();
     }
 
     /**
@@ -771,7 +759,7 @@ public class DecimalFormat extends NumberFormat {
      * @return the negative suffix.
      */
     public String getNegativeSuffix() {
-        return dform.getNegativeSuffix();
+        return ndf.getNegativeSuffix();
     }
 
     /**
@@ -780,7 +768,7 @@ public class DecimalFormat extends NumberFormat {
      * @return the positive prefix.
      */
     public String getPositivePrefix() {
-        return dform.getPositivePrefix();
+        return ndf.getPositivePrefix();
     }
 
     /**
@@ -789,12 +777,12 @@ public class DecimalFormat extends NumberFormat {
      * @return the positive suffix.
      */
     public String getPositiveSuffix() {
-        return dform.getPositiveSuffix();
+        return ndf.getPositiveSuffix();
     }
 
     @Override
     public int hashCode() {
-        return dform.hashCode();
+        return getPositivePrefix().hashCode();
     }
 
     /**
@@ -805,7 +793,7 @@ public class DecimalFormat extends NumberFormat {
      *         {@code false} otherwise.
      */
     public boolean isDecimalSeparatorAlwaysShown() {
-        return dform.isDecimalSeparatorAlwaysShown();
+        return ndf.isDecimalSeparatorAlwaysShown();
     }
 
     /**
@@ -817,7 +805,7 @@ public class DecimalFormat extends NumberFormat {
      *         {@code Double}.
      */
     public boolean isParseBigDecimal() {
-        return dform.isParseBigDecimal();
+        return ndf.isParseBigDecimal();
     }
 
     /**
@@ -838,7 +826,7 @@ public class DecimalFormat extends NumberFormat {
         // In this implementation, NativeDecimalFormat is wrapped to
         // fulfill most of the format and parse feature. And this method is
         // delegated to the wrapped instance of NativeDecimalFormat.
-        dform.setParseIntegerOnly(value);
+        ndf.setParseIntegerOnly(value);
     }
 
     /**
@@ -850,7 +838,7 @@ public class DecimalFormat extends NumberFormat {
      */
     @Override
     public boolean isParseIntegerOnly() {
-        return dform.isParseIntegerOnly();
+        return ndf.isParseIntegerOnly();
     }
 
     private static final Double NEGATIVE_ZERO_DOUBLE = new Double(-0.0);
@@ -880,7 +868,7 @@ public class DecimalFormat extends NumberFormat {
      */
     @Override
     public Number parse(String string, ParsePosition position) {
-        Number number = dform.parse(string, position);
+        Number number = ndf.parse(string, position);
         if (number == null) {
             return null;
         }
@@ -918,7 +906,7 @@ public class DecimalFormat extends NumberFormat {
         if (value != null) {
             // The Java object is canonical, and we copy down to native code.
             this.symbols = (DecimalFormatSymbols) value.clone();
-            dform.setDecimalFormatSymbols(this.symbols);
+            ndf.setDecimalFormatSymbols(this.symbols);
         }
     }
 
@@ -932,7 +920,7 @@ public class DecimalFormat extends NumberFormat {
      */
     @Override
     public void setCurrency(Currency currency) {
-        dform.setCurrency(Currency.getInstance(currency.getCurrencyCode()));
+        ndf.setCurrency(Currency.getInstance(currency.getCurrencyCode()));
         symbols.setCurrency(currency);
     }
 
@@ -945,7 +933,7 @@ public class DecimalFormat extends NumberFormat {
      *            formatted; {@code false} otherwise.
      */
     public void setDecimalSeparatorAlwaysShown(boolean value) {
-        dform.setDecimalSeparatorAlwaysShown(value);
+        ndf.setDecimalSeparatorAlwaysShown(value);
     }
 
     /**
@@ -957,7 +945,7 @@ public class DecimalFormat extends NumberFormat {
      *            the number of digits grouped together.
      */
     public void setGroupingSize(int value) {
-        dform.setGroupingSize(value);
+        ndf.setGroupingSize(value);
     }
 
     /**
@@ -969,7 +957,7 @@ public class DecimalFormat extends NumberFormat {
      */
     @Override
     public void setGroupingUsed(boolean value) {
-        dform.setGroupingUsed(value);
+        ndf.setGroupingUsed(value);
     }
 
     /**
@@ -979,7 +967,7 @@ public class DecimalFormat extends NumberFormat {
      */
     @Override
     public boolean isGroupingUsed() {
-        return dform.isGroupingUsed();
+        return ndf.isGroupingUsed();
     }
 
     /**
@@ -992,7 +980,7 @@ public class DecimalFormat extends NumberFormat {
     @Override
     public void setMaximumFractionDigits(int value) {
         super.setMaximumFractionDigits(value);
-        dform.setMaximumFractionDigits(getMaximumFractionDigits());
+        ndf.setMaximumFractionDigits(getMaximumFractionDigits());
         // Changing the maximum fraction digits needs to update ICU4C's rounding configuration.
         setRoundingMode(roundingMode);
     }
@@ -1007,7 +995,7 @@ public class DecimalFormat extends NumberFormat {
     @Override
     public void setMaximumIntegerDigits(int value) {
         super.setMaximumIntegerDigits(value);
-        dform.setMaximumIntegerDigits(getMaximumIntegerDigits());
+        ndf.setMaximumIntegerDigits(getMaximumIntegerDigits());
     }
 
     /**
@@ -1020,7 +1008,7 @@ public class DecimalFormat extends NumberFormat {
     @Override
     public void setMinimumFractionDigits(int value) {
         super.setMinimumFractionDigits(value);
-        dform.setMinimumFractionDigits(getMinimumFractionDigits());
+        ndf.setMinimumFractionDigits(getMinimumFractionDigits());
     }
 
     /**
@@ -1033,7 +1021,7 @@ public class DecimalFormat extends NumberFormat {
     @Override
     public void setMinimumIntegerDigits(int value) {
         super.setMinimumIntegerDigits(value);
-        dform.setMinimumIntegerDigits(getMinimumIntegerDigits());
+        ndf.setMinimumIntegerDigits(getMinimumIntegerDigits());
     }
 
     /**
@@ -1044,7 +1032,7 @@ public class DecimalFormat extends NumberFormat {
      *            the multiplier.
      */
     public void setMultiplier(int value) {
-        dform.setMultiplier(value);
+        ndf.setMultiplier(value);
     }
 
     /**
@@ -1054,7 +1042,7 @@ public class DecimalFormat extends NumberFormat {
      *            the negative prefix.
      */
     public void setNegativePrefix(String value) {
-        dform.setNegativePrefix(value);
+        ndf.setNegativePrefix(value);
     }
 
     /**
@@ -1064,7 +1052,7 @@ public class DecimalFormat extends NumberFormat {
      *            the negative suffix.
      */
     public void setNegativeSuffix(String value) {
-        dform.setNegativeSuffix(value);
+        ndf.setNegativeSuffix(value);
     }
 
     /**
@@ -1074,7 +1062,7 @@ public class DecimalFormat extends NumberFormat {
      *            the positive prefix.
      */
     public void setPositivePrefix(String value) {
-        dform.setPositivePrefix(value);
+        ndf.setPositivePrefix(value);
     }
 
     /**
@@ -1084,7 +1072,7 @@ public class DecimalFormat extends NumberFormat {
      *            the positive suffix.
      */
     public void setPositiveSuffix(String value) {
-        dform.setPositiveSuffix(value);
+        ndf.setPositiveSuffix(value);
     }
 
     /**
@@ -1096,7 +1084,7 @@ public class DecimalFormat extends NumberFormat {
      *            {@code BigDecimal}; {@code false} otherwise.
      */
     public void setParseBigDecimal(boolean newValue) {
-        dform.setParseBigDecimal(newValue);
+        ndf.setParseBigDecimal(newValue);
     }
 
     /**
@@ -1106,7 +1094,7 @@ public class DecimalFormat extends NumberFormat {
      * @return the localized pattern.
      */
     public String toLocalizedPattern() {
-        return dform.toLocalizedPattern();
+        return ndf.toLocalizedPattern();
     }
 
     /**
@@ -1116,7 +1104,7 @@ public class DecimalFormat extends NumberFormat {
      * @return the non-localized pattern.
      */
     public String toPattern() {
-        return dform.toPattern();
+        return ndf.toPattern();
     }
 
     // the fields list to be serialized
@@ -1157,27 +1145,27 @@ public class DecimalFormat extends NumberFormat {
      */
     private void writeObject(ObjectOutputStream stream) throws IOException, ClassNotFoundException {
         ObjectOutputStream.PutField fields = stream.putFields();
-        fields.put("positivePrefix", dform.getPositivePrefix());
-        fields.put("positiveSuffix", dform.getPositiveSuffix());
-        fields.put("negativePrefix", dform.getNegativePrefix());
-        fields.put("negativeSuffix", dform.getNegativeSuffix());
+        fields.put("positivePrefix", ndf.getPositivePrefix());
+        fields.put("positiveSuffix", ndf.getPositiveSuffix());
+        fields.put("negativePrefix", ndf.getNegativePrefix());
+        fields.put("negativeSuffix", ndf.getNegativeSuffix());
         fields.put("posPrefixPattern", (String) null);
         fields.put("posSuffixPattern", (String) null);
         fields.put("negPrefixPattern", (String) null);
         fields.put("negSuffixPattern", (String) null);
-        fields.put("multiplier", dform.getMultiplier());
-        fields.put("groupingSize", (byte) dform.getGroupingSize());
-        fields.put("groupingUsed", dform.isGroupingUsed());
-        fields.put("decimalSeparatorAlwaysShown", dform.isDecimalSeparatorAlwaysShown());
-        fields.put("parseBigDecimal", dform.isParseBigDecimal());
+        fields.put("multiplier", ndf.getMultiplier());
+        fields.put("groupingSize", (byte) ndf.getGroupingSize());
+        fields.put("groupingUsed", ndf.isGroupingUsed());
+        fields.put("decimalSeparatorAlwaysShown", ndf.isDecimalSeparatorAlwaysShown());
+        fields.put("parseBigDecimal", ndf.isParseBigDecimal());
         fields.put("roundingMode", roundingMode);
         fields.put("symbols", symbols);
         fields.put("useExponentialNotation", false);
         fields.put("minExponentDigits", (byte) 0);
-        fields.put("maximumIntegerDigits", dform.getMaximumIntegerDigits());
-        fields.put("minimumIntegerDigits", dform.getMinimumIntegerDigits());
-        fields.put("maximumFractionDigits", dform.getMaximumFractionDigits());
-        fields.put("minimumFractionDigits", dform.getMinimumFractionDigits());
+        fields.put("maximumIntegerDigits", ndf.getMaximumIntegerDigits());
+        fields.put("minimumIntegerDigits", ndf.getMinimumIntegerDigits());
+        fields.put("maximumFractionDigits", ndf.getMaximumFractionDigits());
+        fields.put("minimumFractionDigits", ndf.getMinimumFractionDigits());
         fields.put("serialVersionOnStream", 4);
         stream.writeFields();
     }
@@ -1198,14 +1186,14 @@ public class DecimalFormat extends NumberFormat {
         this.symbols = (DecimalFormatSymbols) fields.get("symbols", null);
 
         initNative("");
-        dform.setPositivePrefix((String) fields.get("positivePrefix", ""));
-        dform.setPositiveSuffix((String) fields.get("positiveSuffix", ""));
-        dform.setNegativePrefix((String) fields.get("negativePrefix", "-"));
-        dform.setNegativeSuffix((String) fields.get("negativeSuffix", ""));
-        dform.setMultiplier(fields.get("multiplier", 1));
-        dform.setGroupingSize(fields.get("groupingSize", (byte) 3));
-        dform.setGroupingUsed(fields.get("groupingUsed", true));
-        dform.setDecimalSeparatorAlwaysShown(fields.get("decimalSeparatorAlwaysShown", false));
+        ndf.setPositivePrefix((String) fields.get("positivePrefix", ""));
+        ndf.setPositiveSuffix((String) fields.get("positiveSuffix", ""));
+        ndf.setNegativePrefix((String) fields.get("negativePrefix", "-"));
+        ndf.setNegativeSuffix((String) fields.get("negativeSuffix", ""));
+        ndf.setMultiplier(fields.get("multiplier", 1));
+        ndf.setGroupingSize(fields.get("groupingSize", (byte) 3));
+        ndf.setGroupingUsed(fields.get("groupingUsed", true));
+        ndf.setDecimalSeparatorAlwaysShown(fields.get("decimalSeparatorAlwaysShown", false));
 
         setRoundingMode((RoundingMode) fields.get("roundingMode", RoundingMode.HALF_EVEN));
 
@@ -1218,8 +1206,8 @@ public class DecimalFormat extends NumberFormat {
         // behavior in this area is, and it's not obvious how we can second-guess ICU (or tell
         // it to just do exactly what we ask). We only need to do this with maximumIntegerDigits
         // because ICU doesn't seem to have its own ideas about the other options.
-        dform.setMaximumIntegerDigits(maximumIntegerDigits);
-        super.setMaximumIntegerDigits(dform.getMaximumIntegerDigits());
+        ndf.setMaximumIntegerDigits(maximumIntegerDigits);
+        super.setMaximumIntegerDigits(ndf.getMaximumIntegerDigits());
 
         setMinimumIntegerDigits(minimumIntegerDigits);
         setMinimumFractionDigits(minimumFractionDigits);
@@ -1253,7 +1241,7 @@ public class DecimalFormat extends NumberFormat {
         this.roundingMode = roundingMode;
         if (roundingMode != RoundingMode.UNNECESSARY) { // ICU4C doesn't support UNNECESSARY.
             double roundingIncrement = 1.0 / Math.pow(10, Math.max(0, getMaximumFractionDigits()));
-            dform.setRoundingMode(roundingMode, roundingIncrement);
+            ndf.setRoundingMode(roundingMode, roundingIncrement);
         }
     }
 }
diff --git a/luni/src/main/java/java/text/NumberFormat.java b/luni/src/main/java/java/text/NumberFormat.java
index 070174b..c285e3d 100644
--- a/luni/src/main/java/java/text/NumberFormat.java
+++ b/luni/src/main/java/java/text/NumberFormat.java
@@ -165,11 +165,7 @@ public abstract class NumberFormat extends Format {
     }
 
     /**
-     * Returns a new {@code NumberFormat} with the same properties as this
-     * {@code NumberFormat}.
-     *
-     * @return a shallow copy of this {@code NumberFormat}.
-     * @see java.lang.Cloneable
+     * Returns a new {@code NumberFormat} with the same properties.
      */
     @Override
     public Object clone() {
diff --git a/luni/src/main/java/java/text/SimpleDateFormat.java b/luni/src/main/java/java/text/SimpleDateFormat.java
index da5af85..f682c0b 100644
--- a/luni/src/main/java/java/text/SimpleDateFormat.java
+++ b/luni/src/main/java/java/text/SimpleDateFormat.java
@@ -411,9 +411,6 @@ public class SimpleDateFormat extends DateFormat {
     /**
      * Returns a new {@code SimpleDateFormat} with the same pattern and
      * properties as this simple date format.
-     *
-     * @return a shallow copy of this simple date format.
-     * @see java.lang.Cloneable
      */
     @Override
     public Object clone() {
diff --git a/luni/src/main/java/libcore/icu/NativeDecimalFormat.java b/luni/src/main/java/libcore/icu/NativeDecimalFormat.java
index 74775e5..f6b5214 100644
--- a/luni/src/main/java/libcore/icu/NativeDecimalFormat.java
+++ b/luni/src/main/java/libcore/icu/NativeDecimalFormat.java
@@ -29,7 +29,7 @@ import java.text.ParsePosition;
 import java.util.Currency;
 import java.util.NoSuchElementException;
 
-public final class NativeDecimalFormat {
+public final class NativeDecimalFormat implements Cloneable {
     /**
      * Constants corresponding to the native type UNumberFormatSymbol, for setSymbol.
      */
@@ -144,22 +144,6 @@ public final class NativeDecimalFormat {
         this.lastPattern = pattern;
     }
 
-    // Used to implement clone.
-    private NativeDecimalFormat(NativeDecimalFormat other) {
-        this.address = cloneImpl(other.address);
-        this.lastPattern = other.lastPattern;
-        this.negPrefNull = other.negPrefNull;
-        this.negSuffNull = other.negSuffNull;
-        this.posPrefNull = other.posPrefNull;
-        this.posSuffNull = other.posSuffNull;
-    }
-
-    // TODO: remove this and just have DecimalFormat.hashCode do the right thing itself.
-    @Override
-    public int hashCode() {
-        return this.getPositivePrefix().hashCode();
-    }
-
     public synchronized void close() {
         if (address != 0) {
             close(address);
@@ -167,9 +151,27 @@ public final class NativeDecimalFormat {
         }
     }
 
-    @Override
-    public Object clone() {
-        return new NativeDecimalFormat(this);
+    @Override protected void finalize() throws Throwable {
+        try {
+            close();
+        } finally {
+            super.finalize();
+        }
+    }
+
+    @Override public Object clone() {
+        try {
+            NativeDecimalFormat clone = (NativeDecimalFormat) super.clone();
+            clone.address = cloneImpl(address);
+            clone.lastPattern = lastPattern;
+            clone.negPrefNull = negPrefNull;
+            clone.negSuffNull = negSuffNull;
+            clone.posPrefNull = posPrefNull;
+            clone.posSuffNull = posSuffNull;
+            return clone;
+        } catch (CloneNotSupportedException unexpected) {
+            throw new AssertionError(unexpected);
+        }
     }
 
     /**
-- 
cgit v1.1


From 66e8297c70daaf001ca199e4e4ad3ba5283396d2 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Thu, 20 Sep 2012 18:47:03 -0700
Subject: Fix LocaleData.toString once and for all.

Change-Id: I207a3226470557ac26caba165ef35f5df6859273
---
 luni/src/main/java/libcore/icu/LocaleData.java | 40 +---------------
 luni/src/main/java/libcore/util/Objects.java   | 64 ++++++++++++++++++++++++++
 2 files changed, 66 insertions(+), 38 deletions(-)

diff --git a/luni/src/main/java/libcore/icu/LocaleData.java b/luni/src/main/java/libcore/icu/LocaleData.java
index 97d5d30..8ec2294 100644
--- a/luni/src/main/java/libcore/icu/LocaleData.java
+++ b/luni/src/main/java/libcore/icu/LocaleData.java
@@ -20,6 +20,7 @@ import java.text.DateFormat;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Locale;
+import libcore.util.Objects;
 
 /**
  * Passes locale-specific from ICU native code to Java.
@@ -129,44 +130,7 @@ public final class LocaleData {
     }
 
     @Override public String toString() {
-        return "LocaleData[" +
-                "firstDayOfWeek=" + firstDayOfWeek + "," +
-                "minimalDaysInFirstWeek=" + minimalDaysInFirstWeek + "," +
-                "amPm=" + Arrays.toString(amPm) + "," +
-                "eras=" + Arrays.toString(eras) + "," +
-                "longMonthNames=" + Arrays.toString(longMonthNames) + "," +
-                "shortMonthNames=" + Arrays.toString(shortMonthNames) + "," +
-                "longStandAloneMonthNames=" + Arrays.toString(longStandAloneMonthNames) + "," +
-                "shortStandAloneMonthNames=" + Arrays.toString(shortStandAloneMonthNames) + "," +
-                "longWeekdayNames=" + Arrays.toString(longWeekdayNames) + "," +
-                "shortWeekdayNames=" + Arrays.toString(shortWeekdayNames) + "," +
-                "longStandAloneWeekdayNames=" + Arrays.toString(longStandAloneWeekdayNames) + "," +
-                "shortStandAloneWeekdayNames=" + Arrays.toString(shortStandAloneWeekdayNames) + "," +
-                "fullTimeFormat=" + fullTimeFormat + "," +
-                "longTimeFormat=" + longTimeFormat + "," +
-                "mediumTimeFormat=" + mediumTimeFormat + "," +
-                "shortTimeFormat=" + shortTimeFormat + "," +
-                "fullDateFormat=" + fullDateFormat + "," +
-                "longDateFormat=" + longDateFormat + "," +
-                "mediumDateFormat=" + mediumDateFormat + "," +
-                "shortDateFormat=" + shortDateFormat + "," +
-                "zeroDigit=" + zeroDigit + "," +
-                "decimalSeparator=" + decimalSeparator + "," +
-                "groupingSeparator=" + groupingSeparator + "," +
-                "patternSeparator=" + patternSeparator + "," +
-                "percent=" + percent + "," +
-                "perMill=" + perMill + "," +
-                "monetarySeparator=" + monetarySeparator + "," +
-                "minusSign=" + minusSign + "," +
-                "exponentSeparator=" + exponentSeparator + "," +
-                "infinity=" + infinity + "," +
-                "NaN=" + NaN + "," +
-                "currencySymbol=" + currencySymbol + "," +
-                "internationalCurrencySymbol=" + internationalCurrencySymbol + "," +
-                "numberPattern=" + numberPattern + "," +
-                "integerPattern=" + integerPattern + "," +
-                "currencyPattern=" + currencyPattern + "," +
-                "percentPattern=" + percentPattern + "]";
+        return Objects.toString(this);
     }
 
     public String getDateFormat(int style) {
diff --git a/luni/src/main/java/libcore/util/Objects.java b/luni/src/main/java/libcore/util/Objects.java
index 7817316..573b973 100644
--- a/luni/src/main/java/libcore/util/Objects.java
+++ b/luni/src/main/java/libcore/util/Objects.java
@@ -16,6 +16,10 @@
 
 package libcore.util;
 
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.Arrays;
+
 public final class Objects {
     private Objects() {}
 
@@ -29,4 +33,64 @@ public final class Objects {
     public static int hashCode(Object o) {
         return (o == null) ? 0 : o.hashCode();
     }
+
+    /**
+     * Returns a string reporting the value of each declared field, via reflection.
+     * Static and transient fields are automatically skipped. Produces output like
+     * "SimpleClassName[integer=1234,string="hello",character='c',intArray=[1,2,3]]".
+     */
+    public static String toString(Object o) {
+        Class<?> c = o.getClass();
+        StringBuilder sb = new StringBuilder();
+        sb.append(c.getSimpleName()).append('[');
+        int i = 0;
+        for (Field f : c.getDeclaredFields()) {
+            if ((f.getModifiers() & (Modifier.STATIC | Modifier.TRANSIENT)) != 0) {
+                continue;
+            }
+            f.setAccessible(true);
+            try {
+                Object value = f.get(o);
+
+                if (i++ > 0) {
+                    sb.append(',');
+                }
+
+                sb.append(f.getName());
+                sb.append('=');
+
+                if (value.getClass().isArray()) {
+                    if (value.getClass() == boolean[].class) {
+                        sb.append(Arrays.toString((boolean[]) value));
+                    } else if (value.getClass() == byte[].class) {
+                        sb.append(Arrays.toString((byte[]) value));
+                    } else if (value.getClass() == char[].class) {
+                        sb.append(Arrays.toString((char[]) value));
+                    } else if (value.getClass() == double[].class) {
+                        sb.append(Arrays.toString((double[]) value));
+                    } else if (value.getClass() == float[].class) {
+                        sb.append(Arrays.toString((float[]) value));
+                    } else if (value.getClass() == int[].class) {
+                        sb.append(Arrays.toString((int[]) value));
+                    } else if (value.getClass() == long[].class) {
+                        sb.append(Arrays.toString((long[]) value));
+                    } else if (value.getClass() == short[].class) {
+                        sb.append(Arrays.toString((short[]) value));
+                    } else {
+                        sb.append(Arrays.toString((Object[]) value));
+                    }
+                } else if (value.getClass() == Character.class) {
+                    sb.append('\'').append(value).append('\'');
+                } else if (value.getClass() == String.class) {
+                    sb.append('"').append(value).append('"');
+                } else {
+                    sb.append(value);
+                }
+            } catch (IllegalAccessException unexpected) {
+                throw new AssertionError(unexpected);
+            }
+        }
+        sb.append("]");
+        return sb.toString();
+    }
 }
-- 
cgit v1.1


From 6c9b5377550a9649ed1532d1fcdfeba116c74ead Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Fri, 21 Sep 2012 10:19:21 -0700
Subject: Add setsid.

See "Monkey not handling SIGHUP signal" (https://android-review.googlesource.com/43053).

Change-Id: Ib327702caefa8eb8d044723c270acfe4685c7551
---
 luni/src/main/java/libcore/io/ForwardingOs.java | 1 +
 luni/src/main/java/libcore/io/Os.java           | 1 +
 luni/src/main/java/libcore/io/Posix.java        | 1 +
 luni/src/main/native/libcore_io_Posix.cpp       | 5 +++++
 4 files changed, 8 insertions(+)

diff --git a/luni/src/main/java/libcore/io/ForwardingOs.java b/luni/src/main/java/libcore/io/ForwardingOs.java
index e7f3538..719c5f0 100644
--- a/luni/src/main/java/libcore/io/ForwardingOs.java
+++ b/luni/src/main/java/libcore/io/ForwardingOs.java
@@ -110,6 +110,7 @@ public class ForwardingOs implements Os {
     public void setegid(int egid) throws ErrnoException { os.setegid(egid); }
     public void seteuid(int euid) throws ErrnoException { os.seteuid(euid); }
     public void setgid(int gid) throws ErrnoException { os.setgid(gid); }
+    public int setsid() throws ErrnoException { return os.setsid(); }
     public void setsockoptByte(FileDescriptor fd, int level, int option, int value) throws ErrnoException { os.setsockoptByte(fd, level, option, value); }
     public void setsockoptIfreq(FileDescriptor fd, int level, int option, String value) throws ErrnoException { os.setsockoptIfreq(fd, level, option, value); }
     public void setsockoptInt(FileDescriptor fd, int level, int option, int value) throws ErrnoException { os.setsockoptInt(fd, level, option, value); }
diff --git a/luni/src/main/java/libcore/io/Os.java b/luni/src/main/java/libcore/io/Os.java
index 721fe7c..55588d8 100644
--- a/luni/src/main/java/libcore/io/Os.java
+++ b/luni/src/main/java/libcore/io/Os.java
@@ -103,6 +103,7 @@ public interface Os {
     public void setegid(int egid) throws ErrnoException;
     public void seteuid(int euid) throws ErrnoException;
     public void setgid(int gid) throws ErrnoException;
+    public int setsid() throws ErrnoException;
     public void setsockoptByte(FileDescriptor fd, int level, int option, int value) throws ErrnoException;
     public void setsockoptIfreq(FileDescriptor fd, int level, int option, String value) throws ErrnoException;
     public void setsockoptInt(FileDescriptor fd, int level, int option, int value) throws ErrnoException;
diff --git a/luni/src/main/java/libcore/io/Posix.java b/luni/src/main/java/libcore/io/Posix.java
index a35c1a6..ad01bcf 100644
--- a/luni/src/main/java/libcore/io/Posix.java
+++ b/luni/src/main/java/libcore/io/Posix.java
@@ -154,6 +154,7 @@ public final class Posix implements Os {
     public native void setegid(int egid) throws ErrnoException;
     public native void seteuid(int euid) throws ErrnoException;
     public native void setgid(int gid) throws ErrnoException;
+    public native int setsid() throws ErrnoException;
     public native void setsockoptByte(FileDescriptor fd, int level, int option, int value) throws ErrnoException;
     public native void setsockoptIfreq(FileDescriptor fd, int level, int option, String value) throws ErrnoException;
     public native void setsockoptInt(FileDescriptor fd, int level, int option, int value) throws ErrnoException;
diff --git a/luni/src/main/native/libcore_io_Posix.cpp b/luni/src/main/native/libcore_io_Posix.cpp
index ffac077..eb80e95 100644
--- a/luni/src/main/native/libcore_io_Posix.cpp
+++ b/luni/src/main/native/libcore_io_Posix.cpp
@@ -1071,6 +1071,10 @@ static void Posix_setgid(JNIEnv* env, jobject, jint gid) {
     throwIfMinusOne(env, "setgid", TEMP_FAILURE_RETRY(setgid(gid)));
 }
 
+static jint Posix_setsid(JNIEnv* env, jobject) {
+    return throwIfMinusOne(env, "setsid", TEMP_FAILURE_RETRY(setsid()));
+}
+
 static void Posix_setsockoptByte(JNIEnv* env, jobject, jobject javaFd, jint level, jint option, jint value) {
     int fd = jniGetFDFromFileDescriptor(env, javaFd);
     u_char byte = value;
@@ -1326,6 +1330,7 @@ static JNINativeMethod gMethods[] = {
     NATIVE_METHOD(Posix, setegid, "(I)V"),
     NATIVE_METHOD(Posix, seteuid, "(I)V"),
     NATIVE_METHOD(Posix, setgid, "(I)V"),
+    NATIVE_METHOD(Posix, setsid, "()I"),
     NATIVE_METHOD(Posix, setsockoptByte, "(Ljava/io/FileDescriptor;III)V"),
     NATIVE_METHOD(Posix, setsockoptIfreq, "(Ljava/io/FileDescriptor;IILjava/lang/String;)V"),
     NATIVE_METHOD(Posix, setsockoptInt, "(Ljava/io/FileDescriptor;III)V"),
-- 
cgit v1.1


From dc24b1b274a6110a56993849c8e93033e0c2f1ff Mon Sep 17 00:00:00 2001
From: Jesse Wilson <jwilson@squareup.com>
Date: Fri, 21 Sep 2012 14:58:29 -0400
Subject: Add tests for underscores in URLs.

We're between a rock and a hard place on this. The RFCs say
that underscores aren't permitted in URLs. But browsers have
historically permitted them, and so there are websites that
depend upon them.

Attempting to support the de-facto standard rather than the
spec is difficult because support isn't universal. Mail servers
don't handle them. Internet Explorer loses cookies on them.

Further complicating things is that we can't easily support
underscores in hostnames in HttpURLConnection without also
adding support for that to java.net.URI. This would cause
awkward behavior in class that can be used for its strict
validation.

I'm recommending we stay spec-compliant. If its a major
problem for anyone, they can fix their servers.

Change-Id: I5135e0de20e11275e2459a67ec9e7c0d07b8a35b
http://code.google.com/p/android/issues/detail?id=37577
---
 luni/src/test/java/libcore/java/net/URITest.java | 8 ++++++++
 luni/src/test/java/libcore/java/net/URLTest.java | 8 ++++++++
 2 files changed, 16 insertions(+)

diff --git a/luni/src/test/java/libcore/java/net/URITest.java b/luni/src/test/java/libcore/java/net/URITest.java
index b37358c..04a7d2e 100644
--- a/luni/src/test/java/libcore/java/net/URITest.java
+++ b/luni/src/test/java/libcore/java/net/URITest.java
@@ -659,5 +659,13 @@ public final class URITest extends TestCase {
         }
     }
 
+    // http://code.google.com/p/android/issues/detail?id=37577
+    public void testUnderscore() throws Exception {
+        URI uri = new URI("http://a_b.c.d.net/");
+        assertEquals("a_b.c.d.net", uri.getAuthority());
+        // The RFC's don't permit underscores in hostnames, and neither does URI (unlike URL).
+        assertNull(uri.getHost());
+    }
+
     // Adding a new test? Consider adding an equivalent test to URLTest.java
 }
diff --git a/luni/src/test/java/libcore/java/net/URLTest.java b/luni/src/test/java/libcore/java/net/URLTest.java
index ced8314..962088e 100644
--- a/luni/src/test/java/libcore/java/net/URLTest.java
+++ b/luni/src/test/java/libcore/java/net/URLTest.java
@@ -686,5 +686,13 @@ public final class URLTest extends TestCase {
         assertEquals("re f", new URL("http://host/file?query#re f").getRef());
     }
 
+    // http://code.google.com/p/android/issues/detail?id=37577
+    public void testUnderscore() throws Exception {
+        URL url = new URL("http://a_b.c.d.net/");
+        assertEquals("a_b.c.d.net", url.getAuthority());
+        // The RFC's don't permit underscores in hostnames, but URL accepts them (unlike URI).
+        assertEquals("a_b.c.d.net", url.getHost());
+    }
+
     // Adding a new test? Consider adding an equivalent test to URITest.java
 }
-- 
cgit v1.1


From ce1311ee961cedeec08640726d24669e82bc568b Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Fri, 21 Sep 2012 17:38:14 -0700
Subject: Suppress long broken test caused by kernel bug

Bug: 6964436
Change-Id: I9a6fd2ec589968743dc6727dad406057b328156d
---
 expectations/brokentests.txt | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/expectations/brokentests.txt b/expectations/brokentests.txt
index 6fc48cd..e1d81e0 100644
--- a/expectations/brokentests.txt
+++ b/expectations/brokentests.txt
@@ -8,7 +8,12 @@
   bug: 5834665
 },
 {
-  description: "libcore.java.net.URLConnectionTest#testServerShutdownInput fails on ICL27 mysid-userdebug",
+  description: "FIONREAD/SIOCINQ returns the wrong result on sockets (5731252 is the root cause of 5534202)",
+  name: "libcore.java.net.SocketTest#testAvailable",
+  bug: 5731252
+},
+{
+  description: "libcore.java.net.URLConnectionTest#testServerShutdownInput fails on ICL27 mysid-userdebug (5534202 is caused by 5731252)",
   name: "libcore.java.net.URLConnectionTest#testServerShutdownInput",
   bug: 5534202
 },
-- 
cgit v1.1


From 615225a35dbd838210270b282d1196deff643b51 Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Fri, 21 Sep 2012 16:29:30 -0700
Subject: Add OpenSSLSocketImpl.setSoWriteTimeout to allow SO_SNDTIMEO to be
 specified

Bug: 6693087
Change-Id: Ie6903168ca0ada4516c55dfab5f7194baf965b4c
---
 .../harmony/xnet/provider/jsse/NativeCrypto.java   |  4 +-
 .../xnet/provider/jsse/OpenSSLSocketImpl.java      | 49 +++++++++++++++++-----
 ...che_harmony_xnet_provider_jsse_NativeCrypto.cpp | 22 +++++-----
 .../java/libcore/javax/net/ssl/SSLSocketTest.java  | 49 +++++++++++++++++++++-
 4 files changed, 100 insertions(+), 24 deletions(-)

diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/NativeCrypto.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/NativeCrypto.java
index 12f87fa..65373ff 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/NativeCrypto.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/NativeCrypto.java
@@ -645,7 +645,7 @@ public final class NativeCrypto {
     public static native int SSL_read(int sslNativePointer,
                                       FileDescriptor fd,
                                       SSLHandshakeCallbacks shc,
-                                      byte[] b, int off, int len, int timeoutMillis)
+                                      byte[] b, int off, int len, int readTimeoutMillis)
         throws IOException;
 
     /**
@@ -654,7 +654,7 @@ public final class NativeCrypto {
     public static native void SSL_write(int sslNativePointer,
                                         FileDescriptor fd,
                                         SSLHandshakeCallbacks shc,
-                                        byte[] b, int off, int len)
+                                        byte[] b, int off, int len, int writeTimeoutMillis)
         throws IOException;
 
     public static native void SSL_interrupt(int sslNativePointer);
diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLSocketImpl.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLSocketImpl.java
index 5ab5aa7..4cc16e6 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLSocketImpl.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLSocketImpl.java
@@ -42,7 +42,11 @@ import javax.net.ssl.SSLProtocolException;
 import javax.net.ssl.SSLSession;
 import javax.net.ssl.X509TrustManager;
 import javax.security.auth.x500.X500Principal;
+import static libcore.io.OsConstants.*;
+import libcore.io.ErrnoException;
+import libcore.io.Libcore;
 import libcore.io.Streams;
+import libcore.io.StructTimeval;
 import org.apache.harmony.security.provider.cert.X509CertImpl;
 
 /**
@@ -93,7 +97,8 @@ public class OpenSSLSocketImpl
      * OpenSSLSocketImplWrapper overrides setSoTimeout and
      * getSoTimeout to delegate to the wrapped socket.
      */
-    private int timeoutMilliseconds = 0;
+    private int readTimeoutMilliseconds = 0;
+    private int writeTimeoutMilliseconds = 0;
 
     private int handshakeTimeoutMilliseconds = -1;  // -1 = same as timeout; 0 = infinite
     private String wrappedHost;
@@ -361,9 +366,11 @@ public class OpenSSLSocketImpl
             }
 
             // Temporarily use a different timeout for the handshake process
-            int savedTimeoutMilliseconds = getSoTimeout();
+            int savedReadTimeoutMilliseconds = getSoTimeout();
+            int savedWriteTimeoutMilliseconds = getSoWriteTimeout();
             if (handshakeTimeoutMilliseconds >= 0) {
                 setSoTimeout(handshakeTimeoutMilliseconds);
+                setSoWriteTimeout(handshakeTimeoutMilliseconds);
             }
 
             int sslSessionNativePointer;
@@ -399,7 +406,8 @@ public class OpenSSLSocketImpl
 
             // Restore the original timeout now that the handshake is complete
             if (handshakeTimeoutMilliseconds >= 0) {
-                setSoTimeout(savedTimeoutMilliseconds);
+                setSoTimeout(savedReadTimeoutMilliseconds);
+                setSoWriteTimeout(savedWriteTimeoutMilliseconds);
             }
 
             // if not, notifyHandshakeCompletedListeners later in handshakeCompleted() callback
@@ -696,7 +704,7 @@ public class OpenSSLSocketImpl
                     return;
                 }
                 NativeCrypto.SSL_write(sslNativePointer, socket.getFileDescriptor$(),
-                        OpenSSLSocketImpl.this, buf, offset, byteCount);
+                        OpenSSLSocketImpl.this, buf, offset, byteCount, writeTimeoutMilliseconds);
             }
         }
     }
@@ -827,21 +835,42 @@ public class OpenSSLSocketImpl
         throw new SocketException("Methods sendUrgentData, setOOBInline are not supported.");
     }
 
-    @Override public void setSoTimeout(int timeoutMilliseconds) throws SocketException {
-        super.setSoTimeout(timeoutMilliseconds);
-        this.timeoutMilliseconds = timeoutMilliseconds;
+    @Override public void setSoTimeout(int readTimeoutMilliseconds) throws SocketException {
+        super.setSoTimeout(readTimeoutMilliseconds);
+        this.readTimeoutMilliseconds = readTimeoutMilliseconds;
     }
 
     @Override public int getSoTimeout() throws SocketException {
-        return timeoutMilliseconds;
+        return readTimeoutMilliseconds;
+    }
+
+    /**
+     * Note write timeouts are not part of the javax.net.ssl.SSLSocket API
+     */
+    public void setSoWriteTimeout(int writeTimeoutMilliseconds) throws SocketException {
+        this.writeTimeoutMilliseconds = writeTimeoutMilliseconds;
+
+        StructTimeval tv = StructTimeval.fromMillis(writeTimeoutMilliseconds);
+        try {
+            Libcore.os.setsockoptTimeval(getFileDescriptor$(), SOL_SOCKET, SO_SNDTIMEO, tv);
+        } catch (ErrnoException errnoException) {
+            throw errnoException.rethrowAsSocketException();
+        }
+    }
+
+    /**
+     * Note write timeouts are not part of the javax.net.ssl.SSLSocket API
+     */
+    public int getSoWriteTimeout() throws SocketException {
+        return writeTimeoutMilliseconds;
     }
 
     /**
      * Set the handshake timeout on this socket.  This timeout is specified in
      * milliseconds and will be used only during the handshake process.
      */
-    public void setHandshakeTimeout(int timeoutMilliseconds) throws SocketException {
-        this.handshakeTimeoutMilliseconds = timeoutMilliseconds;
+    public void setHandshakeTimeout(int handshakeTimeoutMilliseconds) throws SocketException {
+        this.handshakeTimeoutMilliseconds = handshakeTimeoutMilliseconds;
     }
 
     @Override public void close() throws IOException {
diff --git a/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp b/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
index 15bfab8..83f28d2 100644
--- a/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
+++ b/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
@@ -3755,7 +3755,7 @@ static jobjectArray NativeCrypto_SSL_get_peer_cert_chain(JNIEnv* env, jclass, ji
  * cleanly shut down, or THROW_SSLEXCEPTION if an exception should be thrown.
  */
 static int sslRead(JNIEnv* env, SSL* ssl, jobject fdObject, jobject shc, char* buf, jint len,
-                   int* sslReturnCode, int* sslErrorCode, int timeout_millis) {
+                   int* sslReturnCode, int* sslErrorCode, int read_timeout_millis) {
     JNI_TRACE("ssl=%p sslRead buf=%p len=%d", ssl, buf, len);
 
     if (len == 0) {
@@ -3834,7 +3834,7 @@ static int sslRead(JNIEnv* env, SSL* ssl, jobject fdObject, jobject shc, char* b
             // Need to wait for availability of underlying layer, then retry.
             case SSL_ERROR_WANT_READ:
             case SSL_ERROR_WANT_WRITE: {
-                int selectResult = sslSelect(env, sslError, fdObject, appData, timeout_millis);
+                int selectResult = sslSelect(env, sslError, fdObject, appData, read_timeout_millis);
                 if (selectResult == THROWN_EXCEPTION) {
                     return THROWN_EXCEPTION;
                 }
@@ -3886,11 +3886,11 @@ static int sslRead(JNIEnv* env, SSL* ssl, jobject fdObject, jobject shc, char* b
  */
 static jint NativeCrypto_SSL_read(JNIEnv* env, jclass, jint ssl_address, jobject fdObject,
                                   jobject shc, jbyteArray b, jint offset, jint len,
-                                  jint timeout_millis)
+                                  jint read_timeout_millis)
 {
     SSL* ssl = to_SSL(env, ssl_address, true);
-    JNI_TRACE("ssl=%p NativeCrypto_SSL_read fd=%p shc=%p b=%p offset=%d len=%d timeout_millis=%d",
-              ssl, fdObject, shc, b, offset, len, timeout_millis);
+    JNI_TRACE("ssl=%p NativeCrypto_SSL_read fd=%p shc=%p b=%p offset=%d len=%d read_timeout_millis=%d",
+              ssl, fdObject, shc, b, offset, len, read_timeout_millis);
     if (ssl == NULL) {
         return 0;
     }
@@ -3914,7 +3914,7 @@ static jint NativeCrypto_SSL_read(JNIEnv* env, jclass, jint ssl_address, jobject
     int sslErrorCode = SSL_ERROR_NONE;;
 
     int ret = sslRead(env, ssl, fdObject, shc, reinterpret_cast<char*>(bytes.get() + offset), len,
-                      &returnCode, &sslErrorCode, timeout_millis);
+                      &returnCode, &sslErrorCode, read_timeout_millis);
 
     int result;
     switch (ret) {
@@ -3954,7 +3954,7 @@ static jint NativeCrypto_SSL_read(JNIEnv* env, jclass, jint ssl_address, jobject
  * cleanly shut down, or THROW_SSLEXCEPTION if an exception should be thrown.
  */
 static int sslWrite(JNIEnv* env, SSL* ssl, jobject fdObject, jobject shc, const char* buf, jint len,
-                    int* sslReturnCode, int* sslErrorCode) {
+                    int* sslReturnCode, int* sslErrorCode, int write_timeout_millis) {
     JNI_TRACE("ssl=%p sslWrite buf=%p len=%d", ssl, buf, len);
 
     if (len == 0) {
@@ -4040,7 +4040,7 @@ static int sslWrite(JNIEnv* env, SSL* ssl, jobject fdObject, jobject shc, const
             // it's also not standard Java behavior, so we wait forever here.
             case SSL_ERROR_WANT_READ:
             case SSL_ERROR_WANT_WRITE: {
-                int selectResult = sslSelect(env, sslError, fdObject, appData, 0);
+                int selectResult = sslSelect(env, sslError, fdObject, appData, write_timeout_millis);
                 if (selectResult == THROWN_EXCEPTION) {
                     return THROWN_EXCEPTION;
                 }
@@ -4091,7 +4091,7 @@ static int sslWrite(JNIEnv* env, SSL* ssl, jobject fdObject, jobject shc, const
  * OpenSSL write function (2): write into buffer at offset n chunks.
  */
 static void NativeCrypto_SSL_write(JNIEnv* env, jclass, jint ssl_address, jobject fdObject,
-                                   jobject shc, jbyteArray b, jint offset, jint len)
+                                   jobject shc, jbyteArray b, jint offset, jint len, jint write_timeout_millis)
 {
     SSL* ssl = to_SSL(env, ssl_address, true);
     JNI_TRACE("ssl=%p NativeCrypto_SSL_write fd=%p shc=%p b=%p offset=%d len=%d",
@@ -4118,7 +4118,7 @@ static void NativeCrypto_SSL_write(JNIEnv* env, jclass, jint ssl_address, jobjec
     int returnCode = 0;
     int sslErrorCode = SSL_ERROR_NONE;
     int ret = sslWrite(env, ssl, fdObject, shc, reinterpret_cast<const char*>(bytes.get() + offset),
-                       len, &returnCode, &sslErrorCode);
+                       len, &returnCode, &sslErrorCode, write_timeout_millis);
 
     switch (ret) {
         case THROW_SSLEXCEPTION:
@@ -4487,7 +4487,7 @@ static JNINativeMethod sNativeCryptoMethods[] = {
     NATIVE_METHOD(NativeCrypto, SSL_get_certificate, "(I)[[B"),
     NATIVE_METHOD(NativeCrypto, SSL_get_peer_cert_chain, "(I)[[B"),
     NATIVE_METHOD(NativeCrypto, SSL_read, "(I" FILE_DESCRIPTOR SSL_CALLBACKS "[BIII)I"),
-    NATIVE_METHOD(NativeCrypto, SSL_write, "(I" FILE_DESCRIPTOR SSL_CALLBACKS "[BII)V"),
+    NATIVE_METHOD(NativeCrypto, SSL_write, "(I" FILE_DESCRIPTOR SSL_CALLBACKS "[BIII)V"),
     NATIVE_METHOD(NativeCrypto, SSL_interrupt, "(I)V"),
     NATIVE_METHOD(NativeCrypto, SSL_shutdown, "(I" FILE_DESCRIPTOR SSL_CALLBACKS ")V"),
     NATIVE_METHOD(NativeCrypto, SSL_free, "(I)V"),
diff --git a/luni/src/test/java/libcore/javax/net/ssl/SSLSocketTest.java b/luni/src/test/java/libcore/javax/net/ssl/SSLSocketTest.java
index 8c9239e..4095081 100644
--- a/luni/src/test/java/libcore/javax/net/ssl/SSLSocketTest.java
+++ b/luni/src/test/java/libcore/javax/net/ssl/SSLSocketTest.java
@@ -19,6 +19,7 @@ package libcore.javax.net.ssl;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
+import java.lang.reflect.Method;
 import java.net.ServerSocket;
 import java.net.Socket;
 import java.net.SocketException;
@@ -1012,7 +1013,7 @@ public class SSLSocketTest extends TestCase {
         assertEquals(0, wrapping.getSoTimeout());
 
         // setting wrapper sets underlying and ...
-        int expectedTimeoutMillis = 1000;  // Using a small value such as 10 was affected by rounding
+        int expectedTimeoutMillis = 1000;  // 10 was too small because it was affected by rounding
         wrapping.setSoTimeout(expectedTimeoutMillis);
         assertEquals(expectedTimeoutMillis, wrapping.getSoTimeout());
         assertEquals(expectedTimeoutMillis, underlying.getSoTimeout());
@@ -1050,6 +1051,52 @@ public class SSLSocketTest extends TestCase {
         listening.close();
     }
 
+    public void test_SSLSocket_setSoWriteTimeout() throws Exception {
+        if (StandardNames.IS_RI) {
+            // RI does not support write timeout on sockets
+            return;
+        }
+
+        final TestSSLContext c = TestSSLContext.create();
+        SSLSocket client = (SSLSocket) c.clientContext.getSocketFactory().createSocket(c.host,
+                                                                                       c.port);
+        final SSLSocket server = (SSLSocket) c.serverSocket.accept();
+        ExecutorService executor = Executors.newSingleThreadExecutor();
+        Future<Void> future = executor.submit(new Callable<Void>() {
+            @Override public Void call() throws Exception {
+                server.startHandshake();
+                return null;
+            }
+        });
+        executor.shutdown();
+        client.startHandshake();
+
+        // Reflection is used so this can compile on the RI
+        String expectedClassName = "org.apache.harmony.xnet.provider.jsse.OpenSSLSocketImpl";
+        Class actualClass = client.getClass();
+        assertEquals(expectedClassName, actualClass.getName());
+        Method setSoWriteTimeout = actualClass.getMethod("setSoWriteTimeout",
+                                                         new Class[] { Integer.TYPE });
+        setSoWriteTimeout.invoke(client, 1);
+
+        // Try to make the size smaller (it can be 512k or even megabytes).
+        // Note that it may not respect your request, so read back the actual value.
+        int sendBufferSize = 1024;
+        client.setSendBufferSize(sendBufferSize);
+        sendBufferSize = client.getSendBufferSize();
+
+        try {
+            client.getOutputStream().write(new byte[sendBufferSize + 1]);
+            fail();
+        } catch (SocketTimeoutException expected) {
+        }
+
+        future.get();
+        client.close();
+        server.close();
+        c.close();
+    }
+
     public void test_SSLSocket_interrupt() throws Exception {
         ServerSocket listening = new ServerSocket(0);
 
-- 
cgit v1.1


From 8205bc491d7e9167aa190fca584b30cb1599ab51 Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Sun, 23 Sep 2012 13:15:48 -0700
Subject: Add write timeout argument to SSL_write calls NativeCryptoTest

Bug: 6693087
Change-Id: Ie18b227580682ff1d1cc8221de1b89677d446b66
---
 .../harmony/xnet/provider/jsse/NativeCryptoTest.java     | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/NativeCryptoTest.java b/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/NativeCryptoTest.java
index b2be7f5..a215445 100644
--- a/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/NativeCryptoTest.java
+++ b/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/NativeCryptoTest.java
@@ -872,7 +872,7 @@ public class NativeCryptoTest extends TestCase {
                 NativeCrypto.SSL_set_options(
                         s, NativeCrypto.SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION);
                 NativeCrypto.SSL_renegotiate(s);
-                NativeCrypto.SSL_write(s, fd, callback, new byte[] { 42 }, 0, 1);
+                NativeCrypto.SSL_write(s, fd, callback, new byte[] { 42 }, 0, 1, 0);
                 super.afterHandshake(session, s, c, sock, fd, callback);
             }
         };
@@ -1241,7 +1241,7 @@ public class NativeCryptoTest extends TestCase {
                                        SSLHandshakeCallbacks callback)
                 throws Exception {
                 NativeCrypto.SSL_renegotiate(s);
-                NativeCrypto.SSL_write(s, fd, callback, new byte[] { 42 }, 0, 1);
+                NativeCrypto.SSL_write(s, fd, callback, new byte[] { 42 }, 0, 1, 0);
                 super.afterHandshake(session, s, c, sock, fd, callback);
             }
         };
@@ -1408,7 +1408,7 @@ public class NativeCryptoTest extends TestCase {
                                            Socket sock, FileDescriptor fd,
                                            SSLHandshakeCallbacks callback)
                         throws Exception {
-                    NativeCrypto.SSL_write(s, fd, callback, BYTES, 0, BYTES.length);
+                    NativeCrypto.SSL_write(s, fd, callback, BYTES, 0, BYTES.length, 0);
                     super.afterHandshake(session, s, c, sock, fd, callback);
                 }
             };
@@ -1451,7 +1451,7 @@ public class NativeCryptoTest extends TestCase {
 
     public void test_SSL_write() throws Exception {
         try {
-            NativeCrypto.SSL_write(NULL, null, null, null, 0, 0);
+            NativeCrypto.SSL_write(NULL, null, null, null, 0, 0, 0);
             fail();
         } catch (NullPointerException expected) {
         }
@@ -1461,7 +1461,7 @@ public class NativeCryptoTest extends TestCase {
             int c = NativeCrypto.SSL_CTX_new();
             int s = NativeCrypto.SSL_new(c);
             try {
-                NativeCrypto.SSL_write(s, null, DUMMY_CB, null, 0, 1);
+                NativeCrypto.SSL_write(s, null, DUMMY_CB, null, 0, 1, 0);
                 fail();
             } catch (NullPointerException expected) {
             }
@@ -1474,7 +1474,7 @@ public class NativeCryptoTest extends TestCase {
             int c = NativeCrypto.SSL_CTX_new();
             int s = NativeCrypto.SSL_new(c);
             try {
-                NativeCrypto.SSL_write(s, INVALID_FD, null, null, 0, 1);
+                NativeCrypto.SSL_write(s, INVALID_FD, null, null, 0, 1, 0);
                 fail();
             } catch (NullPointerException expected) {
             }
@@ -1487,7 +1487,7 @@ public class NativeCryptoTest extends TestCase {
             int c = NativeCrypto.SSL_CTX_new();
             int s = NativeCrypto.SSL_new(c);
             try {
-                NativeCrypto.SSL_write(s, INVALID_FD, DUMMY_CB, null, 0, 1);
+                NativeCrypto.SSL_write(s, INVALID_FD, DUMMY_CB, null, 0, 1, 0);
                 fail();
             } catch (NullPointerException expected) {
             }
@@ -1500,7 +1500,7 @@ public class NativeCryptoTest extends TestCase {
             int c = NativeCrypto.SSL_CTX_new();
             int s = NativeCrypto.SSL_new(c);
             try {
-                NativeCrypto.SSL_write(s, INVALID_FD, DUMMY_CB, new byte[1], 0, 1);
+                NativeCrypto.SSL_write(s, INVALID_FD, DUMMY_CB, new byte[1], 0, 1, 0);
                 fail();
             } catch (SSLException expected) {
             }
-- 
cgit v1.1


From acba45cc4b1f98f67fcdeda2f7c13ed57659b92a Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Mon, 24 Sep 2012 09:06:37 -0700
Subject: Fix umask.

Bug: 7094213
Change-Id: I81979e6f050912cdc4cde8084765d09ec64c0689
---
 luni/src/main/native/libcore_io_Posix.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/luni/src/main/native/libcore_io_Posix.cpp b/luni/src/main/native/libcore_io_Posix.cpp
index eb80e95..dd9b87f 100644
--- a/luni/src/main/native/libcore_io_Posix.cpp
+++ b/luni/src/main/native/libcore_io_Posix.cpp
@@ -1219,7 +1219,7 @@ static void Posix_tcdrain(JNIEnv* env, jobject, jobject javaFd) {
     throwIfMinusOne(env, "tcdrain", TEMP_FAILURE_RETRY(tcdrain(fd)));
 }
 
-static jint Posix_umask(JNIEnv*, jint mask) {
+static jint Posix_umask(JNIEnv*, jobject, jint mask) {
     return umask(mask);
 }
 
-- 
cgit v1.1


From 03c772cadc72ca8cbcde78b266a347dbc6e68ad4 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Mon, 24 Sep 2012 09:06:37 -0700
Subject: Fix umask.

(cherry-pick of acba45cc4b1f98f67fcdeda2f7c13ed57659b92a.)

Bug: 7094213
Change-Id: I0c5cbfbfcd937e2393b30f3f50edea40586278cb
---
 luni/src/main/native/libcore_io_Posix.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/luni/src/main/native/libcore_io_Posix.cpp b/luni/src/main/native/libcore_io_Posix.cpp
index eb80e95..dd9b87f 100644
--- a/luni/src/main/native/libcore_io_Posix.cpp
+++ b/luni/src/main/native/libcore_io_Posix.cpp
@@ -1219,7 +1219,7 @@ static void Posix_tcdrain(JNIEnv* env, jobject, jobject javaFd) {
     throwIfMinusOne(env, "tcdrain", TEMP_FAILURE_RETRY(tcdrain(fd)));
 }
 
-static jint Posix_umask(JNIEnv*, jint mask) {
+static jint Posix_umask(JNIEnv*, jobject, jint mask) {
     return umask(mask);
 }
 
-- 
cgit v1.1


From fce022be38a2c79f9cdc8d9fea33c72cf2f16528 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Mon, 24 Sep 2012 11:02:11 -0700
Subject: Fix flaky finalization tests.

(cherry-pick of bb9878546d29f4f4688d68f12b2af9d8c9a68fe4.)

Bug: 6973520
Change-Id: I372e451b5858e2f01a0aeeb7cb659f7df9f9348b
---
 .../harmony/archive/tests/java/util/zip/ZipFileTest.java |  8 +++-----
 .../tests/api/java/lang/ref/PhantomReferenceTest.java    |  5 +++--
 .../java/tests/api/java/lang/ref/ReferenceQueueTest.java |  4 ++--
 .../test/java/tests/api/java/lang/ref/ReferenceTest.java | 16 ++++++----------
 .../java/tests/api/java/lang/ref/SoftReferenceTest.java  |  4 ++--
 .../test/java/tests/api/java/util/WeakHashMapTest.java   | 10 ++++++----
 6 files changed, 22 insertions(+), 25 deletions(-)

diff --git a/luni/src/test/java/org/apache/harmony/archive/tests/java/util/zip/ZipFileTest.java b/luni/src/test/java/org/apache/harmony/archive/tests/java/util/zip/ZipFileTest.java
index 17d251b..a423f22 100644
--- a/luni/src/test/java/org/apache/harmony/archive/tests/java/util/zip/ZipFileTest.java
+++ b/luni/src/test/java/org/apache/harmony/archive/tests/java/util/zip/ZipFileTest.java
@@ -32,6 +32,7 @@ import java.util.Enumeration;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipException;
 import java.util.zip.ZipFile;
+import libcore.java.lang.ref.FinalizationTester;
 
 public class ZipFileTest extends junit.framework.TestCase {
 
@@ -150,11 +151,8 @@ public class ZipFileTest extends junit.framework.TestCase {
          * entry1); entry1 = null; zip = null;
          */
 
-        assertNotNull("Did not find entry",
-                test_finalize1(test_finalize2(file)));
-        System.gc();
-        System.gc();
-        System.runFinalization();
+        assertNotNull("Did not find entry", test_finalize1(test_finalize2(file)));
+        FinalizationTester.induceFinalization();
         file.delete();
         assertTrue("Zip should not exist", !file.exists());
     }
diff --git a/luni/src/test/java/tests/api/java/lang/ref/PhantomReferenceTest.java b/luni/src/test/java/tests/api/java/lang/ref/PhantomReferenceTest.java
index 06221c9..6470579 100644
--- a/luni/src/test/java/tests/api/java/lang/ref/PhantomReferenceTest.java
+++ b/luni/src/test/java/tests/api/java/lang/ref/PhantomReferenceTest.java
@@ -20,6 +20,7 @@ package tests.api.java.lang.ref;
 import java.lang.ref.PhantomReference;
 import java.lang.ref.Reference;
 import java.lang.ref.ReferenceQueue;
+import libcore.java.lang.ref.FinalizationTester;
 
 //TODO: write a test to verify that the referent's finalize() happens
 //      before the PhantomReference is enqueued.
@@ -81,8 +82,8 @@ public class PhantomReferenceTest extends junit.framework.TestCase {
             Thread t = new TestThread();
             t.start();
             t.join();
-            System.gc();
-            System.runFinalization();
+
+            FinalizationTester.induceFinalization();
 
             assertNull("get() should return null.", tprs[0].get());
             assertNull("get() should return null.", tprs[1].get());
diff --git a/luni/src/test/java/tests/api/java/lang/ref/ReferenceQueueTest.java b/luni/src/test/java/tests/api/java/lang/ref/ReferenceQueueTest.java
index dc7e738..cad61b3 100644
--- a/luni/src/test/java/tests/api/java/lang/ref/ReferenceQueueTest.java
+++ b/luni/src/test/java/tests/api/java/lang/ref/ReferenceQueueTest.java
@@ -22,6 +22,7 @@ import java.lang.ref.Reference;
 import java.lang.ref.ReferenceQueue;
 import java.lang.ref.SoftReference;
 import java.lang.ref.WeakReference;
+import libcore.java.lang.ref.FinalizationTester;
 
 public class ReferenceQueueTest extends junit.framework.TestCase {
     static Boolean b;
@@ -97,8 +98,7 @@ public class ReferenceQueueTest extends junit.framework.TestCase {
         sr.enqueue();
         wr.enqueue();
 
-        System.gc();
-        System.runFinalization();
+        FinalizationTester.induceFinalization();
 
         assertNull(rq.poll());
     }
diff --git a/luni/src/test/java/tests/api/java/lang/ref/ReferenceTest.java b/luni/src/test/java/tests/api/java/lang/ref/ReferenceTest.java
index a1a7a8c..7461b47 100644
--- a/luni/src/test/java/tests/api/java/lang/ref/ReferenceTest.java
+++ b/luni/src/test/java/tests/api/java/lang/ref/ReferenceTest.java
@@ -22,6 +22,7 @@ import java.lang.ref.ReferenceQueue;
 import java.lang.ref.SoftReference;
 import java.lang.ref.WeakReference;
 import junit.framework.AssertionFailedError;
+import libcore.java.lang.ref.FinalizationTester;
 
 public class ReferenceTest extends junit.framework.TestCase {
     Object tmpA, tmpB, tmpC, obj;
@@ -146,16 +147,14 @@ public class ReferenceTest extends junit.framework.TestCase {
         ReferenceQueue<Object> queue = new ReferenceQueue<Object>();
 
         r = newWeakReference(queue);
-        System.gc();
-        System.runFinalization();
+        FinalizationTester.induceFinalization();
         Reference ref = queue.remove();
         assertNotNull("Object not enqueued.", ref);
         assertSame("Unexpected ref1", ref, r);
         assertNull("Object could not be reclaimed1.", r.get());
 
         r = newWeakReference(queue);
-        System.gc();
-        System.runFinalization();
+        FinalizationTester.induceFinalization();
 
         // wait for the reference queue thread to enqueue the newly-finalized object
         Thread.yield();
@@ -213,8 +212,7 @@ public class ReferenceTest extends junit.framework.TestCase {
             Thread t = new TestThread();
             t.start();
             t.join();
-            System.gc();
-            System.runFinalization();
+            FinalizationTester.induceFinalization();
             ref = rq.remove(5000L);    // Give up after five seconds.
 
             assertNotNull("Object not garbage collected.", ref);
@@ -238,8 +236,7 @@ public class ReferenceTest extends junit.framework.TestCase {
     public void test_get() {
         WeakReference ref = newWeakReference(null);
 
-        System.gc();
-        System.runFinalization();
+        FinalizationTester.induceFinalization();
         assertNull("get() doesn't return null after gc for WeakReference", ref.get());
 
         obj = new Object();
@@ -322,8 +319,7 @@ public class ReferenceTest extends junit.framework.TestCase {
             Thread t = new TestThread();
             t.start();
             t.join();
-            System.gc();
-            System.runFinalization();
+            FinalizationTester.induceFinalization();
             Thread.sleep(1000);
             if (error != null) {
                 throw error;
diff --git a/luni/src/test/java/tests/api/java/lang/ref/SoftReferenceTest.java b/luni/src/test/java/tests/api/java/lang/ref/SoftReferenceTest.java
index 77c6536..197d829 100644
--- a/luni/src/test/java/tests/api/java/lang/ref/SoftReferenceTest.java
+++ b/luni/src/test/java/tests/api/java/lang/ref/SoftReferenceTest.java
@@ -22,6 +22,7 @@ import java.lang.ref.Reference;
 import java.lang.ref.ReferenceQueue;
 import java.lang.ref.SoftReference;
 import java.util.Vector;
+import libcore.java.lang.ref.FinalizationTester;
 
 public class SoftReferenceTest extends junit.framework.TestCase {
     static Boolean bool;
@@ -124,8 +125,7 @@ public class SoftReferenceTest extends junit.framework.TestCase {
             TestThread t = new TestThread();
             t.start();
             t.join();
-            System.gc();
-            System.runFinalization();
+            FinalizationTester.induceFinalization();
             ref = rq.poll();
             assertNotNull("Object not garbage collected.", ref);
             assertNull("Object is not null.", ref.get());
diff --git a/luni/src/test/java/tests/api/java/util/WeakHashMapTest.java b/luni/src/test/java/tests/api/java/util/WeakHashMapTest.java
index 0e43bf6..d1a43e5 100644
--- a/luni/src/test/java/tests/api/java/util/WeakHashMapTest.java
+++ b/luni/src/test/java/tests/api/java/util/WeakHashMapTest.java
@@ -25,6 +25,7 @@ import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.WeakHashMap;
+import libcore.java.lang.ref.FinalizationTester;
 
 import tests.support.Support_MapTest2;
 
@@ -208,7 +209,7 @@ public class WeakHashMapTest extends junit.framework.TestCase {
         do {
             System.gc();
             System.gc();
-            Runtime.getRuntime().runFinalization();
+            FinalizationTester.induceFinalization();
             count++;
         } while (count <= 5 && entrySet.size() == 100);
 
@@ -240,7 +241,8 @@ public class WeakHashMapTest extends junit.framework.TestCase {
         WeakHashMap map = new WeakHashMap();
         map.put(null, "value"); // add null key
         System.gc();
-        System.runFinalization();
+        System.gc();
+        FinalizationTester.induceFinalization();
         map.remove("nothing"); // Cause objects in queue to be removed
         assertEquals("null key was removed", 1, map.size());
     }
@@ -315,7 +317,7 @@ public class WeakHashMapTest extends junit.framework.TestCase {
         do {
             System.gc();
             System.gc();
-            Runtime.getRuntime().runFinalization();
+            FinalizationTester.induceFinalization();
             count++;
         } while (count <= 5 && keySet.size() == 100);
 
@@ -352,7 +354,7 @@ public class WeakHashMapTest extends junit.framework.TestCase {
         do {
             System.gc();
             System.gc();
-            Runtime.getRuntime().runFinalization();
+            FinalizationTester.induceFinalization();
             count++;
         } while (count <= 5 && valuesCollection.size() == 100);
 
-- 
cgit v1.1


From 6d41a7cc3cb4cc684c8bece69ddc55954812ad6e Mon Sep 17 00:00:00 2001
From: Narayan Kamath <narayan@google.com>
Date: Mon, 24 Sep 2012 11:35:16 +0100
Subject: Strip content length in requests with "transparent" gzip handling.

We need to strip both the Content-Length and the Content-Encoding
for such requests. In such requests, it will be the length of the
compressed response. We hide the fact that compression is taking place
from clients, so we shouldn't give them the content length either.

(cherry picked from commit f9d60aed414ae21811a6488f603333517f257b22)

Change-Id: Ic2776ecf020c34b1c55e2fb7e2f0728e553187a0
---
 luni/src/main/java/libcore/net/http/HttpEngine.java        | 5 +++++
 luni/src/main/java/libcore/net/http/ResponseHeaders.java   | 5 +++++
 luni/src/test/java/libcore/java/net/URLConnectionTest.java | 8 ++++++--
 3 files changed, 16 insertions(+), 2 deletions(-)

diff --git a/luni/src/main/java/libcore/net/http/HttpEngine.java b/luni/src/main/java/libcore/net/http/HttpEngine.java
index a370956..8f97c81 100644
--- a/luni/src/main/java/libcore/net/http/HttpEngine.java
+++ b/luni/src/main/java/libcore/net/http/HttpEngine.java
@@ -524,8 +524,13 @@ public class HttpEngine {
             /*
              * If the response was transparently gzipped, remove the gzip header field
              * so clients don't double decompress. http://b/3009828
+             *
+             * Also remove the Content-Length in this case because it contains the length
+             * of the gzipped response. This isn't terribly useful and is dangerous because
+             * clients can query the content length, but not the content encoding.
              */
             responseHeaders.stripContentEncoding();
+            responseHeaders.stripContentLength();
             responseBodyIn = new GZIPInputStream(transferStream);
         } else {
             responseBodyIn = transferStream;
diff --git a/luni/src/main/java/libcore/net/http/ResponseHeaders.java b/luni/src/main/java/libcore/net/http/ResponseHeaders.java
index 003b445..c0b4200 100644
--- a/luni/src/main/java/libcore/net/http/ResponseHeaders.java
+++ b/luni/src/main/java/libcore/net/http/ResponseHeaders.java
@@ -187,6 +187,11 @@ public final class ResponseHeaders {
         headers.removeAll("Content-Encoding");
     }
 
+    public void stripContentLength() {
+        contentLength = -1;
+        headers.removeAll("Content-Length");
+    }
+
     public boolean isChunked() {
         return "chunked".equalsIgnoreCase(transferEncoding);
     }
diff --git a/luni/src/test/java/libcore/java/net/URLConnectionTest.java b/luni/src/test/java/libcore/java/net/URLConnectionTest.java
index 762bac4..d7a4544 100644
--- a/luni/src/test/java/libcore/java/net/URLConnectionTest.java
+++ b/luni/src/test/java/libcore/java/net/URLConnectionTest.java
@@ -989,21 +989,25 @@ public final class URLConnectionTest extends TestCase {
         URLConnection connection = server.getUrl("/").openConnection();
         assertEquals("ABCABCABC", readAscii(connection.getInputStream(), Integer.MAX_VALUE));
         assertNull(connection.getContentEncoding());
+        assertEquals(-1, connection.getContentLength());
 
         RecordedRequest request = server.takeRequest();
         assertContains(request.getHeaders(), "Accept-Encoding: gzip");
     }
 
     public void testClientConfiguredGzipContentEncoding() throws Exception {
+        byte[] bodyBytes = gzip("ABCDEFGHIJKLMNOPQRSTUVWXYZ".getBytes("UTF-8"));
         server.enqueue(new MockResponse()
-                .setBody(gzip("ABCDEFGHIJKLMNOPQRSTUVWXYZ".getBytes("UTF-8")))
-                .addHeader("Content-Encoding: gzip"));
+                .setBody(bodyBytes)
+                .addHeader("Content-Encoding: gzip")
+                .addHeader("Content-Length: " + bodyBytes.length));
         server.play();
 
         URLConnection connection = server.getUrl("/").openConnection();
         connection.addRequestProperty("Accept-Encoding", "gzip");
         InputStream gunzippedIn = new GZIPInputStream(connection.getInputStream());
         assertEquals("ABCDEFGHIJKLMNOPQRSTUVWXYZ", readAscii(gunzippedIn, Integer.MAX_VALUE));
+        assertEquals(bodyBytes.length, connection.getContentLength());
 
         RecordedRequest request = server.takeRequest();
         assertContains(request.getHeaders(), "Accept-Encoding: gzip");
-- 
cgit v1.1


From 3d43199950729e592ac3e104442b4b350a86aec8 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Tue, 25 Sep 2012 15:29:36 -0700
Subject: Fix ConcurrentCloseTest flakiness.

We were running the risk that the server's end of a client socket would get
closed by the finalizer thread, resulting in read(2) returning 0 to the client,
and the test failing like this:

  junit.framework.AssertionFailedError: read returned -1
      at libcore.java.net.ConcurrentCloseTest.test_read(ConcurrentCloseTest.java:121)
      at java.lang.reflect.Method.invokeNative(Native Method)

(cherry-pick of 4bbcd7e5aee1e984a4fcf46385667f9ad03dbc16.)

Bug: 7206024
Change-Id: I0dae214a7ee609655f4f4781abf4457863bcfd5f
---
 .../java/libcore/java/net/ConcurrentCloseTest.java | 73 +++++++++++-----------
 1 file changed, 38 insertions(+), 35 deletions(-)

diff --git a/luni/src/test/java/libcore/java/net/ConcurrentCloseTest.java b/luni/src/test/java/libcore/java/net/ConcurrentCloseTest.java
index d33c5f3..06a546a 100644
--- a/luni/src/test/java/libcore/java/net/ConcurrentCloseTest.java
+++ b/luni/src/test/java/libcore/java/net/ConcurrentCloseTest.java
@@ -16,11 +16,13 @@
 
 package libcore.java.net;
 
+import java.io.IOException;
 import java.net.DatagramPacket;
 import java.net.DatagramSocket;
 import java.net.InetSocketAddress;
 import java.net.ServerSocket;
 import java.net.Socket;
+import java.net.SocketAddress;
 import java.net.SocketException;
 import java.nio.channels.AsynchronousCloseException;
 import java.nio.channels.ClosedChannelException;
@@ -102,16 +104,7 @@ public class ConcurrentCloseTest extends junit.framework.TestCase {
     }
 
     public void test_read() throws Exception {
-        final ServerSocket ss = new ServerSocket(0);
-        new Thread(new Runnable() {
-            public void run() {
-                try {
-                    ss.accept();
-                } catch (Exception ex) {
-                    ex.printStackTrace();
-                }
-            }
-        }).start();
+        SilentServer ss = new SilentServer();
         Socket s = new Socket();
         s.connect(ss.getLocalSocketAddress());
         new Killer(s).start();
@@ -126,16 +119,7 @@ public class ConcurrentCloseTest extends junit.framework.TestCase {
     }
 
     public void test_read_multiple() throws Throwable {
-        final ServerSocket ss = new ServerSocket(0);
-        new Thread(new Runnable() {
-            public void run() {
-                try {
-                    ss.accept();
-                } catch (Exception ex) {
-                    ex.printStackTrace();
-                }
-            }
-        }).start();
+        SilentServer ss = new SilentServer();
         final Socket s = new Socket();
         s.connect(ss.getLocalSocketAddress());
 
@@ -173,6 +157,8 @@ public class ConcurrentCloseTest extends junit.framework.TestCase {
         for (Throwable exception : thrownExceptions) {
             throw exception;
         }
+
+        ss.close();
     }
 
     public void test_recv() throws Exception {
@@ -190,21 +176,7 @@ public class ConcurrentCloseTest extends junit.framework.TestCase {
     }
 
     public void test_write() throws Exception {
-        final ServerSocket ss = new ServerSocket(0);
-        new Thread(new Runnable() {
-            public void run() {
-                try {
-                    System.err.println("accepting...");
-
-                    Socket client = ss.accept();
-                    System.err.println("accepted...");
-                    Thread.sleep(30 * 1000);
-                    System.err.println("server exiting...");
-                } catch (Exception ex) {
-                    ex.printStackTrace();
-                }
-            }
-        }).start();
+        final SilentServer ss = new SilentServer();
         Socket s = new Socket();
         s.connect(ss.getLocalSocketAddress());
         new Killer(s).start();
@@ -224,6 +196,37 @@ public class ConcurrentCloseTest extends junit.framework.TestCase {
         ss.close();
     }
 
+    // This server accepts connections, but doesn't read or write anything.
+    // It holds on to the Socket connecting to the client so it won't be GCed.
+    // Call "close" to close both the server socket and its client connection.
+    static class SilentServer {
+        private final ServerSocket ss;
+        private Socket client;
+
+        public SilentServer() throws IOException {
+            ss = new ServerSocket(0);
+            new Thread(new Runnable() {
+                public void run() {
+                    try {
+                        client = ss.accept();
+                    } catch (Exception ex) {
+                        ex.printStackTrace();
+                    }
+                }
+            }).start();
+        }
+
+        public SocketAddress getLocalSocketAddress() {
+            return ss.getLocalSocketAddress();
+        }
+
+        public void close() throws IOException {
+            client.close();
+            ss.close();
+        }
+    }
+
+    // This thread calls the "close" method on the supplied T after 2s.
     static class Killer<T> extends Thread {
         private final T s;
 
-- 
cgit v1.1


From db611c5813f623ee0403aedd156bb15780ed6e69 Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Sun, 30 Sep 2012 00:58:56 -0700
Subject: 
 NativeCryptoTest#test_SSL_do_handshake_clientCertificateRequested_throws_after_renegotiate
 failure

Bug: 6964910
Change-Id: I13bed4e5ed104241025fbb1d5e28427ec16d7a80
---
 ...apache_harmony_xnet_provider_jsse_NativeCrypto.cpp |  7 ++++---
 .../harmony/xnet/provider/jsse/NativeCryptoTest.java  | 19 ++++++++++++-------
 2 files changed, 16 insertions(+), 10 deletions(-)

diff --git a/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp b/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
index 83f28d2..348960d 100644
--- a/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
+++ b/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
@@ -3955,7 +3955,8 @@ static jint NativeCrypto_SSL_read(JNIEnv* env, jclass, jint ssl_address, jobject
  */
 static int sslWrite(JNIEnv* env, SSL* ssl, jobject fdObject, jobject shc, const char* buf, jint len,
                     int* sslReturnCode, int* sslErrorCode, int write_timeout_millis) {
-    JNI_TRACE("ssl=%p sslWrite buf=%p len=%d", ssl, buf, len);
+    JNI_TRACE("ssl=%p sslWrite buf=%p len=%d write_timeout_millis=%d",
+              ssl, buf, len, write_timeout_millis);
 
     if (len == 0) {
         // Don't bother doing anything in this case.
@@ -4094,8 +4095,8 @@ static void NativeCrypto_SSL_write(JNIEnv* env, jclass, jint ssl_address, jobjec
                                    jobject shc, jbyteArray b, jint offset, jint len, jint write_timeout_millis)
 {
     SSL* ssl = to_SSL(env, ssl_address, true);
-    JNI_TRACE("ssl=%p NativeCrypto_SSL_write fd=%p shc=%p b=%p offset=%d len=%d",
-              ssl, fdObject, shc, b, offset, len);
+    JNI_TRACE("ssl=%p NativeCrypto_SSL_write fd=%p shc=%p b=%p offset=%d len=%d write_timeout_millis=%d",
+              ssl, fdObject, shc, b, offset, len, write_timeout_millis);
     if (ssl == NULL) {
         return;
     }
diff --git a/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/NativeCryptoTest.java b/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/NativeCryptoTest.java
index a215445..f5cb7fd 100644
--- a/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/NativeCryptoTest.java
+++ b/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/NativeCryptoTest.java
@@ -868,17 +868,21 @@ public class NativeCryptoTest extends TestCase {
                                        Socket sock, FileDescriptor fd,
                                        SSLHandshakeCallbacks callback)
                     throws Exception {
-                NativeCrypto.SSL_set_verify(s, NativeCrypto.SSL_VERIFY_PEER);
-                NativeCrypto.SSL_set_options(
-                        s, NativeCrypto.SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION);
-                NativeCrypto.SSL_renegotiate(s);
-                NativeCrypto.SSL_write(s, fd, callback, new byte[] { 42 }, 0, 1, 0);
-                super.afterHandshake(session, s, c, sock, fd, callback);
+                try {
+                    NativeCrypto.SSL_set_verify(s, NativeCrypto.SSL_VERIFY_PEER);
+                    NativeCrypto.SSL_set_options(
+                            s, NativeCrypto.SSL_OP_NO_SESSION_RESUMPTION_ON_RENEGOTIATION);
+                    NativeCrypto.SSL_renegotiate(s);
+                    NativeCrypto.SSL_write(s, fd, callback, new byte[] { 42 }, 0, 1,
+                                           (int) ((TIMEOUT_SECONDS * 1000) / 2));
+                } catch (SocketTimeoutException expected) {
+                } finally {
+                    super.afterHandshake(session, s, c, sock, fd, callback);
+                }
             }
         };
         Future<TestSSLHandshakeCallbacks> client = handshake(listener, 0, true, cHooks, null);
         Future<TestSSLHandshakeCallbacks> server = handshake(listener, 0, false, sHooks, null);
-        server.get(TIMEOUT_SECONDS, TimeUnit.SECONDS);
         try {
             client.get(TIMEOUT_SECONDS, TimeUnit.SECONDS);
         } catch (ExecutionException e) {
@@ -886,6 +890,7 @@ public class NativeCryptoTest extends TestCase {
                 throw e;
             }
         }
+        server.get(TIMEOUT_SECONDS, TimeUnit.SECONDS);
     }
 
     public void test_SSL_do_handshake_client_timeout() throws Exception {
-- 
cgit v1.1


From 51de62cf77a070e2a45ae397c391832b9a781d91 Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Sun, 30 Sep 2012 00:01:15 -0700
Subject: Fix flaky NativeCryptoTest.test_SSL_do_handshake_client_timeout

Fix similar issue in test_SSL_do_handshake_server_timeout

Bug: 6229479
Change-Id: If2cf7d7dfe468843285a531f4b8b42941996a3ed
---
 ...che_harmony_xnet_provider_jsse_NativeCrypto.cpp |  3 +
 .../xnet/provider/jsse/NativeCryptoTest.java       | 64 +++++++++++++++-------
 2 files changed, 46 insertions(+), 21 deletions(-)

diff --git a/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp b/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
index 83f28d2..95dcbf5 100644
--- a/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
+++ b/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
@@ -2264,12 +2264,15 @@ class AppData {
     static AppData* create() {
         UniquePtr<AppData> appData(new AppData());
         if (pipe(appData.get()->fdsEmergency) == -1) {
+            ALOGE("AppData::create pipe(2) failed: %s", strerror(errno));
             return NULL;
         }
         if (!setBlocking(appData.get()->fdsEmergency[0], false)) {
+            ALOGE("AppData::create fcntl(2) failed: %s", strerror(errno));
             return NULL;
         }
         if (MUTEX_SETUP(appData.get()->mutex) == -1) {
+            ALOGE("pthread_mutex_init(3) failed: %s", strerror(errno));
             return NULL;
         }
         return appData.release();
diff --git a/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/NativeCryptoTest.java b/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/NativeCryptoTest.java
index a215445..5b90045 100644
--- a/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/NativeCryptoTest.java
+++ b/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/NativeCryptoTest.java
@@ -42,6 +42,7 @@ import javax.net.ssl.SSLException;
 import javax.net.ssl.SSLProtocolException;
 import javax.security.auth.x500.X500Principal;
 import junit.framework.TestCase;
+import libcore.io.IoUtils;
 import libcore.java.security.StandardNames;
 import libcore.java.security.TestKeyStore;
 import org.apache.harmony.xnet.provider.jsse.NativeCrypto.SSLHandshakeCallbacks;
@@ -51,7 +52,8 @@ public class NativeCryptoTest extends TestCase {
 
     private static final int NULL = 0;
     private static final FileDescriptor INVALID_FD = new FileDescriptor();
-    private static final SSLHandshakeCallbacks DUMMY_CB = new TestSSLHandshakeCallbacks(-1, null);
+    private static final SSLHandshakeCallbacks DUMMY_CB
+            = new TestSSLHandshakeCallbacks(null, 0, null);
 
     private static final long TIMEOUT_SECONDS = 5;
 
@@ -145,17 +147,11 @@ public class NativeCryptoTest extends TestCase {
         KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA");
         kpg.initialize(512);
 
-        RSAPrivateCrtKey privKey1, privKey2;
+        KeyPair kp1 = kpg.generateKeyPair();
+        RSAPrivateCrtKey privKey1 = (RSAPrivateCrtKey) kp1.getPrivate();
 
-        {
-            KeyPair kp1 = kpg.generateKeyPair();
-            privKey1 = (RSAPrivateCrtKey) kp1.getPrivate();
-        }
-
-        {
-            KeyPair kp2 = kpg.generateKeyPair();
-            privKey2 = (RSAPrivateCrtKey) kp2.getPrivate();
-        }
+        KeyPair kp2 = kpg.generateKeyPair();
+        RSAPrivateCrtKey privKey2 = (RSAPrivateCrtKey) kp2.getPrivate();
 
         int pkey1 = 0, pkey1_copy = 0, pkey2 = 0;
         try {
@@ -581,11 +577,14 @@ public class NativeCryptoTest extends TestCase {
     }
 
     public static class TestSSLHandshakeCallbacks implements SSLHandshakeCallbacks {
+        private final Socket socket;
         private final int sslNativePointer;
         private final Hooks hooks;
 
-        public TestSSLHandshakeCallbacks(int sslNativePointer,
+        public TestSSLHandshakeCallbacks(Socket socket,
+                                         int sslNativePointer,
                                          Hooks hooks) {
+            this.socket = socket;
             this.sslNativePointer = sslNativePointer;
             this.hooks = hooks;
         }
@@ -637,6 +636,10 @@ public class NativeCryptoTest extends TestCase {
             }
             this.handshakeCompletedCalled = true;
         }
+
+        public Socket getSocket() {
+            return socket;
+        }
     }
 
     public static class ServerHooks extends Hooks {
@@ -674,12 +677,13 @@ public class NativeCryptoTest extends TestCase {
                                               listener.getLocalPort())
                                  : listener.accept());
                 if (timeout == -1) {
-                    return null;
+                    return new TestSSLHandshakeCallbacks(socket, 0, null);
                 }
                 FileDescriptor fd = socket.getFileDescriptor$();
                 int c = hooks.getContext();
                 int s = hooks.beforeHandshake(c);
-                TestSSLHandshakeCallbacks callback = new TestSSLHandshakeCallbacks(s, hooks);
+                TestSSLHandshakeCallbacks callback
+                        = new TestSSLHandshakeCallbacks(socket, s, hooks);
                 if (DEBUG) {
                     System.out.println("ssl=0x" + Integer.toString(s, 16)
                                        + " handshake"
@@ -689,14 +693,19 @@ public class NativeCryptoTest extends TestCase {
                                        + " timeout=" + timeout
                                        + " client=" + client);
                 }
-                int session = NativeCrypto.SSL_do_handshake(s, fd, callback, timeout, client,
-                        npnProtocols);
-                if (DEBUG) {
-                    System.out.println("ssl=0x" + Integer.toString(s, 16)
-                                       + " handshake"
-                                       + " session=0x" + Integer.toString(session, 16));
+                int session = NULL;
+                try {
+                    session = NativeCrypto.SSL_do_handshake(s, fd, callback, timeout, client,
+                                                            npnProtocols);
+                    if (DEBUG) {
+                        System.out.println("ssl=0x" + Integer.toString(s, 16)
+                                           + " handshake"
+                                           + " session=0x" + Integer.toString(session, 16));
+                    }
+                } finally {
+                    // Ensure afterHandshake is called to free resources
+                    hooks.afterHandshake(session, s, c, socket, fd, callback);
                 }
-                hooks.afterHandshake(session, s, c, socket, fd, callback);
                 return callback;
             }
         });
@@ -891,30 +900,43 @@ public class NativeCryptoTest extends TestCase {
     public void test_SSL_do_handshake_client_timeout() throws Exception {
         // client timeout
         final ServerSocket listener = new ServerSocket(0);
+        Socket serverSocket = null;
         try {
             Hooks cHooks = new Hooks();
             Hooks sHooks = new ServerHooks(getServerPrivateKey(), getServerCertificates());
             Future<TestSSLHandshakeCallbacks> client = handshake(listener, 1, true, cHooks, null);
             Future<TestSSLHandshakeCallbacks> server = handshake(listener, -1, false, sHooks, null);
+            serverSocket = server.get(TIMEOUT_SECONDS, TimeUnit.SECONDS).getSocket();
             client.get(TIMEOUT_SECONDS, TimeUnit.SECONDS);
             fail();
         } catch (ExecutionException expected) {
+            if (SocketTimeoutException.class != expected.getCause().getClass()) {
+                expected.printStackTrace();
+            }
             assertEquals(SocketTimeoutException.class, expected.getCause().getClass());
+        } finally {
+            // Manually close peer socket when testing timeout
+            IoUtils.closeQuietly(serverSocket);
         }
     }
 
     public void test_SSL_do_handshake_server_timeout() throws Exception {
         // server timeout
         final ServerSocket listener = new ServerSocket(0);
+        Socket clientSocket = null;
         try {
             Hooks cHooks = new Hooks();
             Hooks sHooks = new ServerHooks(getServerPrivateKey(), getServerCertificates());
             Future<TestSSLHandshakeCallbacks> client = handshake(listener, -1, true, cHooks, null);
             Future<TestSSLHandshakeCallbacks> server = handshake(listener, 1, false, sHooks, null);
+            clientSocket = client.get(TIMEOUT_SECONDS, TimeUnit.SECONDS).getSocket();
             server.get(TIMEOUT_SECONDS, TimeUnit.SECONDS);
             fail();
         } catch (ExecutionException expected) {
             assertEquals(SocketTimeoutException.class, expected.getCause().getClass());
+        } finally {
+            // Manually close peer socket when testing timeout
+            IoUtils.closeQuietly(clientSocket);
         }
     }
 
-- 
cgit v1.1


From b2e6be1cc1d375ca2fc28ee1fdfc10c0adc2554d Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Fri, 28 Sep 2012 15:53:29 -0700
Subject: Rewrite NIO Pipe to use socketpair(2).

Our Pipe originally used socket(2) to create AF_INET/AF_INET6
sockets. This was clearly a bad idea.

I rewrote it to use socketpair(2) and AF_UNIX, but this was
before the big "expose POSIX" rewrite, so it required a bunch
of hacks in the native code, so I went with pipe(2) instead.

The trouble with pipe(2) is that we end up using FileChannel
to implement the Pipe.SinkChannel and Pipe.SourceChannel, but
the kernel won't wake a read(2) on a pipe if another thread
calls close(2) on it, so we started failing interrupt tests.

This (final?) rewrite is hopefully the best of all worlds:
we don't have any INTERNET permission needs, the code is as
simple as the pipe(2) code, and interruption works.

Bug: 7084342
Bug: 2735373
Bug: http://code.google.com/p/android/issues/detail?id=9431

(cherry picked from commit 3218082325b6b8713a8ac15731482e3da86a7df9)

Change-Id: Ib92cdf8c818f6bba1f00e191f1b624ce9e693754
---
 luni/src/main/java/java/nio/PipeImpl.java          | 46 +++++++++-------------
 .../main/java/java/nio/SelectorProviderImpl.java   |  2 +-
 luni/src/main/java/java/nio/SocketChannelImpl.java |  9 +++++
 luni/src/main/java/libcore/io/BlockGuardOs.java    |  6 +++
 luni/src/main/java/libcore/io/ForwardingOs.java    |  1 +
 luni/src/main/java/libcore/io/Os.java              |  1 +
 luni/src/main/java/libcore/io/Posix.java           |  1 +
 luni/src/main/native/libcore_io_Posix.cpp          | 10 +++++
 8 files changed, 47 insertions(+), 29 deletions(-)

diff --git a/luni/src/main/java/java/nio/PipeImpl.java b/luni/src/main/java/java/nio/PipeImpl.java
index 50028f4..d4dde3b 100644
--- a/luni/src/main/java/java/nio/PipeImpl.java
+++ b/luni/src/main/java/java/nio/PipeImpl.java
@@ -19,8 +19,8 @@ package java.nio;
 import java.io.Closeable;
 import java.io.FileDescriptor;
 import java.io.IOException;
-import java.nio.channels.FileChannel;
 import java.nio.channels.Pipe;
+import java.nio.channels.SocketChannel;
 import java.nio.channels.spi.SelectorProvider;
 import libcore.io.ErrnoException;
 import libcore.io.IoUtils;
@@ -34,13 +34,16 @@ final class PipeImpl extends Pipe {
     private final PipeSinkChannel sink;
     private final PipeSourceChannel source;
 
-    public PipeImpl() throws IOException {
+    public PipeImpl(SelectorProvider selectorProvider) throws IOException {
         try {
-            FileDescriptor[] fds = Libcore.os.pipe();
-            // Which fd is used for which channel is important. Unix pipes are only guaranteed to be
-            // unidirectional, and indeed are only unidirectional on Linux.
-            this.sink = new PipeSinkChannel(fds[1]);
-            this.source = new PipeSourceChannel(fds[0]);
+            FileDescriptor fd1 = new FileDescriptor();
+            FileDescriptor fd2 = new FileDescriptor();
+            Libcore.os.socketpair(AF_UNIX, SOCK_STREAM, 0, fd1, fd2);
+
+            // It doesn't matter which file descriptor we use for which end;
+            // they're guaranteed to be indistinguishable.
+            this.sink = new PipeSinkChannel(selectorProvider, fd1);
+            this.source = new PipeSourceChannel(selectorProvider, fd2);
         } catch (ErrnoException errnoException) {
             throw errnoException.rethrowAsIOException();
         }
@@ -54,27 +57,14 @@ final class PipeImpl extends Pipe {
         return source;
     }
 
-    /**
-     * FileChannelImpl doesn't close its fd itself; it calls close on the object it's given.
-     */
-    private static class FdCloser implements Closeable {
-        private final FileDescriptor fd;
-        private FdCloser(FileDescriptor fd) {
-            this.fd = fd;
-        }
-        public void close() throws IOException {
-            IoUtils.close(fd);
-        }
-    }
-
     private class PipeSourceChannel extends Pipe.SourceChannel implements FileDescriptorChannel {
         private final FileDescriptor fd;
-        private final FileChannel channel;
+        private final SocketChannel channel;
 
-        private PipeSourceChannel(FileDescriptor fd) throws IOException {
-            super(SelectorProvider.provider());
+        private PipeSourceChannel(SelectorProvider selectorProvider, FileDescriptor fd) throws IOException {
+            super(selectorProvider);
             this.fd = fd;
-            this.channel = NioUtils.newFileChannel(new FdCloser(fd), fd, O_RDONLY);
+            this.channel = new SocketChannelImpl(selectorProvider, fd);
         }
 
         @Override protected void implCloseSelectableChannel() throws IOException {
@@ -104,12 +94,12 @@ final class PipeImpl extends Pipe {
 
     private class PipeSinkChannel extends Pipe.SinkChannel implements FileDescriptorChannel {
         private final FileDescriptor fd;
-        private final FileChannel channel;
+        private final SocketChannel channel;
 
-        private PipeSinkChannel(FileDescriptor fd) throws IOException {
-            super(SelectorProvider.provider());
+        private PipeSinkChannel(SelectorProvider selectorProvider, FileDescriptor fd) throws IOException {
+            super(selectorProvider);
             this.fd = fd;
-            this.channel = NioUtils.newFileChannel(new FdCloser(fd), fd, O_WRONLY);
+            this.channel = new SocketChannelImpl(selectorProvider, fd);
         }
 
         @Override protected void implCloseSelectableChannel() throws IOException {
diff --git a/luni/src/main/java/java/nio/SelectorProviderImpl.java b/luni/src/main/java/java/nio/SelectorProviderImpl.java
index 03003fe..b7c34e8 100644
--- a/luni/src/main/java/java/nio/SelectorProviderImpl.java
+++ b/luni/src/main/java/java/nio/SelectorProviderImpl.java
@@ -34,7 +34,7 @@ public final class SelectorProviderImpl extends SelectorProvider {
     }
 
     public Pipe openPipe() throws IOException {
-        return new PipeImpl();
+        return new PipeImpl(this);
     }
 
     public AbstractSelector openSelector() throws IOException {
diff --git a/luni/src/main/java/java/nio/SocketChannelImpl.java b/luni/src/main/java/java/nio/SocketChannelImpl.java
index ff2c157..233daf0 100644
--- a/luni/src/main/java/java/nio/SocketChannelImpl.java
+++ b/luni/src/main/java/java/nio/SocketChannelImpl.java
@@ -103,6 +103,15 @@ class SocketChannelImpl extends SocketChannel implements FileDescriptorChannel {
     }
 
     /*
+     * Constructor for use by Pipe.SinkChannel and Pipe.SourceChannel.
+     */
+    public SocketChannelImpl(SelectorProvider selectorProvider, FileDescriptor existingFd) throws IOException {
+        super(selectorProvider);
+        status = SOCKET_STATUS_CONNECTED;
+        fd = existingFd;
+    }
+
+    /*
      * Getting the internal Socket If we have not the socket, we create a new
      * one.
      */
diff --git a/luni/src/main/java/libcore/io/BlockGuardOs.java b/luni/src/main/java/libcore/io/BlockGuardOs.java
index 61c9765..c61a3cf 100644
--- a/luni/src/main/java/libcore/io/BlockGuardOs.java
+++ b/luni/src/main/java/libcore/io/BlockGuardOs.java
@@ -181,6 +181,12 @@ public class BlockGuardOs extends ForwardingOs {
         return tagSocket(os.socket(domain, type, protocol));
     }
 
+    @Override public void socketpair(int domain, int type, int protocol, FileDescriptor fd1, FileDescriptor fd2) throws ErrnoException {
+        os.socketpair(domain, type, protocol, fd1, fd2);
+        tagSocket(fd1);
+        tagSocket(fd2);
+    }
+
     @Override public int write(FileDescriptor fd, ByteBuffer buffer) throws ErrnoException {
         BlockGuard.getThreadPolicy().onWriteToDisk();
         return os.write(fd, buffer);
diff --git a/luni/src/main/java/libcore/io/ForwardingOs.java b/luni/src/main/java/libcore/io/ForwardingOs.java
index 719c5f0..ee26d04 100644
--- a/luni/src/main/java/libcore/io/ForwardingOs.java
+++ b/luni/src/main/java/libcore/io/ForwardingOs.java
@@ -121,6 +121,7 @@ public class ForwardingOs implements Os {
     public void setuid(int uid) throws ErrnoException { os.setuid(uid); }
     public void shutdown(FileDescriptor fd, int how) throws ErrnoException { os.shutdown(fd, how); }
     public FileDescriptor socket(int domain, int type, int protocol) throws ErrnoException { return os.socket(domain, type, protocol); }
+    public void socketpair(int domain, int type, int protocol, FileDescriptor fd1, FileDescriptor fd2) throws ErrnoException { os.socketpair(domain, type, protocol, fd1, fd2); }
     public StructStat stat(String path) throws ErrnoException { return os.stat(path); }
     public StructStatFs statfs(String path) throws ErrnoException { return os.statfs(path); }
     public String strerror(int errno) { return os.strerror(errno); }
diff --git a/luni/src/main/java/libcore/io/Os.java b/luni/src/main/java/libcore/io/Os.java
index 55588d8..1f42497 100644
--- a/luni/src/main/java/libcore/io/Os.java
+++ b/luni/src/main/java/libcore/io/Os.java
@@ -114,6 +114,7 @@ public interface Os {
     public void setuid(int uid) throws ErrnoException;
     public void shutdown(FileDescriptor fd, int how) throws ErrnoException;
     public FileDescriptor socket(int domain, int type, int protocol) throws ErrnoException;
+    public void socketpair(int domain, int type, int protocol, FileDescriptor fd1, FileDescriptor fd2) throws ErrnoException;
     public StructStat stat(String path) throws ErrnoException;
     /* TODO: replace statfs with statvfs. */
     public StructStatFs statfs(String path) throws ErrnoException;
diff --git a/luni/src/main/java/libcore/io/Posix.java b/luni/src/main/java/libcore/io/Posix.java
index ad01bcf..2fb187e 100644
--- a/luni/src/main/java/libcore/io/Posix.java
+++ b/luni/src/main/java/libcore/io/Posix.java
@@ -165,6 +165,7 @@ public final class Posix implements Os {
     public native void setuid(int uid) throws ErrnoException;
     public native void shutdown(FileDescriptor fd, int how) throws ErrnoException;
     public native FileDescriptor socket(int domain, int type, int protocol) throws ErrnoException;
+    public native void socketpair(int domain, int type, int protocol, FileDescriptor fd1, FileDescriptor fd2) throws ErrnoException;
     public native StructStat stat(String path) throws ErrnoException;
     public native StructStatFs statfs(String path) throws ErrnoException;
     public native String strerror(int errno);
diff --git a/luni/src/main/native/libcore_io_Posix.cpp b/luni/src/main/native/libcore_io_Posix.cpp
index dd9b87f..acb3dc2 100644
--- a/luni/src/main/native/libcore_io_Posix.cpp
+++ b/luni/src/main/native/libcore_io_Posix.cpp
@@ -1168,6 +1168,15 @@ static jobject Posix_socket(JNIEnv* env, jobject, jint domain, jint type, jint p
     return fd != -1 ? jniCreateFileDescriptor(env, fd) : NULL;
 }
 
+static void Posix_socketpair(JNIEnv* env, jobject, jint domain, jint type, jint protocol, jobject javaFd1, jobject javaFd2) {
+    int fds[2];
+    int rc = throwIfMinusOne(env, "socketpair", TEMP_FAILURE_RETRY(socketpair(domain, type, protocol, fds)));
+    if (rc != -1) {
+        jniSetFileDescriptorOfFD(env, javaFd1, fds[0]);
+        jniSetFileDescriptorOfFD(env, javaFd2, fds[1]);
+    }
+}
+
 static jobject Posix_stat(JNIEnv* env, jobject, jstring javaPath) {
     return doStat(env, javaPath, false);
 }
@@ -1341,6 +1350,7 @@ static JNINativeMethod gMethods[] = {
     NATIVE_METHOD(Posix, setuid, "(I)V"),
     NATIVE_METHOD(Posix, shutdown, "(Ljava/io/FileDescriptor;I)V"),
     NATIVE_METHOD(Posix, socket, "(III)Ljava/io/FileDescriptor;"),
+    NATIVE_METHOD(Posix, socketpair, "(IIILjava/io/FileDescriptor;Ljava/io/FileDescriptor;)V"),
     NATIVE_METHOD(Posix, stat, "(Ljava/lang/String;)Llibcore/io/StructStat;"),
     NATIVE_METHOD(Posix, statfs, "(Ljava/lang/String;)Llibcore/io/StructStatFs;"),
     NATIVE_METHOD(Posix, strerror, "(I)Ljava/lang/String;"),
-- 
cgit v1.1


From 50e50d57783060196a1f8e367616f2109c9edb4e Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Thu, 4 Oct 2012 23:10:28 -0700
Subject: Ensure we give "tl" the display name "Filipino".

This isn't right for all locales, but it's right for "tl" in "tl" itself,
which is how we render language names in Settings.

(Yes, I know that "tl" is for "Tagalog" and "fil" is for "Filipino", but
Google policy is to use the latter name. If our resource system weren't
limited to two-letter language codes, we'd be using the modern three-letter
"fil" instead of the obsolete "tl", but we can't fix that right now. Bukas.)

Bug: 7291355
Change-Id: I7d9021dc55d9f1d3f8a75b10c890a2d5f91982d6
---
 luni/src/main/java/java/util/Locale.java             | 11 +++++++++++
 luni/src/test/java/libcore/java/util/LocaleTest.java | 10 ++++++++++
 2 files changed, 21 insertions(+)

diff --git a/luni/src/main/java/java/util/Locale.java b/luni/src/main/java/java/util/Locale.java
index 6b20a1c..0fbe2f5 100644
--- a/luni/src/main/java/java/util/Locale.java
+++ b/luni/src/main/java/java/util/Locale.java
@@ -396,6 +396,17 @@ public final class Locale implements Cloneable, Serializable {
         if (languageCode.isEmpty()) {
             return "";
         }
+
+        // Last-minute workaround for http://b/7291355 in jb-mr1.
+        // This isn't right for all languages, but it's right for en and tl.
+        // We should have more CLDR data in a future release, but we'll still
+        // probably want to have frameworks/base translate the obsolete tl and
+        // tl-rPH locales to fil and fil-rPH at runtime, at which point
+        // libcore and icu4c will just do the right thing.
+        if (languageCode.equals("tl")) {
+            return "Filipino";
+        }
+
         String result = ICU.getDisplayLanguageNative(toString(), locale.toString());
         if (result == null) { // TODO: do we need to do this, or does ICU do it for us?
             result = ICU.getDisplayLanguageNative(toString(), Locale.getDefault().toString());
diff --git a/luni/src/test/java/libcore/java/util/LocaleTest.java b/luni/src/test/java/libcore/java/util/LocaleTest.java
index 541dd66..b146b1a 100644
--- a/luni/src/test/java/libcore/java/util/LocaleTest.java
+++ b/luni/src/test/java/libcore/java/util/LocaleTest.java
@@ -46,6 +46,16 @@ public class LocaleTest extends junit.framework.TestCase {
         assertEquals("Deutsch", Locale.GERMAN.getDisplayLanguage(Locale.GERMAN));
     }
 
+    // http://b/7291355; Locale.getDisplayLanguage fails for tl in tl in ICU 4.9.
+    public void test_tl() throws Exception {
+        Locale tl = new Locale("tl");
+        Locale tl_PH = new Locale("tl", "PH");
+        assertEquals("Filipino", tl.getDisplayLanguage(Locale.ENGLISH));
+        assertEquals("Filipino", tl_PH.getDisplayLanguage(Locale.ENGLISH));
+        assertEquals("Filipino", tl.getDisplayLanguage(tl));
+        assertEquals("Filipino", tl_PH.getDisplayLanguage(tl_PH));
+    }
+
     // http://b/3452611; Locale.getDisplayLanguage fails for the obsolete language codes.
     public void test_getDisplayName_obsolete() throws Exception {
         // he (new) -> iw (obsolete)
-- 
cgit v1.1


From b11e44a402eb0f9c5da1f7482fc1eabdd9adff47 Mon Sep 17 00:00:00 2001
From: Jesse Wilson <jwilson@squareup.com>
Date: Thu, 20 Sep 2012 16:47:52 -0400
Subject: Fix a bug in tunnel construction and 'Connection: close' headers.

Based on https://github.com/square/okhttp/pull/30
(git fetch git://github.com/square/okhttp.git && git cherry-pick -x b8c51dc5bdc89d5487cbc110d6fe40389de16480)

Bug: http://code.google.com/p/android/issues/detail?id=37221
Bug: 7291446

(cherry picked from commit 4bedacd569fed2db56c518ed239412b3fe32245e)

Change-Id: I68c55e9259db91dbccca30824c00726094570304
---
 luni/src/main/java/libcore/net/http/HttpEngine.java | 16 +++++++++-------
 .../java/libcore/java/net/URLConnectionTest.java    | 21 +++++++++++++++++++++
 2 files changed, 30 insertions(+), 7 deletions(-)

diff --git a/luni/src/main/java/libcore/net/http/HttpEngine.java b/luni/src/main/java/libcore/net/http/HttpEngine.java
index 8f97c81..42c9b96 100644
--- a/luni/src/main/java/libcore/net/http/HttpEngine.java
+++ b/luni/src/main/java/libcore/net/http/HttpEngine.java
@@ -491,8 +491,15 @@ public class HttpEngine {
                 reusable = false;
             }
 
-            // If the headers specify that the connection shouldn't be reused, don't reuse it.
-            if (hasConnectionCloseHeader()) {
+            // If the request specified that the connection shouldn't be reused,
+            // don't reuse it. This advice doesn't apply to CONNECT requests because
+            // the "Connection: close" header goes the origin server, not the proxy.
+            if (requestHeaders.hasConnectionClose() && method != CONNECT) {
+                reusable = false;
+            }
+
+            // If the response specified that the connection shouldn't be reused, don't reuse it.
+            if (responseHeaders != null && responseHeaders.hasConnectionClose()) {
                 reusable = false;
             }
 
@@ -764,11 +771,6 @@ public class HttpEngine {
         return agent != null ? agent : ("Java" + System.getProperty("java.version"));
     }
 
-    private boolean hasConnectionCloseHeader() {
-        return (responseHeaders != null && responseHeaders.hasConnectionClose())
-                || requestHeaders.hasConnectionClose();
-    }
-
     protected final String getOriginAddress(URL url) {
         int port = url.getPort();
         String result = url.getHost();
diff --git a/luni/src/test/java/libcore/java/net/URLConnectionTest.java b/luni/src/test/java/libcore/java/net/URLConnectionTest.java
index d7a4544..e40ba57 100644
--- a/luni/src/test/java/libcore/java/net/URLConnectionTest.java
+++ b/luni/src/test/java/libcore/java/net/URLConnectionTest.java
@@ -795,6 +795,27 @@ public final class URLConnectionTest extends TestCase {
         assertContainsNoneMatching(get.getHeaders(), "Proxy\\-Authorization.*");
     }
 
+    // Don't disconnect after building a tunnel with CONNECT
+    // http://code.google.com/p/android/issues/detail?id=37221
+    public void testProxyWithConnectionClose() throws IOException {
+        TestSSLContext testSSLContext = TestSSLContext.create();
+        server.useHttps(testSSLContext.serverContext.getSocketFactory(), true);
+        server.enqueue(new MockResponse()
+                .setSocketPolicy(SocketPolicy.UPGRADE_TO_SSL_AT_END)
+                .clearHeaders());
+        server.enqueue(new MockResponse().setBody("this response comes via a proxy"));
+        server.play();
+
+        URL url = new URL("https://android.com/foo");
+        HttpsURLConnection connection = (HttpsURLConnection) url.openConnection(
+                server.toProxyAddress());
+        connection.setRequestProperty("Connection", "close");
+        connection.setSSLSocketFactory(testSSLContext.clientContext.getSocketFactory());
+        connection.setHostnameVerifier(new RecordingHostnameVerifier());
+
+        assertContent("this response comes via a proxy", connection);
+    }
+
     public void testDisconnectedConnection() throws IOException {
         server.enqueue(new MockResponse().setBody("ABCDEFGHIJKLMNOPQR"));
         server.play();
-- 
cgit v1.1


From f3862a786823c304a0f36f11266c66a55a68a5cf Mon Sep 17 00:00:00 2001
From: Kenny Root <kroot@google.com>
Date: Fri, 5 Oct 2012 16:23:06 -0700
Subject: NativeCrypto: clear errors for key verification

It appears that OpenSSL has a bug where any DSA key verification
operation that fails will push an error on the OpenSSL error stack. This
change will clear the error state whenever a key verification is
performed.

(cherry picked from commit 912d5102b2986e3cdedb311784a43c7fe68db790)

Bug: 7302619
Change-Id: I16d1afad20f2d3934a01963ab62eea45b6caa6a1
---
 .../native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp  | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp b/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
index cb82226..1cecffc 100644
--- a/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
+++ b/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
@@ -1810,6 +1810,13 @@ static jint NativeCrypto_EVP_VerifyFinal(JNIEnv* env, jclass, jint ctxRef, jbyte
     if (ok < 0) {
         throwExceptionIfNecessary(env, "NativeCrypto_EVP_VerifyFinal");
     }
+
+    /*
+     * For DSA keys, OpenSSL appears to have a bug where it returns
+     * errors for any result != 1. See dsa_ossl.c in dsa_do_verify
+     */
+    freeOpenSslErrorState();
+
     JNI_TRACE("NativeCrypto_EVP_VerifyFinal(%p, %p, %d, %d, %p) => %d",
               ctx, buffer, offset, length, pkey, ok);
 
-- 
cgit v1.1


From 29e51335337132ebe338b61c7ff16ec4005285c9 Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Sun, 7 Oct 2012 22:07:36 -0700
Subject: 
 NativeCryptoTest#test_SSL_do_handshake_clientCertificateRequested_throws_after_renegotiate

Depending on the timing of the two threads, SocketTimeoutException or SSLProtocolException can be thrown.

Bug: 6964910
Change-Id: Ia921f0dc61d1f2eb39a8d41c4ff6d551c924977e
---
 .../java/org/apache/harmony/xnet/provider/jsse/NativeCryptoTest.java    | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/NativeCryptoTest.java b/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/NativeCryptoTest.java
index d4d9349..303c234 100644
--- a/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/NativeCryptoTest.java
+++ b/luni/src/test/java/org/apache/harmony/xnet/provider/jsse/NativeCryptoTest.java
@@ -884,7 +884,7 @@ public class NativeCryptoTest extends TestCase {
                     NativeCrypto.SSL_renegotiate(s);
                     NativeCrypto.SSL_write(s, fd, callback, new byte[] { 42 }, 0, 1,
                                            (int) ((TIMEOUT_SECONDS * 1000) / 2));
-                } catch (SocketTimeoutException expected) {
+                } catch (IOException expected) {
                 } finally {
                     super.afterHandshake(session, s, c, sock, fd, callback);
                 }
-- 
cgit v1.1


From cc5d0071987b9cacd58750e53ede3fd3b53fb2c9 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Wed, 10 Oct 2012 11:45:03 -0700
Subject: Fix races in OldPreferencesTest.

(cherry-pick of 0f12963651c3f11e50c36c96338fab085ed0bbd9.)

Bug: 6972612
Change-Id: Ibc919c7023898f9e521f222d69c7efb50a170923
---
 .../java/util/prefs/OldPreferencesTest.java        | 136 ++++++++++-----------
 1 file changed, 68 insertions(+), 68 deletions(-)

diff --git a/luni/src/test/java/libcore/java/util/prefs/OldPreferencesTest.java b/luni/src/test/java/libcore/java/util/prefs/OldPreferencesTest.java
index aa5f088..f8a8154 100644
--- a/luni/src/test/java/libcore/java/util/prefs/OldPreferencesTest.java
+++ b/luni/src/test/java/libcore/java/util/prefs/OldPreferencesTest.java
@@ -29,8 +29,10 @@ import junit.framework.TestCase;
 
 public final class OldPreferencesTest extends TestCase {
 
-    final static String longKey;
-    final static String longValue;
+    private static final boolean ENCOURAGE_RACES = false;
+
+    private static final String longKey;
+    private static final String longValue;
 
     static {
         StringBuilder key = new StringBuilder(Preferences.MAX_KEY_LENGTH);
@@ -316,8 +318,7 @@ public final class OldPreferencesTest extends TestCase {
         String longName = name.toString();
 
         Preferences root = Preferences.userRoot();
-        Preferences parent = Preferences
-                .userNodeForPackage(Preferences.class);
+        Preferences parent = Preferences.userNodeForPackage(Preferences.class);
         Preferences pref = parent.node("mock");
 
         try {
@@ -352,8 +353,7 @@ public final class OldPreferencesTest extends TestCase {
 
     public void testNodeExists() throws BackingStoreException {
 
-        Preferences parent = Preferences
-                .userNodeForPackage(Preferences.class);
+        Preferences parent = Preferences.userNodeForPackage(Preferences.class);
         Preferences pref = parent.node("mock");
 
         try {
@@ -393,16 +393,14 @@ public final class OldPreferencesTest extends TestCase {
     }
 
     public void testParent() {
-        Preferences parent = Preferences
-                .userNodeForPackage(Preferences.class);
+        Preferences parent = Preferences.userNodeForPackage(Preferences.class);
         Preferences pref = parent.node("mock");
 
         assertSame(parent, pref.parent());
     }
 
     public void testPut() throws BackingStoreException {
-        Preferences pref = Preferences
-        .userNodeForPackage(Preferences.class);
+        Preferences pref = Preferences.userNodeForPackage(Preferences.class);
         pref.put("", "emptyvalue");
         assertEquals("emptyvalue", pref.get("", null));
         pref.put("testPutkey", "value1");
@@ -468,8 +466,7 @@ public final class OldPreferencesTest extends TestCase {
     }
 
     public void testPutDouble() {
-        Preferences pref = Preferences
-        .userNodeForPackage(Preferences.class);
+        Preferences pref = Preferences.userNodeForPackage(Preferences.class);
         try {
             pref.putDouble(null, 3);
             fail();
@@ -580,8 +577,7 @@ public final class OldPreferencesTest extends TestCase {
     }
 
     public void testRemove() throws BackingStoreException {
-        Preferences pref = Preferences
-        .userNodeForPackage(Preferences.class);
+        Preferences pref = Preferences.userNodeForPackage(Preferences.class);
         pref.remove("key");
 
         pref.put("key", "value");
@@ -606,8 +602,7 @@ public final class OldPreferencesTest extends TestCase {
     }
 
     public void testRemoveNode() throws BackingStoreException {
-        Preferences pref = Preferences
-        .userNodeForPackage(Preferences.class);
+        Preferences pref = Preferences.userNodeForPackage(Preferences.class);
         Preferences child = pref.node("child");
         Preferences child1 = pref.node("child1");
         Preferences grandchild = child.node("grandchild");
@@ -636,11 +631,12 @@ public final class OldPreferencesTest extends TestCase {
             nl = new MockNodeChangeListener();
             pref.addNodeChangeListener(nl);
             child1 = pref.node("mock1");
-            nl.waitForEvent();
+            nl.waitForEvent(1);
             assertEquals(1, nl.getAdded());
             nl.reset();
             pref.node("mock1");
-            nl.waitForEvent();
+            // There shouldn't be an event, but wait in case one arrives...
+            try { Thread.sleep(1000); } catch (InterruptedException ignored) {}
             assertEquals(0, nl.getAdded());
             nl.reset();
         } finally {
@@ -653,7 +649,7 @@ public final class OldPreferencesTest extends TestCase {
             pref.addNodeChangeListener(nl);
             pref.addNodeChangeListener(nl);
             child1 = pref.node("mock2");
-            nl.waitForEvent();
+            nl.waitForEvent(2);
             assertEquals(2, nl.getAdded());
             nl.reset();
         } finally {
@@ -667,7 +663,7 @@ public final class OldPreferencesTest extends TestCase {
             pref.addNodeChangeListener(nl);
             child1 = pref.node("mock3");
             child1.removeNode();
-            nl.waitForEvent();
+            nl.waitForEvent(2);
             assertEquals(1, nl.getRemoved());
             nl.reset();
         } finally {
@@ -680,7 +676,7 @@ public final class OldPreferencesTest extends TestCase {
             pref.addNodeChangeListener(nl);
             child1 = pref.node("mock6");
             child1.removeNode();
-            nl.waitForEvent();
+            nl.waitForEvent(4);
             assertEquals(2, nl.getRemoved());
             nl.reset();
         } finally {
@@ -695,27 +691,29 @@ public final class OldPreferencesTest extends TestCase {
             child1 = pref.node("mock4");
             child1.addNodeChangeListener(nl);
             pref.node("mock4/mock5");
-            nl.waitForEvent();
+            nl.waitForEvent(1);
             assertEquals(1, nl.getAdded());
             nl.reset();
             child3 = pref.node("mock4/mock5/mock6");
-            nl.waitForEvent();
+            // There shouldn't be an event, but wait in case one arrives...
+            try { Thread.sleep(1000); } catch (InterruptedException ignored) {}
             assertEquals(0, nl.getAdded());
             nl.reset();
 
             child3.removeNode();
-            nl.waitForEvent();
+            // There shouldn't be an event, but wait in case one arrives...
+            try { Thread.sleep(1000); } catch (InterruptedException ignored) {}
             assertEquals(0, nl.getRemoved());
             nl.reset();
 
             pref.node("mock4/mock7");
-            nl.waitForEvent();
+            nl.waitForEvent(1);
             assertEquals(1, nl.getAdded());
             nl.reset();
 
             child1.removeNode();
-            nl.waitForEvent();
-            assertEquals(2, nl.getRemoved()); // fail 1
+            nl.waitForEvent(2);
+            assertEquals(2, nl.getRemoved());
             nl.reset();
         } finally {
             try {
@@ -749,7 +747,7 @@ public final class OldPreferencesTest extends TestCase {
             try {
                 pref.clear();
                 pl.waitForEvent(2);
-                assertEquals(2, pl.getChanged()); // fail 1
+                assertEquals(2, pl.getChanged());
             } catch(BackingStoreException bse) {
                 pl.reset();
                 fail("BackingStoreException is thrown");
@@ -784,7 +782,7 @@ public final class OldPreferencesTest extends TestCase {
             try {
                 pref.clear();
                 pl.waitForEvent(3);
-                assertEquals(3, pl.getChanged()); // fails
+                assertEquals(3, pl.getChanged());
             } catch(BackingStoreException bse) {
                 fail("BackingStoreException is thrown");
             }
@@ -868,25 +866,38 @@ public final class OldPreferencesTest extends TestCase {
     static class MockNodeChangeListener implements NodeChangeListener {
         private int added = 0;
         private int removed = 0;
+        private int eventCount = 0;
 
-        public synchronized void waitForEvent() {
-            try {
-                wait(500);
-            } catch (InterruptedException ignored) {
+        public void waitForEvent(int count) {
+            synchronized (this) {
+                while (eventCount < count) {
+                    try {
+                        wait();
+                    } catch (InterruptedException ignored) {
+                    }
+                }
             }
         }
 
-        public synchronized void childAdded(NodeChangeEvent e) {
-            ++added;
-            notifyAll();
+        public void childAdded(NodeChangeEvent e) {
+            if (ENCOURAGE_RACES) try { Thread.sleep(1000); } catch (InterruptedException ignored) { }
+            synchronized (this) {
+                ++eventCount;
+                ++added;
+                notifyAll();
+            }
         }
 
-        public synchronized void childRemoved(NodeChangeEvent e) {
-            removed++;
-            notifyAll();
+        public void childRemoved(NodeChangeEvent e) {
+            if (ENCOURAGE_RACES) try { Thread.sleep(1000); } catch (InterruptedException ignored) { }
+            synchronized (this) {
+                ++eventCount;
+                ++removed;
+                notifyAll();
+            }
         }
 
-        public synchronized  int getAdded() {
+        public synchronized int getAdded() {
             return added;
         }
 
@@ -894,7 +905,8 @@ public final class OldPreferencesTest extends TestCase {
             return removed;
         }
 
-        public void reset() {
+        public synchronized void reset() {
+            eventCount = 0;
             added = 0;
             removed = 0;
         }
@@ -902,47 +914,35 @@ public final class OldPreferencesTest extends TestCase {
 
     private static class MockPreferenceChangeListener implements PreferenceChangeListener {
         private int changed = 0;
-        private boolean addDispatched = false;
-        private boolean result = false;
+        private int eventCount = 0;
 
         public void waitForEvent(int count) {
-            for (int i = 0; i < count; i++) {
-                try {
-                    synchronized (this) {
-                        wait(500);
+            synchronized (this) {
+                while (eventCount < count) {
+                    try {
+                        wait();
+                    } catch (InterruptedException ignored) {
                     }
-                } catch (InterruptedException ignored) {
                 }
             }
         }
 
-        public synchronized void preferenceChange(PreferenceChangeEvent pce) {
-            changed++;
-            addDispatched = true;
-            notifyAll();
-        }
-
-        public boolean getResult() throws InterruptedException {
-            if (!addDispatched) {
-                // TODO: don't know why must add limitation
-                wait(100);
+        public void preferenceChange(PreferenceChangeEvent pce) {
+            if (ENCOURAGE_RACES) try { Thread.sleep(1000); } catch (InterruptedException ignored) { }
+            synchronized (this) {
+                ++eventCount;
+                ++changed;
+                notifyAll();
             }
-            addDispatched = false;
-            return result;
         }
 
-        public synchronized int getChanged() throws InterruptedException {
-            if (!addDispatched) {
-                // TODO: don't know why must add limitation
-                wait(1000);
-            }
-            addDispatched = false;
+        public synchronized int getChanged() {
             return changed;
         }
 
-        public void reset() {
+        public synchronized void reset() {
+            eventCount = 0;
             changed = 0;
-            result = false;
         }
     }
 
-- 
cgit v1.1


From 78601286edbfed7ea072814763f661eb80f6e777 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Wed, 10 Oct 2012 14:45:57 -0700
Subject: Extra log output for ConcurrentCloseTest flakiness.

No clue what's wrong here, but we're seeing some flakiness in the
"connect" tests. Hopefully there will be a clue in this extra
output next time we see a failure.

(cherry-pick of 735875881f3995ec6a687e65a2e5495304bc48be.)

Bug: 6971145
Change-Id: I8236b2fb368581e2b6965898f109370e7e0af2e5
---
 .../java/libcore/java/net/ConcurrentCloseTest.java | 26 +++++++++++-----------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/luni/src/test/java/libcore/java/net/ConcurrentCloseTest.java b/luni/src/test/java/libcore/java/net/ConcurrentCloseTest.java
index 06a546a..6988f6f 100644
--- a/luni/src/test/java/libcore/java/net/ConcurrentCloseTest.java
+++ b/luni/src/test/java/libcore/java/net/ConcurrentCloseTest.java
@@ -38,12 +38,12 @@ import tests.net.StuckServer;
  */
 public class ConcurrentCloseTest extends junit.framework.TestCase {
     public void test_accept() throws Exception {
-        ServerSocket s = new ServerSocket(0);
-        new Killer(s).start();
+        ServerSocket ss = new ServerSocket(0);
+        new Killer(ss).start();
         try {
             System.err.println("accept...");
-            s.accept();
-            fail("accept returned!");
+            Socket s = ss.accept();
+            fail("accept returned " + s + "!");
         } catch (SocketException expected) {
             assertEquals("Socket closed", expected.getMessage());
         }
@@ -54,9 +54,9 @@ public class ConcurrentCloseTest extends junit.framework.TestCase {
         Socket s = new Socket();
         new Killer(s).start();
         try {
-            System.err.println("connect...");
+            System.err.println("connect " + s + " to " + ss.getLocalSocketAddress() + "...");
             s.connect(ss.getLocalSocketAddress());
-            fail("connect returned!");
+            fail("connect returned: " + s + "!");
         } catch (SocketException expected) {
             assertEquals("Socket closed", expected.getMessage());
         } finally {
@@ -69,9 +69,9 @@ public class ConcurrentCloseTest extends junit.framework.TestCase {
         Socket s = new Socket();
         new Killer(s).start();
         try {
-            System.err.println("connect (with timeout)...");
+            System.err.println("connect (with timeout) " + s + " to " + ss.getLocalSocketAddress() + "...");
             s.connect(ss.getLocalSocketAddress(), 3600 * 1000);
-            fail("connect returned!");
+            fail("connect returned: " + s + "!");
         } catch (SocketException expected) {
             assertEquals("Socket closed", expected.getMessage());
         } finally {
@@ -84,13 +84,13 @@ public class ConcurrentCloseTest extends junit.framework.TestCase {
         SocketChannel s = SocketChannel.open();
         new Killer(s.socket()).start();
         try {
-            System.err.println("connect (non-blocking)...");
+            System.err.println("connect (non-blocking) " + s + " to " + ss.getLocalSocketAddress() + "...");
             s.configureBlocking(false);
             s.connect(ss.getLocalSocketAddress());
             while (!s.finishConnect()) {
                 // Spin like a mad thing!
             }
-            fail("connect returned!");
+            fail("connect returned: " + s + "!");
         } catch (SocketException expected) {
             assertEquals("Socket closed", expected.getMessage());
         } catch (AsynchronousCloseException alsoOkay) {
@@ -111,7 +111,7 @@ public class ConcurrentCloseTest extends junit.framework.TestCase {
         try {
             System.err.println("read...");
             int i = s.getInputStream().read();
-            fail("read returned " + i);
+            fail("read returned: " + i);
         } catch (SocketException expected) {
             assertEquals("Socket closed", expected.getMessage());
         }
@@ -136,7 +136,7 @@ public class ConcurrentCloseTest extends junit.framework.TestCase {
                         try {
                             System.err.println("read...");
                             int i = s.getInputStream().read();
-                            fail("read returned " + i);
+                            fail("read returned: " + i);
                         } catch (SocketException expected) {
                             assertEquals("Socket closed", expected.getMessage());
                         }
@@ -238,7 +238,7 @@ public class ConcurrentCloseTest extends junit.framework.TestCase {
             try {
                 System.err.println("sleep...");
                 Thread.sleep(2000);
-                System.err.println("close...");
+                System.err.println("close " + s + "...");
                 s.getClass().getMethod("close").invoke(s);
             } catch (Exception ex) {
                 ex.printStackTrace();
-- 
cgit v1.1


From 72e44404c32a98e7675a6e7cfbf856adb499a434 Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Mon, 8 Oct 2012 17:24:36 -0700
Subject: Change OpenSSLCipherRSA.{engineGetBlockSize,engineGetOutputSize} to
 return result based on key size

Includes cherry-pick of 847f22adbd0e829b84491d7202dcbed5bf67a98c

Bug: 7192453
Change-Id: Ib5fa1e313d942d2c1034e8e7831af285ad24d71d
---
 .../xnet/provider/jsse/OpenSSLCipherRSA.java       |   24 +-
 ...che_harmony_xnet_provider_jsse_NativeCrypto.cpp |   40 +-
 .../test/java/libcore/javax/crypto/CipherTest.java | 1182 +++++++++++++++++---
 .../java/libcore/java/security/StandardNames.java  |   40 +
 4 files changed, 1078 insertions(+), 208 deletions(-)

diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLCipherRSA.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLCipherRSA.java
index a11ffa9..ddf2e0d 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLCipherRSA.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLCipherRSA.java
@@ -110,16 +110,34 @@ public abstract class OpenSSLCipherRSA extends CipherSpi {
 
     @Override
     protected int engineGetBlockSize() {
-        return 0;
+        if (encrypting) {
+            return paddedBlockSizeBytes();
+        }
+        return keySizeBytes();
     }
 
     @Override
     protected int engineGetOutputSize(int inputLen) {
+        if (encrypting) {
+            return keySizeBytes();
+        }
+        return paddedBlockSizeBytes();
+    }
+
+    private int paddedBlockSizeBytes() {
+        int paddedBlockSizeBytes = keySizeBytes();
+        if (padding == NativeCrypto.RSA_PKCS1_PADDING) {
+            paddedBlockSizeBytes--;  // for 0 prefix
+            paddedBlockSizeBytes -= 10;  // PKCS1 padding header length
+        }
+        return paddedBlockSizeBytes;
+    }
+
+    private int keySizeBytes() {
         if (key == null) {
             throw new IllegalStateException("cipher is not initialized");
         }
-
-        return buffer.length;
+        return NativeCrypto.RSA_size(this.key.getPkeyContext());
     }
 
     @Override
diff --git a/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp b/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
index 1cecffc..322f416 100644
--- a/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
+++ b/luni/src/main/native/org_apache_harmony_xnet_provider_jsse_NativeCrypto.cpp
@@ -505,11 +505,11 @@ static bool arrayToBignum(JNIEnv* env, jbyteArray source, BIGNUM** dest) {
 /**
  * Converts an OpenSSL BIGNUM to a Java byte[] array.
  */
-static jbyteArray bignumToArray(JNIEnv* env, BIGNUM* source) {
-    JNI_TRACE("bignumToArray(%p)", source);
+static jbyteArray bignumToArray(JNIEnv* env, BIGNUM* source, const char* sourceName) {
+    JNI_TRACE("bignumToArray(%p, %s)", source, sourceName);
 
     if (source == NULL) {
-        jniThrowNullPointerException(env, NULL);
+        jniThrowNullPointerException(env, sourceName);
         return NULL;
     }
 
@@ -517,7 +517,7 @@ static jbyteArray bignumToArray(JNIEnv* env, BIGNUM* source) {
     jbyteArray javaBytes = env->NewByteArray(len);
     ScopedByteArrayRW bytes(env, javaBytes);
     if (bytes.get() == NULL) {
-        JNI_TRACE("bignumToArray(%p) => NULL", source);
+        JNI_TRACE("bignumToArray(%p, %s) => NULL", source, sourceName);
         return NULL;
     }
 
@@ -535,7 +535,7 @@ static jbyteArray bignumToArray(JNIEnv* env, BIGNUM* source) {
         return NULL;
     }
 
-    JNI_TRACE("bignumToArray(%p) => %p", source, javaBytes);
+    JNI_TRACE("bignumToArray(%p, %s) => %p", source, sourceName, javaBytes);
     return javaBytes;
 }
 
@@ -1204,13 +1204,13 @@ static jobjectArray NativeCrypto_get_RSA_public_params(JNIEnv* env, jclass, jint
         return NULL;
     }
 
-    jbyteArray n = bignumToArray(env, rsa->n);
+    jbyteArray n = bignumToArray(env, rsa->n, "n");
     if (env->ExceptionCheck()) {
         return NULL;
     }
     env->SetObjectArrayElement(joa, 0, n);
 
-    jbyteArray e = bignumToArray(env, rsa->e);
+    jbyteArray e = bignumToArray(env, rsa->e, "e");
     if (env->ExceptionCheck()) {
         return NULL;
     }
@@ -1237,14 +1237,14 @@ static jobjectArray NativeCrypto_get_RSA_private_params(JNIEnv* env, jclass, jin
         return NULL;
     }
 
-    jbyteArray n = bignumToArray(env, rsa->n);
+    jbyteArray n = bignumToArray(env, rsa->n, "n");
     if (env->ExceptionCheck()) {
         return NULL;
     }
     env->SetObjectArrayElement(joa, 0, n);
 
     if (rsa->e != NULL) {
-        jbyteArray e = bignumToArray(env, rsa->e);
+        jbyteArray e = bignumToArray(env, rsa->e, "e");
         if (env->ExceptionCheck()) {
             return NULL;
         }
@@ -1252,7 +1252,7 @@ static jobjectArray NativeCrypto_get_RSA_private_params(JNIEnv* env, jclass, jin
     }
 
     if (rsa->d != NULL) {
-        jbyteArray d = bignumToArray(env, rsa->d);
+        jbyteArray d = bignumToArray(env, rsa->d, "d");
         if (env->ExceptionCheck()) {
             return NULL;
         }
@@ -1260,7 +1260,7 @@ static jobjectArray NativeCrypto_get_RSA_private_params(JNIEnv* env, jclass, jin
     }
 
     if (rsa->p != NULL) {
-        jbyteArray p = bignumToArray(env, rsa->p);
+        jbyteArray p = bignumToArray(env, rsa->p, "p");
         if (env->ExceptionCheck()) {
             return NULL;
         }
@@ -1268,7 +1268,7 @@ static jobjectArray NativeCrypto_get_RSA_private_params(JNIEnv* env, jclass, jin
     }
 
     if (rsa->q != NULL) {
-        jbyteArray q = bignumToArray(env, rsa->q);
+        jbyteArray q = bignumToArray(env, rsa->q, "q");
         if (env->ExceptionCheck()) {
             return NULL;
         }
@@ -1276,7 +1276,7 @@ static jobjectArray NativeCrypto_get_RSA_private_params(JNIEnv* env, jclass, jin
     }
 
     if (rsa->dmp1 != NULL) {
-        jbyteArray dmp1 = bignumToArray(env, rsa->dmp1);
+        jbyteArray dmp1 = bignumToArray(env, rsa->dmp1, "dmp1");
         if (env->ExceptionCheck()) {
             return NULL;
         }
@@ -1284,7 +1284,7 @@ static jobjectArray NativeCrypto_get_RSA_private_params(JNIEnv* env, jclass, jin
     }
 
     if (rsa->dmq1 != NULL) {
-        jbyteArray dmq1 = bignumToArray(env, rsa->dmq1);
+        jbyteArray dmq1 = bignumToArray(env, rsa->dmq1, "dmq1");
         if (env->ExceptionCheck()) {
             return NULL;
         }
@@ -1292,7 +1292,7 @@ static jobjectArray NativeCrypto_get_RSA_private_params(JNIEnv* env, jclass, jin
     }
 
     if (rsa->iqmp != NULL) {
-        jbyteArray iqmp = bignumToArray(env, rsa->iqmp);
+        jbyteArray iqmp = bignumToArray(env, rsa->iqmp, "iqmp");
         if (env->ExceptionCheck()) {
             return NULL;
         }
@@ -1397,26 +1397,26 @@ static jobjectArray NativeCrypto_get_DSA_params(JNIEnv* env, jclass, jint pkeyRe
         return NULL;
     }
 
-    jbyteArray g = bignumToArray(env, dsa->g);
+    jbyteArray g = bignumToArray(env, dsa->g, "g");
     if (env->ExceptionCheck()) {
         return NULL;
     }
     env->SetObjectArrayElement(joa, 0, g);
 
-    jbyteArray p = bignumToArray(env, dsa->p);
+    jbyteArray p = bignumToArray(env, dsa->p, "p");
     if (env->ExceptionCheck()) {
         return NULL;
     }
     env->SetObjectArrayElement(joa, 1, p);
 
-    jbyteArray q = bignumToArray(env, dsa->q);
+    jbyteArray q = bignumToArray(env, dsa->q, "q");
     if (env->ExceptionCheck()) {
         return NULL;
     }
     env->SetObjectArrayElement(joa, 2, q);
 
     if (dsa->pub_key != NULL) {
-        jbyteArray pub_key = bignumToArray(env, dsa->pub_key);
+        jbyteArray pub_key = bignumToArray(env, dsa->pub_key, "pub_key");
         if (env->ExceptionCheck()) {
             return NULL;
         }
@@ -1424,7 +1424,7 @@ static jobjectArray NativeCrypto_get_DSA_params(JNIEnv* env, jclass, jint pkeyRe
     }
 
     if (dsa->priv_key != NULL) {
-        jbyteArray priv_key = bignumToArray(env, dsa->priv_key);
+        jbyteArray priv_key = bignumToArray(env, dsa->priv_key, "priv_key");
         if (env->ExceptionCheck()) {
             return NULL;
         }
diff --git a/luni/src/test/java/libcore/javax/crypto/CipherTest.java b/luni/src/test/java/libcore/javax/crypto/CipherTest.java
index d31825a..68a46f3 100644
--- a/luni/src/test/java/libcore/javax/crypto/CipherTest.java
+++ b/luni/src/test/java/libcore/javax/crypto/CipherTest.java
@@ -17,37 +17,87 @@
 package libcore.javax.crypto;
 
 import com.android.org.bouncycastle.asn1.x509.KeyUsage;
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
 import java.math.BigInteger;
+import java.security.InvalidAlgorithmParameterException;
 import java.security.InvalidKeyException;
-import java.security.InvalidParameterException;
 import java.security.Key;
 import java.security.KeyFactory;
 import java.security.PrivateKey;
-import java.security.Provider.Service;
 import java.security.Provider;
 import java.security.PublicKey;
+import java.security.SecureRandom;
 import java.security.Security;
 import java.security.cert.Certificate;
+import java.security.interfaces.RSAPrivateKey;
+import java.security.interfaces.RSAPublicKey;
+import java.security.spec.AlgorithmParameterSpec;
 import java.security.spec.RSAPrivateKeySpec;
 import java.security.spec.RSAPublicKeySpec;
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
 import javax.crypto.BadPaddingException;
 import javax.crypto.Cipher;
-import javax.crypto.KeyGenerator;
 import javax.crypto.IllegalBlockSizeException;
+import javax.crypto.KeyGenerator;
+import javax.crypto.SecretKey;
+import javax.crypto.SecretKeyFactory;
+import javax.crypto.ShortBufferException;
+import javax.crypto.spec.IvParameterSpec;
+import javax.crypto.spec.PBEKeySpec;
+import javax.crypto.spec.PBEParameterSpec;
+import javax.crypto.spec.SecretKeySpec;
 import junit.framework.TestCase;
+import libcore.java.security.StandardNames;
 import libcore.java.security.TestKeyStore;
 
 public final class CipherTest extends TestCase {
 
+    private static final String[] RSA_PROVIDERS = ((StandardNames.IS_RI)
+                                                   ? new String[] { "SunJCE" }
+                                                   : new String[] { "BC" , "AndroidOpenSSL" });
+
+    private static final String[] AES_PROVIDERS = ((StandardNames.IS_RI)
+                                                   ? new String[] { "SunJCE" }
+                                                   : new String[] { "BC" }); // TOOD: , "AndroidOpenSSL"
+
+    private static final boolean IS_UNLIMITED;
+    static {
+        boolean is_unlimited;
+        if (StandardNames.IS_RI) {
+            try {
+                String algorithm = "PBEWITHMD5ANDTRIPLEDES";
+                Cipher.getInstance(algorithm).init(getEncryptMode(algorithm),
+                                                   getEncryptKey(algorithm),
+                                                   getAlgorithmParameterSpec(algorithm));
+                is_unlimited = true;
+            } catch (Exception e) {
+                is_unlimited = false;
+                System.out.println("WARNING: Some tests disabled due to lack of "
+                                   + "'Java Cryptography Extension (JCE) Unlimited Strength Jurisdiction Policy Files'");
+            }
+        } else {
+            is_unlimited = true;
+        }
+        IS_UNLIMITED = is_unlimited;
+    }
+
     private static boolean isUnsupported(String algorithm) {
+        if (algorithm.equals("RC2")) {
+            return true;
+        }
         if (algorithm.equals("PBEWITHMD5ANDRC2")) {
             return true;
         }
-        if (algorithm.equals("PBEWITHSHA1ANDRC2")) {
+        if (algorithm.startsWith("PBEWITHSHA1ANDRC2")) {
             return true;
         }
         if (algorithm.equals("PBEWITHSHAAND40BITRC2-CBC")) {
@@ -59,6 +109,11 @@ public final class CipherTest extends TestCase {
         if (algorithm.equals("PBEWITHSHAANDTWOFISH-CBC")) {
             return true;
         }
+        if (!IS_UNLIMITED) {
+            if (algorithm.equals("PBEWITHMD5ANDTRIPLEDES")) {
+                return true;
+            }
+        }
         return false;
     }
 
@@ -76,10 +131,13 @@ public final class CipherTest extends TestCase {
         return Cipher.DECRYPT_MODE;
     }
 
-    private static String getBaseAlgoritm(String algorithm) {
+    private static String getBaseAlgorithm(String algorithm) {
         if (algorithm.equals("AESWRAP")) {
             return "AES";
         }
+        if (algorithm.startsWith("AES/")) {
+            return "AES";
+        }
         if (algorithm.equals("PBEWITHMD5AND128BITAES-CBC-OPENSSL")) {
             return "AES";
         }
@@ -114,18 +172,24 @@ public final class CipherTest extends TestCase {
             return "DES";
         }
         if (algorithm.equals("DESEDEWRAP")) {
-            return "DESede";
+            return "DESEDE";
         }
         if (algorithm.equals("PBEWITHSHAAND2-KEYTRIPLEDES-CBC")) {
-            return "DESede";
+            return "DESEDE";
         }
         if (algorithm.equals("PBEWITHSHAAND3-KEYTRIPLEDES-CBC")) {
-            return "DESede";
+            return "DESEDE";
+        }
+        if (algorithm.equals("PBEWITHMD5ANDTRIPLEDES")) {
+            return "DESEDE";
         }
-        if (algorithm.equals("RSA/ECB/NoPadding")) {
+        if (algorithm.equals("PBEWITHSHA1ANDDESEDE")) {
+            return "DESEDE";
+        }
+        if (algorithm.equals("RSA/ECB/NOPADDING")) {
             return "RSA";
         }
-        if (algorithm.equals("RSA/ECB/PKCS1Padding")) {
+        if (algorithm.equals("RSA/ECB/PKCS1PADDING")) {
             return "RSA";
         }
         if (algorithm.equals("PBEWITHSHAAND40BITRC4")) {
@@ -138,27 +202,36 @@ public final class CipherTest extends TestCase {
     }
 
     private static boolean isAsymmetric(String algorithm) {
-        return getBaseAlgoritm(algorithm).equals("RSA");
+        return getBaseAlgorithm(algorithm).equals("RSA");
     }
 
     private static boolean isWrap(String algorithm) {
         return algorithm.endsWith("WRAP");
     }
 
+    private static boolean isPBE(String algorithm) {
+        return algorithm.startsWith("PBE");
+    }
+
     private static Map<String, Key> ENCRYPT_KEYS = new HashMap<String, Key>();
     private synchronized static Key getEncryptKey(String algorithm) throws Exception {
         Key key = ENCRYPT_KEYS.get(algorithm);
         if (key != null) {
             return key;
         }
-        algorithm = getBaseAlgoritm(algorithm);
-        if (algorithm.equals("RSA")) {
+        if (algorithm.startsWith("RSA")) {
             KeyFactory kf = KeyFactory.getInstance("RSA");
             RSAPrivateKeySpec keySpec = new RSAPrivateKeySpec(RSA_2048_modulus,
                                                               RSA_2048_privateExponent);
             key = kf.generatePrivate(keySpec);
+        } else if (isPBE(algorithm)) {
+            SecretKeyFactory skf = SecretKeyFactory.getInstance(algorithm);
+            key = skf.generateSecret(new PBEKeySpec("secret".toCharArray()));
         } else {
-            KeyGenerator kg = KeyGenerator.getInstance(algorithm);
+            KeyGenerator kg = KeyGenerator.getInstance(getBaseAlgorithm(algorithm));
+            if (StandardNames.IS_RI && algorithm.equals("AES")) {
+                kg.init(128);
+            }
             key = kg.generateKey();
         }
         ENCRYPT_KEYS.put(algorithm, key);
@@ -171,8 +244,7 @@ public final class CipherTest extends TestCase {
         if (key != null) {
             return key;
         }
-        algorithm = getBaseAlgoritm(algorithm);
-        if (algorithm.equals("RSA")) {
+        if (algorithm.startsWith("RSA")) {
             KeyFactory kf = KeyFactory.getInstance("RSA");
             RSAPublicKeySpec keySpec = new RSAPublicKeySpec(RSA_2048_modulus,
                                                             RSA_2048_publicExponent);
@@ -187,84 +259,213 @@ public final class CipherTest extends TestCase {
 
     private static Map<String, Integer> EXPECTED_BLOCK_SIZE = new HashMap<String, Integer>();
     static {
-        EXPECTED_BLOCK_SIZE.put("AES", 16);
-        EXPECTED_BLOCK_SIZE.put("PBEWITHMD5AND128BITAES-CBC-OPENSSL", 16);
-        EXPECTED_BLOCK_SIZE.put("PBEWITHMD5AND192BITAES-CBC-OPENSSL", 16);
-        EXPECTED_BLOCK_SIZE.put("PBEWITHMD5AND256BITAES-CBC-OPENSSL", 16);
-        EXPECTED_BLOCK_SIZE.put("PBEWITHSHA256AND128BITAES-CBC-BC", 16);
-        EXPECTED_BLOCK_SIZE.put("PBEWITHSHA256AND192BITAES-CBC-BC", 16);
-        EXPECTED_BLOCK_SIZE.put("PBEWITHSHA256AND256BITAES-CBC-BC", 16);
-        EXPECTED_BLOCK_SIZE.put("PBEWITHSHAAND128BITAES-CBC-BC", 16);
-        EXPECTED_BLOCK_SIZE.put("PBEWITHSHAAND192BITAES-CBC-BC", 16);
-        EXPECTED_BLOCK_SIZE.put("PBEWITHSHAAND256BITAES-CBC-BC", 16);
-
-        EXPECTED_BLOCK_SIZE.put("AESWRAP", 0);
-
-        EXPECTED_BLOCK_SIZE.put("ARC4", 0);
-        EXPECTED_BLOCK_SIZE.put("PBEWITHSHAAND40BITRC4", 0);
-        EXPECTED_BLOCK_SIZE.put("PBEWITHSHAAND128BITRC4", 0);
-
-        EXPECTED_BLOCK_SIZE.put("BLOWFISH", 8);
-
-        EXPECTED_BLOCK_SIZE.put("DES", 8);
-        EXPECTED_BLOCK_SIZE.put("PBEWITHMD5ANDDES", 8);
-        EXPECTED_BLOCK_SIZE.put("PBEWITHSHA1ANDDES", 8);
-
-        EXPECTED_BLOCK_SIZE.put("DESEDE", 8);
-        EXPECTED_BLOCK_SIZE.put("PBEWITHSHAAND2-KEYTRIPLEDES-CBC", 8);
-        EXPECTED_BLOCK_SIZE.put("PBEWITHSHAAND3-KEYTRIPLEDES-CBC", 8);
-
-        EXPECTED_BLOCK_SIZE.put("DESEDEWRAP", 0);
-
-        EXPECTED_BLOCK_SIZE.put("RSA", 255);
-        EXPECTED_BLOCK_SIZE.put("RSA/ECB/NoPadding", 0);
-        EXPECTED_BLOCK_SIZE.put("RSA/ECB/PKCS1Padding", 0);
-    }
-    private static int getExpectedBlockSize(String algorithm) {
-        Integer expected = EXPECTED_BLOCK_SIZE.get(algorithm);
-        assertNotNull(algorithm, expected);
+        setExpectedBlockSize("AES", 16);
+        setExpectedBlockSize("PBEWITHMD5AND128BITAES-CBC-OPENSSL", 16);
+        setExpectedBlockSize("PBEWITHMD5AND192BITAES-CBC-OPENSSL", 16);
+        setExpectedBlockSize("PBEWITHMD5AND256BITAES-CBC-OPENSSL", 16);
+        setExpectedBlockSize("PBEWITHSHA256AND128BITAES-CBC-BC", 16);
+        setExpectedBlockSize("PBEWITHSHA256AND192BITAES-CBC-BC", 16);
+        setExpectedBlockSize("PBEWITHSHA256AND256BITAES-CBC-BC", 16);
+        setExpectedBlockSize("PBEWITHSHAAND128BITAES-CBC-BC", 16);
+        setExpectedBlockSize("PBEWITHSHAAND192BITAES-CBC-BC", 16);
+        setExpectedBlockSize("PBEWITHSHAAND256BITAES-CBC-BC", 16);
+
+        if (StandardNames.IS_RI) {
+            setExpectedBlockSize("AESWRAP", 16);
+        } else {
+            setExpectedBlockSize("AESWRAP", 0);
+        }
+
+        setExpectedBlockSize("ARC4", 0);
+        setExpectedBlockSize("ARCFOUR", 0);
+        setExpectedBlockSize("PBEWITHSHAAND40BITRC4", 0);
+        setExpectedBlockSize("PBEWITHSHAAND128BITRC4", 0);
+
+        setExpectedBlockSize("BLOWFISH", 8);
+
+        setExpectedBlockSize("DES", 8);
+        setExpectedBlockSize("PBEWITHMD5ANDDES", 8);
+        setExpectedBlockSize("PBEWITHSHA1ANDDES", 8);
+
+        setExpectedBlockSize("DESEDE", 8);
+        setExpectedBlockSize("PBEWITHSHAAND2-KEYTRIPLEDES-CBC", 8);
+        setExpectedBlockSize("PBEWITHSHAAND3-KEYTRIPLEDES-CBC", 8);
+        setExpectedBlockSize("PBEWITHMD5ANDTRIPLEDES", 8);
+        setExpectedBlockSize("PBEWITHSHA1ANDDESEDE", 8);
+
+
+        if (StandardNames.IS_RI) {
+            setExpectedBlockSize("DESEDEWRAP", 8);
+        } else {
+            setExpectedBlockSize("DESEDEWRAP", 0);
+        }
+
+        if (StandardNames.IS_RI) {
+            setExpectedBlockSize("RSA", 0);
+            setExpectedBlockSize("RSA/ECB/NoPadding", 0);
+            setExpectedBlockSize("RSA/ECB/PKCS1Padding", 0);
+        } else {
+            setExpectedBlockSize("RSA", Cipher.ENCRYPT_MODE, 256);
+            setExpectedBlockSize("RSA/ECB/NoPadding", Cipher.ENCRYPT_MODE, 256);
+            setExpectedBlockSize("RSA/ECB/PKCS1Padding", Cipher.ENCRYPT_MODE, 245);
+
+            // BC strips the leading 0 for us even when NoPadding is specified
+            setExpectedBlockSize("RSA", Cipher.ENCRYPT_MODE, "BC", 255);
+            setExpectedBlockSize("RSA/ECB/NoPadding", Cipher.ENCRYPT_MODE, "BC", 255);
+
+            setExpectedBlockSize("RSA", Cipher.DECRYPT_MODE, 256);
+            setExpectedBlockSize("RSA/ECB/NoPadding", Cipher.DECRYPT_MODE, 256);
+            setExpectedBlockSize("RSA/ECB/PKCS1Padding", Cipher.DECRYPT_MODE, 256);
+        }
+    }
+
+    private static String modeKey(String algorithm, int mode) {
+        return algorithm + ":" + mode;
+    }
+
+    private static String modeProviderKey(String algorithm, int mode, String provider) {
+        return algorithm + ":" + mode + ":" + provider;
+    }
+
+    private static void setExpectedSize(Map<String, Integer> map,
+                                        String algorithm, int value) {
+        algorithm = algorithm.toUpperCase(Locale.US);
+        map.put(algorithm, value);
+    }
+
+    private static void setExpectedSize(Map<String, Integer> map,
+                                        String algorithm, int mode, int value) {
+        setExpectedSize(map, modeKey(algorithm, mode), value);
+    }
+
+    private static void setExpectedSize(Map<String, Integer> map,
+                                        String algorithm, int mode, String provider, int value) {
+        setExpectedSize(map, modeProviderKey(algorithm, mode, provider), value);
+    }
+
+    private static int getExpectedSize(Map<String, Integer> map, String algorithm, int mode, String provider) {
+        Integer expected = map.get(modeProviderKey(algorithm, mode, provider));
+        if (expected != null) {
+            return expected;
+        }
+        expected = map.get(modeKey(algorithm, mode));
+        if (expected != null) {
+            return expected;
+        }
+        expected = map.get(algorithm);
+        assertNotNull("Algorithm " + algorithm + " not found in " + map, expected);
         return expected;
     }
 
+    private static void setExpectedBlockSize(String algorithm, int value) {
+        setExpectedSize(EXPECTED_BLOCK_SIZE, algorithm, value);
+    }
+
+    private static void setExpectedBlockSize(String algorithm, int mode, int value) {
+        setExpectedSize(EXPECTED_BLOCK_SIZE, algorithm, mode, value);
+    }
+
+    private static void setExpectedBlockSize(String algorithm, int mode, String provider, int value) {
+        setExpectedSize(EXPECTED_BLOCK_SIZE, algorithm, mode, provider, value);
+    }
+
+    private static int getExpectedBlockSize(String algorithm, int mode, String provider) {
+        return getExpectedSize(EXPECTED_BLOCK_SIZE, algorithm, mode, provider);
+    }
+
     private static Map<String, Integer> EXPECTED_OUTPUT_SIZE = new HashMap<String, Integer>();
     static {
-        EXPECTED_OUTPUT_SIZE.put("AES", 16);
-        EXPECTED_OUTPUT_SIZE.put("PBEWITHMD5AND128BITAES-CBC-OPENSSL", 16);
-        EXPECTED_OUTPUT_SIZE.put("PBEWITHMD5AND192BITAES-CBC-OPENSSL", 16);
-        EXPECTED_OUTPUT_SIZE.put("PBEWITHMD5AND256BITAES-CBC-OPENSSL", 16);
-        EXPECTED_OUTPUT_SIZE.put("PBEWITHSHA256AND128BITAES-CBC-BC", 16);
-        EXPECTED_OUTPUT_SIZE.put("PBEWITHSHA256AND192BITAES-CBC-BC", 16);
-        EXPECTED_OUTPUT_SIZE.put("PBEWITHSHA256AND256BITAES-CBC-BC", 16);
-        EXPECTED_OUTPUT_SIZE.put("PBEWITHSHAAND128BITAES-CBC-BC", 16);
-        EXPECTED_OUTPUT_SIZE.put("PBEWITHSHAAND192BITAES-CBC-BC", 16);
-        EXPECTED_OUTPUT_SIZE.put("PBEWITHSHAAND256BITAES-CBC-BC", 16);
-
-        EXPECTED_OUTPUT_SIZE.put("AESWRAP", -1);
-
-        EXPECTED_OUTPUT_SIZE.put("ARC4", 0);
-        EXPECTED_OUTPUT_SIZE.put("PBEWITHSHAAND40BITRC4", 0);
-        EXPECTED_OUTPUT_SIZE.put("PBEWITHSHAAND128BITRC4", 0);
-
-        EXPECTED_OUTPUT_SIZE.put("BLOWFISH", 8);
-
-        EXPECTED_OUTPUT_SIZE.put("DES", 8);
-        EXPECTED_OUTPUT_SIZE.put("PBEWITHMD5ANDDES", 8);
-        EXPECTED_OUTPUT_SIZE.put("PBEWITHSHA1ANDDES", 8);
-
-        EXPECTED_OUTPUT_SIZE.put("DESEDE", 8);
-        EXPECTED_OUTPUT_SIZE.put("PBEWITHSHAAND2-KEYTRIPLEDES-CBC", 8);
-        EXPECTED_OUTPUT_SIZE.put("PBEWITHSHAAND3-KEYTRIPLEDES-CBC", 8);
-
-        EXPECTED_OUTPUT_SIZE.put("DESEDEWRAP", -1);
-
-        EXPECTED_OUTPUT_SIZE.put("RSA", 256);
-        EXPECTED_OUTPUT_SIZE.put("RSA/ECB/NoPadding", 256);
-        EXPECTED_OUTPUT_SIZE.put("RSA/ECB/PKCS1Padding", 256);
-    }
-    private static int getExpectedOutputSize(String algorithm) {
-        Integer expected = EXPECTED_OUTPUT_SIZE.get(algorithm);
-        assertNotNull(algorithm, expected);
-        return expected;
+        setExpectedOutputSize("AES", Cipher.ENCRYPT_MODE, 16);
+        setExpectedOutputSize("PBEWITHMD5AND128BITAES-CBC-OPENSSL", 16);
+        setExpectedOutputSize("PBEWITHMD5AND192BITAES-CBC-OPENSSL", 16);
+        setExpectedOutputSize("PBEWITHMD5AND256BITAES-CBC-OPENSSL", 16);
+        setExpectedOutputSize("PBEWITHSHA256AND128BITAES-CBC-BC", 16);
+        setExpectedOutputSize("PBEWITHSHA256AND192BITAES-CBC-BC", 16);
+        setExpectedOutputSize("PBEWITHSHA256AND256BITAES-CBC-BC", 16);
+        setExpectedOutputSize("PBEWITHSHAAND128BITAES-CBC-BC", 16);
+        setExpectedOutputSize("PBEWITHSHAAND192BITAES-CBC-BC", 16);
+        setExpectedOutputSize("PBEWITHSHAAND256BITAES-CBC-BC", 16);
+
+        setExpectedOutputSize("AES", Cipher.DECRYPT_MODE, 0);
+        setExpectedOutputSize("PBEWITHMD5AND128BITAES-CBC-OPENSSL", Cipher.DECRYPT_MODE, 0);
+        setExpectedOutputSize("PBEWITHMD5AND192BITAES-CBC-OPENSSL", Cipher.DECRYPT_MODE, 0);
+        setExpectedOutputSize("PBEWITHMD5AND256BITAES-CBC-OPENSSL", Cipher.DECRYPT_MODE, 0);
+        setExpectedOutputSize("PBEWITHSHA256AND128BITAES-CBC-BC", Cipher.DECRYPT_MODE, 0);
+        setExpectedOutputSize("PBEWITHSHA256AND192BITAES-CBC-BC", Cipher.DECRYPT_MODE, 0);
+        setExpectedOutputSize("PBEWITHSHA256AND256BITAES-CBC-BC", Cipher.DECRYPT_MODE, 0);
+        setExpectedOutputSize("PBEWITHSHAAND128BITAES-CBC-BC", Cipher.DECRYPT_MODE, 0);
+        setExpectedOutputSize("PBEWITHSHAAND192BITAES-CBC-BC", Cipher.DECRYPT_MODE, 0);
+        setExpectedOutputSize("PBEWITHSHAAND256BITAES-CBC-BC", Cipher.DECRYPT_MODE, 0);
+
+        if (StandardNames.IS_RI) {
+            setExpectedOutputSize("AESWRAP", Cipher.WRAP_MODE, 8);
+            setExpectedOutputSize("AESWRAP", Cipher.UNWRAP_MODE, 0);
+        } else {
+            setExpectedOutputSize("AESWRAP", -1);
+        }
+
+        setExpectedOutputSize("ARC4", 0);
+        setExpectedOutputSize("ARCFOUR", 0);
+        setExpectedOutputSize("PBEWITHSHAAND40BITRC4", 0);
+        setExpectedOutputSize("PBEWITHSHAAND128BITRC4", 0);
+
+        setExpectedOutputSize("BLOWFISH", Cipher.ENCRYPT_MODE, 8);
+        setExpectedOutputSize("BLOWFISH", Cipher.DECRYPT_MODE, 0);
+
+        setExpectedOutputSize("DES", Cipher.ENCRYPT_MODE, 8);
+        setExpectedOutputSize("PBEWITHMD5ANDDES", Cipher.ENCRYPT_MODE, 8);
+        setExpectedOutputSize("PBEWITHSHA1ANDDES", Cipher.ENCRYPT_MODE, 8);
+
+        setExpectedOutputSize("DES", Cipher.DECRYPT_MODE, 0);
+        setExpectedOutputSize("PBEWITHMD5ANDDES", Cipher.DECRYPT_MODE, 0);
+        setExpectedOutputSize("PBEWITHSHA1ANDDES", Cipher.DECRYPT_MODE, 0);
+
+        setExpectedOutputSize("DESEDE", Cipher.ENCRYPT_MODE, 8);
+        setExpectedOutputSize("PBEWITHSHAAND2-KEYTRIPLEDES-CBC", Cipher.ENCRYPT_MODE, 8);
+        setExpectedOutputSize("PBEWITHSHAAND3-KEYTRIPLEDES-CBC", Cipher.ENCRYPT_MODE, 8);
+        setExpectedOutputSize("PBEWITHMD5ANDTRIPLEDES", Cipher.ENCRYPT_MODE, 8);
+        setExpectedOutputSize("PBEWITHSHA1ANDDESEDE", Cipher.ENCRYPT_MODE, 8);
+
+        setExpectedOutputSize("DESEDE", Cipher.DECRYPT_MODE, 0);
+        setExpectedOutputSize("PBEWITHSHAAND2-KEYTRIPLEDES-CBC", Cipher.DECRYPT_MODE, 0);
+        setExpectedOutputSize("PBEWITHSHAAND3-KEYTRIPLEDES-CBC", Cipher.DECRYPT_MODE, 0);
+        setExpectedOutputSize("PBEWITHMD5ANDTRIPLEDES", Cipher.DECRYPT_MODE, 0);
+        setExpectedOutputSize("PBEWITHSHA1ANDDESEDE", Cipher.DECRYPT_MODE, 0);
+
+        if (StandardNames.IS_RI) {
+            setExpectedOutputSize("DESEDEWRAP", Cipher.WRAP_MODE, 16);
+            setExpectedOutputSize("DESEDEWRAP", Cipher.UNWRAP_MODE, 0);
+        } else {
+            setExpectedOutputSize("DESEDEWRAP", -1);
+        }
+
+        setExpectedOutputSize("RSA", Cipher.ENCRYPT_MODE, 256);
+        setExpectedOutputSize("RSA/ECB/NoPadding", Cipher.ENCRYPT_MODE, 256);
+        setExpectedOutputSize("RSA/ECB/PKCS1Padding", Cipher.ENCRYPT_MODE, 256);
+
+        setExpectedOutputSize("RSA", Cipher.DECRYPT_MODE, 256);
+        setExpectedOutputSize("RSA/ECB/NoPadding", Cipher.DECRYPT_MODE, 256);
+        setExpectedOutputSize("RSA/ECB/PKCS1Padding", Cipher.DECRYPT_MODE, 245);
+
+        // BC strips the leading 0 for us even when NoPadding is specified
+        setExpectedOutputSize("RSA", Cipher.DECRYPT_MODE, "BC", 255);
+        setExpectedOutputSize("RSA/ECB/NoPadding", Cipher.DECRYPT_MODE, "BC", 255);
+    }
+
+    private static void setExpectedOutputSize(String algorithm, int value) {
+        setExpectedSize(EXPECTED_OUTPUT_SIZE, algorithm, value);
+    }
+
+    private static void setExpectedOutputSize(String algorithm, int mode, int value) {
+        setExpectedSize(EXPECTED_OUTPUT_SIZE, algorithm, mode, value);
+    }
+
+    private static void setExpectedOutputSize(String algorithm, int mode, String provider, int value) {
+        setExpectedSize(EXPECTED_OUTPUT_SIZE, algorithm, mode, provider, value);
+    }
+
+    private static int getExpectedOutputSize(String algorithm, int mode, String provider) {
+        return getExpectedSize(EXPECTED_OUTPUT_SIZE, algorithm, mode, provider);
     }
 
     private static byte[] ORIGINAL_PLAIN_TEXT = new byte[] { 0x0a, 0x0b, 0x0c };
@@ -356,13 +557,28 @@ public final class CipherTest extends TestCase {
     };
 
     private static byte[] getExpectedPlainText(String algorithm) {
-        if (algorithm.equals("RSA/ECB/NoPadding")) {
+        if (algorithm.equals("RSA/ECB/NOPADDING")) {
             return PKCS1_BLOCK_TYPE_00_PADDED_PLAIN_TEXT;
         }
         return ORIGINAL_PLAIN_TEXT;
     }
 
+    private static AlgorithmParameterSpec getAlgorithmParameterSpec(String algorithm) {
+        if (!isPBE(algorithm)) {
+            return null;
+        }
+        final byte[] salt = new byte[8];
+        new SecureRandom().nextBytes(salt);
+        return new PBEParameterSpec(salt, 1024);
+    }
+
     public void test_getInstance() throws Exception {
+        final ByteArrayOutputStream errBuffer = new ByteArrayOutputStream();
+        PrintStream out = new PrintStream(errBuffer);
+
+        Set<String> seenBaseCipherNames = new HashSet<String>();
+        Set<String> seenCiphersWithModeAndPadding = new HashSet<String>();
+
         Provider[] providers = Security.getProviders();
         for (Provider provider : providers) {
             Set<Provider.Service> services = provider.getServices();
@@ -371,37 +587,91 @@ public final class CipherTest extends TestCase {
                 if (!type.equals("Cipher")) {
                     continue;
                 }
+
                 String algorithm = service.getAlgorithm();
+
+                /*
+                 * Any specific modes and paddings aren't tested directly here,
+                 * but we need to make sure we see the bare algorithm from some
+                 * provider. We will test each mode specifically when we get the
+                 * base cipher.
+                 */
+                final int firstSlash = algorithm.indexOf('/');
+                if (firstSlash == -1) {
+                    seenBaseCipherNames.add(algorithm);
+                } else {
+                    final String baseCipherName = algorithm.substring(0, firstSlash);
+                    if (!seenBaseCipherNames.contains(baseCipherName)) {
+                        seenCiphersWithModeAndPadding.add(baseCipherName);
+                    }
+                    continue;
+                }
+
                 try {
-                    // Cipher.getInstance(String)
-                    Cipher c1 = Cipher.getInstance(algorithm);
-                    assertEquals(algorithm, c1.getAlgorithm());
-                    test_Cipher(c1);
-
-                    // Cipher.getInstance(String, Provider)
-                    Cipher c2 = Cipher.getInstance(algorithm, provider);
-                    assertEquals(algorithm, c2.getAlgorithm());
-                    assertEquals(provider, c2.getProvider());
-                    test_Cipher(c2);
-
-                    // KeyGenerator.getInstance(String, String)
-                    Cipher c3 = Cipher.getInstance(algorithm, provider.getName());
-                    assertEquals(algorithm, c3.getAlgorithm());
-                    assertEquals(provider, c3.getProvider());
-                    test_Cipher(c3);
+                    test_Cipher_Algorithm(provider, algorithm);
                 } catch (Throwable e) {
-                    throw new Exception("Problem testing Cipher." + algorithm, e);
+                    out.append("Error encountered checking " + algorithm
+                               + " with provider " + provider.getName() + "\n");
+                    e.printStackTrace(out);
+                }
+
+                Set<String> modes = StandardNames.getModesForCipher(algorithm);
+                if (modes != null) {
+                    for (String mode : modes) {
+                        Set<String> paddings = StandardNames.getPaddingsForCipher(algorithm);
+                        if (paddings != null) {
+                            for (String padding : paddings) {
+                                final String algorithmName = algorithm + "/" + mode + "/" + padding;
+                                try {
+                                    test_Cipher_Algorithm(provider, algorithmName);
+                                } catch (Throwable e) {
+                                    out.append("Error encountered checking " + algorithmName
+                                               + " with provider " + provider.getName() + "\n");
+                                    e.printStackTrace(out);
+                                }
+                            }
+                        }
+                    }
                 }
             }
         }
+
+        seenCiphersWithModeAndPadding.removeAll(seenBaseCipherNames);
+        assertEquals("Ciphers seen with mode and padding but not base cipher",
+                Collections.EMPTY_SET, seenCiphersWithModeAndPadding);
+
+        out.flush();
+        if (errBuffer.size() > 0) {
+            throw new Exception("Errors encountered:\n\n" + errBuffer.toString() + "\n\n");
+        }
+    }
+
+    private void test_Cipher_Algorithm(Provider provider, String algorithm) throws Exception {
+        // Cipher.getInstance(String)
+        Cipher c1 = Cipher.getInstance(algorithm);
+        assertEquals(algorithm, c1.getAlgorithm());
+        test_Cipher(c1);
+
+        // Cipher.getInstance(String, Provider)
+        Cipher c2 = Cipher.getInstance(algorithm, provider);
+        assertEquals(algorithm, c2.getAlgorithm());
+        assertEquals(provider, c2.getProvider());
+        test_Cipher(c2);
+
+        // KeyGenerator.getInstance(String, String)
+        Cipher c3 = Cipher.getInstance(algorithm, provider.getName());
+        assertEquals(algorithm, c3.getAlgorithm());
+        assertEquals(provider, c3.getProvider());
+        test_Cipher(c3);
     }
 
     private void test_Cipher(Cipher c) throws Exception {
-        // TODO: test all supported modes and padding for a given algorithm
-        String algorithm = c.getAlgorithm();
+        String algorithm = c.getAlgorithm().toUpperCase(Locale.US);
         if (isUnsupported(algorithm)) {
             return;
         }
+        String providerName = c.getProvider().getName();
+        String cipherID = algorithm + ":" + providerName;
 
         try {
             c.getOutputSize(0);
@@ -410,21 +680,28 @@ public final class CipherTest extends TestCase {
 
         // TODO: test keys from different factories (e.g. OpenSSLRSAPrivateKey vs JCERSAPrivateKey)
         Key encryptKey = getEncryptKey(algorithm);
-        c.init(getEncryptMode(algorithm), encryptKey);
 
-        assertEquals(getExpectedBlockSize(algorithm), c.getBlockSize());
+        final AlgorithmParameterSpec spec = getAlgorithmParameterSpec(algorithm);
 
-        assertEquals(getExpectedOutputSize(algorithm), c.getOutputSize(0));
+        int encryptMode = getEncryptMode(algorithm);
+        c.init(encryptMode, encryptKey, spec);
+        assertEquals(cipherID, getExpectedBlockSize(algorithm, encryptMode, providerName), c.getBlockSize());
+        assertEquals(cipherID, getExpectedOutputSize(algorithm, encryptMode, providerName), c.getOutputSize(0));
+        int decryptMode = getDecryptMode(algorithm);
+        c.init(decryptMode, encryptKey, spec);
+        assertEquals(cipherID, getExpectedBlockSize(algorithm, decryptMode, providerName), c.getBlockSize());
+        assertEquals(cipherID, getExpectedOutputSize(algorithm, decryptMode, providerName), c.getOutputSize(0));
 
         // TODO: test Cipher.getIV()
 
         // TODO: test Cipher.getParameters()
 
-        assertNull(c.getExemptionMechanism());
+        assertNull(cipherID, c.getExemptionMechanism());
 
+        c.init(getEncryptMode(algorithm), encryptKey, spec);
         if (isWrap(algorithm)) {
             byte[] cipherText = c.wrap(encryptKey);
-            c.init(getDecryptMode(algorithm), getDecryptKey(algorithm));
+            c.init(getDecryptMode(algorithm), getDecryptKey(algorithm), spec);
             int keyType = (isAsymmetric(algorithm)) ? Cipher.PRIVATE_KEY : Cipher.SECRET_KEY;
             Key decryptedKey = c.unwrap(cipherText, encryptKey.getAlgorithm(), keyType);
             assertEquals("encryptKey.getAlgorithm()=" + encryptKey.getAlgorithm()
@@ -434,33 +711,40 @@ public final class CipherTest extends TestCase {
                          encryptKey, decryptedKey);
         } else {
             byte[] cipherText = c.doFinal(ORIGINAL_PLAIN_TEXT);
-            c.init(getDecryptMode(algorithm), getDecryptKey(algorithm));
+            c.init(getDecryptMode(algorithm), getDecryptKey(algorithm), spec);
             byte[] decryptedPlainText = c.doFinal(cipherText);
-            assertEquals(Arrays.toString(getExpectedPlainText(algorithm)),
+            assertEquals(cipherID,
+                         Arrays.toString(getExpectedPlainText(algorithm)),
                          Arrays.toString(decryptedPlainText));
         }
     }
 
     public void testInputPKCS1Padding() throws Exception {
-        testInputPKCS1Padding(PKCS1_BLOCK_TYPE_01_PADDED_PLAIN_TEXT, getEncryptKey("RSA"), getDecryptKey("RSA"));
+        for (String provider : RSA_PROVIDERS) {
+            testInputPKCS1Padding(provider);
+        }
+    }
+
+    private void testInputPKCS1Padding(String provider) throws Exception {
+        testInputPKCS1Padding(provider, PKCS1_BLOCK_TYPE_01_PADDED_PLAIN_TEXT, getEncryptKey("RSA"), getDecryptKey("RSA"));
         try {
-            testInputPKCS1Padding(PKCS1_BLOCK_TYPE_02_PADDED_PLAIN_TEXT, getEncryptKey("RSA"), getDecryptKey("RSA"));
+            testInputPKCS1Padding(provider, PKCS1_BLOCK_TYPE_02_PADDED_PLAIN_TEXT, getEncryptKey("RSA"), getDecryptKey("RSA"));
             fail();
         } catch (BadPaddingException expected) {
         }
         try {
-            testInputPKCS1Padding(PKCS1_BLOCK_TYPE_01_PADDED_PLAIN_TEXT, getDecryptKey("RSA"), getEncryptKey("RSA"));
+            testInputPKCS1Padding(provider, PKCS1_BLOCK_TYPE_01_PADDED_PLAIN_TEXT, getDecryptKey("RSA"), getEncryptKey("RSA"));
             fail();
         } catch (BadPaddingException expected) {
         }
-        testInputPKCS1Padding(PKCS1_BLOCK_TYPE_02_PADDED_PLAIN_TEXT, getDecryptKey("RSA"), getEncryptKey("RSA"));
+        testInputPKCS1Padding(provider, PKCS1_BLOCK_TYPE_02_PADDED_PLAIN_TEXT, getDecryptKey("RSA"), getEncryptKey("RSA"));
     }
 
-    private void testInputPKCS1Padding(byte[] prePaddedPlainText, Key encryptKey, Key decryptKey) throws Exception {
-        Cipher encryptCipher = Cipher.getInstance("RSA/ECB/NoPadding");
+    private void testInputPKCS1Padding(String provider, byte[] prePaddedPlainText, Key encryptKey, Key decryptKey) throws Exception {
+        Cipher encryptCipher = Cipher.getInstance("RSA/ECB/NoPadding", provider);
         encryptCipher.init(Cipher.ENCRYPT_MODE, encryptKey);
         byte[] cipherText = encryptCipher.doFinal(prePaddedPlainText);
-        Cipher decryptCipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
+        Cipher decryptCipher = Cipher.getInstance("RSA/ECB/PKCS1Padding", provider);
         decryptCipher.init(Cipher.DECRYPT_MODE, decryptKey);
         byte[] plainText = decryptCipher.doFinal(cipherText);
         assertEquals(Arrays.toString(ORIGINAL_PLAIN_TEXT),
@@ -468,36 +752,51 @@ public final class CipherTest extends TestCase {
     }
 
     public void testOutputPKCS1Padding() throws Exception {
-       testOutputPKCS1Padding((byte) 1, getEncryptKey("RSA"), getDecryptKey("RSA"));
-       testOutputPKCS1Padding((byte) 2, getDecryptKey("RSA"), getEncryptKey("RSA"));
+        for (String provider : RSA_PROVIDERS) {
+            testOutputPKCS1Padding(provider);
+        }
     }
 
-    private void testOutputPKCS1Padding(byte expectedBlockType, Key encryptKey, Key decryptKey) throws Exception {
-        Cipher encryptCipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
+    private void testOutputPKCS1Padding(String provider) throws Exception {
+       testOutputPKCS1Padding(provider, (byte) 1, getEncryptKey("RSA"), getDecryptKey("RSA"));
+       testOutputPKCS1Padding(provider, (byte) 2, getDecryptKey("RSA"), getEncryptKey("RSA"));
+    }
+
+    private void testOutputPKCS1Padding(String provider, byte expectedBlockType, Key encryptKey, Key decryptKey) throws Exception {
+        Cipher encryptCipher = Cipher.getInstance("RSA/ECB/PKCS1Padding", provider);
         encryptCipher.init(Cipher.ENCRYPT_MODE, encryptKey);
         byte[] cipherText = encryptCipher.doFinal(ORIGINAL_PLAIN_TEXT);
-        Cipher decryptCipher = Cipher.getInstance("RSA/ECB/NoPadding");
+        Cipher decryptCipher = Cipher.getInstance("RSA/ECB/NoPadding", provider);
         decryptCipher.init(Cipher.DECRYPT_MODE, decryptKey);
         byte[] plainText = decryptCipher.doFinal(cipherText);
-        assertPadding(expectedBlockType, ORIGINAL_PLAIN_TEXT, plainText);
+        assertPadding(provider, expectedBlockType, ORIGINAL_PLAIN_TEXT, plainText);
     }
 
-    private void assertPadding(byte expectedBlockType, byte[] expectedData, byte[] actualDataWithPadding) {
-        assertNotNull(actualDataWithPadding);
-        assertEquals(getExpectedOutputSize("RSA"), actualDataWithPadding.length);
-        assertEquals(0, actualDataWithPadding[0]);
-        byte actualBlockType = actualDataWithPadding[1];
-        assertEquals(expectedBlockType, actualBlockType);
+    private void assertPadding(String provider, byte expectedBlockType, byte[] expectedData, byte[] actualDataWithPadding) {
+        assertNotNull(provider, actualDataWithPadding);
+        int expectedOutputSize = getExpectedOutputSize("RSA", Cipher.DECRYPT_MODE, provider);
+        assertEquals(provider, expectedOutputSize, actualDataWithPadding.length);
+        int expectedBlockTypeOffset;
+        if (provider.equals("BC")) {
+            // BC strips the leading 0 for us on decrypt even when NoPadding is specified...
+            expectedBlockTypeOffset = 0;
+        } else {
+            expectedBlockTypeOffset = 1;
+            assertEquals(provider, 0, actualDataWithPadding[0]);
+        }
+        byte actualBlockType = actualDataWithPadding[expectedBlockTypeOffset];
+        assertEquals(provider, expectedBlockType, actualBlockType);
         int actualDataOffset = actualDataWithPadding.length - expectedData.length;
         if (actualBlockType == 1) {
-            for (int i = 2; i < actualDataOffset - 1; i++) {
-                assertEquals((byte) 0xFF, actualDataWithPadding[i]);
+            int expectedDataOffset = expectedBlockTypeOffset + 1;
+            for (int i = expectedDataOffset; i < actualDataOffset - 1; i++) {
+                assertEquals(provider, (byte) 0xFF, actualDataWithPadding[i]);
             }
         }
-        assertEquals(0x00, actualDataWithPadding[actualDataOffset-1]);
+        assertEquals(provider, 0x00, actualDataWithPadding[actualDataOffset-1]);
         byte[] actualData = new byte[expectedData.length];
         System.arraycopy(actualDataWithPadding, actualDataOffset, actualData, 0, actualData.length);
-        assertEquals(Arrays.toString(expectedData), Arrays.toString(actualData));
+        assertEquals(provider, Arrays.toString(expectedData), Arrays.toString(actualData));
     }
 
     public void testCipherInitWithCertificate () throws Exception {
@@ -935,13 +1234,19 @@ public final class CipherTest extends TestCase {
     };
 
     public void testRSA_ECB_NoPadding_Private_OnlyDoFinal_Success() throws Exception {
+        for (String provider : RSA_PROVIDERS) {
+            testRSA_ECB_NoPadding_Private_OnlyDoFinal_Success(provider);
+        }
+    }
+
+    private void testRSA_ECB_NoPadding_Private_OnlyDoFinal_Success(String provider) throws Exception {
         KeyFactory kf = KeyFactory.getInstance("RSA");
         RSAPrivateKeySpec keySpec = new RSAPrivateKeySpec(RSA_2048_modulus,
                 RSA_2048_privateExponent);
 
         final PrivateKey privKey = kf.generatePrivate(keySpec);
 
-        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding");
+        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding", provider);
 
         /*
          * You're actually decrypting with private keys, but there is no
@@ -960,13 +1265,19 @@ public final class CipherTest extends TestCase {
     }
 
     public void testRSA_ECB_NoPadding_Private_UpdateThenEmptyDoFinal_Success() throws Exception {
+        for (String provider : RSA_PROVIDERS) {
+            testRSA_ECB_NoPadding_Private_UpdateThenEmptyDoFinal_Success(provider);
+        }
+    }
+
+    private void testRSA_ECB_NoPadding_Private_UpdateThenEmptyDoFinal_Success(String provider) throws Exception {
         KeyFactory kf = KeyFactory.getInstance("RSA");
         RSAPrivateKeySpec keySpec = new RSAPrivateKeySpec(RSA_2048_modulus,
                 RSA_2048_privateExponent);
 
         final PrivateKey privKey = kf.generatePrivate(keySpec);
 
-        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding");
+        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding", provider);
 
         /*
          * You're actually decrypting with private keys, but there is no
@@ -988,13 +1299,20 @@ public final class CipherTest extends TestCase {
 
     public void testRSA_ECB_NoPadding_Private_SingleByteUpdateThenEmptyDoFinal_Success()
             throws Exception {
+        for (String provider : RSA_PROVIDERS) {
+            testRSA_ECB_NoPadding_Private_SingleByteUpdateThenEmptyDoFinal_Success(provider);
+        }
+    }
+
+    private void testRSA_ECB_NoPadding_Private_SingleByteUpdateThenEmptyDoFinal_Success(String provider)
+            throws Exception {
         KeyFactory kf = KeyFactory.getInstance("RSA");
         RSAPrivateKeySpec keySpec = new RSAPrivateKeySpec(RSA_2048_modulus,
                 RSA_2048_privateExponent);
 
         final PrivateKey privKey = kf.generatePrivate(keySpec);
 
-        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding");
+        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding", provider);
 
         /*
          * You're actually decrypting with private keys, but there is no
@@ -1020,12 +1338,18 @@ public final class CipherTest extends TestCase {
     }
 
     public void testRSA_ECB_NoPadding_Private_OnlyDoFinalWithOffset_Success() throws Exception {
+        for (String provider : RSA_PROVIDERS) {
+            testRSA_ECB_NoPadding_Private_OnlyDoFinalWithOffset_Success(provider);
+        }
+    }
+
+    private void testRSA_ECB_NoPadding_Private_OnlyDoFinalWithOffset_Success(String provider) throws Exception {
         KeyFactory kf = KeyFactory.getInstance("RSA");
         RSAPrivateKeySpec keySpec = new RSAPrivateKeySpec(RSA_2048_modulus,
                 RSA_2048_privateExponent);
         final PrivateKey privKey = kf.generatePrivate(keySpec);
 
-        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding");
+        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding", provider);
 
         /*
          * You're actually decrypting with private keys, but there is no
@@ -1051,12 +1375,18 @@ public final class CipherTest extends TestCase {
     }
 
     public void testRSA_ECB_NoPadding_Public_OnlyDoFinal_Success() throws Exception {
+        for (String provider : RSA_PROVIDERS) {
+            testRSA_ECB_NoPadding_Public_OnlyDoFinal_Success(provider);
+        }
+    }
+
+    private void testRSA_ECB_NoPadding_Public_OnlyDoFinal_Success(String provider) throws Exception {
         KeyFactory kf = KeyFactory.getInstance("RSA");
         RSAPublicKeySpec keySpec = new RSAPublicKeySpec(RSA_2048_modulus, RSA_2048_publicExponent);
 
         final PublicKey privKey = kf.generatePublic(keySpec);
 
-        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding");
+        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding", provider);
 
         /*
          * You're actually encrypting with public keys, but there is no
@@ -1065,22 +1395,26 @@ public final class CipherTest extends TestCase {
          */
         c.init(Cipher.ENCRYPT_MODE, privKey);
         byte[] encrypted = c.doFinal(RSA_Vector1_Encrypt_Private);
-        assertTrue("Encrypted should match expected",
-                Arrays.equals(RSA_2048_Vector1, encrypted));
+        assertEncryptedEqualsNoPadding(provider, Cipher.ENCRYPT_MODE, RSA_2048_Vector1, encrypted);
 
         c.init(Cipher.DECRYPT_MODE, privKey);
         encrypted = c.doFinal(RSA_Vector1_Encrypt_Private);
-        assertTrue("Encrypted should match expected",
-                Arrays.equals(RSA_2048_Vector1, encrypted));
+        assertEncryptedEqualsNoPadding(provider, Cipher.DECRYPT_MODE, RSA_2048_Vector1, encrypted);
     }
 
     public void testRSA_ECB_NoPadding_Public_OnlyDoFinalWithOffset_Success() throws Exception {
+        for (String provider : RSA_PROVIDERS) {
+            testRSA_ECB_NoPadding_Public_OnlyDoFinalWithOffset_Success(provider);
+        }
+    }
+
+    private void testRSA_ECB_NoPadding_Public_OnlyDoFinalWithOffset_Success(String provider) throws Exception {
         KeyFactory kf = KeyFactory.getInstance("RSA");
         RSAPublicKeySpec keySpec = new RSAPublicKeySpec(RSA_2048_modulus, RSA_2048_publicExponent);
 
         final PublicKey pubKey = kf.generatePublic(keySpec);
 
-        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding");
+        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding", provider);
 
         /*
          * You're actually encrypting with public keys, but there is no
@@ -1092,22 +1426,33 @@ public final class CipherTest extends TestCase {
         final int encryptLen = c.doFinal(RSA_Vector1_Encrypt_Private, 0,
                 RSA_Vector1_Encrypt_Private.length, encrypted, 0);
         assertEquals("Encrypted size should match expected", RSA_2048_Vector1.length, encryptLen);
-        assertTrue("Encrypted should match expected", Arrays.equals(RSA_2048_Vector1, encrypted));
+        assertEncryptedEqualsNoPadding(provider, Cipher.ENCRYPT_MODE, RSA_2048_Vector1, encrypted);
 
         c.init(Cipher.DECRYPT_MODE, pubKey);
-        final int decryptLen = c.doFinal(RSA_Vector1_Encrypt_Private, 0,
+        int decryptLen = c.doFinal(RSA_Vector1_Encrypt_Private, 0,
                 RSA_Vector1_Encrypt_Private.length, encrypted, 0);
+        if (provider.equals("BC")) {
+            // BC strips the leading 0 for us on decrypt even when NoPadding is specified...
+            decryptLen++;
+            encrypted = Arrays.copyOf(encrypted, encrypted.length - 1);
+        }
         assertEquals("Encrypted size should match expected", RSA_2048_Vector1.length, decryptLen);
-        assertTrue("Encrypted should match expected", Arrays.equals(RSA_2048_Vector1, encrypted));
+        assertEncryptedEqualsNoPadding(provider, Cipher.DECRYPT_MODE, RSA_2048_Vector1, encrypted);
     }
 
     public void testRSA_ECB_NoPadding_Public_UpdateThenEmptyDoFinal_Success() throws Exception {
+        for (String provider : RSA_PROVIDERS) {
+            testRSA_ECB_NoPadding_Public_UpdateThenEmptyDoFinal_Success(provider);
+        }
+    }
+
+    private void testRSA_ECB_NoPadding_Public_UpdateThenEmptyDoFinal_Success(String provider) throws Exception {
         KeyFactory kf = KeyFactory.getInstance("RSA");
         RSAPublicKeySpec keySpec = new RSAPublicKeySpec(RSA_2048_modulus, RSA_2048_publicExponent);
 
         final PublicKey privKey = kf.generatePublic(keySpec);
 
-        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding");
+        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding", provider);
 
         /*
          * You're actually encrypting with public keys, but there is no
@@ -1117,22 +1462,29 @@ public final class CipherTest extends TestCase {
         c.init(Cipher.ENCRYPT_MODE, privKey);
         c.update(RSA_Vector1_Encrypt_Private);
         byte[] encrypted = c.doFinal();
-        assertTrue("Encrypted should match expected", Arrays.equals(RSA_2048_Vector1, encrypted));
+        assertEncryptedEqualsNoPadding(provider, Cipher.ENCRYPT_MODE, RSA_2048_Vector1, encrypted);
 
         c.init(Cipher.DECRYPT_MODE, privKey);
         c.update(RSA_Vector1_Encrypt_Private);
         encrypted = c.doFinal();
-        assertTrue("Encrypted should match expected", Arrays.equals(RSA_2048_Vector1, encrypted));
+        assertEncryptedEqualsNoPadding(provider, Cipher.DECRYPT_MODE, RSA_2048_Vector1, encrypted);
     }
 
     public void testRSA_ECB_NoPadding_Public_SingleByteUpdateThenEmptyDoFinal_Success()
             throws Exception {
+        for (String provider : RSA_PROVIDERS) {
+            testRSA_ECB_NoPadding_Public_SingleByteUpdateThenEmptyDoFinal_Success(provider);
+        }
+    }
+
+    private void testRSA_ECB_NoPadding_Public_SingleByteUpdateThenEmptyDoFinal_Success(String provider)
+            throws Exception {
         KeyFactory kf = KeyFactory.getInstance("RSA");
         RSAPublicKeySpec keySpec = new RSAPublicKeySpec(RSA_2048_modulus, RSA_2048_publicExponent);
 
         final PublicKey privKey = kf.generatePublic(keySpec);
 
-        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding");
+        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding", provider);
 
         /*
          * You're actually encrypting with public keys, but there is no
@@ -1145,23 +1497,29 @@ public final class CipherTest extends TestCase {
             c.update(RSA_Vector1_Encrypt_Private, i, 1);
         }
         byte[] encrypted = c.doFinal(RSA_Vector1_Encrypt_Private, i, RSA_2048_Vector1.length - i);
-        assertTrue("Encrypted should match expected", Arrays.equals(RSA_2048_Vector1, encrypted));
+        assertEncryptedEqualsNoPadding(provider, Cipher.ENCRYPT_MODE, RSA_2048_Vector1, encrypted);
 
         c.init(Cipher.DECRYPT_MODE, privKey);
         for (i = 0; i < RSA_Vector1_Encrypt_Private.length / 2; i++) {
             c.update(RSA_Vector1_Encrypt_Private, i, 1);
         }
         encrypted = c.doFinal(RSA_Vector1_Encrypt_Private, i, RSA_2048_Vector1.length - i);
-        assertTrue("Encrypted should match expected", Arrays.equals(RSA_2048_Vector1, encrypted));
+        assertEncryptedEqualsNoPadding(provider, Cipher.DECRYPT_MODE, RSA_2048_Vector1, encrypted);
     }
 
     public void testRSA_ECB_NoPadding_Public_TooSmall_Success() throws Exception {
+        for (String provider : RSA_PROVIDERS) {
+            testRSA_ECB_NoPadding_Public_TooSmall_Success(provider);
+        }
+    }
+
+    private void testRSA_ECB_NoPadding_Public_TooSmall_Success(String provider) throws Exception {
         KeyFactory kf = KeyFactory.getInstance("RSA");
         RSAPublicKeySpec keySpec = new RSAPublicKeySpec(RSA_2048_modulus, RSA_2048_publicExponent);
 
         final PublicKey privKey = kf.generatePublic(keySpec);
 
-        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding");
+        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding", provider);
 
         /*
          * You're actually encrypting with public keys, but there is no
@@ -1180,13 +1538,19 @@ public final class CipherTest extends TestCase {
     }
 
     public void testRSA_ECB_NoPadding_Private_TooSmall_Success() throws Exception {
+        for (String provider : RSA_PROVIDERS) {
+            testRSA_ECB_NoPadding_Private_TooSmall_Success(provider);
+        }
+    }
+
+    private void testRSA_ECB_NoPadding_Private_TooSmall_Success(String provider) throws Exception {
         KeyFactory kf = KeyFactory.getInstance("RSA");
         RSAPrivateKeySpec keySpec = new RSAPrivateKeySpec(RSA_2048_modulus,
                 RSA_2048_privateExponent);
 
         final PrivateKey privKey = kf.generatePrivate(keySpec);
 
-        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding");
+        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding", provider);
 
         /*
          * You're actually encrypting with public keys, but there is no
@@ -1195,24 +1559,48 @@ public final class CipherTest extends TestCase {
          */
         c.init(Cipher.ENCRYPT_MODE, privKey);
         byte[] encrypted = c.doFinal(RSA_Vector1_ZeroPadded_Encrypted);
-        assertTrue("Encrypted should match expected",
-                Arrays.equals(TooShort_Vector_Zero_Padded, encrypted));
+        assertEncryptedEqualsNoPadding(provider, Cipher.ENCRYPT_MODE,
+                                       TooShort_Vector_Zero_Padded, encrypted);
 
         c.init(Cipher.DECRYPT_MODE, privKey);
         encrypted = c.doFinal(RSA_Vector1_ZeroPadded_Encrypted);
-        assertTrue("Encrypted should match expected",
-                Arrays.equals(TooShort_Vector_Zero_Padded, encrypted));
+        assertEncryptedEqualsNoPadding(provider, Cipher.DECRYPT_MODE,
+                                       TooShort_Vector_Zero_Padded, encrypted);
+    }
+
+    private static void assertEncryptedEqualsNoPadding(String provider, int mode,
+                                                       byte[] expected, byte[] actual) {
+        if (provider.equals("BC") && mode == Cipher.DECRYPT_MODE) {
+            // BouncyCastle does us the favor of stripping leading zeroes in DECRYPT_MODE
+            int nonZeroOffset = 0;
+            for (byte b : expected) {
+                if (b != 0) {
+                    break;
+                }
+                nonZeroOffset++;
+            }
+            expected = Arrays.copyOfRange(expected, nonZeroOffset, expected.length);
+        }
+        assertEquals("Encrypted should match expected",
+                     Arrays.toString(expected), Arrays.toString(actual));
     }
 
     public void testRSA_ECB_NoPadding_Private_CombinedUpdateAndDoFinal_TooBig_Failure()
             throws Exception {
+        for (String provider : RSA_PROVIDERS) {
+            testRSA_ECB_NoPadding_Private_CombinedUpdateAndDoFinal_TooBig_Failure(provider);
+        }
+    }
+
+    private void testRSA_ECB_NoPadding_Private_CombinedUpdateAndDoFinal_TooBig_Failure(String provider)
+            throws Exception {
         KeyFactory kf = KeyFactory.getInstance("RSA");
         RSAPrivateKeySpec keySpec = new RSAPrivateKeySpec(RSA_2048_modulus,
                 RSA_2048_privateExponent);
 
         final PrivateKey privKey = kf.generatePrivate(keySpec);
 
-        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding");
+        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding", provider);
 
         /*
          * You're actually encrypting with public keys, but there is no
@@ -1226,18 +1614,28 @@ public final class CipherTest extends TestCase {
             c.doFinal(RSA_Vector1_ZeroPadded_Encrypted);
             fail("Should have error when block size is too big.");
         } catch (IllegalBlockSizeException success) {
+            assertFalse(provider, "BC".equals(provider));
+        } catch (ArrayIndexOutOfBoundsException success) {
+            assertEquals("BC", provider);
         }
     }
 
     public void testRSA_ECB_NoPadding_Private_UpdateInAndOutPlusDoFinal_TooBig_Failure()
             throws Exception {
+        for (String provider : RSA_PROVIDERS) {
+            testRSA_ECB_NoPadding_Private_UpdateInAndOutPlusDoFinal_TooBig_Failure(provider);
+        }
+    }
+
+    private void testRSA_ECB_NoPadding_Private_UpdateInAndOutPlusDoFinal_TooBig_Failure(String provider)
+            throws Exception {
         KeyFactory kf = KeyFactory.getInstance("RSA");
         RSAPrivateKeySpec keySpec = new RSAPrivateKeySpec(RSA_2048_modulus,
                 RSA_2048_privateExponent);
 
         final PrivateKey privKey = kf.generatePrivate(keySpec);
 
-        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding");
+        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding", provider);
 
         /*
          * You're actually encrypting with public keys, but there is no
@@ -1254,17 +1652,26 @@ public final class CipherTest extends TestCase {
             c.doFinal(RSA_Vector1_ZeroPadded_Encrypted);
             fail("Should have error when block size is too big.");
         } catch (IllegalBlockSizeException success) {
+            assertFalse(provider, "BC".equals(provider));
+        } catch (ArrayIndexOutOfBoundsException success) {
+            assertEquals("BC", provider);
         }
     }
 
     public void testRSA_ECB_NoPadding_Private_OnlyDoFinal_TooBig_Failure() throws Exception {
+        for (String provider : RSA_PROVIDERS) {
+            testRSA_ECB_NoPadding_Private_OnlyDoFinal_TooBig_Failure(provider);
+        }
+    }
+
+    private void testRSA_ECB_NoPadding_Private_OnlyDoFinal_TooBig_Failure(String provider) throws Exception {
         KeyFactory kf = KeyFactory.getInstance("RSA");
         RSAPrivateKeySpec keySpec = new RSAPrivateKeySpec(RSA_2048_modulus,
                 RSA_2048_privateExponent);
 
         final PrivateKey privKey = kf.generatePrivate(keySpec);
 
-        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding");
+        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding", provider);
 
         /*
          * You're actually encrypting with public keys, but there is no
@@ -1283,26 +1690,46 @@ public final class CipherTest extends TestCase {
             c.doFinal(tooBig_Vector);
             fail("Should have error when block size is too big.");
         } catch (IllegalBlockSizeException success) {
+            assertFalse(provider, "BC".equals(provider));
+        } catch (ArrayIndexOutOfBoundsException success) {
+            assertEquals("BC", provider);
         }
     }
 
     public void testRSA_ECB_NoPadding_GetBlockSize_Success() throws Exception {
-        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding");
-        assertEquals("RSA is not a block cipher and should return block size of 0",
-                0, c.getBlockSize());
+        for (String provider : RSA_PROVIDERS) {
+            testRSA_ECB_NoPadding_GetBlockSize_Success(provider);
+        }
+    }
+
+    private void testRSA_ECB_NoPadding_GetBlockSize_Success(String provider) throws Exception {
+        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding", provider);
+        if (StandardNames.IS_RI) {
+            assertEquals(0, c.getBlockSize());
+        } else {
+            try {
+                c.getBlockSize();
+                fail();
+            } catch (IllegalStateException expected) {
+            }
+        }
 
         KeyFactory kf = KeyFactory.getInstance("RSA");
         RSAPublicKeySpec pubKeySpec = new RSAPublicKeySpec(RSA_2048_modulus,
                 RSA_2048_publicExponent);
         final PublicKey pubKey = kf.generatePublic(pubKeySpec);
         c.init(Cipher.ENCRYPT_MODE, pubKey);
-
-        assertEquals("RSA is not a block cipher and should return block size of 0",
-                0, c.getBlockSize());
+        assertEquals(getExpectedBlockSize("RSA", Cipher.ENCRYPT_MODE, provider), c.getBlockSize());
     }
 
     public void testRSA_ECB_NoPadding_GetOutputSize_NoInit_Failure() throws Exception {
-        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding");
+        for (String provider : RSA_PROVIDERS) {
+            testRSA_ECB_NoPadding_GetOutputSize_NoInit_Failure(provider);
+        }
+    }
+
+    private void testRSA_ECB_NoPadding_GetOutputSize_NoInit_Failure(String provider) throws Exception {
+        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding", provider);
         try {
             c.getOutputSize(RSA_2048_Vector1.length);
             fail("Should throw IllegalStateException if getOutputSize is called before init");
@@ -1311,32 +1738,39 @@ public final class CipherTest extends TestCase {
     }
 
     public void testRSA_ECB_NoPadding_GetOutputSize_Success() throws Exception {
+        for (String provider : RSA_PROVIDERS) {
+            testRSA_ECB_NoPadding_GetOutputSize_Success(provider);
+        }
+    }
+
+    private void testRSA_ECB_NoPadding_GetOutputSize_Success(String provider) throws Exception {
         KeyFactory kf = KeyFactory.getInstance("RSA");
         RSAPublicKeySpec pubKeySpec = new RSAPublicKeySpec(RSA_2048_modulus,
                 RSA_2048_publicExponent);
         final PublicKey pubKey = kf.generatePublic(pubKeySpec);
 
-        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding");
+        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding", provider);
         c.init(Cipher.ENCRYPT_MODE, pubKey);
 
         final int modulusInBytes = RSA_2048_modulus.bitLength() / 8;
-        assertEquals("Output size should be equal to modulus size",
-                modulusInBytes, c.getOutputSize(RSA_2048_Vector1.length));
-
-        assertEquals("Output size should be equal to modulus size",
-                modulusInBytes, c.getOutputSize(RSA_2048_Vector1.length * 2));
-
-        assertEquals("Output size should be equal to modulus size",
-                modulusInBytes, c.getOutputSize(0));
+        assertEquals(modulusInBytes, c.getOutputSize(RSA_2048_Vector1.length));
+        assertEquals(modulusInBytes, c.getOutputSize(RSA_2048_Vector1.length * 2));
+        assertEquals(modulusInBytes, c.getOutputSize(0));
     }
 
     public void testRSA_ECB_NoPadding_GetIV_Success() throws Exception {
+        for (String provider : RSA_PROVIDERS) {
+            testRSA_ECB_NoPadding_GetIV_Success(provider);
+        }
+    }
+
+    private void testRSA_ECB_NoPadding_GetIV_Success(String provider) throws Exception {
         KeyFactory kf = KeyFactory.getInstance("RSA");
         RSAPublicKeySpec pubKeySpec = new RSAPublicKeySpec(RSA_2048_modulus,
                 RSA_2048_publicExponent);
         final PublicKey pubKey = kf.generatePublic(pubKeySpec);
 
-        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding");
+        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding", provider);
         assertNull("ECB mode has no IV and should be null", c.getIV());
 
         c.init(Cipher.ENCRYPT_MODE, pubKey);
@@ -1345,12 +1779,390 @@ public final class CipherTest extends TestCase {
     }
 
     public void testRSA_ECB_NoPadding_GetParameters_NoneProvided_Success() throws Exception {
+        for (String provider : RSA_PROVIDERS) {
+            testRSA_ECB_NoPadding_GetParameters_NoneProvided_Success(provider);
+        }
+    }
+
+    private void testRSA_ECB_NoPadding_GetParameters_NoneProvided_Success(String provider) throws Exception {
         KeyFactory kf = KeyFactory.getInstance("RSA");
         RSAPublicKeySpec pubKeySpec = new RSAPublicKeySpec(RSA_2048_modulus,
                 RSA_2048_publicExponent);
         final PublicKey pubKey = kf.generatePublic(pubKeySpec);
 
-        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding");
+        Cipher c = Cipher.getInstance("RSA/ECB/NoPadding", provider);
         assertNull("Parameters should be null", c.getParameters());
     }
+
+    /*
+     * Test vector generation:
+     * openssl rand -hex 16
+     * echo '3d4f8970b1f27537f40a39298a41555f' | sed 's/\(..\)/(byte) 0x\1, /g'
+     */
+    private static final byte[] AES_128_KEY = new byte[] {
+            (byte) 0x3d, (byte) 0x4f, (byte) 0x89, (byte) 0x70, (byte) 0xb1, (byte) 0xf2,
+            (byte) 0x75, (byte) 0x37, (byte) 0xf4, (byte) 0x0a, (byte) 0x39, (byte) 0x29,
+            (byte) 0x8a, (byte) 0x41, (byte) 0x55, (byte) 0x5f,
+    };
+
+    /*
+     * Test key generation:
+     * openssl rand -hex 24
+     * echo '5a7a3d7e40b64ed996f7afa15f97fd595e27db6af428e342' | sed 's/\(..\)/(byte) 0x\1, /g'
+     */
+    private static final byte[] AES_192_KEY = new byte[] {
+            (byte) 0x5a, (byte) 0x7a, (byte) 0x3d, (byte) 0x7e, (byte) 0x40, (byte) 0xb6,
+            (byte) 0x4e, (byte) 0xd9, (byte) 0x96, (byte) 0xf7, (byte) 0xaf, (byte) 0xa1,
+            (byte) 0x5f, (byte) 0x97, (byte) 0xfd, (byte) 0x59, (byte) 0x5e, (byte) 0x27,
+            (byte) 0xdb, (byte) 0x6a, (byte) 0xf4, (byte) 0x28, (byte) 0xe3, (byte) 0x42,
+    };
+
+    /*
+     * Test key generation:
+     * openssl rand -hex 32
+     * echo 'ec53c6d51d2c4973585fb0b8e51cd2e39915ff07a1837872715d6121bf861935' | sed 's/\(..\)/(byte) 0x\1, /g'
+     */
+    private static final byte[] AES_256_KEY = new byte[] {
+            (byte) 0xec, (byte) 0x53, (byte) 0xc6, (byte) 0xd5, (byte) 0x1d, (byte) 0x2c,
+            (byte) 0x49, (byte) 0x73, (byte) 0x58, (byte) 0x5f, (byte) 0xb0, (byte) 0xb8,
+            (byte) 0xe5, (byte) 0x1c, (byte) 0xd2, (byte) 0xe3, (byte) 0x99, (byte) 0x15,
+            (byte) 0xff, (byte) 0x07, (byte) 0xa1, (byte) 0x83, (byte) 0x78, (byte) 0x72,
+            (byte) 0x71, (byte) 0x5d, (byte) 0x61, (byte) 0x21, (byte) 0xbf, (byte) 0x86,
+            (byte) 0x19, (byte) 0x35,
+    };
+
+    private static final byte[][] AES_KEYS = new byte[][] {
+            AES_128_KEY, AES_192_KEY, AES_256_KEY,
+    };
+
+    private static final String[] AES_MODES = new String[] {
+            "AES/ECB",
+            "AES/CBC",
+            "AES/CFB",
+            "AES/CTR",
+            "AES/OFB",
+    };
+
+    /*
+     * Test vector creation:
+     * echo -n 'Hello, world!' | recode ../x1 | sed 's/0x/(byte) 0x/g'
+     */
+    private static final byte[] AES_128_ECB_PKCS5Padding_TestVector_1_Plaintext = new byte[] {
+            (byte) 0x48, (byte) 0x65, (byte) 0x6C, (byte) 0x6C, (byte) 0x6F, (byte) 0x2C,
+            (byte) 0x20, (byte) 0x77, (byte) 0x6F, (byte) 0x72, (byte) 0x6C, (byte) 0x64,
+            (byte) 0x21,
+    };
+
+    /*
+     * Test vector creation:
+     * openssl enc -aes-128-ecb -K 3d4f8970b1f27537f40a39298a41555f -in blah|openssl enc -aes-128-ecb -K 3d4f8970b1f27537f40a39298a41555f -nopad -d|recode ../x1 | sed 's/0x/(byte) 0x/g'
+     */
+    private static final byte[] AES_128_ECB_PKCS5Padding_TestVector_1_Plaintext_Padded = new byte[] {
+            (byte) 0x48, (byte) 0x65, (byte) 0x6C, (byte) 0x6C, (byte) 0x6F, (byte) 0x2C,
+            (byte) 0x20, (byte) 0x77, (byte) 0x6F, (byte) 0x72, (byte) 0x6C, (byte) 0x64,
+            (byte) 0x21, (byte) 0x03, (byte) 0x03, (byte) 0x03
+    };
+
+    /*
+     * Test vector generation:
+     * openssl enc -aes-128-ecb -K 3d4f8970b1f27537f40a39298a41555f -in blah|recode ../x1 | sed 's/0x/(byte) 0x/g'
+     */
+    private static final byte[] AES_128_ECB_PKCS5Padding_TestVector_1_Encrypted = new byte[] {
+            (byte) 0x65, (byte) 0x3E, (byte) 0x86, (byte) 0xFB, (byte) 0x05, (byte) 0x5A,
+            (byte) 0x52, (byte) 0xEA, (byte) 0xDD, (byte) 0x08, (byte) 0xE7, (byte) 0x48,
+            (byte) 0x33, (byte) 0x01, (byte) 0xFC, (byte) 0x5A,
+    };
+
+    /*
+     * Test key generation:
+     * openssl rand -hex 16
+     * echo 'ceaa31952dfd3d0f5af4b2042ba06094' | sed 's/\(..\)/(byte) 0x\1, /g'
+     */
+    private static final byte[] AES_256_CBC_PKCS5Padding_TestVector_1_IV = new byte[] {
+            (byte) 0xce, (byte) 0xaa, (byte) 0x31, (byte) 0x95, (byte) 0x2d, (byte) 0xfd,
+            (byte) 0x3d, (byte) 0x0f, (byte) 0x5a, (byte) 0xf4, (byte) 0xb2, (byte) 0x04,
+            (byte) 0x2b, (byte) 0xa0, (byte) 0x60, (byte) 0x94,
+    };
+
+    /*
+     * Test vector generation:
+     * echo -n 'I only regret that I have but one test to write.' | recode ../x1 | sed 's/0x/(byte) 0x/g'
+     */
+    private static final byte[] AES_256_CBC_PKCS5Padding_TestVector_1_Plaintext = new byte[] {
+            (byte) 0x49, (byte) 0x20, (byte) 0x6F, (byte) 0x6E, (byte) 0x6C, (byte) 0x79,
+            (byte) 0x20, (byte) 0x72, (byte) 0x65, (byte) 0x67, (byte) 0x72, (byte) 0x65,
+            (byte) 0x74, (byte) 0x20, (byte) 0x74, (byte) 0x68, (byte) 0x61, (byte) 0x74,
+            (byte) 0x20, (byte) 0x49, (byte) 0x20, (byte) 0x68, (byte) 0x61, (byte) 0x76,
+            (byte) 0x65, (byte) 0x20, (byte) 0x62, (byte) 0x75, (byte) 0x74, (byte) 0x20,
+            (byte) 0x6F, (byte) 0x6E, (byte) 0x65, (byte) 0x20, (byte) 0x74, (byte) 0x65,
+            (byte) 0x73, (byte) 0x74, (byte) 0x20, (byte) 0x74, (byte) 0x6F, (byte) 0x20,
+            (byte) 0x77, (byte) 0x72, (byte) 0x69, (byte) 0x74, (byte) 0x65, (byte) 0x2E
+    };
+
+    /*
+     * Test vector generation:
+     * echo -n 'I only regret that I have but one test to write.' | openssl enc -aes-256-cbc -K ec53c6d51d2c4973585fb0b8e51cd2e39915ff07a1837872715d6121bf861935 -iv ceaa31952dfd3d0f5af4b2042ba06094 | openssl enc -aes-256-cbc -K ec53c6d51d2c4973585fb0b8e51cd2e39915ff07a1837872715d6121bf861935 -iv ceaa31952dfd3d0f5af4b2042ba06094 -d -nopad | recode ../x1 | sed 's/0x/(byte) 0x/g'
+     */
+    private static final byte[] AES_256_CBC_PKCS5Padding_TestVector_1_Plaintext_Padded = new byte[] {
+            (byte) 0x49, (byte) 0x20, (byte) 0x6F, (byte) 0x6E, (byte) 0x6C, (byte) 0x79,
+            (byte) 0x20, (byte) 0x72, (byte) 0x65, (byte) 0x67, (byte) 0x72, (byte) 0x65,
+            (byte) 0x74, (byte) 0x20, (byte) 0x74, (byte) 0x68, (byte) 0x61, (byte) 0x74,
+            (byte) 0x20, (byte) 0x49, (byte) 0x20, (byte) 0x68, (byte) 0x61, (byte) 0x76,
+            (byte) 0x65, (byte) 0x20, (byte) 0x62, (byte) 0x75, (byte) 0x74, (byte) 0x20,
+            (byte) 0x6F, (byte) 0x6E, (byte) 0x65, (byte) 0x20, (byte) 0x74, (byte) 0x65,
+            (byte) 0x73, (byte) 0x74, (byte) 0x20, (byte) 0x74, (byte) 0x6F, (byte) 0x20,
+            (byte) 0x77, (byte) 0x72, (byte) 0x69, (byte) 0x74, (byte) 0x65, (byte) 0x2E,
+            (byte) 0x10, (byte) 0x10, (byte) 0x10, (byte) 0x10, (byte) 0x10, (byte) 0x10,
+            (byte) 0x10, (byte) 0x10, (byte) 0x10, (byte) 0x10, (byte) 0x10, (byte) 0x10,
+            (byte) 0x10, (byte) 0x10, (byte) 0x10, (byte) 0x10
+    };
+
+    /*
+     * Test vector generation:
+     * echo -n 'I only regret that I have but one test to write.' | openssl enc -aes-256-cbc -K ec53c6d51d2c4973585fb0b8e51cd2e39915ff07a1837872715d6121bf861935 -iv ceaa31952dfd3d0f5af4b2042ba06094 | recode ../x1 | sed 's/0x/(byte) 0x/g'
+     */
+    private static final byte[] AES_256_CBC_PKCS5Padding_TestVector_1_Ciphertext = new byte[] {
+            (byte) 0x90, (byte) 0x65, (byte) 0xDD, (byte) 0xAF, (byte) 0x7A, (byte) 0xCE,
+            (byte) 0xAE, (byte) 0xBF, (byte) 0xE8, (byte) 0xF6, (byte) 0x9E, (byte) 0xDB,
+            (byte) 0xEA, (byte) 0x65, (byte) 0x28, (byte) 0xC4, (byte) 0x9A, (byte) 0x28,
+            (byte) 0xEA, (byte) 0xA3, (byte) 0x95, (byte) 0x2E, (byte) 0xFF, (byte) 0xF1,
+            (byte) 0xA0, (byte) 0xCA, (byte) 0xC2, (byte) 0xA4, (byte) 0x65, (byte) 0xCD,
+            (byte) 0xBF, (byte) 0xCE, (byte) 0x9E, (byte) 0xF1, (byte) 0x57, (byte) 0xF6,
+            (byte) 0x32, (byte) 0x2E, (byte) 0x8F, (byte) 0x93, (byte) 0x2E, (byte) 0xAE,
+            (byte) 0x41, (byte) 0x33, (byte) 0x54, (byte) 0xD0, (byte) 0xEF, (byte) 0x8C,
+            (byte) 0x52, (byte) 0x14, (byte) 0xAC, (byte) 0x2D, (byte) 0xD5, (byte) 0xA4,
+            (byte) 0xF9, (byte) 0x20, (byte) 0x77, (byte) 0x25, (byte) 0x91, (byte) 0x3F,
+            (byte) 0xD1, (byte) 0xB9, (byte) 0x00, (byte) 0x3E
+    };
+
+    private static class CipherTestParam {
+        public final String mode;
+
+        public final byte[] key;
+
+        public final byte[] iv;
+
+        public final byte[] plaintext;
+
+        public final byte[] ciphertext;
+
+        public final byte[] plaintextPadded;
+
+        public CipherTestParam(String mode, byte[] key, byte[] iv, byte[] plaintext,
+                byte[] plaintextPadded, byte[] ciphertext) {
+            this.mode = mode;
+            this.key = key;
+            this.iv = iv;
+            this.plaintext = plaintext;
+            this.plaintextPadded = plaintextPadded;
+            this.ciphertext = ciphertext;
+        }
+    }
+
+    private static List<CipherTestParam> CIPHER_TEST_PARAMS = new ArrayList<CipherTestParam>();
+    static {
+        CIPHER_TEST_PARAMS.add(new CipherTestParam("AES/ECB", AES_128_KEY,
+                null,
+                AES_128_ECB_PKCS5Padding_TestVector_1_Plaintext,
+                AES_128_ECB_PKCS5Padding_TestVector_1_Plaintext_Padded,
+                AES_128_ECB_PKCS5Padding_TestVector_1_Encrypted));
+        if (IS_UNLIMITED) {
+            CIPHER_TEST_PARAMS.add(new CipherTestParam("AES/CBC", AES_256_KEY,
+                    AES_256_CBC_PKCS5Padding_TestVector_1_IV,
+                    AES_256_CBC_PKCS5Padding_TestVector_1_Plaintext,
+                    AES_256_CBC_PKCS5Padding_TestVector_1_Plaintext_Padded,
+                    AES_256_CBC_PKCS5Padding_TestVector_1_Ciphertext));
+        }
+    }
+
+    public void testCipher_Success() throws Exception {
+        for (String provider : AES_PROVIDERS) {
+            testCipher_Success(provider);
+        }
+    }
+
+    private void testCipher_Success(String provider) throws Exception {
+        final ByteArrayOutputStream errBuffer = new ByteArrayOutputStream();
+        PrintStream out = new PrintStream(errBuffer);
+        for (CipherTestParam p : CIPHER_TEST_PARAMS) {
+            try {
+                checkCipher(p, provider);
+            } catch (Exception e) {
+                out.append("Error encountered checking " + p.mode + ", keySize="
+                        + (p.key.length * 8) + "\n");
+                e.printStackTrace(out);
+            }
+        }
+        out.flush();
+        if (errBuffer.size() > 0) {
+            throw new Exception("Errors encountered:\n\n" + errBuffer.toString() + "\n\n");
+        }
+    }
+
+    private void checkCipher(CipherTestParam p, String provider) throws Exception {
+        SecretKey key = new SecretKeySpec(p.key, "AES");
+        Cipher c = Cipher.getInstance(p.mode + "/PKCS5Padding", provider);
+        AlgorithmParameterSpec spec = null;
+        if (p.iv != null) {
+            spec = new IvParameterSpec(p.iv);
+        }
+        c.init(Cipher.ENCRYPT_MODE, key, spec);
+
+        final byte[] actualCiphertext = c.doFinal(p.plaintext);
+        assertTrue(Arrays.equals(p.ciphertext, actualCiphertext));
+
+        c.init(Cipher.DECRYPT_MODE, key, spec);
+
+        final byte[] actualPlaintext = c.doFinal(p.ciphertext);
+        assertTrue(Arrays.equals(p.plaintext, actualPlaintext));
+
+        Cipher cNoPad = Cipher.getInstance(p.mode + "/NoPadding", provider);
+        cNoPad.init(Cipher.DECRYPT_MODE, key, spec);
+
+        final byte[] actualPlaintextPadded = cNoPad.doFinal(p.ciphertext);
+        assertTrue(Arrays.equals(p.plaintextPadded, actualPlaintextPadded));
+    }
+
+    public void testCipher_ShortBlock_Failure() throws Exception {
+        for (String provider : AES_PROVIDERS) {
+            testCipher_ShortBlock_Failure(provider);
+        }
+    }
+
+    private void testCipher_ShortBlock_Failure(String provider) throws Exception {
+        final ByteArrayOutputStream errBuffer = new ByteArrayOutputStream();
+        PrintStream out = new PrintStream(errBuffer);
+        for (CipherTestParam p : CIPHER_TEST_PARAMS) {
+            try {
+                checkCipher_ShortBlock_Failure(p, provider);
+            } catch (Exception e) {
+                out.append("Error encountered checking " + p.mode + ", keySize="
+                        + (p.key.length * 8) + "\n");
+                e.printStackTrace(out);
+            }
+        }
+        out.flush();
+        if (errBuffer.size() > 0) {
+            throw new Exception("Errors encountered:\n\n" + errBuffer.toString() + "\n\n");
+        }
+    }
+
+    private void checkCipher_ShortBlock_Failure(CipherTestParam p, String provider) throws Exception {
+        SecretKey key = new SecretKeySpec(p.key, "AES");
+        Cipher c = Cipher.getInstance(p.mode + "/NoPadding", provider);
+        if (c.getBlockSize() == 0) {
+            return;
+        }
+
+        c.init(Cipher.ENCRYPT_MODE, key);
+        try {
+            c.doFinal(new byte[] { 0x01, 0x02, 0x03 });
+            fail("Should throw IllegalBlockSizeException on wrong-sized block");
+        } catch (IllegalBlockSizeException expected) {
+        }
+    }
+
+    public void testAES_ECB_PKCS5Padding_ShortBuffer_Failure() throws Exception {
+        for (String provider : AES_PROVIDERS) {
+            testAES_ECB_PKCS5Padding_ShortBuffer_Failure(provider);
+        }
+    }
+
+    private void testAES_ECB_PKCS5Padding_ShortBuffer_Failure(String provider) throws Exception {
+        SecretKey key = new SecretKeySpec(AES_128_KEY, "AES");
+        Cipher c = Cipher.getInstance("AES/ECB/PKCS5Padding", provider);
+        c.init(Cipher.ENCRYPT_MODE, key);
+
+        final byte[] fragmentOutput = c.update(AES_128_ECB_PKCS5Padding_TestVector_1_Plaintext);
+        if (fragmentOutput != null) {
+            assertEquals(0, fragmentOutput.length);
+        }
+
+        // Provide null buffer.
+        {
+            try {
+                c.doFinal(null, 0);
+                fail("Should throw NullPointerException on null output buffer");
+            } catch (NullPointerException expected) {
+            } catch (IllegalArgumentException expected) {
+            }
+        }
+
+        // Provide short buffer.
+        {
+            final byte[] output = new byte[c.getBlockSize() - 1];
+            try {
+                c.doFinal(output, 0);
+                fail("Should throw ShortBufferException on short output buffer");
+            } catch (ShortBufferException expected) {
+            }
+        }
+
+        // Start 1 byte into output buffer.
+        {
+            final byte[] output = new byte[c.getBlockSize()];
+            try {
+                c.doFinal(output, 1);
+                fail("Should throw ShortBufferException on short output buffer");
+            } catch (ShortBufferException expected) {
+            }
+        }
+
+        // Should keep data for real output buffer
+        {
+            final byte[] output = new byte[c.getBlockSize()];
+            assertEquals(AES_128_ECB_PKCS5Padding_TestVector_1_Encrypted.length, c.doFinal(output, 0));
+            assertTrue(Arrays.equals(AES_128_ECB_PKCS5Padding_TestVector_1_Encrypted, output));
+        }
+    }
+
+    public void testAES_ECB_NoPadding_IncrementalUpdate_Success() throws Exception {
+        for (String provider : AES_PROVIDERS) {
+            testAES_ECB_NoPadding_IncrementalUpdate_Success(provider);
+        }
+    }
+
+    private void testAES_ECB_NoPadding_IncrementalUpdate_Success(String provider) throws Exception {
+        SecretKey key = new SecretKeySpec(AES_128_KEY, "AES");
+        Cipher c = Cipher.getInstance("AES/ECB/NoPadding", provider);
+        c.init(Cipher.ENCRYPT_MODE, key);
+
+        for (int i = 0; i < AES_128_ECB_PKCS5Padding_TestVector_1_Plaintext_Padded.length - 1; i++) {
+            final byte[] outputFragment = c.update(AES_128_ECB_PKCS5Padding_TestVector_1_Plaintext_Padded, i, 1);
+            if (outputFragment != null) {
+                assertEquals(0, outputFragment.length);
+            }
+        }
+
+        final byte[] output = c.doFinal(AES_128_ECB_PKCS5Padding_TestVector_1_Plaintext_Padded,
+                AES_128_ECB_PKCS5Padding_TestVector_1_Plaintext_Padded.length - 1, 1);
+        assertNotNull(output);
+        assertEquals(AES_128_ECB_PKCS5Padding_TestVector_1_Plaintext_Padded.length, output.length);
+
+        assertTrue(Arrays.equals(AES_128_ECB_PKCS5Padding_TestVector_1_Encrypted, output));
+    }
+
+    private static final byte[] AES_IV_ZEROES = new byte[] {
+            (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
+            (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
+            (byte) 0x00, (byte) 0x00, (byte) 0x00, (byte) 0x00,
+    };
+
+    public void testAES_ECB_NoPadding_IvParameters_Failure() throws Exception {
+        for (String provider : AES_PROVIDERS) {
+            testAES_ECB_NoPadding_IvParameters_Failure(provider);
+        }
+    }
+
+    private void testAES_ECB_NoPadding_IvParameters_Failure(String provider) throws Exception {
+        SecretKey key = new SecretKeySpec(AES_128_KEY, "AES");
+        Cipher c = Cipher.getInstance("AES/ECB/NoPadding", provider);
+
+        AlgorithmParameterSpec spec = new IvParameterSpec(AES_IV_ZEROES);
+        try {
+            c.init(Cipher.ENCRYPT_MODE, key, spec);
+            fail("Should not accept an IV in ECB mode");
+        } catch (InvalidAlgorithmParameterException expected) {
+        }
+    }
 }
diff --git a/support/src/test/java/libcore/java/security/StandardNames.java b/support/src/test/java/libcore/java/security/StandardNames.java
index dc57086..4211a10 100644
--- a/support/src/test/java/libcore/java/security/StandardNames.java
+++ b/support/src/test/java/libcore/java/security/StandardNames.java
@@ -85,6 +85,13 @@ public final class StandardNames extends Assert {
      */
     public static final Map<String,Set<String>> PROVIDER_ALGORITHMS
             = new HashMap<String,Set<String>>();
+
+    public static final Map<String,Set<String>> CIPHER_MODES
+            = new HashMap<String,Set<String>>();
+
+    public static final Map<String,Set<String>> CIPHER_PADDINGS
+            = new HashMap<String,Set<String>>();
+
     private static void provide(String type, String algorithm) {
         Set<String> algorithms = PROVIDER_ALGORITHMS.get(type);
         if (algorithms == null) {
@@ -102,6 +109,22 @@ public final class StandardNames extends Assert {
             assertNotNull(PROVIDER_ALGORITHMS.remove(type));
         }
     }
+    private static void provideCipherModes(String algorithm, String newModes[]) {
+        Set<String> modes = CIPHER_MODES.get(algorithm);
+        if (modes == null) {
+            modes = new HashSet<String>();
+            CIPHER_MODES.put(algorithm, modes);
+        }
+        modes.addAll(Arrays.asList(newModes));
+    }
+    private static void provideCipherPaddings(String algorithm, String newPaddings[]) {
+        Set<String> paddings = CIPHER_MODES.get(algorithm);
+        if (paddings == null) {
+            paddings = new HashSet<String>();
+            CIPHER_MODES.put(algorithm, paddings);
+        }
+        paddings.addAll(Arrays.asList(newPaddings));
+    }
     static {
         provide("AlgorithmParameterGenerator", "DSA");
         provide("AlgorithmParameterGenerator", "DiffieHellman");
@@ -122,7 +145,10 @@ public final class StandardNames extends Assert {
         provide("CertStore", "Collection");
         provide("CertStore", "LDAP");
         provide("CertificateFactory", "X.509");
+        // TODO: provideCipherModes and provideCipherPaddings for other Ciphers
         provide("Cipher", "AES");
+        provideCipherModes("AES", new String[] { "CBC", "CFB", "CTR", "CTS", "ECB", "OFB" });
+        provideCipherPaddings("AES", new String[] { "NoPadding", "PKCS5Padding" });
         provide("Cipher", "AESWrap");
         provide("Cipher", "ARCFOUR");
         provide("Cipher", "Blowfish");
@@ -848,4 +874,18 @@ public final class StandardNames extends Assert {
         assertValidCipherSuites(CIPHER_SUITES, cipherSuites);
         assertEquals(CIPHER_SUITES_DEFAULT, Arrays.asList(cipherSuites));
     }
+
+    /**
+     * Get all supported mode names for the given cipher.
+     */
+    public static Set<String> getModesForCipher(String cipher) {
+        return CIPHER_MODES.get(cipher);
+    }
+
+    /**
+     * Get all supported padding names for the given cipher.
+     */
+    public static Set<String> getPaddingsForCipher(String cipher) {
+        return CIPHER_PADDINGS.get(cipher);
+    }
 }
-- 
cgit v1.1


From dd3dd77ee8e10d3f4ff7c9bfd41bdf681b9f7ae3 Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Fri, 12 Oct 2012 14:58:40 -0700
Subject: Change ThreadsTest to use CyclicBarrier to address flakiness

Bug: 7337970
Change-Id: I17318afadd04d972f907fe968e050ece98116c6a
---
 .../apache/harmony/kernel/dalvik/ThreadsTest.java  | 56 +++++++++++++++-------
 1 file changed, 40 insertions(+), 16 deletions(-)

diff --git a/luni/src/test/java/tests/api/org/apache/harmony/kernel/dalvik/ThreadsTest.java b/luni/src/test/java/tests/api/org/apache/harmony/kernel/dalvik/ThreadsTest.java
index bdc580d..95b5c13 100644
--- a/luni/src/test/java/tests/api/org/apache/harmony/kernel/dalvik/ThreadsTest.java
+++ b/luni/src/test/java/tests/api/org/apache/harmony/kernel/dalvik/ThreadsTest.java
@@ -17,7 +17,8 @@
 package tests.api.org.apache.harmony.kernel.dalvik;
 
 import java.lang.reflect.Field;
-
+import java.util.concurrent.CyclicBarrier;
+import java.util.concurrent.TimeUnit;
 import junit.framework.Assert;
 import junit.framework.TestCase;
 import sun.misc.Unsafe;
@@ -50,10 +51,11 @@ public class ThreadsTest extends TestCase {
 
     /** Test the case where the park times out. */
     public void test_parkFor_1() {
-        Parker parker = new Parker(false, 500);
+        CyclicBarrier barrier = new CyclicBarrier(2);
+        Parker parker = new Parker(barrier, false, 500);
         Thread parkerThread = new Thread(parker);
         Thread waiterThread =
-            new Thread(new WaitAndUnpark(1000, parkerThread));
+            new Thread(new WaitAndUnpark(barrier, 1000, parkerThread));
 
         parkerThread.start();
         waiterThread.start();
@@ -62,10 +64,11 @@ public class ThreadsTest extends TestCase {
 
     /** Test the case where the unpark happens before the timeout. */
     public void test_parkFor_2() {
-        Parker parker = new Parker(false, 1000);
+        CyclicBarrier barrier = new CyclicBarrier(2);
+        Parker parker = new Parker(barrier, false, 1000);
         Thread parkerThread = new Thread(parker);
         Thread waiterThread =
-            new Thread(new WaitAndUnpark(300, parkerThread));
+            new Thread(new WaitAndUnpark(barrier, 300, parkerThread));
 
         parkerThread.start();
         waiterThread.start();
@@ -74,7 +77,8 @@ public class ThreadsTest extends TestCase {
 
     /** Test the case where the thread is preemptively unparked. */
     public void test_parkFor_3() {
-        Parker parker = new Parker(false, 1000);
+        CyclicBarrier barrier = new CyclicBarrier(2);
+        Parker parker = new Parker(barrier, false, 1000);
         Thread parkerThread = new Thread(parker);
 
         UNSAFE.unpark(parkerThread);
@@ -84,10 +88,11 @@ public class ThreadsTest extends TestCase {
 
     /** Test the case where the park times out. */
     public void test_parkUntil_1() {
-        Parker parker = new Parker(true, 500);
+        CyclicBarrier barrier = new CyclicBarrier(2);
+        Parker parker = new Parker(barrier, true, 500);
         Thread parkerThread = new Thread(parker);
         Thread waiterThread =
-            new Thread(new WaitAndUnpark(1000, parkerThread));
+            new Thread(new WaitAndUnpark(barrier, 1000, parkerThread));
 
         parkerThread.start();
         waiterThread.start();
@@ -96,10 +101,11 @@ public class ThreadsTest extends TestCase {
 
     /** Test the case where the unpark happens before the timeout. */
     public void test_parkUntil_2() {
-        Parker parker = new Parker(true, 1000);
+        CyclicBarrier barrier = new CyclicBarrier(2);
+        Parker parker = new Parker(barrier, true, 1000);
         Thread parkerThread = new Thread(parker);
         Thread waiterThread =
-            new Thread(new WaitAndUnpark(300, parkerThread));
+            new Thread(new WaitAndUnpark(barrier, 300, parkerThread));
 
         parkerThread.start();
         waiterThread.start();
@@ -108,7 +114,8 @@ public class ThreadsTest extends TestCase {
 
     /** Test the case where the thread is preemptively unparked. */
     public void test_parkUntil_3() {
-        Parker parker = new Parker(true, 1000);
+        CyclicBarrier barrier = new CyclicBarrier(2);
+        Parker parker = new Parker(barrier, true, 1000);
         Thread parkerThread = new Thread(parker);
 
         UNSAFE.unpark(parkerThread);
@@ -123,6 +130,9 @@ public class ThreadsTest extends TestCase {
      * the indicated value, noting the duration of time actually parked.
      */
     private static class Parker implements Runnable {
+
+        private final CyclicBarrier barrier;
+
         /** whether {@link #amount} is milliseconds to wait in an
          * absolute fashion (<code>true</code>) or nanoseconds to wait
          * in a relative fashion (<code>false</code>) */
@@ -147,7 +157,8 @@ public class ThreadsTest extends TestCase {
          * either case, this constructor takes a duration to park for
          * @param parkMillis the number of milliseconds to be parked
          */
-        public Parker(boolean absolute, long parkMillis) {
+        public Parker(CyclicBarrier barrier, boolean absolute, long parkMillis) {
+            this.barrier = barrier;
             this.absolute = absolute;
 
             // Multiply by 1000000 because parkFor() takes nanoseconds.
@@ -155,8 +166,14 @@ public class ThreadsTest extends TestCase {
         }
 
         public void run() {
+            try {
+                barrier.await(60, TimeUnit.SECONDS);
+            } catch (Exception e) {
+                throw new AssertionError(e);
+            }
             boolean absolute = this.absolute;
             long amount = this.amount;
+            long startNanos = System.nanoTime();
             long start = System.currentTimeMillis();
 
             if (absolute) {
@@ -165,11 +182,11 @@ public class ThreadsTest extends TestCase {
                 UNSAFE.park(false, amount);
             }
 
-            long end = System.currentTimeMillis();
+            long endNanos = System.nanoTime();
 
             synchronized (this) {
-                startMillis = start;
-                endMillis = end;
+                startMillis = startNanos / 1000000;
+                endMillis = endNanos / 1000000;
                 completed = true;
                 notifyAll();
             }
@@ -230,16 +247,23 @@ public class ThreadsTest extends TestCase {
      * specified amount of time and then unparks an indicated thread.
      */
     private static class WaitAndUnpark implements Runnable {
+        private final CyclicBarrier barrier;
         private final long waitMillis;
         private final Thread thread;
 
-        public WaitAndUnpark(long waitMillis, Thread thread) {
+        public WaitAndUnpark(CyclicBarrier barrier, long waitMillis, Thread thread) {
+            this.barrier = barrier;
             this.waitMillis = waitMillis;
             this.thread = thread;
         }
 
         public void run() {
             try {
+                barrier.await(60, TimeUnit.SECONDS);
+            } catch (Exception e) {
+                throw new AssertionError(e);
+            }
+            try {
                 Thread.sleep(waitMillis);
             } catch (InterruptedException ex) {
                 throw new RuntimeException("shouldn't happen", ex);
-- 
cgit v1.1


From f86b7fe243d8d116fa708259f84a25331b2a235d Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Mon, 15 Oct 2012 11:03:38 -0700
Subject: Fix ThreadsTest use of CyclicBarrier

Bug: 7337970
Change-Id: I7da3e22bc2c773258d30f0919d51d386f7b92e7d
---
 .../java/tests/api/org/apache/harmony/kernel/dalvik/ThreadsTest.java  | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/luni/src/test/java/tests/api/org/apache/harmony/kernel/dalvik/ThreadsTest.java b/luni/src/test/java/tests/api/org/apache/harmony/kernel/dalvik/ThreadsTest.java
index 95b5c13..9c9f346 100644
--- a/luni/src/test/java/tests/api/org/apache/harmony/kernel/dalvik/ThreadsTest.java
+++ b/luni/src/test/java/tests/api/org/apache/harmony/kernel/dalvik/ThreadsTest.java
@@ -77,7 +77,7 @@ public class ThreadsTest extends TestCase {
 
     /** Test the case where the thread is preemptively unparked. */
     public void test_parkFor_3() {
-        CyclicBarrier barrier = new CyclicBarrier(2);
+        CyclicBarrier barrier = new CyclicBarrier(1);
         Parker parker = new Parker(barrier, false, 1000);
         Thread parkerThread = new Thread(parker);
 
@@ -114,7 +114,7 @@ public class ThreadsTest extends TestCase {
 
     /** Test the case where the thread is preemptively unparked. */
     public void test_parkUntil_3() {
-        CyclicBarrier barrier = new CyclicBarrier(2);
+        CyclicBarrier barrier = new CyclicBarrier(1);
         Parker parker = new Parker(barrier, true, 1000);
         Thread parkerThread = new Thread(parker);
 
-- 
cgit v1.1


From 2b096f630d94f957b981ef511c70c856893dc47e Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Mon, 15 Oct 2012 16:59:38 -0700
Subject: Fix test flakiness.

Support_PortManager is a bad idea, badly implemented. Kill some more of it.
Only OldDatagramSocketTest still uses Support_PortManager, so hopefully we
can kill this completely soon.

Bug: 7347233
Change-Id: I9dec7b23d59edc8c7a5e391dd5ebccd2a92f82b5
---
 .../test/java/libcore/java/net/OldSocketTest.java  | 437 ++++++---------------
 1 file changed, 118 insertions(+), 319 deletions(-)

diff --git a/luni/src/test/java/libcore/java/net/OldSocketTest.java b/luni/src/test/java/libcore/java/net/OldSocketTest.java
index fda9557..033a7bf 100644
--- a/luni/src/test/java/libcore/java/net/OldSocketTest.java
+++ b/luni/src/test/java/libcore/java/net/OldSocketTest.java
@@ -38,7 +38,6 @@ import java.nio.channels.IllegalBlockingModeException;
 import java.nio.channels.SocketChannel;
 import java.security.Permission;
 import tests.support.Support_Configuration;
-import tests.support.Support_PortManager;
 
 public class OldSocketTest extends OldSocketTestCase {
 
@@ -115,17 +114,15 @@ public class OldSocketTest extends OldSocketTestCase {
 
     public void test_ConstructorLjava_lang_StringILjava_net_InetAddressI1() throws IOException {
         int sport = startServer("Cons String,I,InetAddress,I");
-        int portNumber = Support_PortManager.getNextPort();
         s = new Socket(InetAddress.getLocalHost().getHostName(), sport,
-                InetAddress.getLocalHost(), portNumber);
+                InetAddress.getLocalHost(), 0);
         assertTrue("Failed to create socket", s.getPort() == sport);
     }
 
     public void test_ConstructorLjava_lang_StringILjava_net_InetAddressI2() throws IOException {
-        int testPort = Support_PortManager.getNextPort();
-        Socket s1 = new Socket("www.google.com", 80, null, testPort);
+        Socket s1 = new Socket("www.google.com", 80, null, 0);
         try {
-            Socket s2 = new Socket("www.google.com", 80, null, testPort);
+            Socket s2 = new Socket("www.google.com", 80, null, s1.getLocalPort());
             try {
                 s2.close();
             } catch (IOException ignored) {
@@ -162,10 +159,8 @@ public class OldSocketTest extends OldSocketTestCase {
         // Test for method java.net.Socket(java.net.InetAddress, int,
         // java.net.InetAddress, int)
         int sport = startServer("Cons InetAddress,I,InetAddress,I");
-        int portNumber = Support_PortManager.getNextPort();
         s = new Socket(InetAddress.getLocalHost().getHostName(), sport,
-                InetAddress.getLocalHost(), portNumber);
-        assertTrue("Failed to create socket", s.getLocalPort() == portNumber);
+                InetAddress.getLocalHost(), 0);
     }
 
     public void test_ConstructorLjava_net_InetAddressIZ() throws IOException {
@@ -180,8 +175,7 @@ public class OldSocketTest extends OldSocketTestCase {
     public void test_close() throws IOException {
         // Test for method void java.net.Socket.close()
         int sport = startServer("SServer close");
-        int portNumber = Support_PortManager.getNextPort();
-        s = new Socket(InetAddress.getLocalHost(), sport, null, portNumber);
+        s = new Socket(InetAddress.getLocalHost(), sport, null, 0);
         try {
             s.setSoLinger(false, 100);
         } catch (IOException e) {
@@ -199,8 +193,7 @@ public class OldSocketTest extends OldSocketTestCase {
     public void test_getInetAddress() throws IOException {
         // Test for method java.net.InetAddress java.net.Socket.getInetAddress()
         int sport = startServer("SServer getInetAddress");
-        int portNumber = Support_PortManager.getNextPort();
-        s = new Socket(InetAddress.getLocalHost(), sport, null, portNumber);
+        s = new Socket(InetAddress.getLocalHost(), sport, null, 0);
         assertTrue("Returned incorrect InetAddress", s.getInetAddress().equals(
                 InetAddress.getLocalHost()));
 
@@ -220,9 +213,7 @@ public class OldSocketTest extends OldSocketTestCase {
     public void test_getKeepAlive() {
         try {
             int sport = startServer("SServer getKeepAlive");
-            int portNumber = Support_PortManager.getNextPort();
-            Socket theSocket = new Socket(InetAddress.getLocalHost(), sport,
-                    null, portNumber);
+            Socket theSocket = new Socket(InetAddress.getLocalHost(), sport, null, 0);
             theSocket.setKeepAlive(true);
             assertTrue("getKeepAlive false when it should be true", theSocket
                     .getKeepAlive());
@@ -254,8 +245,7 @@ public class OldSocketTest extends OldSocketTestCase {
         // Test for method java.net.InetAddress
         // java.net.Socket.getLocalAddress()
         int sport = startServer("SServer getLocAddress");
-        int portNumber = Support_PortManager.getNextPort();
-        s = new Socket(InetAddress.getLocalHost(), sport, null, portNumber);
+        s = new Socket(InetAddress.getLocalHost(), sport, null, 0);
         assertEquals("Returned incorrect InetAddress",
                 InetAddress.getLocalHost(), s.getLocalAddress());
 
@@ -271,10 +261,10 @@ public class OldSocketTest extends OldSocketTestCase {
     public void test_getLocalPort() throws IOException {
         // Test for method int java.net.Socket.getLocalPort()
         int sport = startServer("SServer getLocalPort");
-        int portNumber = Support_PortManager.getNextPort();
         s = new Socket(InetAddress.getLocalHost().getHostName(), sport,
-                InetAddress.getLocalHost(), portNumber);
-        assertTrue("Returned incorrect port", s.getLocalPort() == portNumber);
+                InetAddress.getLocalHost(), 0);
+        // There's nothing we can usefully assert about the kernel-assigned port.
+        s.getLocalPort();
     }
 
     @SuppressWarnings("deprecation")
@@ -282,15 +272,13 @@ public class OldSocketTest extends OldSocketTestCase {
         // Test for method java.io.OutputStream
         // java.net.Socket.getOutputStream()
         int sport = startServer("SServer getOutputStream");
-        int portNumber = Support_PortManager.getNextPort();
-        s = new Socket(InetAddress.getLocalHost(), sport, null, portNumber);
+        s = new Socket(InetAddress.getLocalHost(), sport);
         java.io.OutputStream os = s.getOutputStream();
         assertNotNull("Failed to get stream", os);
         os.write(1);
         s.close();
         // Regression test for harmony-2934
-        s = new Socket("127.0.0.1", Support_PortManager.getNextPort(),
-                false);
+        s = new Socket("127.0.0.1", sport, false);
         OutputStream o = s.getOutputStream();
         o.write(1);
         try {
@@ -301,8 +289,7 @@ public class OldSocketTest extends OldSocketTestCase {
         s.close();
 
         // Regression test for harmony-2942
-        s = new Socket("0.0.0.0", Support_PortManager.getNextPort(),
-                false);
+        s = new Socket("0.0.0.0", sport, false);
         o = s.getOutputStream();
         o.write(1);
         try {
@@ -316,18 +303,15 @@ public class OldSocketTest extends OldSocketTestCase {
     public void test_getPort() throws IOException {
         // Test for method int java.net.Socket.getPort()
         int sport = startServer("SServer getPort");
-        int portNumber = Support_PortManager.getNextPort();
-        s = new Socket(InetAddress.getLocalHost(), sport, null, portNumber);
-        assertTrue("Returned incorrect port" + s.getPort(),
-                s.getPort() == sport);
+        s = new Socket(InetAddress.getLocalHost(), sport, null, 0);
+        assertTrue("Returned incorrect port" + s.getPort(), s.getPort() == sport);
     }
 
     public void test_getSoLinger() {
         // Test for method int java.net.Socket.getSoLinger()
         int sport = startServer("SServer getSoLinger");
         try {
-            int portNumber = Support_PortManager.getNextPort();
-            s = new Socket(InetAddress.getLocalHost(), sport, null, portNumber);
+            s = new Socket(InetAddress.getLocalHost(), sport, null, 0);
             s.setSoLinger(true, 200);
             assertEquals("Returned incorrect linger", 200, s.getSoLinger());
             ensureExceptionThrownIfOptionIsUnsupportedOnOS(SO_LINGER);
@@ -337,8 +321,7 @@ public class OldSocketTest extends OldSocketTestCase {
         }
 
         try {
-            int portNumber = Support_PortManager.getNextPort();
-            s = new Socket(InetAddress.getLocalHost(), sport, null, portNumber);
+            s = new Socket(InetAddress.getLocalHost(), sport, null, 0);
             s.close();
             try {
                 s.getSoLinger();
@@ -354,9 +337,7 @@ public class OldSocketTest extends OldSocketTestCase {
     public void test_getReceiveBufferSize() {
         try {
             int sport = startServer("SServer getReceiveBufferSize");
-            int portNumber = Support_PortManager.getNextPort();
-            s = new Socket(InetAddress.getLocalHost().getHostName(), sport,
-                    null, portNumber);
+            s = new Socket(InetAddress.getLocalHost().getHostName(), sport, null, 0);
             s.setReceiveBufferSize(130);
             assertTrue("Incorrect buffer size", s.getReceiveBufferSize() >= 130);
             ensureExceptionThrownIfOptionIsUnsupportedOnOS(SO_RCVBUF);
@@ -381,9 +362,7 @@ public class OldSocketTest extends OldSocketTestCase {
     public void test_getSendBufferSize() {
         int sport = startServer("SServer setSendBufferSize");
         try {
-            int portNumber = Support_PortManager.getNextPort();
-            s = new Socket(InetAddress.getLocalHost().getHostName(), sport,
-                    null, portNumber);
+            s = new Socket(InetAddress.getLocalHost().getHostName(), sport, null, 0);
             s.setSendBufferSize(134);
             assertTrue("Incorrect buffer size", s.getSendBufferSize() >= 134);
             ensureExceptionThrownIfOptionIsUnsupportedOnOS(SO_SNDBUF);
@@ -391,8 +370,7 @@ public class OldSocketTest extends OldSocketTestCase {
             handleException(e, SO_SNDBUF);
         }
         try {
-            int portNumber = Support_PortManager.getNextPort();
-            s = new Socket(InetAddress.getLocalHost(), sport, null, portNumber);
+            s = new Socket(InetAddress.getLocalHost(), sport, null, 0);
             s.close();
             try {
                 s.getSendBufferSize();
@@ -430,8 +408,7 @@ public class OldSocketTest extends OldSocketTestCase {
         // Test for method boolean java.net.Socket.getTcpNoDelay()
         int sport = startServer("SServer getTcpNoDelay");
         try {
-            int portNumber = Support_PortManager.getNextPort();
-            s = new Socket(InetAddress.getLocalHost(), sport, null, portNumber);
+            s = new Socket(InetAddress.getLocalHost(), sport, null, 0);
             boolean bool = !s.getTcpNoDelay();
             s.setTcpNoDelay(bool);
             assertTrue("Failed to get no delay setting: " + s.getTcpNoDelay(),
@@ -442,8 +419,7 @@ public class OldSocketTest extends OldSocketTestCase {
         }
 
         try {
-            int portNumber = Support_PortManager.getNextPort();
-            s = new Socket(InetAddress.getLocalHost(), sport, null, portNumber);
+            s = new Socket(InetAddress.getLocalHost(), sport, null, 0);
             s.close();
             try {
                 s.getTcpNoDelay();
@@ -461,9 +437,7 @@ public class OldSocketTest extends OldSocketTestCase {
         // crashed machines. Just make sure we can set it
         try {
             int sport = startServer("SServer setKeepAlive");
-            int portNumber = Support_PortManager.getNextPort();
-            Socket theSocket = new Socket(InetAddress.getLocalHost(), sport,
-                    null, portNumber);
+            Socket theSocket = new Socket(InetAddress.getLocalHost(), sport, null, 0);
             theSocket.setKeepAlive(true);
             theSocket.setKeepAlive(false);
             ensureExceptionThrownIfOptionIsUnsupportedOnOS(SO_KEEPALIVE);
@@ -509,8 +483,7 @@ public class OldSocketTest extends OldSocketTestCase {
     public void test_setSendBufferSizeI() {
         try {
             int sport = startServer("SServer setSendBufferSizeI");
-            int portNumber = Support_PortManager.getNextPort();
-            s = new Socket(InetAddress.getLocalHost(), sport, null, portNumber);
+            s = new Socket(InetAddress.getLocalHost(), sport, null, 0);
             s.setSendBufferSize(134);
             assertTrue("Incorrect buffer size", s.getSendBufferSize() >= 134);
             ensureExceptionThrownIfOptionIsUnsupportedOnOS(SO_SNDBUF);
@@ -533,8 +506,7 @@ public class OldSocketTest extends OldSocketTestCase {
     public void test_setReceiveBufferSizeI() {
         try {
             int sport = startServer("SServer setReceiveBufferSizeI");
-            int portNumber = Support_PortManager.getNextPort();
-            s = new Socket(InetAddress.getLocalHost(), sport, null, portNumber);
+            s = new Socket(InetAddress.getLocalHost(), sport, null, 0);
             s.setReceiveBufferSize(130);
             assertTrue("Incorrect buffer size", s.getReceiveBufferSize() >= 130);
             ensureExceptionThrownIfOptionIsUnsupportedOnOS(SO_RCVBUF);
@@ -558,8 +530,7 @@ public class OldSocketTest extends OldSocketTestCase {
         // Test for method void java.net.Socket.setSoLinger(boolean, int)
         try {
             int sport = startServer("SServer setSoLingerZI");
-            int portNumber = Support_PortManager.getNextPort();
-            s = new Socket(InetAddress.getLocalHost(), sport, null, portNumber);
+            s = new Socket(InetAddress.getLocalHost(), sport, null, 0);
             s.setSoLinger(true, 500);
             assertEquals("Set incorrect linger", 500, s.getSoLinger());
             ensureExceptionThrownIfOptionIsUnsupportedOnOS(SO_LINGER);
@@ -584,8 +555,7 @@ public class OldSocketTest extends OldSocketTestCase {
         // Test for method void java.net.Socket.setTcpNoDelay(boolean)
         try {
             int sport = startServer("SServer setTcpNoDelayZ");
-            int portNumber = Support_PortManager.getNextPort();
-            s = new Socket(InetAddress.getLocalHost(), sport, null, portNumber);
+            s = new Socket(InetAddress.getLocalHost(), sport, null, 0);
             boolean bool;
             s.setTcpNoDelay(bool = !s.getTcpNoDelay());
             assertTrue("Failed to set no delay setting: " + s.getTcpNoDelay(),
@@ -610,9 +580,8 @@ public class OldSocketTest extends OldSocketTestCase {
     public void test_toString() throws IOException {
         // Test for method java.lang.String java.net.Socket.toString()
         int sport = startServer("SServer toString");
-        int portNumber = Support_PortManager.getNextPort();
         s = new Socket(InetAddress.getLocalHost().getHostName(), sport,
-                InetAddress.getLocalHost(), portNumber);
+                InetAddress.getLocalHost(), 0);
         assertEquals("Socket[address=" + InetAddress.getLocalHost() + ",port=" + s.getPort()
                 + ",localPort=" + s.getLocalPort() + "]", s.toString());
     }
@@ -620,9 +589,8 @@ public class OldSocketTest extends OldSocketTestCase {
     // AndroidOnly: RI returns wrong value for EOF
     public void test_shutdownInput() throws Exception {
         InetAddress addr = InetAddress.getLocalHost();
-        int port = Support_PortManager.getNextPort();
-        ServerSocket serverSocket = new ServerSocket(port, 5, addr);
-        Socket theSocket = new Socket(addr, port);
+        ServerSocket serverSocket = new ServerSocket(0, 5, addr);
+        Socket theSocket = new Socket(addr, serverSocket.getLocalPort());
         Socket servSock = serverSocket.accept();
 
         InputStream theInput = theSocket.getInputStream();
@@ -656,10 +624,8 @@ public class OldSocketTest extends OldSocketTestCase {
     }
 
     public void test_shutdownOutput() throws IOException {
-        InetAddress addr = InetAddress.getLocalHost();
-        int port = Support_PortManager.getNextPort();
-        ServerSocket serverSocket = new ServerSocket(port, 5, addr);
-        Socket theSocket = new Socket(addr, port);
+        ServerSocket serverSocket = new ServerSocket(0, 5);
+        Socket theSocket = new Socket(serverSocket.getInetAddress(), serverSocket.getLocalPort());
         Socket servSock = serverSocket.accept();
 
         InputStream theInput = theSocket.getInputStream();
@@ -692,17 +658,9 @@ public class OldSocketTest extends OldSocketTestCase {
         // set up server connect and then validate that we get the right
         // response for the local address
         int sport = startServer("SServer getLocSocketAddress");
-        int portNumber = Support_PortManager.getNextPort();
-        s = new Socket(InetAddress.getLocalHost(), sport, null, portNumber);
-        assertTrue(
-                "Returned incorrect InetSocketAddress(1):"
-                        + s.getLocalSocketAddress().toString()
-                        + "Expected: "
-                        + (new InetSocketAddress(InetAddress.getLocalHost(),
-                                portNumber)).toString(), s
-                        .getLocalSocketAddress().equals(
-                                new InetSocketAddress(InetAddress
-                                        .getLocalHost(), portNumber)));
+        s = new Socket(InetAddress.getLocalHost(), sport, null, 0);
+        assertEquals(new InetSocketAddress(InetAddress.getLocalHost(), s.getLocalPort()),
+                     s.getLocalSocketAddress());
         s.close();
 
         // now create a socket that is not bound and validate we get the
@@ -713,21 +671,12 @@ public class OldSocketTest extends OldSocketTestCase {
                 theSocket.getLocalSocketAddress());
 
         // now bind the socket and make sure we get the right answer
-        portNumber = Support_PortManager.getNextPort();
-        theSocket.bind(new InetSocketAddress(InetAddress.getLocalHost(),
-                portNumber));
-        assertTrue(
-                "Returned incorrect InetSocketAddress(2):"
-                        + theSocket.getLocalSocketAddress().toString()
-                        + "Expected: "
-                        + (new InetSocketAddress(InetAddress.getLocalHost(),
-                                portNumber)).toString(), theSocket
-                        .getLocalSocketAddress().equals(
-                                new InetSocketAddress(InetAddress
-                                        .getLocalHost(), portNumber)));
+        theSocket.bind(new InetSocketAddress(InetAddress.getLocalHost(), 0));
+        assertEquals(new InetSocketAddress(InetAddress.getLocalHost(), theSocket.getLocalPort()),
+                     theSocket.getLocalSocketAddress());
         theSocket.close();
 
-        // now validate that behaviour when the any address is returned
+        // now validate that behavior when the any address is returned
         s = new Socket();
         s.bind(new InetSocketAddress(InetAddress.getByName("0.0.0.0"), 0));
 
@@ -747,8 +696,7 @@ public class OldSocketTest extends OldSocketTestCase {
         // set up server connect and then validate that we get the right
         // response for the remote address
         int sport = startServer("SServer getLocRemoteAddress");
-        int portNumber = Support_PortManager.getNextPort();
-        s = new Socket(InetAddress.getLocalHost(), sport, null, portNumber);
+        s = new Socket(InetAddress.getLocalHost(), sport, null, 0);
         assertTrue("Returned incorrect InetSocketAddress(1):"
                 + s.getLocalSocketAddress().toString(),
                 s.getRemoteSocketAddress()
@@ -760,9 +708,7 @@ public class OldSocketTest extends OldSocketTestCase {
         // now create one that is not connect and validate that we get the
         // right answer
         Socket theSocket = new Socket();
-        portNumber = Support_PortManager.getNextPort();
-        theSocket.bind(new InetSocketAddress(InetAddress.getLocalHost(),
-                portNumber));
+        theSocket.bind(new InetSocketAddress(InetAddress.getLocalHost(), 0));
 
         assertNull("Returned incorrect InetSocketAddress -unconnected socket:"
                 + "Expected: NULL", theSocket.getRemoteSocketAddress());
@@ -781,10 +727,8 @@ public class OldSocketTest extends OldSocketTestCase {
     }
 
     public void test_isBound() throws IOException {
-        InetAddress addr = InetAddress.getLocalHost();
-        int port = Support_PortManager.getNextPort();
-        ServerSocket serverSocket = new ServerSocket(port, 5, addr);
-        Socket theSocket = new Socket(addr, port);
+        ServerSocket serverSocket = new ServerSocket(0, 5);
+        Socket theSocket = new Socket(serverSocket.getInetAddress(), serverSocket.getLocalPort());
         Socket servSock = serverSocket.accept();
         assertTrue("Socket indicated  not bound when it should be (1)",
                 theSocket.isBound());
@@ -793,14 +737,11 @@ public class OldSocketTest extends OldSocketTestCase {
 
         // now do it with the new constructors and revalidate. Connect causes
         // the socket to be bound
-        InetSocketAddress theAddress = new InetSocketAddress(InetAddress
-                .getLocalHost(), Support_PortManager.getNextPort());
         theSocket = new Socket();
         assertFalse("Socket indicated bound when it was not (2)", theSocket
                 .isBound());
-        serverSocket = new ServerSocket();
-        serverSocket.bind(theAddress);
-        theSocket.connect(theAddress);
+        serverSocket = new ServerSocket(0, 5);
+        theSocket.connect(serverSocket.getLocalSocketAddress());
         servSock = serverSocket.accept();
         assertTrue("Socket indicated not bound when it should be (2)",
                 theSocket.isBound());
@@ -808,12 +749,10 @@ public class OldSocketTest extends OldSocketTestCase {
         serverSocket.close();
 
         // now test when we bind explicitly
-        InetSocketAddress theLocalAddress = new InetSocketAddress(InetAddress
-                .getLocalHost(), Support_PortManager.getNextPort());
         theSocket = new Socket();
         assertFalse("Socket indicated bound when it was not (3)", theSocket
                 .isBound());
-        theSocket.bind(theLocalAddress);
+        theSocket.bind(null);
         assertTrue("Socket indicated not bound when it should be (3a)",
                 theSocket.isBound());
         theSocket.close();
@@ -822,10 +761,8 @@ public class OldSocketTest extends OldSocketTestCase {
     }
 
     public void test_isConnected() throws IOException {
-        InetAddress addr = InetAddress.getLocalHost();
-        int port = Support_PortManager.getNextPort();
-        ServerSocket serverSocket = new ServerSocket(port, 5, addr);
-        Socket theSocket = new Socket(addr, port);
+        ServerSocket serverSocket = new ServerSocket(0, 5);
+        Socket theSocket = new Socket(serverSocket.getInetAddress(), serverSocket.getLocalPort());
         Socket servSock = serverSocket.accept();
         assertTrue("Socket indicated  not connected when it should be",
                 theSocket.isConnected());
@@ -833,14 +770,11 @@ public class OldSocketTest extends OldSocketTestCase {
         serverSocket.close();
 
         // now do it with the new constructors and revalidate
-        InetSocketAddress theAddress = new InetSocketAddress(InetAddress
-                .getLocalHost(), Support_PortManager.getNextPort());
         theSocket = new Socket();
         assertFalse("Socket indicated connected when it was not", theSocket
                 .isConnected());
-        serverSocket = new ServerSocket();
-        serverSocket.bind(theAddress);
-        theSocket.connect(theAddress);
+        serverSocket = new ServerSocket(0, 5);
+        theSocket.connect(serverSocket.getLocalSocketAddress());
         servSock = serverSocket.accept();
         assertTrue("Socket indicated  not connected when it should be",
                 theSocket.isConnected());
@@ -849,10 +783,8 @@ public class OldSocketTest extends OldSocketTestCase {
     }
 
     public void test_isClosed() throws IOException {
-        InetAddress addr = InetAddress.getLocalHost();
-        int port = Support_PortManager.getNextPort();
-        ServerSocket serverSocket = new ServerSocket(port, 5, addr);
-        Socket theSocket = new Socket(addr, port);
+        ServerSocket serverSocket = new ServerSocket(0, 5);
+        Socket theSocket = new Socket(serverSocket.getInetAddress(), serverSocket.getLocalPort());
         Socket servSock = serverSocket.accept();
 
         // validate isClosed returns expected values
@@ -862,7 +794,7 @@ public class OldSocketTest extends OldSocketTestCase {
         assertTrue("Socket should indicate it is closed(1):", theSocket
                 .isClosed());
 
-        theSocket = new Socket(addr, port);
+        theSocket = new Socket(serverSocket.getInetAddress(), serverSocket.getLocalPort());
         assertFalse("Socket should indicate it is not closed(2):", theSocket
                 .isClosed());
         theSocket.close();
@@ -891,7 +823,7 @@ public class OldSocketTest extends OldSocketTestCase {
         try {
             theSocket.bind(new InetSocketAddress(InetAddress
                     .getByAddress(Support_Configuration.nonLocalAddressBytes),
-                    Support_PortManager.getNextPort()));
+                    80));
             fail("No exception when binding to bad address:"
                    + theSocket.getLocalSocketAddress().toString());
         } catch (IOException ex) {
@@ -900,39 +832,21 @@ public class OldSocketTest extends OldSocketTestCase {
 
         // now create a socket that is not bound and then bind it
         theSocket = new Socket();
-        int portNumber = Support_PortManager.getNextPort();
         theSocket.bind(new InetSocketAddress(InetAddress.getLocalHost(),
-                portNumber));
+                0));
 
         // validate that the localSocketAddress reflects the address we
         // bound to
-        assertTrue(
-                "Local address not correct after bind:"
-                        + theSocket.getLocalSocketAddress().toString()
-                        + " Expected: "
-                        + (new InetSocketAddress(InetAddress.getLocalHost(),
-                                portNumber)).toString(), theSocket
-                        .getLocalSocketAddress().equals(
-                                new InetSocketAddress(InetAddress
-                                        .getLocalHost(), portNumber)));
+        assertEquals(new InetSocketAddress(InetAddress.getLocalHost(), theSocket.getLocalPort()),
+                     theSocket.getLocalSocketAddress());
 
         // make sure we can now connect and that connections appear to come
         // from the address we bound to.
-        InetSocketAddress theAddress = new InetSocketAddress(InetAddress
-                .getLocalHost(), Support_PortManager.getNextPort());
-        ServerSocket serverSocket = new ServerSocket();
-        serverSocket.bind(theAddress);
-        theSocket.connect(theAddress);
+        ServerSocket serverSocket = new ServerSocket(0, 5);
+        theSocket.connect(serverSocket.getLocalSocketAddress());
         Socket servSock = serverSocket.accept();
-        assertTrue(
-                "Returned Remote address from server connected to does not match expected local address:"
-                        + servSock.getRemoteSocketAddress().toString()
-                        + " Expected: "
-                        + (new InetSocketAddress(InetAddress.getLocalHost(),
-                                portNumber)).toString(), servSock
-                        .getRemoteSocketAddress().equals(
-                                new InetSocketAddress(InetAddress
-                                        .getLocalHost(), portNumber)));
+        assertEquals(new InetSocketAddress(InetAddress.getLocalHost(), theSocket.getLocalPort()),
+                     servSock.getRemoteSocketAddress());
         theSocket.close();
         servSock.close();
         serverSocket.close();
@@ -951,10 +865,8 @@ public class OldSocketTest extends OldSocketTestCase {
         theSocket = new Socket();
         Socket theSocket2 = new Socket();
         try {
-            theAddress = new InetSocketAddress(InetAddress.getLocalHost(),
-                    Support_PortManager.getNextPort());
-            theSocket.bind(theAddress);
-            theSocket2.bind(theAddress);
+            theSocket.bind(null);
+            theSocket2.bind(theSocket.getLocalSocketAddress());
             fail("No exception binding to address that is not available");
         } catch (IOException ex) {
         }
@@ -1020,7 +932,7 @@ public class OldSocketTest extends OldSocketTestCase {
         }
 
         // start by validating the error checks
-        int portNumber = Support_PortManager.getNextPort();
+        int portNumber = 0;
         Socket theSocket = null;
         ServerSocket serverSocket = null;
         SocketAddress theAddress = null;
@@ -1084,17 +996,8 @@ public class OldSocketTest extends OldSocketTestCase {
 
         // now validate that we can actually connect when somebody is listening
         theSocket = new Socket();
-        serverSocket = new ServerSocket();
-        serverSocket.bind(theAddress);
-        theSocket.connect(theAddress);
-        theSocket.close();
-        serverSocket.close();
-
-        // now validate that we can actually connect when somebody is listening
-        theSocket = new Socket();
-        serverSocket = new ServerSocket();
-        serverSocket.bind(theAddress);
-        theSocket.connect(theAddress);
+        serverSocket = new ServerSocket(0, 5);
+        theSocket.connect(serverSocket.getLocalSocketAddress());
 
         // validate that when a socket is connected that it answers
         // correctly to related queries
@@ -1119,10 +1022,9 @@ public class OldSocketTest extends OldSocketTestCase {
         // are already connected
         try {
             theSocket = new Socket();
-            serverSocket = new ServerSocket();
-            serverSocket.bind(theAddress);
-            theSocket.connect(theAddress);
-            theSocket.connect(theAddress);
+            serverSocket = new ServerSocket(0, 5);
+            theSocket.connect(serverSocket.getLocalSocketAddress());
+            theSocket.connect(serverSocket.getLocalSocketAddress());
             theSocket.close();
             serverSocket.close();
             fail("No exception when we try to connect on a connected socket: ");
@@ -1145,9 +1047,8 @@ public class OldSocketTest extends OldSocketTestCase {
 
         // now validate that connected socket can be used to read/write
         theSocket = new Socket();
-        serverSocket = new ServerSocket();
-        serverSocket.bind(theAddress);
-        theSocket.connect(theAddress);
+        serverSocket = new ServerSocket(0, 5);
+        theSocket.connect(serverSocket.getLocalSocketAddress());
         Socket servSock = serverSocket.accept();
         InputStream theInput = theSocket.getInputStream();
         OutputStream theOutput = servSock.getOutputStream();
@@ -1197,10 +1098,8 @@ public class OldSocketTest extends OldSocketTestCase {
         SocketChannel channel = SocketChannel.open();
         channel.configureBlocking(false);
         Socket socket = channel.socket();
-        int port = Support_PortManager.getNextPort();
         try {
-            socket.connect( new InetSocketAddress(InetAddress.getLocalHost(),
-                    Support_PortManager.getNextPort()));
+            socket.connect(serverSocket.getLocalSocketAddress());
             fail("IllegalBlockingModeException was not thrown.");
         } catch (IllegalBlockingModeException expected) {
         }
@@ -1263,28 +1162,14 @@ public class OldSocketTest extends OldSocketTestCase {
         }
 
         // start by validating the error checks
-        int portNumber = Support_PortManager.getNextPort();
-        Socket theSocket = null;
-        ServerSocket serverSocket = null;
-        SocketAddress theAddress = null;
-        SocketAddress nonConnectableAddress = null;
-        SocketAddress nonReachableAddress = null;
-        SocketAddress nonListeningAddress = null;
-        SocketAddress invalidType = null;
         byte[] theBytes = { 0, 0, 0, 0 };
+        SocketAddress theAddress = new InetSocketAddress(InetAddress.getLocalHost(), 0);
+        SocketAddress nonConnectableAddress = new InetSocketAddress(InetAddress.getByAddress(theBytes), 0);
+        SocketAddress nonReachableAddress = new InetSocketAddress(InetAddress.getByName(Support_Configuration.ResolvedNotExistingHost), 0);
+        SocketAddress invalidType = new mySocketAddress();
 
-        theAddress = new InetSocketAddress(InetAddress.getLocalHost(),
-                portNumber);
-        nonConnectableAddress = new InetSocketAddress(InetAddress
-                .getByAddress(theBytes), portNumber);
-        nonReachableAddress = new InetSocketAddress(InetAddress
-                .getByName(Support_Configuration.ResolvedNotExistingHost),
-                portNumber);
-        // make sure we get another port
-        Thread.sleep(7000);
-        nonListeningAddress = new InetSocketAddress(InetAddress.getLocalHost(),
-                Support_PortManager.getNextPort());
-        invalidType = new mySocketAddress();
+        Socket theSocket = null;
+        ServerSocket serverSocket = null;
 
         try {
             theSocket = new Socket();
@@ -1340,9 +1225,8 @@ public class OldSocketTest extends OldSocketTestCase {
 
         // now validate that we can actually connect when somebody is listening
         theSocket = new Socket();
-        serverSocket = new ServerSocket();
-        serverSocket.bind(theAddress);
-        theSocket.connect(theAddress, 0);
+        serverSocket = new ServerSocket(0, 5);
+        theSocket.connect(serverSocket.getLocalSocketAddress());
         theSocket.close();
         serverSocket.close();
 
@@ -1350,7 +1234,7 @@ public class OldSocketTest extends OldSocketTestCase {
         // an address on which nobody is listening
         try {
             theSocket = new Socket();
-            theSocket.connect(nonListeningAddress, 100000);
+            theSocket.connect(new InetSocketAddress(InetAddress.getLocalHost(), 80), 100000);
             theSocket.close();
             fail("No exception when connecting to address nobody listening on: ");
         } catch (Exception e) {
@@ -1390,12 +1274,9 @@ public class OldSocketTest extends OldSocketTestCase {
         }
 
         // now validate that we can actually connect when somebody is listening
-        new InetSocketAddress(InetAddress.getLocalHost(), Support_PortManager
-                .getNextPort());
         theSocket = new Socket();
-        serverSocket = new ServerSocket();
-        serverSocket.bind(theAddress);
-        theSocket.connect(theAddress, 100000);
+        serverSocket = new ServerSocket(0, 5);
+        theSocket.connect(serverSocket.getLocalSocketAddress());
 
         // validate that when a socket is connected that it answers
         // correctly to related queries
@@ -1419,8 +1300,6 @@ public class OldSocketTest extends OldSocketTestCase {
         // now validate that we get the right exception if we connect when we
         // are already connected
         try {
-            new InetSocketAddress(InetAddress.getLocalHost(),
-                    Support_PortManager.getNextPort());
             theSocket = new Socket();
             serverSocket = new ServerSocket();
             serverSocket.bind(theAddress);
@@ -1447,12 +1326,9 @@ public class OldSocketTest extends OldSocketTestCase {
         }
 
         // now validate that connected socket can be used to read/write
-        new InetSocketAddress(InetAddress.getLocalHost(), Support_PortManager
-                .getNextPort());
         theSocket = new Socket();
-        serverSocket = new ServerSocket();
-        serverSocket.bind(theAddress);
-        theSocket.connect(theAddress, 100000);
+        serverSocket = new ServerSocket(0, 5);
+        theSocket.connect(serverSocket.getLocalSocketAddress());
         Socket servSock = serverSocket.accept();
         InputStream theInput = theSocket.getInputStream();
         OutputStream theOutput = servSock.getOutputStream();
@@ -1515,10 +1391,8 @@ public class OldSocketTest extends OldSocketTestCase {
         SocketChannel channel = SocketChannel.open();
         channel.configureBlocking(false);
         Socket socket = channel.socket();
-        int port = Support_PortManager.getNextPort();
         try {
-            socket.connect( new InetSocketAddress(InetAddress.getLocalHost(),
-                    Support_PortManager.getNextPort()), port);
+            socket.connect(serverSocket.getLocalSocketAddress());
             fail("IllegalBlockingModeException was not thrown.");
         } catch (IllegalBlockingModeException expected) {
         }
@@ -1526,12 +1400,9 @@ public class OldSocketTest extends OldSocketTestCase {
     }
 
     public void test_isInputShutdown() throws IOException {
-        InetSocketAddress theAddress = new InetSocketAddress(InetAddress
-                .getLocalHost(), Support_PortManager.getNextPort());
         Socket theSocket = new Socket();
-        ServerSocket serverSocket = new ServerSocket();
-        serverSocket.bind(theAddress);
-        theSocket.connect(theAddress);
+        ServerSocket serverSocket = new ServerSocket(0, 5);
+        theSocket.connect(serverSocket.getLocalSocketAddress());
         Socket servSock = serverSocket.accept();
         InputStream theInput = theSocket.getInputStream();
         OutputStream theOutput = servSock.getOutputStream();
@@ -1559,12 +1430,9 @@ public class OldSocketTest extends OldSocketTestCase {
     }
 
     public void test_isOutputShutdown() throws IOException {
-        InetSocketAddress theAddress = new InetSocketAddress(InetAddress
-                .getLocalHost(), Support_PortManager.getNextPort());
         Socket theSocket = new Socket();
-        ServerSocket serverSocket = new ServerSocket();
-        serverSocket.bind(theAddress);
-        theSocket.connect(theAddress);
+        ServerSocket serverSocket = new ServerSocket(0, 5);
+        theSocket.connect(serverSocket.getLocalSocketAddress());
         Socket servSock = serverSocket.accept();
         InputStream theInput = theSocket.getInputStream();
         OutputStream theOutput = servSock.getOutputStream();
@@ -1591,18 +1459,14 @@ public class OldSocketTest extends OldSocketTestCase {
 
     }
 
-    public void test_setReuseAddressZ() {
+    public void test_setReuseAddressZ() throws Exception {
 
         try {
             InetAddress allAddresses[] = InetAddress.getAllByName(InetAddress
                     .getLocalHost().getHostName());
             if (allAddresses.length > 1) {
 
-                InetSocketAddress theAddress = new InetSocketAddress(
-                        InetAddress.getLocalHost(), Support_PortManager
-                                .getNextPort());
-                ServerSocket serverSocket = new ServerSocket();
-                serverSocket.bind(theAddress);
+                ServerSocket serverSocket = new ServerSocket(0, 5);
 
                 // try to bind to port address that is already in use with
                 // reuseAddress = false.
@@ -1612,17 +1476,15 @@ public class OldSocketTest extends OldSocketTestCase {
                 // what the expected result is. It seems that on linux
                 // platforms we also don't get an exception.
                 InetSocketAddress theLocalAddress = new InetSocketAddress(
-                        (InetAddress) allAddresses[1], Support_PortManager
-                                .getNextPort());
+                        (InetAddress) allAddresses[1], 0);
                 InetSocketAddress theOtherLocalAddress = new InetSocketAddress(
-                        (InetAddress) allAddresses[0], theLocalAddress
-                                .getPort());
+                        (InetAddress) allAddresses[0], theLocalAddress.getPort());
                 Socket theSocket = new Socket();
                 theSocket.setReuseAddress(false);
                 theSocket.bind(theLocalAddress);
                 Socket theSocket2 = null;
                 String platform = System.getProperty("os.name");
-                try {
+
                     theSocket2 = new Socket();
                     theSocket2.setReuseAddress(false);
                     theSocket2.bind(theOtherLocalAddress);
@@ -1639,69 +1501,34 @@ public class OldSocketTest extends OldSocketTestCase {
                                 + ":"
                                 + theOtherLocalAddress.toString());
                     }
-                } catch (IOException ex) {
-                    if ((platform.startsWith("Linux"))
-                            || ((platform.startsWith("Windows")) && ((((InetAddress) allAddresses[0]) instanceof Inet4Address) && (((InetAddress) allAddresses[1]) instanceof Inet4Address)))) {
-                        fail("Got unexpected exception when binding with setReuseAddress false on windows platform:"
-                                + theAddress.toString() + ":" + ex.toString());
-                    }
-                }
                 theSocket.close();
                 theSocket2.close();
 
                 // try to bind to port that is already in use with reuseAddress
                 // = true
-                theLocalAddress = new InetSocketAddress(
-                        (InetAddress) allAddresses[0], Support_PortManager
-                                .getNextPort());
-                theOtherLocalAddress = new InetSocketAddress(
-                        (InetAddress) allAddresses[1], theLocalAddress
-                                .getPort());
+                theLocalAddress = new InetSocketAddress((InetAddress) allAddresses[0], 0);
 
                 theSocket = new Socket();
                 theSocket.setReuseAddress(true);
                 theSocket.bind(theLocalAddress);
-                try {
-                    theSocket2 = new Socket();
-                    theSocket2.setReuseAddress(true);
-                    theSocket2.bind(theOtherLocalAddress);
-                    theSocket2.close();
-                } catch (IOException ex) {
-                    fail("IOException when setReuseAddress is true and we bind :"
-                            + ex.toString());
-                }
+                theSocket2 = new Socket();
+                theSocket2.setReuseAddress(true);
+                theOtherLocalAddress = new InetSocketAddress((InetAddress) allAddresses[1], theSocket.getLocalPort());
+                theSocket2.bind(theOtherLocalAddress);
+                theSocket2.close();
                 theSocket.close();
                 serverSocket.close();
 
                 // try with default behavior which should be the same on all
                 // platforms
-                theLocalAddress = new InetSocketAddress(
-                        (InetAddress) allAddresses[0], Support_PortManager
-                                .getNextPort());
-                theOtherLocalAddress = new InetSocketAddress(
-                        (InetAddress) allAddresses[1], theLocalAddress
-                                .getPort());
+                theLocalAddress = new InetSocketAddress((InetAddress) allAddresses[0], 0);
 
                 theSocket = new Socket();
                 theSocket.bind(theLocalAddress);
-                try {
-                    theSocket2 = new Socket();
-                    theSocket2.bind(theOtherLocalAddress);
-                    theSocket2.close();
-                    if ((!platform.startsWith("Linux"))
-                            && ((!platform.startsWith("Windows")) || !((((InetAddress) allAddresses[0]) instanceof Inet4Address) && (((InetAddress) allAddresses[1]) instanceof Inet4Address)))) {
-                        fail("No exception when setReuseAddress is default and we bind:"
-                                + theLocalAddress.toString()
-                                + ":"
-                                + theOtherLocalAddress.toString());
-                    }
-                } catch (IOException ex) {
-                    if ((platform.startsWith("Linux"))
-                            || ((platform.startsWith("Windows")) && ((((InetAddress) allAddresses[0]) instanceof Inet4Address) && (((InetAddress) allAddresses[1]) instanceof Inet4Address)))) {
-                        fail("Got unexpected exception when binding with setReuseAddress default on windows platform:"
-                                + theAddress.toString() + ":" + ex.toString());
-                    }
-                }
+                theSocket2 = new Socket();
+                theOtherLocalAddress = new InetSocketAddress((InetAddress) allAddresses[1], theSocket.getLocalPort());
+                theSocket2.bind(theOtherLocalAddress);
+                theSocket2.close();
                 theSocket.close();
                 serverSocket.close();
 
@@ -1754,8 +1581,6 @@ public class OldSocketTest extends OldSocketTestCase {
     public void test_setOOBInlineZ() {
         // mostly tested in getOOBInline. Just set to make sure call works ok
         try {
-            new InetSocketAddress(InetAddress.getLocalHost(),
-                    Support_PortManager.getNextPort());
             Socket theSocket = new Socket();
             theSocket.setOOBInline(true);
             assertTrue("expected OOBIline to be true", theSocket.getOOBInline());
@@ -1779,8 +1604,6 @@ public class OldSocketTest extends OldSocketTestCase {
     public void test_getOOBInline() {
 
         try {
-            new InetSocketAddress(InetAddress.getLocalHost(),
-                    Support_PortManager.getNextPort());
             Socket theSocket = new Socket();
 
             // validate that value reflects what we set it to true after true,
@@ -1812,8 +1635,6 @@ public class OldSocketTest extends OldSocketTestCase {
             int IPTOS_LOWCOST = 0x2;
             int IPTOS_THROUGHPUT = 0x8;
 
-            new InetSocketAddress(InetAddress.getLocalHost(),
-                    Support_PortManager.getNextPort());
             Socket theSocket = new Socket();
 
             // validate that value set must be between 0 and 255
@@ -1851,8 +1672,6 @@ public class OldSocketTest extends OldSocketTestCase {
 
     public void test_getTrafficClass() {
         try {
-            new InetSocketAddress(InetAddress.getLocalHost(),
-                    Support_PortManager.getNextPort());
             Socket theSocket = new Socket();
 
             /*
@@ -1888,13 +1707,9 @@ public class OldSocketTest extends OldSocketTestCase {
             // is silently ignored
             String urgentData = "U";
             try {
-                InetSocketAddress theAddress = new InetSocketAddress(
-                        InetAddress.getLocalHost(), Support_PortManager
-                                .getNextPort());
                 Socket theSocket = new Socket();
-                ServerSocket serverSocket = new ServerSocket();
-                serverSocket.bind(theAddress);
-                theSocket.connect(theAddress);
+                ServerSocket serverSocket = new ServerSocket(0, 5);
+                theSocket.connect(serverSocket.getLocalSocketAddress());
                 Socket servSock = serverSocket.accept();
                 InputStream theInput = theSocket.getInputStream();
                 OutputStream theOutput = servSock.getOutputStream();
@@ -1931,12 +1746,9 @@ public class OldSocketTest extends OldSocketTestCase {
 
                 // now validate that urgent data is received as expected. Expect
                 // that it should be between the two writes.
-                theAddress = new InetSocketAddress(InetAddress.getLocalHost(),
-                        Support_PortManager.getNextPort());
                 theSocket = new Socket();
-                serverSocket = new ServerSocket();
-                serverSocket.bind(theAddress);
-                theSocket.connect(theAddress);
+                serverSocket = new ServerSocket(0, 5);
+                theSocket.connect(serverSocket.getLocalSocketAddress());
                 servSock = serverSocket.accept();
                 theInput = theSocket.getInputStream();
                 theOutput = servSock.getOutputStream();
@@ -1973,12 +1785,9 @@ public class OldSocketTest extends OldSocketTestCase {
                 serverSocket.close();
 
                 // now test case where we try to send two urgent bytes.
-                theAddress = new InetSocketAddress(InetAddress.getLocalHost(),
-                        Support_PortManager.getNextPort());
                 theSocket = new Socket();
-                serverSocket = new ServerSocket();
-                serverSocket.bind(theAddress);
-                theSocket.connect(theAddress);
+                serverSocket = new ServerSocket(0, 5);
+                theSocket.connect(serverSocket.getLocalSocketAddress());
                 servSock = serverSocket.accept();
                 theInput = theSocket.getInputStream();
                 theOutput = servSock.getOutputStream();
@@ -2022,12 +1831,9 @@ public class OldSocketTest extends OldSocketTestCase {
                  */
                 if (!platform.startsWith("Windows")) {
                     // now test the case were we send turn the OOBInline on/off
-                    theAddress = new InetSocketAddress(InetAddress
-                            .getLocalHost(), Support_PortManager.getNextPort());
                     theSocket = new Socket();
-                    serverSocket = new ServerSocket();
-                    serverSocket.bind(theAddress);
-                    theSocket.connect(theAddress);
+                    serverSocket = new ServerSocket(0, 5);
+                    theSocket.connect(serverSocket.getLocalSocketAddress());
                     servSock = serverSocket.accept();
                     theInput = theSocket.getInputStream();
                     theOutput = servSock.getOutputStream();
@@ -2139,12 +1945,9 @@ public class OldSocketTest extends OldSocketTestCase {
                 }
 
                 // now test the case where there is only urgent data
-                theAddress = new InetSocketAddress(InetAddress.getLocalHost(),
-                        Support_PortManager.getNextPort());
                 theSocket = new Socket();
-                serverSocket = new ServerSocket();
-                serverSocket.bind(theAddress);
-                theSocket.connect(theAddress);
+                serverSocket = new ServerSocket(0, 5);
+                theSocket.connect(serverSocket.getLocalSocketAddress());
                 servSock = serverSocket.accept();
                 theInput = theSocket.getInputStream();
                 theOutput = servSock.getOutputStream();
@@ -2370,13 +2173,9 @@ public class OldSocketTest extends OldSocketTestCase {
 
     }
 
-    /**
-     *
-     */
     protected int startServer(String name) {
-        int portNumber = Support_PortManager.getNextPort();
         try {
-            ss = new ServerSocket(portNumber, 5);
+            ss = new ServerSocket(0, 5);
         } catch (IOException e) {
             fail(name + ": " + e);
         }
-- 
cgit v1.1


From 243111f8533820ea8d27bde6317f88f610aa5867 Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Mon, 15 Oct 2012 18:28:05 -0700
Subject: Fix flakiness with InterruptedStreamTest DO NOT MERGE

Bug: 6951157
Change-Id: I4a23a90a4a54d71f9cc5f0c608a30000c8e1b033
---
 .../libcore/java/io/InterruptedStreamTest.java     | 50 ++++++++++++++++++----
 1 file changed, 41 insertions(+), 9 deletions(-)

diff --git a/luni/src/test/java/libcore/java/io/InterruptedStreamTest.java b/luni/src/test/java/libcore/java/io/InterruptedStreamTest.java
index e1f51bd..e46df5d 100755
--- a/luni/src/test/java/libcore/java/io/InterruptedStreamTest.java
+++ b/luni/src/test/java/libcore/java/io/InterruptedStreamTest.java
@@ -46,10 +46,16 @@ public final class InterruptedStreamTest extends TestCase {
 
     private Socket[] sockets;
 
+    @Override protected void setUp() throws Exception {
+        Thread.interrupted(); // clear interrupted bit
+        super.tearDown();
+    }
+
     @Override protected void tearDown() throws Exception {
         if (sockets != null) {
             sockets[0].close();
             sockets[1].close();
+            sockets = null;
         }
         Thread.interrupted(); // clear interrupted bit
         super.tearDown();
@@ -111,56 +117,66 @@ public final class InterruptedStreamTest extends TestCase {
     }
 
     private void testInterruptInputStream(final InputStream in) throws Exception {
-        interruptMeLater();
+        Thread thread = interruptMeLater();
         try {
             in.read();
             fail();
         } catch (InterruptedIOException expected) {
+        } finally {
+            waitForInterrupt(thread);
         }
     }
 
     private void testInterruptReader(final PipedReader reader) throws Exception {
-        interruptMeLater();
+        Thread thread = interruptMeLater();
         try {
             reader.read();
             fail();
         } catch (InterruptedIOException expected) {
+        } finally {
+            waitForInterrupt(thread);
         }
     }
 
     private void testInterruptReadableChannel(final ReadableByteChannel channel) throws Exception {
-        interruptMeLater();
+        Thread thread = interruptMeLater();
         try {
             channel.read(ByteBuffer.allocate(BUFFER_SIZE));
             fail();
         } catch (ClosedByInterruptException expected) {
+        } finally {
+            waitForInterrupt(thread);
         }
     }
 
     private void testInterruptOutputStream(final OutputStream out) throws Exception {
-        interruptMeLater();
+        Thread thread = interruptMeLater();
         try {
             // this will block when the receiving buffer fills up
             while (true) {
                 out.write(new byte[BUFFER_SIZE]);
             }
         } catch (InterruptedIOException expected) {
+        } finally {
+            waitForInterrupt(thread);
         }
     }
 
     private void testInterruptWriter(final PipedWriter writer) throws Exception {
-        interruptMeLater();
+        Thread thread = interruptMeLater();
         try {
             // this will block when the receiving buffer fills up
             while (true) {
                 writer.write(new char[BUFFER_SIZE]);
             }
         } catch (InterruptedIOException expected) {
+        } finally {
+            waitForInterrupt(thread);
         }
     }
 
     private void testInterruptWritableChannel(final WritableByteChannel channel) throws Exception {
-        interruptMeLater();
+        Thread thread = interruptMeLater();
         try {
             // this will block when the receiving buffer fills up
             while (true) {
@@ -168,12 +184,14 @@ public final class InterruptedStreamTest extends TestCase {
             }
         } catch (ClosedByInterruptException expected) {
         } catch (ClosedChannelException expected) {
+        } finally {
+            waitForInterrupt(thread);
         }
     }
 
-    private void interruptMeLater() throws Exception {
+    private Thread interruptMeLater() throws Exception {
         final Thread toInterrupt = Thread.currentThread();
-        new Thread(new Runnable () {
+        Thread thread = new Thread(new Runnable () {
             @Override public void run() {
                 try {
                     Thread.sleep(1000);
@@ -181,6 +199,20 @@ public final class InterruptedStreamTest extends TestCase {
                 }
                 toInterrupt.interrupt();
             }
-        }).start();
+        });
+        thread.start();
+        return thread;
+    }
+
+    private static void waitForInterrupt(Thread thread) throws Exception {
+        try {
+            thread.join();
+        } catch (InterruptedException ignore) {
+            // There is currently a race between Thread.interrupt in
+            // interruptMeLater and Thread.join here. Most of the time
+            // we won't get an InterruptedException, but occasionally
+            // we do, so for now ignore this exception.
+            // http://b/6951157
+        }
     }
 }
-- 
cgit v1.1


From 0e1afa1091f74a6228c01d8c7a8eebf001efdc57 Mon Sep 17 00:00:00 2001
From: Elliott Hughes <enh@google.com>
Date: Fri, 12 Oct 2012 15:35:50 -0700
Subject: Fix ConcurrentCloseTest flakiness.

We can't rely on consuming all the listen(2) backlog. For the tests we've
seen fail because they sometimes connect rather than time out, switch to
an unroutable address.

(cherry-pick of babccbf9e429c4c78aca24c205825ceaaf7d3f37.)

Bug: 6971145
Change-Id: Ibfa412ff1ad7da7e63842d0162cc67a706e2b27e
---
 expectations/knownfailures.txt                     |  9 ----
 .../java/libcore/java/net/ConcurrentCloseTest.java | 14 ++---
 .../java/libcore/java/net/URLConnectionTest.java   |  2 +-
 .../libcore/java/nio/channels/SelectorTest.java    |  3 +-
 support/src/test/java/tests/net/StuckServer.java   | 60 +++++++++++++---------
 5 files changed, 44 insertions(+), 44 deletions(-)

diff --git a/expectations/knownfailures.txt b/expectations/knownfailures.txt
index 972f1ef..5e24be3 100644
--- a/expectations/knownfailures.txt
+++ b/expectations/knownfailures.txt
@@ -194,15 +194,6 @@
   bug: 2400429
 },
 {
-  description: "Concurrent close tests fail on the device",
-  names: [
-    "libcore.java.net.ConcurrentCloseTest#test_connect",
-    "libcore.java.net.ConcurrentCloseTest#test_connect_nonBlocking"
-  ],
-  modes: [ "device" ],
-  bug: 3044772
-},
-{
   description: "HTTPS connections should not be pooled.",
   name: "libcore.java.net.URLConnectionTest#testConnectViaHttpsReusingConnectionsDifferentFactories",
   bug: 3042192
diff --git a/luni/src/test/java/libcore/java/net/ConcurrentCloseTest.java b/luni/src/test/java/libcore/java/net/ConcurrentCloseTest.java
index 6988f6f..99a479c2 100644
--- a/luni/src/test/java/libcore/java/net/ConcurrentCloseTest.java
+++ b/luni/src/test/java/libcore/java/net/ConcurrentCloseTest.java
@@ -50,11 +50,11 @@ public class ConcurrentCloseTest extends junit.framework.TestCase {
     }
 
     public void test_connect() throws Exception {
-        StuckServer ss = new StuckServer();
+        StuckServer ss = new StuckServer(false);
         Socket s = new Socket();
         new Killer(s).start();
         try {
-            System.err.println("connect " + s + " to " + ss.getLocalSocketAddress() + "...");
+            System.err.println("connect...");
             s.connect(ss.getLocalSocketAddress());
             fail("connect returned: " + s + "!");
         } catch (SocketException expected) {
@@ -65,11 +65,11 @@ public class ConcurrentCloseTest extends junit.framework.TestCase {
     }
 
     public void test_connect_timeout() throws Exception {
-        StuckServer ss = new StuckServer();
+        StuckServer ss = new StuckServer(false);
         Socket s = new Socket();
         new Killer(s).start();
         try {
-            System.err.println("connect (with timeout) " + s + " to " + ss.getLocalSocketAddress() + "...");
+            System.err.println("connect (with timeout)...");
             s.connect(ss.getLocalSocketAddress(), 3600 * 1000);
             fail("connect returned: " + s + "!");
         } catch (SocketException expected) {
@@ -80,11 +80,11 @@ public class ConcurrentCloseTest extends junit.framework.TestCase {
     }
 
     public void test_connect_nonBlocking() throws Exception {
-        StuckServer ss = new StuckServer();
+        StuckServer ss = new StuckServer(false);
         SocketChannel s = SocketChannel.open();
         new Killer(s.socket()).start();
         try {
-            System.err.println("connect (non-blocking) " + s + " to " + ss.getLocalSocketAddress() + "...");
+            System.err.println("connect (non-blocking)...");
             s.configureBlocking(false);
             s.connect(ss.getLocalSocketAddress());
             while (!s.finishConnect()) {
@@ -238,7 +238,7 @@ public class ConcurrentCloseTest extends junit.framework.TestCase {
             try {
                 System.err.println("sleep...");
                 Thread.sleep(2000);
-                System.err.println("close " + s + "...");
+                System.err.println("close...");
                 s.getClass().getMethod("close").invoke(s);
             } catch (Exception ex) {
                 ex.printStackTrace();
diff --git a/luni/src/test/java/libcore/java/net/URLConnectionTest.java b/luni/src/test/java/libcore/java/net/URLConnectionTest.java
index e40ba57..1f2ebf9 100644
--- a/luni/src/test/java/libcore/java/net/URLConnectionTest.java
+++ b/luni/src/test/java/libcore/java/net/URLConnectionTest.java
@@ -1645,7 +1645,7 @@ public final class URLConnectionTest extends TestCase {
      * addresses. This is typically one IPv4 address and one IPv6 address.
      */
     public void testConnectTimeouts() throws IOException {
-        StuckServer ss = new StuckServer();
+        StuckServer ss = new StuckServer(false);
         int serverPort = ss.getLocalPort();
         URLConnection urlConnection = new URL("http://localhost:" + serverPort).openConnection();
         int timeout = 1000;
diff --git a/luni/src/test/java/libcore/java/nio/channels/SelectorTest.java b/luni/src/test/java/libcore/java/nio/channels/SelectorTest.java
index f73b6d5..4fc70c4 100644
--- a/luni/src/test/java/libcore/java/nio/channels/SelectorTest.java
+++ b/luni/src/test/java/libcore/java/nio/channels/SelectorTest.java
@@ -55,11 +55,10 @@ public class SelectorTest extends TestCase {
     public void testNonBlockingConnect_slow() throws Exception {
         // Test the case where we have to wait for the connection.
         Selector selector = Selector.open();
-        StuckServer ss = new StuckServer();
+        StuckServer ss = new StuckServer(true);
         try {
             SocketChannel sc = SocketChannel.open();
             sc.configureBlocking(false);
-            ss.unblockAfterMs(2000);
             sc.connect(ss.getLocalSocketAddress());
             SelectionKey key = sc.register(selector, SelectionKey.OP_CONNECT);
             assertEquals(1, selector.select());
diff --git a/support/src/test/java/tests/net/StuckServer.java b/support/src/test/java/tests/net/StuckServer.java
index eababce..f7a3118 100644
--- a/support/src/test/java/tests/net/StuckServer.java
+++ b/support/src/test/java/tests/net/StuckServer.java
@@ -17,6 +17,7 @@
 package tests.net;
 
 import java.io.IOException;
+import java.net.InetAddress;
 import java.net.InetSocketAddress;
 import java.net.ServerSocket;
 import java.net.Socket;
@@ -26,48 +27,57 @@ import java.util.ArrayList;
  * A test ServerSocket that you can't connect to --- connects will time out.
  */
 public final class StuckServer {
+    private static final boolean DEBUG = false;
+
     private ServerSocket serverSocket;
+    private InetSocketAddress address;
     private ArrayList<Socket> clients = new ArrayList<Socket>();
 
-    public StuckServer() throws IOException {
+    public StuckServer(boolean useBacklog) throws IOException {
         // Set a backlog and use it up so that we can expect the
-        // connection to time out. According to Steven's
+        // connection to time out. According to Stevens
         // 4.5 "listen function", Linux adds 3 to the specified
         // backlog, so we need to connect 4 times before it will hang.
-        serverSocket = new ServerSocket(0, 1);
-        for (int i = 0; i < 4; i++) {
-            clients.add(new Socket(serverSocket.getInetAddress(), serverSocket.getLocalPort()));
-        }
-    }
-
-    public void unblockAfterMs(final int ms) {
-        Thread t = new Thread(new Runnable() {
-            @Override public void run() {
-                try {
-                    Thread.sleep(ms);
-                    for (Socket client : clients) {
-                        client.close();
-                    }
-                    clients.clear();
-                    clients.add(serverSocket.accept());
-                } catch (Exception ex) {
-                    ex.printStackTrace();
+        // The trouble with this is that it won't hang forever.
+        // After 10s or so, the kernel allows a couple more connections.
+        // This mode is ony useful if you actually want to continue eventually; we use it to
+        // test non-blocking connects, for example, where you want to test every part of the code.
+        if (useBacklog) {
+            this.serverSocket = new ServerSocket(0, 1);
+            this.address = (InetSocketAddress) serverSocket.getLocalSocketAddress();
+            if (DEBUG) {
+                System.err.println("StuckServer: " + serverSocket);
+            }
+            for (int i = 0; i < 4; ++i) {
+                Socket client = new Socket(serverSocket.getInetAddress(), serverSocket.getLocalPort());
+                clients.add(client);
+                if (DEBUG) {
+                    System.err.println("StuckServer client " + i + " - " + client);
                 }
             }
-        });
-        t.start();
+        } else {
+            // In general, though, you don't want to rely on listen(2) backlog. http://b/6971145.
+            // RFC 5737 implies this network will be unreachable. (There are two other networks
+            // to try if we have trouble with this one.)
+            // We've had trouble with 10.* in the past (because test labs running CTS often use
+            // net 10!) but hopefully this network will be better.
+            InetAddress testNet1 = InetAddress.getByAddress(new byte[] { (byte) 192, 0, 2, 0 });
+            this.address = new InetSocketAddress(testNet1, 80);
+        }
     }
 
     public InetSocketAddress getLocalSocketAddress() {
-        return (InetSocketAddress) serverSocket.getLocalSocketAddress();
+        return address;
     }
 
     public int getLocalPort() {
-        return serverSocket.getLocalPort();
+        return address.getPort();
     }
 
     public void close() throws IOException {
-        serverSocket.close();
+        if (serverSocket != null) {
+            serverSocket.close();
+        }
         for (Socket client : clients) {
             client.close();
         }
-- 
cgit v1.1


From 50e0be631dec4c97be6453a83bbed851def86d21 Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Thu, 18 Oct 2012 15:39:52 -0700
Subject: Wait for threads to finish in ThreadsTest before continuing

Bug: 7355008
Change-Id: Ifdedca5cf5c96c86f94a0deead61e1798d1a495f
---
 .../apache/harmony/kernel/dalvik/ThreadsTest.java  | 41 ++++++++++++----------
 1 file changed, 22 insertions(+), 19 deletions(-)

diff --git a/luni/src/test/java/tests/api/org/apache/harmony/kernel/dalvik/ThreadsTest.java b/luni/src/test/java/tests/api/org/apache/harmony/kernel/dalvik/ThreadsTest.java
index 9c9f346..5185885 100644
--- a/luni/src/test/java/tests/api/org/apache/harmony/kernel/dalvik/ThreadsTest.java
+++ b/luni/src/test/java/tests/api/org/apache/harmony/kernel/dalvik/ThreadsTest.java
@@ -28,8 +28,6 @@ import sun.misc.Unsafe;
  */
 public class ThreadsTest extends TestCase {
     private static Unsafe UNSAFE = null;
-    private static RuntimeException INITIALIZEFAILED = null;
-
     static {
         /*
          * Set up {@link #UNSAFE}. This subverts the access check to
@@ -43,14 +41,14 @@ public class ThreadsTest extends TestCase {
 
             UNSAFE = (Unsafe) field.get(null);
         } catch (NoSuchFieldException ex) {
-            INITIALIZEFAILED = new RuntimeException(ex);
+            throw new RuntimeException(ex);
         } catch (IllegalAccessException ex) {
-            INITIALIZEFAILED = new RuntimeException(ex);
+            throw new RuntimeException(ex);
         }
     }
 
     /** Test the case where the park times out. */
-    public void test_parkFor_1() {
+    public void test_parkFor_1() throws Exception {
         CyclicBarrier barrier = new CyclicBarrier(2);
         Parker parker = new Parker(barrier, false, 500);
         Thread parkerThread = new Thread(parker);
@@ -60,10 +58,12 @@ public class ThreadsTest extends TestCase {
         parkerThread.start();
         waiterThread.start();
         parker.assertDurationIsInRange(500);
+        waiterThread.join();
+        parkerThread.join();
     }
 
     /** Test the case where the unpark happens before the timeout. */
-    public void test_parkFor_2() {
+    public void test_parkFor_2() throws Exception {
         CyclicBarrier barrier = new CyclicBarrier(2);
         Parker parker = new Parker(barrier, false, 1000);
         Thread parkerThread = new Thread(parker);
@@ -73,10 +73,12 @@ public class ThreadsTest extends TestCase {
         parkerThread.start();
         waiterThread.start();
         parker.assertDurationIsInRange(300);
+        waiterThread.join();
+        parkerThread.join();
     }
 
     /** Test the case where the thread is preemptively unparked. */
-    public void test_parkFor_3() {
+    public void test_parkFor_3() throws Exception {
         CyclicBarrier barrier = new CyclicBarrier(1);
         Parker parker = new Parker(barrier, false, 1000);
         Thread parkerThread = new Thread(parker);
@@ -84,10 +86,11 @@ public class ThreadsTest extends TestCase {
         UNSAFE.unpark(parkerThread);
         parkerThread.start();
         parker.assertDurationIsInRange(0);
+        parkerThread.join();
     }
 
     /** Test the case where the park times out. */
-    public void test_parkUntil_1() {
+    public void test_parkUntil_1() throws Exception {
         CyclicBarrier barrier = new CyclicBarrier(2);
         Parker parker = new Parker(barrier, true, 500);
         Thread parkerThread = new Thread(parker);
@@ -97,10 +100,12 @@ public class ThreadsTest extends TestCase {
         parkerThread.start();
         waiterThread.start();
         parker.assertDurationIsInRange(500);
+        waiterThread.join();
+        parkerThread.join();
     }
 
     /** Test the case where the unpark happens before the timeout. */
-    public void test_parkUntil_2() {
+    public void test_parkUntil_2() throws Exception {
         CyclicBarrier barrier = new CyclicBarrier(2);
         Parker parker = new Parker(barrier, true, 1000);
         Thread parkerThread = new Thread(parker);
@@ -110,10 +115,12 @@ public class ThreadsTest extends TestCase {
         parkerThread.start();
         waiterThread.start();
         parker.assertDurationIsInRange(300);
+        waiterThread.join();
+        parkerThread.join();
     }
 
     /** Test the case where the thread is preemptively unparked. */
-    public void test_parkUntil_3() {
+    public void test_parkUntil_3() throws Exception {
         CyclicBarrier barrier = new CyclicBarrier(1);
         Parker parker = new Parker(barrier, true, 1000);
         Thread parkerThread = new Thread(parker);
@@ -121,6 +128,7 @@ public class ThreadsTest extends TestCase {
         UNSAFE.unpark(parkerThread);
         parkerThread.start();
         parker.assertDurationIsInRange(0);
+        parkerThread.join();
     }
 
     // TODO: Add more tests.
@@ -234,10 +242,12 @@ public class ThreadsTest extends TestCase {
 
             if (duration < minimum) {
                 Assert.fail("expected duration: " + expectedMillis +
-                        "; actual too short: " + duration);
+                            " minimum duration: " + minimum +
+                            " actual duration too short: " + duration);
             } else if (duration > maximum) {
                 Assert.fail("expected duration: " + expectedMillis +
-                        "; actual too long: " + duration);
+                            " maximum duration: " + maximum +
+                            " actual duration too long: " + duration);
             }
         }
     }
@@ -272,11 +282,4 @@ public class ThreadsTest extends TestCase {
             UNSAFE.unpark(thread);
         }
     }
-
-    @Override
-    protected void setUp() throws Exception {
-        if (INITIALIZEFAILED != null) {
-            throw INITIALIZEFAILED;
-        }
-    }
 }
-- 
cgit v1.1


From eef7e9357c272a9154f007e8bee2a09eed66d101 Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Wed, 31 Oct 2012 22:39:03 -0700
Subject: Test to verify BC Signature algorithms by OID

Bug: 7453821
Change-Id: I69408d0bb4063e34441ed1d7632fd1ccac39965b
---
 .../harmony/xnet/provider/jsse/OpenSSLProvider.java   | 11 +++++------
 .../java/libcore/java/security/SignatureTest.java     | 19 +++++++++++++++++++
 .../java/libcore/java/security/StandardNames.java     |  4 ----
 3 files changed, 24 insertions(+), 10 deletions(-)

diff --git a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLProvider.java b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLProvider.java
index fd9be17..d4aa57f 100644
--- a/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLProvider.java
+++ b/luni/src/main/java/org/apache/harmony/xnet/provider/jsse/OpenSSLProvider.java
@@ -73,12 +73,11 @@ public final class OpenSSLProvider extends Provider {
         // put("KeyFactory.DSA", OpenSSLDSAKeyFactory.class.getName());
 
         // Signatures
-        put("Signature.MD5WithRSAEncryption", OpenSSLSignature.MD5RSA.class.getName());
-        put("Alg.Alias.Signature.MD5WithRSA", "MD5WithRSAEncryption");
-        put("Alg.Alias.Signature.MD5/RSA", "MD5WithRSAEncryption");
-        put("Alg.Alias.Signature.1.2.840.113549.1.1.4", "MD5WithRSAEncryption");
-        put("Alg.Alias.Signature.1.2.840.113549.2.5with1.2.840.113549.1.1.1",
-                "MD5WithRSAEncryption");
+        put("Signature.MD5WithRSA", OpenSSLSignature.MD5RSA.class.getName());
+        put("Alg.Alias.Signature.MD5WithRSAEncryption", "MD5WithRSA");
+        put("Alg.Alias.Signature.MD5/RSA", "MD5WithRSA");
+        put("Alg.Alias.Signature.1.2.840.113549.1.1.4", "MD5WithRSA");
+        put("Alg.Alias.Signature.1.2.840.113549.2.5with1.2.840.113549.1.1.1", "MD5WithRSA");
 
         put("Signature.SHA1WithRSA", OpenSSLSignature.SHA1RSA.class.getName());
         put("Alg.Alias.Signature.SHA1WithRSA", "SHA1WithRSA");
diff --git a/luni/src/test/java/libcore/java/security/SignatureTest.java b/luni/src/test/java/libcore/java/security/SignatureTest.java
index 92b5513..63daa88 100644
--- a/luni/src/test/java/libcore/java/security/SignatureTest.java
+++ b/luni/src/test/java/libcore/java/security/SignatureTest.java
@@ -1253,4 +1253,23 @@ public class SignatureTest extends TestCase {
         sig.update(Vector2Data);
         assertTrue("Signature must verify correctly", sig.verify(SHA1withDSA_Vector2Signature));
     }
+
+    // NetscapeCertRequest looks up Signature algorithms by OID from
+    // BC but BC version 1.47 had registration bugs and MD5withRSA was
+    // overlooked.  http://b/7453821
+    public void testGetInstanceFromOID() throws Exception {
+        assertBouncyCastleSignatureFromOID("1.2.840.113549.1.1.4");  // MD5withRSA
+        assertBouncyCastleSignatureFromOID("1.2.840.113549.1.1.5");  // SHA1withRSA
+        assertBouncyCastleSignatureFromOID("1.3.14.3.2.29");         // SHA1withRSA
+        assertBouncyCastleSignatureFromOID("1.2.840.113549.1.1.11"); // SHA256withRSA
+        assertBouncyCastleSignatureFromOID("1.2.840.113549.1.1.12"); // SHA384withRSA
+        assertBouncyCastleSignatureFromOID("1.2.840.113549.1.1.13"); // SHA512withRSA
+        assertBouncyCastleSignatureFromOID("1.2.840.10040.4.3");     // SHA1withDSA
+    }
+
+    private void assertBouncyCastleSignatureFromOID(String oid) throws Exception {
+        Signature signature = Signature.getInstance(oid, "BC");
+        assertNotNull(oid, signature);
+        assertEquals(oid, signature.getAlgorithm());
+    }
 }
diff --git a/support/src/test/java/libcore/java/security/StandardNames.java b/support/src/test/java/libcore/java/security/StandardNames.java
index 4211a10..be880d3 100644
--- a/support/src/test/java/libcore/java/security/StandardNames.java
+++ b/support/src/test/java/libcore/java/security/StandardNames.java
@@ -348,10 +348,6 @@ public final class StandardNames extends Assert {
             unprovide("MessageDigest", "SHA");
             provide("MessageDigest", "SHA-1");
 
-            // different names: added "Encryption" suffix
-            unprovide("Signature", "MD5withRSA");
-            provide("Signature", "MD5WithRSAEncryption");
-
             // Added to support Android KeyStore operations
             provide("Signature", "NONEwithRSA");
             provide("Cipher", "RSA/ECB/NOPADDING");
-- 
cgit v1.1


From 85c4f329001b9837f4ad9e6ef9fdf68c2d1eb6bd Mon Sep 17 00:00:00 2001
From: Brian Carlstrom <bdc@google.com>
Date: Thu, 1 Nov 2012 20:50:22 -0700
Subject: Bump ThreadsTest tolerance from 5% to 10%

Bug: 7378963
Change-Id: I45fb1350baaf591e59b78bb3cf97091667cb079c
---
 .../tests/api/org/apache/harmony/kernel/dalvik/ThreadsTest.java     | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/luni/src/test/java/tests/api/org/apache/harmony/kernel/dalvik/ThreadsTest.java b/luni/src/test/java/tests/api/org/apache/harmony/kernel/dalvik/ThreadsTest.java
index 5185885..19c6229 100644
--- a/luni/src/test/java/tests/api/org/apache/harmony/kernel/dalvik/ThreadsTest.java
+++ b/luni/src/test/java/tests/api/org/apache/harmony/kernel/dalvik/ThreadsTest.java
@@ -224,7 +224,7 @@ public class ThreadsTest extends TestCase {
         }
 
         /**
-         * Asserts that the actual duration is within 5% of the
+         * Asserts that the actual duration is within 10% of the
          * given expected time.
          *
          * @param expectedMillis the expected duration, in milliseconds
@@ -234,9 +234,9 @@ public class ThreadsTest extends TestCase {
              * Allow a bit more slop for the maximum on "expected
              * instantaneous" results.
              */
-            long minimum = (long) ((double) expectedMillis * 0.95);
+            long minimum = (long) ((double) expectedMillis * 0.90);
             long maximum =
-                Math.max((long) ((double) expectedMillis * 1.05), 10);
+                Math.max((long) ((double) expectedMillis * 1.10), 10);
             long waitMillis = Math.max(expectedMillis * 10, 10);
             long duration = getDurationMillis(waitMillis);
 
-- 
cgit v1.1